public async Task <IActionResult> GetProductRelationById(Int64 RelationProductId)
        {
            ProductRelation Items = new ProductRelation();

            try
            {
                Items = await _context.ProductRelation.Where(q => q.RelationProductId == RelationProductId).FirstOrDefaultAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError($"Ocurrio un error: { ex.ToString() }");
                return(BadRequest($"Ocurrio un error:{ex.Message}"));
            }
            return(await Task.Run(() => Ok(Items)));
        }
        public async Task <IActionResult> GetProductRelationByProductIDSubProductId([FromBody] ProductRelation _pr)
        {
            List <ProductRelation> Items = new List <ProductRelation>();

            try
            {
                Items = await _context.ProductRelation.Where(q => q.ProductId == _pr.ProductId)
                        .Where(q => q.SubProductId == _pr.SubProductId)
                        .ToListAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError($"Ocurrio un error: { ex.ToString() }");
                return(BadRequest($"Ocurrio un error:{ex.Message}"));
            }
            return(await Task.Run(() => Ok(Items)));
        }
        public async Task <ActionResult <ProductRelation> > Update([FromBody] ProductRelation productrelation)
        {
            ProductRelation _productrelation = productrelation;

            try
            {
                _context.ProductRelation.Update(_productrelation);
                await _context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError($"Ocurrio un error: { ex.ToString() }");
                return(BadRequest($"Ocurrio un error:{ex.Message}"));
            }
            return(await Task.Run(() => Ok(_productrelation)));

            //   return Ok(subproduct);
        }
        public async Task <ActionResult <ProductRelation> > Delete([FromBody] ProductRelation ProductRelation)
        {
            ProductRelation _ProductRelation = new ProductRelation();

            try
            {
                _ProductRelation = _context.ProductRelation
                                   .Where(x => x.RelationProductId == ProductRelation.RelationProductId)
                                   .FirstOrDefault();
                _context.ProductRelation.Remove(_ProductRelation);
                await _context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError($"Ocurrio un error: { ex.ToString() }");
                return(BadRequest($"Ocurrio un error:{ex.Message}"));
            }

            // return Ok(currency);
            return(await Task.Run(() => Ok(_ProductRelation)));
        }
        private void UpdateRelatedProducts(FieldChange fieldChange, Product product)
        {
            var productRepository = ObjectFactory.Instance.Resolve <IRepository <Product> >();

            var selectedSitecoreProductIds = fieldChange.Value.Split(new [] { '|' }, StringSplitOptions.RemoveEmptyEntries);

            var selectedRelations = new List <ProductRelation>();

            var defaultProductRelationType = ProductRelationType.SingleOrDefault(x => x.ProductRelationTypeId == 1);

            var products = productRepository.Select(new ProductsByGuidsQuery(selectedSitecoreProductIds.Select(Guid.Parse).ToList()));

            // Creating relations from selected products
            foreach (var selectedProduct in products)
            {
                var relation = new ProductRelation()
                {
                    Product             = product,
                    RelatedProduct      = selectedProduct,
                    ProductRelationType = defaultProductRelationType
                };

                selectedRelations.Add(relation);
            }


            // Removing relations
            var relationsToRemove = product.ProductRelations.Where(
                relation => selectedRelations.All(x => x.RelatedProduct.ProductId != relation.RelatedProduct.ProductId)).ToList();

            relationsToRemove.ForEach(x => product.ProductRelations.Remove(x));

            // Adding new relations
            var relationsToAdd = selectedRelations.Where(
                relation => product.ProductRelations.All(x => x.RelatedProduct.ProductId != relation.RelatedProduct.ProductId));

            relationsToAdd.ForEach(x => product.ProductRelations.Add(x));
        }
예제 #6
0
        /// <summary>
        /// ”даление из списка параметров, которые в одной группе с об¤зательными параметрами.
        /// </summary>
        /// <returns></returns>
        public static IEnumerable <Parameter> GetUsefull(this IEnumerable <Parameter> targetParameters, ProductRelation relation)
        {
            var parameters = targetParameters as List <Parameter> ?? targetParameters.ToList();

            //об¤зательные параметры
            var goodParams = relation.ChildProductParameters.ToList();
            var groups     = goodParams.Select(x => x.ParameterGroup).Distinct();
            //парметры, способные увести в сторону (плохие)
            var badParams = parameters.Where(x => groups.Contains(x.ParameterGroup)).Except(goodParams).ToList();
            //об¤зательное пересечение путей
            var ints = Intercect(goodParams).ToList();

            //все пути всех параметров
            var paths = parameters.SelectMany(x => x.Paths()).ToList();

            //исключаем пути с плохими параметрами
            paths = paths.Where(x => !x.Parameters.Intersect(badParams).Any()).ToList();
            //исключаем пути без хороших параметров
            paths = paths.Where(x => x.Parameters.Intersect(goodParams).Any()).ToList();
            //исключаем пути без пересечений
            paths = paths.Where(x => ints.AllContainsIn(x.Parameters)).ToList();

            var result = paths.SelectMany(x => x.Parameters).Distinct().ToList();

            return(result);
        }
 public void AddSubProduct(ProductRelation productRelation)
 {
     AddOperation(
         (connection, transaction) => connection.ExecuteAsync(productRelation.ToInsertQuery(), productRelation, transaction));
 }
예제 #8
0
        public void Init()
        {
            _breaker = new Parameter {
                ParameterGroup = _eqType, Value = "выключатель"
            };
            _transformator = new Parameter {
                ParameterGroup = _eqType, Value = "трансформатор"
            };
            _drive = new Parameter {
                ParameterGroup = _eqType, Value = "привод выключателя"
            };
            _drivesReducer = new Parameter {
                ParameterGroup = _eqType, Value = "редуктор"
            };

            _v110 = new Parameter {
                ParameterGroup = _voltage, Value = "110кВ"
            }.
            AddRequiredPreviousParameters(new[] { _breaker });
            _v220 = new Parameter {
                ParameterGroup = _voltage, Value = "220кВ"
            }.
            AddRequiredPreviousParameters(new[] { _breaker });
            _v500 = new Parameter {
                ParameterGroup = _voltage, Value = "500кВ"
            }.
            AddRequiredPreviousParameters(new[] { _breaker });

            _c2500 = new Parameter {
                ParameterGroup = _current, Value = "2500 А"
            }.
            AddRequiredPreviousParameters(new[] { _breaker, _v110 }).
            AddRequiredPreviousParameters(new[] { _breaker, _v220 });
            _c3150 = new Parameter {
                ParameterGroup = _current, Value = "3150 А"
            }.
            AddRequiredPreviousParameters(new[] { _breaker, _v110 }).
            AddRequiredPreviousParameters(new[] { _breaker, _v220 }).
            AddRequiredPreviousParameters(new[] { _breaker, _v500 });
            _c0001 = new Parameter {
                ParameterGroup = _current, Value = "1 А"
            }.
            AddRequiredPreviousParameters(new[] { _transformator });
            _c0005 = new Parameter {
                ParameterGroup = _current, Value = "5 А"
            }.
            AddRequiredPreviousParameters(new[] { _transformator });

            _parameters = new List <Parameter>(new[]
            {
                _breaker, _transformator, _drive, _drivesReducer, _v110, _v220, _v500, _c2500, _c3150, _c0001, _c0005
            });



            _groups = new List <ParameterGroup> {
                _eqType, _voltage, _current
            };

            _productsRelationTransformatorsToBreker = new ProductRelation
            {
                ParentProductParameters = new List <Parameter> {
                    _breaker, _v110
                },
                ChildProductParameters = new List <Parameter> {
                    _transformator
                },
                Count = 6
            };
            _productsRelationDriveToBreker = new ProductRelation
            {
                ParentProductParameters = new List <Parameter> {
                    _breaker, _v110
                },
                ChildProductParameters = new List <Parameter> {
                    _drive
                },
                Count = 1
            };
            _productsRelationReducerToDrive = new ProductRelation
            {
                ParentProductParameters = new List <Parameter> {
                    _drive
                },
                ChildProductParameters = new List <Parameter> {
                    _drivesReducer
                },
                Count = 3
            };
            _requiredDependentEquipmentsParametersList = new List <ProductRelation>
            {
                _productsRelationTransformatorsToBreker,
                _productsRelationDriveToBreker,
                _productsRelationReducerToDrive
            };

            _productSelector = new ProductSelector(_parameters, null);
            ProductSelector.ProductRelations = _requiredDependentEquipmentsParametersList;
        }