public async Task <IHttpActionResult> CreateCardDelivery(CardDelivery entity)
        {
            userId = User.Identity.GetUserId();

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var newEntity = entity;

            context.CardDelivery.Add(newEntity);
            await context.SaveChangesAsync();

            return(Ok <CardDelivery>(newEntity));
        }
        public CardDeliveryRegRespObj AddCardDelivery(RegCardDeliveryObj regObj)
        {
            var response = new CardDeliveryRegRespObj
            {
                Status = new APIResponseStatus
                {
                    IsSuccessful = false,
                    Message      = new APIResponseMessage()
                }
            };

            try
            {
                if (regObj.Equals(null))
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! Unable to proceed with your request";
                    response.Status.Message.TechnicalMessage = "Registration Object is empty / invalid";
                    return(response);
                }

                if (!EntityValidatorHelper.Validate(regObj, out var valResults))
                {
                    var errorDetail = new StringBuilder();
                    if (!valResults.IsNullOrEmpty())
                    {
                        errorDetail.AppendLine("Following error occurred:");
                        valResults.ForEachx(m => errorDetail.AppendLine(m.ErrorMessage));
                    }
                    else
                    {
                        errorDetail.AppendLine("Validation error occurred! Please check all supplied parameters and try again");
                    }
                    response.Status.Message.FriendlyMessage  = errorDetail.ToString();
                    response.Status.Message.TechnicalMessage = errorDetail.ToString();
                    response.Status.IsSuccessful             = false;
                    return(response);
                }

                if (!HelperMethods.IsUserValid(regObj.AdminUserId, regObj.SysPathCode, HelperMethods.getRequesterRoles(), ref response.Status.Message))
                {
                    return(response);
                }

                var associatedCard = GetCardInfo(regObj.CardId);
                if (associatedCard == null)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! No Card  Information Found";
                    response.Status.Message.TechnicalMessage = "Error Occurred! No Card  Information Found";
                    return(response);
                }

                var associatedCardItem = GetCardItemInfo(regObj.CardItemId);
                if (associatedCardItem == null)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! No Card Item  Information Found";
                    response.Status.Message.TechnicalMessage = "Error Occurred! No Card Item Information Found";
                    return(response);
                }

                if (associatedCard.Status != CardStatus.Registered)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! This Card Item Is Not Available For Delivery";
                    response.Status.Message.TechnicalMessage = "Error Occurred! This Card Item Is Not Available For Delivery";
                    return(response);
                }

                //check validity of start/stop batch number

                if ((int.Parse(regObj.StopBatchNumber) - int.Parse(regObj.StartBatchNumber) + 1) !=
                    associatedCard.QuantityPerBatch)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! Incorrect StopBatchNumber/StartBatchNumber Data";
                    response.Status.Message.TechnicalMessage = "Error Occurred! Incorrect StopBatchNumber/StartBatchNumber Data";
                    return(response);
                }

                if (regObj.BatchId != associatedCardItem.BatchId)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! Incorrect BatchId";
                    response.Status.Message.TechnicalMessage = "Error Occurred! Incorrect BatchId";
                    return(response);
                }
                if (regObj.DeliveredQuantity < 1)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! You Cannot Register An empty delivery ";
                    response.Status.Message.TechnicalMessage = "Error Occurred! Incorrect quantity Delivered Data";
                    return(response);
                }

                if (regObj.DeliveredQuantity + associatedCardItem.DeliveredQuantity > associatedCardItem.BatchQuantity)
                {
                    if (associatedCardItem.BatchQuantity - (associatedCardItem.DeliveredQuantity) > 0)
                    {
                        response.Status.Message.FriendlyMessage = $"Incorrect Quantity Delivered,{associatedCardItem.BatchQuantity - (associatedCardItem.DeliveredQuantity)} is only available for delivery";
                    }
                    else if (associatedCardItem.BatchQuantity - (associatedCardItem.DeliveredQuantity) == 0)
                    {
                        response.Status.Message.FriendlyMessage = $"This Delivery is Complete";
                    }

                    response.Status.Message.TechnicalMessage = "Error Occurred! Incorrect Quantity Delivered";
                    return(response);
                }

                if (DateTime.Parse(regObj.TimeStampDelivered) > DateTime.Now)
                {
                    response.Status.Message.FriendlyMessage  = "Error Occurred! You Cannot Register A delivery before DeliveryDate";
                    response.Status.Message.TechnicalMessage = "Error Occurred! Incorrect Delivery Date Data";
                    return(response);
                }

                using (var db = _uoWork.BeginTransaction())
                {
                    var newCardDelivery = new CardDelivery
                    {
                        CardId             = regObj.CardId,
                        CardItemId         = regObj.CardItemId,
                        CardTypeId         = regObj.CardTypeId,
                        BatchId            = associatedCardItem.BatchId,
                        Status             = CardStatus.Registered,
                        ApprovedBy         = 0,
                        ApproverComment    = regObj.ApproverComment,
                        TimeStampApproved  = "",
                        DefectiveQuantity  = regObj.DefectiveQuantity,
                        TimeStampDelivered = regObj.TimeStampDelivered,
                        MissingQuantity    = regObj.MissingQuantity,
                        DeliveredQuantity  = regObj.DeliveredQuantity,
                        StartBatchNumber   = associatedCardItem.BatchId + "" + "000",
                        StopBatchNumber    = associatedCardItem.BatchId + "" + "999",
                        ReceivedBy         = regObj.AdminUserId,
                        TimeStampRegisered = DateMap.CurrentTimeStamp(),
                    };

                    var deliveryAdded = _repository.Add(newCardDelivery);
                    _uoWork.SaveChanges();
                    if (deliveryAdded.CardDeliveryId < 1)
                    {
                        db.Rollback();
                        response.Status.Message.FriendlyMessage  = "Error Occurred! Unable to complete your request. Please try again later";
                        response.Status.Message.TechnicalMessage = "Unable to save to database";
                        return(response);
                    }
                    associatedCardItem.MissingQuantity     += regObj.MissingQuantity;
                    associatedCardItem.DefectiveQuantity   += regObj.DefectiveQuantity;
                    associatedCardItem.DeliveredQuantity   += regObj.DeliveredQuantity;
                    associatedCardItem.AvailableQuantity   += regObj.DeliveredQuantity - (regObj.MissingQuantity + regObj.DefectiveQuantity);
                    associatedCardItem.TimeStampDelivered   = deliveryAdded.TimeStampRegisered;
                    associatedCardItem.DefectiveBatchNumber = regObj.DefectiveBatchNumber;
                    associatedCardItem.Status = CardStatus.Registered;

                    var updateCardItem = _cardItemRepository.Update(associatedCardItem);
                    _uoWork.SaveChanges();
                    if (updateCardItem.CardItemId < 1)
                    {
                        db.Rollback();
                        response.Status.Message.FriendlyMessage  = "Error Occurred! Unable to complete your request. Please try again later";
                        response.Status.Message.TechnicalMessage = "Unable to save to database";
                        return(response);
                    }


                    associatedCard.Status = CardStatus.Registered;
                    var updateCard = _cardRepository.Update(associatedCard);
                    _uoWork.SaveChanges();
                    if (updateCard.CardId < 1)
                    {
                        db.Rollback();
                        response.Status.Message.FriendlyMessage  = "Error Occurred! Unable to complete your request. Please try again later";
                        response.Status.Message.TechnicalMessage = "Unable to save to database";
                        return(response);
                    }
                    db.Commit();

                    response.Status.IsSuccessful            = true;
                    response.CardDeliveryId                 = deliveryAdded.CardDeliveryId;
                    response.Status.Message.FriendlyMessage = "Card Delivery Added Successfully";
                }
            }
            catch (DbEntityValidationException ex)
            {
                ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
                response.Status.Message.FriendlyMessage  = "Error Occurred! Please try again later";
                response.Status.Message.TechnicalMessage = "Error: " + ex.GetBaseException().Message;
                response.Status.IsSuccessful             = false;
                return(response);
            }
            catch (Exception ex)
            {
                ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
                response.Status.Message.FriendlyMessage  = "Error Occurred! Please try again later";
                response.Status.Message.TechnicalMessage = "Error: " + ex.GetBaseException().Message;
                response.Status.IsSuccessful             = false;
                return(response);
            }

            return(response);
        }
Ejemplo n.º 3
0
        public async Task <IHttpActionResult> CreateCardDelivery(CardDelivery entity)
        {
            string userId = User.Identity.GetUserId();

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            JobTracker jobTracker = await context.JobTrackers.FindAsync(entity.JobTrackerId);

            Job job = await context.Jobs.FindAsync(jobTracker.JobId);

            var depart = _repo.FindDepartmentByName("Quality Control");

            var jobStatusWIP         = _repo.FindJobStatusByName("WIP");
            var jobStatusCompleted   = _repo.FindJobStatusByName("Completed");
            var jobStatusQueue       = _repo.FindJobStatusByName("Queue");
            var jobStatusNotRequired = _repo.FindJobStatusByName("Not Required");

            var jobTypePersoOnly               = _repo.FindJobTypeByName("Perso Only");
            var jobTypePrintingOnly            = _repo.FindJobTypeByName("Printing Only");
            var jobTypePrintingAndPerso        = _repo.FindJobTypeByName("Printing And Perso");
            var jobTypePrintingPersoAndMailing = _repo.FindJobTypeByName("Printing, Perso And Mailing");
            var jobTypePersoAndMailing         = _repo.FindJobTypeByName("Perso And Mailing");
            var serviceType = job.ServiceTypeId;

            //Todo: Redundant code section
            #region JobTrackerUpdateFlow

            int departmentId = 0;
            var dipatchUnit  = _repo.FindDepartmentByName("Dispatch");
            var mailingUnit  = _repo.FindDepartmentByName("Mailing");

            if (serviceType == jobTypePersoOnly.Id)
            {
                departmentId = dipatchUnit.Id;
            }
            else if (serviceType == jobTypePrintingOnly.Id)
            {
                departmentId = dipatchUnit.Id;
            }
            else if (serviceType == jobTypePrintingAndPerso.Id)
            {
                departmentId = dipatchUnit.Id;
            }
            else if (serviceType == jobTypePersoAndMailing.Id)
            {
                departmentId = mailingUnit.Id;
            }
            else if (serviceType == jobTypePrintingPersoAndMailing.Id)
            {
                departmentId = mailingUnit.Id;
            }

            #endregion

            //1. Create the Appproval
            var newEntity = new CardDelivery()
            {
                JobTrackerId       = entity.JobTrackerId,
                DepartmentId       = depart.Id,
                DeliveredById      = userId,
                ConfirmedById      = userId,
                DeliveredOn        = DateTime.Now,
                ConfirmedOn        = DateTime.Now,
                TargetDepartmentId = departmentId
            };

            context.CardDelivery.Add(newEntity);
            await context.SaveChangesAsync();

            return(Ok <CardDelivery>(entity));
        }