public BaseApiController(
IManagerStore managerStore,
ICrudManager <TModel> manager)
: base(managerStore)
{
_manager = manager;
}
protected override void beforeEach()
{
Given = new TaskViewModel
{
Product = "3_Chemicals",
Task = ObjectMother.ValidTask("raif"),
};
_field = ObjectMother.ValidField("raif");
_equipment1 = ObjectMother.ValidEquipment("raif").WithEntityId(6);
_equipment2 = ObjectMother.ValidEquipment("poop").WithEntityId(7);
_equipment3 = ObjectMother.ValidEquipment("crap").WithEntityId(8);
repo = MockFor <IRepository>();
repo.Stub(x => x.Find <Field>(1)).Return(_field);
_validInventoryChemical = ObjectMother.ValidInventoryProductChemical("lsd").WithEntityId(3);
repo.Stub(x => x.Find <InventoryProduct>(3)).Return(_validInventoryChemical);
_employee1 = ObjectMother.ValidEmployee("raif");
_employee2 = ObjectMother.ValidEmployee("Amahl");
_employee3 = ObjectMother.ValidEmployee("Ramsay");
repo.Stub(x => x.Find <Employee>(1)).Return(_employee1);
repo.Stub(x => x.Find <Employee>(2)).Return(_employee2);
repo.Stub(x => x.Find <Employee>(3)).Return(_employee3);
repo.Stub(x => x.Find <Equipment>(6)).Return(_equipment1);
repo.Stub(x => x.Find <Equipment>(7)).Return(_equipment2);
repo.Stub(x => x.Find <Equipment>(8)).Return(_equipment3);
_crudManager = MockRepository.GenerateMock <ICrudManager>();
_crudManager.Expect(x => x.Finish()).Return(new Notification());
_saveEntityService = MockFor <ISaveEntityService>();
_sesCatcher = _saveEntityService.CaptureArgumentsFor(x => x.ProcessSave(new Task(), null), x => x.Return(_crudManager));
}
public ICrudManager SaveUploadedFile(string systemFolder, string fileNameNoExtension, ICrudManager crudManager)
{
var file = _sessionContext.RetrieveUploadedFile();
if (file == null || file.ContentLength <= 0 || crudManager.HasFailingReport()) return crudManager;
var folderPath = _sessionContext.MapPath(systemFolder);
var extension = file.FileName.Substring(file.FileName.LastIndexOf("."));
var newName = fileNameNoExtension + extension;
string filePath = folderPath + "\\" + newName;
var exists = Directory.Exists(folderPath);
if (!exists)
{
Directory.CreateDirectory(folderPath);
}
//TODO insert rules engine here
var fileExists = File.Exists(filePath);
CrudReport crudReport= new CrudReport();
if (fileExists)
{
crudReport.AddErrorInfo(new ErrorInfo(null,WebLocalizationKeys.FILE_ALREADY_EXISTS.ToString()));
crudManager.AddCrudReport(crudReport);
return crudManager;
}
file.SaveAs(filePath);
crudReport.Success = true;
crudManager.AddCrudReport(crudReport);
return crudManager;
}
public CrudManager(ICrudManager <Entity> crudManager)
{
if (crudManager == null)
{
throw new IncompleteException("El gestor de CRUD no fué configurado");
}
_crudManager = crudManager;
}
public static async Task <ActionResult <IEnumerable <UriAndValue <T> > > > AddNoGet <T, TKey>(
this Controller controller,
ICrudManager <T, TKey> manager,
IEnumerable <T> values,
Action <T, TKey> setIdFunc)
where T : class where TKey : IComparable
{
return(controller.Ok(await AddNoGetIntern(controller, manager, values, setIdFunc)));
}
public AccountManager(UserManager user, TokenManager token, LoginLogsManager logs, RoleManager role, SelectedRoleManager selectedRole)
{
_selectedRole = selectedRole;
_role = role;
_logCrud = logs;
_token = token;
_userCrud = user;
_user = user;
_tokenCrud = token;
}
protected ModelValidatorBase(ICrudManager <T> manager, ValidationMode mode)
{
_mode = mode;
_manager = manager;
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(x => x.Id).GreaterThan(0).When(x => HasFlag(ValidationMode.None & ~(ValidationMode.Add | ValidationMode.DataRelevance)))
.WithMessage("{PropertyName} can't be less or equal 0.");
RuleFor(x => x.Id).MustAsync(async(id, token) => await ExistsAsync(id, _manager))
.When(x => HasFlag(ValidationMode.Exist | ValidationMode.Delete | ValidationMode.Update))
.WithMessage("{PropertyValue}th item isn't exists.");
}
public void Setup()
{
_continuation = new Continuation {Success = true};
_validTask = ObjectMother.ValidTask("raif");
_validTask.QuantityUsed = 5;
_crudManager = MockRepository.GenerateMock<ICrudManager>();
_crudManager.Expect(x => x.Finish()).Return(new Notification());
_saveEntityService = MockRepository.GenerateMock<ISaveEntityService>();
_sesCatcher = _saveEntityService.CaptureArgumentsFor(x => x.ProcessSave(_validTask.InventoryProduct, _crudManager), x => x.Return(_crudManager));
_SUT = new InventoryService(null,_saveEntityService);
_SUT.DecrementTaskProduct(_validTask, _crudManager);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_manager != null)
{
_manager.Dispose();
_manager = null;
}
}
base.Dispose(disposing);
}
public void Setup()
{
_continuation = new Continuation {
Success = true
};
_validTask = ObjectMother.ValidTask("raif");
_validTask.QuantityUsed = 5;
_crudManager = MockRepository.GenerateMock <ICrudManager>();
_crudManager.Expect(x => x.Finish()).Return(new Notification());
_saveEntityService = MockRepository.GenerateMock <ISaveEntityService>();
_sesCatcher = _saveEntityService.CaptureArgumentsFor(x => x.ProcessSave(_validTask.InventoryProduct, _crudManager), x => x.Return(_crudManager));
_SUT = new InventoryService(null, _saveEntityService);
_SUT.DecrementTaskProduct(_validTask, _crudManager);
}
public void Setup()
{
_poliId = 0;
_repo = MockRepository.GenerateMock<IRepository>();
_purchaseOrderLineItem = ObjectMother.ValidPurchaseOrderLineItem("raif");
_inventoryBaseProducts = new List<InventoryProduct> { ObjectMother.ValidInventoryBaseProduct("raif")}.AsQueryable();
_purchaseOrderLineItem.TotalReceived = 4;
_repo.Expect(x => x.Query<InventoryProduct>(null)).IgnoreArguments().Return(_inventoryBaseProducts);
_saveEntityService = MockRepository.GenerateMock<ISaveEntityService>();
_crudManager = MockRepository.GenerateMock<ICrudManager>();
_crudManager.Expect(x => x.Finish()).Return(new Notification());
_sesCatcher = _saveEntityService.CaptureArgumentsFor(x=>x.ProcessSave(_inventoryBaseProducts.FirstOrDefault(),null),x=>x.Return(_crudManager));
_SUT = new InventoryService(_repo, _saveEntityService);
_crudManager = _SUT.ReceivePurchaseOrderLineItem(_purchaseOrderLineItem);
}
public void Setup()
{
_poliId = 0;
_repo = MockRepository.GenerateMock <IRepository>();
_purchaseOrderLineItem = ObjectMother.ValidPurchaseOrderLineItem("raif");
_inventoryBaseProducts = new List <InventoryProduct>().AsQueryable();
_purchaseOrderLineItem.TotalReceived = 4;
_repo.Expect(x => x.Query <InventoryProduct>(null)).IgnoreArguments().Return(_inventoryBaseProducts);
_crudManager = MockRepository.GenerateMock <ICrudManager>();
_crudManager.Expect(x => x.Finish()).Return(new Notification());
_saveEntityService = MockRepository.GenerateMock <ISaveEntityService>();
_sesCatcher = _saveEntityService.CaptureArgumentsFor(x => x.ProcessSave(_inventoryBaseProducts.FirstOrDefault(), null), x => x.Return(_crudManager));
_SUT = new InventoryService(_repo, _saveEntityService);
_crudManager = _SUT.ReceivePurchaseOrderLineItem(_purchaseOrderLineItem);
}
public ICrudManager ProcessSave <DOMAINMODEL>(DOMAINMODEL model, ICrudManager crudManager = null)
where DOMAINMODEL : DomainEntity
{
if (crudManager == null)
{
crudManager = new CrudManager(_repository);
}
var report = _castleValidationRunner.Validate(model);
if (report.Success)
{
_repository.Save(model);
//report.Target = model;
}
crudManager.AddCrudReport(report);
return(crudManager);
}
public ActionResult Save(TaskViewModel input)
{
var task = input.Task.EntityId > 0? _repository.Find <Task>(input.Task.EntityId):new Task();
mapItem(task, input.Task);
mapChildren(task, input);
ICrudManager crudManager = null;
if (task.Complete && !task.InventoryDecremented)
{
crudManager = _inventoryService.DecrementTaskProduct(task);
task.InventoryDecremented = true;
}
crudManager = _saveEntityService.ProcessSave(task, crudManager);
var notification = crudManager.Finish();
return(Json(notification));
}
public ICrudManager DecrementTaskProduct(Task task, ICrudManager crudManager = null)
{
if (crudManager == null)
{
crudManager = new CrudManager(_repository);
}
if (task.InventoryProduct == null)
{
return(crudManager);
}
if (!task.QuantityUsed.HasValue)
{
var crudReport = new CrudReport {
Success = false
};
crudReport.AddErrorInfo(new ErrorInfo("QuantityUsed", CoreLocalizationKeys.QUANTITY_USED_REQUIRED.ToString()));
crudManager.AddCrudReport(crudReport);
return(crudManager);
}
task.InventoryProduct.Quantity -= task.QuantityUsed.Value;
return(_saveEntityService.ProcessSave(task.InventoryProduct, crudManager));
}
public static async Task <IEnumerable <UriAndValue <T> > > AddNoGetIntern <T, TKey>(
this Controller controller,
ICrudManager <T, TKey> manager,
IEnumerable <T> values,
Action <T, TKey> setIdFunc)
where T : class where TKey : IComparable
{
IEnumerable <TKey> newIds = await manager.Add(values);
Func <T, TKey, T> mySetFunc = (v, k) =>
{
setIdFunc(v, k);
return(v);
};
string uri = controller.GetCurrentUri("/bulk");
var newUris = newIds.Select(id => uri + "/" + id);
var results = newIds.Select((id, idx) => new UriAndValue <T>()
{
Uri = uri + "/" + id, Value = mySetFunc(values.ElementAt(idx), id)
});
return(results);
}
public static async Task <ActionResult <UrisAndValues <T> > > Add2 <T, TKey>(this Controller controller, ICrudManager <T, TKey> manager, IEnumerable <T> values)
where T : class where TKey : IComparable
{
return(controller.Ok((await AddIntern(controller, manager, values)).ToUrisAndValues()));
}
public CrudApiController(IManagerStore managerStore, ICrudManager <TModel> manager)
: base(managerStore, manager)
{
}
public ICrudManager ReceivePurchaseOrderLineItem(PurchaseOrderLineItem purchaseOrderLineItem, ICrudManager crudManager = null)
{
var inventoryProducts = _repository.Query <InventoryProduct>(x => x.Product.EntityId == purchaseOrderLineItem.Product.EntityId && x.UnitType == purchaseOrderLineItem.UnitType);
var inventoryProduct = inventoryProducts.FirstOrDefault() ?? new InventoryProduct
{
Product = purchaseOrderLineItem.Product,
UnitType = purchaseOrderLineItem.UnitType,
SizeOfUnit = purchaseOrderLineItem.SizeOfUnit
};
inventoryProduct.LastVendor = purchaseOrderLineItem.PurchaseOrder.Vendor;
inventoryProduct.Quantity += purchaseOrderLineItem.TotalReceived.Value;
return(_saveEntityService.ProcessSave(inventoryProduct, crudManager));
}
protected Task <bool> ExistsAsync <TModel>(int id, ICrudManager <TModel> manager) where TModel : class, IModel
{
return(manager.ExistAsync(id));
}
protected GetService(ICrudManager <T, TKey> manager)
{
_manager = manager;
}
public static async Task <ActionResult> Delete <T, TKey>(this Controller controller, ICrudManager <T, TKey> manager, IEnumerable <TKey> ids) where T : class where TKey : IComparable
{
await manager.Delete(ids);
return(controller.NoContent());
}
public static async Task <ActionResult> Update <T, TKey>(this Controller controller, ICrudManager <T, TKey> manager, TKey idFromUri, TKey idFromValue, T value)
where T : class where TKey : IComparable
{
if (idFromUri.CompareTo(idFromValue) != 0)
{
return(controller.BadRequest("Mismatch between id and dto.Id"));
}
await manager.Update(value);
return(controller.NoContent());
}
public static async Task <IEnumerable <UriAndValue <T> > > AddIntern <T, TKey>(this Controller controller, ICrudManager <T, TKey> manager, IEnumerable <T> values)
where T : class where TKey : IComparable
{
var newIds = await manager.Add(values);
var newObjects = await manager.Get(newIds);
string uri = controller.GetCurrentUri("/bulk");
var newUris = newIds.Select(id => uri + "/" + id);
var results = newIds.Select((id, idx) => new UriAndValue <T>()
{
Uri = uri + "/" + id, Value = newObjects.ElementAt(idx)
});
return(results);
}
protected CrudService(ICrudManager <T, TKey> manager) : base(manager)
{
_manager = manager;
}
public static async Task <ActionResult <T> > AddNoGet <T, TKey>(this Controller controller, ICrudManager <T, TKey> manager, T value, Action <T, TKey> setIdFunc)
where T : class where TKey : IComparable
{
TKey newId = await manager.Add(value);
string newUri = controller.GetCurrentUri() + "/" + newId;
setIdFunc(value, newId);
return(controller.Created(newUri, value));
}
public ICrudManager SaveUploadedFile(string systemFolder, string fileNameNoExtension, ICrudManager crudManager)
{
var file = _sessionContext.RetrieveUploadedFile();
if (file == null || file.ContentLength <= 0 || crudManager.HasFailingReport())
{
return(crudManager);
}
var folderPath = _sessionContext.MapPath(systemFolder);
var extension = file.FileName.Substring(file.FileName.LastIndexOf("."));
var newName = fileNameNoExtension + extension;
string filePath = folderPath + "\\" + newName;
var exists = Directory.Exists(folderPath);
if (!exists)
{
Directory.CreateDirectory(folderPath);
}
//TODO insert rules engine here
var fileExists = File.Exists(filePath);
CrudReport crudReport = new CrudReport();
if (fileExists)
{
crudReport.AddErrorInfo(new ErrorInfo(null, WebLocalizationKeys.FILE_ALREADY_EXISTS.ToString()));
crudManager.AddCrudReport(crudReport);
return(crudManager);
}
file.SaveAs(filePath);
crudReport.Success = true;
crudManager.AddCrudReport(crudReport);
return(crudManager);
}
