public IFluentPackingSlipDetail CreatePackingSlipDetailsByView(PackingSlipView view)
        {
            try
            {
                Task <PackingSlip> packingSlipTask = Task.Run(async() => await unitOfWork.packingSlipRepository.GetEntityBySlipDocument(view.SlipDocument));
                if (packingSlipTask.Result != null)
                {
                    long packingSlipId = view.PackingSlipId;

                    //TODO - send a list of ids and return back the views
                    foreach (var detailView in view.PackingSlipDetailViews)
                    {
                        detailView.PackingSlipId = packingSlipId;

                        PackingSlipDetail newDetail = new PackingSlipDetail();


                        newDetail = MapToEntity(detailView);

                        Task <IList <PackingSlipDetail> > listTask = Task.Run(async() => await unitOfWork.packingSlipDetailRepository.FindByExpression(e => e.ItemId == detailView.ItemId && e.PackingSlipId == newDetail.PackingSlipId));
                        Task.WaitAll(listTask);

                        if (listTask.Result == null)
                        {
                            //_dbContext.Set<PackingSlipDetail>().Add(newDetail);
                            AddPackingSlipDetail(newDetail);
                            return(this as IFluentPackingSlipDetail);
                        }
                    }
                }
                processStatus = CreateProcessStatus.AlreadyExists;
                return(this as IFluentPackingSlipDetail);
            }
            catch (Exception ex) { throw new Exception("CreatePackingSlipDetailsByView", ex); }
        }
Beispiel #2
0
        private async Task <PackingSlipDetailView> MapToPackingSlipDetailView(PackingSlipDetail inputObject)
        {
            PackingSlipDetailView outObject = mapper.Map <PackingSlipDetailView>(inputObject);
            await Task.Yield();

            return(outObject);
        }
        public async Task <CreateProcessStatus> CreatePackingSlipDetailsByView(PackingSlipView view)
        {
            try
            {
                PackingSlip packingSlip = await(from e in _dbContext.PackingSlips
                                                where e.SlipDocument == view.SlipDocument
                                                select e).FirstOrDefaultAsync <PackingSlip>();

                if (packingSlip != null)
                {
                    long packingSlipId = packingSlip.PackingSlipId;

                    foreach (var detail in view.PackingSlipDetailViews)
                    {
                        detail.PackingSlipId = packingSlipId;

                        PackingSlipDetail newDetail = new PackingSlipDetail();
                        applicationViewFactory.MapPackingSlipDetailEntity(ref newDetail, detail);

                        var queryDetail = await(from e in _dbContext.PackingSlipDetails
                                                where e.ItemId == detail.ItemId &&
                                                e.PackingSlipId == newDetail.PackingSlipId
                                                select e).FirstOrDefaultAsync <PackingSlipDetail>();
                        if (queryDetail == null)
                        {
                            _dbContext.Set <PackingSlipDetail>().Add(newDetail);
                        }
                    }
                    return(CreateProcessStatus.Insert);
                }
                return(CreateProcessStatus.AlreadyExists);
            }
            catch (Exception ex) { throw new Exception(GetMyMethodName(), ex); }
        }
        private PackingSlipDetail MapToEntity(PackingSlipDetailView inputObject)
        {
            Mapper            mapper    = new Mapper();
            PackingSlipDetail outObject = mapper.Map <PackingSlipDetail>(inputObject);

            return(outObject);
        }
        public async Task <IActionResult> DeletePackingSlipDetail([FromBody] PackingSlipDetailView view)
        {
            PackingSlipDetailModule invMod            = new PackingSlipDetailModule();
            PackingSlipDetail       packingSlipDetail = await invMod.PackingSlipDetail.Query().MapToEntity(view);

            invMod.PackingSlipDetail.DeletePackingSlipDetail(packingSlipDetail).Apply();

            return(Ok(view));
        }
 public PackingSlipDetailView(PackingSlipDetail detail)
 {
     this.PackingSlipDetailId = detail.PackingSlipDetailId;
     this.PackingSlipId       = detail.PackingSlipId;
     this.ItemId        = detail.ItemId;
     this.Quantity      = detail.Quantity;
     this.UnitPrice     = detail.UnitPrice;
     this.ExtendedCost  = detail.ExtendedCost;
     this.UnitOfMeasure = detail.UnitOfMeasure;
     this.Description   = detail.Description;
 }
        public async Task <IActionResult> UpdatePackingSlipDetail([FromBody] PackingSlipDetailView view)
        {
            PackingSlipDetailModule invMod = new PackingSlipDetailModule();

            PackingSlipDetail packingSlipDetail = await invMod.PackingSlipDetail.Query().MapToEntity(view);


            invMod.PackingSlipDetail.UpdatePackingSlipDetail(packingSlipDetail).Apply();

            PackingSlipDetailView retView = await invMod.PackingSlipDetail.Query().GetViewById(packingSlipDetail.PackingSlipDetailId);


            return(Ok(retView));
        }
        public async Task <IActionResult> AddPackingSlipDetail([FromBody] PackingSlipDetailView view)
        {
            PackingSlipDetailModule invMod = new PackingSlipDetailModule();

            NextNumber nnPackingSlipDetail = await invMod.PackingSlipDetail.Query().GetNextNumber();

            view.PackingSlipDetailNumber = nnPackingSlipDetail.NextNumberValue;

            PackingSlipDetail packingSlipDetail = await invMod.PackingSlipDetail.Query().MapToEntity(view);

            invMod.PackingSlipDetail.AddPackingSlipDetail(packingSlipDetail).Apply();

            PackingSlipDetailView newView = await invMod.PackingSlipDetail.Query().GetViewByNumber(view.PackingSlipDetailNumber);


            return(Ok(newView));
        }
        public async Task TestAddUpdatDelete()
        {
            PackingSlipDetailModule PackingSlipDetailMod = new PackingSlipDetailModule();

            PackingSlip packingSlip = await PackingSlipDetailMod.PackingSlip.Query().GetEntityById(9);

            ItemMaster itemMaster = await PackingSlipDetailMod.ItemMaster.Query().GetEntityById(5);

            PackingSlipDetailView view = new PackingSlipDetailView()
            {
                PackingSlipId   = packingSlip.PackingSlipId,
                ItemId          = itemMaster.ItemId,
                ItemCode        = itemMaster.ItemCode,
                ItemDescription = itemMaster.Description,
                Branch          = itemMaster.Branch,
                Quantity        = 5,
                UnitPrice       = 10M,
                ExtendedCost    = 50M,
                UnitOfMeasure   = "Each",
                Description     = "Packing Slip Description"
            };
            NextNumber nnNextNumber = await PackingSlipDetailMod.PackingSlipDetail.Query().GetNextNumber();

            view.PackingSlipDetailNumber = nnNextNumber.NextNumberValue;

            PackingSlipDetail packingSlipDetail = await PackingSlipDetailMod.PackingSlipDetail.Query().MapToEntity(view);

            PackingSlipDetailMod.PackingSlipDetail.AddPackingSlipDetail(packingSlipDetail).Apply();

            PackingSlipDetail newPackingSlipDetial = await PackingSlipDetailMod.PackingSlipDetail.Query().GetEntityByNumber(view.PackingSlipDetailNumber);

            Assert.NotNull(newPackingSlipDetial);

            newPackingSlipDetial.Description = "Packing Slip Description Update";

            PackingSlipDetailMod.PackingSlipDetail.UpdatePackingSlipDetail(newPackingSlipDetial).Apply();

            PackingSlipDetailView updateView = await PackingSlipDetailMod.PackingSlipDetail.Query().GetViewById(newPackingSlipDetial.PackingSlipDetailId);

            Assert.Same(updateView.Description, "Packing Slip Description Update");
            PackingSlipDetailMod.PackingSlipDetail.DeletePackingSlipDetail(newPackingSlipDetial).Apply();
            PackingSlipDetail lookupPackingSlipDetial = await PackingSlipDetailMod.PackingSlipDetail.Query().GetEntityById(view.PackingSlipDetailId);

            Assert.Null(lookupPackingSlipDetial);
        }
 public IFluentPackingSlipDetail DeletePackingSlipDetail(PackingSlipDetail deleteObject)
 {
     unitOfWork.packingSlipDetailRepository.DeleteObject(deleteObject);
     this.processStatus = CreateProcessStatus.Delete;
     return(this as IFluentPackingSlipDetail);
 }
 public IFluentPackingSlipDetail AddPackingSlipDetail(PackingSlipDetail newObject)
 {
     unitOfWork.packingSlipDetailRepository.AddObject(newObject);
     this.processStatus = CreateProcessStatus.Insert;
     return(this as IFluentPackingSlipDetail);
 }