public Entity ReplaceTranslationService(ITranslationService newService)
{
var component = CreateComponent<TranslationServiceComponent>(ComponentIds.TranslationService);
component.service = newService;
ReplaceComponent(ComponentIds.TranslationService, component);
return this;
}
public LoginController(IUserRepository userRepository, IServiceBus bus, ITranslationService translationService, IPasswordPolicy passwordPolicy)
{
_userRepository = userRepository;
_bus = bus;
_translationService = translationService;
_passwordPolicy = passwordPolicy;
}
public ExplorerServiceDependencies(ITranslationService translationService,
IExplorerItemViewModelFactory explorerItemViewModelFactory,
IExplorerViewModel explorerViewModel)
{
TranslationService = translationService;
ExplorerItemViewModelFactory = explorerItemViewModelFactory;
ExplorerViewModel = explorerViewModel;
}
public AdministrationHomeController(IDataService dataService, ICacheService cacheService,
ITranslationService translationService, IMailService mailService, IConfigurationService configurationService)
{
_dataService = dataService;
_cacheService = cacheService;
_translationService = translationService;
_mailService = mailService;
_configurationService = configurationService;
}
public RevationLiveDataService(IRevationLiveReadService revationLiveReadService,
ITranslationService<Socket> socketTranslator,
ITranslationService<Generic> genericTranslator)
{
_revationLiveReadService = revationLiveReadService;
_socketTranslator = socketTranslator;
_genericTranslator = genericTranslator;
Name = _revationLiveReadService.Name;
}
public RevationHistoricDataService(IRevationHistoricReadService readService,
ITranslationService<AgentBucket,ACDAgentSplitDatum> translatesAgentBucketToAgentSplitData,
ITranslationService<GroupStatusBucket,ACDSplitDatum> translatesGroupStatusBucketToSplitData,
ITranslationService<UserStatusBucket,ACDAgentDatum> translatesUserStatusBucketToAgentData)
{
_readService = readService;
_translatesAgentBucketToAgentSplitData = translatesAgentBucketToAgentSplitData;
_translatesGroupStatusBucketToSplitData = translatesGroupStatusBucketToSplitData;
_translatesUserStatusBucketToAgentData = translatesUserStatusBucketToAgentData;
}
public AlertsView(ITranslationService translationService)
: base(translationService)
{
InitializeComponent();
ShowLateLoans = true;
ShowPerformingLoansToday = true;
_lateLoansItem.Checked = true;
_performingLoansItemToday.Checked = true;
_clearSearchButton.Visible = false;
SetUp();
}
public Startup(IHttpJsonClient httpJsonClient = null,
ITranslatorClient translatorClient = null,
ITranslationService translationService = null,
TranslationServicesConfiguration translationServicesConfiguration = null)
{
_httpJsonClient = httpJsonClient;
_translatorClient = translatorClient;
_translationService = translationService;
_translationServicesConfiguration = translationServicesConfiguration;
IoC = BuildContainer();
}
public HomeController(
IApplicationSettings applicationSettings,
ICultureService cultureService,
IServiceBus serviceBus,
ITranslationService translationService
)
{
_applicationSettings = applicationSettings;
_cultureService = cultureService;
_serviceBus = serviceBus;
_translationService = translationService;
}
public void TranslateItem(Item item, ITranslationService service)
{
var sourceItem = Sitecore.Context.ContentDatabase.GetItem(item.ID, Sitecore.Globalization.Language.Parse(BaseLanguage));
Job job = Context.Job;
if (job != null)
{
job.Status.LogInfo(Translate.Text("Translating item by path {0}.", new object[] { item.Paths.FullPath }));
}
if (item.Versions.Count == 0)
{
if (sourceItem == null)
{
return;
}
item = item.Versions.AddVersion();
item.Editing.BeginEdit();
foreach (Field field in sourceItem.Fields)
{
if ((string.IsNullOrEmpty(sourceItem[field.Name]) || field.Shared))
{
continue;
}
if (!FieldIsTranslatable(field) || FieldIsStandard(field))
{
item[field.Name] = sourceItem[field.Name];
}
else
{
var text = sourceItem[field.Name];
var translatedText = string.Empty;
if (text.Length < MaxServiceRequestLength)
{
item[field.Name] = service.Translate(text);
continue;
}
translatedText = SplitText(text, MaxServiceRequestLength).Aggregate(translatedText, (current, textBlock) => current + service.Translate(textBlock));
item[field.Name] = translatedText;
}
}
item.Editing.EndEdit();
}
}
public StartPageView(ITranslationService translationService) : base(translationService)
{
InitializeComponent();
SizeChanged += (sender, e) => OnResize();
new ToolTip().SetToolTip(_englishPictureBox, "English");
new ToolTip().SetToolTip(_frenchPictureBox, "Français");
new ToolTip().SetToolTip(_russianPictureBox, "Русский");
new ToolTip().SetToolTip(_spanishPictureBox, "Español");
new ToolTip().SetToolTip(_portuguesePictureBox, "Português");
_newClientButton.Click += (sender, e) =>
{
_newClientMenu.Show(_newClientButton, 0, _newClientButton.Height);
};
}
public PersonListViewModelDepedencies(
ITranslationService translationService,
IPersonDocumentConfiguration document,
ICrudGroupController crudGroupController,
IValidationService<IPersonRowViewModel> validationService,
IPersonResource personResource,
ITrackedCollectionFactory<PersonModel, IPersonRowViewModel> trackedCollectionFactory)
{
TranslationService = translationService;
Document = document;
CrudGroupController = crudGroupController;
ValidationService = validationService;
PersonResource = personResource;
TrackedCollectionFactory = trackedCollectionFactory;
}
public BlogViewModelService(IBlogService blogService, IDateTimeService dateTimeService, IStoreService storeService, ISlugService slugService,
IPictureService pictureService, ICustomerService customerService, ITranslationService translationService, IProductService productService,
IVendorService vendorService, ILanguageService languageService, IWorkContext workContext, SeoSettings seoSettings)
{
_blogService = blogService;
_dateTimeService = dateTimeService;
_storeService = storeService;
_slugService = slugService;
_pictureService = pictureService;
_customerService = customerService;
_translationService = translationService;
_productService = productService;
_vendorService = vendorService;
_languageService = languageService;
_workContext = workContext;
_seoSettings = seoSettings;
}
public ProductReviewViewModelService(
IProductService productService,
IProductReviewService productReviewService,
ICustomerService customerService,
IStoreService storeService,
IDateTimeService dateTimeService,
ITranslationService translationService,
IMediator mediator)
{
_productService = productService;
_productReviewService = productReviewService;
_customerService = customerService;
_storeService = storeService;
_dateTimeService = dateTimeService;
_translationService = translationService;
_mediator = mediator;
}
public DeleteAccountCommandHandler(
ICustomerService customerService,
IMessageProviderService messageProviderService,
IQueuedEmailService queuedEmailService,
INewsLetterSubscriptionService newsLetterSubscriptionService,
ICustomerActivityService customerActivityService,
ITranslationService translationService,
LanguageSettings languageSettings)
{
_customerService = customerService;
_messageProviderService = messageProviderService;
_queuedEmailService = queuedEmailService;
_newsLetterSubscriptionService = newsLetterSubscriptionService;
_customerActivityService = customerActivityService;
_translationService = translationService;
_languageSettings = languageSettings;
}
public GetVendorAllHandler(
IVendorService vendorService,
IPictureService pictureService,
ITranslationService translationService,
ICacheBase cacheBase,
IMediator mediator,
MediaSettings mediaSettings,
VendorSettings vendorSettings)
{
_vendorService = vendorService;
_pictureService = pictureService;
_translationService = translationService;
_cacheBase = cacheBase;
_mediator = mediator;
_mediaSettings = mediaSettings;
_vendorSettings = vendorSettings;
}
public DevicePageViewModel(
INavigationService navigationService,
ITranslationService translationService,
IDeviceManager deviceManager,
IDialogService dialogService,
NavigationParameters parameters)
: base(navigationService, translationService)
{
_deviceManager = deviceManager;
_dialogService = dialogService;
Device = parameters.Get <Device>("device");
RenameCommand = new SafeCommand(async() => await RenameDeviceAsync());
BuWizzOutputLevelChangedCommand = new SafeCommand <int>(outputLevel => SetBuWizzOutputLevel(outputLevel));
BuWizz2OutputLevelChangedCommand = new SafeCommand <int>(outputLevel => SetBuWizzOutputLevel(outputLevel));
}
public AffiliateViewModelService(IWorkContext workContext, ICountryService countryService,
IPriceFormatter priceFormatter, IAffiliateService affiliateService,
ICustomerService customerService, IOrderService orderService, ITranslationService translationService, IDateTimeService dateTimeService,
IOrderStatusService orderStatusService,
SeoSettings seoSettings)
{
_workContext = workContext;
_countryService = countryService;
_priceFormatter = priceFormatter;
_affiliateService = affiliateService;
_customerService = customerService;
_orderService = orderService;
_translationService = translationService;
_dateTimeService = dateTimeService;
_orderStatusService = orderStatusService;
_seoSettings = seoSettings;
}
public DrinkEventHandlingService(
IUserRepository userRepository,
IDrinkEventRepository drinkEventRepository,
UserStatisticUpdateService rankingService,
ITranslationService translationService,
IActivityRepository activityRepository,
PushNotificationService pushNotificationService,
ILogger <DrinkEventHandlingService> logger)
{
this.userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
this.drinkEventRepository = drinkEventRepository ?? throw new ArgumentNullException(nameof(drinkEventRepository));
this.rankingService = rankingService ?? throw new ArgumentNullException(nameof(rankingService));
this.translationService = translationService ?? throw new ArgumentNullException(nameof(translationService));
this.activityRepository = activityRepository ?? throw new ArgumentNullException(nameof(activityRepository));
this.pushNotificationService = pushNotificationService ?? throw new ArgumentNullException(nameof(pushNotificationService));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public PluginController(
ITranslationService translationService,
IThemeProvider themeProvider,
ILogger logger,
IHostApplicationLifetime applicationLifetime,
IWorkContext workContext,
IServiceProvider serviceProvider,
AppConfig appConfig)
{
_translationService = translationService;
_themeProvider = themeProvider;
_logger = logger;
_workContext = workContext;
_applicationLifetime = applicationLifetime;
_serviceProvider = serviceProvider;
_appConfig = appConfig;
}
public NewsController(
INewsViewModelService newsViewModelService,
INewsService newsService,
ILanguageService languageService,
ITranslationService translationService,
IStoreService storeService,
IGroupService groupService,
IDateTimeService dateTimeService)
{
_newsViewModelService = newsViewModelService;
_newsService = newsService;
_languageService = languageService;
_translationService = translationService;
_storeService = storeService;
_groupService = groupService;
_dateTimeService = dateTimeService;
}
protected override void SubmitLinkChangesWithUpdateDoc(
LinkChangeGroup linkChanges,
ServiceContainer serviceContainer,
TfsLinkingProviderBase.LinkSubmissionPhase submissionPhase)
{
ConfigurationService configService = serviceContainer.GetService(typeof(ConfigurationService)) as ConfigurationService;
ITranslationService translationService = serviceContainer.GetService(typeof(ITranslationService)) as ITranslationService;
bool nonWorkItemLinkChangesAllSubmitted = SubmitNonWorkItemLinkChanges(
linkChanges, serviceContainer, configService, translationService, submissionPhase);
bool workItemLinkChangesAllSubmitted = SubmitWorkItemLinkChanges(
linkChanges, serviceContainer, configService, translationService, submissionPhase);
linkChanges.Status = (nonWorkItemLinkChangesAllSubmitted && workItemLinkChangesAllSubmitted && AllActionSubmitted(linkChanges))
? LinkChangeGroup.LinkChangeGroupStatus.Completed
: LinkChangeGroup.LinkChangeGroupStatus.ReadyForMigration;
}
public UpdateBrandCommandHandler(
IBrandService brandService,
ISlugService slugService,
ILanguageService languageService,
ICustomerActivityService customerActivityService,
ITranslationService translationService,
IPictureService pictureService,
SeoSettings seoSettings)
{
_brandService = brandService;
_slugService = slugService;
_languageService = languageService;
_customerActivityService = customerActivityService;
_translationService = translationService;
_pictureService = pictureService;
_seoSettings = seoSettings;
}
public MerchandiseReturnController(
IMerchandiseReturnService merchandiseReturnService,
IOrderService orderService,
IWorkContext workContext,
IGroupService groupService,
ITranslationService translationService,
IMediator mediator,
OrderSettings orderSettings)
{
_merchandiseReturnService = merchandiseReturnService;
_orderService = orderService;
_workContext = workContext;
_groupService = groupService;
_translationService = translationService;
_mediator = mediator;
_orderSettings = orderSettings;
}
public UserValidator(IDbContext dbContext, ITranslationService translation)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
RuleFor(m => m.DisplayName).NotEmpty()
.WithMessage(translation["User.Fields.DisplayName.Required"])
.MinimumLength(3)
.WithMessage(translation["User.Fields.DisplayName.MinimumLength"])
.MaximumLength(User.DisplayNameLength)
.WithMessage(translation["User.Fields.DisplayName.MaximumLength"])
.DependentRules(() =>
{
RuleFor(m => m).Must(model =>
IsUniqueDisplayName(model.DisplayName, model.Id))
.WithMessage(translation["User.Fields.DisplayName.Unique"])
.OverridePropertyName(nameof(UserModel.DisplayName));
});
RuleFor(m => m.UserName).NotEmpty()
.WithMessage(translation["User.Fields.UserName.Required"])
.MinimumLength(3)
.WithMessage(translation["User.Fields.UserName.MinimumLength"])
.MaximumLength(User.UserNameLength)
.WithMessage(translation["User.Fields.UserName.MaximumLength"])
.Matches("^[a-zA-Z0-9_]*$")
.WithMessage(translation["User.Fields.UserName.RegularExpression"])
.DependentRules(() =>
{
RuleFor(m => m).Must(model =>
IsUniqueUserName(model.UserName, model.Id))
.WithMessage(translation["User.Fields.UserName.Unique"])
.OverridePropertyName(nameof(UserModel.UserName));
});
RuleFor(m => m.Password).NotEmpty()
.WithMessage(translation["User.Fields.Password.Required"])
.When(m => m.IsNew(), ApplyConditionTo.CurrentValidator)
.MinimumLength(6)
.WithMessage(translation["User.Fields.Password.MinimumLength"])
.MaximumLength(User.PasswordLength)
.WithMessage(translation["User.Fields.Password.MaximumLength"]);
RuleFor(m => m).Must(model => !CheckDuplicateRoles(model))
.WithMessage(translation["User.Fields.Roles.Unique"])
.When(m => m.Roles != null && m.Roles.Any(r => !r.IsDeleted()));
}
public SequenceListPageViewModel(
INavigationService navigationService,
ITranslationService translationService,
ICreationManager creationManager,
IDialogService dialogService,
ISharedFileStorageService sharedFileStorageService)
: base(navigationService, translationService)
{
_creationManager = creationManager;
_dialogService = dialogService;
SharedFileStorageService = sharedFileStorageService;
ImportSequenceCommand = new SafeCommand(async() => await ImportSequenceAsync(), () => SharedFileStorageService.IsSharedStorageAvailable);
AddSequenceCommand = new SafeCommand(async() => await AddSequenceAsync());
SequenceTappedCommand = new SafeCommand <Sequence>(async sequence => await NavigationService.NavigateToAsync <SequenceEditorPageViewModel>(new NavigationParameters(("sequence", sequence))));
DeleteSequenceCommand = new SafeCommand <Sequence>(async(sequence) => await DeleteSequenceAsync(sequence));
}
/// <summary>
/// Ctor
/// </summary>
public ShippingService(
IWarehouseService warehouseService,
ILogger logger,
ITranslationService translationService,
ICountryService countryService,
IEnumerable <IShippingRateCalculationProvider> shippingRateCalculationProvider,
ShippingProviderSettings shippingProviderSettings,
ShippingSettings shippingSettings)
{
_warehouseService = warehouseService;
_logger = logger;
_translationService = translationService;
_countryService = countryService;
_shippingRateCalculationProvider = shippingRateCalculationProvider;
_shippingProviderSettings = shippingProviderSettings;
_shippingSettings = shippingSettings;
}
public DiscountController(
IDiscountViewModelService discountViewModelService,
IDiscountService discountService,
ITranslationService translationService,
IWorkContext workContext,
IStoreService storeService,
IDateTimeService dateTimeService,
IGroupService groupService)
{
_discountViewModelService = discountViewModelService;
_discountService = discountService;
_translationService = translationService;
_workContext = workContext;
_storeService = storeService;
_dateTimeService = dateTimeService;
_groupService = groupService;
}
public RegistersController(ITranslationService translationService,
RegisterDbContext dbContext, IRegisterItemService registerItemService, ISearchService searchService, IVersioningService versioningService,
IRegisterService registerService, IAccessControlService accessControlService, IInspireDatasetService inspireDatasetService, IGeodatalovDatasetService geodatalovService, IInspireMonitoringService inspireMonitoringService, ISynchronizationService synchronizationService, IStatusReportService statusReportService)
{
_db = dbContext;
_registerItemService = registerItemService;
_searchService = searchService;
_versioningService = versioningService;
_registerService = registerService;
_accessControlService = accessControlService;
_translationService = translationService;
_inspireDatasetService = inspireDatasetService;
_geodatalovDatasetService = geodatalovService;
_inspireMonitoringService = inspireMonitoringService;
_synchronizationService = synchronizationService;
_statusReportService = statusReportService;
}
public static void SetContainer(IIocContainer container)
{
s_Ioc = container;
// init translation service first and replace global resource manager
TR = Resolve <ITranslationService>();
// managers
PanelFillers = Resolve <IPanelFillerManager>();
PanelColumns = Resolve <IPanelColumnManager>();
FolderManager = Resolve <IFolderManager>();
// presenters
Presenter = Resolve <IMainPresenter>();
MainPages = Resolve <IPagesPresenter>();
// other
Config = Resolve <IConfigModel>();
Threads = Resolve <ILazyThreadPool>();
Images = Resolve <IImageManager>();
}
public MainContentViewModel(IWindowService windowService, ITranslationService translationService)
{
if (windowService == null) throw new ArgumentNullException(nameof(windowService));
if (translationService == null) throw new ArgumentNullException(nameof(translationService));
_windowService = windowService;
_translationService = translationService;
_project = new Project();
_project.CreateDocument("Document");
MessengerInstance.Register<NotificationMessageAction<string>>(this, Tokens.NewComponent, m => OpenNewComponentDialog(m.Notification, m.Execute));
MessengerInstance.Register<GenericMessage<string>>(this, Tokens.Translation, m =>
{
var result = _translationService.TranslateToBraille(m.Content);
_project.CurrentDocument.FlowDocument.Preview = result;
});
}
public DocumentController(IDocumentViewModelService documentViewModelService,
IDocumentService documentService,
IDocumentTypeService documentTypeService,
ITranslationService translationService,
ICustomerService customerService,
IGroupService groupService,
IStoreService storeService,
ICustomerActivityService customerActivityService)
{
_documentViewModelService = documentViewModelService;
_documentService = documentService;
_documentTypeService = documentTypeService;
_translationService = translationService;
_customerService = customerService;
_groupService = groupService;
_storeService = storeService;
_customerActivityService = customerActivityService;
}
public PaymentController(IPaymentService paymentService,
ISettingService settingService,
ICountryService countryService,
IGroupService groupService,
IShippingMethodService shippingMethodService,
ITranslationService translationService,
IServiceProvider serviceProvider,
IWorkContext workContext)
{
_paymentService = paymentService;
_settingService = settingService;
_countryService = countryService;
_groupService = groupService;
_shippingMethodService = shippingMethodService;
_translationService = translationService;
_serviceProvider = serviceProvider;
_workContext = workContext;
}
public AcceptInvitationCommandHandler(
IInvitationRepository invitationRepository,
IUserRepository userRepository,
INotificationService notificationService,
IActivityRepository activityRepository,
ITranslationService translationService,
UserStatisticUpdateService rankingService,
ILogger <AcceptInvitationCommandHandler> logger)
{
this.invitationRepository = invitationRepository;
this.userRepository = userRepository;
this.notificationService = notificationService;
this.activityRepository = activityRepository;
this.translationService = translationService;
this.rankingService = rankingService;
this.logger = logger;
}
public OrderController(IOrderService orderService,
IWorkContext workContext,
IPaymentService paymentService,
IPaymentTransactionService paymentTransactionService,
ITranslationService translationService,
IGroupService groupService,
IMediator mediator,
OrderSettings orderSettings)
{
_orderService = orderService;
_workContext = workContext;
_paymentService = paymentService;
_paymentTransactionService = paymentTransactionService;
_translationService = translationService;
_groupService = groupService;
_mediator = mediator;
_orderSettings = orderSettings;
}
public KnowledgebaseArticleModelValidator(
IEnumerable <IValidatorConsumer <KnowledgebaseArticleModel> > validators,
ITranslationService translationService, IKnowledgebaseService knowledgebaseService)
: base(validators)
{
RuleFor(x => x.Name).NotEmpty().WithMessage(translationService.GetResource("Admin.Content.Knowledgebase.KnowledgebaseArticle.Fields.Name.Required"));
RuleFor(x => x.ParentCategoryId).NotEmpty().WithMessage(translationService.GetResource("Admin.Content.Knowledgebase.KnowledgebaseArticle.Fields.ParentCategoryId.Required"));
RuleFor(x => x.ParentCategoryId).Must(x =>
{
var category = knowledgebaseService.GetKnowledgebaseCategory(x);
if (category != null)
{
return(true);
}
return(false);
}).WithMessage(translationService.GetResource("Admin.Content.Knowledgebase.KnowledgebaseArticle.Fields.ParentCategoryId.MustExist"));
}
public VocabularyItemDialogViewModel(Action <VocabularyRecord> onSaveItem)
{
Question = question;
this.onSaveItem = onSaveItem;
translationService = ViewModelLocator.Resolve <ITranslationService>();
speachService = ViewModelLocator.Resolve <ISpeachService>();
SaveCommand = new RelayCommand(SaveCommandHandler, () => Question != null);
CancelCommand = new RelayCommand(() => { Close(); });
TranslateForeignCommand = new RelayCommand(TranslateForeignCommandHandler, () => Question != null);
TranslateNativeCommand = new RelayCommand(TranslateNativeCommandHandler, () => Question != null);
SpeakForeignCommand = new RelayCommand(SpeakForeignCommandHandler);
SpeakNativeCommand = new RelayCommand(SpeakNativeCommandHandler);
}
public ShippingPointController(
IWorkContext workContext,
IUserFieldService userFieldService,
ITranslationService translationService,
IShippingPointService ShippingPointService,
ICountryService countryService,
IStoreService storeService,
IPriceFormatter priceFormatter
)
{
_workContext = workContext;
_userFieldService = userFieldService;
_translationService = translationService;
_shippingPointService = ShippingPointService;
_countryService = countryService;
_storeService = storeService;
_priceFormatter = priceFormatter;
}
public ShippingPointRateProvider(
IShippingPointService shippingPointService,
ITranslationService translationService,
IWorkContext workContext,
IUserFieldService userFieldService,
ICountryService countryService,
ICurrencyService currencyService,
ShippingPointRateSettings shippingPointRateSettings
)
{
_shippingPointService = shippingPointService;
_translationService = translationService;
_workContext = workContext;
_userFieldService = userFieldService;
_countryService = countryService;
_currencyService = currencyService;
_shippingPointRateSettings = shippingPointRateSettings;
}
public HasOneProductController(IDiscountService discountService,
ISettingService settingService,
IPermissionService permissionService,
IWorkContext workContext,
ITranslationService translationService,
IStoreService storeService,
IVendorService vendorService,
IProductService productService)
{
_discountService = discountService;
_settingService = settingService;
_permissionService = permissionService;
_workContext = workContext;
_translationService = translationService;
_storeService = storeService;
_vendorService = vendorService;
_productService = productService;
}
public GetBlogPostListHandler(
IBlogService blogService,
IWorkContext workContext,
IPictureService pictureService,
ITranslationService translationService,
IDateTimeService dateTimeService,
BlogSettings blogSettings,
MediaSettings mediaSettings)
{
_blogService = blogService;
_workContext = workContext;
_pictureService = pictureService;
_translationService = translationService;
_dateTimeService = dateTimeService;
_blogSettings = blogSettings;
_mediaSettings = mediaSettings;
}
public UserFieldValidator(
IEnumerable <IValidatorConsumer <UserFieldModel> > validators,
ITranslationService translationService)
: base(validators)
{
RuleFor(x => x.Id)
.NotEmpty()
.WithMessage(translationService.GetResource("Admin.Common.UserFields.Fields.Id.Required"));
RuleFor(x => x.ObjectType)
.NotEmpty()
.WithMessage(translationService.GetResource("Admin.Common.UserFields.Fields.ObjectType.Required"));
RuleFor(x => x.Key)
.NotEmpty()
.WithMessage(translationService.GetResource("Admin.Common.UserFields.Fields.Key.Required"));
RuleFor(x => x.Value)
.NotEmpty()
.WithMessage(translationService.GetResource("Admin.Common.UserFields.Fields.Value.Required"));
}
public SpecificationAttributeController(ISpecificationAttributeService specificationAttributeService,
ILanguageService languageService,
ITranslationService translationService,
ICustomerActivityService customerActivityService,
IStoreService storeService,
IWorkContext workContext,
IGroupService groupService,
SeoSettings seoSettings)
{
_specificationAttributeService = specificationAttributeService;
_languageService = languageService;
_translationService = translationService;
_customerActivityService = customerActivityService;
_storeService = storeService;
_workContext = workContext;
_groupService = groupService;
_seoSettings = seoSettings;
}
public static async Task<bool> IsValidCulturesListAsync(string cultures, ITranslationService translationService)
{
// Empty is ok, eg administrators that do not translate anything
if (String.IsNullOrWhiteSpace(cultures)) return true;
// First and last character must be the delimiter, thus we need at least three characters
if (cultures.Length < 3 ||
cultures[0] != CultureDelimiter ||
cultures[cultures.Length - 1] != CultureDelimiter)
{
return false;
}
var culturesList = SplitUserCulturesList(cultures);
var knownCultures = await translationService.GetCachedLanguagesAsync().ConfigureAwait(false);
var knownCultureCodes = knownCultures.Select(kc => kc.Culture).ToList();
// If the culture list for the user has a culture that we don't know of as an application -> invalid
var result = culturesList.Except(knownCultureCodes);
return !result.Any();
}
public void Config(Stream shrink, string cultureCode, ITranslationService t)
{
_shrink = shrink;
_cultureCode = cultureCode;
_translationService = t;
}
ITranslationService getTranslationService()
{
if (service == null)
service = translation.GetSingleEntity().translationService.service;
return service;
}
public UpgradeView(ITranslationService translationService)
: base(translationService)
{
InitializeComponent();
}
public RepaymentView(ITranslationService translationService)
: base(translationService)
{
InitializeComponent();
}
public IndexerBuisnessService(LagerDAO dao, ITranslationService translate)
{
this.dao = dao;
this.translate = translate;
}
static NrkTranslatableStrings()
{
trans = new TranslationService();
trans.Init();
}
public RepaymentPresenter(IRepaymentView view, IRepaymentService repaymentService, ITranslationService translationService)
{
_view = view;
_repaymentService = repaymentService;
_translationService = translationService;
}
public void SetBaseServices(IUIFactoryService uiFactoryService, EventService eventService, ITranslationService translationService)
{
this.uiFactoryService = uiFactoryService;
this.eventService = eventService;
this.translationService = translationService;
}
//public static CouchDB db;
//
// This method is invoked when the application has loaded and is ready to run. In this
// method you should instantiate the window, load the UI into it and then make the window
// visible.
//
// You have 17 seconds to return from this method, or iOS will terminate your application.
//
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
GAI.SharedInstance.DispatchInterval = 20;
GAI.SharedInstance.TrackUncaughtExceptions = true;
Tracker = GAI.SharedInstance.GetTracker (TrackingId);
iRate.SharedInstance.UserDidAttemptToRateApp += (sender, e) => {
GAI.SharedInstance.DefaultTracker.Send (GAIDictionaryBuilder.CreateEvent ("UserRating", "User is rating app now!","UsesCount", iRate.SharedInstance.UsesCount).Build ());
Console.WriteLine ("User is rating app now!");
};
iRate.SharedInstance.UserDidDeclineToRateApp += (sender, e) => {
GAI.SharedInstance.DefaultTracker.Send (GAIDictionaryBuilder.CreateEvent ("UserRating", "User does not want to rate app","UsesCount", iRate.SharedInstance.UsesCount).Build ());
Console.WriteLine ("User does not want to rate app");
};
iRate.SharedInstance.UserDidRequestReminderToRateApp += (sender, e) => {
GAI.SharedInstance.DefaultTracker.Send (GAIDictionaryBuilder.CreateEvent ("UserRating", "User will rate app later","UsesCount", iRate.SharedInstance.UsesCount).Build ());
Console.WriteLine ("User will rate app later");
};
key = new KeyStorageServiceIos ();
var documents = Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData);
var pathToDatabase = Path.Combine(documents, "db_sqlite-net.db");
Connection conn = new Connection (pathToDatabase);
dao = new LagerDAO (conn,Variant);
dao.LimitExceeded += (object sender, EventArgs e) => PleaseBuyFullVersion ();
bl = new IndexerBuisnessService (dao, new TranslationServiceIos());
its = new TranslationServiceIos ();
// create a new window instance based on the screen size
window = new UIWindow (UIScreen.MainScreen.Bounds);
Dashboard = new DashBoardViewController ();
navController = new UINavigationController (Dashboard);
//navController.NavigationBar.BackgroundColor = UIColor.Clear;
// if(MonoTouch.Foundation.isi
// window.TintColor = UIColor.Purple;
window.RootViewController = navController;
// If you have defined a root view controller, set it here:
//this.window.RootViewController = dashboard;
// make the window visible
window.MakeKeyAndVisible ();
return true;
}
public void TranslateItem(Item item, ITranslationService service)
{
var sourceItem = Sitecore.Context.ContentDatabase.GetItem(item.ID, Sitecore.Globalization.Language.Parse(BaseLanguage));
Job job = Context.Job;
if (job != null)
{
job.Status.LogInfo(Translate.Text("Translating item by path {0}.", new object[] { item.Paths.FullPath }));
}
if (item.Versions.Count == 0)
{
if (sourceItem == null)
{
return;
}
item = item.Versions.AddVersion();
item.Editing.BeginEdit();
foreach (Field field in sourceItem.Fields)
{
if (string.IsNullOrEmpty(field.Name) || (string.IsNullOrEmpty(sourceItem[field.Name]) || field.Shared))
{
continue;
}
if (!FieldIsTranslatable(field) || FieldIsStandard(field))
{
item[field.Name] = sourceItem[field.Name];
}
else
{
if (field.TypeKey == "rich text")
{
Sitecore.Diagnostics.Log.Info("HTML Field", "Translator");
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(sourceItem[field.Name]);
HtmlNodeCollection coll = doc.DocumentNode.SelectNodes("//text()[normalize-space(.) != '']");
foreach (HtmlNode node in coll)
{
if (node.InnerText == node.InnerHtml)
{
node.InnerHtml = service.Translate(node.InnerText);
}
}
item[field.Name] = doc.DocumentNode.OuterHtml;
}
else
{
var text = sourceItem[field.Name];
var translatedText = string.Empty;
if (text.Length < MaxServiceRequestLength)
{
item[field.Name] = service.Translate(text);
continue;
}
translatedText = SplitText(text, MaxServiceRequestLength).Aggregate(translatedText, (current, textBlock) => current + service.Translate(textBlock));
item[field.Name] = translatedText;
}
}
}
item.Editing.EndEdit();
}
}
public BaseView(ITranslationService translationService)
{
_translationService = translationService;
Font = SystemFonts.MessageBoxFont;
InitializeComponent();
}
public ResourcesController(ITranslationService translationService, IConfigurationService configurationService)
{
_translationService = translationService;
_configurationService = configurationService;
}
public LoginView(ITranslationService translationService) : base(translationService)
{
InitializeComponent();
}
public TranslationsController(ILanguageService languageService, ITranslationService translationService)
{
_languageService = languageService;
_translationService = translationService;
}
public TranslationController(ITranslationService translationService)
{
_translationService = translationService;
}
public XSController(ITranslationService translator)
{
_translator = translator;
}
