public ActionResult CalculateDistances(int id)
{
RaceDetails details = _raceRepository.GetRaceDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null || details.Detail.EntityStateId != Dom.EntityType.Race.State.Open)
{
return(NotFoundResult());
}
Race race = _raceRepository.Get <Race>(id);
race.RaceDistances.ToList().ForEach(x => _raceRepository.Delete(x));
var members = race.RacePigeons.Select(m => m.Pigeon.Member).Distinct().ToList();
foreach (var member in members)
{
race.RaceDistances.Add(new RaceDistance
{
Distance = member.Address?.Latitude == null
? 0
: CoordinatesManager.CalculateDistance(member.Address.Latitude, member.Address.Longitude,
race.Point.Address.Latitude, race.Point.Address.Longitude),
MemberId = member.Id
});
}
_raceRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(Mvc.Controller.Race.Details, Mvc.Controller.Race.Name, new { id }));
}
private Dictionary <Distance, List <RaceDetails> > ModifyValue(Dictionary <Distance, List <RaceDetails> > value, int level)
{
if (value == null)
{
value = new Dictionary <Distance, List <RaceDetails> >();
}
if (++level > 4)
{
return(value);
}
var details = new RaceDetails();
InitializeInstance(details);
value[Distance.foo] = new List <RaceDetails>()
{
details
};
if (value.TryGetValue(Distance.bar, out var list) && (list.Count > 0))
{
ModifyInstance(list[0], level);
list.Add(null);
}
value[Distance.baz] = null;
return(value);
}
private void CheckInstance(RaceDetails instance)
{
// object
Assert.IsTrue(instance.__isset.def_nested);
Assert.IsTrue(instance.__isset.opt_nested);
Assert.IsNull(instance.Def_nested);
Assert.IsNull(instance.Opt_nested);
// string
Assert.IsTrue(instance.__isset.def_four);
Assert.IsTrue(instance.__isset.opt_four);
Assert.IsNull(instance.Req_four);
Assert.IsNull(instance.Def_four);
Assert.IsNull(instance.Opt_four);
// byte[]
Assert.IsTrue(instance.__isset.def_five);
Assert.IsTrue(instance.__isset.opt_five);
Assert.IsNull(instance.Req_five);
Assert.IsNull(instance.Def_five);
Assert.IsNull(instance.Opt_five);
// list<>
Assert.IsTrue(instance.__isset.def_six);
Assert.IsTrue(instance.__isset.opt_six);
Assert.IsNull(instance.Req_six);
Assert.IsNull(instance.Opt_six);
Assert.IsNull(instance.Def_six);
}
private static void CheckInstance(RaceDetails instance)
{
// object
Assert.IsTrue(instance.__isset.def_nested);
Assert.IsTrue(instance.__isset.opt_nested);
Assert.IsNull(instance.Def_nested);
Assert.IsNull(instance.Opt_nested);
// string
Assert.IsTrue(instance.__isset.def_four);
Assert.IsTrue(instance.__isset.opt_four);
Assert.IsTrue(string.IsNullOrEmpty(instance.Req_four));
Assert.IsNull(instance.Def_four);
Assert.IsNull(instance.Opt_four);
// byte[]
Assert.IsTrue(instance.__isset.def_five);
Assert.IsTrue(instance.__isset.opt_five);
Assert.IsTrue((instance.Req_five == null) || (instance.Req_five.Length == 0));
Assert.IsNull(instance.Def_five);
Assert.IsNull(instance.Opt_five);
// list<>
Assert.IsTrue(instance.__isset.def_six);
Assert.IsTrue(instance.__isset.opt_six);
Assert.IsNull(instance.Req_six);
Assert.IsNull(instance.Opt_six);
Assert.IsNull(instance.Def_six);
}
public ActionResult ListTargets()
{
//
ClassLibrary1.Model1 db = new ClassLibrary1.Model1();
var AllRunners = db.memberLists;
var targetdistanceMeters = Convert.ToDouble(TempData["targetdistance"]);
var targetdistanceName = RaceDetails.GetByRaceNameByMeters(targetdistanceMeters);
IEnumerable <ClubMemberListItemVM> vm = ClubMemberListItemVM.buildVM(AllRunners);
return(View(vm));
}
private RaceDetails MakeNestedRaceDetails(int nesting)
{
if (++nesting > 1)
{
return(null);
}
var instance = new RaceDetails();
InitializeInstance(instance, nesting);
return(instance);
}
private jack MakeNestedUnion(int nesting)
{
if (++nesting > 1)
{
return(null);
}
var details = new RaceDetails();
InitializeInstance(details, nesting);
return(new jack.nested_struct(details));
}
private RaceDetails ModifyValue(RaceDetails value, int level)
{
if (++level > 4)
{
return(value);
}
if (value == null)
{
value = new RaceDetails();
}
ModifyInstance(value, level);
return(value);
}
public ActionResult Details(int id)
{
RaceDetails details = _raceRepository.GetRaceDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null)
{
return(NotFoundResult());
}
RaceDetailsViewModel viewModel = Mapper.Map <RaceDetailsViewModel>(details);
InitDetailsViewModel(viewModel, details);
return(View(Mvc.View.Race.Details, viewModel));
}
private async Task UpdateRacesAsync(string jobType, int id)
{
RaceDetails race = new RaceDetails();
race = await _scrapDataService.ScrapGenericObject <RaceDetails>(id, jobType);
//if the race is from 2018
if (race != null)
{
if (race.RaceDate.Year == 2018)
{
lock (((ICollection)Races).SyncRoot)
{
Races.Add(race);
}
}
}
}
private void InitDetailsViewModel(RaceDetailsViewModel viewModel, RaceDetails details)
{
InitBaseDetailViewModel(details.Detail, viewModel.Detail);
InitBaseDetailEntityStateChange(viewModel.Detail);
if (details.Detail.EntityStateId == Dom.EntityType.Race.State.Open &&
details.Detail.StartRaceTime != null &&
details.Detail.DarknessBeginTime != null &&
details.Detail.DarknessEndTime != null &&
details.Detail.HasCalculatedDistances &&
details.StatementPigeonIds != null && details.StatementPigeonIds.Any() &&
details.Detail.ReturnPigeonCount * 1.0 / details.StatementPigeonIds.Count >= 0.2
)
{
viewModel.CanCalculateResults = true;
}
viewModel.Detail.RaceTypeName = GetRaceTypeName(viewModel.Detail.RaceTypeId);
viewModel.Detail.SeasonTypeName = GetSeasonTypeName(viewModel.Detail.SeasonTypeId);
viewModel.Detail.SeasonName = $"{viewModel.Detail.SeasonTypeName}-{viewModel.Detail.Year}";
ViewData[Mvc.ViewData.Controller] = Mvc.Controller.Race.Name;
}
public RaceDetails SplitRaceNodeString(string jobType, string stringNode, string propertyName)
{
RaceDetails race = new RaceDetails();
string date = SplitDate(jobType, stringNode);
string distance = SplitDistance(jobType, stringNode);
string horseName = SplitName(jobType, stringNode, typeof(LoadedHorse), propertyName);
string place = SplitPlace(jobType, stringNode);
string competitors = SplitCompetitors(jobType, stringNode);
string category = SplitCategory(jobType, stringNode);
string racersLink = SplitRacersLink(jobType, stringNode);
string racersName = SplitRacersName(jobType, stringNode);
return(race = ParseRaceData(date,
distance,
horseName,
place,
competitors,
category,
racersLink,
racersName));
}
public ActionResult Edit(int id)
{
RaceDetails details = _raceRepository.GetRaceDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null || details.Detail?.EntityStateId != Dom.EntityType.Race.State.Open)
{
return(NotFoundResult());
}
RaceDetailsViewModel viewModel = Mapper.Map <RaceDetailsViewModel>(details);
var points = _pointRepository.GetPoints(UserContext.User.Id, UserContext.User.OrganizationId, viewModel.Detail.OrganizationId);
viewModel.Detail.PointItems = Mapper.Map <ICollection <SelectListItem> >(points);
foreach (var pigeon in details.Pigeons)
{
pigeon.Ring = Format.FormattedRing(pigeon.Year, pigeon.Code, pigeon.Number);
pigeon.InStatement = details.StatementPigeonIds.Contains(pigeon.Id);
}
viewModel.StatementIds = details.StatementPigeonIds.ToList();
viewModel.StatementItems = new Dictionary <string, ICollection <SelectListItem> >();
foreach (var member in details.Members)
{
viewModel.StatementItems.Add(
Format.FormattedInitials(member.LastName, member.FirstName, member.MiddleName) + $" (#{member.Id})",
details.Pigeons
.Where(m => m.MemberId == member.Id)
.Select(g => new SelectListItem
{
Value = g.Id.ToString(),
Text = g.Ring,
Selected = g.InStatement
}).ToList()
);
}
return(View(Mvc.View.Race.Edit, viewModel));
}
private static void AddResult(ExcelWorksheet workSheet, int row, int col, int runnerId, Model1 db)
{
// var d = RaceDetails.GetMetersByName(workSheet.Cells[row, col].Value.ToString());
var d = RaceDetails.GetMetersByCode(workSheet.Cells[row, col].Value.ToString());
var distance = workSheet.Cells[row, col].Value;
var time = workSheet.Cells[row, col + 1].Value.ToString();
string output = new string(time.Where(c => (Char.IsDigit(c) || c == '.' || c == ':')).ToArray());
string SubString = output.Substring(output.Length - 8);
TimeSpan ts = TimeSpan.Parse(SubString);
double totalSeconds = ts.TotalSeconds;
int seconds = Convert.ToInt32(totalSeconds);
ClassLibrary1.race Arace = new race();
Arace.runner = runnerId;
Arace.distance = d;
Arace.time = seconds;
db.races.Add(Arace);
db.SaveChanges();
}
private void ModifyInstance(RaceDetails instance, int level)
{
if ((instance == null) || (++level > 4))
{
return;
}
instance.Opt_one = ModifyValue(instance.Opt_one);
instance.Opt_two = ModifyValue(instance.Opt_two);
instance.Opt_three = ModifyValue(instance.Opt_three);
instance.Opt_four = ModifyValue(instance.Opt_four);
instance.Opt_five = ModifyValue(instance.Opt_five);
instance.Opt_six = ModifyValue(instance.Opt_six);
instance.Opt_seven = ModifyValue(instance.Opt_seven);
instance.Opt_eight = ModifyValue(instance.Opt_eight);
instance.Req_one = ModifyValue(instance.Req_one);
instance.Req_two = ModifyValue(instance.Req_two);
instance.Req_three = ModifyValue(instance.Req_three);
instance.Req_four = ModifyValue(instance.Req_four);
instance.Req_five = ModifyValue(instance.Req_five);
instance.Req_six = ModifyValue(instance.Req_six);
instance.Req_seven = ModifyValue(instance.Req_seven);
instance.Req_eight = ModifyValue(instance.Req_eight);
instance.Def_one = ModifyValue(instance.Def_one);
instance.Def_two = ModifyValue(instance.Def_two);
instance.Def_three = ModifyValue(instance.Def_three);
instance.Def_four = ModifyValue(instance.Def_four);
instance.Def_five = ModifyValue(instance.Def_five);
instance.Def_six = ModifyValue(instance.Def_six);
instance.Def_seven = ModifyValue(instance.Def_seven);
instance.Def_eight = ModifyValue(instance.Def_eight);
instance.Opt_one_with_value = ModifyValue(instance.Opt_one_with_value);
instance.Opt_two_with_value = ModifyValue(instance.Opt_two_with_value);
instance.Opt_three_with_value = ModifyValue(instance.Opt_three_with_value);
instance.Opt_four_with_value = ModifyValue(instance.Opt_four_with_value);
instance.Opt_five_with_value = ModifyValue(instance.Opt_five_with_value);
instance.Opt_six_with_value = ModifyValue(instance.Opt_six_with_value);
instance.Opt_seven_with_value = ModifyValue(instance.Opt_seven_with_value);
instance.Opt_eight_with_value = ModifyValue(instance.Opt_eight_with_value);
instance.Req_one_with_value = ModifyValue(instance.Req_one_with_value);
instance.Req_two_with_value = ModifyValue(instance.Req_two_with_value);
instance.Req_three_with_value = ModifyValue(instance.Req_three_with_value);
instance.Req_four_with_value = ModifyValue(instance.Req_four_with_value);
instance.Req_five_with_value = ModifyValue(instance.Req_five_with_value);
instance.Req_six_with_value = ModifyValue(instance.Req_six_with_value);
instance.Req_seven_with_value = ModifyValue(instance.Req_seven_with_value);
instance.Req_eight_with_value = ModifyValue(instance.Req_eight_with_value);
instance.Def_one_with_value = ModifyValue(instance.Def_one_with_value);
instance.Def_two_with_value = ModifyValue(instance.Def_two_with_value);
instance.Def_three_with_value = ModifyValue(instance.Def_three_with_value);
instance.Def_four_with_value = ModifyValue(instance.Def_four_with_value);
instance.Def_five_with_value = ModifyValue(instance.Def_five_with_value);
instance.Def_six_with_value = ModifyValue(instance.Def_six_with_value);
instance.Def_seven_with_value = ModifyValue(instance.Def_seven_with_value);
instance.Def_eight_with_value = ModifyValue(instance.Def_eight_with_value);
instance.Last_of_the_mohicans = ModifyValue(instance.Last_of_the_mohicans);
instance.Far_list = ModifyValue(instance.Far_list);
instance.Far_set = ModifyValue(instance.Far_set);
instance.Far_map = ModifyValue(instance.Far_map);
instance.Far_set_list = ModifyValue(instance.Far_set_list);
instance.Far_list_map_set = ModifyValue(instance.Far_list_map_set);
instance.Far_map_dist_to_rds = ModifyValue(instance.Far_map_dist_to_rds, level);
instance.Req_nested = ModifyValue(instance.Req_nested, level);
instance.Opt_nested = ModifyValue(instance.Opt_nested, level);
instance.Def_nested = ModifyValue(instance.Def_nested, level);
instance.Req_union = ModifyValue(instance.Req_union, level);
instance.Opt_union = ModifyValue(instance.Opt_union, level);
instance.Def_union = ModifyValue(instance.Def_union, level);
instance.Triplesix = ModifyValue(instance.Triplesix);
}
public RaceDetails ParseRaceData(string raceDate,
string raceDistance,
string horsesName,
string racePlace,
string raceCompetitors,
string raceCategory,
string racersLink,
string racersName)
{
RaceDetails race = new RaceDetails();
int n;
bool parseTest;
DateTime t;
parseTest = int.TryParse(raceDistance, out n);
if (parseTest)
{
race.RaceDistance = int.Parse(raceDistance); //race distance
}
else
{
race.RaceDistance = 2000; //race distance
}
parseTest = int.TryParse(raceCompetitors, out n);
if (parseTest)
{
race.RaceCompetition = int.Parse(raceCompetitors); //race qty of horses
}
else
{
race.RaceCompetition = 10; //race qty of horses
}
if (racePlace != "0" && racePlace != "D" && racePlace != "PN" && racePlace != "Z" && racePlace != "ZN" && racePlace != "SN")
{
parseTest = int.TryParse(racePlace, out n);
if (parseTest)
{
race.WonPlace = int.Parse(racePlace); //won place
}
else
{
if (racePlace == "N/A")
{
race.WonPlace = 0;
}
else
{
race.WonPlace = race.RaceCompetition; //won place
}
}
}
else
{
race.WonPlace = race.RaceCompetition;
}
parseTest = DateTime.TryParse(raceDate, out t);
if (parseTest)
{
race.RaceDate = DateTime.Parse(raceDate); //day of race
}
else
{
race.RaceDate = _dateToday; //day of race
}
if (!string.IsNullOrEmpty(horsesName))
{
race.HorseName = horsesName; //rided horse
}
else
{
race.HorseName = "-"; //rided horse
}
if (raceCategory.Contains("Grupa"))
{
raceCategory = raceCategory.Replace("Grupa ", "");
race.RaceCategory = raceCategory; // category name
}
else
{
race.RaceCategory = raceCategory; // category name
}
if (!string.IsNullOrEmpty(racersLink))
{
race.RacersLink = racersLink; //link tho the racer
}
else
{
race.RaceLink = "-";
}
if (!string.IsNullOrEmpty(racersName))
{
race.RacersName = racersName; //name of the racer
}
else
{
race.RaceLink = "-";
}
return(race);
}
private void reloadUI(string root)
{
currentRoot = root;
mods.Clear();
modZips.Clear();
lstRaces.Items.Clear();
lstMods.Items.Clear();
llToxicRagers.Text = tagLines[new Random().Next(tagLines.Count)];
txtPath.Text = root;
btnInstall.Text = "select a mod and a map to replace, then click here!";
btnInstall.Enabled = false;
string twtFile = Path.Combine(txtPath.Text, "data.twt");
if (File.Exists(twtFile))
{
TWT twt = TWT.Load(twtFile);
foreach (TWTEntry entry in twt.Contents)
{
twt.Extract(entry, Path.Combine(txtPath.Text, "data"));
}
File.Move(twtFile, Path.Combine(txtPath.Text, "data.twat"));
}
string racesTXT = Path.Combine(txtPath.Text, "data", "races.txt");
if (File.Exists(racesTXT))
{
races = RacesTXT.Load(Path.Combine(txtPath.Text, "data", "races.txt"));
foreach (RaceDetails race in races.Races)
{
if (!race.BoundaryRace)
{
lstRaces.Items.Add(race.Name);
}
}
}
string mapModDir = Path.Combine(txtPath.Text, ".mods", "maps");
if (Directory.Exists(mapModDir))
{
foreach (string file in Directory.GetFiles(mapModDir, "*.zip"))
{
using (FileStream fs = new FileStream(file, FileMode.Open))
using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Read))
{
if (archive.Entries.Any(f => f.Name.EndsWith(".c2t", StringComparison.InvariantCultureIgnoreCase)) &&
archive.Entries.Any(f => f.Name == "" && f.FullName.ToLower() == @"data/races/"))
{
ZipArchiveEntry entry = archive.Entries.First(f => f.Name.EndsWith(".c2t", StringComparison.InvariantCultureIgnoreCase));
using (MemoryStream ms = new MemoryStream())
using (BinaryReader br = new BinaryReader(ms))
{
entry.Open().CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
RaceDetails details = RaceDetails.Load(new DocumentParser(br));
int index = lstMods.Items.Add(details.Name);
modZips.Add(index, file);
mods.Add(details);
}
}
}
}
}
foreach (string file in Directory.GetFiles(txtPath.Text, "*.c2t"))
{
RaceDetails details = RaceDetails.Load(new DocumentParser(file));
if (!mods.Any(m => m.Name == details.Name))
{
lstMods.Items.Add(details.Name);
mods.Add(details);
}
}
}
public ActionResult Details(int id, RaceListService.Models.memberDetailVM rxvm)
{
try
{
var valid = (bool)Session["login"];
if (!valid)
{
return(RedirectToAction("Index", "Default"));
}
}
catch
{
return(RedirectToAction("Index", "Default"));
}
// get runner
var ThisRunner = db.memberLists.Find(id);
ViewBag.Title = "Cup Times";
var targetDistance = TempData["targetdistance"];
// create vm
memberDetailVM vm = new memberDetailVM();
// give vm runner name
vm.Name = ThisRunner.Name;
vm.currentTarget = RaceTimesVM.formatResult(ThisRunner.Time);
// get ALL thier races
IEnumerable <ClassLibrary1.race> listofraces = ThisRunner.races;
// create an empty list to display and populate with details
vm.listOfRaces = new List <RaceTimesVM>();
vm.listOfRaces = memberDetailVM.buildList(listofraces, Convert.ToDouble(targetDistance));
List <RaceTimesVM> copy = new List <RaceTimesVM>();
copy.AddRange(vm.listOfRaces);
vm.simpleAverage = memberDetailVM.CalcSimpleAve(vm.listOfRaces);
vm.listOfRaces = copy.OrderBy(r => r.predictedTime).ToList();
vm.SelectedRaceIDs = memberDetailVM.buildSelectedList(vm.listOfRaces);
// non selected
if (rxvm.SelectedRaceIDs != null && rxvm.SelectedRaceIDs.Count > 0)
{
List <RaceTimesVM> selectedRaceVM = new List <RaceTimesVM>();
List <race> selectedRaces = new List <race>();
foreach (var r in listofraces)
{
if (rxvm.SelectedRaceIDs.Any(s => s == r.Id))
{
selectedRaces.Add(r);
}
}
vm.selectedRaces = memberDetailVM.buildList(selectedRaces, Convert.ToDouble(targetDistance));
vm.SelectedRaceIDs = memberDetailVM.buildSelectedList(vm.selectedRaces);
vm.topAndtailAverage = memberDetailVM.CalcSimpleAve(vm.selectedRaces);
string newtime = vm.topAndtailAverage;
int seconds = UpdateTime(newtime);
ThisRunner.Time = seconds;
ThisRunner.Distance = Convert.ToDouble(targetDistance);
vm.SelectedRaceIDs = rxvm.SelectedRaceIDs;
vm.currentTarget = RaceTimesVM.formatResult(seconds);
}
else
{
// none selected
string newtime = vm.simpleAverage;
int seconds = UpdateTime(newtime);
ThisRunner.Time = seconds;
}
ViewBag.targetdistance = RaceDetails.GetByRaceNameByMeters(Convert.ToDouble(TempData["targetdistance"]));
db.Entry(ThisRunner).State = EntityState.Modified;
db.SaveChanges();
TempData["targetdistance"] = targetDistance;
return(View(vm));
// return RedirectToAction("ListRunners");
}
/// <summary>
/// Some classes have collections of objects as props, here we get them
/// </summary>
/// <typeparam name="T">collection generic type</typeparam>
/// <param name="raceHtmlAgilityList">list of HTML documents by HtmlAfilityPack framework</param>
/// <param name="propertyName">property collection name of currently scrapped object (ex. AllRaces - of the horse)</param>
/// <param name="nodeDictionary">xpath dictionary with property name as a Key</param>
/// <param name="jobType">type of scrapping</param>
/// <param name="raceDate">day of race input</param>
/// <returns></returns>
public List <T> GetGenericList <T>(List <HtmlDocument> raceHtmlAgilityList, string propertyName, Dictionary <string, string> nodeDictionary, string jobType, DateTime raceDate)
{
List <HorseChildDetails> children = new List <HorseChildDetails>();
List <RaceDetails> races = new List <RaceDetails>();
List <HorseDataWrapper> horses = new List <HorseDataWrapper>();
string xpath = nodeDictionary[propertyName];
bool nodeConditions = false;
foreach (var raceHtmlAgility in raceHtmlAgilityList)
{
nodeConditions = _parseService.VerifyNodeCondition(raceHtmlAgility.DocumentNode.OuterHtml.ToString(), propertyName, jobType);
if (nodeConditions) //check complete page
{
HtmlNode[] tableRowsNode = raceHtmlAgility.DocumentNode.SelectNodes(xpath).ToArray();
if (tableRowsNode.Length > 0)
{
foreach (var row in tableRowsNode)
{
string nodeString = row.OuterHtml.ToString();
nodeConditions = _parseService.VerifyNodeCondition(nodeString, propertyName, jobType);
if (nodeConditions) //check single row
{
if (typeof(T) == typeof(HorseChildDetails))
{
HorseChildDetails child = new HorseChildDetails();
child = _parseService.SplitChildNodeString(jobType, nodeString, propertyName, raceDate);
children.Add(child);
}
else if (typeof(T) == typeof(RaceDetails))
{
RaceDetails race = new RaceDetails();
race = _parseService.SplitRaceNodeString(jobType, nodeString, propertyName);
races.Add(race);
}
else if (typeof(T) == typeof(HorseDataWrapper))
{
HorseDataWrapper horse = new HorseDataWrapper();
horse = _parseService.SplitHorseNodeString(jobType, nodeString, propertyName, raceDate);
horses.Add(horse);
}
}
}
}
}
}
if (typeof(T) == typeof(HorseChildDetails))
{
return((List <T>)Convert.ChangeType(children, typeof(List <T>)));
}
else if (typeof(T) == typeof(RaceDetails))
{
return((List <T>)Convert.ChangeType(races, typeof(List <T>)));
}
else if (typeof(T) == typeof(HorseDataWrapper))
{
return((List <T>)Convert.ChangeType(horses, typeof(List <T>)));
}
else
{
throw new ArgumentException();
}
}
private RaceDetails InitializeInstance(RaceDetails instance, int nesting = 0)
{
// at init, we intentionally leave all non-required fields unset
Assert.IsFalse(instance.__isset.opt_one);
Assert.IsFalse(instance.__isset.opt_two);
Assert.IsFalse(instance.__isset.opt_three);
Assert.IsFalse(instance.__isset.opt_four);
Assert.IsFalse(instance.__isset.opt_five);
Assert.IsFalse(instance.__isset.opt_six);
Assert.IsFalse(instance.__isset.opt_seven);
Assert.IsFalse(instance.__isset.opt_eight);
// set all required to null/default
instance.Req_one = default;
instance.Req_two = default;
instance.Req_three = default;
instance.Req_four = default;
instance.Req_five = default;
instance.Req_six = default;
instance.Req_seven = default;;
instance.Req_eight = default;
// leave non-required fields unset again
Assert.IsFalse(instance.__isset.def_one);
Assert.IsFalse(instance.__isset.def_two);
Assert.IsFalse(instance.__isset.def_three);
Assert.IsFalse(instance.__isset.def_four);
Assert.IsFalse(instance.__isset.def_five);
Assert.IsFalse(instance.__isset.def_six);
Assert.IsFalse(instance.__isset.def_seven);
Assert.IsFalse(instance.__isset.def_eight);
// these should have IDL defaults set
Assert.IsTrue(instance.__isset.opt_one_with_value);
Assert.IsTrue(instance.__isset.opt_two_with_value);
Assert.IsTrue(instance.__isset.opt_three_with_value);
Assert.IsTrue(instance.__isset.opt_four_with_value);
Assert.IsTrue(instance.__isset.opt_five_with_value);
Assert.IsTrue(instance.__isset.opt_six_with_value);
Assert.IsTrue(instance.__isset.opt_seven_with_value);
Assert.IsTrue(instance.__isset.opt_eight_with_value);
Assert.AreEqual(instance.Req_one_with_value, (Distance)1);
Assert.AreEqual(instance.Req_two_with_value, 2.22);
Assert.AreEqual(instance.Req_three_with_value, 3);
Assert.AreEqual(instance.Req_four_with_value, "four");
Assert.AreEqual("five", Encoding.UTF8.GetString(instance.Req_five_with_value));
Assert.IsTrue(instance.Req_six_with_value.Count == 1);
Assert.AreEqual(instance.Req_six_with_value[0], 6);
Assert.IsTrue(instance.Req_seven_with_value.Count == 1);
Assert.IsTrue(instance.Req_seven_with_value.Contains(7));
Assert.IsTrue(instance.Req_eight_with_value.Count == 1);
Assert.IsTrue(instance.Req_eight_with_value[8] == 8);
Assert.IsTrue(instance.__isset.def_one_with_value);
Assert.IsTrue(instance.__isset.def_two_with_value);
Assert.IsTrue(instance.__isset.def_three_with_value);
Assert.IsTrue(instance.__isset.def_four_with_value);
Assert.IsTrue(instance.__isset.def_five_with_value);
Assert.IsTrue(instance.__isset.def_six_with_value);
Assert.IsTrue(instance.__isset.def_seven_with_value);
Assert.IsTrue(instance.__isset.def_eight_with_value);
instance.Last_of_the_mohicans = true;
if (nesting < 2)
{
instance.Far_list = new List <Distance>()
{
Distance.foo, Distance.bar, Distance.baz
};
instance.Far_set = new THashSet <Distance>()
{
Distance.foo, Distance.bar, Distance.baz
};
instance.Far_map = new Dictionary <Distance, Distance>()
{
[Distance.foo] = Distance.foo, [Distance.bar] = Distance.bar, [Distance.baz] = Distance.baz
};
instance.Far_set_list = new THashSet <List <Distance> >()
{
new List <Distance>()
{
Distance.foo
}
};
instance.Far_list_map_set = new List <Dictionary <sbyte, THashSet <Distance> > >()
{
new Dictionary <sbyte, THashSet <Distance> >()
{
[1] = new THashSet <Distance>()
{
Distance.baz
}
}
};
instance.Far_map_dist_to_rds = new Dictionary <Distance, List <RaceDetails> >()
{
[Distance.bar] = new List <RaceDetails>()
{
MakeNestedRaceDetails(nesting)
}
};
instance.Req_nested = MakeNestedRaceDetails(nesting);
Assert.IsFalse(instance.__isset.opt_nested);
Assert.IsFalse(instance.__isset.def_nested);
instance.Req_union = MakeNestedUnion(nesting);
Assert.IsFalse(instance.__isset.opt_union);
Assert.IsFalse(instance.__isset.def_union);
}
instance.Triplesix = (Distance)666;
return(instance);
}
/// <summary>
/// Generic method that scraps single object for Jockey, Horse, Race
/// </summary>
/// <typeparam name="T">Jockey, Horse, Race</typeparam>
/// <param name="id">id on the website</param>
/// <param name="jobType">type of scrapping</param>
/// <returns>returns back casted generic object</returns>
public async Task <T> ScrapGenericObject <T>(int id, string jobType)
{
LoadedJockey jockey = new LoadedJockey();
LoadedHorse horse = new LoadedHorse();
RaceDetails race = new RaceDetails();
Dictionary <string, string> nodeDictionary = new Dictionary <string, string>();
List <HtmlDocument> raceHtmlAgilityList = new List <HtmlDocument>();
string linkBase = "";
if (jobType.Contains("JockeysPl"))
{
linkBase = "https://koniewyscigowe.pl/dzokej?d=";
nodeDictionary = _dictionaryService.GetJockeyPlNodeDictionary();
}
else if (jobType.Contains("JockeysCz"))
{
linkBase = "http://dostihyjc.cz/jezdec.php?IDTR=";
nodeDictionary = _dictionaryService.GetJockeyCzNodeDictionary();
}
else if (jobType.Contains("HistoricPl"))
{
linkBase = "https://koniewyscigowe.pl/wyscig?w=";
nodeDictionary = _dictionaryService.GetRacePlNodeDictionary();
}
else if (jobType.Contains("HorsesPl"))
{
linkBase = "https://koniewyscigowe.pl/horse/";
nodeDictionary = _dictionaryService.GetHorsePlNodeDictionary();
}
else if (jobType.Contains("HorsesCz"))
{
linkBase = "http://dostihyjc.cz/kun.php?ID=";
nodeDictionary = _dictionaryService.GetHorseCzNodeDictionary();
}
string link = GetLink(linkBase, id);
string html = await GetHtmlDocumentAsync(link);
HtmlDocument htmlAgility = GetHtmlAgility(html);
string nodeString = htmlAgility.DocumentNode.OuterHtml.ToString();
bool nodeConditions = _parseService.VerifyNodeCondition(nodeString, null, jobType);
if (typeof(T) == typeof(LoadedJockey))
{
if (nodeConditions)
{
string name = _parseService.SplitName(jobType, nodeString, typeof(T), null);
raceHtmlAgilityList = await GetRaceHtmlAgilityListAsync(jobType, link);
jockey = _parseService.ParseJockeyData(link, name);
jockey.AllRaces = GetGenericList <RaceDetails>(raceHtmlAgilityList, nameof(jockey.AllRaces), nodeDictionary, jobType, _dateToday);
}
else
{
jockey = null;
}
return((T)Convert.ChangeType(jockey, typeof(T)));
}
else if (typeof(T) == typeof(RaceDetails))
{
if (nodeConditions)
{
string horsesNode = nodeDictionary[nameof(race.HorseList)];
raceHtmlAgilityList = await GetRaceHtmlAgilityListAsync(jobType, link);
race = _parseService.SplitRaceNodeString(jobType, nodeString, null);
race.RaceLink = link;
race.HorseList = GetGenericList <HorseDataWrapper>(raceHtmlAgilityList, nameof(race.HorseList), nodeDictionary, jobType, race.RaceDate);
race.RaceCompetition = race.HorseList.Count;
}
else
{
race = null;
}
return((T)Convert.ChangeType(race, typeof(T)));
}
else if (typeof(T) == typeof(LoadedHorse))
{
if (nodeConditions)
{
HorseDataWrapper wrapper = new HorseDataWrapper();
raceHtmlAgilityList = await GetRaceHtmlAgilityListAsync(jobType, link);
string name = _parseService.SplitName(jobType, nodeString, typeof(T), null);
string age = _parseService.SplitAge(jobType, nodeString, _dateToday, nameof(horse.Age));
string racer = "";
wrapper = _parseService.ParseHorseData(_dateToday, name, age, link, racer, jobType);
horse.Link = link;
horse.Name = wrapper.HorseName;
horse.Age = wrapper.Age;
horse.Father = GetFather(jobType, htmlAgility, nameof(horse.Father), nodeDictionary);
horse.FatherLink = GetFather(jobType, htmlAgility, nameof(horse.FatherLink), nodeDictionary);
horse.AllRaces = GetGenericList <RaceDetails>(raceHtmlAgilityList, nameof(horse.AllRaces), nodeDictionary, jobType, _dateToday);
horse.AllChildren = GetGenericList <HorseChildDetails>(raceHtmlAgilityList, nameof(horse.AllChildren), nodeDictionary, jobType, _dateToday);
}
else
{
horse = null;
}
return((T)Convert.ChangeType(horse, typeof(T)));
}
else
{
throw new ArgumentException();
}
}
private static void VerifyIdenticalContent(RaceDetails first, RaceDetails second)
{
Assert.AreEqual(first, second);
Assert.AreEqual(first.Opt_two, second.Opt_two);
Assert.AreEqual(first.Opt_three, second.Opt_three);
Assert.AreEqual(first.Opt_four, second.Opt_four);
Assert.IsTrue(TCollections.Equals(first.Opt_five, second.Opt_five));
Assert.IsTrue(TCollections.Equals(first.Opt_six, second.Opt_six));
Assert.IsTrue(TCollections.Equals(first.Opt_seven, second.Opt_seven));
Assert.IsTrue(TCollections.Equals(first.Opt_eight, second.Opt_eight));
Assert.AreEqual(first.Req_one, second.Req_one);
Assert.AreEqual(first.Req_two, second.Req_two);
Assert.AreEqual(first.Req_three, second.Req_three);
Assert.AreEqual(first.Req_four, second.Req_four);
Assert.IsTrue(TCollections.Equals(first.Req_five, second.Req_five));
Assert.IsTrue(TCollections.Equals(first.Req_six, second.Req_six));
Assert.IsTrue(TCollections.Equals(first.Req_seven, second.Req_seven));
Assert.IsTrue(TCollections.Equals(first.Req_eight, second.Req_eight));
Assert.AreEqual(first.Def_one, second.Def_one);
Assert.AreEqual(first.Def_two, second.Def_two);
Assert.AreEqual(first.Def_three, second.Def_three);
Assert.AreEqual(first.Def_four, second.Def_four);
Assert.IsTrue(TCollections.Equals(first.Def_five, second.Def_five));
Assert.IsTrue(TCollections.Equals(first.Def_six, second.Def_six));
Assert.IsTrue(TCollections.Equals(first.Def_seven, second.Def_seven));
Assert.IsTrue(TCollections.Equals(first.Def_eight, second.Def_eight));
Assert.AreEqual(first.Opt_one_with_value, second.Opt_one_with_value);
Assert.AreEqual(first.Opt_two_with_value, second.Opt_two_with_value);
Assert.AreEqual(first.Opt_three_with_value, second.Opt_three_with_value);
Assert.AreEqual(first.Opt_four_with_value, second.Opt_four_with_value);
Assert.IsTrue(TCollections.Equals(first.Opt_five_with_value, second.Opt_five_with_value));
Assert.IsTrue(TCollections.Equals(first.Opt_six_with_value, second.Opt_six_with_value));
Assert.IsTrue(TCollections.Equals(first.Opt_seven_with_value, second.Opt_seven_with_value));
Assert.IsTrue(TCollections.Equals(first.Opt_eight_with_value, second.Opt_eight_with_value));
Assert.AreEqual(first.Req_one_with_value, second.Req_one_with_value);
Assert.AreEqual(first.Req_two_with_value, second.Req_two_with_value);
Assert.AreEqual(first.Req_three_with_value, second.Req_three_with_value);
Assert.AreEqual(first.Req_four_with_value, second.Req_four_with_value);
Assert.IsTrue(TCollections.Equals(first.Req_five_with_value, second.Req_five_with_value));
Assert.IsTrue(TCollections.Equals(first.Req_six_with_value, second.Req_six_with_value));
Assert.IsTrue(TCollections.Equals(first.Req_seven_with_value, second.Req_seven_with_value));
Assert.IsTrue(TCollections.Equals(first.Req_eight_with_value, second.Req_eight_with_value));
Assert.AreEqual(first.Def_one_with_value, second.Def_one_with_value);
Assert.AreEqual(first.Def_two_with_value, second.Def_two_with_value);
Assert.AreEqual(first.Def_three_with_value, second.Def_three_with_value);
Assert.AreEqual(first.Def_four_with_value, second.Def_four_with_value);
Assert.IsTrue(TCollections.Equals(first.Def_five_with_value, second.Def_five_with_value));
Assert.IsTrue(TCollections.Equals(first.Def_six_with_value, second.Def_six_with_value));
Assert.IsTrue(TCollections.Equals(first.Def_seven_with_value, second.Def_seven_with_value));
Assert.IsTrue(TCollections.Equals(first.Def_eight_with_value, second.Def_eight_with_value));
Assert.AreEqual(first.Last_of_the_mohicans, second.Last_of_the_mohicans);
Assert.IsTrue(TCollections.Equals(first.Far_list, second.Far_list));
Assert.IsTrue(TCollections.Equals(first.Far_set, second.Far_set));
Assert.IsTrue(TCollections.Equals(first.Far_map, second.Far_map));
Assert.IsTrue(TCollections.Equals(first.Far_set_list, second.Far_set_list));
Assert.IsTrue(TCollections.Equals(first.Far_list_map_set, second.Far_list_map_set));
Assert.IsTrue(TCollections.Equals(first.Far_map_dist_to_rds, second.Far_map_dist_to_rds));
Assert.AreEqual(first.Req_nested, second.Req_nested);
Assert.AreEqual(first.Opt_nested, second.Opt_nested);
Assert.AreEqual(first.Def_nested, second.Def_nested);
Assert.AreEqual(first.Req_union, second.Req_union);
Assert.AreEqual(first.Opt_union, second.Opt_union);
Assert.AreEqual(first.Def_union, second.Def_union);
Assert.AreEqual(first.Triplesix, second.Triplesix);
}
public ActionResult CalculateResult(int id)
{
RaceDetails details = _raceRepository.GetRaceDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null)
{
return(NotFoundResult());
}
if (details.Detail.EntityStateId != Dom.EntityType.Race.State.Open ||
details.Detail.StartRaceTime == null ||
details.Detail.DarknessBeginTime == null ||
details.Detail.DarknessEndTime == null ||
details.StatementPigeonIds == null ||
(details.StatementPigeonIds != null && details.Detail.ReturnPigeonCount * 1.0 / details.StatementPigeonIds.Count <= 0.2))
{
return(NotFoundResult());
}
Race race = _raceRepository.Get <Race>(id);
race.RaceResults.ToList().ForEach(
x =>
{
x.RaceResultCategories.ToList().ForEach(c => _raceRepository.Delete(c));
_raceRepository.Delete(x);
});
var members = race.RacePigeons.Select(m => m.Pigeon.Member).Distinct().ToList();
int memberCount = members.Count;
int pigeonCount = race.RacePigeons.Count;
ICollection <RaceResult> raceResults = new List <RaceResult>();
foreach (var pigeonReturnTime in race.PigeonReturnTimes)
{
double?distance = race.RaceDistances.First(m => m.MemberId == pigeonReturnTime.Pigeon.MemberId)?.Distance;
if (distance > 0)
{
var totalTime = FlyTime(race.StartRaceTime.Value, pigeonReturnTime.ReturnTime);
var speed = distance.Value / totalTime;
raceResults.Add(new RaceResult
{
Pigeon = pigeonReturnTime.Pigeon,
RaceId = id,
Distance = distance.Value,
FlyTime = totalTime,
Speed = speed * 60
});
}
}
List <RaceResult> raceResultSortered = raceResults
.OrderByDescending(m => m.Speed) //
.ThenByDescending(m => m.Distance) // якщо швидкість однакова, вище стоїть голуб із більшою дистанцією
.ThenBy(m => m.Pigeon.Number) // якщо швидкість і дистанція однакові, вище стоїть голуб із меншим порядковим номером кільця
.ToList();
//todo
//Якщо середня швидкість першого голуба становить менше 600 м / хв.,
//місця у гонці повинні визначатися за фактичним часом констатування голубів
//у гонці без врахування швидкості та відстані від точки випуску до учасника.
//Якщо зафіксований час співпадає для двох і більше голубів, розстановка місць здійснюється від більшої подоланої дистанції до меншої.
int numberOfPrizes = pigeonCount / 5;
// заокруглення в більшу сторону
if (numberOfPrizes * 5 < pigeonCount)
{
numberOfPrizes++;
}
for (int i = 0; i < raceResultSortered.Count; i++)
{
raceResultSortered[i].Position = i + 1;
if (i < numberOfPrizes)
{
raceResultSortered[i].Ac = true;
var raceResultCategories = RaceManager.GetCategory(raceResultSortered[i].Pigeon.Year, raceResultSortered[i].Distance, memberCount, pigeonCount);
raceResultSortered[i].RaceResultCategories = new List <RaceResultCategory>();
foreach (var raceResultCategory in raceResultCategories)
{
raceResultSortered[i].RaceResultCategories.Add(
new RaceResultCategory
{
RaceResult = raceResultSortered[i],
CategoryId = raceResultCategory.Key,
IsOlymp = raceResultCategory.Value,
Coefficient = RaceManager.CalculateCoefficient(pigeonCount, i + 1),
Mark = RaceManager.CalculateMark(numberOfPrizes, i + 1)
});
}
}
race.RaceResults.Add(raceResultSortered[i]);
}
race.RaceStatistics.ToList().ForEach(x => _raceRepository.Delete(x));
foreach (var member in members)
{
int memberId = member.Id;
int statedPigeonCount = race.RacePigeons.Count(m => m.Pigeon.MemberId == memberId);
int prizePigeonCount = race.RaceResults.Count(m => m.Pigeon.MemberId == memberId && m.Ac);
double mark = race.RaceResults.Where(m => m.Pigeon.MemberId == memberId && m.Ac).OrderBy(m => m.Position).Take(5).Sum(m => m.RaceResultCategories.First().Mark);
race.RaceStatistics.Add(new RaceStatistic
{
MemberId = member.Id,
StatedPigeonCount = statedPigeonCount,
PrizePigeonCount = prizePigeonCount,
Mark = mark,
Success = prizePigeonCount * 100.0 / statedPigeonCount
});
}
var firstPigeon = raceResultSortered.FirstOrDefault(m => m.Position == 1);
var lastPigeon = raceResultSortered.FirstOrDefault(m => m.Position == numberOfPrizes);
race.PigeonCount = race.RacePigeons.Count;
race.MemberCount = memberCount;
race.AverageDistance = race.RaceDistances.Where(m => m.Distance > 0).Average(m => m.Distance);
race.TimeOfFirst = race.StartRaceTime.Value.AddSeconds(firstPigeon.FlyTime);
race.TimeOfLast = race.StartRaceTime.Value.AddSeconds(lastPigeon.FlyTime);
race.SpeedOfFirst = firstPigeon.Speed;
race.SpeedOfLast = lastPigeon.Speed;
race.TwentyPercent = race.PigeonCount / 5;
race.CockCount = race.RacePigeons.Count(m => m.Pigeon.SexId == Dom.Sex.C**k);
race.HenCount = race.RacePigeons.Count(m => m.Pigeon.SexId == Dom.Sex.Hen);
int currentYear = DateTime.UtcNow.Year;
race.YoungCount = race.RacePigeons.Count(m => currentYear - m.Pigeon.Year == 0);
race.YearlyCount = race.RacePigeons.Count(m => currentYear - m.Pigeon.Year == 1);
race.AdultsCount = race.RacePigeons.Count(m => currentYear - m.Pigeon.Year > 1);
race.StartСompetitionTime = race.PigeonReturnTimes.Min(m => m.ReturnTime);
//todo
race.EndСompetitionTime = race.StartRaceTime.Value.AddSeconds(lastPigeon.FlyTime);
race.DurationOfCompetition = race.EndСompetitionTime.Value.Subtract(race.StartСompetitionTime.Value).TotalSeconds;
race.PigeonTwentyPercentAFact = race.RaceResults.Count(m => m.FlyTime < race.DurationOfCompetition.Value);
race.MemberTwentyPercentAFact = race.RaceResults.Where(m => m.FlyTime < race.DurationOfCompetition.Value).Select(m => m.Pigeon.MemberId).Distinct().Count();
race.InFactAbidedPercent = race.PigeonTwentyPercentAFact * 100.0 / race.PigeonCount;
_raceRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(Mvc.Controller.Race.Details, Mvc.Controller.Race.Name, new { id }));
}
public ActionResult Edit(RaceDetailsViewModel viewModel)
{
if (viewModel.Detail.DarknessEndTime <= viewModel.Detail.DarknessBeginTime)
{
AddModelError(viewModel, m => m.Detail.DarknessEndTime, StyleContext.GetTranslation(Dom.Translation.Race.DarknessEndTimeLessDarknessBeginTime));
}
if (viewModel.Detail.StartRaceTime < viewModel.Detail.DarknessBeginTime)
{
AddModelError(viewModel, m => m.Detail.StartRaceTime, StyleContext.GetTranslation(Dom.Translation.Race.StartRaceTimeLessDarknessBeginTime));
}
if (ModelState.IsValid)
{
Race race = _raceRepository.Get <Race>(viewModel.Detail.Id);
race.Name = viewModel.Detail.Name;
race.PointId = viewModel.Detail.PointId;
race.StartRaceTime = viewModel.Detail.StartRaceTime;
race.DarknessBeginTime = viewModel.Detail.DarknessBeginTime;
race.DarknessEndTime = viewModel.Detail.DarknessEndTime;
race.Weather = viewModel.Detail.Weather;
race.RacePigeons.ToList().ForEach(x => _raceRepository.Delete(x));
if (viewModel.StatementIds != null)
{
foreach (var pigeon in viewModel.StatementIds)
{
race.RacePigeons.Add(
new RacePigeon
{
PigeonId = pigeon,
RaceId = race.Id
});
}
}
_raceRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(Mvc.Controller.Race.Details, Mvc.Controller.Race.Name, new { id = viewModel.Detail.Id }));
}
RaceDetails details = _raceRepository.GetRaceDetails(UserContext.User.Id, UserContext.User.OrganizationId, viewModel.Detail.Id);
var points = _pointRepository.GetPoints(UserContext.User.Id, UserContext.User.OrganizationId, viewModel.Detail.OrganizationId);
viewModel.Detail.PointItems = Mapper.Map <ICollection <SelectListItem> >(points);
foreach (var pigeon in details.Pigeons)
{
pigeon.Ring = Format.FormattedRing(pigeon.Year, pigeon.Code, pigeon.Number);
pigeon.InStatement = details.StatementPigeonIds.Contains(pigeon.Id);
}
viewModel.StatementIds = details.StatementPigeonIds.ToList();
viewModel.StatementItems = new Dictionary <string, ICollection <SelectListItem> >();
foreach (var member in details.Members)
{
viewModel.StatementItems.Add(
Format.FormattedInitials(member.LastName, member.FirstName, member.MiddleName) + $" (#{member.Id})",
details.Pigeons
.Where(m => m.MemberId == member.Id)
.Select(g => new SelectListItem
{
Value = g.Id.ToString(),
Text = g.Ring,
Selected = g.InStatement
}).ToList()
);
}
return(View(Mvc.View.Race.Edit, viewModel));
}
private void btnInstall_Click(object sender, EventArgs e)
{
bool success = false;
RaceDetails oldRace = races.Races[lstRaces.SelectedIndex];
RaceDetails newRace = mods[lstMods.SelectedIndex];
string oldRaceName = Path.GetFileNameWithoutExtension(oldRace.RaceFilename);
string newRaceName = Path.GetFileNameWithoutExtension(newRace.RaceFilename);
// extract archive (if installing from one)
if (modZips.ContainsKey(lstMods.SelectedIndex))
{
using (ZipArchive archive = ZipFile.OpenRead(modZips[lstMods.SelectedIndex]))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.Name == "")
{
continue;
}
string destinationPath = Path.GetFullPath(Path.Combine(txtPath.Text, entry.FullName));
if (destinationPath.StartsWith(txtPath.Text, StringComparison.Ordinal))
{
if (File.Exists(destinationPath))
{
File.Delete(destinationPath);
}
entry.ExtractToFile(destinationPath);
}
}
}
}
// validate installation by checking MapFilename exists
if (Directory.Exists(Path.Combine(txtPath.Text, "data", "races", newRaceName)))
{
success = File.Exists(Path.Combine(txtPath.Text, "data", "races", newRaceName, $"{newRaceName}.txt"));
}
else
{
if (File.Exists(Path.Combine(txtPath.Text, "data", "races", $"{newRaceName}.twt")))
{
TWT twt = TWT.Load(Path.Combine(txtPath.Text, "data", "races", $"{newRaceName}.twt"));
success = twt.Contents.Any(entry => string.Compare(entry.Name, $"{newRaceName}.txt", true) == 0);
}
}
if (success)
{
// create c2t file for track to be replaced
using (DocumentWriter dw = new DocumentWriter(Path.Combine(txtPath.Text, $"{oldRaceName}.c2t")))
{
oldRace.Write(dw);
}
// update races.txt
races.Races[lstRaces.SelectedIndex] = newRace;
File.Delete(Path.Combine(txtPath.Text, "data", "races.old"));
File.Move(Path.Combine(txtPath.Text, "data", "races.txt"), Path.Combine(txtPath.Text, "data", "races.old"));
races.Save(Path.Combine(txtPath.Text, "data", "races.txt"));
reloadUI(currentRoot);
}
}
