public OrderPaidConsumer(ILicenseService licenseService, IOrderService orderService,
IWorkContext workContext)
{
this._licenseService = licenseService;
this._orderService = orderService;
this._workContext = workContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(ILicenseService licenseService, ILicenseValidationService licenseValidationService,
IMessageService messageService, INetworkLicenseService networkLicenseService,
ILicenseVisualizerService licenseVisualizerService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => networkLicenseService);
Argument.IsNotNull(() => licenseVisualizerService);
Argument.IsNotNull(() => uiVisualizerService);
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_messageService = messageService;
_networkLicenseService = networkLicenseService;
_licenseVisualizerService = licenseVisualizerService;
_uiVisualizerService = uiVisualizerService;
RemoveLicense = new Command(OnRemoveLicenseExecute);
ValidateLicenseOnServer = new TaskCommand(OnValidateLicenseOnServerExecuteAsync, OnValidateLicenseOnServerCanExecute);
ValidateLicenseOnLocalNetwork = new TaskCommand(OnValidateLicenseOnLocalNetworkExecuteAsync, OnValidateLicenseOnLocalNetworkCanExecute);
ShowLicense = new Command(OnShowLicenseExecute);
ShowLicenseUsage = new Command(OnShowLicenseUsageExecute);
ServerUri = string.Format("http://localhost:1815/api/license/validate");
}
public SettingsViewModel(
IRuntimeConfigurationService configurationService,
ILicenseService licenseService,
ICommandManager commandManager, DataPersisterService dataPersisterService,
GlobalFrontendService globalFrontendService, GlobalService globalService,
IAdvancedMessageService advancedMessageService,
AudioService audioService, MidiService midiService
)
{
Argument.IsNotNull(() => configurationService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => licenseService);
_configurationService = configurationService;
_commandManager = commandManager;
_globalService = globalService;
_advancedMessageService = advancedMessageService;
ApplicationState = globalFrontendService.ApplicationState;
OpenVstWorkerLogDirectory = new Command(OnOpenVstWorkerLogDirectoryExecute);
OpenDataDirectory = new Command(OnOpenDataDirectoryExecute);
Title = "Settings";
PresetDatabaseStatistics = dataPersisterService.GetStorageStatistics();
TotalPresets = (from p in PresetDatabaseStatistics select p.PresetCount).Sum();
TotalPresetsUncompressedSize = (from p in PresetDatabaseStatistics select p.PresetUncompressedSize).Sum();
TotalPresetsCompressedSize = (from p in PresetDatabaseStatistics select p.PresetCompressedSize).Sum();
SavedSpace = (from p in PresetDatabaseStatistics select p.SavedSpace).Sum();
SavedSpacePercent = (double)TotalPresetsCompressedSize / TotalPresetsUncompressedSize;
AudioOutputDevices = audioService.GetOutputDevices();
MidiInputDevices = midiService.GetInputDevices();
}
private string GetNonPermanentLicenseOptionText()
{
ILicenseService service = this.Services.GetService <ILicenseService>();
bool flag1 = service.FeaturesFromSku(service.MostPermissiveSkuId).Contains(ExpressionFeatureMapper.ActivationLicense);
bool flag2 = (int)this.GraceDaysRemaining == 1;
if (flag1)
{
if (flag2)
{
return(StringTable.LicensingRemainingDaysInActivationTextSingular);
}
return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.LicensingRemainingDaysInActivationTextPlural, new object[1]
{
(object)this.GraceDaysRemaining
}));
}
if (flag2)
{
return(StringTable.LicensingUseTrialTextSingular);
}
return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.LicensingUseTrialTextPlural, new object[1]
{
(object)this.GraceDaysRemaining
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(ILicenseService licenseService, ILicenseValidationService licenseValidationService,
IMessageService messageService, INetworkLicenseService networkLicenseService,
ILicenseVisualizerService licenseVisualizerService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => networkLicenseService);
Argument.IsNotNull(() => licenseVisualizerService);
Argument.IsNotNull(() => uiVisualizerService);
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_messageService = messageService;
_networkLicenseService = networkLicenseService;
_licenseVisualizerService = licenseVisualizerService;
_uiVisualizerService = uiVisualizerService;
RemoveLicense = new Command(OnRemoveLicenseExecute);
ValidateLicenseOnServer = new TaskCommand(OnValidateLicenseOnServerExecuteAsync, OnValidateLicenseOnServerCanExecute);
ValidateLicenseOnLocalNetwork = new TaskCommand(OnValidateLicenseOnLocalNetworkExecuteAsync, OnValidateLicenseOnLocalNetworkCanExecute);
ShowLicense = new Command(OnShowLicenseExecute);
ShowLicenseUsage = new Command(OnShowLicenseUsageExecute);
ServerUri = string.Format("http://localhost:1815/api/license/validate");
}
public LicenseViewModel(LicenseInfo licenseInfo, INavigationService navigationService, IProcessService processService,
ILicenseService licenseService, ILicenseValidationService licenseValidationService, IUIVisualizerService uiVisualizerService,
IMessageService messageService, ILanguageService languageService, ILicenseModeService licenseModeService)
{
Argument.IsNotNull(() => licenseInfo);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => languageService);
Argument.IsNotNull(() => licenseModeService);
_navigationService = navigationService;
_processService = processService;
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
_languageService = languageService;
_licenseModeService = licenseModeService;
LicenseInfo = licenseInfo;
Title = licenseInfo.Title;
XmlData = new ObservableCollection <XmlDataModel>();
Paste = new TaskCommand(OnPasteExecuteAsync);
ShowClipboard = new TaskCommand(OnShowClipboardExecuteAsync);
PurchaseLinkClick = new Command(OnPurchaseLinkClickExecute);
AboutSiteClick = new Command(OnAboutSiteClickExecute);
RemoveLicense = new TaskCommand(OnRemoveLicenseExecuteAsync, OnRemoveLicenseCanExecute);
}
private LicenseSectionController(
ILicenseService licenseService,
IDialogManager dialogManager)
{
_licenseService = licenseService;
_dialogManager = dialogManager;
}
public LicenseModelFactory(
IBaseModelFactory baseModelFactory,
ILicenseService licenseService)
{
_baseModelFactory = baseModelFactory;
_licenseService = licenseService;
}
private string GetDaysRemainingMessage(ILicenseService licenseService, Guid skuId)
{
uint num = (uint)Math.Floor((double)licenseService.GetRemainingGraceMinutes(skuId) / 1440.0);
bool flag = (int)num == 1;
if (licenseService.SkusFromFeature(ExpressionFeatureMapper.ActivationLicense).Contains(skuId))
{
if (flag)
{
return(StringTable.AboutDialogRemainingDaysToActivateMessageSingular);
}
return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.AboutDialogRemainingDaysToActivateMessagePlural, new object[1]
{
(object)num.ToString((IFormatProvider)CultureInfo.CurrentCulture)
}));
}
if (flag)
{
return(StringTable.AboutDialogRemainingTrialDaysMessageSingular);
}
return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.AboutDialogRemainingTrialDaysMessagePlural, new object[1]
{
(object)num.ToString((IFormatProvider)CultureInfo.CurrentCulture)
}));
}
public ToolsUpdateLicenseCommandContainer(ICommandManager commandManager, IServiceLocator serviceLocator)
: base(Commands.Tools.UpdateLicense, commandManager, serviceLocator)
{
_openFileService = ServiceLocator.ResolveType <IOpenFileService>();
_licenseService = ServiceLocator.ResolveType <ILicenseService>();
_messageService = ServiceLocator.ResolveType <IMessageService>();
}
private void btnRemoveSelected_Click(object sender, System.Windows.RoutedEventArgs e)
{
if (gridProducts.SelectedItem != null)
{
Product product = gridProducts.SelectedItem as Product;
if (MessageBox.Show(string.Format("Are you sure you want to delete the {0} product?", product.Name), "Delete Product", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
ILicenseService licenseService = ObjectLocator.GetInstance <ILicenseService>();
if (licenseService.IsProductIdUsed(product.ProductId))
{
MessageBox.Show(string.Format("Cannot delete the {0} product as it is active.", product.Name));
return;
}
IProductsService productsService = ObjectLocator.GetInstance <IProductsService>();
productsService.DeleteProductById(product.ProductId);
IEventAggregator eventAggregator = ObjectLocator.GetInstance <IEventAggregator>();
eventAggregator.SendMessage <ProductsUpdatedEvent>();
gridProducts.ItemsSource = productsService.GetAllProducts();
}
}
else
{
MessageBox.Show("Please select a product to remove from the grid above.");
}
}
public override void Configure(object viewModelInfo)
{
var showRegister = (bool)viewModelInfo;
server = new DeployLXLicensingServer();
server.CookieContainer = new CookieContainer();
licenseService = ServiceLocator.Current.GetInstance <ILicenseService>();
NotificationRequest = new InteractionRequest <INotification>();
title = CommonResourceManager.Instance.GetResourceString("Common_RegistrationView_Title");
InitializeCommands();
if (showRegister)
{
InitializeRegister(true);
OnInitialized();
return;
}
Initialize();
OnInitialized();
}
/// <summary>
/// Initializes a new instance of the <see cref="LicenseViewModel" /> class.
/// </summary>
/// <param name="licenseInfo">The single license model.</param>
/// <param name="navigationService">The navigation service.</param>
/// <param name="processService">The process service.</param>
/// <param name="licenseService">The license service.</param>
/// <param name="licenseValidationService">The license validation service.</param>
/// <param name="uiVisualizerService">The uiVisualizer service.</param>
/// <param name="messageService">The message service.</param>
/// <exception cref="ArgumentNullException">The <paramref name="licenseInfo" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigationService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="processService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="licenseService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="uiVisualizerService" /> is <c>null</c>.</exception>
public LicenseViewModel(LicenseInfo licenseInfo, INavigationService navigationService, IProcessService processService,
ILicenseService licenseService, ILicenseValidationService licenseValidationService, IUIVisualizerService uiVisualizerService,
IMessageService messageService)
{
Argument.IsNotNull(() => licenseInfo);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
_navigationService = navigationService;
_processService = processService;
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
LicenseInfo = licenseInfo;
Title = licenseInfo.Title;
XmlData = new ObservableCollection<XmlDataModel>();
Paste = new TaskCommand(OnPasteExecuteAsync);
ShowClipboard = new Command(OnShowClipboardExecute);
PurchaseLinkClick = new Command(OnPurchaseLinkClickExecute);
AboutSiteClick = new Command(OnAboutSiteClickExecute);
RemoveLicense = new TaskCommand(OnRemoveLicenseExecuteAsync, OnRemoveLicenseCanExecute);
}
public LicensesController(IEmailSender emailSender, ILicenseService licenseService, ILicensePaymentService licensePaymentService, IHttpUserContext userContext, ILicenseTypesService licenseTypesService)
{
_licenseService = licenseService;
_licensePaymentService = licensePaymentService;
_userContext = userContext;
_licenseTypesService = licenseTypesService;
}
private static void RemoveProduct(object sender, ExecutedRoutedEventArgs e)
{
MainWindow mainWindow = (MainWindow)sender;
if (mainWindow.ProductsScreen != null)
{
if (mainWindow.ProductsScreen.SelectedProduct != null)
{
if (MessageBox.Show(string.Format("Are you sure you want to delete the {0} product?", mainWindow.ProductsScreen.SelectedProduct.Name), "Delete Product", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
ILicenseService licenseService = ObjectLocator.GetInstance <ILicenseService>();
if (licenseService.IsProductIdUsed(mainWindow.ProductsScreen.SelectedProduct.ProductId))
{
MessageBox.Show(string.Format("Cannot delete the {0} product as it is active.", mainWindow.ProductsScreen.SelectedProduct.Name));
return;
}
IProductsService productsService = ObjectLocator.GetInstance <IProductsService>();
productsService.DeleteProductById(mainWindow.ProductsScreen.SelectedProduct.ProductId);
IEventAggregator eventAggregator = ObjectLocator.GetInstance <IEventAggregator>();
eventAggregator.SendMessage <ProductsUpdatedEvent>();
}
}
else
{
MessageBox.Show("You must select a product first.");
}
}
}
internal static LicenseState ProjectTypeLicense(ProjectLicenseGroup group, IServiceProvider services)
{
ILicenseService service = services.GetService <ILicenseService>();
switch (group)
{
case ProjectLicenseGroup.WpfSilverlight:
{
IList <Guid> guids = service.SkusFromFeature(ExpressionFeatureMapper.WpfFeature);
IList <Guid> guids1 = service.SkusFromFeature(ExpressionFeatureMapper.SilverlightFeature);
return(LicensingHelper.DetermineLicenseState(service, LicensingHelper.CombineLists(guids, guids1)));
}
case ProjectLicenseGroup.SilverlightMobile:
{
return(LicensingHelper.DetermineLicenseState(service, service.SkusFromFeature(ExpressionFeatureMapper.MobileFeature)));
}
case ProjectLicenseGroup.SketchFlow:
{
IList <Guid> list = service.SkusFromFeature(ExpressionFeatureMapper.HobbledSketchFlowFeature);
list = list.Union <Guid>(service.SkusFromFeature(ExpressionFeatureMapper.SketchFlowFeature)).ToList <Guid>();
return(LicensingHelper.DetermineLicenseState(service, list));
}
}
return(LicenseState.FullLicense());
}
private static bool ShouldNag(ILicenseService licenseService, Guid skuId, int nagDays)
{
if (licenseService.IsInGrace(skuId) && licenseService.FeaturesFromSku(skuId).Contains(ExpressionFeatureMapper.TrialLicense))
{
return(licenseService.GetRemainingGraceMinutes(skuId) / 1440 < nagDays);
}
return(false);
}
private string GetFullyLicensedMessage(ILicenseService licenseService, Guid skuId)
{
if (!licenseService.SkusFromFeature(ExpressionFeatureMapper.ActivationLicense).Contains(skuId))
{
return(StringTable.AboutDialogFullyLicensedMessage);
}
return(StringTable.AboutDialogFullyLicensedAndActivatedMessage);
}
public static DateTime?GetCurrentLicenseExpirationDateTime(this ILicenseService licenseService)
{
Argument.IsNotNull(() => licenseService);
var license = licenseService.CurrentLicense;
return((license != null) ? license.Expiration : (DateTime?)null);
}
/// <summary>
/// Instantiates new instance of <see cref="ContactTrackingService"/>.
/// </summary>
public ContactTrackingService()
{
mCurrentContactProvider = Service.Entry <ICurrentContactProvider>();
mSiteService = Service.Entry <ISiteService>();
mLicenseService = Service.Entry <ILicenseService>();
mCrawlerChecker = Service.Entry <ICrawlerChecker>();
mSettingsService = Service.Entry <ISettingsService>();
}
public NoteProcessingService()
{
handHistoryParserFactory = ServiceLocator.Current.GetInstance <IHandHistoryParserFactory>();
storageModel = ServiceLocator.Current.TryResolve <SingletonStorageModel>();
licenseService = ServiceLocator.Current.GetInstance <ILicenseService>();
InitializeLimits();
}
public VstPluginSettingsViewModel(Plugin plugin, IVstService vstService, IOpenFileService openFileService,
ISelectDirectoryService selectDirectoryService, ILicenseService licenseService,
IAdvancedMessageService messageService,
ICommandManager commandManager,
RemoteVstService remoteVstService,
INativeInstrumentsResourceGeneratorService
resourceGeneratorService)
{
Argument.IsNotNull(() => vstService);
Argument.IsNotNull(() => openFileService);
Argument.IsNotNull(() => selectDirectoryService);
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => resourceGeneratorService);
Argument.IsNotNull(() => commandManager);
Plugin = plugin;
_openFileService = openFileService;
_commandManager = commandManager;
_selectDirectoryService = selectDirectoryService;
_licenseService = licenseService;
_vstService = vstService;
_resourceGeneratorService = resourceGeneratorService;
_messageService = messageService;
_remoteVstService = remoteVstService;
OpenNKSFile = new TaskCommand(OnOpenNKSFileExecute);
ClearMappings = new TaskCommand(OnClearMappingsExecute);
AddAdditionalPresetFiles = new TaskCommand(OnAddAdditionalPresetFilesExecute);
AddAdditionalPresetFolder = new TaskCommand(OnAddAdditionalPresetFolderExecute);
RemoveAdditionalBankFiles = new Command <object>(OnRemoveAdditionalBankFilesExecute);
RemoveCategory = new Command <object>(OnRemoveCategoryExecute);
AddCategory = new Command(OnAddCategoryExecute);
ReplaceVBLogo = new TaskCommand(OnReplaceVBLogoExecute);
ReplaceVBArtwork = new TaskCommand(OnReplaceVBArtworkExecute);
ReplaceMSTLogo = new TaskCommand(OnReplaceMSTLogoExecute);
ReplaceMSTArtwork = new TaskCommand(OnReplaceMSTArtworkExecute);
ReplaceMSTPlugin = new TaskCommand(OnReplaceMSTPluginExecute);
ReplaceOSOLogo = new TaskCommand(OnReplaceOSOLogoExecute);
SubmitResource = new TaskCommand(OnSubmitResourceExecute);
QueryOnlineResources = new TaskCommand(OnQueryOnlineResourcesExecute);
LoadSelectedOnlineResource = new TaskCommand(OnLoadSelectedOnlineResourceExecute);
GenerateResources = new TaskCommand(OnGenerateResourcesExecute);
Title = "Settings for " + Plugin.PluginName;
GenerateControllerMappingModels();
PluginLocations = (from pluginLocation in Plugin.PluginLocations
where pluginLocation.IsPresent
select pluginLocation).ToList();
}
public static bool IsSketchFlowLicensed(ILicenseService licenseService)
{
if (LicensingHelper.isAnySketchFlowSkuEnabled.HasValue)
{
return(LicensingHelper.isAnySketchFlowSkuEnabled.Value);
}
LicensingHelper.isAnySketchFlowSkuEnabled = new bool?(licenseService.IsAnySkuEnabled(licenseService.SkusFromFeature(ExpressionFeatureMapper.SketchFlowFeature)));
return(LicensingHelper.isAnySketchFlowSkuEnabled.Value);
}
public PluginNotExportedAllToPresetExportListCommandContainer(ICommandManager commandManager,
IServiceLocator serviceLocator)
: base(Commands.Plugin.NotExportedAllToPresetExportList, commandManager, serviceLocator)
{
_applicationService = ServiceLocator.ResolveType <IApplicationService>();
_dispatcherService = ServiceLocator.ResolveType <IDispatcherService>();
_licenseService = ServiceLocator.ResolveType <ILicenseService>();
_globalService = ServiceLocator.ResolveType <GlobalService>();
}
protected void ProcessLicenseServiceResponse(IEnterKeyResponse response)
{
ILicenseService service1 = this.Services.GetService <ILicenseService>();
IMessageDisplayService service2 = this.Services.GetService <IMessageDisplayService>();
this.IsLicensed = response.IsEnabled;
if ((int)response.ErrorCode != -1073418160)
{
LicensingDialogHelper.ShowErrorMessageFromResponse((ILicenseSubServiceResponse)response, service2);
}
if (!response.IsEnabled)
{
if (service1.HasKey(response.KeySku) && service1.GetUnlicensedReason(response.KeySku) == UnlicensedReason.GraceTimeExpired)
{
MessageBoxArgs args = new MessageBoxArgs()
{
Owner = (Window)this,
Message = StringTable.LicensingYouNeedToActivate,
Button = MessageBoxButton.OK,
Image = MessageBoxImage.Exclamation
};
int num = (int)service2.ShowMessage(args);
}
else
{
MessageBoxArgs args = new MessageBoxArgs()
{
Owner = (Window)this,
Message = StringTable.LicensingInvalidKeyMessage,
Button = MessageBoxButton.OK,
Image = MessageBoxImage.Hand
};
int num = (int)service2.ShowMessage(args);
}
}
else if (this.ShouldActivate && service1.SkusFromFeature(ExpressionFeatureMapper.ActivationLicense).Contains(response.KeySku) && !response.IsActivated)
{
MessageBoxArgs args = new MessageBoxArgs()
{
Owner = (Window)this,
Message = StringTable.LicensingEnterKeySucceededAndActivationFailed,
Image = MessageBoxImage.Exclamation
};
int num = (int)service2.ShowMessage(args);
LicensingDialogHelper.ShowActivationDialog(this.Services, (CommonDialogCreator) new ActivationDialogCreator(this.Services, ActivationWizardAction.ChooseActivationType));
}
else
{
MessageBoxArgs args = new MessageBoxArgs()
{
Owner = (Window)this,
Message = StringTable.LicensingValidMessage
};
int num = (int)service2.ShowMessage(args);
}
}
public UploadProductsWindow()
{
InitializeComponent();
WindowHelper.CheckAndApplyTheme(this);
_servicesService = ObjectLocator.GetInstance <IServicesService>();
_licenseSetService = ObjectLocator.GetInstance <ILicenseSetService>();
_licenseService = ObjectLocator.GetInstance <ILicenseService>();
}
public PluginNotExportedSelectedToPresetExportListCommandContainer(ICommandManager commandManager,
IServiceLocator serviceLocator)
: base(Commands.Plugin.NotExportedSelectedToPresetExportList, commandManager, serviceLocator)
{
_applicationService = ServiceLocator.ResolveType <IApplicationService>();
_dispatcherService = ServiceLocator.ResolveType <IDispatcherService>();
_licenseService = ServiceLocator.ResolveType <ILicenseService>();
_globalFrontendService.SelectedPlugins.CollectionChanged += OnSelectedPluginsListChanged;
}
public HudStoreViewModel()
{
licenseService = ServiceLocator.Current.GetInstance <ILicenseService>();
var eventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>();
eventAggregator.GetEvent <LicenseUpdatedEvent>().Subscribe(x => this.RaisePropertyChanged(nameof(IsOpenHudUploadToStoreVisible)));
OpenHudUploadToStoreRequest = new InteractionRequest <INotification>();
}
public UploadProductsWindow()
{
InitializeComponent();
WindowHelper.CheckAndApplyTheme(this);
_servicesService = ObjectLocator.GetInstance<IServicesService>();
_licenseSetService = ObjectLocator.GetInstance<ILicenseSetService>();
_licenseService = ObjectLocator.GetInstance<ILicenseService>();
}
public NetworkLicenseService(ILicenseService licenseService, IIdentificationService identificationService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => identificationService);
_licenseService = licenseService;
_identificationService = identificationService;
SearchTimeout = TimeSpan.FromSeconds(2);
}
public NetworkLicenseService(ILicenseService licenseService, IIdentificationService identificationService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => identificationService);
_licenseService = licenseService;
_identificationService = identificationService;
SearchTimeout = TimeSpan.FromSeconds(2);
}
private LicenseDialogController(
IDialogManager dialogManager,
ILicenseChecker licenseChecker,
ILicenseService licenseService,
IWebBrowser webBrowser)
{
_dialogManager = dialogManager;
_licenseChecker = licenseChecker;
_licenseService = licenseService;
_webBrowser = webBrowser;
}
public LicenseManager(
LicenseObjectContext objectContext,
IPermissionService permissionService,
ILicenseService licenseService,
IWebHelper webHelper)
{
_objectContext = objectContext;
_permissionService = permissionService;
_licenseService = licenseService;
_webHelper = webHelper;
}
public static string LoadExistingLicense(this ILicenseService licenseService)
{
var licenseString = licenseService.LoadLicense(LicenseMode.CurrentUser);
if (string.IsNullOrWhiteSpace(licenseString))
{
licenseString = licenseService.LoadLicense(LicenseMode.MachineWide);
}
return(licenseString);
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleLicenseService" /> class.
/// </summary>
/// <param name="licenseService">The license service.</param>
/// <param name="licenseValidationService">The license validation service.</param>
/// <param name="licenseVisualizerService">The license visualizer service.</param>
/// <param name="expirationBehavior">The expiration behavior.</param>
/// <exception cref="ArgumentNullException">The <paramref name="licenseService" /> is <c>null</c>.</exception>
public SimpleLicenseService(ILicenseService licenseService, ILicenseValidationService licenseValidationService, ILicenseVisualizerService licenseVisualizerService, IExpirationBehavior expirationBehavior)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => licenseVisualizerService);
Argument.IsNotNull(() => expirationBehavior);
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_licenseVisualizerService = licenseVisualizerService;
_expirationBehavior = expirationBehavior;
}
public ServicesService(IServicesRepository servicesRepository, IServiceStatusProvider serviceStatusProvider,
IPackingService packingService, ILicenseActiviationProvider licenseActiviationProvider, ILicenseKeyService licenseKeyService,
ILicenseService licenseService, ILicenseSetService licenseSetService, IClientLicenseService clientLicenseService,
IProductsProvider productsProvider)
{
_servicesRepository = servicesRepository;
_serviceStatusProvider = serviceStatusProvider;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_licenseKeyService = licenseKeyService;
_licenseService = licenseService;
_licenseSetService = licenseSetService;
_clientLicenseService = clientLicenseService;
_productsProvider = productsProvider;
}
public PayPalAdvancedPaymentProcessor(PayPalAdvancedPaymentSettings payPalAdvancedPaymentSettings,
ISettingService settingService,
ICustomerService customerService,
IWebHelper webHelper,
IOrderTotalCalculationService orderTotalCalculationService,
HttpContextBase httpContext,
IOrderService orderService,
ILicenseService licenseService,
PayPalAdvancedObjectContext objectContext,
IEncryptionService encryptionService,
PayPalHelper payPalHelper)
{
this._payPalAdvancedPaymentSettings = payPalAdvancedPaymentSettings;
this._settingService = settingService;
this._customerService = customerService;
this._webHelper = webHelper;
this._orderTotalCalculationService = orderTotalCalculationService;
this._httpContext = httpContext;
this._licenseService = licenseService;
this._objectContext = objectContext;
this._encryptionService = encryptionService;
this._payPalHelper = payPalHelper;
}
public PaymentPayPalAdvancedController(
IWorkContext workContext,
IStoreService storeService,
ISettingService settingService,
IPaymentService paymentService,
IOrderService orderService,
IOrderProcessingService orderProcessingService,
ILocalizationService localizationService,
IStoreContext storeContext,
IOrderTotalCalculationService orderTotalCalculationService,
ICurrencyService _currencyService,
IPriceFormatter priceFormatter,
ITaxService taxService,
PayPalAdvancedPaymentSettings payPalAdvancedPaymentSettings,
TaxSettings taxSettings,
RewardPointsSettings rewardPointsSettings,
ILicenseService licenseService,
IEncryptionService encryptionService,
PayPalHelper payPalHelper,
ILogger logger)
{
this._workContext = workContext;
this._storeService = storeService;
this._settingService = settingService;
this._paymentService = paymentService;
this._orderService = orderService;
this._orderProcessingService = orderProcessingService;
this._localizationService = localizationService;
this._storeContext = storeContext;
this._orderTotalCalculationService = orderTotalCalculationService;
this._currencyService = _currencyService;
this._priceFormatter = priceFormatter;
this._taxService = taxService;
this._payPalAdvancedPaymentSettings = payPalAdvancedPaymentSettings;
this._taxSettings = taxSettings;
this._rewardPointsSettings = rewardPointsSettings;
this._licenseService = licenseService;
this._encryptionService = encryptionService;
this._payPalHelper = payPalHelper;
this._logger = logger;
}
public LicenseController(IMachineCodeProvider machineCodeProvider, ILicenseService licenseService) {
this._machineCodeProvider = machineCodeProvider;
this._licenseService = licenseService;
}
