private string GetSubRegion(SubRegion subRegion)
{
if (subRegion == SubRegion.None)
{
return(string.Empty);
}
return(subRegion.ToString().ToLower());
}
/// <summary>
/// Create web model[DropDown] from entity
/// </summary>
public static ApiModel.SubRegionDropDown CreateFrom(this SubRegion source)
{
return(new ApiModel.SubRegionDropDown
{
SubRegionId = source.SubRegionId,
SubRegionCodeName = source.SubRegionCode + " - " + source.SubRegionName,
RegionId = source.RegionId
});
}
public async Task PrepareDailyCheckLists(IServiceScope scope)
{
var dbContext = scope.ServiceProvider.GetRequiredService <AppDbContext>();
List <string> vehicleNumbers = (from v in dbContext.Vehicles
join gv in dbContext.GBMSVehicles on v.VehicleNumber equals gv.Description
select gv.Description).ToList();
foreach (var vehicleNumber in vehicleNumbers)
{
Vehicle vehicle = (from f in dbContext.Vehicles
join v in dbContext.GBMSVehicles on f.VehicleNumber equals v.Description
where v.Description == vehicleNumber
select f).SingleOrDefault();
Region region = (from r in dbContext.Regions
where r.XDescription == vehicle.Region
select r).SingleOrDefault();
SubRegion subRegion = (from s in dbContext.SubRegions
where s.XDescription == vehicle.SubRegion
select s).SingleOrDefault();
Station station = (from st in dbContext.Stations
where st.XDescription == vehicle.Station
select st).SingleOrDefault();
string DriverName = (from d in dbContext.Drivers
where d.VehicleNumber == vehicleNumber
select d.Name).SingleOrDefault();
IEnumerable <DailyMorning> fMSDailyMornings = from m in dbContext.DailyMorningChecks where m.VehicleNumber == vehicleNumber && m.LastUpdated.Date == (PakistanDateTime.Today) select m;
if (!fMSDailyMornings.Any())
{
DailyMorning dailyMorning = new();
dailyMorning.Id = Guid.NewGuid();
dailyMorning.LastUpdated = PakistanDateTime.Now;
dailyMorning.VehicleNumber = vehicleNumber;
dailyMorning.DriverName = DriverName;
dailyMorning.Region = region.XDescription;
dailyMorning.Subregion = subRegion.XDescription;
dailyMorning.Station = station.XDescription;
await dbContext.DailyMorningChecks.AddAsync(dailyMorning);
await dbContext.SaveChangesAsync();
}
IEnumerable <DailyEvening> fMSDailyEvenings = from e in dbContext.DailyEveningChecks where e.VehicleNumber == vehicleNumber && e.LastUpdated.Date == (PakistanDateTime.Today) select e;
if (!fMSDailyEvenings.Any())
{
DailyEvening dailyEvening = new();
dailyEvening.Id = Guid.NewGuid();
dailyEvening.LastUpdated = PakistanDateTime.Now;
dailyEvening.VehicleNumber = vehicleNumber;
dailyEvening.DriverName = DriverName;
dailyEvening.Region = region.XDescription;
dailyEvening.Subregion = subRegion.XDescription;
dailyEvening.Station = station.XDescription;
await dbContext.DailyEveningChecks.AddAsync(dailyEvening);
await dbContext.SaveChangesAsync();
}
}
}
public SubRegion Post(SubRegion subRegion)
{
if (subRegion == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
return(subRegionService.SaveSubRegion(subRegion.CreateFrom()).CreateFromm());
}
public Boolean Delete(SubRegion subRegion)
{
if (subRegion == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
subRegionService.DeleteSubRegion(subRegion.SubRegionId);
return(true);
}
public void CorrectlyMovesToNextSubRegion_OnlyOneNextSubRegion()
{
const MagicType firstBossEggType = MagicType.Fire;
const MagicType secondBossEggType = MagicType.Ice;
TeamConfiguration firstBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, firstBossEggType));
SubRegion subRegionA = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(firstBossConfiguration));
const string secondRegionIntro = "Who wants donuts?!?";
TeamConfiguration secondBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, secondBossEggType));
SubRegion subRegionB = new SubRegion(WorldSubRegion.DesertCrypt, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(secondBossConfiguration), regionIntro: secondRegionIntro);
SubRegion[] subRegions = { subRegionA, subRegionB };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
AreaMap <Region, WorldRegion> regionMap = new AreaMap <Region, WorldRegion>(fakeFieldsRegion, new MapPath <Region, WorldRegion>(fakeFieldsRegion));
AreaMap <SubRegion, WorldSubRegion> subRegionMap = new AreaMap <SubRegion, WorldSubRegion>(subRegionA, new MapPath <SubRegion, WorldSubRegion>(subRegionA, subRegionB));
_mapManager.SetRegionalMap(regionMap);
_mapManager.SetSubRegionalMap(WorldRegion.Fields, subRegionMap);
_regionManager = GetRegionManager();
TestEnemyFighter target = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
target.SetHealth(1, 0);
_humanFighter1.SetMove(_basicAttackMove, 1);
_humanFighter1.SetMove(_runawayMove, 1);
_humanFighter1.SetMoveTarget(target);
_humanFighter2.SetMove(_doNothingMove);
_chanceService.PushAttackHitsNotCrit();
_regionManager.Battle(_battleManager, _humanTeam);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.NotNull(outputs.FirstOrDefault(o => o.Message == secondRegionIntro + "\n"));
List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();
Assert.AreEqual(2, enemyTeams.Count);
Egg secondBoss = enemyTeams[1].Fighters[0] as Egg;
Assert.NotNull(secondBoss);
Assert.AreEqual(secondBossEggType, secondBoss.MagicType);
Assert.AreEqual(WorldSubRegion.DesertCrypt, subRegionMap.CurrentArea.AreaId);
}
/// <summary>
/// update sub Region object Properties in case of updation
/// </summary>
protected void UpdateSubRegionPropertie(SubRegion region, SubRegion dbVersion)
{
dbVersion.RecLastUpdatedBy = regionRepository.LoggedInUserIdentity;
dbVersion.RecLastUpdatedDt = DateTime.Now;
dbVersion.RowVersion = dbVersion.RowVersion + 1;
dbVersion.SubRegionCode = region.SubRegionCode;
dbVersion.SubRegionName = region.SubRegionName;
dbVersion.SubRegionDescription = region.SubRegionDescription;
dbVersion.RegionId = region.RegionId;
}
/// <summary>
/// Set newly created sub Region object Properties in case of adding
/// </summary>
private void SetSubRegionProperties(SubRegion region, SubRegion dbVersion)
{
dbVersion.RecLastUpdatedBy = dbVersion.RecCreatedBy = regionRepository.LoggedInUserIdentity;
dbVersion.RecLastUpdatedDt = dbVersion.RecCreatedDt = DateTime.Now;
dbVersion.SubRegionCode = region.SubRegionCode;
dbVersion.SubRegionName = region.SubRegionName;
dbVersion.SubRegionDescription = region.SubRegionDescription;
dbVersion.RegionId = region.RegionId;
dbVersion.UserDomainKey = regionRepository.UserDomainKey;
}
public Task SyncSubRegions(List <RbSubRegion> subregions, IServiceScope scope)
{
var context = scope.ServiceProvider.GetRequiredService <AppDbContext>();
foreach (var item in subregions)
{
var subregion = (from s in context.SubRegions where s.XCode == item.XCode select s).FirstOrDefault();
if (subregion == null)
{
subregion = new SubRegion()
{
AddDate = item.AddDate,
AddId = item.AddId,
IpAdd = item.IpAdd,
XAbbrevation = item.XAbbrevation,
Id = Guid.NewGuid(),
IpMod = item.IpMod,
ModDate = item.ModDate,
ModId = item.ModId,
XCode = item.XCode,
XDescription = item.XDescription,
XRemarks = item.XRemarks,
XrowId = item.XrowId,
XRevenueAuthroity = item.XRevenueAuthroity,
XRevenueAuthroityDescription = item.XRevenueAuthroityDescription,
XRegion = item.XRegion,
XRegionDescription = item.XRegionDescription,
LastSync = DateTime.UtcNow
};
context.SubRegions.Add(subregion);
}
else
{
subregion.AddDate = item.AddDate;
subregion.AddId = item.AddId;
subregion.IpAdd = item.IpAdd;
subregion.XAbbrevation = item.XAbbrevation;
subregion.IpMod = item.IpMod;
subregion.ModDate = item.ModDate;
subregion.ModId = item.ModId;
subregion.XDescription = item.XDescription;
subregion.XRemarks = item.XRemarks;
subregion.XrowId = item.XrowId;
subregion.XRevenueAuthroity = item.XRevenueAuthroity;
subregion.XRevenueAuthroityDescription = item.XRevenueAuthroityDescription;
subregion.XRegion = item.XRegion;
subregion.XRegionDescription = item.XRegionDescription;
subregion.LastSync = DateTime.UtcNow;
}
}
context.SaveChanges();
return(Task.CompletedTask);
}
public async Task <IActionResult> Create([Bind("SubRegionId,Name,ContinentId")] SubRegion subRegion)
{
if (ModelState.IsValid)
{
_context.Add(subRegion);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["ContinentId"] = new SelectList(_context.Continent, "ContinentId", "Name", subRegion.ContinentId);
return(View(subRegion));
}
public void Subscribe(SubRegion subRegion, EventType eventType)
{
switch (eventType)
{
case EventType.SubRegionCompleted:
subRegion.SubRegionCompleted += _logSubRegionCompleted;
break;
default:
throw new ArgumentOutOfRangeException(nameof(eventType), eventType, "a valid EventType must be specified compatible with SubRegion's implemented events");
}
}
/// <summary>
/// Create from domain model to web model
/// </summary>
public static ApiModel.SubRegion CreateFromm(this SubRegion source)
{
return(new ApiModel.SubRegion
{
SubRegionId = source.SubRegionId,
SubRegionCode = source.SubRegionCode,
SubRegionName = source.SubRegionName,
SubRegionDescription = source.SubRegionDescription,
RegionId = source.RegionId,
RegionName = source.Region.RegionName
});
}
public ActionResult SubRegion_ContentHandler(string inputSubRegionName, string selectedCropFieldID, string selectedCropTypeID, string inputCroppedProductAmount, string inputSoilWaterContent) //Statik olarak veri girdisi
//Var olan bir tarlaya yeni bir ekim alanı eklersin
//böylece yeni tahminler için Azure ML ' e girdi sağlamış olursun
//bu girdiler eklenen her sensörün gönderdiği değerleri temsil etmektedir.
{
if (Session["KisiTanimlayici"].ToString() == "Customer")
{
TempData["SecurityWall_Home"] = "Güvenlik Duvarına Takıldınız.";
return(RedirectToAction("Index", "Login"));
}
else
{
OptagricEntities DB = new OptagricEntities();
ViewBag.CropFields = DB.CropField.ToList();
ViewBag.CropType = DB.CropType.ToList();
try
{
if (inputSubRegionName != null && selectedCropFieldID != null && selectedCropTypeID != null && inputCroppedProductAmount != null && inputSoilWaterContent != null)
{
SubRegion eklenecek = new SubRegion
{
Name = inputSubRegionName,
CF_ID = Convert.ToInt32(selectedCropFieldID),
CropTypeID = Convert.ToInt32(selectedCropTypeID),
CroppedProductAmount = Convert.ToInt32(inputCroppedProductAmount),
SoilWaterContent = Convert.ToInt32(inputSoilWaterContent),
};
DB.SubRegion.Add(eklenecek);
DB.SaveChanges();
//ActionLogs(tut, "Insert", "SubRegion_ContentHandler");
string p1 = this.ControllerContext.RouteData.Values["action"].ToString();
string p2 = this.ControllerContext.RouteData.Values["controller"].ToString();
CRUD_Logs(p1, Session["CurrentUserGuid"].ToString(), "INSERT", eklenecek.Name + " / " + p1 + " / " + p2);
TempData["SubRegionSuccess"] = "Ekleme Başarılı";
return(View());
}
else
{
return(View());
}
}
catch (Exception)
{
TempData["SubRegionError"] = "Lütfen Değeleri Uygun Giriniz";
return(View());
}
}
}
public void BuildSubregionDictionary()
{
foreach (Country country in AllCountries())
{
if (!subRegions.ContainsKey(country.subregion))
{
var subRegion = new SubRegion(country.subregion);
subRegions.Add(country.subregion, subRegion);
}
subRegions[country.subregion].Countries.Add(country.name, country);
country.SubRegion = subRegions[country.subregion];
}
}
public Team GetTeam(SubRegion region)
{
var enemyList = new List <IFighter>();
int numEnemies = _chanceService.WhichEventOccurs(region.NumberEnemyFighterChances);
for (var i = 0; i < numEnemies; ++i)
{
enemyList.Add(GetEnemy(region));
}
//TODO: MenuManager should probably be supplied, perhaps?
return(new Team(new MenuManager(new ConsoleInput(), new ConsoleOutput(), _menuFactory), enemyList));
}
private EnemyFighter GetEnemy(SubRegion region)
{
//FighterType[] types = regionFighterTypesDictionary[region.AreaId];
//var length = types.Length;
//var odds = new double[length];
//for (var i = 0; i < length; ++i)
//{
// odds[i] = (1.0/length);
//}
FighterType selectedFighterType = _chanceService.WhichEventOccurs(region.EnemyTypes);
return((EnemyFighter)FighterFactory.GetFighter(selectedFighterType, 1));
}
public void CorrectNumberOfBattlesBeforeBoss([Range(1, 3)] int numberBattles)
{
TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 5), new EnemyConfiguration(FighterType.ShieldGuy, 2), new EnemyConfiguration(FighterType.ShieldGuy, 3));
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, numberBattles, new[] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg },
new BattlefieldConfiguration(bossConfiguration));
SubRegion[] subRegions = { subRegion };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
for (int i = 0; i < numberBattles; ++i)
{
Team team = GetSingleEnemyTeam();
_teamFactory.PushTeams(team);
_chanceService.PushWhichEventOccurs(0);
}
_regionManager = GetRegionManager();
IFighter target = TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
target.PhysicalDamage(target.MaxHealth);
_humanFighter1.SetMove(_basicAttackMove, numberBattles);
_humanFighter1.SetMoveTarget(target);
_chanceService.PushAttackHitsNotCrit(numberBattles);
_humanFighter1.SetMove(_runawayMove);
_humanFighter2.SetMove(_doNothingMove);
_chanceService.PushWhichEventsOccur(0, 0, 0, 0, 0, 0); //used for when the bosses are selecting their moves
_regionManager.Battle(_battleManager, _humanTeam);
List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();
Assert.AreEqual(numberBattles + 1, enemyTeams.Count);
Team bossTeam = enemyTeams[numberBattles];
Assert.AreEqual(3, bossTeam.Fighters.Count);
Assert.True(bossTeam.Fighters.Exists(f => f is Barbarian && f.Level == 5));
Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 2));
Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 3));
}
/// <summary>
/// Delete sub Region by id
/// </summary>
public void DeleteSubRegion(long subRegionId)
{
SubRegion dbversion = subRegionRepository.Find((int)subRegionId);
// Assocoation with city check
if (cityRepository.IsSubRegionAssociatedWithCity(subRegionId))
{
throw new CaresException(Resources.GeographicalHierarchy.SubRegion.SubRegionIsAssociatedWithCityError);
}
if (dbversion == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Sub Region with Id {0} not found!", subRegionId));
}
subRegionRepository.Delete(dbversion);
subRegionRepository.SaveChanges();
}
private static SubRegionVM SubRegionViewModel(SubRegion r)
{
return(new SubRegionVM()
{
AddDate = r.AddDate,
AddId = r.AddId,
IpAdd = r.IpAdd,
Code = r.XCode,
Description = r.XDescription,
IpMod = r.IpMod,
ModDate = r.ModDate,
ModId = r.ModId,
Remarks = r.XRemarks,
rowId = r.XrowId,
Abbrevation = r.XAbbrevation,
Id = r.Id
});
}
private void UpdateStorageSystemsForSubRegion(int subRegionId)
{
var storageSystems = _ud.GetStorageSystems();
if (storageSystems.Count() > 0)
{
foreach (var s in storageSystems)
{
if (s.AnnualPrecipitation != null)
{
SubRegion subregion = _sd.GetSubRegion(subRegionId);
s.AnnualPrecipitation = subregion.AnnualPrecipitation;
}
_ud.UpdateManureStorageSystem(s);
}
}
}
public async Task <string> PostCountry(Country country)
{
var original = db.Countries.Where(c => c.CountryCode == country.CountryCode).FirstOrDefault();
if (original == null)
{
var countryRegion = await _apiService.GetCountryRegion(country);
var region = db.Regions.Where(r => r.Name == countryRegion.region).FirstOrDefault();
if (region == null)
{
region = new Region()
{
Name = countryRegion.region
};
db.Regions.Add(region);
db.SaveChanges();
}
var subRegion = db.SubRegions.Where(sr => sr.Name == countryRegion.subregion).FirstOrDefault();
if (subRegion == null)
{
subRegion = new SubRegion()
{
Name = countryRegion.subregion,
RegionID = region.RegionID
};
db.SubRegions.Add(subRegion);
db.SaveChanges();
}
country.SubRegionID = subRegion.SubRegionID;
db.Countries.Add(country);
db.SaveChanges();
return("OK");
}
return("ALREADY_EXISTS");
}
public List <Region> GetRegions()
{
List <Country> countries = countryService.GetCountries();
if (countries == null)
{
return(null);
}
List <Region> regions = new List <Region>();
var regionList = countries.Select(x => x.Region).Distinct().ToList();
regionList.Sort();
foreach (var region in regionList)
{
var subRegions = countries.Where(c => c.Region == region).Select(r => r.SubRegion).Distinct().ToList();
subRegions.Sort();
var subRegionList = new List <SubRegion>();
foreach (var subRegion in subRegions)
{
var subRegionCountries = countries.Where(x => x.SubRegion == subRegion && x.Region == region).ToList();
subRegionCountries.Sort((x, y) => x.Name.CompareTo(y.Name));
var subRegionInfo = new SubRegion()
{
Name = subRegion,
Countries = subRegionCountries
};
subRegionList.Add(subRegionInfo);
}
var regionInfo = new Region()
{
Name = region,
SubRegions = subRegionList
};
regions.Add(regionInfo);
}
return(regions);
}
void RemoveEdgesForSubRegion(SubRegion subRegion)
{
foreach (var topEdge in subRegion.Top)
{
_top.Remove(topEdge);
}
foreach (var bottomEdge in subRegion.Bottom)
{
_bottom.Remove(bottomEdge);
}
foreach (var leftEdge in subRegion.Left)
{
_left.Remove(leftEdge);
}
foreach (var rightEdge in subRegion.Right)
{
_right.Remove(rightEdge);
}
}
void AddEdgesForSubRegion(SubRegion subRegion)
{
foreach (var topEdge in subRegion.Top)
{
_top.Add(topEdge, subRegion);
}
foreach (var bottomEdge in subRegion.Bottom)
{
_bottom.Add(bottomEdge, subRegion);
}
foreach (var leftEdge in subRegion.Left)
{
_left.Add(leftEdge, subRegion);
}
foreach (var rightEdge in subRegion.Right)
{
_right.Add(rightEdge, subRegion);
}
}
private void UpdateStorageSystemsForSubRegion(int subRegionId)
{
var storageSystems = _ud.GetStorageSystems();
decimal conversionForLiquid = 0.024542388m;
decimal conversionForSolid = 0.000102408m;
if (storageSystems.Count() > 0)
{
foreach (var s in storageSystems)
{
if (s.AnnualPrecipitation != null)
{
SubRegion subregion = _sd.GetSubRegion(subRegionId);
s.AnnualPrecipitation = subregion.AnnualPrecipitation;
}
_ud.UpdateManureStorageSystem(s);
}
}
}
public void CorrectlyClearsEarlierGroupingResult_WhenDesertRegionCompleted([Range(0, 1)] int selectedSubRegionIndex)
{
//arrange
Region desertRegion;
MapGrouping <SubRegion, WorldSubRegion> firstGrouping, secondGrouping;
MockMenu menu1, menu2;
List <WorldSubRegion> firstGroupingSubRegions =
WorldSubRegions.GetSubRegionsByGroupingId(Globals.GroupingKeys.FirstDesertGroupingId).ToList();
WorldSubRegion selectedSubRegionEnum = firstGroupingSubRegions[selectedSubRegionIndex];
PickNextArea_GroupingSetup_DesertGroupings(out firstGrouping, out secondGrouping, out desertRegion);
PickNextArea_MenuSetup_DesertGroupings(selectedSubRegionEnum, WorldSubRegion.VillageCenter, out menu1, out menu2);
Team team = PickNextArea_TeamSetup_DesertGroupings();
//all sub regions must be unlocked for the Decision Manager to be called
Assert.True(secondGrouping.Values.TrueForAll(grouping => !grouping.IsLocked));
_decisionManager.PickNextArea(firstGrouping, team);
desertRegion.OnRegionCompleted(new RegionCompletedEventArgs(desertRegion));
//will set the menus to return a different selection, and so if the returned region matches the original selection, the test has failed
WorldSubRegion secondMenuSelection = firstGroupingSubRegions[selectedSubRegionIndex + 1];
menu1.SetNextSelection(new TypedMenuSelection <WorldSubRegion>(secondMenuSelection, "", null, null));
menu2.SetNextSelection(new TypedMenuSelection <WorldSubRegion>(WorldSubRegion.BeastTemple, "", null, null));
_menuFactory.SetMenu(MenuType.NonSpecificMenu, menu1);
_menuFactory.SetMenu(MenuType.NonSpecificMenu, menu2);
firstGrouping.Unlock(s => true);
secondGrouping.Unlock(s => true);
//Act
SubRegion secondReturnedRegion = _decisionManager.PickNextArea(firstGrouping, team);
//Assert
Assert.AreEqual(secondMenuSelection, secondReturnedRegion.AreaId);
}
public ActionResult Create(SubRegion subRegion, FormCollection form)
{
try
{
subRegion.PhotoUrl = form["PhotoUrl"].ToString();
subRegion.SubRegionCode = subRegion.RegionCode.Trim() + subRegion.SubRegionCode.Trim();
_wineRepository.AddSubRegion(subRegion);
_wineRepository.Save();
return(RedirectToAction("Index"));
}
catch
{
SubRegionAdminViewModel viewModel = new SubRegionAdminViewModel()
{
SubRegion = subRegion,
Countries = _wineRepository.FindAllCountries().ToList(),
Regions = _wineRepository.FindAllRegions().ToList()
};
return(View(viewModel));
}
}
public List <SubRegion> GetAllSubRegion()
{
List <SubRegion> subRegionList = new List <SubRegion>();
try
{
using (DbCommand command = _db.GetStoredProcCommand(Constants.SpGetAllSubRegions))
{
using (DbConnection connection = _db.CreateConnection())
{
connection.Open();
command.Connection = connection;
using (IDataReader reader = command.ExecuteReader())
{
SqlDataReader dr = (SqlDataReader)reader;
if (dr.HasRows)
{
while (dr.Read())
{
SubRegion Subregion = new SubRegion();
Subregion.SubRegionId = Convert.ToInt32(dr["SubRegionId"]);
Subregion.SubRegionName = Convert.ToString(dr["SubRegionName"]);
subRegionList.Add(Subregion);
}
}
}
connection.Close();
}
}
}
catch (Exception ex) { }
return(subRegionList);
}
public void SubRegionalMap_CorrectlyFiresOnRegionCompletedEvent()
{
SubRegion fakeSubRegion = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0],
new FighterType[0], new BattlefieldConfiguration(new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, MagicType.Fire))));
_logger.Subscribe(fakeSubRegion, EventType.SubRegionCompleted);
AreaMap <SubRegion, WorldSubRegion> fakeRegionalMap =
new AreaMap <SubRegion, WorldSubRegion>(fakeSubRegion, new MapPath <SubRegion, WorldSubRegion>(fakeSubRegion));
fakeRegionalMap.Advance(new MockDecisionManager(new GodRelationshipManager()), new TestTeam());
List <EventLog> logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
EventLog log = logs[0];
Assert.AreEqual(EventType.SubRegionCompleted, log.Type);
SubRegionCompletedEventArgs e = log.E as SubRegionCompletedEventArgs;
Assert.AreEqual(fakeSubRegion, e?.CompletedSubRegion);
}
public void GetTeam_AssignsAppropriateNumberOfEnemiesToTeam([Values(1, 2, 3, 4)] int numEnemies)
{
//push logic for determining how many fighters will be in the enemy team, driven by SubRegion configuration
_chanceService.PushWhichEventOccurs(0);
Type[] types = { typeof(Goblin), typeof(Fairy), typeof(Golem), typeof(Ogre) };
for (var i = 0; i < numEnemies; ++i)
{
_chanceService.PushWhichEventOccurs(i);
}
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, 1, new [] { new ChanceEvent <int>(numEnemies, 1) },
new[] { FighterType.Goblin, FighterType.Fairy, FighterType.Golem, FighterType.Ogre }, null);
_enemyTeam = _teamFactory.GetTeam(subRegion);
Assert.AreEqual(numEnemies, _enemyTeam.Fighters.Count);
for (var i = 0; i < numEnemies; ++i)
{
var enemy = _enemyTeam.Fighters[i];
Assert.AreEqual(types[i], enemy.GetType());
}
}
/// <summary>
/// Returns the values in the list with simple bounds.
/// </summary>
protected List<SubRegion> GetRegionsInValueSet(List<DataValue> values, bool ignoreBadData, bool useSteppedCalculations)
{
// nothing to do if no data.
if (values == null)
{
return null;
}
SubRegion currentRegion = null;
List<SubRegion> regions = new List<SubRegion>();
for (int ii = 0; ii < values.Count; ii++)
{
double currentValue = 0;
DateTime currentTime = values[ii].SourceTimestamp;
StatusCode currentStatus = values[ii].StatusCode;
// convert to doubles to facilitate numeric calculations.
if (StatusCode.IsNotBad(currentStatus))
{
try
{
currentValue = CastToDouble(values[ii]);
}
catch (Exception)
{
currentStatus = StatusCodes.BadTypeMismatch;
}
}
else
{
// use the previous value if end of region is bad.
if (currentRegion != null)
{
currentValue = currentRegion.StartValue;
}
}
// some aggregates ignore bad data so remove them from the set.
if (ignoreBadData)
{
// always keep the first region.
if (currentRegion != null)
{
if (!IsGood(values[ii]))
{
// set the status to sub normal if bad end data ignored.
if (StatusCode.IsNotBad(currentRegion.StatusCode))
{
currentRegion.StatusCode = StatusCodes.UncertainDataSubNormal;
}
// skip everything but the endpoint.
if (ii < values.Count - 1)
{
continue;
}
}
else
{
if (!useSteppedCalculations && StatusCode.IsNotGood(values[ii].StatusCode))
{
currentRegion.StatusCode = StatusCodes.UncertainDataSubNormal;
}
}
}
}
if (currentRegion != null)
{
// if using stepped calculations the end value is not used.
if (useSteppedCalculations)
{
currentRegion.EndValue = currentRegion.StartValue;
}
// using interpolated calculations means the end affects the status of the current region.
else
{
if (IsGood(values[ii]))
{
// handle case with uncertain end point.
if (StatusCode.IsNotGood(values[ii].StatusCode) && StatusCode.IsNotBad(currentRegion.StatusCode))
{
currentRegion.StatusCode = StatusCodes.UncertainDataSubNormal;
}
currentRegion.EndValue = currentValue;
}
else
{
if (StatusCode.IsNotBad(currentRegion.StatusCode))
{
currentRegion.StatusCode = StatusCodes.UncertainDataSubNormal;
}
if (ignoreBadData && StatusCode.IsNotBad(currentStatus))
{
currentRegion.EndValue = currentValue;
}
}
}
// if at end of data then duration is 1 tick.
// must be end of data if start of region is good yet end bound is bad.
if (!ignoreBadData && currentRegion != null && IsGood(currentRegion.DataPoint) && currentStatus == StatusCodes.BadNoData && ii == values.Count - 1)
{
currentRegion.Duration = 1;
}
// calculate region span.
else
{
// set uncertain status to bad if treat uncertain as bad is true.
if (StatusCode.IsUncertain(currentStatus) && !IsGood(values[ii]))
{
currentStatus = StatusCodes.BadNoData;
}
currentRegion.Duration = (currentTime - currentRegion.StartTime).TotalMilliseconds;
}
regions.Add(currentRegion);
}
// start a new region.
currentRegion = new SubRegion();
currentRegion.StartValue = currentValue;
currentRegion.EndValue = currentValue;
currentRegion.StartTime = currentTime;
currentRegion.StatusCode = currentStatus;
currentRegion.DataPoint = values[ii];
}
return regions;
}
