public void Initialize()
        {
            try
            {
                var language        = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
                var dictionaryItems = new List <Type>();

                if (!language.CheckExists(typeof(Receipt_Gift_ParentKey)))
                {
                    dictionaryItems.Add(typeof(Receipt_Gift_ParentKey));
                }

                if (!language.CheckExists(typeof(Receipt_Gift)))
                {
                    dictionaryItems.Add(typeof(Receipt_Gift));
                }

                if (!language.CheckExists(typeof(Receipt_Bonus)))
                {
                    dictionaryItems.Add(typeof(Receipt_Bonus));
                }

                language.CreateDictionaryItems(dictionaryItems);
            }
            catch (System.Exception ex)
            {
                _logger.Error(typeof(_43_ReceiptMigration), ex.Message);
                _logger.Error(typeof(_43_ReceiptMigration), ex.StackTrace);
            }
        }
 public HomeContentNode(IContentService contentService, ILocalizationService localizationService, IDomainService domainService, IContentTypeService contentTypeService, ILogger logger)
 {
     this.contentService            = contentService;
     this.contentTypeService        = contentTypeService;
     this.logger                    = logger;
     this.languageDictionaryService = new LanguageDictionaryService(localizationService, domainService, logger);
     this.nodeHelper                = new NodeHelper();
 }
        private void Reconfigure()
        {
            try
            {
                // Create the Template if it doesn't exist
                if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
                {
                    //then create the template
                    Template  newTemplate    = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
                    ITemplate masterTemplate = fileService.GetTemplate(PARENT_TEMPLATE_ALIAS);
                    newTemplate.SetMasterTemplate(masterTemplate);
                    fileService.SaveTemplate(newTemplate);

                    // Set template for document type
                    var genericDocType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
                    genericDocType.AddTemplate(contentTypeService, newTemplate);

                    ContentHelper.CopyPhysicalAssets(new ReconfigureSportsPageEmbeddedResources());

                    ConnectorContext.AuditService.Add(AuditType.Save, -1, newTemplate.Id, "Template", $"Teplate '{TEMPLATE_NAME}' has been created and assigned");
                }

                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(localizationService, domainService, logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Pages_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(Pages_ParentKey),
                            typeof(Pages_SportsPage),
                            typeof(Pages_SportEvents),
                            typeof(Pages_SportEventsEventName),
                            typeof(Pages_SportEventsEventScheduleTime),
                            typeof(Pages_SportEventsEventStatusDescription),
                            typeof(Pages_SportEventsEventTournament),
                            typeof(Pages_SportEventsEventCategory),
                            typeof(Pages_SportEventsEventCategorySport),
                            typeof(Pages_SportEventsNoEvents)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items
                    }
                }
            }

            catch (Exception ex)
            {
                logger.Error(typeof(_08_SportsPageIntegration), ex.Message);
                logger.Error(typeof(_08_SportsPageIntegration), ex.StackTrace);
            }
        }
Exemple #4
0
        private void CreateDictionaryItems()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(localizationService, domainService, logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Login_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(Login_ParentKey),
                            typeof(Login_EmailUsernameOrPhone),
                            typeof(Login_EmailUsernameOrPhonePlaceholder),
                            typeof(Login_ForgotPassword),
                            typeof(Login_Password),
                            typeof(Login_RememberMe),
                            typeof(Login_Login),
                            typeof(Login_DontHaveAccount),
                            typeof(Login_LoginSuccess),
                            typeof(Login_LoginFailure)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                    }
                }

                var firstEmbeddedResource = new LoginEmbeddedResources().Resources[0];
                if (!ContentHelper.AssetAlreadyExists(firstEmbeddedResource.FileName, firstEmbeddedResource.OutputDirectory))
                {
                    ContentHelper.CopyPhysicalAssets(new LoginEmbeddedResources());
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_05_Phase2Milestone7DictionaryMigration), ex.Message);
                logger.Error(typeof(_05_Phase2Milestone7DictionaryMigration), ex.StackTrace);
            }
        }
        private void InsertDictionaries()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language        = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
                    var dictionaryItems = new List <Type>();

                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Genders_ParentKey)))
                    {
                        dictionaryItems.Add(typeof(Genders_ParentKey));
                    }

                    if (!language.CheckExists(typeof(Genders_Male)))
                    {
                        dictionaryItems.Add(typeof(Genders_Male));
                    }

                    if (!language.CheckExists(typeof(Genders_Female)))
                    {
                        dictionaryItems.Add(typeof(Genders_Female));
                    }

                    if (!language.CheckExists(typeof(Genders_Unknown)))
                    {
                        dictionaryItems.Add(typeof(Genders_Unknown));
                    }


                    language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                    ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Item", $"Gender Dictionary Items have been created/updated");
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_32_GenderDictionaries), ex.Message);
                logger.Error(typeof(_32_GenderDictionaries), ex.StackTrace);
            }
        }
Exemple #6
0
        private void CreateDictionaryLanguage()
        {
            try
            {
                var language        = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
                var dictionaryItems = new List <Type>();

                // Check if parent Key exists, and skip if true
                if (!language.CheckExists(typeof(BonusTransaction_ParentKey)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_ParentKey));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Name)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Name));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Type)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Type));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Status)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Status));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionStatus)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionStatus));
                }

                if (!language.CheckExists(typeof(BonusTransaction_BonusApplied)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_BonusApplied));
                }

                if (!language.CheckExists(typeof(BonusTransaction_DepositBonus)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_DepositBonus));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Active)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Active));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Closed)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Closed));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Completed)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Completed));
                }

                if (!language.CheckExists(typeof(BonusTransaction_Incomplete)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_Incomplete));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionName)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionName));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionQualifierDifference)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionQualifierDifference));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionQualifierProgress)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionQualifierProgress));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionQualifierRequirement)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionQualifierRequirement));
                }

                if (!language.CheckExists(typeof(BonusTransaction_RedemptionStatus)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_RedemptionStatus));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalBetAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalBetAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalCasinoAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalCasinoAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalDepositAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalDepositAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalLiveCasinoAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalLiveCasinoAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalLotteryAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalLotteryAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalPokerAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalPokerAmount));
                }

                if (!language.CheckExists(typeof(BonusTransaction_TotalSportsbookAmount)))
                {
                    dictionaryItems.Add(typeof(BonusTransaction_TotalSportsbookAmount));
                }

                language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items
            }
            catch (System.Exception ex)
            {
                logger.Error(typeof(_35_BonusHistoryPageDocumentType), ex.Message);
                logger.Error(typeof(_35_BonusHistoryPageDocumentType), ex.StackTrace);
            }
        }
Exemple #7
0
        private void InsertDictionaries()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language        = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
                    var dictionaryItems = new List <Type>();
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(ServerErrors_ParentKey)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ParentKey));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_MissingField)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_MissingField));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidEmailFormat)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidEmailFormat));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidDate)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidDate));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidAge)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidAge));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_MobileOrEmailRequired)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_MobileOrEmailRequired));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidCountry)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidCountry));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidCurrency)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidCurrency));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidLanguage)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidLanguage));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidTimeZone)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidTimeZone));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ExistingCustomer)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ExistingCustomer));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_EmailNotFound)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_EmailNotFound));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_EmailSendFail)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_EmailSendFail));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ChangePassword)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ChangePassword));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidCustomer)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidCustomer));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidOldPassword)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidOldPassword));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_MatchingOldAndNewPassword)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_MatchingOldAndNewPassword));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidCustomerStatus)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidCustomerStatus));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_CustomerNotFound)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_CustomerNotFound));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_VerificationRecordNotFound)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_VerificationRecordNotFound));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_VerificationEmailExpired)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_VerificationEmailExpired));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ValidationCodeExpired)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ValidationCodeExpired));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ValidationCodeSendFail)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ValidationCodeSendFail));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_SMSSendFail)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_SMSSendFail));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidMobileNumber)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidMobileNumber));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidVerificationEmail)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidVerificationEmail));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_VerificationCodeLimitExceeded)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_VerificationCodeLimitExceeded));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_MobileNumberNotFound)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_MobileNumberNotFound));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ValidationCodeInvalid)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ValidationCodeInvalid));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_UnhandledError)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_UnhandledError));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_FieldRequired)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_FieldRequired));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_BelowMinimumWithdrawalAmount)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_BelowMinimumWithdrawalAmount));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InsufficientBalance)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InsufficientBalance));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_UsernameCannotBeEmailAddress)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_UsernameCannotBeEmailAddress));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidLogin)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidLogin));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_Other)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_Other));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_AccountLocked)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_AccountLocked));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ExceedsMaximalWithdrawal)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_ExceedsMaximalWithdrawal));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidCard)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidCard));
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidIBAN)))
                    {
                        dictionaryItems.Add(typeof(ServerErrors_InvalidIBAN));
                    }

                    language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                    ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Item", $"Server Error Dictionary Items have been created/updated");
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_25_ServerErrorsDictionaries), ex.Message);
                logger.Error(typeof(_25_ServerErrorsDictionaries), ex.StackTrace);
            }
        }
        private void UpdateHomeDocumentType()
        {
            try
            {
                var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);

                var container = contentTypeService.GetContainers(CONTAINER, 1).FirstOrDefault();

                if (contentType != null)
                {
                    if (contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "termsAndConditionsMessage") == null)
                    {
                        // Add Document Type Properties
                        #region Tenant Home Page Content
                        PropertyType termsAndConditionsMessagePropType = new PropertyType(dataTypeService.GetDataType(-88), "termsAndConditionsMessage")
                        {
                            Name        = "Terms and Conditions",
                            Description = "Message to display for required accepting Terms and Conditions",
                            Variations  = ContentVariation.Culture
                        };
                        contentType.AddPropertyType(termsAndConditionsMessagePropType, CONTENT_TAB);
                        #endregion

                        contentTypeService.Save(contentType);
                        ConnectorContext.AuditService.Add(AuditType.New, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");

                        ContentHelper.CopyPhysicalAssets(new RegisterUpdateHomeEmbeddedResources());
                        //CreateMasterTemplate();
                    }

                    var telegramUsername = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "telegramUsername");
                    if (telegramUsername != null)
                    {
                        if (telegramUsername.Name != "Telegram URL")
                        {
                            telegramUsername.Name        = "Telegram URL";
                            telegramUsername.Description = "";

                            telegramUsername.ValidationRegExp = "";
                            contentType.AddPropertyType(telegramUsername);

                            contentTypeService.Save(contentType);
                        }
                        else if (!string.IsNullOrEmpty(telegramUsername.ValidationRegExp))
                        {
                            telegramUsername.ValidationRegExp = "";
                            contentType.AddPropertyType(telegramUsername);

                            contentTypeService.Save(contentType);
                        }
                    }

                    var helpdeskTelegramAccount = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "helpdeskTelegramAccount");
                    if (helpdeskTelegramAccount != null)
                    {
                        if (helpdeskTelegramAccount.Name != "HelpDesk Telegram Bot")
                        {
                            helpdeskTelegramAccount.Name        = "HelpDesk Telegram Bot";
                            helpdeskTelegramAccount.Description = "";

                            helpdeskTelegramAccount.ValidationRegExp = "";
                            contentType.AddPropertyType(helpdeskTelegramAccount);

                            contentTypeService.Save(contentType);
                        }
                        else if (!string.IsNullOrEmpty(helpdeskTelegramAccount.ValidationRegExp))
                        {
                            helpdeskTelegramAccount.ValidationRegExp = "";
                            contentType.AddPropertyType(helpdeskTelegramAccount);

                            contentTypeService.Save(contentType);
                        }
                    }

                    var whatsAppNumber = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "whatsAppNumber");
                    if (whatsAppNumber != null)
                    {
                        if (whatsAppNumber.Name != "Whatsapp URL")
                        {
                            whatsAppNumber.Name        = "Whatsapp URL";
                            whatsAppNumber.Description = "";

                            whatsAppNumber.ValidationRegExp = "";
                            contentType.AddPropertyType(whatsAppNumber);

                            contentTypeService.Save(contentType);
                        }
                        else if (!string.IsNullOrEmpty(whatsAppNumber.ValidationRegExp))
                        {
                            whatsAppNumber.ValidationRegExp = "";
                            contentType.AddPropertyType(whatsAppNumber);

                            contentTypeService.Save(contentType);
                        }
                    }
                    //var
                    //var
                }

                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Home_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(Home_ParentKey),
                            typeof(Home_Register),
                            typeof(Site_ParentKey),
                            typeof(Site_AlreadyHaveAccount),
                            typeof(Register_ParentKey),
                            typeof(Register_RegisterTitle),
                            typeof(Register_RegisterStep),
                            typeof(Register_RegisterOf),
                            typeof(Register_PhoneNumber),
                            typeof(Register_PhoneNumberPlaceholder),
                            typeof(Register_IsMandatory),
                            typeof(Register_Continue),
                            typeof(Register_PhoneNumberInstructions),
                            typeof(Register_VerificationCode),
                            typeof(Register_VerificationCodePlaceholder),
                            typeof(Register_EnterCode),
                            typeof(Register_Enter6DigitVerificationCode),
                            typeof(Register_EnterVerificationCode),
                            typeof(Register_ResendCode),
                            typeof(Register_Wait),
                            typeof(Register_VerificationCodeInvalidOrExpired),
                            typeof(Register_Email),
                            typeof(Register_EmailPlaceholder),
                            typeof(Register_Password),
                            typeof(Register_PasswordPlaceholder),
                            typeof(Register_ConfirmPassword),
                            typeof(Register_FirstName),
                            typeof(Register_FirstNamePlaceholder),
                            typeof(Register_LastName),
                            typeof(Register_LastNamePlaceholder),
                            typeof(Register_Username),
                            typeof(Register_UsernamePlaceholder),
                            typeof(Register_Gender),
                            typeof(Register_DateOfBirth),
                            typeof(Register_DateOfBirthDay),
                            typeof(Register_DateOfBirthMonth),
                            typeof(Register_DateOfBirthMonthJanuary),
                            typeof(Register_DateOfBirthMonthFebruary),
                            typeof(Register_DateOfBirthMonthMarch),
                            typeof(Register_DateOfBirthMonthApril),
                            typeof(Register_DateOfBirthMonthMay),
                            typeof(Register_DateOfBirthMonthJune),
                            typeof(Register_DateOfBirthMonthJuly),
                            typeof(Register_DateOfBirthMonthAugust),
                            typeof(Register_DateOfBirthMonthSeptember),
                            typeof(Register_DateOfBirthMonthOctober),
                            typeof(Register_DateOfBirthMonthNovember),
                            typeof(Register_DateOfBirthMonthDecember),
                            typeof(Register_DateOfBirthYear),
                            typeof(Register_IAgreeWithThe),
                            typeof(Register_TermsAndConditions),
                            typeof(Register_Finish),
                            typeof(Register_IncorrectOrInvalid),
                            typeof(Register_VerifyEmailSentToTitle),
                            typeof(Register_VerifyEmailSentTo),
                            typeof(Register_VerifyEmailSentToPleaseClick),
                            typeof(Register_ResendVerificationEmail),
                            typeof(Register_ResendVerificationEmailSent),
                            typeof(Register_ChangeEmail),
                            typeof(Register_IsInvalid),
                            typeof(Register_Title),
                            typeof(Register_Address1),
                            typeof(Register_Address1Placeholder),
                            typeof(Register_Address2),
                            typeof(Register_Address2Placeholder),
                            typeof(Register_Address3),
                            typeof(Register_Address3Placeholder),
                            typeof(Register_CityOrTown),
                            typeof(Register_CityOrTownPlaceholder),
                            typeof(Register_PostalCode),
                            typeof(Register_PostalCodePlaceholder),
                            typeof(Register_Country),
                            typeof(Register_Preferences),
                            typeof(Register_Language),
                            typeof(Register_Currency),
                            typeof(Register_OddsDisplay),
                            typeof(Register_TimeZone),
                            typeof(Register_BonusCode),
                            typeof(Register_BonusCodePlaceholder),
                            typeof(Register_Referrer),
                            typeof(Register_ReferrerPlaceholder),
                            typeof(Register_ReceiveNotifications),
                            typeof(Register_ReceiveNotificationsViaInPlatformMessages),
                            typeof(Register_ReceiveNotificationsViaEmail),
                            typeof(Register_ReceiveNotificationsViaSMS),
                            typeof(Register_CookiesPolicy),
                            typeof(Register_PrivacyPolicy),
                            typeof(Register_MinimunAge),
                            typeof(Register_Age),
                            typeof(Register_AgeYearsOld),
                            typeof(Register_NewEmail),
                            typeof(Register_CurrentEmail)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                        ConnectorContext.AuditService.Add(AuditType.Save, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated, and Dictionaries Created");
                    }
                }

                var oldHome = contentTypeService.Get(HomeDocumentType.DOCUMENT_TYPE_ALIAS);
                if (oldHome != null)
                {
                    // remove old home document type
                    contentTypeService.Delete(contentTypeService.Get(HomeDocumentType.DOCUMENT_TYPE_ALIAS));
                    // remove old home template
                    fileService.DeleteTemplate(HomeDocumentType.TEMPLATE_ALIAS);
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_02_HomeDocumentTypePhase2Milestone6), ex.Message);
                logger.Error(typeof(_02_HomeDocumentTypePhase2Milestone6), ex.StackTrace);
            }
        }
Exemple #9
0
        private void CreateDocumentType()
        {
            try
            {
                var container     = contentTypeService.GetContainers(CONTAINER, 1).FirstOrDefault();
                var containerId   = container.Id;
                var contentType   = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
                var parentDocType = contentTypeService.Get(PARENT_NODE_DOCUMENT_TYPE_ALIAS);
                if (contentType == null)
                {
                    ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
                    {
                        Name          = DOCUMENT_TYPE_NAME,
                        Alias         = DOCUMENT_TYPE_ALIAS,
                        AllowedAsRoot = false,
                        Description   = DOCUMENT_TYPE_DESCRIPTION,
                        Icon          = ICON,
                        SortOrder     = 0,
                        Variations    = ContentVariation.Culture,
                        ParentId      = parentDocType.Id
                    };

                    // Create the Template if it doesn't exist
                    if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
                    {
                        var       layoutAlias    = "totalCodeLayout";
                        ITemplate masterTemplate = fileService.GetTemplate(layoutAlias);
                        //then create the template
                        Template newTemplate = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
                        newTemplate.SetMasterTemplate(masterTemplate);
                        fileService.SaveTemplate(newTemplate);
                    }

                    // Set templates for document type
                    var template = fileService.GetTemplate(TEMPLATE_ALIAS);
                    docType.AllowedTemplates = new List <ITemplate> {
                        template
                    };
                    docType.SetDefaultTemplate(template);

                    contentTypeService.Save(docType);

                    // set as allowed content type in account home
                    ContentHelper.AddAllowedDocumentType(contentTypeService, PARENT_NODE_DOCUMENT_TYPE_ALIAS, DOCUMENT_TYPE_ALIAS);

                    ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_NAME}' has been created");

                    ContentHelper.CopyPhysicalAssets(new EditAccountDetailsEmbeddedResources());

                    if (createDictionaryItems)
                    {
                        // Check if parent Key exists, and skip if true
                        var language = new LanguageDictionaryService(localizationService, domainService, logger);
                        if (!language.CheckExists(typeof(Account_ParentKey)))
                        {
                            // Add Dictionary Items
                            var dictionaryItems = new List <Type>
                            {
                                typeof(Account_ParentKey),
                                typeof(Others_Save),
                                typeof(Account_AccountPageTitle),
                                typeof(Account_AccountEditPageTitle)
                            };
                            language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                            ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_09_EditAccountDocumentType), ex.Message);
                logger.Error(typeof(_09_EditAccountDocumentType), ex.StackTrace);
            }
        }
Exemple #10
0
 public UtilityController(ILocalizationService localizationService, IDomainService domainService, ILogger logger, IUtilityService utilityService, IContentService contentService)
 {
     _localizationService       = localizationService;
     _languageDictionaryService = new LanguageDictionaryService(localizationService, domainService, logger);
     _utilityService            = utilityService;
 }
Exemple #11
0
        private void CreateMilestoneItems()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(localizationService, domainService, logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Forgot_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(Forgot_ParentKey),
                            typeof(Forgot_EnterCaptcha),
                            typeof(Forgot_Captcha),
                            typeof(Forgot_ForgotUsernameSuccess),
                            typeof(Forgot_ForgotUsernameFailure),
                            typeof(Forgot_ChangePassword),
                            typeof(Forgot_ConfirmNewPassword),
                            typeof(Forgot_NewPassword),
                            typeof(Forgot_ChangePasswordSuccess),
                            typeof(Forgot_ForgotPasswordEmailSentToTitle),
                            typeof(Forgot_ForgotPasswordEmailSentTo),
                            typeof(Forgot_ResendResetPasswordEmail),
                            typeof(Forgot_ResendResetPasswordEmailSent),
                            typeof(Forgot_ForgotPasswordInstructions),
                            typeof(Forgot_ForgotUsernameInstructions),
                            typeof(Forgot_ForgotPassword),
                            typeof(Forgot_UsernameRequestSuccessful),

                            typeof(Others_ConfirmEmail),
                            typeof(Others_Successful)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items
                    }

                    if (!language.CheckExists(typeof(Reset_ParentKey)))
                    {
                        var resetPasswordViaEmailDictionary = new List <Type>
                        {
                            typeof(Reset_ParentKey),
                            typeof(Reset_ChangePassword),
                            typeof(Reset_ResetPasswordSuccess),
                            typeof(Reset_ResetPasswordFailure)
                        };
                        language.CreateDictionaryItems(resetPasswordViaEmailDictionary); // Create Dictionary Items
                    }
                    ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Reset Password Dictionary Items", "Dictionaries Created");

                    if (!language.CheckExists(typeof(ServerErrors_ParentKey)))
                    {
                        var serverErrorsDictionary = new List <Type>
                        {
                            typeof(ServerErrors_ParentKey),
                            typeof(ServerErrors_MissingField),
                            typeof(ServerErrors_InvalidEmailFormat),
                            typeof(ServerErrors_InvalidDate),
                            typeof(ServerErrors_InvalidAge),
                            typeof(ServerErrors_MobileOrEmailRequired),
                            typeof(ServerErrors_InvalidCountry),
                            typeof(ServerErrors_InvalidCurrency),
                            typeof(ServerErrors_InvalidLanguage),
                            typeof(ServerErrors_InvalidTimeZone),
                            typeof(ServerErrors_ExistingCustomer),
                            typeof(ServerErrors_EmailNotFound),
                            typeof(ServerErrors_EmailSendFail),
                            typeof(ServerErrors_ChangePassword),
                            typeof(ServerErrors_InvalidCustomer),
                            typeof(ServerErrors_InvalidOldPassword),
                            typeof(ServerErrors_MatchingOldAndNewPassword),
                            typeof(ServerErrors_InvalidCustomerStatus),
                            typeof(ServerErrors_CustomerNotFound),
                            typeof(ServerErrors_VerificationRecordNotFound),
                            typeof(ServerErrors_VerificationEmailExpired),
                            typeof(ServerErrors_ValidationCodeExpired),
                            typeof(ServerErrors_ValidationCodeSendFail),
                            typeof(ServerErrors_SMSSendFail),
                            typeof(ServerErrors_InvalidMobileNumber),
                            typeof(ServerErrors_InvalidVerificationEmail),
                            typeof(ServerErrors_VerificationCodeLimitExceeded),
                            typeof(ServerErrors_MobileNumberNotFound),
                            typeof(ServerErrors_ValidationCodeInvalid),
                            typeof(ServerErrors_UnhandledError)
                        };
                        language.CreateDictionaryItems(serverErrorsDictionary); // Create Dictionary Items
                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Server Error Dictionary Items", "Dictionaries Created");
                    }

                    var firstEmbeddedResource = new Milestone7EmbeddedResources().Resources[0];
                    if (!ContentHelper.AssetAlreadyExists(firstEmbeddedResource.FileName, firstEmbeddedResource.OutputDirectory))
                    {
                        ContentHelper.CopyPhysicalAssets(new Milestone7EmbeddedResources());
                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Templates", "Templates Created");
                    }

                    // changed Email Confirmation page to remove from Allowed in Root
                    var confirmEmailDocType = contentTypeService.Get(_03_ConfirmEmailDocumentType.DOCUMENT_TYPE_ALIAS);
                    if (!confirmEmailDocType.AllowedAsRoot)
                    {
                        confirmEmailDocType.AllowedAsRoot = false;
                        contentTypeService.Save(confirmEmailDocType);
                    }

                    // delete en-GB
                    var enGB = localizationService.GetLanguageByIsoCode("en-GB");
                    if (enGB != null)
                    {
                        localizationService.Delete(enGB);
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_06_Phase2Milestone7), ex.Message);
                logger.Error(typeof(_06_Phase2Milestone7), ex.StackTrace);
            }
        }
Exemple #12
0
        public void Initialize()
        {
            var language        = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
            var dictionaryItems = new List <Type>();

            // Check if parent Key exists, and skip if true
            if (!language.CheckExists(typeof(AccountPage_ParentKey)))
            {
                dictionaryItems.Add(typeof(AccountPage_ParentKey));
            }

            if (!language.CheckExists(typeof(AccountPage_ChangeUsername)))
            {
                dictionaryItems.Add(typeof(AccountPage_ChangeUsername));
            }

            if (!language.CheckExists(typeof(AccountPage_CurrentUsername)))
            {
                dictionaryItems.Add(typeof(AccountPage_CurrentUsername));
            }

            if (!language.CheckExists(typeof(AccountPage_NewUsername)))
            {
                dictionaryItems.Add(typeof(AccountPage_NewUsername));
            }

            if (!language.CheckExists(typeof(Account_UsernameChangedSucccess)))
            {
                dictionaryItems.Add(typeof(Account_UsernameChangedSucccess));
            }

            if (!language.CheckExists(typeof(Account_UsernameChangedSucccessNotice)))
            {
                dictionaryItems.Add(typeof(Account_UsernameChangedSucccessNotice));
            }

            if (!language.CheckExists(typeof(Account_ChangeUsernameFailure)))
            {
                dictionaryItems.Add(typeof(Account_ChangeUsernameFailure));
            }

            if (!language.CheckExists(typeof(ServerErrors_ParentKey)))
            {
                dictionaryItems.Add(typeof(ServerErrors_ParentKey));
            }

            if (!language.CheckExists(typeof(ServerErrors_MatchingUsername)))
            {
                dictionaryItems.Add(typeof(ServerErrors_MatchingUsername));
            }

            if (!language.CheckExists(typeof(ServerErrors_UndefinedCustomer)))
            {
                dictionaryItems.Add(typeof(ServerErrors_UndefinedCustomer));
            }

            if (!language.CheckExists(typeof(ServerErrors_InvalidUsername)))
            {
                dictionaryItems.Add(typeof(ServerErrors_InvalidUsername));
            }

            if (dictionaryItems.Count > 0)
            {
                language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Item", $"Common Dictionary Items have been created/updated");
            }
        }
        private void CreateDictionaryItems()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(localizationService, domainService, logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(Others_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(Others_ParentKey),
                            typeof(Others_Deposit),
                            typeof(Others_Login),
                            typeof(Others_Register),
                            typeof(Others_Search),
                            typeof(Others_ForgotPassword),
                            typeof(Others_Balance),
                            typeof(Others_Cash),
                            typeof(Others_Withdrawable),
                            typeof(Others_BetCredits),
                            typeof(Others_Change),
                            typeof(Others_Edit),
                            typeof(Others_MarketingPreferences),
                            typeof(Others_ChangePassword),
                            typeof(Others_WhatCanWeHelp),
                            typeof(Others_Back),
                            typeof(Others_CreditCard),
                            typeof(Others_Delete),
                            typeof(Others_AddNewPaymentMethod),
                            typeof(Others_PaymentMethod),
                            typeof(Others_Status),
                            typeof(Others_StartDate),
                            typeof(Others_EndDate),
                            typeof(Others_ApplyFilters),
                            typeof(Others_ResetFilters),
                            typeof(Others_Filter),
                            typeof(Others_Rejected),
                            typeof(Others_IDCertificate),
                            typeof(Others_UploadedDocumentRules),
                            typeof(Others_Verified),
                            typeof(Others_Passport),
                            typeof(Others_Upload),
                            typeof(Others_FrontBack),
                            typeof(Others_Pending),
                            typeof(Others_BankStatement),
                            typeof(Others_UtilityBill),
                            typeof(Others_Receipt),
                            typeof(Others_FirstAndLastName),
                            typeof(Others_Date),
                            typeof(Others_Amount),
                            typeof(Others_TransactionNumber),
                            typeof(Others_WithdrawCancelled),
                            typeof(Others_GotIt),
                            typeof(Others_AreYouSureWant),
                            typeof(Others_Cancel),
                            typeof(Others_This),
                            typeof(Others_Withdraw),
                            typeof(Others_Yes),
                            typeof(Others_No),
                            typeof(Others_PasswordChanged),
                            typeof(Others_GetStarted),
                            typeof(Others_NewPaymentMethodAdded),
                            typeof(Others_PasswordResetLinkSent),
                            typeof(Others_PasswordResetLinkSentTo),
                            typeof(Others_ProceedToLogin),
                            typeof(Others_MessageSent),
                            typeof(Others_ResetPassword),
                            typeof(Others_ConfirmNewPassword),
                            typeof(Others_SaveNewPassword),
                            typeof(Others_ForgotUsernameEmail),
                            typeof(Others_EnterMobileSendUsername),
                            typeof(Others_EnterEmailToSendLink),
                            typeof(Others_AccountHolderName),
                            typeof(Others_CardNumber16Digits),
                            typeof(Others_ChangePhone),
                            typeof(Others_EditUserInfo),
                            typeof(Others_Male),
                            typeof(Others_Female),
                            typeof(Others_UserInfoUpdated),
                            typeof(Others_EnterPasswordToChange),
                            typeof(Others_SuccessChanged),
                            typeof(Others_PleaseEnterPasswordToChange),
                            typeof(Others_ChangeEmailVerifyNewEmail),
                            typeof(Others_WillNotBeReplacedUntil),
                            typeof(Others_NewPassword),
                            typeof(Others_WeWillRespondToEmail),
                            typeof(Others_Within24Hours),
                            typeof(Others_ContactUs),
                            typeof(Others_Subject),
                            typeof(Others_Message),
                            typeof(Others_Uploading),
                            typeof(Others_AttachFile),
                            typeof(Others_Send),
                            typeof(Others_NewTicket),
                            typeof(Others_NewMessage),
                            typeof(Others_Close),
                            typeof(Others_Ticket),
                            typeof(Others_Created),
                            typeof(Others_WeWillRespondTo),
                            typeof(Others_TicketSuccessClose),
                            typeof(Others_Settings),
                            typeof(Others_Fractional),
                            typeof(Others_ChoosePaymentMethod),
                            typeof(Others_Exclusive),
                            typeof(Others_AccessToExclusivePoints),
                            typeof(Others_Rewards),
                            typeof(Others_OtherPartners),
                            typeof(Others_MarketResearch),
                            typeof(Others_Tipping),
                            typeof(Others_Reply),
                            typeof(Others_Type),
                            typeof(Others_AmountToWithdraw),
                            typeof(Others_WithdrawWarning)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items

                        if (!language.CheckExists(typeof(Others_DepositBonusCode)))
                        {
                            var latestAddition = new List <Type>
                            {
                                typeof(Others_DepositBonusCode)
                            };
                            language.CreateDictionaryItems(latestAddition); // Create Dictionary Items
                        }

                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_04_RenantePhase2Milestone6DictionaryMigration), ex.Message);
                logger.Error(typeof(_04_RenantePhase2Milestone6DictionaryMigration), ex.StackTrace);
            }
        }
 public DictionarySettingsSurfaceController(ILocalizationService localizationService, IDomainService domainService, ILogger logger)
 {
     this.localizationService  = localizationService;
     languageDictionaryService = new LanguageDictionaryService(localizationService, domainService, logger);
 }
        private void CreateDictionaryItems()
        {
            try
            {
                if (createDictionaryItems)
                {
                    var language = new LanguageDictionaryService(localizationService, domainService, logger);
                    // Check if parent Key exists, and skip if true
                    if (!language.CheckExists(typeof(ServerErrors_ParentKey)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems = new List <Type>
                        {
                            typeof(ServerErrors_MissingField),
                            typeof(ServerErrors_InvalidEmailFormat),
                            typeof(ServerErrors_InvalidDate),
                            typeof(ServerErrors_InvalidAge),
                            typeof(ServerErrors_MobileOrEmailRequired),
                            typeof(ServerErrors_InvalidCountry),
                            typeof(ServerErrors_InvalidCurrency),
                            typeof(ServerErrors_InvalidLanguage),
                            typeof(ServerErrors_InvalidTimeZone),
                            typeof(ServerErrors_ExistingCustomer),
                            typeof(ServerErrors_EmailNotFound),
                            typeof(ServerErrors_EmailSendFail),
                            typeof(ServerErrors_ChangePassword),
                            typeof(ServerErrors_InvalidCustomer),
                            typeof(ServerErrors_InvalidOldPassword),
                            typeof(ServerErrors_MatchingOldAndNewPassword),
                            typeof(ServerErrors_InvalidCustomerStatus),
                            typeof(ServerErrors_CustomerNotFound),
                            typeof(ServerErrors_VerificationRecordNotFound),
                            typeof(ServerErrors_VerificationEmailExpired),
                            typeof(ServerErrors_ValidationCodeExpired),
                            typeof(ServerErrors_ValidationCodeSendFail),
                            typeof(ServerErrors_SMSSendFail),
                            typeof(ServerErrors_InvalidMobileNumber),
                            typeof(ServerErrors_InvalidVerificationEmail),
                            typeof(ServerErrors_VerificationCodeLimitExceeded),
                            typeof(ServerErrors_MobileNumberNotFound),
                            typeof(ServerErrors_ValidationCodeInvalid),
                            typeof(ServerErrors_UnhandledError),
                            typeof(ServerErrors_FieldRequired),
                            typeof(ServerErrors_BelowMinimumWithdrawalAmount),
                            typeof(ServerErrors_InsufficientBalance),
                            typeof(ServerErrors_UsernameCannotBeEmailAddress)
                        };
                        language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items
                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                    }

                    if (!language.CheckExists(typeof(ServerErrors_ConnectionTimeout)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems1 = new List <Type>
                        {
                            typeof(ServerErrors_ConnectionTimeout)
                        };
                        language.CreateDictionaryItems(dictionaryItems1); // Create Dictionary Items
                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                    }

                    if (!language.CheckExists(typeof(ServerErrors_InvalidLogin)))
                    {
                        // Add Dictionary Items
                        var dictionaryItems2 = new List <Type>
                        {
                            typeof(ServerErrors_InvalidLogin)
                        };
                        language.CreateDictionaryItems(dictionaryItems2); // Create Dictionary Items
                        ConnectorContext.AuditService.Add(AuditType.Save, -1, -1, "Dictionary Items", $"Dictionaries Created");
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(typeof(_28_ServerErrorsDictionary), ex.Message);
                logger.Error(typeof(_28_ServerErrorsDictionary), ex.StackTrace);
            }
        }