public SoftwareModuleController()
{
_softwareModuleServices = new ServiceSoftwareModule();
_auditLogService = new ServiceAuditLog();
_userId = Convert.ToInt32(((ClaimsIdentity)User.Identity).Claims.Where(c => c.Type == "user_id")
.Select(c => c.Value).SingleOrDefault());
}
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 SoftwareModule(EntityPolicyModules policyModule)
{
var clientSoftwareModule = new DtoClientSoftwareModule();
var softwareModule = new ServiceSoftwareModule().GetModule(policyModule.ModuleId);
clientSoftwareModule.Guid = softwareModule.Guid;
clientSoftwareModule.DisplayName = softwareModule.Name;
clientSoftwareModule.Command = softwareModule.Command;
clientSoftwareModule.Arguments = softwareModule.Arguments + " " + softwareModule.AdditionalArguments;
clientSoftwareModule.Order = policyModule.Order;
clientSoftwareModule.Timeout = softwareModule.Timeout;
clientSoftwareModule.InstallType = softwareModule.InstallType;
clientSoftwareModule.RedirectOutput = softwareModule.RedirectStdOut;
clientSoftwareModule.RedirectError = softwareModule.RedirectStdError;
foreach (var successCode in softwareModule.SuccessCodes.Split(','))
{
clientSoftwareModule.SuccessCodes.Add(successCode);
}
var moduleFiles = new ServiceModule().GetModuleFiles(softwareModule.Guid);
foreach (var file in moduleFiles.OrderBy(x => x.FileName))
{
var clientFile = new DtoClientFileHash();
clientFile.FileName = file.FileName;
clientFile.FileHash = file.Md5Hash;
clientSoftwareModule.Files.Add(clientFile);
}
if (softwareModule.ImpersonationId != -1)
{
var impersonationGuid = new ServiceImpersonationAccount().GetGuid(softwareModule.ImpersonationId);
if (!string.IsNullOrEmpty(impersonationGuid))
{
clientSoftwareModule.RunAs = impersonationGuid;
}
}
if (policyModule.ConditionId != -1)
{
var conditionScript = new ServiceScriptModule().GetModule(policyModule.ConditionId);
if (conditionScript != null)
{
clientSoftwareModule.ConditionFailedAction = policyModule.ConditionFailedAction;
clientSoftwareModule.ConditionNextOrder = policyModule.ConditionNextModule;
clientSoftwareModule.Condition = new DtoClientModuleCondition();
clientSoftwareModule.Condition.Arguments = conditionScript.Arguments;
clientSoftwareModule.Condition.DisplayName = conditionScript.Name;
clientSoftwareModule.Condition.Guid = conditionScript.Guid;
clientSoftwareModule.Condition.RedirectError = conditionScript.RedirectStdError;
clientSoftwareModule.Condition.RedirectOutput = conditionScript.RedirectStdOut;
if (conditionScript.ImpersonationId != -1)
{
var scriptImpersonationGuid = new ServiceImpersonationAccount().GetGuid(conditionScript.ImpersonationId);
if (!string.IsNullOrEmpty(scriptImpersonationGuid))
{
clientSoftwareModule.Condition.RunAs = scriptImpersonationGuid;
}
}
clientSoftwareModule.Condition.ScriptType = conditionScript.ScriptType;
foreach (var successCode in conditionScript.SuccessCodes.Split(','))
{
clientSoftwareModule.Condition.SuccessCodes.Add(successCode);
}
clientSoftwareModule.Condition.Timeout = conditionScript.Timeout;
clientSoftwareModule.Condition.WorkingDirectory = conditionScript.WorkingDirectory;
}
}
_clientPolicy.SoftwareModules.Add(clientSoftwareModule);
}
public DtoActionResult Restore(int moduleId, EnumModule.ModuleType moduleType)
{
var result = _moduleServices.RestoreModule(moduleId, moduleType);
if (result == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (result.Success)
{
var auditLog = new EntityAuditLog();
switch (moduleType)
{
case EnumModule.ModuleType.Command:
var cModule = new ServiceCommandModule().GetModule(moduleId);
auditLog.ObjectName = cModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(cModule);
break;
case EnumModule.ModuleType.FileCopy:
var fModule = new ServiceFileCopyModule().GetModule(moduleId);
auditLog.ObjectName = fModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(fModule);
break;
case EnumModule.ModuleType.Printer:
var pModule = new ServicePrinterModule().GetModule(moduleId);
auditLog.ObjectName = pModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(pModule);
break;
case EnumModule.ModuleType.Script:
var scModule = new ServiceScriptModule().GetModule(moduleId);
auditLog.ObjectName = scModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(scModule);
break;
case EnumModule.ModuleType.Software:
var sModule = new ServiceSoftwareModule().GetModule(moduleId);
auditLog.ObjectName = sModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(sModule);
break;
case EnumModule.ModuleType.Wupdate:
var uModule = new ServiceWuModule().GetModule(moduleId);
auditLog.ObjectName = uModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(uModule);
break;
case EnumModule.ModuleType.Message:
var messageModule = new ServiceMessageModule().GetModule(moduleId);
auditLog.ObjectName = messageModule.Name;
auditLog.ObjectJson = JsonConvert.SerializeObject(messageModule);
break;
}
auditLog.ObjectType = moduleType.ToString();
auditLog.ObjectId = result.Id;
auditLog.UserId = _userId;
auditLog.AuditType = EnumAuditEntry.AuditType.Restore;
_auditLogService.AddAuditLog(auditLog);
}
return(result);
}
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 CreateSoftware()
{
foreach (var softwareModule in _export.SoftwareModules)
{
if (_export.Instructions.Contains("[generate-module-guid]"))
{
softwareModule.Guid = Guid.NewGuid().ToString();
}
if (_uow.SoftwareModuleRepository.Exists(h => h.Guid.Equals(softwareModule.Guid)))
{
return(new DtoActionResult()
{
ErrorMessage = "A Software Module With This Guid Already Exists. " + softwareModule.Guid
});
}
var software = new EntitySoftwareModule();
software.Name = softwareModule.DisplayName;
software.Description = "Added Via Policy Template " + _export.Name + " On " + DateTime.Now +
"\r\n" + software.Description;
software.Guid = softwareModule.Guid;
software.Arguments = softwareModule.Arguments;
software.RedirectStdError = softwareModule.RedirectError;
software.RedirectStdOut = softwareModule.RedirectOutput;
software.SuccessCodes = softwareModule.SuccessCodes;
software.Timeout = softwareModule.Timeout;
software.AdditionalArguments = softwareModule.AdditionalArguments;
software.Command = softwareModule.Command;
software.InstallType = softwareModule.InstallType;
software.ImpersonationId = -1;
if (softwareModule.UploadedFiles.Any())
{
_policyHasInternalFiles = true;
}
if (softwareModule.ExternalFiles.Any())
{
_policyHasExternalFiles = true;
}
if (_uow.SoftwareModuleRepository.Exists(h => h.Name.Equals(software.Name)))
{
for (var c = 1; c <= 100; c++)
{
if (c == 100)
{
return new DtoActionResult()
{
ErrorMessage = "Could Not Determine A Software Name"
}
}
;
var newName = software.Name + "_" + c;
if (!_uow.SoftwareModuleRepository.Exists(h => h.Name == newName))
{
software.Name = newName;
break;
}
}
}
var addResult = new ServiceSoftwareModule().AddModule(software);
if (!addResult.Success)
{
return(addResult);
}
var policyModule = new EntityPolicyModules();
policyModule.Guid = software.Guid;
policyModule.ModuleId = addResult.Id;
policyModule.ModuleType = EnumModule.ModuleType.Software;
policyModule.Name = software.Name;
policyModule.Order = softwareModule.Order;
policyModule.PolicyId = _policy.Id;
policyModule.ConditionFailedAction = softwareModule.ConditionFailedAction;
policyModule.ConditionNextModule = softwareModule.ConditionNextOrder;
var conditionId = CreateCondition(softwareModule.Condition);
if (conditionId != 0)
{
policyModule.ConditionId = conditionId;
}
else
{
policyModule.ConditionId = -1;
}
_uow.PolicyModulesRepository.Insert(policyModule);
}
return(new DtoActionResult()
{
Success = true
});
}
