private void WuModule(EntityPolicyModules policyModule)
{
var clientWuModule = new DtoClientWuModule();
var wuModule = new ServiceWuModule().GetModule(policyModule.ModuleId);
clientWuModule.Guid = wuModule.Guid;
clientWuModule.DisplayName = wuModule.Name;
clientWuModule.Arguments = wuModule.AdditionalArguments;
clientWuModule.Order = policyModule.Order;
clientWuModule.Timeout = wuModule.Timeout;
clientWuModule.RedirectOutput = wuModule.RedirectStdOut;
clientWuModule.RedirectError = wuModule.RedirectStdError;
foreach (var successCode in wuModule.SuccessCodes.Split(','))
{
clientWuModule.SuccessCodes.Add(successCode);
}
if (policyModule.ConditionId != -1)
{
var conditionScript = new ServiceScriptModule().GetModule(policyModule.ConditionId);
if (conditionScript != null)
{
clientWuModule.ConditionFailedAction = policyModule.ConditionFailedAction;
clientWuModule.ConditionNextOrder = policyModule.ConditionNextModule;
clientWuModule.Condition = new DtoClientModuleCondition();
clientWuModule.Condition.Arguments = conditionScript.Arguments;
clientWuModule.Condition.DisplayName = conditionScript.Name;
clientWuModule.Condition.Guid = conditionScript.Guid;
clientWuModule.Condition.RedirectError = conditionScript.RedirectStdError;
clientWuModule.Condition.RedirectOutput = conditionScript.RedirectStdOut;
if (conditionScript.ImpersonationId != -1)
{
var scriptImpersonationGuid = new ServiceImpersonationAccount().GetGuid(conditionScript.ImpersonationId);
if (!string.IsNullOrEmpty(scriptImpersonationGuid))
{
clientWuModule.Condition.RunAs = scriptImpersonationGuid;
}
}
clientWuModule.Condition.ScriptType = conditionScript.ScriptType;
foreach (var successCode in conditionScript.SuccessCodes.Split(','))
{
clientWuModule.Condition.SuccessCodes.Add(successCode);
}
clientWuModule.Condition.Timeout = conditionScript.Timeout;
clientWuModule.Condition.WorkingDirectory = conditionScript.WorkingDirectory;
}
}
var moduleFiles = new ServiceModule().GetModuleFiles(wuModule.Guid);
foreach (var file in moduleFiles.OrderBy(x => x.FileName))
{
var clientFile = new DtoClientFileHash();
clientFile.FileName = file.FileName;
clientFile.FileHash = file.Md5Hash;
clientWuModule.Files.Add(clientFile);
}
_clientPolicy.WuModules.Add(clientWuModule);
}
private void CopyScriptModule(EntityPolicyModules policyModule)
{
var scriptModuleExport = new DtoScriptModuleExport();
var scriptModule = new ServiceScriptModule().GetModule(policyModule.ModuleId);
scriptModuleExport.ScriptContents = scriptModule.ScriptContents;
scriptModuleExport.Description = scriptModule.Description;
scriptModuleExport.DisplayName = scriptModule.Name;
scriptModuleExport.Arguments = scriptModule.Arguments;
scriptModuleExport.Order = policyModule.Order;
scriptModuleExport.Timeout = scriptModule.Timeout;
scriptModuleExport.ScriptType = scriptModule.ScriptType;
scriptModuleExport.RedirectOutput = scriptModule.RedirectStdOut;
scriptModuleExport.RedirectError = scriptModule.RedirectStdError;
scriptModuleExport.AddToInventory = scriptModule.AddInventoryCollection;
scriptModuleExport.WorkingDirectory = scriptModule.WorkingDirectory;
scriptModuleExport.IsCondition = scriptModule.IsCondition;
scriptModuleExport.SuccessCodes = scriptModule.SuccessCodes;
scriptModuleExport.Guid = scriptModule.Guid;
scriptModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
scriptModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
if (policyModule.ConditionId != -1)
{
scriptModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.ScriptModules.Add(scriptModuleExport);
}
protected void btnSubmit_OnClick(object sender, EventArgs e)
{
var listPolicyModules = new List <EntityPolicyModules>();
foreach (GridViewRow row in gvModules.Rows)
{
var cb = (CheckBox)row.FindControl("chkSelector");
if (cb == null || !cb.Checked)
{
continue;
}
var dataKey = gvModules.DataKeys[row.RowIndex];
if (dataKey == null)
{
continue;
}
var policyModule = new EntityPolicyModules();
policyModule.ModuleId = Convert.ToInt32(dataKey.Value);
policyModule.PolicyId = Policy.Id;
policyModule.Guid = row.Cells[5].Text;
policyModule.ModuleType = (EnumModule.ModuleType)Enum.Parse(typeof(EnumModule.ModuleType), row.Cells[4].Text);
listPolicyModules.Add(policyModule);
}
var result = Call.PolicyModulesApi.PostList(listPolicyModules);
EndUserMessage = result.Success ? "Successfully Added Modules To Policy" : result.ErrorMessage;
}
public DtoActionResult UpdatePolicyModule(EntityPolicyModules policy)
{
var u = GetPolicyModule(policy.Id);
if (u == null)
{
return new DtoActionResult {
ErrorMessage = "Policy Module Not Found", Id = 0
}
}
;
var activePolicy = new ServicePolicy().GetActivePolicy(u.PolicyId);
if (activePolicy != null)
{
return new DtoActionResult()
{
ErrorMessage = "Active Policies Cannot Be Updated. You Must Deactivate It First."
}
}
;
var actionResult = new DtoActionResult();
_uow.PolicyModulesRepository.Update(policy, policy.Id);
_uow.Save();
actionResult.Success = true;
actionResult.Id = policy.Id;
return(actionResult);
}
}
}
public DtoActionResult Put(int id, EntityPolicyModules policyModule)
{
policyModule.Id = id;
var result = _policyModulesServices.UpdatePolicyModule(policyModule);
if (result == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(result);
}
private void CopySoftwareModule(EntityPolicyModules policyModule)
{
var softwareModuleExport = new DtoSoftwareModuleExport();
var softwareModule = new ServiceSoftwareModule().GetModule(policyModule.ModuleId);
softwareModuleExport.DisplayName = softwareModule.Name;
softwareModuleExport.Command = softwareModule.Command;
softwareModuleExport.Description = softwareModule.Description;
softwareModuleExport.Arguments = softwareModule.Arguments;
softwareModuleExport.AdditionalArguments = softwareModule.AdditionalArguments;
softwareModuleExport.Order = policyModule.Order;
softwareModuleExport.Timeout = softwareModule.Timeout;
softwareModuleExport.InstallType = softwareModule.InstallType;
softwareModuleExport.RedirectOutput = softwareModule.RedirectStdOut;
softwareModuleExport.RedirectError = softwareModule.RedirectStdError;
softwareModuleExport.SuccessCodes = softwareModule.SuccessCodes;
softwareModuleExport.Guid = softwareModule.Guid;
softwareModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
softwareModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
var uploadedFiles = new ServiceUploadedFile().GetFilesForModule(softwareModule.Guid);
foreach (var file in uploadedFiles.OrderBy(x => x.Name))
{
var uploadedFile = new DtoUploadedFileExport();
uploadedFile.FileName = file.Name;
uploadedFile.Md5Hash = file.Hash;
uploadedFile.ModuleGuid = file.Guid;
softwareModuleExport.UploadedFiles.Add(uploadedFile);
}
var externalFiles = new ServiceExternalDownload().GetForModule(softwareModule.Guid);
foreach (var file in externalFiles.OrderBy(x => x.FileName))
{
var externalFile = new DtoExternalFileExport();
externalFile.FileName = file.FileName;
externalFile.Sha256Hash = file.Sha256Hash;
externalFile.Url = file.Url;
externalFile.ModuleGuid = file.ModuleGuid;
softwareModuleExport.ExternalFiles.Add(externalFile);
}
if (policyModule.ConditionId != -1)
{
softwareModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.SoftwareModules.Add(softwareModuleExport);
}
private void CopyCommandModule(EntityPolicyModules policyModule)
{
var commandModuleExport = new DtoCommandModuleExport();
var commandModule = new ServiceCommandModule().GetModule(policyModule.ModuleId);
commandModuleExport.Description = commandModule.Description;
commandModuleExport.Order = policyModule.Order;
commandModuleExport.Command = commandModule.Command;
commandModuleExport.Arguments = commandModule.Arguments;
commandModuleExport.DisplayName = commandModule.Name;
commandModuleExport.Timeout = commandModule.Timeout;
commandModuleExport.RedirectOutput = commandModule.RedirectStdOut;
commandModuleExport.RedirectError = commandModule.RedirectStdError;
commandModuleExport.WorkingDirectory = commandModule.WorkingDirectory;
commandModuleExport.SuccessCodes = commandModule.SuccessCodes;
commandModuleExport.Guid = commandModule.Guid;
commandModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
commandModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
var uploadedFiles = new ServiceUploadedFile().GetFilesForModule(commandModule.Guid);
foreach (var file in uploadedFiles.OrderBy(x => x.Name))
{
var uploadedFile = new DtoUploadedFileExport();
uploadedFile.FileName = file.Name;
uploadedFile.Md5Hash = file.Hash;
uploadedFile.ModuleGuid = file.Guid;
commandModuleExport.UploadedFiles.Add(uploadedFile);
}
var externalFiles = new ServiceExternalDownload().GetForModule(commandModule.Guid);
foreach (var file in externalFiles.OrderBy(x => x.FileName))
{
var externalFile = new DtoExternalFileExport();
externalFile.FileName = file.FileName;
externalFile.Sha256Hash = file.Sha256Hash;
externalFile.Url = file.Url;
externalFile.ModuleGuid = file.ModuleGuid;
commandModuleExport.ExternalFiles.Add(externalFile);
}
if (policyModule.ConditionId != -1)
{
commandModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.CommandModules.Add(commandModuleExport);
}
private void PrinterModule(EntityPolicyModules policyModule)
{
var clientPrinterModule = new DtoClientPrinterModule();
var printerModule = new ServicePrinterModule().GetModule(policyModule.ModuleId);
clientPrinterModule.Guid = printerModule.Guid;
clientPrinterModule.DisplayName = printerModule.Name;
clientPrinterModule.PrinterPath = printerModule.NetworkPath;
clientPrinterModule.Order = policyModule.Order;
clientPrinterModule.IsDefault = printerModule.IsDefault;
clientPrinterModule.RestartSpooler = printerModule.RestartSpooler;
clientPrinterModule.PrinterAction = printerModule.Action;
clientPrinterModule.WaitForEnumeration = printerModule.WaitForEnumeration;
if (policyModule.ConditionId != -1)
{
var conditionScript = new ServiceScriptModule().GetModule(policyModule.ConditionId);
if (conditionScript != null)
{
clientPrinterModule.ConditionFailedAction = policyModule.ConditionFailedAction;
clientPrinterModule.ConditionNextOrder = policyModule.ConditionNextModule;
clientPrinterModule.Condition = new DtoClientModuleCondition();
clientPrinterModule.Condition.Arguments = conditionScript.Arguments;
clientPrinterModule.Condition.DisplayName = conditionScript.Name;
clientPrinterModule.Condition.Guid = conditionScript.Guid;
clientPrinterModule.Condition.RedirectError = conditionScript.RedirectStdError;
clientPrinterModule.Condition.RedirectOutput = conditionScript.RedirectStdOut;
if (conditionScript.ImpersonationId != -1)
{
var scriptImpersonationGuid = new ServiceImpersonationAccount().GetGuid(conditionScript.ImpersonationId);
if (!string.IsNullOrEmpty(scriptImpersonationGuid))
{
clientPrinterModule.Condition.RunAs = scriptImpersonationGuid;
}
}
clientPrinterModule.Condition.ScriptType = conditionScript.ScriptType;
foreach (var successCode in conditionScript.SuccessCodes.Split(','))
{
clientPrinterModule.Condition.SuccessCodes.Add(successCode);
}
clientPrinterModule.Condition.Timeout = conditionScript.Timeout;
clientPrinterModule.Condition.WorkingDirectory = conditionScript.WorkingDirectory;
}
}
_clientPolicy.PrinterModules.Add(clientPrinterModule);
}
private string VerifyMessage(EntityPolicyModules policyModule)
{
var messageModule = new ServiceMessageModule().GetModule(policyModule.ModuleId);
if (string.IsNullOrEmpty(messageModule.Name))
{
return("A Message Module Has An Invalid Name");
}
if (messageModule.Archived)
{
return("Message Module: " + messageModule.Name + " Is Archived");
}
if (string.IsNullOrEmpty(messageModule.Guid))
{
return("Message Module: " + messageModule.Name + " Has An Invalid GUID");
}
if (string.IsNullOrEmpty(messageModule.Title))
{
return("Message Module: " + messageModule.Name + " Has An Invalid Title");
}
if (string.IsNullOrEmpty(messageModule.Message))
{
return("Message Module: " + messageModule.Name + " Has An Invalid Message");
}
int value;
if (!int.TryParse(policyModule.Order.ToString(), out value))
{
return("Message Module: " + messageModule.Name + " Has An Invalid Order");
}
int tValue;
if (!int.TryParse(messageModule.Timeout.ToString(), out tValue))
{
return("Message Module: " + messageModule.Name + " Has An Invalid Timeout");
}
return(null);
}
private string VerifyPrinter(EntityPolicyModules policyModule)
{
var printerModule = new ServicePrinterModule().GetModule(policyModule.ModuleId);
if (printerModule == null)
{
return("An Assigned Printer Module No Longer Exists");
}
if (string.IsNullOrEmpty(printerModule.Name))
{
return("A Printer Module Has An Invalid Name");
}
if (printerModule.Archived)
{
return("Printer Module: " + printerModule.Name + " Is Archived");
}
if (string.IsNullOrEmpty(printerModule.NetworkPath))
{
return("Printer Module: " + printerModule.Name + " Has An Invalid Network Path");
}
if (string.IsNullOrEmpty(printerModule.Guid))
{
return("Printer Module: " + printerModule.Name + " Has An Invalid GUID");
}
if (printerModule.Action != EnumPrinterModule.ActionType.Delete &&
printerModule.Action != EnumPrinterModule.ActionType.Install &&
printerModule.Action != EnumPrinterModule.ActionType.InstallPowershell &&
printerModule.Action != EnumPrinterModule.ActionType.None)
{
return("Printer Module: " + printerModule.Name + " Has An Invalid Action");
}
int value;
if (!int.TryParse(policyModule.Order.ToString(), out value))
{
return("Printer Module: " + printerModule.Name + " Has An Invalid Order");
}
return(null);
}
private void CopyFileCopyModule(EntityPolicyModules policyModule)
{
var fileCopyModuleExport = new DtoFileCopyModuleExport();
var fileCopyModule = new ServiceFileCopyModule().GetModule(policyModule.ModuleId);
fileCopyModuleExport.DisplayName = fileCopyModule.Name;
fileCopyModuleExport.Description = fileCopyModule.Description;
fileCopyModuleExport.Destination = fileCopyModule.Destination;
fileCopyModuleExport.Order = policyModule.Order;
fileCopyModuleExport.Unzip = fileCopyModule.DecompressAfterCopy;
fileCopyModuleExport.Guid = fileCopyModule.Guid;
fileCopyModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
fileCopyModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
var uploadedFiles = new ServiceUploadedFile().GetFilesForModule(fileCopyModule.Guid);
foreach (var file in uploadedFiles.OrderBy(x => x.Name))
{
var uploadedFile = new DtoUploadedFileExport();
uploadedFile.FileName = file.Name;
uploadedFile.Md5Hash = file.Hash;
uploadedFile.ModuleGuid = file.Guid;
fileCopyModuleExport.UploadedFiles.Add(uploadedFile);
}
var externalFiles = new ServiceExternalDownload().GetForModule(fileCopyModule.Guid);
foreach (var file in externalFiles.OrderBy(x => x.FileName))
{
var externalFile = new DtoExternalFileExport();
externalFile.FileName = file.FileName;
externalFile.Sha256Hash = file.Sha256Hash;
externalFile.Url = file.Url;
externalFile.ModuleGuid = file.ModuleGuid;
fileCopyModuleExport.ExternalFiles.Add(externalFile);
}
if (policyModule.ConditionId != -1)
{
fileCopyModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.FileCopyModules.Add(fileCopyModuleExport);
}
private void MessageModule(EntityPolicyModules policyModule)
{
var clientMessageModule = new DtoClientMessageModule();
var messageModule = new ServiceMessageModule().GetModule(policyModule.ModuleId);
clientMessageModule.Guid = messageModule.Guid;
clientMessageModule.DisplayName = messageModule.Name;
clientMessageModule.Order = policyModule.Order;
clientMessageModule.Title = messageModule.Title;
clientMessageModule.Message = messageModule.Message;
clientMessageModule.Timeout = messageModule.Timeout;
if (policyModule.ConditionId != -1)
{
var conditionScript = new ServiceScriptModule().GetModule(policyModule.ConditionId);
if (conditionScript != null)
{
clientMessageModule.ConditionFailedAction = policyModule.ConditionFailedAction;
clientMessageModule.ConditionNextOrder = policyModule.ConditionNextModule;
clientMessageModule.Condition = new DtoClientModuleCondition();
clientMessageModule.Condition.Arguments = conditionScript.Arguments;
clientMessageModule.Condition.DisplayName = conditionScript.Name;
clientMessageModule.Condition.Guid = conditionScript.Guid;
clientMessageModule.Condition.RedirectError = conditionScript.RedirectStdError;
clientMessageModule.Condition.RedirectOutput = conditionScript.RedirectStdOut;
if (conditionScript.ImpersonationId != -1)
{
var scriptImpersonationGuid = new ServiceImpersonationAccount().GetGuid(conditionScript.ImpersonationId);
if (!string.IsNullOrEmpty(scriptImpersonationGuid))
{
clientMessageModule.Condition.RunAs = scriptImpersonationGuid;
}
}
clientMessageModule.Condition.ScriptType = conditionScript.ScriptType;
foreach (var successCode in conditionScript.SuccessCodes.Split(','))
{
clientMessageModule.Condition.SuccessCodes.Add(successCode);
}
clientMessageModule.Condition.Timeout = conditionScript.Timeout;
clientMessageModule.Condition.WorkingDirectory = conditionScript.WorkingDirectory;
}
}
_clientPolicy.MessageModules.Add(clientMessageModule);
}
public DtoActionResult AddPolicyModule(EntityPolicyModules policyModule)
{
var activePolicy = new ServicePolicy().GetActivePolicy(policyModule.PolicyId);
if (activePolicy != null)
{
return new DtoActionResult()
{
ErrorMessage = "Active Policies Cannot Be Updated. You Must Deactivate It First."
}
}
;
var actionResult = new DtoActionResult();
_uow.PolicyModulesRepository.Insert(policyModule);
_uow.Save();
actionResult.Success = true;
actionResult.Id = policyModule.Id;
return(actionResult);
}
private void CopyMessageModule(EntityPolicyModules policyModule)
{
var messageModuleExport = new DtoMessageModuleExport();
var messageModule = new ServiceMessageModule().GetModule(policyModule.ModuleId);
messageModuleExport.Description = messageModule.Description;
messageModuleExport.DisplayName = messageModule.Name;
messageModuleExport.Order = policyModule.Order;
messageModuleExport.Timeout = messageModule.Timeout;
messageModuleExport.Guid = messageModule.Guid;
messageModuleExport.Title = messageModule.Title;
messageModuleExport.Message = messageModule.Message;
messageModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
messageModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
if (policyModule.ConditionId != -1)
{
messageModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.MessageModules.Add(messageModuleExport);
}
private void CopyPrinterModule(EntityPolicyModules policyModule)
{
var printerModuleExport = new DtoPrinterModuleExport();
var printerModule = new ServicePrinterModule().GetModule(policyModule.ModuleId);
printerModuleExport.DisplayName = printerModule.Name;
printerModuleExport.PrinterPath = printerModule.NetworkPath;
printerModuleExport.Description = printerModule.Description;
printerModuleExport.Order = policyModule.Order;
printerModuleExport.IsDefault = printerModule.IsDefault;
printerModuleExport.RestartSpooler = printerModule.RestartSpooler;
printerModuleExport.PrinterAction = printerModule.Action;
printerModuleExport.WaitForEnumeration = printerModule.WaitForEnumeration;
printerModuleExport.Guid = printerModule.Guid;
printerModuleExport.ConditionFailedAction = policyModule.ConditionFailedAction;
printerModuleExport.ConditionNextOrder = policyModule.ConditionNextModule;
if (policyModule.ConditionId != -1)
{
printerModuleExport.Condition = GetCondition(policyModule.ConditionId);
}
_policyExport.PrinterModules.Add(printerModuleExport);
}
private string VerifyScript(EntityPolicyModules policyModule)
{
var scriptModule = new ServiceScriptModule().GetModule(policyModule.ModuleId);
if (scriptModule == null)
{
return("An Assigned Script Module No Longer Exists");
}
if (string.IsNullOrEmpty(scriptModule.Name))
{
return("A Script Module Has An Invalid Name");
}
if (scriptModule.Archived)
{
return("Script Module: " + scriptModule.Name + " Is Archived");
}
if (string.IsNullOrEmpty(scriptModule.ScriptContents))
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Script. It Cannot Be Empty.");
}
if (string.IsNullOrEmpty(scriptModule.Guid))
{
return("Script Module: " + scriptModule.Name + " Has An Invalid GUID");
}
if (scriptModule.ScriptType != EnumScriptModule.ScriptType.Batch &&
scriptModule.ScriptType != EnumScriptModule.ScriptType.Powershell &&
scriptModule.ScriptType != EnumScriptModule.ScriptType.VbScript)
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Type");
}
int value;
if (!int.TryParse(scriptModule.Timeout.ToString(), out value))
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Timeout");
}
List <string> successCodes = new List <string>();
foreach (var successCode in scriptModule.SuccessCodes.Split(','))
{
successCodes.Add(successCode);
}
if (successCodes.Count == 0)
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Success Code");
}
if (successCodes.Any(code => !int.TryParse(code, out value)))
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Success Code");
}
if (!string.IsNullOrEmpty(scriptModule.WorkingDirectory))
{
try
{
Path.GetFullPath(scriptModule.WorkingDirectory);
}
catch
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Working Directory");
}
}
if (scriptModule.ImpersonationId != -1)
{
var impAccount = new ServiceImpersonationAccount().GetAccount(scriptModule.ImpersonationId);
if (impAccount == null)
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Impersonation Account");
}
}
if (!int.TryParse(policyModule.Order.ToString(), out value))
{
return("Script Module: " + scriptModule.Name + " Has An Invalid Order");
}
return(null);
}
private DtoActionResult CreateFileCopy()
{
foreach (var fileCopyModule in _export.FileCopyModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
fileCopyModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.FileCopyModuleRepository.Exists(h => h.Guid.Equals(fileCopyModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A File Copy Module With This Guid Already Exists. " + fileCopyModule.Guid
});
}
var fileCopy = new EntityFileCopyModule();
fileCopy.Name = fileCopyModule.DisplayName;
fileCopy.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + fileCopyModule.Description;
fileCopy.Guid = fileCopyModule.Guid;
fileCopy.DecompressAfterCopy = fileCopyModule.Unzip;
fileCopy.Destination = fileCopyModule.Destination;
if (fileCopyModule.UploadedFiles.Any())
{
_policyHasInternalFiles = true;
}
if (fileCopyModule.ExternalFiles.Any())
{
_policyHasExternalFiles = true;
}
if (_uow.FileCopyModuleRepository.Exists(h => h.Name.Equals(fileCopy.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A File Copy Name"
}
}
;
var newName = fileCopy.Name + "_" + c;
if (!_uow.FileCopyModuleRepository.Exists(h => h.Name == newName))
{
fileCopy.Name = newName;
break;
}
}
}
var addResult = new ServiceFileCopyModule().AddModule(fileCopy);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = fileCopy.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.FileCopy;
policyModule.Name = fileCopy.Name;
policyModule.Order = fileCopyModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = fileCopyModule.ConditionFailedAction;
policyModule.ConditionNextModule = fileCopyModule.ConditionNextOrder;
var conditionId = CreateCondition(fileCopyModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
public DtoActionResult Post(EntityPolicyModules policyModule)
{
return(_policyModulesServices.AddPolicyModule(policyModule));
}
private string VerifySoftware(EntityPolicyModules policyModule)
{
var softwareModule = new ServiceSoftwareModule().GetModule(policyModule.ModuleId);
if (string.IsNullOrEmpty(softwareModule.Name))
{
return("A Software Module Has An Invalid Name");
}
if (softwareModule.Archived)
{
return("Software Module: " + softwareModule.Name + " Is Archived");
}
if (string.IsNullOrEmpty(softwareModule.Guid))
{
return("Software Module: " + softwareModule.Name + " Has An Invalid GUID");
}
int value;
if (!int.TryParse(softwareModule.Timeout.ToString(), out value))
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Timeout");
}
if (string.IsNullOrEmpty(softwareModule.Command))
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Command");
}
if (!int.TryParse(policyModule.Order.ToString(), out value))
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Order");
}
List <string> successCodes = new List <string>();
foreach (var successCode in softwareModule.SuccessCodes.Split(','))
{
successCodes.Add(successCode);
}
if (successCodes.Count == 0)
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Success Code");
}
if (successCodes.Any(code => !int.TryParse(code, out value)))
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Success Code");
}
var uploadedFiles = new ServiceUploadedFile().GetFilesForModule(softwareModule.Guid);
var externalFiles = new ServiceExternalDownload().GetForModule(softwareModule.Guid);
if (uploadedFiles == null && externalFiles == null)
{
return("Software Module: " + softwareModule.Name + " Does Not Have Any Associated Files");
}
try
{
if (uploadedFiles.Count == 0 && externalFiles.Count == 0)
{
return("Software Module: " + softwareModule.Name + " Does Not Have Any Associated Files");
}
}
catch
{
return("Software Module: " + softwareModule.Name + " Error While Determining Associated Files");
}
var basePath = Path.Combine(ServiceSetting.GetSettingValue(SettingStrings.StoragePath), "software_uploads");
using (var unc = new UncServices())
{
if (unc.NetUseWithCredentials() || unc.LastError == 1219)
{
try
{
foreach (var file in uploadedFiles.OrderBy(x => x.Name))
{
if (string.IsNullOrEmpty(file.Hash))
{
return("Software Module: " + softwareModule.Name + " " + file.Name + " Does Not Have An MD5 Hash");
}
var fullPath = Path.Combine(basePath, file.Guid, file.Name);
if (!File.Exists(fullPath))
{
return("Software Module: " + softwareModule.Name + " " + fullPath + " Does Not Exist");
}
}
foreach (var file in externalFiles.OrderBy(x => x.FileName))
{
if (file.Status != EnumFileDownloader.DownloadStatus.Complete)
{
return("Software Module: " + softwareModule.Name + " " + file.FileName + " Has Not Finished Downloading Or Is In An Error State");
}
if (string.IsNullOrEmpty(file.Md5Hash))
{
return("Software Module: " + softwareModule.Name + " " + file.FileName + " Does Not Have An MD5 Hash");
}
var fullPath = Path.Combine(basePath, file.ModuleGuid, file.FileName);
if (!File.Exists(fullPath))
{
return("Software Module: " + softwareModule.Name + " " + fullPath + " Does Not Exist");
}
}
}
catch (Exception ex)
{
Logger.Debug(ex.Message);
return("Software Module: " + softwareModule.Name + " Unknown Error Trying To Verify Files");
}
}
else
{
return("Could Not Reach Storage Path");
}
}
if (softwareModule.ImpersonationId != -1)
{
var impAccount = new ServiceImpersonationAccount().GetAccount(softwareModule.ImpersonationId);
if (impAccount == null)
{
return("Software Module: " + softwareModule.Name + " Has An Invalid Impersonation Account");
}
}
return(null);
}
private DtoActionResult CreateMessages()
{
foreach (var messageModule in _export.MessageModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
messageModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.MessageModuleRepository.Exists(h => h.Guid.Equals(messageModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A Message Module With This Guid Already Exists. " + messageModule.Guid
});
}
var message = new EntityMessageModule();
message.Name = messageModule.DisplayName;
message.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + messageModule.Description;
message.Guid = messageModule.Guid;
message.Title = messageModule.Title;
message.Message = messageModule.Message;
message.Timeout = messageModule.Timeout;
if (_uow.MessageModuleRepository.Exists(h => h.Name.Equals(message.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A Message Name"
}
}
;
var newName = message.Name + "_" + c;
if (!_uow.MessageModuleRepository.Exists(h => h.Name == newName))
{
message.Name = newName;
break;
}
}
}
var addResult = new ServiceMessageModule().AddModule(message);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = message.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.Message;
policyModule.Name = message.Name;
policyModule.Order = messageModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = messageModule.ConditionFailedAction;
policyModule.ConditionNextModule = messageModule.ConditionNextOrder;
var conditionId = CreateCondition(messageModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
private DtoActionResult CreateWindowsUpdate()
{
foreach (var wuModuleModule in _export.WuModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
wuModuleModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.WindowsUpdateModuleRepository.Exists(h => h.Guid.Equals(wuModuleModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A Windows Update Module With This Guid Already Exists. " + wuModuleModule.Guid
});
}
var wu = new EntityWuModule();
wu.Name = wuModuleModule.DisplayName;
wu.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + wu.Description;
wu.Guid = wuModuleModule.Guid;
wu.AdditionalArguments = wuModuleModule.Arguments;
wu.RedirectStdError = wuModuleModule.RedirectError;
wu.RedirectStdOut = wuModuleModule.RedirectOutput;
wu.SuccessCodes = wuModuleModule.SuccessCodes;
wu.Timeout = wuModuleModule.Timeout;
if (wuModuleModule.UploadedFiles.Any())
{
_policyHasInternalFiles = true;
}
if (wuModuleModule.ExternalFiles.Any())
{
_policyHasExternalFiles = true;
}
if (_uow.WindowsUpdateModuleRepository.Exists(h => h.Name.Equals(wu.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A Windows Update Name"
}
}
;
var newName = wu.Name + "_" + c;
if (!_uow.WindowsUpdateModuleRepository.Exists(h => h.Name == newName))
{
wu.Name = newName;
break;
}
}
}
var addResult = new ServiceWuModule().AddModule(wu);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = wu.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.Wupdate;
policyModule.Name = wu.Name;
policyModule.Order = wuModuleModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = wuModuleModule.ConditionFailedAction;
policyModule.ConditionNextModule = wuModuleModule.ConditionNextOrder;
var conditionId = CreateCondition(wuModuleModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
private DtoActionResult CreateScripts()
{
foreach (var scriptModule in _export.ScriptModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
scriptModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.ScriptModuleRepository.Exists(h => h.Guid.Equals(scriptModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A Script Module With This Guid Already Exists. " + scriptModule.Guid
});
}
var script = new EntityScriptModule();
script.AddInventoryCollection = scriptModule.AddToInventory;
script.Name = scriptModule.DisplayName;
script.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + script.Description;
script.Guid = scriptModule.Guid;
script.Arguments = scriptModule.Arguments;
script.IsCondition = scriptModule.IsCondition;
script.RedirectStdError = scriptModule.RedirectError;
script.RedirectStdOut = scriptModule.RedirectOutput;
script.ScriptContents = scriptModule.ScriptContents;
script.ScriptType = scriptModule.ScriptType;
script.SuccessCodes = scriptModule.SuccessCodes;
script.Timeout = scriptModule.Timeout;
script.WorkingDirectory = scriptModule.WorkingDirectory;
script.ImpersonationId = -1;
if (_uow.ScriptModuleRepository.Exists(h => h.Name.Equals(script.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A Script Name"
}
}
;
var newName = script.Name + "_" + c;
if (!_uow.ScriptModuleRepository.Exists(h => h.Name == newName))
{
script.Name = newName;
break;
}
}
}
var addResult = new ServiceScriptModule().AddModule(script);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = script.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.Script;
policyModule.Name = script.Name;
policyModule.Order = scriptModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = scriptModule.ConditionFailedAction;
policyModule.ConditionNextModule = scriptModule.ConditionNextOrder;
var conditionId = CreateCondition(scriptModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
private string VerifyWindowsUpdate(EntityPolicyModules policyModule)
{
var wuModule = new ServiceWuModule().GetModule(policyModule.ModuleId);
if (string.IsNullOrEmpty(wuModule.Name))
{
return("A Windows Update Module Has An Invalid Name");
}
if (wuModule.Archived)
{
return("Windows Update Module: " + wuModule.Name + " Is Archived");
}
if (string.IsNullOrEmpty(wuModule.Guid))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid GUID");
}
int value;
if (!int.TryParse(wuModule.Timeout.ToString(), out value))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid Timeout");
}
if (!int.TryParse(policyModule.Order.ToString(), out value))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid Order");
}
List <string> successCodes = new List <string>();
foreach (var successCode in wuModule.SuccessCodes.Split(','))
{
successCodes.Add(successCode);
}
if (successCodes.Count == 0)
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid Success Code");
}
if (successCodes.Any(code => !int.TryParse(code, out value)))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid Success Code");
}
var uploadedFiles = new ServiceUploadedFile().GetFilesForModule(wuModule.Guid);
var externalFiles = new ServiceExternalDownload().GetForModule(wuModule.Guid);
if (uploadedFiles == null && externalFiles == null)
{
return("Windows Update Module: " + wuModule.Name + " Does Not Have Any Associated Files");
}
try
{
if (uploadedFiles.Count == 0 && externalFiles.Count == 0)
{
return("Windows Update Module: " + wuModule.Name + " Does Not Have Any Associated Files");
}
}
catch
{
return("Windows Update Module: " + wuModule.Name + " Error While Determining Associated Files");
}
var firstExtension = "";
int uploadFileCounter = 0;
foreach (var file in uploadedFiles)
{
var ext = Path.GetExtension(file.Name);
if (ext == null)
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid File Extension In The Uploaded Files List");
}
if (!ext.ToLower().Equals(".cab") && !ext.ToLower().Equals(".msu"))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid File Extension In The Uploaded Files List");
}
if (uploadFileCounter == 0)
{
firstExtension = ext;
}
else
{
if (!firstExtension.Equals(ext))
{
return("Windows Update Module: " + wuModule.Name + " All Files Per Windows Update Module Must Be The Same Type. IE. All .msu Or All .cab");
}
}
uploadFileCounter++;
}
int externalFileCounter = 0;
foreach (var file in externalFiles)
{
var ext = Path.GetExtension(file.FileName);
if (ext == null)
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid File Extension In The External Files List");
}
if (!ext.ToLower().Equals(".cab") && !ext.ToLower().Equals(".msu"))
{
return("Windows Update Module: " + wuModule.Name + " Has An Invalid File Extension In The External Files List");
}
if (uploadFileCounter == 0 && string.IsNullOrEmpty(firstExtension)) //don't overwrite extension that may have been set in uploaded files
{
firstExtension = ext;
}
else
{
if (!firstExtension.Equals(ext))
{
return("Windows Update Module: " + wuModule.Name + " All Files Per Windows Update Module Must Be The Same Type. IE. All .msu Or All .cab");
}
}
externalFileCounter++;
}
var basePath = Path.Combine(ServiceSetting.GetSettingValue(SettingStrings.StoragePath), "software_uploads");
using (var unc = new UncServices())
{
if (unc.NetUseWithCredentials() || unc.LastError == 1219)
{
try
{
foreach (var file in uploadedFiles.OrderBy(x => x.Name))
{
if (string.IsNullOrEmpty(file.Hash))
{
return("Windows Update Module: " + wuModule.Name + " " + file.Name + " Does Not Have An MD5 Hash");
}
var fullPath = Path.Combine(basePath, file.Guid, file.Name);
if (!File.Exists(fullPath))
{
return("Windows Update Module: " + wuModule.Name + " " + fullPath + " Does Not Exist");
}
}
foreach (var file in externalFiles.OrderBy(x => x.FileName))
{
if (file.Status != EnumFileDownloader.DownloadStatus.Complete)
{
return("Windows Update Module: " + wuModule.Name + " " + file.FileName + " Has Not Finished Downloading Or Is In An Error State");
}
if (string.IsNullOrEmpty(file.Md5Hash))
{
return("Windows Update Module: " + wuModule.Name + " " + file.FileName + " Does Not Have An MD5 Hash");
}
var fullPath = Path.Combine(basePath, file.ModuleGuid, file.FileName);
if (!File.Exists(fullPath))
{
return("Windows Update Module: " + wuModule.Name + " " + fullPath + " Does Not Exist");
}
}
}
catch (Exception ex)
{
Logger.Debug(ex.Message);
return("Windows Update Module: " + wuModule.Name + " Unknown Error Trying To Verify Files");
}
}
else
{
return("Could Not Reach Storage Path");
}
}
return(null);
}
public DtoClientPolicy CreateInstantModule(DtoGuidTypeMapping moduleType)
{
_clientPolicy.Name = "Instant Module ";
_clientPolicy.Guid = Guid.NewGuid().ToString();
_clientPolicy.Frequency = EnumPolicy.Frequency.OncePerComputer;
_clientPolicy.Trigger = EnumPolicy.Trigger.StartupOrCheckin;
_clientPolicy.SubFrequency = 0;
_clientPolicy.StartDate = DateTime.Now;
_clientPolicy.CompletedAction = EnumPolicy.CompletedAction.DoNothing;
_clientPolicy.RemoveInstallCache = true;
_clientPolicy.ExecutionType = EnumPolicy.ExecutionType.Install;
_clientPolicy.ErrorAction = EnumPolicy.ErrorAction.Continue;
_clientPolicy.IsInventory = EnumPolicy.InventoryAction.Disabled;
_clientPolicy.RemoteAccess = EnumPolicy.RemoteAccess.NotConfigured;
_clientPolicy.IsLoginTracker = false;
_clientPolicy.FrequencyMissedAction = EnumPolicy.FrequencyMissedAction.NextOpportunity;
_clientPolicy.LogLevel = EnumPolicy.LogLevel.Full;
_clientPolicy.SkipServerResult = false;
_clientPolicy.IsApplicationMonitor = false;
_clientPolicy.StartWindowScheduleId = -1;
_clientPolicy.EndWindowScheduleId = -1;
_clientPolicy.WuType = EnumPolicy.WuType.Disabled;
_clientPolicy.PolicyComCondition = EnumPolicy.PolicyComCondition.Any;
//_clientPolicy.Id = _policy.Id;
_clientPolicy.ConditionFailedAction = EnumCondition.FailedAction.MarkFailed;
EntityPolicyModules policyModule = new EntityPolicyModules();
policyModule.ConditionId = -1;
policyModule.ModuleId = moduleType.moduleId;
policyModule.ModuleType = moduleType.moduleType;
policyModule.Order = 0;
if (policyModule.ModuleType == EnumModule.ModuleType.Command)
{
CommandModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.FileCopy)
{
FileCopyModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.Script)
{
ScriptModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.Printer)
{
PrinterModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.Software)
{
SoftwareModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.Wupdate)
{
WuModule(policyModule);
}
else if (policyModule.ModuleType == EnumModule.ModuleType.Message)
{
MessageModule(policyModule);
}
return(_clientPolicy);
}
private string VerifyConditions(EntityPolicyModules policyModule, List <EntityPolicyModules> policyModules)
{
if (policyModule.ConditionId != -1) // -1 = disabled
{
var conditionScript = new ServiceScriptModule().GetModule(policyModule.ConditionId);
if (conditionScript == null)
{
return($"Condition Script For {policyModule.Name} Does Not Exist");
}
if (!conditionScript.IsCondition)
{
return($"The Condition Script For {policyModule.Name} Is Not Currently Set As A Condition");
}
if (string.IsNullOrEmpty(conditionScript.Name))
{
return($"A Condition Script For {policyModule.Name} Has An Invalid Name");
}
if (conditionScript.Archived)
{
return($"A Condition Script For {policyModule.Name} Is Archived");
}
if (string.IsNullOrEmpty(conditionScript.ScriptContents))
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Script. It Cannot Be Empty.");
}
if (string.IsNullOrEmpty(conditionScript.Guid))
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid GUID");
}
if (conditionScript.ScriptType != EnumScriptModule.ScriptType.Batch &&
conditionScript.ScriptType != EnumScriptModule.ScriptType.Powershell &&
conditionScript.ScriptType != EnumScriptModule.ScriptType.VbScript)
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Type");
}
int value;
if (!int.TryParse(conditionScript.Timeout.ToString(), out value))
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Timeout");
}
List <string> successCodes = new List <string>();
foreach (var successCode in conditionScript.SuccessCodes.Split(','))
{
successCodes.Add(successCode);
}
if (successCodes.Count == 0)
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Success Code");
}
if (successCodes.Any(code => !int.TryParse(code, out value)))
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Success Code");
}
if (!string.IsNullOrEmpty(conditionScript.WorkingDirectory))
{
try
{
Path.GetFullPath(conditionScript.WorkingDirectory);
}
catch
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Working Directory");
}
}
if (conditionScript.ImpersonationId != -1)
{
var impAccount = new ServiceImpersonationAccount().GetAccount(conditionScript.ImpersonationId);
if (impAccount == null)
{
return("Condition Script: " + conditionScript.Name + " Has An Invalid Impersonation Account");
}
}
if (policyModule.ConditionFailedAction != EnumCondition.FailedAction.GotoModule && policyModule.ConditionFailedAction != EnumCondition.FailedAction.MarkFailed &&
policyModule.ConditionFailedAction != EnumCondition.FailedAction.MarkNotApplicable && policyModule.ConditionFailedAction != EnumCondition.FailedAction.MarkSkipped &&
policyModule.ConditionFailedAction != EnumCondition.FailedAction.MarkSuccess)
{
return($"The Condition Failed Action For {policyModule.Name} Is Not Valid");
}
if (policyModule.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
{
if (!int.TryParse(policyModule.ConditionNextModule.ToString(), out value))
{
return("Module: " + policyModule.Name + " Has An Invalid Next Order Number");
}
if (policyModule.ConditionNextModule <= policyModule.Order)
{
return("Module: " + policyModule.Name + " The Goto Order Number Must Be Greater Than Itself");
}
if (!policyModules.Any(x => x.Order == policyModule.ConditionNextModule))
{
return("Module: " + policyModule.Name + " The Goto Order Number Is Not Assigned To Any Modules.");
}
}
}
return(null);
}
private DtoActionResult CreatePrinters()
{
foreach (var printerModule in _export.PrinterModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
printerModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.PrinterModuleRepository.Exists(h => h.Guid.Equals(printerModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A Printer Module With This Guid Already Exists. " + printerModule.Guid
});
}
var printer = new EntityPrinterModule();
printer.Name = printerModule.DisplayName;
printer.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + printerModule.Description;
printer.Guid = printerModule.Guid;
printer.Action = printerModule.PrinterAction;
printer.IsDefault = printerModule.IsDefault;
printer.NetworkPath = printerModule.PrinterPath;
printer.RestartSpooler = printerModule.RestartSpooler;
printer.WaitForEnumeration = printerModule.WaitForEnumeration;
if (_uow.PrinterModuleRepository.Exists(h => h.Name.Equals(printer.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A Printer Name"
}
}
;
var newName = printer.Name + "_" + c;
if (!_uow.PrinterModuleRepository.Exists(h => h.Name == newName))
{
printer.Name = newName;
break;
}
}
}
var addResult = new ServicePrinterModule().AddModule(printer);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = printer.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.Printer;
policyModule.Name = printer.Name;
policyModule.Order = printerModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = printerModule.ConditionFailedAction;
policyModule.ConditionNextModule = printerModule.ConditionNextOrder;
var conditionId = CreateCondition(printerModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
