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);
}
}
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);
}
}
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);
}
}
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);
}
}
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);
}
}
public UtilityController(ILocalizationService localizationService, IDomainService domainService, ILogger logger, IUtilityService utilityService, IContentService contentService)
{
_localizationService = localizationService;
_languageDictionaryService = new LanguageDictionaryService(localizationService, domainService, logger);
_utilityService = utilityService;
}
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);
}
}
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);
}
}