private async Task <bool> IsPyxisLoadTransactionExists(string deliverToLocation, int facilityId, int formularyId) { TransactionPriority priority = await _transactionPriorityManager.GetTransactionPriority(Priority.PYXISLOAD, facilityId); if (priority != null) { var transactionQueueModels = await _transactionQueueRepository.GetAllTransactions(tq => { if ((tq.Status == TransactionStatus.Pending.ToString() || tq.Status == TransactionStatus.Hold.ToString()) && tq.Destination == deliverToLocation && tq.FormularyId == formularyId && tq.FacilityId == facilityId && tq.TranPriorityId == priority.TransactionPriorityId) { return(true); } else { return(false); } }); if (transactionQueueModels != null && transactionQueueModels.Any()) { return(true); } } return(false); }
/// <summary> /// Get TransactionPriority by FacilityId and PriorityCode. /// This will include TransactionPriorityDetails /// </summary> /// <param name="facilityId"></param> /// <param name="priorityCode"></param> /// <returns></returns> public async Task <TransactionPriority> GetTransactionPriority(int facilityId, string priorityCode) { TransactionPriority transactionPriority = null; var transactionPriorityDb = await _transactionPriorityRepository.GetTransactionPriority(facilityId, priorityCode); if (transactionPriorityDb != null) { transactionPriority = _mapper.Map <TransactionPriority>(transactionPriorityDb); return(transactionPriority); } return(transactionPriority); }
/// <summary> /// Initializes the private fields /// </summary> public TransactionPriorityManagerUnitTest() { _requestRepository = new Mock <IRequestRepository>(); _logger = new Mock <ILogger <TransactionPriorityManager> >(); _transactionPriorityRequest = new TransactionPriority { PriorityCode = "PATIENTPICK", FacilityId = 1, IsActive = true }; _transactionPriorityManager = new TransactionPriorityManager(_requestRepository.Object, _logger.Object); }
/// <summary> /// Check for TransactionPriority. /// If validation fails, return response message /// </summary> /// <param name="transactionPriority"></param> /// <param name="incomingRequestId"></param> /// <param name="priorityCode"></param> private string CheckTransactionPriority(string incomingRequestId, TransactionPriority transactionPriority, string priorityCode) { string responseMessage = string.Empty; if (transactionPriority == null) { responseMessage = LoggingMessage.PriorityInvalid; _logger.LogInformation($"{ incomingRequestId}" + IncomingRequestStatus.Rejected + $"{priorityCode}" + LoggingMessage.PriorityInvalid); return(responseMessage); } return(responseMessage); }
/// <summary> /// Get CriticalLow or StockOut Transactions /// </summary> /// <param name="request"></param> /// <param name="item"></param> /// <returns></returns> private async Task <TransactionQueueModel> GetRefillTransaction(TransactionRequest request, Item item) { List <Infrastructure.DBModel.TransactionQueue> transactionQueueModels = await _transactionQueueRepository.GetAllTransactions(); TransactionQueueModel tranQClSo = null; if (transactionQueueModels != null && transactionQueueModels.Any()) { var result = (from tq in transactionQueueModels where (tq.Status == TransactionStatus.Pending.ToString() || tq.Status == TransactionStatus.Hold.ToString()) && (tq.Type == TransactionType.Batch.ToString() || (tq.Type == TransactionType.Pick.ToString() && tq.Destination != CommonConstants.Destination.BatchPick)) && tq.Destination == request.Patient.DeliverToLocation && tq.ItemId == item.ItemId && tq.FacilityId == request.Facility.FacilityId select tq); if (result != null && result.Any()) { var lstTransactionQueueModel = new List <TransactionQueueModel>(); foreach (var transaction in result) { TransactionPriority priority = await _transactionPriorityManager.GetTransactionPriority(transaction.TranPriorityId); if (priority != null && priority.IsAdu.GetValueOrDefault(false) && StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString())) { lstTransactionQueueModel.Add(_mapper.Map <TransactionQueueModel>(transaction)); } } if (lstTransactionQueueModel.Any()) { tranQClSo = (from tq in lstTransactionQueueModel orderby tq.ReceivedDt descending select tq).FirstOrDefault(); } } } return(tranQClSo); }
private void ConfigureTimeToLive(TransactionPriority priority, TransactionQueueModel newTransaction) { if (priority.TransactionPriorityCode == Priority.STAT.ToString()) { newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Stat)); } else if (newTransaction.Destination == TransactionType.BatchParent.ToString()) { newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.BatchPicks)); } else if (newTransaction.Type == TransactionType.Pick) { newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Pick)); } else if (newTransaction.Type == TransactionType.CycleCount) { newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.CycleCount)); } else { newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Other)); } }
public async Task GetTransactionPriority_ShouldReturnTransactionPriority() { //Arrange string mockPriorityCode = "PATIENTPICK"; int mockfacilityId = 1; //Arrange CCEProxy.API.Infrastructure.DataAccess.DBModel.TransactionPriority transactionPriority = new CCEProxy.API.Infrastructure.DataAccess.DBModel.TransactionPriority() { FacilityId = mockfacilityId, PriorityCode = mockPriorityCode }; _mockTransactionPriorityRepository.Setup(x => x.GetTransactionPriority(mockfacilityId, mockPriorityCode)) .Returns(Task.FromResult(transactionPriority)); //Act IRequestRepository requestRepository = new RequestRepository(_mockIncomingRepository.Object, _mockTransactionPriorityRepository.Object, _mockFacilityRepository.Object, _mapper); TransactionPriority mockResponse = await requestRepository.GetTransactionPriority(mockfacilityId, mockPriorityCode); //Assert Assert.Equal(mockPriorityCode, mockResponse.PriorityCode); }
/// <summary> /// This method is used for processing Adu transaction /// </summary> /// <param name="request"></param> /// <param name="transactionQueueModel"></param> /// <param name="item"></param> /// <param name="priority"></param> /// <param name="facility"></param> /// <returns></returns> public async Task <Tuple <bool, bool> > ProcessAduTransaction(TransactionRequest request, TransactionQueueModel transactionQueueModel, Item item, TransactionPriority priority, ExternalDependencies.BusinessLayer.Models.Facility facility) { var result = new Tuple <bool, bool>(false, false); //PyxisLoad duplicate check if (await IsPyxisLoadTransactionExists(request.Patient.DeliverToLocation, facility.Id, transactionQueueModel.FormularyId)) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.PyxisLoadTransactionExists, request.RequestId)); //Not updated any existing txn and current txn should be ignored result = new Tuple <bool, bool>(true, false); return(result); } //If the current transaction is not of type PYXISLOAD if (priority.IsAdu.GetValueOrDefault(false) && !StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISLOAD.ToString())) { //Refill duplicate check if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString()) && await IsPyxisRefillTransactionExists(request.Patient.DeliverToLocation, facility.Id, transactionQueueModel.FormularyId)) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.PyxisRefillTransactionExists, request.RequestId)); //Not updated any existing txn and current txn should be ignored result = new Tuple <bool, bool>(true, false); return(result); } //Get the critlow, stockout or stkout transaction from Database var tranQClSo = await GetCriticalLowOrStockOutTransaction(request, item); //If the current transaction is refill if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString()) && tranQClSo != null) { result = await UpdateQuantityFromReplenishmentOrder(transactionQueueModel.Quantity.Value, tranQClSo); return(result); } //If the current transaction is critlow, stockout or stkout if (priority != null && IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode)) { //Get the refill transaction from Database var tranQRefillDetail = await GetRefillTransaction(request, item); //If there is not transation of type Refill present in Database if (tranQRefillDetail != null) { await ConvertReplenishmentToCriticalLowOrStockOut(tranQRefillDetail, request, priority, transactionQueueModel.Quantity.Value); _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.UpdatedQuantityPriorityAndRequestIdForAduTransaction, transactionQueueModel.Quantity.Value, priority.TransactionPriorityCode, request.RequestId)); //Updated one existing txn result = new Tuple <bool, bool>(true, true); return(result); } if (tranQClSo != null) { var priorityResult = await _transactionPriorityManager.GetTransactionPriority(tranQClSo.TranPriorityId); //Case when Critical Low exists in DB if (IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode) && StringHelper.IsEqual(priorityResult.TransactionPriorityCode, Priority.PYXISCRITLOW.ToString())) { tranQClSo.Quantity = transactionQueueModel.Quantity.Value; tranQClSo.QuantityProcessed = tranQClSo.Quantity; tranQClSo.TranPriorityId = priority.TransactionPriorityId; tranQClSo.StatusChangeDT = DateTime.Now; tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow; tranQClSo.IncomingRequestId = request.RequestId; await _transactionQueueRepository.UpdateTransaction(tranQClSo); //Updated one existing txn result = new Tuple <bool, bool>(true, true); } //Case when Stockout Low exists in DB else if (IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode) && StringHelper.IsEqual(priorityResult.TransactionPriorityCode, Priority.PYXISSTOCKOUT.ToString())) { tranQClSo.Quantity = transactionQueueModel.Quantity.Value; tranQClSo.QuantityProcessed = tranQClSo.Quantity; tranQClSo.StatusChangeDT = DateTime.Now; tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow; tranQClSo.IncomingRequestId = request.RequestId; await _transactionQueueRepository.UpdateTransaction(tranQClSo); //Updated one existing txn result = new Tuple <bool, bool>(true, true); } else { //Not updated any existing txn and current txn should be ignored result = new Tuple <bool, bool>(true, false); } return(result); } return(await EligibleforAduDupDelete(transactionQueueModel, facility, request)); } } return(result); }
private async Task ConvertReplenishmentToCriticalLowOrStockOut(TransactionQueueModel tranQRefillDetail, TransactionRequest request, TransactionPriority priority, int quantity) { tranQRefillDetail.TranPriorityId = priority.TransactionPriorityId; tranQRefillDetail.Type = TransactionType.Pick; tranQRefillDetail.Quantity = quantity; tranQRefillDetail.QuantityProcessed = quantity; tranQRefillDetail.StatusChangeDT = DateTime.Now; tranQRefillDetail.StatusChangeUtcDateTime = DateTime.UtcNow; tranQRefillDetail.IncomingRequestId = request.RequestId; await _transactionQueueRepository.UpdateTransaction(tranQRefillDetail); }
private void SetTransactionDetails(TransactionPriority priority, Formulary formulary, Facility facility, FacilityFormulary facilityFormulary, Destination destination, TransactionRequest incomingRequest, Item item, int partNo, int orderCount, TransactionQueueModel newTransaction, int quantity) { var localNow = DateTime.Now; var utcNow = DateTime.UtcNow; User usr = new User(UserName.Admin.ToString()); newTransaction.StatusChangeDT = localNow; newTransaction.StatusChangeUtcDateTime = utcNow; if (formulary != null) { newTransaction.Description = (priority != null && priority.UseInterfaceItemName.GetValueOrDefault()) ? item.ItemName : formulary.Description; newTransaction.FormularyId = formulary.FormularyId; } // Apply ADU Round if Qualifies if (quantity > 0 && facility != null && priority != null && destination != null && facilityFormulary != null && (priority.IsAdu != null && (bool)priority.IsAdu) && (facility.AduQtyRounding != null && (bool)facility.AduQtyRounding) && (facilityFormulary.AduQtyRounding != null && (bool)facilityFormulary.AduQtyRounding) && (destination.AduQtyRounding != null && (bool)destination.AduQtyRounding)) { newTransaction.Quantity = AduQtyRound(quantity); newTransaction.QuantityProcessed = newTransaction.Quantity; _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.AduQuantity, newTransaction.Quantity, incomingRequest.RequestId)); } else { newTransaction.Quantity = quantity; newTransaction.QuantityProcessed = newTransaction.Quantity; } newTransaction.Type = TransactionType.Pick; newTransaction.OrderId = incomingRequest.Order?.OrderNo; newTransaction.ItemId = item.ItemId; if (!string.IsNullOrEmpty(item.ComponentStrength)) { newTransaction.Strength = item.ComponentStrength.Trim(); } if (!string.IsNullOrEmpty(item.ComponentStrengthUnits)) { newTransaction.StrengthUnit = item.ComponentStrengthUnits.Trim(); } //set these two to real values for display purposes newTransaction.ComponentNumber = partNo; newTransaction.NumberOfComponents = orderCount; // Patient info SetPatientInfo(newTransaction, incomingRequest); newTransaction.FacilityId = facility.Id; newTransaction.IncomingRequestId = incomingRequest.RequestId; if (priority != null) { newTransaction.TranPriorityId = priority.TransactionPriorityId; } newTransaction.ReceivedDt = localNow; newTransaction.ReceivedUtcDateTime = utcNow; if (usr != null) { newTransaction.RequestedBy = usr.UserName; } if (!string.IsNullOrEmpty(incomingRequest.Patient?.DeliverToLocation)) { newTransaction.Destination = incomingRequest.Patient.DeliverToLocation.Trim(); } if (!string.IsNullOrEmpty(newTransaction.Exception) && newTransaction.Exception.Length > 80) { newTransaction.Exception = newTransaction.Exception.Substring(0, 80); } if (!string.IsNullOrEmpty(item.Concentration)) { newTransaction.Concentration = item.Concentration.Trim(); } if (!string.IsNullOrEmpty(item.TotalDose)) { newTransaction.TotalDose = item.TotalDose.Trim(); } if (!string.IsNullOrEmpty(item.DispenseAmount)) { newTransaction.DispenseAmount = item.DispenseAmount.Trim(); } }
/// <summary> /// Insert TransactionPriority to db. /// </summary> /// <param name="transactionPriority"></param> public async Task AddTransactionPriorityRequest(TransactionPriority transactionPriority) { var insertTransactionPriorityRequest = _mapper.Map <Infrastructure.DataAccess.DBModel.TransactionPriority>(transactionPriority); await _transactionPriorityRepository.InsertAsync(insertTransactionPriorityRequest); }
/// <summary> /// This method processes the facility request from Facility Service and insert the data into database. /// <param name="transactionPriorityRequest">facilityRequest</param> /// </summary> public async Task ProcessTransactionPriorityRequest(TransactionPriority transactionPriorityRequest) { _logger.LogInformation(LoggingMessage.ProcessTransactionPriorityRequest, JsonConvert.SerializeObject(transactionPriorityRequest)); await _requestRepository.AddTransactionPriorityRequest(transactionPriorityRequest); }