private void DeleteMarketGroups(UpdateActivityDto activityDto)
        {
            var deletedMarketGroupsDtos = activityDto
                                          .Pharmacy
                                          .ActivityMarketGroupDtoItems
                                          .Where(c => c.State == ObjectState.Delete && c.Id > 0);

            var deletedMarketGroupsIds = deletedMarketGroupsDtos
                                         .Select(x => x.Id)
                                         .ToList();

            _repository.RemoveAll(_repository
                                  .Queryable <ActivityMarketGroup>()
                                  .Where(x => deletedMarketGroupsIds.Contains(x.Id))
                                  .ToList());

            if (activityDto.Pharmacy.CheckedOrganizations == null)
            {
                return;
            }

            var removedOrganizations = activityDto
                                       .Pharmacy
                                       .CheckedOrganizations
                                       .Where(c => deletedMarketGroupsIds.Contains(c.ActivityMarketGroupId))
                                       .ToList();


            activityDto.Pharmacy.CheckedOrganizations = activityDto
                                                        .Pharmacy
                                                        .CheckedOrganizations
                                                        .Except(removedOrganizations)
                                                        .ToList();
        }
        public long Execute(UpdateActivityDto activityDto)
        {
            if (activityDto.Products == null)
            {
                return(activityDto.ActivityId);
            }

            var activity = _repository
                           .Queryable <Activity>()
                           .Single(x => x.Id == activityDto.ActivityId);

            activity.PackageName = activityDto.Products.PackageName;

            if (activityDto.Products.RemovedProductsIds.IsEmpty() == false)
            {
                var removedActivityProducts = _repository
                                              .Queryable <ActivityProduct>()
                                              .Where(x => x.Activity.Id == activityDto.ActivityId && activityDto.Products.RemovedProductsIds.Contains(x.Product.Id))
                                              .ToList();

                _repository.RemoveAll(removedActivityProducts);
            }

            if (activityDto.Products.AddedProductsIds.IsEmpty() == false)
            {
                var activityProducts = _repository
                                       .QueryableAsNoTracking <ActivityProduct>()
                                       .Where(x => x.Activity.Id == activityDto.ActivityId)
                                       .Select(x => x.Product.Id)
                                       .ToList();

                var addedProductsIds = _repository
                                       .QueryableAsNoTracking <Product>()
                                       .Where(x => activityDto.Products.AddedProductsIds.Contains(x.Id))
                                       .Where(x => activityProducts.Contains(x.Id) == false)
                                       .Select(x => x.Id)
                                       .ToList();

                foreach (var addedProductId in addedProductsIds)
                {
                    _repository.Add(new ActivityProduct
                    {
                        ActivityId = activityDto.ActivityId,
                        ProductId  = addedProductId
                    });
                }
            }

            _repository.Save();

            return(activity.Id);
        }
        public long Execute(UpdateActivityDto activityDto)
        {
            if (activityDto.Conditions == null)
            {
                return(activityDto.ActivityId);
            }

            AddNewIndicators(activityDto);
            DeleteIndicators(activityDto);
            DeleteIndicatorsInActivityProduct(activityDto);
            UpdateIndicators(activityDto);
            return(activityDto.ActivityId);
        }
        private void UpdateIndicators(UpdateActivityDto activityDto)
        {
            var activityIndicatorDtos = activityDto
                                        .Conditions
                                        .ActivityIndicatorList
                                        .Where(c => c.State == ObjectState.Edit)
                                        .ToList();

            foreach (var activityIndicatorDto in activityIndicatorDtos)
            {
                var activityIndicator = _repository
                                        .Queryable <ActivityIndicator>()
                                        .SingleOrDefault(c => c.Id == activityIndicatorDto.Id);

                if (activityIndicator == null)
                {
                    continue;
                }

                activityIndicator.Comments      = activityIndicatorDto.Comments;
                activityIndicator.IndicatorId   = activityIndicatorDto.Indicator.Id;
                activityIndicator.ProductTypeId = activityIndicatorDto.ProductType.Id;
                _repository.LocalOrAttach(activityIndicator);
            }

            var indicatorDtos = activityDto
                                .Conditions
                                .ActivityIndicatorList
                                .Where(c => c.State == ObjectState.Edit || c.State == ObjectState.Normal)
                                .ToList();

            foreach (var indicator in indicatorDtos)
            {
                _repository.RemoveAll(_repository
                                      .Queryable <ActivityIndicatorCheck>()
                                      .Where(c => c.ActivityIndicatorId == indicator.Id)
                                      .ToList());
                _repository.Save();

                List <ActivityIndicatorCheck> activityIndicatorCheckList = indicator.CheckedActivityIndicator.Select(indicatorCheck => new ActivityIndicatorCheck
                {
                    ActivityMarketGroupId = indicatorCheck.ActivityMarketGroupId,
                    ActivityIndicatorId   = indicator.Id,
                    ProductId             = indicatorCheck.ProductId,
                    IndicatorFieldId      = indicatorCheck.IndicatorFieldId,
                    IndicatorFieldValue   = string.IsNullOrEmpty(indicatorCheck.IndicatorFieldValue) ? string.Empty : indicatorCheck.IndicatorFieldValue
                }).ToList();
                _repository.AddAll(activityIndicatorCheckList);
                _repository.Save();
            }
        }
        private void AddNewIndicators(UpdateActivityDto activityDto)
        {
            var newActivityIndicatorDtos = activityDto
                                           .Conditions
                                           .ActivityIndicatorList
                                           .Where(c => c.State == ObjectState.Create && c.Indicator.Id != 0)
                                           .ToList();

            foreach (var newActivityIndicator in newActivityIndicatorDtos)
            {
                if (newActivityIndicator.Indicator == null || newActivityIndicator.ProductType == null)
                {
                    continue;
                }
                if (newActivityIndicator.ProductType.Id == 0 || newActivityIndicator.ProductType.Id == 0)
                {
                    continue;
                }

                var activityIndicator = new ActivityIndicator
                {
                    ActivityId    = activityDto.ActivityId,
                    IndicatorId   = newActivityIndicator.Indicator.Id,
                    ProductTypeId = newActivityIndicator.ProductType.Id,
                    Comments      = newActivityIndicator.Comments
                };


                _repository.Add(activityIndicator);

                _repository.Save();

                if (newActivityIndicator.CheckedActivityIndicator == null)
                {
                    continue;
                }

                List <ActivityIndicatorCheck> activityIndicatorCheckList = newActivityIndicator.CheckedActivityIndicator.Select(indicatorCheck => new ActivityIndicatorCheck
                {
                    ActivityMarketGroupId = indicatorCheck.ActivityMarketGroupId,
                    ActivityIndicatorId   = activityIndicator.Id,
                    ProductId             = indicatorCheck.ProductId,
                    IndicatorFieldId      = indicatorCheck.IndicatorFieldId,
                    IndicatorFieldValue   = string.IsNullOrEmpty(indicatorCheck.IndicatorFieldValue) ? string.Empty : indicatorCheck.IndicatorFieldValue
                }).ToList();
                _repository.AddAll(activityIndicatorCheckList);
                _repository.Save();
            }
        }
        private void DeleteIndicatorsInActivityProduct(UpdateActivityDto activityDto)
        {
            var productList           = _repository.Queryable <ActivityProduct>().Where(c => c.ActivityId == activityDto.ActivityId);
            var activityIndicatorList = _repository.Queryable <ActivityIndicatorCheck>()
                                        .Include(c => c.ActivityIndicator)
                                        .Where(
                c =>
                c.ActivityIndicator.ActivityId == activityDto.ActivityId &&
                !productList.Any(c2 => c2.ProductId == c.ProductId)).ToList();

            if (activityIndicatorList.Count != 0)
            {
                _repository.RemoveAll(activityIndicatorList);
            }
            _repository.Save();
        }
        public long Execute(UpdateActivityDto activityDto)
        {
            if (activityDto.Pharmacy == null)
            {
                return(activityDto.ActivityId);
            }

            AddNewMarketGroups(activityDto);

            DeleteMarketGroups(activityDto);

            foreach (var item in activityDto.Pharmacy.ActivityMarketGroupDtoItems.Where(c => c.State == ObjectState.Edit))
            {
                var changeItem = _repository.Queryable <ActivityMarketGroup>().SingleOrDefault(c => c.Id == item.Id);
                if (changeItem == null)
                {
                    continue;
                }
                changeItem.Name        = item.Name;
                changeItem.Description = item.Description;
                _repository.LocalOrAttach(changeItem);
            }


            if (activityDto.Pharmacy.CheckedOrganizations != null)
            {
                var modifyMarketGroupsDtos = activityDto.Pharmacy.ActivityMarketGroupDtoItems.Where(c => c.State != ObjectState.Create && c.State != ObjectState.Delete).ToList();
                var modifyMarketGroupsIds  = modifyMarketGroupsDtos.Select(x => x.Id).ToList();
                _repository.RemoveAll(_repository.Queryable <ActivityMarketGroupOrganization>().Where(x => modifyMarketGroupsIds.Contains(x.ActivityMarketGroupId)).ToList());

                var addCheckedOrganizationsItems = (from checkedOrganizationsItem in activityDto.Pharmacy.CheckedOrganizations
                                                    where modifyMarketGroupsIds.Contains(checkedOrganizationsItem.ActivityMarketGroupId)
                                                    select new ActivityMarketGroupOrganization()
                {
                    ActivityMarketGroupId = checkedOrganizationsItem.ActivityMarketGroupId,
                    OrganizationId = checkedOrganizationsItem.OrganizationsId
                }).ToList();
                _repository.AddAll(addCheckedOrganizationsItems);
            }
            _repository.Save();
            return(activityDto.ActivityId);
        }
        private void DeleteIndicators(UpdateActivityDto activityDto)
        {
            var deletedActivityIndicatorDtos = activityDto
                                               .Conditions
                                               .ActivityIndicatorList
                                               .Where(c => c.State == ObjectState.Delete && c.Id > 0)
                                               .ToList();

            foreach (var deletedActivityIndicator in deletedActivityIndicatorDtos)
            {
                _repository.RemoveAll(_repository
                                      .Queryable <ActivityIndicatorCheck>()
                                      .Where(c => c.ActivityIndicatorId == deletedActivityIndicator.Id)
                                      .ToList());

                _repository.Remove(_repository
                                   .Queryable <ActivityIndicator>()
                                   .SingleOrDefault(c => c.Id == deletedActivityIndicator.Id));
            }
            _repository.Save();
        }
        private void AddNewMarketGroups(UpdateActivityDto activityDto)
        {
            var pharmaciesTabDto = activityDto.Pharmacy;

            var newMarketGroupsDtos = pharmaciesTabDto
                                      .ActivityMarketGroupDtoItems
                                      .Where(c => c.State == ObjectState.Create && !String.IsNullOrEmpty(c.Name.Trim()))
                                      .ToList();

            foreach (var newMarketGroupDtos in newMarketGroupsDtos)
            {
                var frontId = newMarketGroupDtos.Id;

                var newActivityMarketGroup = new ActivityMarketGroup
                {
                    ActivityId  = activityDto.ActivityId,
                    Name        = newMarketGroupDtos.Name,
                    Description = newMarketGroupDtos.Description
                };

                _repository.Add <ActivityMarketGroup>(newActivityMarketGroup);
                _repository.Save();
                if (pharmaciesTabDto.CheckedOrganizations.IsEmpty() == false)
                {
                    var activityMarketGroupId         = newActivityMarketGroup.Id;
                    var organizationsOfNewMarketGroup = pharmaciesTabDto
                                                        .CheckedOrganizations
                                                        .Where(c => c.ActivityMarketGroupId == frontId)
                                                        .ToList();

                    _repository.AddAll <ActivityMarketGroupOrganization>(organizationsOfNewMarketGroup
                                                                         .Select(x => new ActivityMarketGroupOrganization
                    {
                        ActivityMarketGroupId = activityMarketGroupId,
                        OrganizationId        = x.OrganizationsId
                    }).ToList());


                    foreach (var checkedOrganizationsItem in pharmaciesTabDto.CheckedOrganizations.Where(x => x.ActivityMarketGroupId == frontId))
                    {
                        checkedOrganizationsItem.ActivityMarketGroupId = activityMarketGroupId;
                    }

                    _repository.Save();
                }

                if (activityDto.Conditions == null)
                {
                    continue;
                }

                var activityIndicatorCheckDtos = activityDto
                                                 .Conditions
                                                 .ActivityIndicatorList
                                                 .Where(x => x.CheckedActivityIndicator != null)
                                                 .SelectMany(x => x.CheckedActivityIndicator)
                                                 .Where(x => x.ActivityMarketGroupId == frontId)
                                                 .ToList();

                activityIndicatorCheckDtos.ForEach(x => x.ActivityMarketGroupId = newActivityMarketGroup.Id);
            }
        }