/// <summary> Insert transaction queue data into DB. </summary> /// <param name="tranQueue"> TransactionQueueModel model </param> /// <returns>transactionQueueId </returns> public async Task <string> CreateTransaction(TransactionQueueModel tranQueue) { var entity = _mapper.Map <DBModel.TransactionQueue>(tranQueue); entity.CreatedBy = UserName.Admin.ToString(); entity.CreatedDate = DateTime.Now; entity.ModifiedBy = UserName.Admin.ToString(); entity.ModifiedDate = DateTime.Now; await _collection.InsertOneAsync(entity); return(entity.Id); }
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); }
/// <summary> /// Update transaction queue data into DB. /// </summary> /// <param name="transaction"> TransactionQueueModel model </param> public async Task <DBModel.TransactionQueue> UpdateTransaction(TransactionQueueModel transaction) { if (!string.IsNullOrEmpty(transaction.TransactionQueueId)) { var entity = _mapper.Map <DBModel.TransactionQueue>(transaction); entity.ModifiedBy = UserName.Admin.ToString(); entity.ModifiedDate = DateTime.Now; await _collection.ReplaceOneAsync(e => e.Id == entity.Id, entity); return(entity); } return(null); }
private void PublishFormularyLocationRequest(TransactionQueueModel transactionQueue, Dictionary <string, string> headers) { var eventMessage = new FormularyLocationRequestEvent { TransactionQueueId = transactionQueue.TransactionQueueId, FormularyId = transactionQueue.FormularyId, FacilityId = transactionQueue.FacilityId, ISAId = transactionQueue.IsaId, Headers = headers }; _eventBus.Publish(_configuration.KafkaFormularyLocationRequestTopic, eventMessage, eventMessage.Headers); _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.DataPublishedForFormularyLocation, JsonConvert.SerializeObject(eventMessage))); }
private void SetPatientInfo(TransactionQueueModel tranQNew, TransactionRequest request) { var item = request.Patient; if (!string.IsNullOrEmpty(item.LastName)) { tranQNew.PatientName = item.LastName; } if (!string.IsNullOrEmpty(item.FirstName)) { tranQNew.PatientName += ", " + item.FirstName.Trim(); } if (!string.IsNullOrEmpty(item.MiddleName)) { tranQNew.PatientName += " " + item.MiddleName.Trim(); } if (!string.IsNullOrEmpty(item.AccountNumber)) { tranQNew.PatientAcctNumber = item.AccountNumber.Trim(); } if (!string.IsNullOrEmpty(item.Mrn)) { tranQNew.Mrn = item.Mrn.Trim(); } if (!string.IsNullOrEmpty(request.ADM?.StationName)) { tranQNew.PatientStation = request.ADM.StationName.Trim(); } if (!string.IsNullOrEmpty(item.Room)) { tranQNew.PatientRoom = item.Room.Trim(); } if (!string.IsNullOrEmpty(item.Bed)) { tranQNew.PatientBed = item.Bed.Trim(); } if (!string.IsNullOrEmpty(request.Order?.OrderingDrInstructions)) { tranQNew.Comments = request.Order.OrderingDrInstructions.Trim(); } }
private void PublishDeviceCommunicationRequest(TransactionQueueModel transactionQueue, Dictionary <string, string> headers) { var eventMessage = new ProcessTransactionQueueIntegrationEvent() { TransactionData = new TransactionData { Quantity = transactionQueue.Quantity.Value, Type = transactionQueue.Type, Devices = transactionQueue.Devices.ToList() }, Headers = headers }; _eventBus.Publish(_configuration.KafkaDeviceTopic, eventMessage, headers); _logger.LogInformation(string.Format(Constants.LoggingMessage.DataPublishedDeviceCommunication, JsonConvert.SerializeObject(eventMessage))); }
/// <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 async Task <Tuple <bool, bool> > EligibleforAduDupDelete(TransactionQueueModel transactionQueueModel, ExternalDependencies.BusinessLayer.Models.Facility facility, TransactionRequest request) { var lastAduXrefs = await _lastAduXrefRepository.GetAllLastAduXrefTransactions(); LastAduXref lastAduXref = lastAduXrefs?.FirstOrDefault(la => la.FacilityId == facility.Id && la.FormularyId == transactionQueueModel.FormularyId && la.Destination == request?.Patient?.DeliverToLocation); var transactions = await _transactionQueueRepository.GetAllTransactions(); var AduItemAlreadyinQueue = transactions?.FirstOrDefault(tqa => tqa.FacilityId == facility.Id && tqa.FormularyId == transactionQueueModel.FormularyId && tqa.Destination == request?.Patient?.DeliverToLocation && (tqa.Status == TransactionStatus.Pending.ToString() || tqa.Status == TransactionStatus.Hold.ToString())); bool eligibleforAduDupCheck = ((lastAduXref != null && lastAduXref.LastAduTransUtcDateTime != null) || (AduItemAlreadyinQueue != null && AduItemAlreadyinQueue.ReceivedUtcDateTime != null)) && facility.AduDupeTimeDelay != null && facility.AduDupeTimeDelay > 0; if (eligibleforAduDupCheck) { bool eligibleforAduDupDelete = (lastAduXref != null && ((DateTime)lastAduXref.LastAduTransUtcDateTime).AddMinutes((int)facility.AduDupeTimeDelay) > DateTime.UtcNow) || (AduItemAlreadyinQueue != null && ((DateTime)AduItemAlreadyinQueue.ReceivedUtcDateTime).AddMinutes((int)facility.AduDupeTimeDelay) > DateTime.UtcNow); if (eligibleforAduDupDelete) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessedAdmTransaction, request.RequestId)); //Not updated any existing txn and current txn should be ignored return(new Tuple <bool, bool>(true, false)); } } //Normal processing //Not updated any existing txn and current txn should also not be ignored return(new Tuple <bool, bool>(false, false)); }
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)); } }
private async Task <Tuple <bool, bool> > UpdateQuantityFromReplenishmentOrder(int quantity, TransactionQueueModel tranQClSo) { var priority = await _transactionPriorityManager.GetTransactionPriority(tranQClSo.TranPriorityId); if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISCRITLOW.ToString())) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.UpdatedQuantityForReplenishmentOrder, quantity, tranQClSo.TransactionQueueId)); tranQClSo.Quantity = quantity; tranQClSo.QuantityProcessed = quantity; tranQClSo.StatusChangeDT = DateTime.Now; tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow; await _transactionQueueRepository.UpdateTransaction(tranQClSo); //Updated one existing txn return(new Tuple <bool, bool>(true, true)); } else { //Not updated any existing txn and current txn should be ignored return(new Tuple <bool, bool>(true, false)); } }
/// <summary> /// This method processes the aggregated incoming request from Aggregator Service, applies business rules and inserts transaction record. /// </summary> /// <param name="request">Incoming request</param> /// <param name="headers">Headers</param> public async Task ProcessTransactionRequest(TransactionRequest request, Dictionary <string, string> headers) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessIncomingRequest, JsonConvert.SerializeObject(request))); var status = TransactionStatus.Interim; var facilityId = request.Facility.FacilityId; FacilityStorageSpace storageSpaceInfo = null; var priority = await _transactionPriorityManager.ValidatePriority(request.Facility.FacilityId, request.Priority); var facility = await _facilityManager.ValidateFacility(facilityId); var destination = await _destinationManager.GetDestinationByCode(request?.Patient?.DeliverToLocation); if (facility != null) { if ((facility.AduIgnoreCritLow == true && string.Equals(request.Priority, Priority.PYXISCRITLOW.ToString(), StringComparison.OrdinalIgnoreCase)) || (facility.AduIgnoreStockout == true && (string.Equals(request.Priority, Priority.PYXISSTOCKOUT.ToString(), StringComparison.OrdinalIgnoreCase) || string.Equals(request.Priority, Priority.PYXISSTKOUT.ToString(), StringComparison.OrdinalIgnoreCase)))) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.RejectedRequest, request.RequestId)); status = TransactionStatus.Ignored; } storageSpaceInfo = facility.StorageSpaces?.Where(x => x.IsDefault).FirstOrDefault(); } var partNo = 0; var multiMedName = string.Empty; var transactionList = new List <TransactionQueueModel>(); var orderCount = Enumerable.Count <Item>(request.Items); var isMultiComponent = orderCount > 1 ? true : false; foreach (var item in request.Items) { FacilityFormulary facilityFormulary = null; var formulary = await _formularyManager.GetFormularyByItemId(item.ItemId); if (formulary != null && formulary.FacilityFormulary != null && formulary.FacilityFormulary.FacilityId == facilityId) { facilityFormulary = formulary.FacilityFormulary; } if (facility != null && facilityFormulary != null && ((string.Equals(request.Priority, Priority.PYXISCRITLOW.ToString(), StringComparison.OrdinalIgnoreCase) && facilityFormulary.AduIgnoreCritLow != null && (bool)facilityFormulary.AduIgnoreCritLow) || ((string.Equals(request.Priority, Priority.PYXISSTOCKOUT.ToString(), StringComparison.OrdinalIgnoreCase) || string.Equals(request.Priority, Priority.PYXISSTKOUT.ToString(), StringComparison.OrdinalIgnoreCase)) && facilityFormulary.AduIgnoreStockout != null && (bool)facilityFormulary.AduIgnoreStockout))) { status = TransactionStatus.Ignored; } //Checks for ADUIgnoreCritLow and ADUIgnoreStockOut prior to ADU Cases if (priority != null && destination != null && ((priority.TransactionPriorityCode.ToLower() == Priority.PYXISCRITLOW.ToString().ToLower() && destination.AduIgnoreCritLow.GetValueOrDefault()) || ((priority.TransactionPriorityCode.ToLower() == Priority.PYXISSTOCKOUT.ToString().ToLower() || priority.TransactionPriorityCode.ToLower() == Priority.PYXISSTKOUT.ToString().ToLower()) && destination.AduIgnoreStockOut.GetValueOrDefault()))) { status = TransactionStatus.Ignored; } int.TryParse(item.OrderAmount, out int quantity); var newTransaction = new TransactionQueueModel(); if (status != TransactionStatus.Ignored) { var isExceptionTransaction = SetExceptionTransaction(facility, formulary, facilityFormulary, storageSpaceInfo, request, item, quantity, newTransaction); if (!isExceptionTransaction) { SetValidTransaction(storageSpaceInfo.Id, newTransaction, status); } } partNo += 1; SetTransactionDetails(priority, formulary, facility, facilityFormulary, destination, request, item, partNo, orderCount, newTransaction, quantity); //ADU Processing variables Tuple <bool, bool> admResult = default(Tuple <bool, bool>); bool isIgnoredTxn = false, isPartialUpdated = false; if (newTransaction.Status != TransactionStatus.Exception && status != TransactionStatus.Ignored && priority.IsAdu.GetValueOrDefault(false)) { admResult = await _aduTransactionManager.ProcessAduTransaction(request, newTransaction, item, priority, facility); isIgnoredTxn = admResult.Item1; isPartialUpdated = admResult.Item2; //Logging for ADU Processing if (isIgnoredTxn) { _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessedAdmTransaction, request.RequestId)); } } ConfigureTimeToLive(priority, newTransaction); if (status != TransactionStatus.Ignored && !isIgnoredTxn && !isPartialUpdated) { newTransaction.TransactionQueueId = await _transactionQueueRepository.CreateTransaction(newTransaction); _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.TransactionCreated, newTransaction.TransactionQueueId, newTransaction.IncomingRequestId)); if (newTransaction.Status == TransactionStatus.Interim) { PublishFormularyLocationRequest(newTransaction, headers); } } else if (!isPartialUpdated) { newTransaction.Status = TransactionStatus.Ignored; newTransaction.TransactionQueueId = await _transactionQueueHistoryRepository.CreateTransaction(newTransaction); _logger.LogInformation(string.Format(CommonConstants.LoggingMessage.IgnoredTransactionCreated, newTransaction.TransactionQueueId, newTransaction.IncomingRequestId)); } } }
private void SetValidTransaction(int isaId, TransactionQueueModel newTransaction, TransactionStatus status) { newTransaction.IsaId = isaId; newTransaction.Status = status; }
private bool SetExceptionTransaction(Facility facility, Formulary formulary, FacilityFormulary facilityFormulary, FacilityStorageSpace storageSpaceInfo, TransactionRequest request, Item item, int quantity, TransactionQueueModel newTransaction) { var isItemAccepted = (facilityFormulary != null && facilityFormulary.Approved) ? true : false; var isActiveFormulary = (formulary != null && !formulary.IsActive.GetValueOrDefault()) ? false : true; if (formulary == null) { newTransaction.Description = item.ItemName; SetTransactionException(newTransaction, CommonConstants.TransactionException.UnknownItemId); if (!int.TryParse(item.OrderAmount.Trim(), out quantity)) { newTransaction.Exception += Environment.NewLine + CommonConstants.TransactionException.InvalidQuantity; } newTransaction.Quantity = quantity; return(true); } if (!isActiveFormulary) { SetTransactionException(newTransaction, CommonConstants.TransactionException.InactiveFormularyItem); return(true); } if (facilityFormulary == null) { SetTransactionException(newTransaction, CommonConstants.TransactionException.FormularyNotMapped); return(true); } if (!isItemAccepted) { SetTransactionException(newTransaction, CommonConstants.TransactionException.NotApprovedFormularyItem); return(true); } if (quantity <= 0) { SetTransactionException(newTransaction, CommonConstants.TransactionException.InvalidUnitQuantity); return(true); } if (storageSpaceInfo == null) { SetTransactionException(newTransaction, CommonConstants.TransactionException.UnassignedLocation); return(true); } return(false); }
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(); } }
private void SetTransactionException(TransactionQueueModel request, string exceptionMessage) { _logger.LogInformation(exceptionMessage); request.Status = TransactionStatus.Exception; request.Exception = exceptionMessage; }
/// <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 <TransactionQueueModel> UpdateTransactionStatusWhenStatusIsComplete(TransactionQueueModel transaction, TransactionStatus status, Dictionary <string, string> headers) { if (transaction.Status == TransactionStatus.Active) { var transactionQueueModel = _mapper.Map <TransactionQueueModel>(await _transactionQueueMongoRepository.UpdateTransactionStatus(transaction.TransactionQueueId, status)); PublishDeviceCommunicationRequest(transactionQueueModel, headers); return(transaction); } else if (transaction.Status == TransactionStatus.Complete) { return(transaction); } return(null); }