public void MapFromDomainEntity_ValidEntity_ReturnDTOEntity()
{
//Arrange
var requisition = new RequisitionDTO
{
ProjectId = new Guid("b58b6a58-2064-4c71-9b3d-c8c4514159a9"),
RequisitionNumber = "1001",
OrderTotal = 50000D,
ReportingTotal = 60000D,
Account = "Account",
Supplier = "Supplier",
CreatedDate = new DateTime(2019, 08, 01),
Status = "Status",
PurchaseOrderNumber = "1234",
Item = "Item",
Currency = "US Dollar"
};
//Act
var response = Requisition.MapFromDomainEntity(requisition);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(requisition.ProjectId, response.ProjectId);
Assert.AreEqual(requisition.RequisitionNumber, response.RequisitionNumber);
Assert.AreEqual(requisition.OrderTotal, response.OrderTotal);
Assert.AreEqual(requisition.ReportingTotal, response.ReportingTotal);
Assert.AreEqual(requisition.Account, response.Account);
Assert.AreEqual(requisition.Supplier, response.Supplier);
Assert.AreEqual(requisition.CreatedDate, response.CreatedDate);
Assert.AreEqual(requisition.Status, response.Status);
Assert.AreEqual(requisition.PurchaseOrderNumber, response.PurchaseOrderNumber);
Assert.AreEqual(requisition.Item, response.Item);
Assert.AreEqual(requisition.Currency, response.Currency);
}
public void RemoveProduct(int productId)
{
List <RequisitionDTO> cart = Session["cart"] as List <RequisitionDTO>;
RequisitionDTO item = (cart ?? throw new InvalidOperationException()).FirstOrDefault(x => x.ProductId == productId);
cart.Remove(item);
}
public void MapToRequisitionLineItemDTO_NullContent_ReturnNull()
{
//Act
var response = RequisitionDTO.MapToRequisitionLineItemDTO(null);
//Assert
Assert.IsNull(response);
}
public void Approved(RequisitionDTO entry)
{
Requisition po = new Requisition();
po.No = entry.No;
po.Approved = entry.Approved;
reqRepo.Approved(po);
}
public void Checked(RequisitionDTO entry)
{
Requisition po = new Requisition();
po.No = entry.No;
po.Checked = entry.Checked;
reqRepo.Checked(po);
}
public ActionResult AddToCart(int id)
{
//POst cart
List <RequisitionDTO> cart = Session["cart"] as List <RequisitionDTO> ?? new List <RequisitionDTO>();
// Init CartVM
RequisitionDTO model = new RequisitionDTO();
// Get the product
Product product = db.Find(id);
var productInCart = cart.FirstOrDefault(x => x.ProductId == id);
if (productInCart == null)
{
cart.Add(new RequisitionDTO()
{
ProductId = product.ProductId,
ProductCode = product.item_code,
ProductDescription = product.Description,
Metric = product.Unit.name,
Qty = 1,
});
}
else
{
// If it is, increment
productInCart.Qty++;
}
// Get total qty and price and add to model
int qty = 0;
foreach (var item in cart)
{
qty += item.Qty;
}
model.Qty = qty;
// Save cart back to session
Session["cart"] = cart;
// Return partial view with model
return(PartialView(model));
}
public void Save(RequisitionDTO entry)
{
try
{
Requisition req = new Requisition();
req.No = entry.No;
req.Date = entry.RequisitionDate;
req.JobOrderNo = entry.JobOrderNo;
req.CompanyId = entry.CompanyTo;
req.UnitPlateNo = entry.UnitPlateNo;
req.JobOrderDate = entry.JobOrderDate;
req.OdometerReading = entry.OdometerReading; //Get from session
req.DriverName = entry.DriverName; //Get from session
req.ReportedBy = entry.ReportedBy; //Get from session
req.CheckedBy = entry.CheckedBy; //Get from session
req.ApprovedBy = Common.GetCurrentUser.GeneralManagerId; //Get from session
req.CompanyId = Sessions.CompanyId.Value;
List <RequisitionItem> lstReqItem = new List <RequisitionItem>();
foreach (RequisitionDTO.Item item in entry.Items)
{
RequisitionItem reqItem = new RequisitionItem
{
RequisitionId = req.Id,
ItemId = item.ItemId,
Quantity = item.Quantity,
SerialNo = item.SerialNo,
Type = item.Type,
QuantityReturn = item.QuantityReturn,
SerialNoReturn = item.SerialNoReturn
};
lstReqItem.Add(reqItem);
}
req.RequisitionItems = lstReqItem;
if (Sessions.CompanyId != entry.CompanyTo)
{
SaveStockTransfer(entry);
}
reqRepo.Save(req);
}
catch { }
}
public JsonResult ProdIncrement(int productId)
{
List <RequisitionDTO> cart = Session["cart"] as List <RequisitionDTO>;
RequisitionDTO item = cart.FirstOrDefault(x => x.ProductId == productId);
if (item != null)
{
item.Qty++;
}
var result = new { qty = item.Qty };
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void SaveStockTransfer(RequisitionDTO entry)
{
StockTransfer st = new StockTransfer();
st.No = entry.No;
st.Date = entry.RequisitionDate;
if (entry.CompanyTo == 0)
{
int vehicleId = vehicleRepo.GetIdByPlateNo(entry.UnitPlateNo);
st.CompanyTo = veAssignRepo.GetIdByVehicleId(vehicleId);
}
else
{
st.CompanyTo = entry.CompanyTo;
}
st.JobOrderNo = entry.JobOrderNo;
st.UnitPlateNo = entry.UnitPlateNo;
st.JobOrderDate = entry.JobOrderDate;
st.OdometerReading = entry.OdometerReading; //Get from session
st.DriverName = entry.DriverName; //Get from session
st.ReportedBy = entry.ReportedBy; //Get from session
st.CheckedBy = entry.CheckedBy; //Get from session
st.ApprovedBy = Common.GetCurrentUser.GeneralManagerId; //Get from session
st.CompanyId = Sessions.CompanyId.Value;
List <StockTransferItem> lstStItem = new List <StockTransferItem>();
foreach (RequisitionDTO.Item item in entry.Items)
{
StockTransferItem stItem = new StockTransferItem
{
StockTransferId = st.Id,
ItemId = item.ItemId,
Quantity = item.Quantity,
SerialNo = item.SerialNo,
Type = item.Type,
QuantityReturn = item.QuantityReturn,
SerialNoReturn = item.SerialNoReturn
};
lstStItem.Add(stItem);
}
st.StockTransferItems = lstStItem;
stRepo.Save(st);
}
public IHttpActionResult CreateRequisition([FromBody] RequisitionDTO requisitionDto)
{
var empNum = requisitionDto.RequisitionEmpNum;
var employee = _employeeRepo.GetById(empNum);
var isDelegated = _delegateRepo.FindCurrentByEmpNum(empNum) != null;
if (isDelegated)
{
return(BadRequest("Delegated staff cannot make request"));
}
var detail = requisitionDto.RequisitionDetails.First();
var requisitionDetail = new RequisitionDetail()
{
ItemNum = detail.ItemNum,
Quantity = detail.Quantity,
};
var requisition = new Requisition()
{
RequisitionEmpNum = requisitionDto.RequisitionEmpNum,
DeptCode = employee.DeptCode,
RequestRemarks = requisitionDto.RequestRemarks,
RequisitionDate = DateTime.Today,
Status = RequisitionStatus.Pending,
RequisitionDetails = new List <RequisitionDetail>()
{
requisitionDetail
}
};
_requistionRepo.Add(requisition);
requisition.RequisitionDetails.First().Stationery = _stationeryRepo.GetById(detail.ItemNum);
//Send email on new thread
var headEmail = _employeeRepo.GetDepartmentHead(employee.DeptCode).EmailAddress;
var email = new LUSSISEmail.Builder().From(employee.EmailAddress).To(headEmail)
.ForNewRequistion(employee.FullName, requisition).Build();
new Thread(delegate() { EmailHelper.SendEmail(email); }).Start();
return(Ok(new { Message = "Requisition created" }));
}
public void MapToRequisitionHeaderDTO_ValidEntity_ReturnDTOEntity()
{
//Act
var response = RequisitionDTO.MapToRequisitionHeaderDTO(requisition);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(requisition.Id, response.Id);
Assert.AreEqual(requisition.Supplier, response.Supplier);
Assert.AreEqual(requisition.RequisitionNumber, response.RequisitionNumber.ToString());
Assert.AreEqual(requisition.Status, response.Status);
DateTime.TryParse(requisition.CreatedDate, out DateTime createdDate);
Assert.AreEqual(createdDate, response.CreatedDate);
Assert.AreEqual(requisition.Currency, response.Currency);
Assert.AreEqual(requisition.PurchaseOrderNumber, response.PurchaseOrderNumber.ToString());
Assert.AreEqual(requisition.ProjectId, response.ProjectId);
}
public async Task <RequisitionDTO> RequestAPI(string cnpj)
{
RequisitionDTO model = new RequisitionDTO();
HttpClient client = new HttpClient();
try
{
HttpResponseMessage response = await client.GetAsync($"https://www.receitaws.com.br/v1/cnpj/{cnpj}");
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
JsonReceiverDTO obJson = JsonConvert.DeserializeObject <JsonReceiverDTO>(json);
if (obJson.status == "OK")
{
model.entidade = new EntidadeDTO();
model.entidade = obJson.LoadEntidadeJson(obJson);
model.statusCode = response.StatusCode;
}
else
{
dynamic jObject = JObject.Parse(json);
model.statusCode = response.StatusCode;
model.message = jObject.message;
}
return(model);
}
else
{
model.statusCode = response.StatusCode;
model.message = response.RequestMessage.ToString();
return(model);
}
}
catch (Exception ex)
{
model.message = "Erro na requisição.";
return(model);
}
}
//Produce decrement
public JsonResult ProdDecrement(int productId)
{
List <RequisitionDTO> cart = Session["cart"] as List <RequisitionDTO>;
RequisitionDTO item = (cart ?? throw new InvalidOperationException()).FirstOrDefault(x => x.ProductId == productId);
if (item.Qty > 1)
{
item.Qty--;
}
else
{
item.Qty = 0;
cart.Remove(item);
}
var result = new { qty = item.Qty };
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void MapToRequisitionLineItemDTO_ValidEntity_ReturnDTOEntity()
{
//Act
var response = RequisitionDTO.MapToRequisitionLineItemDTO(requisition);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(requisition.Id, response.Id);
Assert.AreEqual(requisition.RequisitionLineNumber, response.RequisitionLineNumber.ToString());
Assert.AreEqual(requisition.OrderTotal, response.OrderTotal.ToString());
Assert.AreEqual(requisition.ReportingTotal, response.ReportingTotal.ToString());
Assert.AreEqual(requisition.Item, response.Item);
Assert.AreEqual(requisition.Account, response.Account);
Assert.AreEqual(requisition.CostCode, response.CostCode);
Assert.AreEqual(requisition.ProjectDescription, response.ProjectDescription);
Assert.AreEqual(requisition.TargetLocationCode, response.TargetLocationCode);
Assert.AreEqual(requisition.ShipToAddressName, response.ShipToAddressName);
Assert.AreEqual(requisition.RequestedBy, response.RequestedBy);
Assert.AreEqual(requisition.CurrentApprover, response.CurrentApprover);
Assert.AreEqual(requisition.CreatedBy, response.CreatedBy);
Assert.AreEqual(requisition.RequisitionHeaderId, response.RequisitionHeaderId);
}
public async Task <IHttpActionResult> Process([FromBody] RequisitionDTO requisition)
{
if (requisition.RequisitionEmpNum == requisition.ApprovalEmpNum)
{
return(BadRequest("Employee cannot process its own requisition"));
}
var employee = _employeeRepo.GetById(requisition.ApprovalEmpNum);
if (_delegateRepo.FindCurrentByDeptCode(employee.DeptCode) != null)
{
return(BadRequest("Must revoke current delegate to approve."));
}
try
{
var req = await _requistionRepo.GetByIdAsync(requisition.RequisitionId);
req.ApprovalEmpNum = requisition.ApprovalEmpNum;
req.ApprovalRemarks = requisition.ApprovalRemarks;
req.ApprovalDate = DateTime.Today;
req.Status = requisition.Status;
await _requistionRepo.UpdateAsync(req);
//Send email
var toEmail = _employeeRepo.GetById(requisition.RequisitionEmpNum).EmailAddress;
var approvalEmail = _employeeRepo.GetById(requisition.ApprovalEmpNum).EmailAddress;
var email = new LUSSISEmail.Builder().From(approvalEmail).To(toEmail)
.ForRequisitionApproval(req).Build();
new Thread(delegate() { EmailHelper.SendEmail(email); }).Start();
return(Ok(new { Message = "Updated" }));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult CartPartial()
{
RequisitionDTO request = new RequisitionDTO();
int qty = 0;
if (Session["cart"] != null)
{
var list = (List <RequisitionDTO>)Session["cart"];
foreach (var item in list)
{
qty += item.Qty;
}
request.Qty = qty;
}
else
{
request.Qty = 0;
}
return(PartialView(request));
}
public static Requisition MapFromDomainEntity(RequisitionDTO projectRequisition)
{
if (projectRequisition == null)
{
return(null);
}
return(new Requisition
{
Id = projectRequisition.Id,
ProjectId = projectRequisition.ProjectId,
Status = projectRequisition.Status,
Item = projectRequisition.Item,
OrderTotal = projectRequisition.OrderTotal,
PurchaseOrderNumber = projectRequisition.PurchaseOrderNumber.GetValueOrDefault(),
RequisitionNumber = projectRequisition.RequisitionNumber,
Account = projectRequisition.Account,
CreatedDate = projectRequisition.CreatedDate,
Currency = projectRequisition.Currency,
ReportingTotal = projectRequisition.ReportingTotal,
Supplier = projectRequisition.Supplier
});
}
// Import Requisition
public CoupaImporterJobDefinitionDTO ProcessRequisitionImportJob(Guid jobDefinitionId)
{
var jobDefinition = _coupaImporterRepository.Get(jobDefinitionId);
if (jobDefinition == null)
{
return(null);
}
_unitOfWork.AutoDetectChanges(false);
var requisitionHeaders = new List <RequisitionHeader>();
var listOfRequisitionDTO = new List <RequisitionDTO>();
// Here we use 1000 records batch so that we can reduce the number of loops.
var noOfRotation = jobDefinition.CoupaImporterJobDefinitionDetails.Count() / 1000;
noOfRotation += jobDefinition.CoupaImporterJobDefinitionDetails.Count() % 1000 > 0 ? 1 : 0;
for (var i = 0; i < noOfRotation; i++)
{
var strCoupaImporterJobDefinitionDetails = "[ ";
strCoupaImporterJobDefinitionDetails += string.Join(", ", jobDefinition.CoupaImporterJobDefinitionDetails
.Skip(i * 1000).Take(1000).Select(x => x.RawContent));
strCoupaImporterJobDefinitionDetails += " ]";
// Convert the RawContent to RequisitionHeader
requisitionHeaders.AddRange(JsonConvert.DeserializeObject <List <RequisitionHeader> >(strCoupaImporterJobDefinitionDetails));
// Convert the RawContent to RequisitionDTO
listOfRequisitionDTO.AddRange(JsonConvert.DeserializeObject <List <RequisitionDTO> >(strCoupaImporterJobDefinitionDetails));
}
// In every InvoiceHeader Entity ProjectId is added
requisitionHeaders.ForEach(i => { i.ProjectId = jobDefinition.ProjectId; i.Id = Guid.NewGuid(); });
// Grouping InvoiceHeaders in terms of Unique combination of Supplier & InvoiceNumber
requisitionHeaders = requisitionHeaders.GroupBy(i => new { i.RequisitionNumber, i.Supplier }).Select(x => x.First()).ToList();
foreach (var objRequisition in requisitionHeaders)
{
// Allocate all line items for a invoice header + InvoiceHeaderId added in every associated Line Items.
objRequisition.RequisitionLineItems = listOfRequisitionDTO.Where(x => x.Supplier == objRequisition.Supplier && x.RequisitionNumber == objRequisition.RequisitionNumber.ToString())
.Select(x => RequisitionLineItem.MapFromDomainEntity(RequisitionDTO.MapToRequisitionLineItemDTO(x))).ToList();
objRequisition.RequisitionLineItems.ToList().ForEach(x => { x.RequisitionHeaderId = objRequisition.Id; x.Id = Guid.NewGuid(); });
_projectRequisitionRepository.Add(objRequisition);
}
// At last update all job definition details records
jobDefinition.CoupaImporterJobDefinitionDetails.ToList().ForEach(c => { c.IsProcessed = true; c.IsSuccessful = true; });
_coupaImporterRepository.UpdateAllJobDefinitionDetail(jobDefinitionId, jobDefinition.CoupaImporterJobDefinitionDetails);
jobDefinition.Status = (int)CoupaImporterStatus.Processed;
_coupaImporterRepository.Update(jobDefinitionId, jobDefinition);
_unitOfWork.SaveChanges();
_unitOfWork.AutoDetectChanges(true);
return(CoupaImporterJobDefinitionDTO.MapFromDatabaseEntity(jobDefinition));
}
// GET: api/MobileRequisition/5
public RequisitionListDTO Get(int id)
{
//Get all requsition from this employee
List <Requisition> requisitionHistory = requisitionCatalogueService.GetPersonalRequisitionHistory(id);
List <RequisitionDTO> moDepartmentRequisition = new List <RequisitionDTO>();
foreach (Requisition r in requisitionHistory)
{
RequisitionDTO rDTO = new RequisitionDTO
{
Employee = new EmployeeDTO
{
DepartmentId = r.Employee.DepartmentId,
Email = r.Employee.Email,
Name = r.Employee.Name,
Id = r.Employee.Id,
Image = r.Employee.Image,
Password = r.Employee.Password,
RoleId = r.Employee.RoleId,
Username = r.Employee.Username,
Title = r.Employee.Title
},
Id = r.Id,
EmployeeId = r.EmployeeId,
DateTime = r.DateTime,
Status = r.Status,
Remarks = r.Remarks
};
foreach (RequisitionDetail rd in r.RequisitionDetails)
{
RequisitionDetailDTO rdDTO = new RequisitionDetailDTO
{
Id = rd.Id,
RequisitionId = rd.RequisitionId,
DisbursementId = rd.DisbursementId,
StationeryId = rd.StationeryId,
QuantityOrdered = rd.QuantityOrdered,
QuantityDelivered = rd.QuantityDelivered,
Status = rd.Status,
Stationery = new StationeryDTO
{
Id = rd.Stationery.Id,
Description = rd.Stationery.Description,
Bin = rd.Stationery.Bin,
Image = rd.Stationery.Image
}
};
rDTO.RequisitionDetails.Add(rdDTO);
}
moDepartmentRequisition.Add(rDTO);
}
RequisitionListDTO model = new RequisitionListDTO()
{
Requisitions = moDepartmentRequisition
};
return(model);
}
