Beispiel #1
0
        public static void Merge_RP_PQ_PP()
        {
            db_racing_update =
                new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());
            db_racing_read = new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());

            while (db_racing_update.Horses.Where(x => x.PPMatchBasis == "Pending RP_PQ").Any())
            {
                foreach (
                    Horse rp_horse in
                    db_racing_update.Horses.Where(x => x.PPMatchBasis == "Pending RP_PQ")
                    .OrderBy(x => x.Id)
                    .ThenBy(x => x.Name)
                    .Take(500))
                {
                    rp_horse.PPId         = null;
                    rp_horse.PPMatchBasis = "Failed RP_PQ_PP";

                    Logger.WriteLog("Merging RP/PQ to PP " + rp_horse.Name + " " + rp_horse.Id);

                    PQ_Horse pq_horse = db_racing_update.PQ_Horses.Where(x => x.Id == rp_horse.PQId).FirstOrDefault();
                    if (pq_horse != null)
                    {
                        if (pq_horse.MergeId != null)
                        {
                            Horse_Merged merge_horse =
                                db_racing_update.Horse_Mergeds.Where(x => x.PPId == pq_horse.MergeId).FirstOrDefault();
                            if (merge_horse != null)
                            {
                                merge_horse.RHId = rp_horse.Id;
                                merge_horse.Name = rp_horse.Name;
                                if (merge_horse.Country == null)
                                {
                                    merge_horse.Country = rp_horse.Country;
                                }
                                if (merge_horse.FoalDate == null)
                                {
                                    merge_horse.FoalDate = rp_horse.FoalDate;
                                }
                                if (merge_horse.FoalYear == null)
                                {
                                    merge_horse.FoalYear = rp_horse.FoalYear;
                                }
                                merge_horse.MergeBasis = "RP-PQ Matched";
                            }
                            rp_horse.PPId         = pq_horse.MergeId;
                            rp_horse.PPMatchBasis = "PQ Direct";
                        }

                        else if (Merge_RP_PQ_Merge(pq_horse, 1, rp_horse.Id) != null)
                        {
                            rp_horse.PPId         = pq_horse.MergeId;
                            rp_horse.PPMatchBasis = "PQ Added";
                        }
                    }

                    db_racing_update.SubmitChanges();
                }

                db_racing_update =
                    new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());
            }
        }
Beispiel #2
0
        private static int?Merge_RP_PQ_Merge(PQ_Horse pq_horse, int gen, int rh_id)
        {
            int?merge_sire_id = null;
            int?merge_dam_id  = null;

            PQ_Horse pq_sire = db_racing_read.PQ_Horses.Where(x => x.Id == pq_horse.SireId).FirstOrDefault();

            if (pq_sire == null)
            {
                return(null);
            }
            else
            {
                if (pq_sire.MergeId != null)
                {
                    merge_sire_id = pq_sire.MergeId;
                }
                else
                {
                    merge_sire_id = Merge_RP_PQ_Merge(pq_sire, gen + 1, 0);
                    if (merge_sire_id == null)
                    {
                        return(null);
                    }
                }
            }

            PQ_Horse pq_dam = db_racing_read.PQ_Horses.Where(x => x.Id == pq_horse.DamId).FirstOrDefault();

            if (pq_dam == null)
            {
                return(null);
            }
            else
            {
                if (pq_dam.MergeId != null)
                {
                    merge_dam_id = pq_dam.MergeId;
                }
                else
                {
                    merge_dam_id = Merge_RP_PQ_Merge(pq_dam, gen + 1, 0);
                    if (merge_dam_id == null)
                    {
                        return(null);
                    }
                }
            }

            var merge_horse = new Horse_Merged();

            db_racing_update.Horse_Mergeds.InsertOnSubmit(merge_horse);

            if (rh_id != 0)
            {
                merge_horse.RHId = rh_id;
            }

            CultureInfo cult_info = Thread.CurrentThread.CurrentCulture;
            TextInfo    text_info = cult_info.TextInfo;

            merge_horse.Name    = text_info.ToTitleCase(pq_horse.Name.ToLower());
            merge_horse.Country = pq_horse.Country;
            if (pq_horse.FoalYear != null)
            {
                merge_horse.FoalDate = new DateTime((int)pq_horse.FoalYear, 1, 1);
                merge_horse.FoalYear = pq_horse.FoalYear;
            }
            merge_horse.Colour = pq_horse.Colour;
            merge_horse.Sex    = pq_horse.Sex;
            merge_horse.SireId = merge_sire_id;
            merge_horse.DamId  = merge_dam_id;
            merge_horse.Haplo  =
                db_racing_read.Horse_Mergeds.Where(x => x.Id == merge_dam_id).Select(x => x.Haplo).FirstOrDefault();
            merge_horse.MergeBasis = "RP-PQ Added";

            db_racing_update.SubmitChanges();

            pq_horse.MergeId         = merge_horse.Id;
            pq_horse.MergeMatchBasis = "Added";

            return(merge_horse.Id);
        }
Beispiel #3
0
        public static void Add_RP_Merge()
        {
            db_racing_update =
                new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());
            db_racing_read = new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());

            db_racing_read.CommandTimeout = 180;

            while (db_racing_read.RP_Match_By_Parents.Any())
            {
                List <RP_Match_By_Parent> view_recs = db_racing_read.RP_Match_By_Parents.Take(500).ToList();
                foreach (RP_Match_By_Parent view_rec in view_recs)
                {
                    Logger.WriteLog("Attempting RP Merge for " + view_rec.Name + " " + view_rec.Id);

                    Horse rp_horse = db_racing_update.Horses.Where(x => x.Id == view_rec.Id).FirstOrDefault();
                    if (rp_horse == null)
                    {
                        continue;
                    }

                    rp_horse.PPMatchBasis = "Failed";

                    if (rp_horse.FoalYear == null || view_rec.SireFoalYear == null || view_rec.DamFoalYear == null)
                    {
                        db_racing_update.SubmitChanges();
                        continue;
                    }

                    int sire_diff = (int)rp_horse.FoalYear - (int)view_rec.SireFoalYear;
                    if (sire_diff < 3 || sire_diff > 25)
                    {
                        db_racing_update.SubmitChanges();
                        continue;
                    }

                    int dam_diff = (int)rp_horse.FoalYear - (int)view_rec.DamFoalYear;
                    if (dam_diff < 3 || dam_diff > 25)
                    {
                        db_racing_update.SubmitChanges();
                        continue;
                    }

                    var merge_horse = new Horse_Merged();
                    db_racing_update.Horse_Mergeds.InsertOnSubmit(merge_horse);

                    merge_horse.RHId = rp_horse.Id;

                    merge_horse.Name     = rp_horse.Name;
                    merge_horse.Country  = rp_horse.Country;
                    merge_horse.FoalDate = rp_horse.FoalDate;
                    merge_horse.FoalYear = rp_horse.FoalYear;
                    merge_horse.Colour   = rp_horse.Colour;

                    if (rp_horse.Sex != null)
                    {
                        switch (rp_horse.Sex)
                        {
                        case "f":
                        case "m":
                            merge_horse.Sex = "f";
                            break;

                        case "c":
                        case "h":
                            merge_horse.Sex = "c";
                            break;

                        case "g":
                            merge_horse.Sex = "g";
                            break;

                        case "r":
                            merge_horse.Sex = "r";
                            break;
                        }
                    }

                    merge_horse.SireId = view_rec.SireId;
                    merge_horse.DamId  = view_rec.DamId;
                    merge_horse.Haplo  =
                        db_racing_read.Horse_Mergeds.Where(x => x.Id == merge_horse.DamId)
                        .Select(x => x.Haplo)
                        .FirstOrDefault();
                    merge_horse.MergeBasis = "RP Added";

                    db_racing_update.SubmitChanges();

                    rp_horse.PPId         = merge_horse.Id;
                    rp_horse.PPMatchBasis = "RP Added";

                    db_racing_update.SubmitChanges();
                }
                db_racing_update =
                    new RacingPostRacesDataContext(ConfigurationManager.ConnectionStrings["Racing"].ToString());
            }

            string cmd = "UPDATE Horse SET PPMatchBasis = 'Failed' WHERE PPMatchBasis = 'Failed RP_PQ_PP'";

            db_racing_update.ExecuteCommand(cmd);
        }