// Actions

        /// <summary>
        /// Select items
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public JsonResult SelectTmcItem(TmcViewModel model)
        {
            ApplicationPoaRepository poaRepo = new ApplicationPoaRepository(false);
            //if (model.IsSelected)
            //{
            //    poaRepo.AddLimsTmcTemp(new LimsTmcTemp()
            //    {
            //        TmcId = model.Id.Value,
            //        TmcInId = model.TmcInId.Value,
            //        CreatedDate = DateTime.Now
            //    });
            //}
            //else
            //{
            //    poaRepo.DeleteLimsTmcTemp(new LimsTmcTemp()
            //    {
            //        TmcId = model.Id.Value,
            //        TmcInId = model.TmcInId.Value
            //    });
            //}
            var limsTmcTemp = poaRepo.GetLimsTmcTemps(ltt => ltt.TmcId == model.Id.Value && ltt.TmcInId == model.TmcInId.Value)
                              .FirstOrDefault();

            if (limsTmcTemp != null)
            {
                limsTmcTemp.IsSelected = model.IsSelected;
                poaRepo.UpdateLimsTmcTemp(limsTmcTemp);
                poaRepo.Save();
            }

            return(Json(new { IsSuccess = true }, JsonRequestBehavior.AllowGet));
        }
        public ActionResult CreateTmc([DataSourceRequest] DataSourceRequest request, TmcViewModel model)
        {
            TmcRepository repo = new TmcRepository(false);

            Tmc tmc = new Tmc()
            {
                Id                      = Guid.NewGuid(),
                StateType               = model.StateType,
                Name                    = model.Name,
                Code                    = model.Code,
                CreatedDate             = DateTime.Now,
                CreatedEmployeeId       = UserHelper.GetCurrentEmployee().Id,
                Count                   = model.Count,
                CountActual             = model.CountActual,
                OwnerEmployeeId         = model.OwnerEmployeeId,
                Number                  = model.Number,
                CountFact               = model.CountFact,
                CountConvert            = model.CountFact,
                ExpiryDate              = model.ExpiryDate,
                ManufactureDate         = model.ManufactureDate,
                Manufacturer            = model.Manufacturer,
                MeasureTypeConvertDicId = model.MeasureTypeConvertDicId,
                MeasureTypeDicId        = model.MeasureTypeDicId,
                PackageDicId            = model.PackageDicId,
                Rack                    = model.Rack,
                Safe                    = model.Safe,
                Serial                  = model.Serial,
                StorageDicId            = model.StorageDicId,
                TmcTypeDicId            = model.TmcTypeDicId,
                ReceivingDate           = model.ReceivingDate,
                TmcInId                 = Guid.Parse(model.TmcInIdString),
            };

            repo.Insert(tmc);
            repo.Save();
            model.Id = tmc.Id;

            var newDictionary = repo.TvGetAsQuarable(o => o.Id == tmc.Id).First();

            model.MeasureTypeDicValue = newDictionary.MeasureTypeDicValue;

            var appRepo = new ApplicationPoaRepository(false);

            appRepo.AddLimsTmcTemp(new LimsTmcTemp()
            {
                TmcId         = tmc.Id,
                TmcInId       = tmc.TmcInId,
                CountRequest  = model.CountRequest,
                CountReceived = null,
                IsSelected    = model.IsSelected,
                CreatedDate   = DateTime.Now
            });
            appRepo.Save();

            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult ConfirmSendTo1CTmcs(Guid id)
        {
            ApplicationPoaRepository repo = new ApplicationPoaRepository(false);
            var tmcin = repo.GetAsQuarable(o => o.Id == id).FirstOrDefault();

            if (tmcin != null)
            {
                tmcin.StateType = TmcIn.TmcInStatuses.SendedAdmission1C;
                repo.Update(tmcin);
                repo.Save();
            }

            return(Json(id, JsonRequestBehavior.AllowGet));
        }
        public ActionResult UpdateTmc([DataSourceRequest] DataSourceRequest request, TmcViewModel model)
        {
            TmcRepository repo = new TmcRepository(false);
            Tmc           tmc  = repo.GetAsQuarable(o => o.Id == model.Id).FirstOrDefault();

            if (tmc != null)
            {
                //tmc.StateType = model.StateType;
                //tmc.Name = model.Name;
                //tmc.Code = model.Code;
                //tmc.Count = model.Count;
                //tmc.CountActual = model.CountRequest.Value;
                //tmc.OwnerEmployeeId = model.OwnerEmployeeId;
                //tmc.Number = model.Number;
                //tmc.CountFact = model.CountRequest.Value;
                //tmc.CountConvert = model.CountRequest.Value;
                //tmc.ExpiryDate = model.ExpiryDate;
                //tmc.ManufactureDate = model.ManufactureDate;
                //tmc.Manufacturer = model.Manufacturer;
                //tmc.MeasureTypeConvertDicId = model.MeasureTypeConvertDicId;
                //tmc.MeasureTypeDicId = model.MeasureTypeDicId;
                //tmc.PackageDicId = model.PackageDicId;
                //tmc.Rack = model.Rack;
                //tmc.Safe = model.Safe;
                //tmc.Serial = model.Serial;
                //tmc.StorageDicId = model.StorageDicId;
                //tmc.TmcTypeDicId = model.TmcTypeDicId;
                //tmc.ReceivingDate = model.ReceivingDate;
                tmc.MeasureTypeDicId = model.MeasureTypeDicId;
            }

            repo.Save();

            if (tmc != null)
            {
                var newDictionary = repo.TvGetAsQuarable(o => o.Id == tmc.Id).First();
                model.MeasureTypeDicValue = newDictionary.MeasureTypeDicValue;

                var appRepo     = new ApplicationPoaRepository(false);
                var limsTmcTemp = appRepo.GetLimsTmcTemps(ltt => ltt.TmcId == tmc.Id && ltt.TmcInId == tmc.TmcInId).FirstOrDefault();
                if (limsTmcTemp != null)
                {
                    limsTmcTemp.CountRequest  = model.CountRequest;
                    limsTmcTemp.CountReceived = model.CounReceived;
                }
                appRepo.Save();
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult DestroyApplication([DataSourceRequest] DataSourceRequest request, TmcInView model)
        {
            if (model != null)
            {
                TmcRepository tRepo = new TmcRepository(false);
                tRepo.RemoveTmcByPoaId(model.Id);
                tRepo.Save();

                ApplicationPoaRepository repo = new ApplicationPoaRepository(false);
                TmcIn d = repo.GetAsQuarable(o => o.Id == model.Id).FirstOrDefault();
                repo.Delete(d);
                repo.Save();
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult ConfirmAcceptTmc(Guid id, Tmc tmc)
        {
            TmcRepository repo     = new TmcRepository(false);
            var           tmcExist = repo.GetAsQuarable(o => o.Id == id).FirstOrDefault();

            if (tmcExist != null)
            {
                if (tmcExist.StateType == Tmc.TmcStatuses.Accepted)
                {
                    tmcExist.CountFact    += tmc.Count;
                    tmcExist.CountActual  += tmc.CountConvert;
                    tmcExist.CountConvert += tmc.CountConvert;
                }
                else
                {
                    tmcExist.CountFact   = tmc.Count;
                    tmcExist.CountActual = tmcExist.CountConvert = tmc.CountConvert;
                }

                tmcExist.StateType = Tmc.TmcStatuses.Accepted;

                if (tmc.MeasureTypeConvertDicId != null)
                {
                    tmcExist.MeasureTypeConvertDicId = tmc.MeasureTypeConvertDicId;
                }
                else
                {
                    tmcExist.MeasureTypeConvertDicId = tmcExist.MeasureTypeDicId;
                    tmcExist.CountActual             = tmcExist.CountConvert = tmcExist.CountFact = tmc.Count;
                }
                tmcExist.OwnerEmployeeId = UserHelper.GetCurrentEmployee().Id;
                tmcExist.ReceivingDate   = tmc.ReceivingDate ?? DateTime.Now;
                repo.Save();

                ApplicationPoaRepository repository = new ApplicationPoaRepository(false);
                var limsTmcTemp = repository.GetLimsTmcTemps(ltt => ltt.TmcId == tmc.Id && ltt.TmcInId == tmc.TmcInId).FirstOrDefault();
                if (limsTmcTemp != null)
                {
                    limsTmcTemp.CountReceived = tmc.Count;
                }
                repository.Save();
            }

            return(Json(id, JsonRequestBehavior.AllowGet));
        }
        public ActionResult DestroyTmc([DataSourceRequest] DataSourceRequest request, TmcViewModel dictionary)
        {
            TmcRepository            repo    = new TmcRepository(false);
            ApplicationPoaRepository poaRepo = new ApplicationPoaRepository(false);

            if (dictionary != null)
            {
                var limsTmcTemp = poaRepo.GetLimsTmcTemps(ltt => ltt.TmcId == dictionary.Id && ltt.TmcInId == dictionary.TmcInId).FirstOrDefault();
                poaRepo.DeleteLimsTmcTemp(limsTmcTemp);
                poaRepo.Save();

                Tmc d = repo.GetAsQuarable(o => o.Id == dictionary.Id).First();
                repo.Delete(d);
                repo.Save();
            }

            return(Json(new[] { dictionary }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult UpdateApplication([DataSourceRequest] DataSourceRequest request,
                                              TmcInView model)
        {
            if (model.Id == Guid.Empty)
            {
                model.Id = model.TmcInId;
            }

            ApplicationPoaRepository repo = new ApplicationPoaRepository(false);
            TmcIn d = repo.GetAsQuarable(o => o.Id == model.Id).FirstOrDefault();

            bool isContractChange = d.ContractNumber != model.ContractNumber;

            d.StateType            = model.StateType;
            d.ContractDate         = model.ContractDate;
            d.ContractNumber       = model.ContractNumber;
            d.IsFullDelivery       = model.IsFullDelivery;
            d.LastDeliveryDate     = model.LastDeliveryDate;
            d.OwnerEmployeeId      = model.OwnerEmployeeId;
            d.Provider             = model.Provider;
            d.ProviderBin          = model.ProviderBin;
            d.ExecutorEmployeeId   = model.ExecutorEmployeeId;
            d.AgreementEmployeeId  = model.AgreementEmployeeId;
            d.AccountantEmployeeId = model.AccountantEmployeeId;

            repo.Save();
            model = repo.GetTmcInViews(o => o.Id == d.Id).FirstOrDefault();
            if (isContractChange)
            {
                TmcRepository tmcRepo = new TmcRepository();

                tmcRepo.RemoveTmcByPoaId(model.Id);

                var dicRepo          = new DictionaryRepository(false);
                var contractProducts = tmcRepo.GetI1cLimsContractProducts(lc => lc.ContractNumber == d.ContractNumber);
                foreach (var prod in contractProducts.ToList())
                {
                    var measureId = dicRepo.GetDictionaryIdByTypeAndDisplayName(Dictionary.MeasureType.DicCode, prod.Unit);

                    var tmc = new Tmc()
                    {
                        Id                      = Guid.NewGuid(),
                        CreatedDate             = DateTime.Now,
                        CreatedEmployeeId       = UserHelper.GetCurrentEmployee().Id,
                        TmcInId                 = d.Id,
                        StateType               = 0,
                        Number                  = prod.ProductId,
                        Code                    = prod.ProductId,
                        Name                    = prod.Name,
                        Count                   = prod.QuantityVolume.Value,
                        CountActual             = prod.QuantityVolume.Value,
                        CountFact               = prod.QuantityVolume.Value,
                        CountConvert            = prod.QuantityVolume.Value,
                        MeasureTypeDicId        = measureId,
                        MeasureTypeConvertDicId = measureId
                    };
                    var tmcExist = tmcRepo.GetAsQuarable(t => t.Number == tmc.Number && t.CountFact < t.Count).FirstOrDefault();
                    if (tmcExist == null)
                    {
                        tmcRepo.Insert(tmc);

                        var limsTmc = new LimsTmcTemp()
                        {
                            TmcId        = tmc.Id,
                            TmcInId      = tmc.TmcInId,
                            CreatedDate  = DateTime.Now,
                            CountRequest = tmc.Count,
                            IsSelected   = false
                        };
                        repo.AddLimsTmcTemp(limsTmc);
                    }
                    else
                    {
                        var limsTmc = new LimsTmcTemp()
                        {
                            TmcId        = tmc.Id,
                            TmcInId      = tmc.TmcInId,
                            CreatedDate  = DateTime.Now,
                            CountRequest = prod.QuantityVolume.Value - tmcExist.CountFact,
                            IsSelected   = false
                        };
                        if (prod.QuantityVolume.Value - tmcExist.CountFact > 0)
                        {
                            repo.AddLimsTmcTemp(limsTmc);
                        }
                    }
                }
                tmcRepo.Save();

                repo.Save();
            }
            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }
        public ActionResult CreateApplication([DataSourceRequest] DataSourceRequest request, TmcInViewModel model)
        {
            if (ModelState.IsValid)
            {
                ApplicationPoaRepository repo = new ApplicationPoaRepository(false);
                TmcIn tmcIn = new TmcIn()
                {
                    Id                   = Guid.NewGuid(),
                    StateType            = model.StateType,
                    ContractDate         = model.ContractDate,
                    ContractNumber       = model.ContractNumber,
                    CreatedDate          = DateTime.Now,
                    CreatedEmployeeId    = UserHelper.GetCurrentEmployee().Id,
                    IsFullDelivery       = model.IsFullDelivery,
                    LastDeliveryDate     = model.LastDeliveryDate,
                    OwnerEmployeeId      = model.OwnerEmployeeId,
                    Provider             = model.Provider,
                    ProviderBin          = model.ProviderBin,
                    ExecutorEmployeeId   = model.ExecutorEmployeeId,
                    AgreementEmployeeId  = model.AgreementEmployeeId,
                    AccountantEmployeeId = model.AccountantEmployeeId
                };

                repo.Insert(tmcIn);
                repo.Save();

                var newDictionary = repo.GetTmcInViews(o => o.Id == tmcIn.Id).First();
                model.TmcInId                 = tmcIn.Id;
                model.OwnerEmployeeValue      = newDictionary.OwnerEmployeeValue;
                model.StateTypeValue          = newDictionary.StateTypeValue;
                model.PowerOfAttorney         = newDictionary.PowerOfAttorney;
                model.IsFullDeliveryValue     = newDictionary.IsFullDeliveryValue;
                model.ExecutorEmployeeValue   = newDictionary.ExecutorEmployeeValue;
                model.AgreementEmployeeValue  = newDictionary.AgreementEmployeeValue;
                model.AccountantEmployeeValue = newDictionary.AccountantEmployeeValue;
                model.Id = newDictionary.Id;


                TmcRepository tmcRepo          = new TmcRepository();
                var           dicRepo          = new DictionaryRepository(false);
                var           contractProducts = tmcRepo.GetI1cLimsContractProducts(lc => lc.ContractNumber == tmcIn.ContractNumber);
                foreach (var prod in contractProducts.ToList())
                {
                    var measureId = dicRepo.GetDictionaryIdByTypeAndDisplayName(Dictionary.MeasureType.DicCode, prod.Unit);
                    if (measureId == null || measureId == Guid.Empty)
                    {
                        measureId = dicRepo.GetDictionaryIdByTypeAndName(Dictionary.MeasureType.DicCode, prod.Unit);
                    }

                    var tmc = new Tmc()
                    {
                        Id                      = Guid.NewGuid(),
                        CreatedDate             = DateTime.Now,
                        CreatedEmployeeId       = UserHelper.GetCurrentEmployee().Id,
                        TmcInId                 = tmcIn.Id,
                        StateType               = 0,
                        Number                  = prod.ProductId,
                        Code                    = prod.ProductId,
                        Name                    = prod.Name,
                        Count                   = prod.QuantityVolume.Value,
                        CountActual             = 0, //prod.QuantityVolume.Value,
                        CountFact               = 0, //prod.QuantityVolume.Value,
                        CountConvert            = 0, // prod.QuantityVolume.Value,
                        MeasureTypeDicId        = measureId,
                        MeasureTypeConvertDicId = measureId
                    };


                    var tmcExist = tmcRepo.GetAsQuarable(t => t.Number == tmc.Number && t.StateType != Tmc.TmcStatuses.Writeoff).FirstOrDefault();

                    if (tmcExist == null)
                    {
                        tmcRepo.Insert(tmc);

                        var limsTmc = new LimsTmcTemp()
                        {
                            TmcId        = tmc.Id,
                            TmcInId      = tmc.TmcInId,
                            CreatedDate  = DateTime.Now,
                            CountRequest = tmc.Count,
                            IsSelected   = false
                        };
                        repo.AddLimsTmcTemp(limsTmc);
                    }
                    else if (tmcExist.CountFact < tmcExist.Count)
                    {
                        var limsTmc = new LimsTmcTemp()
                        {
                            TmcId        = tmcExist.Id,
                            TmcInId      = tmcIn.Id,
                            CreatedDate  = DateTime.Now,
                            CountRequest = prod.QuantityVolume.Value - tmcExist.CountFact,
                            IsSelected   = false
                        };
                        if (prod.QuantityVolume.Value - tmcExist.CountFact > 0)
                        {
                            repo.AddLimsTmcTemp(limsTmc);
                        }
                    }
                }
                tmcRepo.Save();

                repo.Save();
            }

            return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
        }