public HttpResponseMessage SaveReleases([FromBody] RequestRelease request)
        {
            var clients = request.Clients;

            updateCLientReleases(clients);
            return(Request.CreateResponse(HttpStatusCode.OK));
        }
        public HttpResponseMessage removeMFR([FromBody] RequestRelease request)
        {
            var mfrs    = request.Mfrs;
            var clients = request.Clients;

            DeleteMfrAllocation(mfrs, clients);
            return(Request.CreateResponse(HttpStatusCode.NoContent));
        }
        public HttpResponseMessage removePackException([FromBody] RequestRelease request)
        {
            var Packs   = request.Packs;
            var clients = request.Clients;

            DeletePackAllocation(Packs, clients);
            return(Request.CreateResponse(HttpStatusCode.NoContent));
        }
        public async Task <HttpResponseMessage> AllocateReleases([FromBody] RequestRelease request)
        {
            var clients = request.Clients;
            var mfrs    = request.Mfrs;

            AllocateMfrs(clients, mfrs);

            var packs = request.Packs;

            if (packs.Count() > 0)
            {
                List <ReleasePack> packsByProduct = new List <ReleasePack>();
                var productLevelProducts          = packs.Where(p => p.ProductLevel).ToList();

                var tempPacks = packs.Where(p => !p.ProductLevel).ToList();

                if (productLevelProducts.Count() > 0)
                {
                    //Get Packs By ProductName
                    var response = await releaseProvider.GetPacksByProduct(productLevelProducts, 1, 1000);

                    var packsResult = response?.Data;

                    if (packsResult != null)
                    {
                        packsByProduct = packsResult;
                    }

                    //update product level for packs
                    foreach (var p in packsByProduct)
                    {
                        p.ProductLevel = true;
                        //var updateProductLevelPack = packsByProduct.FirstOrDefault(x => x.Id == p.Id);
                        //  if (updateProductLevelPack != null)
                        //  {
                        //      updateProductLevelPack.ProductLevel = p.ProductLevel;
                        //  }
                    }
                }

                if (tempPacks.Count > 0)
                {
                    packsByProduct.AddRange(tempPacks);
                }

                AllocatePacks(clients, packsByProduct);
            }
            updateCLientReleases(clients);
            return(Request.CreateResponse(HttpStatusCode.OK));
        }
        public async Task <HttpResponseMessage> SaveExpiryDates([FromBody] RequestRelease request)
        {
            var client = request.Client;
            var packs  = request.Packs;

            using (var context = new EverestPortalContext())
            {
                foreach (var pack in packs)
                {
                    if (pack.ProductLevel)
                    {
                        var eDate = Convert.ToDateTime(pack.ExpiryDate);
                        //var packByPRoducts = await releaseProvider.GetPacksByProduct(new List<ReleasePack> { pack });
                        var response = await releaseProvider.GetPacksByProduct(new List <ReleasePack> {
                            pack
                        }, 1, 1000);

                        var packByPRoducts = response?.Data;

                        foreach (var aPack in packByPRoducts)
                        {
                            var updateClientException = context.ClientPackException.FirstOrDefault(x => x.ClientId == client.clientId && x.PackExceptionId == aPack.Id);
                            if (updateClientException != null)
                            {
                                updateClientException.ExpiryDate = eDate;
                            }
                            else
                            {
                                context.ClientPackException.Add(new ClientPackException {
                                    ClientId        = client.clientId,
                                    PackExceptionId = pack.Id,
                                    ProductLevel    = pack.ProductLevel,
                                    ExpiryDate      = eDate
                                });
                            }
                        }
                    }
                    else
                    {
                        UpdateExpiryDatePack(context, pack, client);
                    }

                    context.SaveChanges();
                }
                ;
            }

            return(Request.CreateResponse(HttpStatusCode.OK));
        }
        public async Task <HttpResponseMessage> SaveAllMfrSearchItems([FromBody] RequestRelease request)
        {
            var clients = request.Clients;
            HttpResponseMessage message;
            var        description = request.Description.ToUpper().Trim();
            List <int> MFRsID      = new List <int>();
            var        result      = await releaseProvider.GetManufacturer(1, 200, description);

            MFRsID = result?.Data?.Select(x => x.Org_Code).ToList();

            AllocateMfrs(clients, MFRsID);

            message = Request.CreateResponse(HttpStatusCode.OK);
            return(message);
        }
        public async Task <HttpResponseMessage> SaveAllPackSearchItems([FromBody] RequestRelease request)
        {
            HttpResponseMessage message;
            var clients     = request.Clients;
            var description = request.Description.ToUpper().Trim();

            List <ReleasePack> packs = new List <ReleasePack>();
            var result = await releaseProvider.GetPackDescription(1, 200, description);

            packs = result?.Data;

            AllocatePacks(clients, packs);

            message = Request.CreateResponse(HttpStatusCode.OK);
            return(message);
        }
        public async Task <HttpResponseMessage> GetPackExceptions([FromBody] RequestRelease request)
        {
            HttpResponseMessage message;
            var query       = string.Empty;
            var rows        = request.Pagination.NoOfItems;
            var cPage       = request.Pagination.CurrentPage;
            var start       = (cPage - 1) * rows;
            var description = request.Description.ToUpper().Trim();

            var result = await releaseProvider.GetPackDescription(cPage, rows, description);

            var response = new
            {
                data        = result?.Data,
                resultCount = result?.TotalCount
            };

            message = Request.CreateResponse(HttpStatusCode.OK, response);
            return(message);
        }