public static SaveOutput SaveGame(TaleWorlds.Core.Game game, ISaveDriver driver) { EntitySystem <GameHandler> entitySystem = Utils.GetPrivateField <EntitySystem <GameHandler> >( typeof(TaleWorlds.Core.Game), "_gameEntitySystem", game); MetaData metaData = GetMetaData(); // Code copied from TaleWorlds.Game.Save(MetaData, ISaveDriver) foreach (GameHandler gameHandler in entitySystem.Components) { gameHandler.OnBeforeSave(); } SaveOutput saveOutput = SaveManager.Save(game, metaData, driver); saveOutput.PrintStatus(); foreach (GameHandler gameHandler2 in entitySystem.Components) { gameHandler2.OnAfterSave(); } // End code copy return(saveOutput); }
protected override async Task <List <int> > SaveExecuteAsync(List <EntryTypeForSave> entities, bool returnIds) { SaveOutput result = await _behavior.Repository.EntryTypes__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }
protected override async Task <List <int> > SaveExecuteAsync(List <DocumentDefinitionForSave> entities, bool returnIds) { #region Validate foreach (var(docDef, docDefIndex) in entities.Indexed()) { if (docDef.LineDefinitions == null || docDef.LineDefinitions.Count == 0) { string path = $"[{docDefIndex}].{nameof(DocumentDefinition.LineDefinitions)}"; string msg = _localizer["Error_OneLineDefinitionIsRquired"]; ModelState.AddError(path, msg); } else { // Line Definitions that are duplicated within the same document var duplicateIndices = docDef.LineDefinitions .Select((entity, index) => (entity.LineDefinitionId, index)) .GroupBy(pair => pair.LineDefinitionId) .Where(g => g.Count() > 1) .SelectMany(g => g) .Select((_, index) => index); foreach (var index in duplicateIndices) { string path = $"[{docDefIndex}].{nameof(DocumentDefinition.LineDefinitions)}[{index}].{nameof(DocumentDefinitionLineDefinition.LineDefinitionId)}"; string msg = _localizer["Error_DuplicateLineDefinition"]; ModelState.AddError(path, msg); } } } #endregion #region Save SaveOutput result = await _behavior.Repository.DocumentDefinitions__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); #endregion }
public static string ToFriendlyString(this SaveOutput save) { if (save.Successful) { return("Successful save."); } string sRet = "Errors during save:"; for (int i = 0; i < save.Errors.Length; i++) { sRet += Environment.NewLine + $"[{i}] {save.Errors[i]}"; } return(sRet); }
public static SaveOutput Save(object target, MetaData metaData, ISaveDriver driver) { if (SaveManager._definitionContext == null) { SaveManager.InitializeGlobalDefinitionContext(); } if (SaveManager._definitionContext.GotError) { List <SaveError> saveErrorList = new List <SaveError>(); foreach (string error in SaveManager._definitionContext.Errors) { saveErrorList.Add(new SaveError(error)); } return(SaveOutput.CreateFailed((IEnumerable <SaveError>)saveErrorList)); } using (new PerformanceTestBlock("Save Context")) { Debug.Print("Saving with new context"); SaveContext saveContext = new SaveContext(SaveManager._definitionContext); if (saveContext.Save(target, metaData)) { try { driver.Save(1, metaData, saveContext.SaveData); return(SaveOutput.CreateSuccessful(saveContext.SaveData)); } catch (Exception ex) { return(SaveOutput.CreateFailed((IEnumerable <SaveError>) new SaveError[1] { new SaveError(ex.Message) })); } } else { return(SaveOutput.CreateFailed((IEnumerable <SaveError>) new SaveError[1] { new SaveError("Not implemented") })); } } }
public byte[] SerializeInitialWorldState() { CampaignEventDispatcher.Instance.OnBeforeSave(); // Save to memory InMemDriver memStream = new InMemDriver(); SaveOutput save = null; GameLoopRunner.RunOnMainThread( () => save = SaveLoad.SaveGame(TaleWorlds.Core.Game.Current, memStream)); Logger.Info(save.ToFriendlyString()); // Write packet ByteWriter writer = new ByteWriter(); writer.Binary.Write((int)ECommand.InitialWorldState); writer.Binary.Write(save.Data.GetData()); return(writer.ToArray()); }
protected override async Task <List <int> > SaveExecuteAsync(List <ReportDefinitionForSave> entities, bool returnIds) { var defs = await _behavior.Definitions(); var settings = await _behavior.Settings(); foreach (var(entity, index) in entities.Indexed()) { if (entity.Roles.Any()) { if (string.IsNullOrWhiteSpace(entity.Title)) { string path = $"[{index}].{nameof(entity.Title)}"; string msg = _localizer["Error_TitleIsRequiredWhenShowInMainMenu"]; ModelState.AddError(path, msg); } } foreach (var(parameter, paramIndex) in entity.Parameters.Indexed()) { // TODO: Need to figure out how to retrieve the default control var errors = ApplicationUtil.ValidateControlOptions(parameter.Control, parameter.ControlOptions, _localizer, settings, defs); foreach (var msg in errors) { ModelState.AddError($"[{index}].{nameof(entity.Parameters)}[{paramIndex}].{nameof(parameter.ControlOptions)}", msg); } } } SaveOutput result = await _behavior.Repository.ReportDefinitions__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }
protected override async Task <List <int> > SaveExecuteAsync(List <ResourceDefinitionForSave> entities, bool returnIds) { foreach (var(entity, index) in entities.Select((e, i) => (e, i))) { if (entity.DefaultVatRate < 0m || entity.DefaultVatRate > 1m) { var path = $"[{index}].{nameof(ResourceDefinition.DefaultVatRate)}"; var msg = _localizer["Error_VatRateMustBeBetweenZeroAndOne"]; ModelState.AddError(path, msg); } } SaveOutput result = await _behavior.Repository.ResourceDefinitions__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }
public SaveOutput Execute(SaveInput input) { var output = new SaveOutput(); if (this.dbFileAccessService.Exists(input.currentDbFile) == false) { this.dbFileAccessService.CopyDbFile(input.masterDbFile, input.currentDbFile); } this.dbMigrationService.Upgrade(); this.projectSettingsAccessService.Update( input.StartDate, input.EndDate, input.Processes, input.Functions, input.Holidays, input.RestDays); this.memberAccessService.Update( input.Members); this.taskAccessService.Update( input.Tasks); this.processDependencyAccessService.Update( input.ProcessDependencies); this.functionDependencyAccessService.Update( input.FunctionDependencies); this.pertAccessService.Update( input.Edges); return(output); }
public static SaveGameData SaveGame(Game game, ISaveDriver driver) { EntitySystem <GameHandler> entitySystem = Utils.GetPrivateField <EntitySystem <GameHandler> >( typeof(Game), "_gameEntitySystem", game); MetaData metaData = GetMetaData(); foreach (GameHandler gameHandler in entitySystem.Components) { gameHandler.OnBeforeSave(); } SaveOutput saveOutput = SaveManager.Save(game, metaData, driver); saveOutput.PrintStatus(); foreach (GameHandler gameHandler2 in entitySystem.Components) { gameHandler2.OnAfterSave(); } return(new SaveGameData(metaData, saveOutput)); }
protected override async Task <List <int> > SaveExecuteAsync(List <DashboardDefinitionForSave> entities, bool returnIds) { #region Validate const int maxOffset = 1000; const int maxSize = 16; var defs = await _behavior.Definitions(); var settings = await _behavior.Settings(); foreach (var(entity, index) in entities.Indexed()) { if (entity.Roles.Any()) { if (string.IsNullOrWhiteSpace(entity.Title)) { string path = $"[{index}].{nameof(entity.Title)}"; string msg = _localizer["Error_TitleIsRequiredWhenShowInMainMenu"]; ModelState.AddError(path, msg); } } var duplicateReportIds = entity.Widgets .GroupBy(e => e.ReportDefinitionId) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToHashSet(); foreach (var(widget, widgetIndex) in entity.Widgets.Indexed()) { if (widget.OffsetX < 0) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.OffsetX)}"; string msg = _localizer["Error_TheField0CannotBeNegative", _localizer["DashboardDefinition_OffsetX"]]; ModelState.AddError(path, msg); } if (widget.OffsetX >= maxOffset) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.OffsetX)}"; string msg = _localizer["Error_Field0MaximumIs1", _localizer["DashboardDefinition_OffsetX"], maxOffset]; ModelState.AddError(path, msg); } if (widget.OffsetY < 0) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.OffsetY)}"; string msg = _localizer["Error_TheField0CannotBeNegative", _localizer["DashboardDefinition_OffsetY"]]; ModelState.AddError(path, msg); } if (widget.OffsetY >= maxOffset) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.OffsetY)}"; string msg = _localizer["Error_Field0MaximumIs1", _localizer["DashboardDefinition_OffsetY"], maxOffset]; ModelState.AddError(path, msg); } if (widget.Width < 0) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.Width)}"; string msg = _localizer["Error_TheField0CannotBeNegative", _localizer["DashboardDefinition_Width"]]; ModelState.AddError(path, msg); } if (widget.Width >= maxSize) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.Width)}"; string msg = _localizer["Error_Field0MaximumIs1", _localizer["DashboardDefinition_Width"], maxSize]; ModelState.AddError(path, msg); } if (widget.Height < 0) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.Height)}"; string msg = _localizer["Error_TheField0CannotBeNegative", _localizer["DashboardDefinition_Height"]]; ModelState.AddError(path, msg); } if (widget.Height >= maxSize) { string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.Height)}"; string msg = _localizer["Error_Field0MaximumIs1", _localizer["DashboardDefinition_Height"], maxSize]; ModelState.AddError(path, msg); } if (duplicateReportIds.Contains(widget.ReportDefinitionId)) { defs.Reports.TryGetValue(widget.ReportDefinitionId.Value, out ReportDefinitionForClient reportDef); string reportName = reportDef == null ? null : settings.Localize(reportDef.Title, reportDef.Title2, reportDef.Title3); string path = $"[{index}].{nameof(entity.Widgets)}[{widgetIndex}].{nameof(widget.ReportDefinitionId)}"; string msg = _localizer["Error_The01IsDuplicated", _localizer["DashboardDefinition_ReportDefinition"], reportName ?? widget.ReportDefinitionId.ToString()]; ModelState.AddError(path, msg); } } } #endregion #region Save // Save SaveOutput result = await _behavior.Repository.DashboardDefinitions__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); // Return return(result.Ids); #endregion }
protected override async Task <List <int> > SaveExecuteAsync(List <PrintingTemplateForSave> entities, bool returnIds) { var definitionedCollections = new string[] { nameof(Document), nameof(Resource), nameof(Agent), nameof(Lookup) }; foreach (var(entity, index) in entities.Indexed()) { if (entity.Usage == TemplateUsages.FromSearchAndDetails || entity.Usage == TemplateUsages.FromDetails) { if (entity.Collection == null) { ModelState.AddError($"[{index}].Collection", _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_Collection"]]); } else { if (definitionedCollections.Contains(entity.Collection)) { // DefinitionId is required when querying by Id if (entity.Usage == TemplateUsages.FromDetails && entity.DefinitionId == null) { ModelState.AddError($"[{index}].DefinitionId", _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_DefinitionId"]]); } } else { entity.DefinitionId = null; } } } if (entity.Usage == TemplateUsages.FromReport) { if (entity.ReportDefinitionId == null) { ModelState.AddError($"[{index}].ReportDefinitionId", _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_ReportDefinitionId"]]); } } // TODO Check that DefinitionId is compatible with Collection var duplicateKeys = entity .Parameters .Select(e => e.Key) .GroupBy(e => e) .Where(e => e.Count() > 1) .Select(e => e.FirstOrDefault()) .ToHashSet(); // Validate parameters foreach (var(parameter, parameterIndex) in entity.Parameters.Indexed()) { if (!TemplexVariable.IsValidVariableName(parameter.Key)) { var path = $"[{index}].{nameof(entity.Parameters)}[{parameterIndex}].{nameof(parameter.Key)}"; var msg = "Invalid Key. Valid keys contain only alphanumeric characters, dollar symbols, and underscores and do not start with a number."; ModelState.AddError(path, msg); } else if (duplicateKeys.Contains(parameter.Key)) { var path = $"[{index}].{nameof(entity.Parameters)}[{parameterIndex}].{nameof(parameter.Key)}"; var msg = $"The Key '{parameter.Key}' is used more than once."; ModelState.AddError(path, msg); } } } SaveOutput result = await _behavior.Repository.PrintingTemplates__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }
protected override async Task <List <int> > SaveExecuteAsync(List <ExchangeRateForSave> entities, bool returnIds) { #region Validate var settings = await _behavior.Settings(); var functionalId = settings.FunctionalCurrencyId; var currencyDateHash = entities .GroupBy(e => new { e.CurrencyId, e.ValidAsOf }) .Where(g => g.Count() > 1) .SelectMany(g => g) .ToHashSet(); // Get the currencies that contribute to duplications, so that we can put their names in the error message // Get them outside the loop in a single DB query (for performance) string[] duplicateCurrenciesIdArray = null; List <Currency> duplicateCurrencies = null; Dictionary <string, Currency> duplicateCurrenciesDictionary = null; foreach (var(entity, index) in entities.Select((e, i) => (e, i))) { // Currency cannot be functional if (entity.CurrencyId == functionalId) { ModelState.AddError($"[{index}].{nameof(ExchangeRate.CurrencyId)}", _localizer["Error_TheCurrencyMustBeDifferentThanFunctional"]); } if (entity.ValidAsOf > DateTime.Today.AddDays(1)) { ModelState.AddError($"[{index}].{nameof(ExchangeRate.ValidAsOf)}", _localizer["Error_TheValidAsOfDateCannotBeInTheFuture"]); } // Amounts must be >= 1 if (entity.AmountInCurrency <= 0m) { ModelState.AddError($"[{index}].{nameof(ExchangeRate.AmountInCurrency)}", _localizer["Error_TheAmountInCurrencyMustBeGreaterThanZero"]); } // Amounts must be >= 1 if (entity.AmountInFunctional <= 0m) { ModelState.AddError($"[{index}].{nameof(ExchangeRate.AmountInFunctional)}", _localizer["Error_TheAmountInFunctionalMustBeGreaterThanZero"]); } // Currency and date must not be duplicated in the uploaded list if (currencyDateHash.Contains(entity)) { // Populate these ones for efficient subsequent passes duplicateCurrenciesIdArray ??= currencyDateHash.Select(e => e.CurrencyId).Distinct().ToArray(); duplicateCurrencies ??= await _behavior.Repository.Currencies.FilterByIds(duplicateCurrenciesIdArray).ToListAsync(QueryContext, cancellation: default); duplicateCurrenciesDictionary ??= duplicateCurrencies.ToDictionary(e => e.Id); var currency = duplicateCurrenciesDictionary[entity.CurrencyId]; var currencyName = settings.Localize(currency.Name, currency.Name2, currency.Name3); ModelState.AddError($"[{index}].{nameof(ExchangeRate.CurrencyId)}", _localizer["Error_TheCurrency0Date1AreDuplicated", currencyName, entity.ValidAsOf.Value.ToString("yyyy-MM-dd")]); } } #endregion #region Save SaveOutput result = await _behavior.Repository.ExchangeRates__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); #endregion }
protected override async Task <List <int> > SaveExecuteAsync(List <NotificationTemplateForSave> entities, bool returnIds) { #region Validation var definitionedCollections = new string[] { nameof(Document), nameof(Resource), nameof(Agent), nameof(Lookup) }; foreach (var(entity, index) in entities.Indexed()) { if (entity.Cardinality == Cardinalities.Bulk) { // ListExpression if (string.IsNullOrWhiteSpace(entity.ListExpression)) { var path = $"[{index}].{nameof(entity.ListExpression)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_ListExpression"]]; ModelState.AddError(path, msg); } else { try { TemplexBase.Parse(entity.ListExpression); } catch { var path = $"[{index}].{nameof(entity.ListExpression)}"; var msg = _localizer["Error_InvalidTemplateExpression0", entity.ListExpression]; ModelState.AddError(path, msg); } } // AddressExpression if (string.IsNullOrWhiteSpace(entity.AddressExpression)) { var path = $"[{index}].{nameof(entity.AddressExpression)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_AddressExpression"]]; ModelState.AddError(path, msg); } else { try { TemplexBase.Parse(entity.AddressExpression); } catch { var path = $"[{index}].{nameof(entity.AddressExpression)}"; var msg = _localizer["Error_InvalidTemplateExpression0", entity.AddressExpression]; ModelState.AddError(path, msg); } } } if (entity.Trigger == Triggers.Automatic) { // Schedule if (string.IsNullOrWhiteSpace(entity.Schedule)) { var path = $"[{index}].{nameof(entity.Schedule)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_Schedule"]]; ModelState.AddError(path, msg); } else { string faultyCron = null; try { var crons = entity.Schedule.Split(';') .Where(e => !string.IsNullOrWhiteSpace(e)) .Select(e => e.Trim()); foreach (var cron in crons) { faultyCron = cron; CronExpression.Parse(cron); } } catch { var path = $"[{index}].{nameof(entity.Schedule)}"; var msg = _localizer["Error_InvalidCronExpression0", faultyCron]; ModelState.AddError(path, msg); } } if (string.IsNullOrWhiteSpace(entity.ConditionExpression)) { // Doesn't matter } else { try { TemplexBase.Parse(entity.ConditionExpression); } catch { var path = $"[{index}].{nameof(entity.ConditionExpression)}"; var msg = _localizer["Error_InvalidTemplateExpression0", entity.ConditionExpression]; ModelState.AddError(path, msg); } } } if (entity.Trigger == Triggers.Manual) { // Usage if (string.IsNullOrWhiteSpace(entity.Usage)) { var path = $"[{index}].{nameof(entity.Usage)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_Usage"]]; ModelState.AddError(path, msg); } else if (entity.Usage == TemplateUsages.FromSearchAndDetails || entity.Usage == TemplateUsages.FromDetails) { if (string.IsNullOrWhiteSpace(entity.Collection)) { var path = $"[{index}].{nameof(entity.Collection)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_Collection"]]; ModelState.AddError(path, msg); } else { if (definitionedCollections.Contains(entity.Collection)) { // DefinitionId is required when querying by Id if (entity.Usage == TemplateUsages.FromDetails && entity.DefinitionId == null) { var path = $"[{index}].{nameof(entity.DefinitionId)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_DefinitionId"]]; ModelState.AddError(path, msg); } } else { entity.DefinitionId = null; } } } else if (entity.Usage == TemplateUsages.FromReport) { if (entity.ReportDefinitionId == null) { var path = $"[{index}].{nameof(entity.ReportDefinitionId)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["Template_ReportDefinitionId"]]; ModelState.AddError(path, msg); } } // TODO Check that DefinitionId is compatible with Collection } if (entity.Channel == Channels.Email) { // Subject if (string.IsNullOrWhiteSpace(entity.Subject)) { var path = $"[{index}].{nameof(entity.Subject)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_Subject"]]; ModelState.AddError(path, msg); } else { try { TemplateTree.Parse(entity.Subject); } catch { var path = $"[{index}].{nameof(entity.Subject)}"; var msg = _localizer["Error_InvalidTemplate"]; ModelState.AddError(path, msg); } } } // Body if (!string.IsNullOrWhiteSpace(entity.Body)) { if (entity.Channel == Channels.Sms) { const int maxSmsExpressionLength = 1024; if (entity.Body.Length > maxSmsExpressionLength) { var path = $"[{index}].{nameof(entity.Body)}"; var msg = _localizer[ErrorMessages.Error_Field0LengthMaximumOf1, _localizer["Template_Body"], maxSmsExpressionLength]; ModelState.AddError(path, msg); } } try { TemplateTree.Parse(entity.Body); } catch { var path = $"[{index}].{nameof(entity.Body)}"; var msg = _localizer["Error_InvalidTemplate"]; ModelState.AddError(path, msg); } } // Caption try { TemplateTree.Parse(entity.Caption); } catch { var path = $"[{index}].{nameof(entity.Caption)}"; var msg = _localizer["Error_InvalidTemplate"]; ModelState.AddError(path, msg); } var duplicateKeys = entity .Parameters .Select(e => e.Key) .GroupBy(e => e) .Where(e => e.Count() > 1) .Select(e => e.FirstOrDefault()) .ToHashSet(); // Parameters foreach (var(parameter, parameterIndex) in entity.Parameters.Indexed()) { if (!TemplexVariable.IsValidVariableName(parameter.Key)) { var path = $"[{index}].{nameof(entity.Parameters)}[{parameterIndex}].{nameof(parameter.Key)}"; var msg = "Invalid Key. Valid keys contain only alphanumeric characters, dollar symbols, and underscores and do not start with a number."; ModelState.AddError(path, msg); } else if (duplicateKeys.Contains(parameter.Key)) { var path = $"[{index}].{nameof(entity.Parameters)}[{parameterIndex}].{nameof(parameter.Key)}"; var msg = $"The Key '{parameter.Key}' is used more than once."; ModelState.AddError(path, msg); } } // Attachments foreach (var(attachment, attachmentIndex) in entity.Attachments.Indexed()) { if (!string.IsNullOrWhiteSpace(attachment.ContextOverride)) { try { TemplexBase.Parse(attachment.ContextOverride); } catch { var path = $"[{index}].{nameof(entity.Attachments)}[{attachmentIndex}].{nameof(attachment.ContextOverride)}"; var msg = _localizer["Error_InvalidTemplateExpression0", attachment.ContextOverride]; ModelState.AddError(path, msg); } } if (!string.IsNullOrWhiteSpace(attachment.DownloadNameOverride)) { try { TemplateTree.Parse(attachment.DownloadNameOverride); } catch { var path = $"[{index}].{nameof(entity.Attachments)}[{attachmentIndex}].{nameof(attachment.DownloadNameOverride)}"; var msg = _localizer["Error_InvalidTemplate0", attachment.DownloadNameOverride]; ModelState.AddError(path, msg); } } } // Subscribers foreach (var(subscriber, subscriberIndex) in entity.Subscribers.Indexed()) { if (subscriber.AddressType == AddressTypes.User) { if (subscriber.UserId == null) { var path = $"[{index}].{nameof(entity.Subscribers)}[{subscriberIndex}].{nameof(subscriber.UserId)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_User"]]; ModelState.AddError(path, msg); } } if (subscriber.AddressType == AddressTypes.Text) { if (entity.Channel == Channels.Email) { if (string.IsNullOrWhiteSpace(subscriber.Email)) { var path = $"[{index}].{nameof(entity.Subscribers)}[{subscriberIndex}].{nameof(subscriber.Email)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_Email"]]; ModelState.AddError(path, msg); } else { try { TemplateTree.Parse(subscriber.Email); } catch { var path = $"[{index}].{nameof(entity.Subscribers)}[{subscriberIndex}].{nameof(subscriber.Email)}"; var msg = _localizer["Error_InvalidTemplate"]; ModelState.AddError(path, msg); } } } if (entity.Channel == Channels.Sms) { if (string.IsNullOrWhiteSpace(subscriber.Phone)) { var path = $"[{index}].{nameof(entity.Subscribers)}[{subscriberIndex}].{nameof(subscriber.Phone)}"; var msg = _localizer[ErrorMessages.Error_Field0IsRequired, _localizer["NotificationTemplate_Phone"]]; ModelState.AddError(path, msg); } else { try { TemplateTree.Parse(subscriber.Phone); } catch { var path = $"[{index}].{nameof(entity.Subscribers)}[{subscriberIndex}].{nameof(subscriber.Phone)}"; var msg = _localizer["Error_InvalidTemplate"]; ModelState.AddError(path, msg); } } } } } } #endregion SaveOutput result = await _behavior.Repository.NotificationTemplates__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }
public SaveGameData([NotNull] MetaData metaData, [NotNull] SaveOutput saveOutput) { MetaData = metaData; SaveOutput = saveOutput; }
protected override async Task <List <int> > SaveExecuteAsync(List <RoleForSave> entities, bool returnIds) { // Hash the indices for performance var indices = entities.ToIndexDictionary(); // Check that line ids are unique entities.ForEach(e => { if (e.Permissions == null) { e.Permissions = new List <PermissionForSave>(); } }); var duplicatePermissionId = entities.SelectMany(e => e.Permissions) // All lines .Where(e => e.Id != 0).GroupBy(e => e.Id).Where(g => g.Count() > 1) // Duplicate Ids .SelectMany(g => g).ToDictionary(e => e, e => e.Id); // to dictionary // Check that line ids are unique entities.ForEach(e => { if (e.Members == null) { e.Members = new List <RoleMembershipForSave>(); } }); var duplicateMembershipId = entities.SelectMany(e => e.Members) // All lines .Where(e => e.Id != 0).GroupBy(e => e.Id).Where(g => g.Count() > 1) // Duplicate Ids .SelectMany(g => g).ToDictionary(e => e, e => e.Id); // to dictionary foreach (var entity in entities) { var permissionIndices = entity.Permissions.ToIndexDictionary(); foreach (var line in entity.Permissions) { if (duplicatePermissionId.ContainsKey(line)) { // This error indicates a bug var index = indices[entity]; var lineIndex = permissionIndices[line]; var id = duplicatePermissionId[line]; ModelState.AddError($"[{index}].{nameof(entity.Permissions)}[{lineIndex}].{nameof(entity.Id)}", _localizer["Error_TheEntityWithId0IsSpecifiedMoreThanOnce", id]); } } var membersIndices = entity.Members.ToIndexDictionary(); foreach (var line in entity.Members) { if (duplicateMembershipId.ContainsKey(line)) { // This error indicates a bug var index = indices[entity]; var lineIndex = membersIndices[line]; var id = duplicateMembershipId[line]; ModelState.AddError($"[{index}].{nameof(entity.Members)}[{lineIndex}].{nameof(entity.Id)}", _localizer["Error_TheEntityWithId0IsSpecifiedMoreThanOnce", id]); } } } // TODO Validate Criteria // Save SaveOutput result = await _behavior.Repository.Roles__Save( entities : entities, returnIds : returnIds, validateOnly : ModelState.IsError, top : ModelState.RemainingErrors, userId : UserId); AddErrorsAndThrowIfInvalid(result.Errors); return(result.Ids); }