Exemple #1
0
        public async Task <IActionResult> PostRestrictionMat([FromBody] RestrictionMatDTO restrictionMatDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var restriction = await restrictionRepository.Add(restrictionMatDTO);

            if (restriction == null)
            {
                return(BadRequest());
            }

            CombinationDTO combination = new CombinationDTO();

            combination.CombinationId     = restriction.combination.CombinationId;
            combination.containedProduct  = restriction.combination.containedProduct.name;
            combination.containingProduct = restriction.combination.containingProduct.name;
            combination.required          = restriction.combination.required;

            RestrictionMat    res_mat = (RestrictionMat)restriction;
            RestrictionMatDTO dto     = new RestrictionMatDTO();

            dto.combination        = combination;
            dto.description        = res_mat.description;
            dto.RestrictionId      = res_mat.RestrictionId;
            dto.containingMaterial = res_mat.containingMaterial.name;
            dto.containedMaterial  = res_mat.containedMaterial.name;

            return(CreatedAtAction("GetRestriction", dto));
        }
Exemple #2
0
        public async Task <IActionResult> PostRestrictionDim([FromBody] RestrictionDimDTO restrictionDimDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var restriction = await restrictionRepository.Add(restrictionDimDTO);

            if (restriction == null)
            {
                return(BadRequest());
            }

            CombinationDTO combination = new CombinationDTO();

            combination.CombinationId     = restriction.combination.CombinationId;
            combination.containedProduct  = restriction.combination.containedProduct.name;
            combination.containingProduct = restriction.combination.containingProduct.name;
            combination.required          = restriction.combination.required;

            RestrictionDim    res_dim = (RestrictionDim)restriction;
            RestrictionDimDTO dto     = new RestrictionDimDTO();

            dto.combination   = combination;
            dto.description   = res_dim.description;
            dto.RestrictionId = res_dim.RestrictionId;
            dto.x             = res_dim.x;
            dto.y             = res_dim.y;
            dto.z             = res_dim.z;

            return(CreatedAtAction("GetRestriction", dto));
        }
Exemple #3
0
        public async Task <IActionResult> GetRestrictions([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            List <Restriction> restrictions = await productRepository.Restricitons(id);

            if (restrictions == null)
            {
                return(BadRequest());
            }

            List <RestrictionDTO> dtos = new List <RestrictionDTO>();

            foreach (Restriction restriction in restrictions)
            {
                CombinationDTO combination = new CombinationDTO();
                combination.CombinationId     = restriction.combination.CombinationId;
                combination.containedProduct  = restriction.combination.containedProduct.name;
                combination.containingProduct = restriction.combination.containingProduct.name;
                combination.required          = restriction.combination.required;

                if (restriction is RestrictionDim)
                {
                    RestrictionDim    res_dim = (RestrictionDim)restriction;
                    RestrictionDimDTO dto     = new RestrictionDimDTO();
                    dto.combination   = combination;
                    dto.description   = res_dim.description;
                    dto.RestrictionId = res_dim.RestrictionId;
                    dto.x             = res_dim.x;
                    dto.y             = res_dim.y;
                    dto.z             = res_dim.z;
                    dtos.Add(dto);
                }

                if (restriction is RestrictionMat)
                {
                    RestrictionMat    res_mat = (RestrictionMat)restriction;
                    RestrictionMatDTO dto     = new RestrictionMatDTO();
                    dto.combination        = combination;
                    dto.description        = res_mat.description;
                    dto.RestrictionId      = res_mat.RestrictionId;
                    dto.containingMaterial = res_mat.containingMaterial.name;
                    dto.containedMaterial  = res_mat.containedMaterial.name;
                    dtos.Add(dto);
                }
            }

            return(Ok(dtos));
        }
        public IEnumerable <CombinationDTO> GetCombination()
        {
            List <CombinationDTO> combinationDTOs = new List <CombinationDTO>();

            foreach (Combination combination in combinationRepository.FindAll())
            {
                CombinationDTO dto = new CombinationDTO();
                dto.CombinationId     = combination.CombinationId;
                dto.containedProduct  = combination.containedProduct.name;
                dto.containingProduct = combination.containingProduct.name;
                dto.required          = combination.required;
                combinationDTOs.Add(dto);
            }
            return(combinationDTOs);
        }
Exemple #5
0
        public async Task <IActionResult> GetRestriction([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var restriction = await restrictionRepository.FindById(id);

            if (restriction == null)
            {
                return(NotFound());
            }

            CombinationDTO combination = new CombinationDTO();

            combination.CombinationId     = restriction.combination.CombinationId;
            combination.containedProduct  = restriction.combination.containedProduct.name;
            combination.containingProduct = restriction.combination.containingProduct.name;
            combination.required          = restriction.combination.required;

            if (restriction is RestrictionDim)
            {
                RestrictionDim    res_dim = (RestrictionDim)restriction;
                RestrictionDimDTO dto     = new RestrictionDimDTO();
                dto.combination   = combination;
                dto.description   = res_dim.description;
                dto.RestrictionId = res_dim.RestrictionId;
                dto.x             = res_dim.x;
                dto.y             = res_dim.y;
                dto.z             = res_dim.z;
                return(Ok(dto));
            }

            if (restriction is RestrictionMat)
            {
                RestrictionMat    res_mat = (RestrictionMat)restriction;
                RestrictionMatDTO dto     = new RestrictionMatDTO();
                dto.combination        = combination;
                dto.description        = res_mat.description;
                dto.RestrictionId      = res_mat.RestrictionId;
                dto.containingMaterial = res_mat.containingMaterial.name;
                dto.containedMaterial  = res_mat.containedMaterial.name;
                return(Ok(dto));
            }

            return(BadRequest());
        }
Exemple #6
0
        public IEnumerable <RestrictionDTO> GetRestriction()
        {
            List <RestrictionDTO> dtos = new List <RestrictionDTO>();

            foreach (Restriction restriction in restrictionRepository.FindAll())
            {
                CombinationDTO combination = new CombinationDTO();
                combination.CombinationId     = restriction.combination.CombinationId;
                combination.containedProduct  = restriction.combination.containedProduct.name;
                combination.containingProduct = restriction.combination.containingProduct.name;
                combination.required          = restriction.combination.required;

                if (restriction is RestrictionDim)
                {
                    RestrictionDim    res_dim = (RestrictionDim)restriction;
                    RestrictionDimDTO dto     = new RestrictionDimDTO();
                    dto.combination   = combination;
                    dto.description   = res_dim.description;
                    dto.RestrictionId = res_dim.RestrictionId;
                    dto.x             = res_dim.x;
                    dto.y             = res_dim.y;
                    dto.z             = res_dim.z;
                    dtos.Add(dto);
                }

                if (restriction is RestrictionMat)
                {
                    RestrictionMat    res_mat = (RestrictionMat)restriction;
                    RestrictionMatDTO dto     = new RestrictionMatDTO();
                    dto.combination        = combination;
                    dto.description        = res_mat.description;
                    dto.RestrictionId      = res_mat.RestrictionId;
                    dto.containingMaterial = res_mat.containingMaterial.name;
                    dto.containedMaterial  = res_mat.containedMaterial.name;
                    dtos.Add(dto);
                }
            }
            return(dtos);
        }
        public async Task <IActionResult> DeleteCombination([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var combination = await combinationRepository.Remove(id);

            if (combination == null)
            {
                return(BadRequest());
            }

            CombinationDTO dto = new CombinationDTO();

            dto.CombinationId     = combination.CombinationId;
            dto.containedProduct  = combination.containedProduct.name;
            dto.containingProduct = combination.containingProduct.name;
            dto.required          = combination.required;

            return(Ok(dto));
        }
        public async Task <IActionResult> PostCombination([FromBody] CombinationDTO combinationDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var combination = await combinationRepository.Add(combinationDTO);

            if (combination == null)
            {
                return(BadRequest());
            }

            CombinationDTO dto = new CombinationDTO();

            dto.CombinationId     = combination.CombinationId;
            dto.containedProduct  = combination.containedProduct.name;
            dto.containingProduct = combination.containingProduct.name;
            dto.required          = combination.required;

            return(CreatedAtAction("GetCombination", dto));
        }