public async Task IShouldCanSeeTheWalletExtract()
{
var viewModel = new ExtractViewModel();
var mockForWalletService = new Mock <IWalletApplicationService>();
mockForWalletService.Setup(d => d.GetExtract(It.IsAny <string>()))
.ReturnsAsync(viewModel)
.Verifiable();
var mockForHttpContextAccessor = new Mock <IHttpContextAccessor>();
mockForHttpContextAccessor.Setup(d => d.HttpContext.User.Identity.Name)
.Returns(It.IsAny <string>())
.Verifiable();
var controller = new WalletController(
mockForWalletService.Object,
mockForHttpContextAccessor.Object);
var result = await controller.Extract();
var resultOk = result as OkObjectResult;
var resultData = resultOk.Value as BalanceViewModel;
Assert.IsInstanceOfType(result, typeof(ActionResult));
Assert.AreEqual(resultOk.StatusCode, 200);
mockForWalletService.VerifyAll();
}
public JsonResult LoadUploadsJS(DTParameters param)
{
try
{
var dtSource = ExtractViewModel.GetExtracts(_unitOfWork);
List <ExtractViewModel> data = new ResultSet_Extracts().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_Extracts().Count(param.Search.Value, dtSource, null);
DTResult <ExtractViewModel> result = new DTResult <ExtractViewModel>
{
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 JsonResult GetUploadNameJS(int uploadId)
{
var ajaxResponse = new AjaxResponse {
Success = false, Message = "An error occurred while getting the upload name."
};
try
{
string uploadName;
var upload = ExtractViewModel.GetExtract(_unitOfWork, uploadId);
if (upload != null)
{
uploadName = upload.Name;
}
else
{
uploadName = "unknown";
}
ajaxResponse.Success = true;
ajaxResponse.TheData = uploadName;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return(Json(ajaxResponse));
}
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 JsonResult SaveUploadJS(ExtractViewModel extract)
{
var ajaxResponse = new AjaxResponse {
Success = false, Message = "An error occurred while saving the upload."
};
//should have already been caught by client, but check again
if (!ModelState.IsValid)
{
ajaxResponse.Message = "Please complete all required form fields.";
return(Json(ajaxResponse));
}
try
{
extract.TheUnitOfWork = _unitOfWork;
if (!extract.IsUniqueYN()) //Uniqueness of extract
{
ajaxResponse.Message = "The upload name already exists.";
return(Json(ajaxResponse));
}
int id = extract.UpdateAndSave();
ajaxResponse.Message = "Success";
ajaxResponse.Success = true;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return(Json(ajaxResponse));
}
public JsonResult EditUploadJS(int uploadId)
{
var ajaxResponse = new AjaxResponse {
Success = false, Message = "There was a problem loading the upload."
};
ExtractViewModel model = new ExtractViewModel();
try
{
var extract = ExtractViewModel.GetExtract(_unitOfWork, uploadId);
if (extract == null)
{
return(Json(ajaxResponse));
}
model.ExtractId = uploadId;
model.Name = extract.Name;
model.NameSave = extract.Name;
ajaxResponse.Success = true;
ajaxResponse.TheData = model;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return(Json(ajaxResponse));
}
public JsonResult EditUploadJS(int uploadId)
{
var ajaxResponse = new AjaxResponse { Success = false, Message = "There was a problem loading the upload." };
ExtractViewModel model = new ExtractViewModel();
try
{
var extract = ExtractViewModel.GetExtract(_unitOfWork, uploadId);
if (extract == null)
{
return (Json(ajaxResponse));
}
model.ExtractId = uploadId;
model.Name = extract.Name;
model.NameSave = extract.Name;
ajaxResponse.Success = true;
ajaxResponse.TheData = model;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return (Json(ajaxResponse));
}
public async Task <ExtractViewModel> GetExtract(string userEmail)
{
var user = await _userService.GetUserByEmail(userEmail);
var transactions = user.Wallet.TransactionsHistory.OrderByDescending(d => d.CreatedAt).ToList();
var result = new ExtractViewModel()
{
DotzBalance = user.Wallet.DotzBalance,
HistoryTransactions = transactions.Select(d => _mapper.Map <ExtractItemViewModel>(d))
};
return(result);
}
public ActionResult ExportUploads()
{
string fileName = "OptimumRCM_Audits.csv";
var uploads = ExtractViewModel.GetExtracts(_unitOfWork)
.Select(a => new
{
InternalUser = a.InternalUserId,
a.Name,
a.DateAdded
})
.OrderBy(a => a.Name)
.ToList();
MemoryStream csvStream = Utility.GenerateCsvStream(fileName, uploads);
return(File(csvStream, "text/csv", fileName));
}
public ActionResult ManageUploads(int?uploadId)
{
ExtractViewModel upload;
if (uploadId != null)
{
upload = ExtractViewModel.GetExtract(_unitOfWork, (int)uploadId);
if (upload == null)
{
throw new ApplicationException(string.Format("The Upload (ID: {0}) could not be loaded.", uploadId));
}
}
else
{
upload = new ExtractViewModel(); //want extractId == 0
}
return(View("ManageUploads", upload));
}
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));
}
public JsonResult DeleteUploadJS(ExtractViewModel extract)
{
var ajaxResponse = new AjaxResponse {
Success = false, Message = string.Format("There was a problem deleting upload, ID: {0}", extract.ExtractId)
};
if (extract.ExtractId == 0) //shouldn't happen
{
return(Json(ajaxResponse));
}
try
{
var existingExCount = _unitOfWork.Audits.GetAll().Where(a => a.ExtractId == extract.ExtractId).Count();
if (existingExCount > 0) //can't delete, its is in use
{
ajaxResponse.Message = "Cannot delete an upload used in an audit";
return(Json(ajaxResponse));
}
int result = ExtractViewModel.DeleteExtract(_unitOfWork, (int)extract.ExtractId);
if (result < 1)
{
return(Json(ajaxResponse));
}
ajaxResponse.Message = "Success";
ajaxResponse.Success = true;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return(Json(ajaxResponse));
}
public JsonResult DeleteUploadJS(ExtractViewModel extract)
{
var ajaxResponse = new AjaxResponse { Success = false, Message = string.Format("There was a problem deleting upload, ID: {0}", extract.ExtractId) };
if (extract.ExtractId == 0) //shouldn't happen
{
return Json(ajaxResponse);
}
try
{
var existingExCount = _unitOfWork.Audits.GetAll().Where(a => a.ExtractId == extract.ExtractId).Count();
if (existingExCount > 0) //can't delete, its is in use
{
ajaxResponse.Message = "Cannot delete an upload used in an audit";
return Json(ajaxResponse);
}
int result = ExtractViewModel.DeleteExtract(_unitOfWork, (int)extract.ExtractId);
if (result < 1)
{
return Json(ajaxResponse);
}
ajaxResponse.Message = "Success";
ajaxResponse.Success = true;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return Json(ajaxResponse);
}
/* ----------------------------------------------------------------- */
///
/// SetOverwrite
///
/// <summary>
/// Subscribes the message to select the overwrite method.
/// </summary>
///
/// <param name="src">Source ViewModel.</param>
/// <param name="value">
/// Overwrite method to set when requested.
/// </param>
///
/// <returns>Object to clear the subscription.</returns>
///
/* ----------------------------------------------------------------- */
public static IDisposable SetOverwrite(this ExtractViewModel src, OverwriteMethod value) =>
src.Subscribe <QueryMessage <OverwriteQuerySource, OverwriteMethod> >(e =>
{
e.Value = value;
e.Cancel = false;
});
public JsonResult SaveUploadJS(ExtractViewModel extract)
{
var ajaxResponse = new AjaxResponse { Success = false, Message = "An error occurred while saving the upload." };
//should have already been caught by client, but check again
if (!ModelState.IsValid)
{
ajaxResponse.Message = "Please complete all required form fields.";
return Json(ajaxResponse);
}
try
{
extract.TheUnitOfWork = _unitOfWork;
if (!extract.IsUniqueYN()) //Uniqueness of extract
{
ajaxResponse.Message = "The upload name already exists.";
return Json(ajaxResponse);
}
int id = extract.UpdateAndSave();
ajaxResponse.Message = "Success";
ajaxResponse.Success = true;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
}
return Json(ajaxResponse);
}
public ActionResult ManageUploads(int? uploadId)
{
ExtractViewModel upload;
if (uploadId != null)
{
upload = ExtractViewModel.GetExtract(_unitOfWork, (int)uploadId);
if (upload == null)
{
throw new ApplicationException(string.Format("The Upload (ID: {0}) could not be loaded.", uploadId));
}
}
else
{
upload = new ExtractViewModel(); //want extractId == 0
}
return View("ManageUploads", upload);
}
/// <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();
}
public ActionResult ShowUploadDetailOnly(int uploadId)
{
ExtractViewModel upload = ExtractViewModel.GetExtract(_unitOfWork, uploadId);
return(View("UploadDetail", upload));
}
public JsonResult SaveAndUploadDataJS()
{
var ajaxResponse = new AjaxResponse {
Success = false, Message = "An error occurred while saving the upload."
};
//added additional try/catches for debugging a problem
try
{
//should have already been caught by client, but check again
if (!ModelState.IsValid)
{
ajaxResponse.Message = "Please complete all required form fields.";
return(Json(ajaxResponse));
}
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
ajaxResponse.Message = "There was a problem validating your input, please try again.";
return(Json(ajaxResponse));
}
//validation
HttpPostedFileBase hpf;
try
{
if (Request.Files.Count != 1)
{
ajaxResponse.Message = "More than one upload file was specified.";
return(Json(ajaxResponse));
}
hpf = Request.Files[0] as HttpPostedFileBase;
if (hpf.ContentLength == 0)
{
ajaxResponse.Message = "The specified upload file is empty.";
return(Json(ajaxResponse));
}
int maxFileBytes = Properties.Settings.Default.MaxUploadSize;
if (hpf.ContentLength > maxFileBytes)
{
ajaxResponse.Message = string.Format("The upload file should not exceed {0} bytes.", maxFileBytes);
return(Json(ajaxResponse));
}
if (!Request.Files[0].FileName.ToLower().EndsWith(".csv"))
{
ajaxResponse.Message = "The upload file must be a CSV file.";
return(Json(ajaxResponse));
}
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
ajaxResponse.Message = "There was a problem validating the specified file.";
return(Json(ajaxResponse));
}
//int extractId = Convert.ToInt32(Request.Form["extractIdJS"]);
string extractName;
string internalUserId;
ExtractViewModel extract;
ajaxResponse.Success = false;
try
{
extractName = Request.Form["extractNameJS"];
internalUserId = Utility.GetAspNetUserName(this);
extract = ExtractViewModel.NewExtract(_unitOfWork, extractName, internalUserId);
if (!extract.IsUniqueYN()) //Uniqueness of extract
{
ajaxResponse.Message = "The upload name already exists.";
return(Json(ajaxResponse));
}
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
ajaxResponse.Message = "There was a problem uniqueness of upload file.";
return(Json(ajaxResponse));
}
try
{
extract.ExtractId = extract.AddAndSave();
if (extract.ExtractId == 0)
{
return(Json(ajaxResponse));
}
ajaxResponse.Id = extract.ExtractId;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
ajaxResponse.Message = "There was a problem saving the main upload record.";
return(Json(ajaxResponse));
}
//proceed with upload
try
{
extract.UploadExtract(hpf.InputStream);
ajaxResponse.Message = "Success";
ajaxResponse.Success = true;
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
ajaxResponse.Message = "An error occurred while uploading the data.";
}
return(Json(ajaxResponse));
}
