public Object Any(Services.Activate request)
        {
            var command = request.ConvertTo<Activate>();

            command.UserId = this.Profile.UserId;
            return _bus.Send(command).IsCommand<Command>();
        }

		public override string OpenEditorScript(Services.JavaScriptTextEditor editor, Control e) {
			string openScript = "";
			string closeScript = "";
			Services.IJavaScriptTextEditable editable = null;
			if (e is Services.IJavaScriptTextEditable) {
				editable = (Services.IJavaScriptTextEditable)e;
				e = editable.Content;
				openScript = editable.OnClientOpenEditor + ";";
				closeScript = editable.OnClientCloseEditor;
			}
			if (Web.UI.Scripts.jQuery.Register(e.Page) &&
#if DEBUG
				Web.UI.Scripts.Register(e.Page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/ckeditor.js") &&
				// Web.Scripts.Register(e.Page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/config.js") && 
				// Web.UI.Scripts.Register(e.Page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/adapters/jquery.js") &&
				Web.UI.Scripts.Register(e.Page, "~/Silversite/Extensions/Silversite.CKEditor/js/Silversite.CKEditor.js")) {
#else
				Web.Scripts.Register(page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/ckeditor.js") &&
				// Web.Scripts.Register(page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/config.js") && 
				// Web.Scripts.Register(page, "~/Silversite/Extensions/Silversite.CKEditor/ckeditor/adapters/jquery.js") &&
				Web.Scripts.Register(page, "~/Silversite/Extensions/Silversite.CKEditor/js/Silversite.CKEditor.js")) {
#endif
				if (string.IsNullOrEmpty(e.ClientID)) throw new ArgumentException("Content must have valid ID.");

				return openScript + "Silversite.CKEditor.Open('" + e.ClientID + "', " + CallbackCommandScript(e) + ", '" + editor.ContentType + "', '" + editor.Menu.ToString() + "', " + closeScript + "');";
			}
			return string.Empty;
		}

		Html.Converter converter = null;

 public EggGroupsController(Services.ServerService ServerService, Services.EggGroupService Service,
     SLLog Log)
 {
     Log_ = Log;
     Service_ = Service;
     this.ServerService_ = ServerService;
 }

        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel(IDataService dataService, Services.IQaStringGeneratorService generator)
        {
            _dataService = dataService;
            _generator = generator;

            _generatedTexts = new System.Collections.ObjectModel.ObservableCollection<TextItemViewModel>();

            this.PropertyChanged += MainViewModel_PropertyChanged;

            _dataService.GetData(
                (item, error) =>
                {
                    if (error != null)
                    {
                        // Report error here
                        return;
                    }

                    _pattern = item.LastPattern;
                    _numberOfCharacters = item.LastCount;
                    _qAApproved = item.LastQa;
                    _countList = item.LastCountList;

                    _results = _generator.Generate(this.NumberOfCharacters, this.Pattern, this.QAApproved);

                    generateCountList();
                });
        }

        public BaseModule(IEventBus eventBus, Services.IGlobalSettingsService globalSettingsService, string modulePath, bool verifyConfigured) : base(modulePath)
        {
            EventBus = eventBus;
            GlobalSettingsService = globalSettingsService;

            WireSetupPipeline(verifyConfigured);
        }

 internal Passive(Services.Dto.StaticData.PassiveDto passiveDto)
 {
     this.Description = passiveDto.description;
     this.image_full = passiveDto.image.full;
     this.Name = passiveDto.name;
     this.SanitizedDescription = passiveDto.sanitizedDescription;
 }

 internal Info(Services.Dto.StaticData.InfoDto infoDto)
 {
     this.Attack = infoDto.attack;
     this.Defense = infoDto.defense;
     this.Difficulty = infoDto.difficulty;
     this.Magic = infoDto.magic;
 }

        public Object Post(Services.Create request)
        {
            var command = request.ConvertTo<Domain.Configuration.AccountType.Commands.Create>();
            command.DeferralMethod = DEFERRAL_METHOD.FromValue(request.DeferralMethod);

            return _bus.Send(command).IsCommand<Command>();
        }

 public EmailService(Services.ServerService ServerService)
 {
     EmailAddress = ServerService.GetEmailAddress();
     EmailPassword = ServerService.GetEmailPassword();
     SMTPAddress = ServerService.GetSMTPSettings();
     SMTPPort = ServerService.GetSMTPPort();
 }

 public GameController(Services.ServerService ServerService,
     Services.GameService GameService, Services.PokedexService PokedexService)
 {
     this.ServerService_ = ServerService;
     this.GameService_ = GameService;
     this.PokedexService_ = PokedexService;
 }

 private static void CreateTestProject(bool useOAuthEndpoints)
 {
     V1Connector connector;
     if (useOAuthEndpoints)
     {
         connector = V1Connector.WithInstanceUrl(ConfigurationManager.AppSettings.Get("V1Url"))
             .WithUserAgentHeader("IntegrationTests", "1.0")
             .WithAccessToken(ConfigurationManager.AppSettings.Get("V1AccessToken"))
             .UseOAuthEndpoints()
             .Build();
     }
     else
     {
         connector = V1Connector.WithInstanceUrl(ConfigurationManager.AppSettings.Get("V1Url"))
             .WithUserAgentHeader("IntegrationTests", "1.0")
             .WithAccessToken(ConfigurationManager.AppSettings.Get("V1AccessToken"))
             .Build();
     }
     var services = new Services(connector);
     var assetType = services.Meta.GetAssetType("Scope");
     var nameAttribute = assetType.GetAttributeDefinition("Name");
     var projectId = services.GetOid("Scope:0");
     var newAsset = services.New(assetType, projectId);
     newAsset.SetAttributeValue(nameAttribute, TestProjectName);
     services.Save(newAsset);
     _testProjectId = newAsset.Oid.Momentless;
 }

        public EmailerService(Logging.ILogger logger
			, Services.IConnectorService connectorService
			, Services.IAccountService accountService
			, Services.CryptoService cryptoService
			, Services.IScheduledTaskService taskService
			)
        {
            this.Logger = logger;
            this.ConnectorService = connectorService;
            this.CryptoService = cryptoService;
            this.AccountService = accountService;
            this.TaskService = taskService;

            var smtpSection = System.Configuration.ConfigurationManager.GetSection("system.net/mailSettings/smtp") as System.Net.Configuration.SmtpSection;
            if (!smtpSection.From.IsNullOrTrimmedEmpty())
            {
                m_MailFrom = new MailAddress(smtpSection.From);
            }
            else
            {
                m_MailFrom = new MailAddress(ERPStoreApplication.WebSiteSettings.Contact.EmailSender,
                               ERPStoreApplication.WebSiteSettings.Contact.EmailSenderName);
            }

            var bccEmail = ERPStoreApplication.WebSiteSettings.Contact.BCCEmail ?? ERPStoreApplication.WebSiteSettings.Contact.ContactEmail;
            m_Bcc = new MailAddressCollection();
            if (bccEmail != null)
            {
                var emailList = bccEmail.Split(';');
                foreach (var email in emailList)
                {
                    m_Bcc.Add(email.Trim());
                }
            }
        }

        public BackgroundViewModel(Services.IBackgroundServiceFactory backgroundServiceFactory)
        {
            _backgroundService = backgroundServiceFactory.MakeBackgroundServiceFromRunner<BackgroundRunners.CounterRunner>();

            _backgroundService.StartService();
            CounterState = GetRunnerCounterState();
        }

 /// <summary>
 /// Creates an instance of the USPS API
 /// </summary>
 /// <param name="userID">Username</param>
 /// <param name="password">Password</param>
 public USPSProvider(string userID, string password)
 {
     this._name = "USPS";
     this._userID = userID;
     this._password = password;
     this._services = Services.Express;
 }

 internal Gold(Services.Dto.StaticData.GoldDto goldDto)
 {
     this.BasePrice = [email protected];
     this.Purchasable = goldDto.purchasable;
     this.Sell = goldDto.sell;
     this.Total = goldDto.total;
 }

		protected override void OnExecute(Services.CommandContext context)
		{
			if(context.Arguments.Length < 1)
				throw new Zongsoft.Services.CommandException("Missing arguments.");

			var dictionary = this.Redis.GetDictionary(context.Arguments[0]);

			switch(context.Arguments.Length)
			{
				case 1:
					if(context.Options.Contains("all"))
					{
						context.Result = (IEnumerable<KeyValuePair<string, string>>)dictionary;
						return;
					}

					throw new Zongsoft.Services.CommandException("Missing arguments.");
				case 2:
					context.Result = dictionary[context.Arguments[1]];
					return;
			}

			var keys = new string[context.Arguments.Length - 1];
			Array.Copy(context.Arguments, 1, keys, 0, keys.Length);

			context.Result = dictionary.GetValues(keys);
		}

 public TransporterPaymentRequestController(IBusinessProcessService _paramBusinessProcessService
                                            , IBusinessProcessStateService _paramBusinessProcessStateService
                                            , IApplicationSettingService _paramApplicationSettingService
                                            , ITransporterPaymentRequestService transporterPaymentRequestService
                                            , ITransportOrderService _paramTransportOrderService
                                            , IBidWinnerService bidWinnerService
                                            , IDispatchService dispatchService
                                            , IWorkflowStatusService workflowStatusService
                                            , IUserAccountService userAccountService
                                            , Services.Procurement.ITransporterService transporterService,
                                            ITransportOrderService transportOrderService,
                                            ITransportOrderDetailService transportOrderDetailService, ICommonService commodityService
                                            , IFlowTemplateService flowTemplateService)
 {
     _BusinessProcessService = _paramBusinessProcessService;
     _BusinessProcessStateService = _paramBusinessProcessStateService;
     _ApplicationSettingService = _paramApplicationSettingService;
     _transporterPaymentRequestService = transporterPaymentRequestService;
     _TransportOrderService = _paramTransportOrderService;
     _bidWinnerService = bidWinnerService;
     _dispatchService = dispatchService;
     _workflowStatusService = workflowStatusService;
     _userAccountService = userAccountService;
     _transporterService = transporterService;
     _transportOrderService = transportOrderService;
     _transportOrderDetailService = transportOrderDetailService;
     _commodityService = commodityService;
     _flowTemplateService = flowTemplateService;
 }

        public ServicesManager(
            INutConfiguration configurationManager,
            Infrastructure.ConfigurationManagement.DbConfigurationSettings.Factory dbConfigurationSettingsFactory,
            IEventBus eventBus,
            IEnumerable<IReportPeriodically> pushServices,
            IEnumerable<IRemoteInvocationService> remoteInvokedServices,
            Services.IGlobalSettingsService globalSettings,
            Func<RegisteredPackagesPollingClient> packagesPollerFactory,
            Func<PollingClientCollection> pollingCollectionFactory,
            Repositories.IPackageRepository packageRepository,
            IHoardeManager hoardeManager)
        {
            _log = LogProvider.For<ServicesManager>();

            _configurationManager = configurationManager;
            _dbConfigurationSettingsFactory = dbConfigurationSettingsFactory;
            _eventBus = eventBus;
            _pushServices = pushServices;
            _remoteInvokedServices = remoteInvokedServices;
            _globalSettings = globalSettings;

            _packagesPollerFactory = packagesPollerFactory;
            _pollingCollectionFactory = pollingCollectionFactory;

            _packageRepository = packageRepository;

            _hoardeManager = hoardeManager;
        }

 internal Passive(Services.Dto.StaticData.PassiveDto passiveDto)
 {
     this.Description = passiveDto.description;
     this.Image = new Image(passiveDto.image);
     this.Name = passiveDto.name;
     this.SanitizedDescription = passiveDto.sanitizedDescription;
 }

		protected override void OnExecute(Services.CommandContext context)
		{
			if(context.Arguments.Length < 1)
				throw new Services.CommandException("Missing arguments.");

			var length = (int)context.Options["length"];

			if(context.Arguments.Length == 1)
			{
				context.Result = this.Redis.GetQueue(context.Arguments[0]).Dequeue(length);
				return;
			}

			var result = new string[context.Arguments.Length * length];

			for(int i = 0; i < context.Arguments.Length; i++)
			{
				var queue = this.Redis.GetQueue(context.Arguments[i]);
				var items = queue.Dequeue(length);

				int j = 0;

				foreach(var item in items)
				{
					result[i * context.Arguments.Length + j++] = (string)item;
				}
			}

			context.Result = result;
		}