public ExecuteCommandCreateNewProcessTask(IActivateItems activator, ProcessTaskType taskType, LoadMetadata loadMetadata, LoadStage loadStage, FileInfo file = null) : base(activator) { _taskType = taskType; _loadMetadata = loadMetadata; _loadStage = loadStage; try { _LoadDirectory = new LoadDirectory(_loadMetadata.LocationOfFlatFiles); } catch (Exception) { SetImpossible("Could not construct LoadDirectory"); } if (taskType == ProcessTaskType.SQLFile) { _image = activator.CoreIconProvider.GetImage(RDMPConcept.SQL, OverlayKind.Add); } else if (taskType == ProcessTaskType.Executable) { _image = new IconOverlayProvider().GetOverlayNoCache(CatalogueIcons.Exe, OverlayKind.Add); } else { SetImpossible("Only SQLFile and Executable task types are supported by this command"); } if (!ProcessTask.IsCompatibleStage(taskType, loadStage)) { SetImpossible("You cannot run " + taskType + " in " + loadStage); } _file = file; }
public ExecuteCommandCreateNewClassBasedProcessTask(IBasicActivateItems activator, LoadMetadata loadMetadata, LoadStage loadStage, [DemandsInitialization("Class to execute, must be an attacher, mutilater etc", TypeOf = typeof(IDisposeAfterDataLoad))] Type type) : base(activator) { _loadMetadata = loadMetadata; _loadStage = loadStage; _type = type; if (typeof(IAttacher).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.Attacher; } else if (typeof(IDataProvider).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.DataProvider; } else if (typeof(IMutilateDataTables).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.MutilateDataTable; } else { SetImpossible($"Type '{_type}' was not a compatible one e.g. IAttacher, IDataProvider or IMutilateDataTables"); } }
public ExecuteCommandCreateNewFileBasedProcessTask(IBasicActivateItems activator, ProcessTaskType taskType, LoadMetadata loadMetadata, LoadStage loadStage, FileInfo file = null) : base(activator) { _taskType = taskType; _loadMetadata = loadMetadata; _loadStage = loadStage; try { _LoadDirectory = new LoadDirectory(_loadMetadata.LocationOfFlatFiles); } catch (Exception) { SetImpossible("Could not construct LoadDirectory"); } if (!(taskType == ProcessTaskType.SQLFile || taskType == ProcessTaskType.Executable)) { SetImpossible("Only SQLFile and Executable task types are supported by this command"); } if (!ProcessTask.IsCompatibleStage(taskType, loadStage)) { SetImpossible("You cannot run " + taskType + " in " + loadStage); } _file = file; }
public void EmptyFilePath(string path, ProcessTaskType typeThatRequiresFiles) { _task.ProcessTaskType = typeThatRequiresFiles; _task.Path = path; _task.SaveToDatabase(); var ex = Assert.Throws <Exception>(() => _checker.Check(new ThrowImmediatelyCheckNotifier())); StringAssert.Contains("does not have a path specified", ex.Message); }
public void EmptyClassPath(string path, ProcessTaskType typeThatRequiresMEF, LoadStage stage) { _task.ProcessTaskType = typeThatRequiresMEF; _task.Path = path; _task.LoadStage = stage; _task.SaveToDatabase(); var ex = Assert.Throws <ArgumentException>(() => _checker.Check(new ThrowImmediatelyCheckNotifier())); Assert.IsTrue(Regex.IsMatch(ex.Message, "Path is blank for ProcessTask 'New Process.*' - it should be a class name of type")); }
private void AddTypeIntoStage(Type type, ProcessTaskType taskType) { var lmd = _loadStageNode.LoadMetadata; var stage = _loadStageNode.LoadStage; ProcessTask newTask = new ProcessTask((ICatalogueRepository)lmd.Repository, lmd, stage); newTask.Path = type.FullName; newTask.ProcessTaskType = taskType; newTask.Name = type.Name; newTask.SaveToDatabase(); Publish(lmd); Activate(newTask); }
internal ProcessTask(ICatalogueRepository repository, DbDataReader r) : base(repository, r) { LoadMetadata_ID = int.Parse(r["LoadMetaData_ID"].ToString()); if (r["RelatesSolelyToCatalogue_ID"] != DBNull.Value) { _relatesSolelyToCatalogueID = int.Parse(r["RelatesSolelyToCatalogue_ID"].ToString()); } Path = r["Path"] as string; Name = r["Name"] as string; Order = int.Parse(r["Order"].ToString()); ProcessTaskType processTaskType; if (ProcessTaskType.TryParse(r["ProcessTaskType"] as string, out processTaskType)) { ProcessTaskType = processTaskType; } else { throw new Exception("Could not parse ProcessTaskType:" + r["ProcessTaskType"]); } LoadStage loadStage; if (LoadStage.TryParse(r["LoadStage"] as string, out loadStage)) { LoadStage = loadStage; } else { throw new Exception("Could not parse LoadStage:" + r["LoadStage"]); } IsDisabled = Convert.ToBoolean(r["IsDisabled"]); }
/// <summary> /// Returns true if the <see cref="ProcessTaskType"/> is allowed to happen during the given <see cref="LoadStage"/> (e.g. you can't use an IAttacher to /// load data into STAGING/LIVE - only RAW). /// </summary> /// <param name="type"></param> /// <param name="stage"></param> /// <returns></returns> public static bool IsCompatibleStage(ProcessTaskType type, LoadStage stage) { switch (type) { case ProcessTaskType.Executable: return(true); case ProcessTaskType.SQLFile: return(stage != LoadStage.GetFiles); case ProcessTaskType.Attacher: return(stage == LoadStage.Mounting); case ProcessTaskType.DataProvider: return(true); case ProcessTaskType.MutilateDataTable: return(stage != LoadStage.GetFiles); default: throw new ArgumentOutOfRangeException("type"); } }
private void SetType(Type type) { _type = type; if (typeof(IAttacher).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.Attacher; } else if (typeof(IDataProvider).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.DataProvider; } else if (typeof(IMutilateDataTables).IsAssignableFrom(_type)) { _processTaskType = ProcessTaskType.MutilateDataTable; } else { SetImpossible($"Type '{_type}' was not a compatible one e.g. IAttacher, IDataProvider or IMutilateDataTables"); } }