private StockMovement InstantiateStockMovement()
{
StockMovement sm = new StockMovement();
sm.StockMovementId = IdService.GetNewStockMovementId(context);
sm.CreatedDateTime = DateTime.Now;
return(sm);
}
private Notification InstantiateNotification(ApplicationUser recipient)
{
//instantiate new notification object and populating the fields
return(new Notification {
NotificationId = IdService.GetNewNotificationId(context),
CreatedDateTime = DateTime.Now,
CreatedFor = recipient,
Status = statusRepository.FindById(14)
});
}
public StockMovement SaveStockMovement(DeliveryOrderDetail deliveryOrderDetail)
{
StockMovement sm = new StockMovement();
sm.DeliveryOrderDetail = deliveryOrderDetail;
sm.DeliveryOrderNo = deliveryOrderDetail.DeliveryOrderNo;
sm.DeliveryOrderDetailItemCode = deliveryOrderDetail.ItemCode;
sm.Item = deliveryOrderDetail.Item;
sm.OriginalQuantity = inventoryRepository.FindById(deliveryOrderDetail.ItemCode).Quantity;
sm.AfterQuantity = sm.OriginalQuantity + deliveryOrderDetail.ActualQuantity;
sm.CreatedDateTime = DateTime.Now;
sm.StockMovementId = IdService.GetNewStockMovementId(context);
return(stockMovementRepository.Save(sm));
}
public void DelegateManagerRole(string recipientEmail, string headEmail, string startDate, string endDate)
{
// Date Format: Sat Jul 28 00:00:00 GMT + 08:00 2018
var startDateActual = new DateTime(
Int32.Parse(startDate.Substring(startDate.Length - 4)),
ConvertMonth(startDate.Substring(4, 3)),
Int32.Parse(startDate.Substring(8, 2))
);
var endDateActual = new DateTime(
Int32.Parse(endDate.Substring(endDate.Length - 4)),
ConvertMonth(endDate.Substring(4, 3)),
Int32.Parse(endDate.Substring(8, 2))
);
if (startDateActual > endDateActual)
{
throw new ArgumentException("Invalid dates");
}
if (userService.FindUserByEmail(recipientEmail).Department.Name != userService.FindUserByEmail(headEmail).Department.Name)
{
throw new ArgumentException("Representative and Department Head not from same Department");
}
if (headEmail != userService.FindUserByEmail(headEmail).Department.Head.Email)
{
throw new ArgumentException("Only Department Heads can delegate roles");
}
var delegation = new Delegation()
{
DelegationId = IdService.GetNewDelegationId(context),
Receipient = userService.FindUserByEmail(recipientEmail),
StartDate = startDateActual,
EndDate = endDateActual,
Status = new StatusService(context).FindStatusByStatusId(1),
CreatedBy = userService.FindUserByEmail(headEmail),
CreatedDateTime = DateTime.Now,
};
delegationRepository.Save(delegation);
new UserService(context).AddDepartmentHeadRole(recipientEmail);
}
public List <PurchaseOrder> CreatePOForEachSupplier(List <Supplier> suppliers)
{
List <PurchaseOrder> poList = new List <PurchaseOrder>();
foreach (Supplier supplier in suppliers)
{
PurchaseOrder p = new PurchaseOrder();
p.PurchaseOrderNo = IdService.GetNewPurchaseOrderNo(context);
p.Supplier = supplier;
p.CreatedDateTime = DateTime.Now;
p.Status = statusRepository.FindById(11);
p.Status.StatusId = 11;
purchaseOrderRepository.Save(p);
poList.Add(p);
}
return(poList);
}
/// <summary>
/// Sets Retrieval.Status to "Retrieved".
/// Creates outstanding requisitions for undisbursed items.
/// </summary>
/// <param name="retrievalId"></param>
/// <param name="email"></param>
/// <returns></returns>
public void ConfirmRetrieval(string retrievalId, string email)
{
// Throw exceptions
if (!retrievalRepository.ExistsById(retrievalId))
{
throw new ArgumentException("Retrieval does not exist");
}
var retrieval = retrievalRepository.FindById(retrievalId);
if (retrieval.Status.StatusId == 20)
{
throw new ArgumentException("Retrieval already confirmed");
}
#region Update Retrieval status
retrieval.Status = new StatusService(context).FindStatusByStatusId(20);
retrieval.UpdatedBy = new UserService(context).FindUserByEmail(email);
retrieval.UpdatedDateTime = DateTime.Now;
#endregion
#region Update Disbursement status
foreach (var disbursement in retrieval.Disbursements)
{
// If item has not yet been retrieved, retrieve it
// Since web does not retrieve items before confirm retrieval
foreach (var detail in disbursement.DisbursementDetails)
{
if (detail.Status.StatusId != 18)
{
detail.Status = new StatusService(context).FindStatusByStatusId(18);
stockmovementService.CreateStockMovement(detail);
}
}
disbursement.Status = statusRepository.FindById(8);
}
#endregion
#region Create Outstanding Requisitions
// For every group of requisitions in the retrieval with the same department
foreach (var requisition in retrieval.Requisitions.GroupBy(r => r.Department))
{
// If retrieval has no disbursement for department,
// Change status to Unable to Fulfill (21)
if (retrieval.Disbursements.Where(d => d.Department == requisition.Key).Count() == 0)
{
requisition.ToList().ForEach(r => r.Status = statusRepository.FindById(21));
}
// If disbursement related to requisitions have no actual quantity disbursed,
// Change status to Unable to Fulfill (21)
else if (retrieval.Disbursements.Where(d => d.Department == requisition.Key).FirstOrDefault().DisbursementDetails.All(dd => dd.ActualQuantity == 0))
{
requisition.ToList().ForEach(r => r.Status = statusRepository.FindById(21));
}
var newRequisitionDetails = new List <RequisitionDetail>();
// For every group of requisition details in the combined requisition with the same Item Code
foreach (var detail in requisition.SelectMany(r => r.RequisitionDetails).GroupBy(detail => detail.Item))
{
// Sum of actual quantity disbursement in disbursement details with the same item code
// as requisition details with in disbursement with the same departmentcode
// If not found, quantity disbursed is 0
var totalDisbursedQuantity = retrieval.Disbursements
.Where(disbursement => disbursement.Department == requisition.Key)
.FirstOrDefault() == null ? 0 : retrieval.Disbursements
.Where(disbursement => disbursement.Department == requisition.Key)
.FirstOrDefault()
.DisbursementDetails
.Where(dd => dd.Item == detail.Key)
.Sum(dd => dd.ActualQuantity);
// If total quantity disbursed is 0, change requisition detail status to unfulfilled (21)
if (totalDisbursedQuantity == 0)
{
detail.ToList().ForEach(d =>
{
d.Status = statusRepository.FindById(21);
});
}
// If remaining quantity is 0, skip creating outstanding requisition detail
if (detail.Sum(d => d.Quantity) - totalDisbursedQuantity == 0)
{
continue;
}
newRequisitionDetails.Add(new RequisitionDetail()
{
RequisitionId = IdService.GetNewAutoGenerateRequisitionId(context),
Item = detail.Key,
ItemCode = detail.Key.ItemCode,
Quantity = detail.Sum(d => d.Quantity) - totalDisbursedQuantity,
Status = new StatusService(context).FindStatusByStatusId(3),
});
}
// Create new outstanding requisition
// Collection point is based on one of the requisition in this retrieval for this department at random
var newRequisition = new Requisition()
{
RequisitionId = IdService.GetNewAutoGenerateRequisitionId(context),
Department = requisition.Key,
CollectionPoint = requisition.OrderBy(r => r.CreatedDateTime).FirstOrDefault().CollectionPoint,
CreatedBy = new UserService(context).FindUserByEmail("*****@*****.**"),
CreatedDateTime = DateTime.Now,
Status = new StatusService(context).FindStatusByStatusId(6),
EmployeeRemarks = $"Automatically generated by system based on outstanding quantity - {retrievalId}",
RequisitionDetails = newRequisitionDetails,
};
// If there are any requisition details saved to new outstanding requisition
if (newRequisitionDetails.Count() > 0)
{
new RequisitionRepository(context).Save(newRequisition);
}
}
#endregion
#region Update all requisition statuses that are not Unable to Fulfilled
foreach (var requisition in retrieval.Requisitions)
{
if (requisition.Status.StatusId != 21)
{
requisition.Status = statusRepository.FindById(8);
}
foreach (var detail in requisition.RequisitionDetails)
{
if (detail.Status.StatusId != 21)
{
detail.Status = statusRepository.FindById(8);
}
}
}
#endregion
#region Update disbursement Remarks
foreach (var disbursement in retrieval.Disbursements)
{
if (new RequisitionRepository(context).FindAll()
.Where(r => r.RequisitionId.StartsWith("SRQ") &&
r.EmployeeRemarks.Contains(disbursement.Retrieval.RetrievalId) &&
r.Department.DepartmentCode == disbursement.Department.DepartmentCode)
.Count() == 1)
{
disbursement.Remarks = $"Please note that this disbursement is a partial fulfillment. We will try to fulfill the rest of your order in the next order cycle. We thank you for your patience and understanding.";
}
}
#endregion
retrievalRepository.Save(retrieval);
#region Create Notification
foreach (var requisition in retrieval.Requisitions.GroupBy(r => r.Department))
{
if (retrieval.Disbursements.Where(d => d.Department.DepartmentCode == requisition.Key.DepartmentCode).Count() == 0)
{
new NotificationService(context).CreateUnableToFulFillNotification(retrieval, requisition.Key.Representative);
}
}
foreach (var disbursement in retrieval.Disbursements)
{
foreach (var requisition in disbursement.Retrieval.Requisitions.GroupBy(r => r.CreatedBy))
{
var notification = new NotificationService(context).CreateNotification(disbursement, requisition.Key);
new NotificationApiController()
{
context = context
}.SendEmail(notification.NotificationId.ToString());
}
}
#endregion
}
public string ProcessRequisitions(List <Requisition> requestList)
{
if (requestList.Count == 0)
{
throw new Exception("List of Requisitions cannot be null");
}
// create one Retrieval
Retrieval r = new Retrieval();
r.RetrievalId = IdService.GetNewRetrievalId(context);
r.CreatedDateTime = DateTime.Now;
r.Status = statusRepository.FindById(19);
if (HttpContext.Current != null)
{
r.CreatedBy = userRepository.FindById(HttpContext.Current.User.Identity.GetUserId());
}
// save the Retrieval
retrievalService.Save(r);
// Map each requisition to each retrieval
foreach (Requisition req in requestList)
{
req.Retrieval = r;
}
// create Disbursements, one for each department
List <Disbursement> emptyDisbursements = CreateDisbursementForEachDepartment(requestList);
// create DisbursementDetails, one for each item by department
List <Disbursement> filledDisbursements = AddDisbursementDetailsForEachDisbursement(emptyDisbursements, requestList);
foreach (Disbursement d in filledDisbursements)
{
var newDisbursementDetails = new List <DisbursementDetail>();
// if disbursement details has plan quantity = 0, ignore
for (int i = 0; i < d.DisbursementDetails.Count(); i++)
{
if (d.DisbursementDetails[i].PlanQuantity == 0)
{
// Change Requisition Detail Status to Unable to fulfill when no quantity is disbursed
d.Retrieval.Requisitions.SelectMany(requisition => requisition.RequisitionDetails.Where(detail => detail.ItemCode == d.DisbursementDetails[i].ItemCode)).ToList().ForEach(detail =>
{
detail.Status = statusRepository.FindById(21);
});
continue;
}
// Add only DisbursementDetails that have plan quantity
newDisbursementDetails.Add(d.DisbursementDetails[i]);
}
// Replace DisbursementDetails with filtered list
d.DisbursementDetails = newDisbursementDetails;
// if disbursement has no disbursement details, skip to next disbursement
if (d.DisbursementDetails.Count() == 0)
{
// Change Requisition Status to Unable to fulfill when no items are disbursed
d.Retrieval.Requisitions.Where(requisition => requisition.Department.DepartmentCode == d.Department.DepartmentCode).ToList().ForEach(requisition =>
{
requisition.Status = statusRepository.FindById(21);
requisitionRepository.Save(requisition);
});
continue;
}
d.DisbursementId = IdService.GetNewDisbursementId(context);
d.Retrieval = r;
d.Status = statusRepository.FindById(17);
if (HttpContext.Current != null)
{
d.CreatedBy = userRepository.FindById(HttpContext.Current.User.Identity.GetUserId());
}
disbursementService.Save(d);
}
// update the status of the requisitions
foreach (Requisition req in requestList)
{
req.Status = statusRepository.FindById(7);
requisitionRepository.Save(req);
}
return(r.RetrievalId);
}
