public JsonResult LoadUploadItemsJS(DTParameters param) //, int extractId) //, int auditId)
{
try
{
var dtSource = ExtractViewModel.GetExtractItems(_unitOfWork, param.PrimaryId);
//var dtsource = _unitOfWork.AuditExtracts.GetAll()
//.Select(s => new ManageStatusesViewModel { StatusId = s.StatusId, Name = s.Name, Description = s.Description, IncludeInAuditYN = s.IncludeInAuditYN }).ToList();
List <ExtractItemModel> data = new ResultSet_ExtractItems().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_ExtractItems().Count(param.Search.Value, dtSource, null);
DTResult <ExtractItemModel> result = new DTResult <ExtractItemModel>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
return(Json(new { error = ex.Message }));
}
}
public ActionResult ExportUploadData(int uploadId, string uploadName)
{
string fileName = string.Format("OptimumRCM_UploadData_{0}.csv", Utility.SanitizeFileName(uploadName));
var extractItems = ExtractViewModel.GetExtractItems(_unitOfWork, uploadId)
.Select(e => new
{
e.UserName,
e.LastName,
e.FirstName,
e.EmployeeID,
e.SecurityGroup
}
)
.OrderBy(e => e.UserName)
.ToList();
MemoryStream csvStream = Utility.GenerateCsvStream(fileName, extractItems);
return(File(csvStream, "text/csv", fileName));
}
/// <summary>
/// Performs the Audit.
/// </summary>
/// <exception cref="System.ApplicationException">A problem occurred while generating database snapshot.</exception>
public void PerformAudit()
{
//when complete present...
//1-Items from upload not included in audit
//2-items in upload but not in master
//3-items in master but not in upload
//4-items in both but with differences
Dictionary <string, ExtractItemModel> extractExclude = new Dictionary <string, ExtractItemModel>();
List <ExtractItemModel> extractInclude = new List <ExtractItemModel>();
List <AuditException> auditExceptions = new List <AuditException>();
//Step 1: get extract contents, by default I'm not peristing it in the model
var extractItems = ExtractViewModel.GetExtractItems(_unitOfWork, (int)this.ExtractId);
//Step 2: determine which extract items can/should be used
foreach (ExtractItemModel extractItem in extractItems)
{
if (!ExcludeFromAuditYN(extractItem))
{
extractInclude.Add(extractItem);
}
else
{
string userNameUse = (extractItem.UserName ?? string.Empty).Trim().ToLower();
if (!extractExclude.ContainsKey(userNameUse))
{
extractExclude.Add(userNameUse, extractItem);
}
}
}
//Note: use extractInclude list as source for audit henceforth
//Step #3: generate database snapshot against which to perform the audit, and build lookup
var genResult = _unitOfWork.OptUsers.GenerateMasterUsersForAudit(this.AuditId);
if (genResult < 1)
{
throw new ApplicationException("A problem occurred while generating database snapshot.");
}
//Step #4: fetch that database snapshot
var databaseMaster = _unitOfWork.AuditMasterItems.GetAll()
.Where(i => i.AuditId == this.AuditId)
.Select(i => new AuditMasterItemModel
{
AuditMasterItemId = i.AuditMasterItemId,
FirstName = i.LastName,
LastName = i.LastName,
Login = i.Login,
Facilities = i.Facilities,
Templates = i.Templates,
ProcessedYN = false //derived col to monitor audit status
})
.ToDictionary(i => i.Login.ToLower(), i => i);
//Step #5: get some helper info to use during audit, e.g. id's for exception types
//ugly code but prevents need for lookups during the audit
int idInUploadButNotInMaster = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InUploadButNotInMaster)
.SingleOrDefault()
.AuditExceptionTypeId;
int idInMasterButNotInUpload = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InMasterButNotInUpload)
.SingleOrDefault()
.AuditExceptionTypeId;
int idInBothWithFacilityDifferences = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InBothWithFacilityDifferences)
.SingleOrDefault()
.AuditExceptionTypeId;
int idInBothWithTemplateDifferences = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InBothWithTemplateDifferences)
.SingleOrDefault()
.AuditExceptionTypeId;
int idInUploadButInvalid = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InUploadButInvalid)
.SingleOrDefault()
.AuditExceptionTypeId;
int idInUploadButHandleManually = _unitOfWork.AuditExceptionTypes.GetAll()
.Where(t => t.Name == AuditExceptionTypeModel.InUploadButHandleManually)
.SingleOrDefault()
.AuditExceptionTypeId;
//Step #6: iterate over upload/extract and perform audit
foreach (ExtractItemModel extractItem in extractInclude)
{
string optTemplates = CalculateOptimumTemplatesForComparison(extractItem.SecurityGroup, this.Name);
string optFac = CalculateOptimumFacilitiesForComparison(extractItem.EmployeeID, this.Name);
if (!databaseMaster.ContainsKey(extractItem.UserName.ToLower()))
{
AuditException ex = new AuditException();
ex.AuditId = this.AuditId;
ex.AuditExceptionTypeId = idInUploadButNotInMaster;
//ex.AuditExceptionType.Name = AuditExceptionTypeModel.InExtractButNotInMaster;
ex.Message = string.Format("User '{0}' occurs in upload but not in master", extractItem.UserName);
ex.UserNameFromOptimum = extractItem.UserName;
ex.UserNameFromMaster = string.Empty;
ex.FacilitiesFromMaster = string.Empty;
ex.FacilitiesFromOptimum = optFac;
ex.TemplatesFromOptimum = optTemplates;
ex.TemplatesFromMaster = string.Empty;
_unitOfWork.AuditExceptions.Add(ex);
}
else
{
//in both but check for facility differences
AuditMasterItemModel dbItem = databaseMaster[extractItem.UserName.ToLower()];
dbItem.ProcessedYN = true; //indicate that db entry has been processed
string dbFac = CalculateDatabaseFacilitiesForComparison(dbItem.Facilities, this.Name);
string dbTemplates = CalculateDatabaseTemplatesForComparison(dbItem.Templates, this.Name);
if (optFac != dbFac)
{
AuditException ex = new AuditException();
ex.AuditId = this.AuditId;
ex.AuditExceptionTypeId = idInBothWithFacilityDifferences;
ex.Message = string.Format("User '{0}' occurs in both but facilities differ", extractItem.UserName);
ex.UserNameFromOptimum = extractItem.UserName;
ex.UserNameFromMaster = extractItem.UserName;
ex.FacilitiesFromMaster = dbFac;
ex.FacilitiesFromOptimum = optFac;
ex.TemplatesFromOptimum = optTemplates;
ex.TemplatesFromMaster = dbTemplates;
_unitOfWork.AuditExceptions.Add(ex);
}
//in both but check for template differences
if (optTemplates != dbTemplates)
{
AuditException ex = new AuditException();
ex.AuditId = this.AuditId;
ex.AuditExceptionTypeId = idInBothWithTemplateDifferences;
ex.Message = string.Format("User '{0}' occurs in both but templates differ", extractItem.UserName);
ex.UserNameFromOptimum = extractItem.UserName;
ex.UserNameFromMaster = extractItem.UserName;
ex.FacilitiesFromMaster = dbFac;
ex.FacilitiesFromOptimum = optFac;
ex.TemplatesFromOptimum = optTemplates;
ex.TemplatesFromMaster = dbTemplates;
_unitOfWork.AuditExceptions.Add(ex);
}
}
}
//Step #7: make note of master items that were not processed
foreach (string key in databaseMaster.Keys)
{
if (!databaseMaster[key].ProcessedYN && !extractExclude.ContainsKey(key))
{
string dbFac = CalculateDatabaseFacilitiesForComparison(databaseMaster[key].Facilities, this.Name);
string dbTemplates = CalculateDatabaseTemplatesForComparison(databaseMaster[key].Templates, this.Name);
AuditException ex = new AuditException();
ex.AuditId = this.AuditId;
ex.AuditExceptionTypeId = idInMasterButNotInUpload;
ex.Message = string.Format("User '{0}' occurs in master but not in upload", key);
ex.UserNameFromMaster = key;
ex.UserNameFromOptimum = string.Empty;
ex.FacilitiesFromMaster = dbFac;
ex.FacilitiesFromOptimum = string.Empty;
ex.TemplatesFromOptimum = string.Empty;
ex.TemplatesFromMaster = dbTemplates;
_unitOfWork.AuditExceptions.Add(ex);
}
}
//Step #8: make note of extract items that were excluded - add them as exceptions
foreach (ExtractItemModel extractItem in extractExclude.Values)
{
AuditException ex = new AuditException();
string optTemplates = CalculateOptimumTemplatesForComparison(extractItem.SecurityGroup, this.Name);
ex.AuditId = this.AuditId;
ex.TemplatesFromMaster = string.Empty;
ex.TemplatesFromOptimum = optTemplates;
ex.UserNameFromMaster = string.Empty;
ex.FacilitiesFromMaster = string.Empty;
ex.UserNameFromOptimum = extractItem.UserName;
if ((extractItem.EmployeeID ?? string.Empty).Trim().ToLower() == "multiple")
{
ex.AuditExceptionTypeId = idInUploadButHandleManually;
ex.Message = string.Format("User '{0}' must be handled manually", extractItem.UserName);
ex.FacilitiesFromOptimum = extractItem.EmployeeID;
}
else
{
string optFac = CalculateOptimumFacilitiesForComparison(extractItem.EmployeeID, this.Name);
ex.AuditExceptionTypeId = idInUploadButInvalid;
ex.Message = string.Format("User '{0}' from upload was excluded from audit", extractItem.UserName);
ex.FacilitiesFromOptimum = optFac;
}
_unitOfWork.AuditExceptions.Add(ex);
}
//Step #9: set end date
Audit audit = _unitOfWork.Audits.GetAll().Where(a => a.AuditId == this.AuditId).SingleOrDefault();
audit.AuditEndDate = DateTime.Now;
//Step #9: commit everyting - may take a minute
_unitOfWork.Save();
}
