private RulesetActionRule BuildRulesetActionRule(ScrimActionType actionType, int points = 0, bool deferToItemCategoryRules = false)
{
return(new RulesetActionRule
{
ScrimActionType = actionType,
Points = points,
DeferToItemCategoryRules = deferToItemCategoryRules,
ScrimActionTypeDomain = ScrimAction.GetDomainFromActionType(actionType)
});
}
private ScrimAction ConvertToDbModel(ScrimActionType value)
{
var name = Enum.GetName(typeof(ScrimActionType), value);
return(new ScrimAction
{
Action = value,
Name = name,
Description = Regex.Replace(name, @"(\p{Ll})(\p{Lu})", "$1 $2"),
Domain = ScrimAction.GetDomainFromActionType(value)
});
}
public void Update(ScrimRollDto scrimRollDto, ScrimActionDto scrimActionDto)
{
try
{
var scrimRoll = new ScrimRoll();
Mapper.Map(scrimRollDto, scrimRoll);
_repository.Repository <ScrimRoll>().Update(scrimRoll);
//CommitUnitOfWork();
var scrimAction = new ScrimAction();
Mapper.Map(scrimActionDto, scrimAction);
if (scrimAction.ID > 0)
{
_repository.Repository <ScrimAction>().Update(scrimAction);
}
else
{
_repository.Repository <ScrimAction>().Insert(scrimAction);
}
CommitUnitOfWork();
}
catch (DbEntityValidationException valEx)
{
var sb = new StringBuilder();
foreach (var failure in valEx.EntityValidationErrors)
{
sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
foreach (var error in failure.ValidationErrors)
{
sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
sb.AppendLine();
}
}
throw new DbEntityValidationException(
"Entity Validation Failed - errors follow:\n" +
sb.ToString(), valEx
); // Add the original exception as the innerException
}
catch (Exception ex)
{
LogException(ex);
throw;
}
}
private void UpdateScrimUsageEntryForContractorRoll(TPOCProductRollDto tpoCProductRollDto, double divisor)
{
DateTime now = DateTime.Now;
TPOBatch batch = _repository.Repository <TPOBatch>().GetAllBy(b => b.BatchNumber == tpoCProductRollDto.BatchNumber && b.IsScrim == true).FirstOrDefault();
ScrimRoll roll = _repository.Repository <ScrimRoll>().GetById(batch.ScrimRollID);
ScrimActionType type = _repository.Repository <ScrimActionType>().GetAllBy(t => t.Code == "PR" && t.PlantID == tpoCProductRollDto.PlantID).FirstOrDefault();
double actionLength = (double)ConvertUoM(tpoCProductRollDto.Length, tpoCProductRollDto.LengthUoMID, roll.LengthUoMID) / divisor;
double actionWeight = (double)ConvertUoM(tpoCProductRollDto.Weight, tpoCProductRollDto.WeightUoMID, roll.WeightUoMID) / divisor;
ScrimAction action = new ScrimAction()
{
ActionDate = now,
ActionLength = actionLength,
ActionReasonText = "Production Entry",
ActionWeight = actionWeight,
DateEntered = now,
EndLength = roll.Length - actionLength,
EndWeight = roll.Weight - actionWeight,
EnteredBy = tpoCProductRollDto.ModifiedBy,
FleeceProd = false,
LastModified = now,
LineID = tpoCProductRollDto.LineID,
ModifiedBy = tpoCProductRollDto.ModifiedBy,
PlantID = tpoCProductRollDto.PlantID,
ReasonID = null,
RollID = null,
ScrimRollID = roll.ID,
ShiftID = tpoCProductRollDto.ShiftID,
StartLength = roll.Length,
StartWeight = roll.Weight,
TypeID = type.ID
};
_repository.Repository <ScrimAction>().Insert(action);
}
public async Task SeedDefaultRuleset()
{
_logger.LogInformation($"Seeding Default Ruleset...");
var stopWatchSetup = new Stopwatch();
var stopWatchCollections = new Stopwatch();
var stopWatchOverlay = new Stopwatch();
var stopWatchActionRules = new Stopwatch();
var stopWatchItemRules = new Stopwatch();
var stopWatchItemCategoryRules = new Stopwatch();
var stopWatchFacilityRules = new Stopwatch();
var stopWatchFinalize = new Stopwatch();
var stopWatchTotal = Stopwatch.StartNew();
stopWatchSetup.Start();
using var factory = _dbContextHelper.GetFactory();
var dbContext = factory.GetDbContext();
var defaultRulesetId = _defaultRulesetId;
var storeRuleset = await dbContext.Rulesets.FirstOrDefaultAsync(r => r.Id == defaultRulesetId);
bool rulesetExistsInDb = false;
RulesetOverlayConfiguration storeOverlayConfiguration = null;
var storeActionRules = new List <RulesetActionRule>();
var storeItemCategoryRules = new List <RulesetItemCategoryRule>();
var storeItemRules = new List <RulesetItemRule>();
var storeFacilityRules = new List <RulesetFacilityRule>();
if (storeRuleset != null)
{
stopWatchCollections.Start();
var storeRulesetWithCollections = await _rulesetDataService.GetRulesetFromIdAsync(storeRuleset.Id, CancellationToken.None, true, true);
storeOverlayConfiguration = storeRulesetWithCollections.RulesetOverlayConfiguration;
storeActionRules = storeRulesetWithCollections.RulesetActionRules.ToList();
storeItemCategoryRules = storeRulesetWithCollections.RulesetItemCategoryRules.ToList();
storeItemRules = storeRulesetWithCollections.RulesetItemRules.ToList();
storeFacilityRules = storeRulesetWithCollections.RulesetFacilityRules.ToList();
rulesetExistsInDb = true;
stopWatchCollections.Stop();
}
else
{
var utcNow = DateTime.UtcNow;
var newRuleset = new Ruleset
{
Name = "Default",
DateCreated = utcNow
};
storeRuleset = newRuleset;
}
storeRuleset.DefaultMatchTitle = "PS2 Scrims";
storeRuleset.IsDefault = true;
storeRuleset.DefaultEndRoundOnFacilityCapture = false;
// Get all async collection requests together
var CollectionsTaskList = new List <Task>();
var allItemCategoryIdsTask = _itemCategoryService.GetItemCategoryIdsAsync();
CollectionsTaskList.Add(allItemCategoryIdsTask);
var allWeaponItemCategoryIdsTask = _itemCategoryService.GetWeaponItemCategoryIdsAsync();
CollectionsTaskList.Add(allWeaponItemCategoryIdsTask);
var allWeaponItemsTask = _itemService.GetAllWeaponItemsAsync();
CollectionsTaskList.Add(allWeaponItemsTask);
await Task.WhenAll(CollectionsTaskList);
var allItemCategoryIds = allItemCategoryIdsTask.Result;
var allWeaponItemCategoryIds = allWeaponItemCategoryIdsTask.Result;
var allWeaponItems = allWeaponItemsTask.Result;
stopWatchSetup.Stop();
stopWatchOverlay.Start();
#region Overlay Configuration
if (storeOverlayConfiguration == null)
{
storeOverlayConfiguration = new RulesetOverlayConfiguration()
{
RulesetId = _defaultRulesetId,
UseCompactLayout = false,
StatsDisplayType = OverlayStatsDisplayType.InfantryScores,
ShowStatusPanelScores = null
};
dbContext.RulesetOverlayConfigurations.Add(storeOverlayConfiguration);
}
else
{
storeOverlayConfiguration.UseCompactLayout = false;
storeOverlayConfiguration.StatsDisplayType = OverlayStatsDisplayType.InfantryScores;
storeOverlayConfiguration.ShowStatusPanelScores = null;
dbContext.RulesetOverlayConfigurations.Update(storeOverlayConfiguration);
}
#endregion Overlay Configuration
stopWatchOverlay.Stop();
stopWatchActionRules.Start();
#region Action rules
var defaultActionRules = GetDefaultActionRules();
var createdActionRules = new List <RulesetActionRule>();
var allActionRules = new List <RulesetActionRule>();
var allActionEnumValues = GetScrimActionTypes().Where(a => a != ScrimActionType.None && a != ScrimActionType.Login && a != ScrimActionType.Logout);
var allActionValues = new List <ScrimActionType>();
allActionValues.AddRange(allActionEnumValues);
allActionValues.AddRange(storeActionRules.Select(ar => ar.ScrimActionType).Where(a => !allActionValues.Contains(a)).ToList());
foreach (var actionType in allActionValues)
{
var storeEntity = storeActionRules?.FirstOrDefault(r => r.ScrimActionType == actionType);
var defaultEntity = defaultActionRules.FirstOrDefault(r => r.ScrimActionType == actionType);
var isValidAction = storeEntity == null || allActionEnumValues.Any(enumValue => enumValue == storeEntity.ScrimActionType);
if (storeEntity == null)
{
if (defaultEntity != null)
{
defaultEntity.RulesetId = defaultRulesetId;
createdActionRules.Add(defaultEntity);
allActionRules.Add(defaultEntity);
}
else
{
var newEntity = BuildRulesetActionRule(defaultRulesetId, actionType, 0);
createdActionRules.Add(newEntity);
allActionRules.Add(newEntity);
}
}
else if (isValidAction)
{
if (defaultEntity != null)
{
storeEntity.Points = defaultEntity.Points;
storeEntity.DeferToItemCategoryRules = defaultEntity.DeferToItemCategoryRules;
storeEntity.ScrimActionTypeDomain = defaultEntity.ScrimActionTypeDomain;
}
else
{
storeEntity.Points = 0;
storeEntity.ScrimActionTypeDomain = ScrimAction.GetDomainFromActionType(storeEntity.ScrimActionType);
}
dbContext.RulesetActionRules.Update(storeEntity);
allActionRules.Add(storeEntity);
}
else
{
dbContext.RulesetActionRules.Remove(storeEntity);
}
}
if (createdActionRules.Any())
{
dbContext.RulesetActionRules.AddRange(createdActionRules);
}
#endregion Action rules
stopWatchActionRules.Stop();
stopWatchItemCategoryRules.Start();
#region Item Category Rules
var defaultItemCategoryRules = GetDefaultItemCategoryRules();
var createdItemCategoryRules = new List <RulesetItemCategoryRule>();
var allItemCategoryRules = new List <RulesetItemCategoryRule>();
foreach (var categoryId in allItemCategoryIds)
{
var isWeaponItemCategoryId = (allWeaponItemCategoryIds.Contains(categoryId));
var storeEntity = storeItemCategoryRules?.FirstOrDefault(r => r.ItemCategoryId == categoryId);
var defaultEntity = defaultItemCategoryRules.FirstOrDefault(r => r.ItemCategoryId == categoryId);
if (storeEntity == null)
{
if (defaultEntity != null)
{
defaultEntity.RulesetId = defaultRulesetId;
createdItemCategoryRules.Add(defaultEntity);
allItemCategoryRules.Add(defaultEntity);
}
else if (isWeaponItemCategoryId)
{
var newEntity = BuildRulesetItemCategoryRule(defaultRulesetId, categoryId, 0);
createdItemCategoryRules.Add(newEntity);
allItemCategoryRules.Add(newEntity);
}
}
else
{
if (isWeaponItemCategoryId)
{
storeEntity.Points = defaultEntity != null ? defaultEntity.Points : 0;
storeEntity.IsBanned = defaultEntity != null ? defaultEntity.IsBanned : false;
storeEntity.DeferToItemRules = defaultEntity != null ? defaultEntity.DeferToItemRules : false;
dbContext.RulesetItemCategoryRules.Update(storeEntity);
allItemCategoryRules.Add(storeEntity);
}
else
{
dbContext.RulesetItemCategoryRules.Remove(storeEntity);
}
}
}
if (createdItemCategoryRules.Any())
{
dbContext.RulesetItemCategoryRules.AddRange(createdItemCategoryRules);
}
#endregion Item Category Rules
stopWatchItemCategoryRules.Stop();
stopWatchItemRules.Start();
#region Item Rules
var defaultItemRules = GetDefaultItemRules();
var createdItemRules = new List <RulesetItemRule>();
var allItemIds = new List <int>(defaultItemRules.Select(r => r.ItemId));
if (storeItemRules != null)
{
allItemIds.AddRange(storeItemRules.Where(r => !allItemIds.Contains(r.ItemId)).Select(r => r.ItemId));
}
if (allWeaponItems != null)
{
allItemIds.AddRange(allWeaponItems.Where(r => !allItemIds.Contains(r.Id)).Select(r => r.Id));
}
var allItemRules = new List <RulesetItemRule>();
foreach (var itemId in allItemIds)
{
var isWeaponItem = (allWeaponItems.Any(r => r.Id == itemId));
var storeEntity = storeItemRules?.FirstOrDefault(r => r.ItemId == itemId);
var defaultEntity = defaultItemRules.FirstOrDefault(r => r.ItemId == itemId);
var categoryId = allWeaponItems.Where(i => i.Id == itemId).Select(i => i.ItemCategoryId).FirstOrDefault();
var categoryDefersToItems = false;
if (categoryId != null)
{
categoryDefersToItems = allItemCategoryRules.Any(r => r.ItemCategoryId == categoryId && r.DeferToItemRules);
}
if (storeEntity == null)
{
if (defaultEntity != null)
{
defaultEntity.RulesetId = defaultRulesetId;
createdItemRules.Add(defaultEntity);
allItemRules.Add(defaultEntity);
}
else if (isWeaponItem && categoryDefersToItems)
{
var defaultPoints = allItemCategoryRules.Where(r => r.ItemCategoryId == categoryId).Select(r => r.Points).FirstOrDefault();
var newEntity = BuildRulesetItemRule(defaultRulesetId, itemId, (int)categoryId, defaultPoints, false);
createdItemRules.Add(newEntity);
allItemRules.Add(newEntity);
}
}
else
{
if (defaultEntity != null)
{
if (categoryId != null && categoryId != defaultEntity.ItemCategoryId)
{
defaultEntity.ItemCategoryId = (int)categoryId;
}
defaultEntity.RulesetId = defaultRulesetId;
storeEntity = defaultEntity;
dbContext.RulesetItemRules.Update(storeEntity);
allItemRules.Add(storeEntity);
}
else if (!isWeaponItem || !categoryDefersToItems)
{
dbContext.RulesetItemRules.Remove(storeEntity);
}
}
}
if (createdItemRules.Any())
{
dbContext.RulesetItemRules.AddRange(createdItemRules);
}
#endregion Item Rules
stopWatchItemRules.Stop();
stopWatchFacilityRules.Start();
#region Facility Rules
var defaultFacilityRules = GetDefaultFacilityRules();
var createdFacilityRules = new List <RulesetFacilityRule>();
var allFacilityRules = new List <RulesetFacilityRule>(storeFacilityRules);
allFacilityRules.AddRange(defaultFacilityRules.Where(d => !allFacilityRules.Any(a => a.FacilityId == d.FacilityId)));
foreach (var facilityRule in allFacilityRules)
{
var storeEntity = storeFacilityRules?.FirstOrDefault(r => r.FacilityId == facilityRule.FacilityId);
var defaultEntity = defaultFacilityRules.FirstOrDefault(r => r.FacilityId == facilityRule.FacilityId);
if (storeEntity == null)
{
if (defaultEntity != null)
{
defaultEntity.RulesetId = defaultRulesetId;
createdFacilityRules.Add(defaultEntity);
}
}
else
{
if (defaultEntity == null)
{
dbContext.RulesetFacilityRules.Remove(storeEntity);
allFacilityRules.Remove(storeEntity);
}
}
}
if (createdFacilityRules.Any())
{
dbContext.RulesetFacilityRules.AddRange(createdFacilityRules);
}
#endregion Facility Rules
stopWatchFacilityRules.Stop();
stopWatchFinalize.Start();
storeRuleset.RulesetOverlayConfiguration = storeOverlayConfiguration;
storeRuleset.RulesetActionRules = allActionRules;
storeRuleset.RulesetItemCategoryRules = allItemCategoryRules;
storeRuleset.RulesetItemRules = allItemRules;
storeRuleset.RulesetFacilityRules = allFacilityRules;
if (rulesetExistsInDb)
{
dbContext.Rulesets.Update(storeRuleset);
}
else
{
dbContext.Rulesets.Add(storeRuleset);
}
await dbContext.SaveChangesAsync();
stopWatchFinalize.Stop();
stopWatchTotal.Stop();
var elapsedMs = stopWatchTotal.ElapsedMilliseconds;
var totalTime = $"Finished seeding Default Ruleset (elapsed: {elapsedMs / 1000.0}s)";
var setupTime = $"\n\t\t Setup: {stopWatchSetup.ElapsedMilliseconds / 1000.0}s";
var collectionsTime = $"\n\t\t\t Get Collections: {stopWatchCollections.ElapsedMilliseconds / 1000.0}s";
var overlayTime = $"\n\t\t\t Overlay Configuration: {stopWatchOverlay.ElapsedMilliseconds / 1000.0}s";
var actionsTime = $"\n\t\t Action Rules: {stopWatchActionRules.ElapsedMilliseconds / 1000.0}s";
var itemCatsTime = $"\n\t\t Item Category Rules: {stopWatchItemCategoryRules.ElapsedMilliseconds / 1000.0}s";
var itemsTime = $"\n\t\t Item Rules: {stopWatchItemRules.ElapsedMilliseconds / 1000.0}s";
var facilitiesTime = $"\n\t\t Facility Rules: {stopWatchFacilityRules.ElapsedMilliseconds / 1000.0}s";
var finalizeTime = $"\n\t\t Finalize: {stopWatchFinalize.ElapsedMilliseconds / 1000.0}s";
_logger.LogInformation($"{totalTime}{setupTime}{collectionsTime}{overlayTime}{actionsTime}{itemCatsTime}{itemsTime}{facilitiesTime}{finalizeTime}");
}
