/// <summary> /// Adds a Slot to a CustomizedProduct. /// </summary> /// <param name="addSlotModelView">AddSlotModelView with the Slot's information</param> /// <returns>An instance of GetCustomizedProductModelView containing updated CustomizedProduct information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when the CustomizedProduct could not be found.</exception> public GetCustomizedProductModelView addSlotToCustomizedProduct(AddSlotModelView addSlotModelView) { CustomizedProductRepository customizedProductRepository = PersistenceContext.repositories().createCustomizedProductRepository(); CustomizedProduct customizedProduct = customizedProductRepository.find(addSlotModelView.customizedProductId); if (customizedProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_CUSTOMIZED_PRODUCT_BY_ID, addSlotModelView.customizedProductId)); } checkUserToken(customizedProduct, addSlotModelView.userAuthToken); CustomizedDimensions customizedDimensions = CustomizedDimensionsModelViewService.fromModelView(addSlotModelView.slotDimensions); customizedProduct.addSlot(customizedDimensions); customizedProduct = customizedProductRepository.update(customizedProduct); return(CustomizedProductModelViewService.fromEntity(customizedProduct)); }
public void ensureCatalogueCollectionCantBeCreatedWithProductsNotInCustomizedProductCollection() { CustomizedProductCollection customizedProductCollection = new CustomizedProductCollection("Closets Spring 2019"); CustomizedProduct customizedProduct1 = buildCustomizedProduct("1234"); customizedProduct1.finalizeCustomization(); //!customized products added to collections need to be finished customizedProductCollection.addCustomizedProduct(customizedProduct1); CustomizedProduct customizedProduct2 = buildCustomizedProduct("1235"); List <CustomizedProduct> customizedProducts = new List <CustomizedProduct>() { customizedProduct1, customizedProduct2 }; Action createCatalogueCollection = () => new CatalogueCollection(customizedProductCollection, customizedProducts); Assert.Throws <ArgumentException>(createCatalogueCollection); }
/// <summary> /// Updates an instance of Slot. /// </summary> /// <param name="updateSlotModelView">Instance of UpdateSlotModelView.</param> /// <returns>Instance of GetCustomizedProductModelView with updated CustomizedProduct information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when the CustomizedProduct or the Slot could not be found.</exception> /// <exception cref="System.ArgumentException">Thrown when none of the CustomizedProduct's properties are updated.</exception> public GetCustomizedProductModelView updateSlot(UpdateSlotModelView updateSlotModelView) { CustomizedProductRepository customizedProductRepository = PersistenceContext.repositories().createCustomizedProductRepository(); CustomizedProduct customizedProduct = customizedProductRepository.find(updateSlotModelView.customizedProductId); if (customizedProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_CUSTOMIZED_PRODUCT_BY_ID, updateSlotModelView.customizedProductId)); } checkUserToken(customizedProduct, updateSlotModelView.userAuthToken); Slot slot = customizedProduct.slots.Where(s => s.Id == updateSlotModelView.slotId).SingleOrDefault(); if (slot == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_SLOT, updateSlotModelView.slotId)); } bool performedAtLeastOneUpdate = false; if (updateSlotModelView.dimensions != null) { CustomizedDimensions updatedDimensions = CustomizedDimensionsModelViewService.fromModelView(updateSlotModelView.dimensions); customizedProduct.resizeSlot(slot, updatedDimensions); performedAtLeastOneUpdate = true; } if (!performedAtLeastOneUpdate) { throw new ArgumentException(ERROR_NO_UPDATE_PERFORMED); } customizedProduct = customizedProductRepository.update(customizedProduct); return(CustomizedProductModelViewService.fromEntity(customizedProduct)); }
public void ensureApplyRemovesDiscreteDimensions() { Color color = Color.valueOf("Durpa", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 35); Material material = new Material("#12", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 110.0, 150.0 })); DiscreteDimensionInterval discrete2 = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 150.0, 150.0 })); Measurement measurement = new Measurement(new SingleValueDimension(200), discrete, new SingleValueDimension(50)); Measurement measurement2 = new Measurement(new SingleValueDimension(200), discrete2, new SingleValueDimension(50)); List <Measurement> measurements = new List <Measurement>() { measurement }; List <Measurement> measurements2 = new List <Measurement>() { measurement2 }; Product component = new Product("#10", "Pandora of Provable Existence: Forbidden Cubicle", "10.gltf", cat, new List <Material>(new[] { material }), measurements2); Product product = new Product("#9", "Pandora of Eternal Return: Pandora's Box", "9.fbx", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 110, 50); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.9"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); Assert.Null(algorithm.apply(custom, component)); }
public void ensureApplyRemovesValuesFromDiscreteDimensions() { Color color = Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 20); Material material = new Material("#24", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 90.0, 100.0, 150.0 })); Measurement measurement = new Measurement(new SingleValueDimension(200), discrete, new SingleValueDimension(50)); List <Measurement> measurements = new List <Measurement>() { measurement }; Product component = new Product("#13", "Mother Goose of Diffractive Recitavo: Diffraction Mother Goose", "13.glb", cat, new List <Material>(new[] { material }), measurements); Product product = new Product("#12", "Mother Goose of Mutual Recursion: Recursive Mother Goose ", "12.fbx", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 100, 50); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.9"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); Product alteredProduct = algorithm.apply(custom, component); DiscreteDimensionInterval discreteDimension = (DiscreteDimensionInterval)alteredProduct.productMeasurements[0].measurement.width; DiscreteDimensionInterval expected = new DiscreteDimensionInterval(new List <double>(new[] { 90.0, 100.0 })); Assert.True(discreteDimension.Equals(expected)); }
/// <summary> /// Adds a CustomizedProduct to the CatalogueCollection. /// </summary> /// <param name="addCatalogueCollectionProductModelView">AddCatalogueCollectionProductModelView with the data used </param> /// <returns></returns> /// <exception cref="ResourceNotFoundException"> /// Thrown when no instance of CommercialCatalogue or CatalogueCollection could be found with the provided identifiers. /// </exception> /// <exception cref="System.ArgumentException"> /// Thrown when the CustomizedProduct being added does not exist in a given CustomizedProductCollection. /// </exception> public GetCommercialCatalogueModelView addCatalogueCollectionProduct(AddCatalogueCollectionProductModelView addCatalogueCollectionProductModelView) { CommercialCatalogueRepository catalogueRepository = PersistenceContext.repositories().createCommercialCatalogueRepository(); CommercialCatalogue commercialCatalogue = catalogueRepository.find(addCatalogueCollectionProductModelView.commercialCatalogueId); if (commercialCatalogue == null) { throw new ResourceNotFoundException(string.Format(CATALOGUE_NOT_FOUND_BY_ID, addCatalogueCollectionProductModelView.commercialCatalogueId)); } CatalogueCollection catalogueCollection = commercialCatalogue.catalogueCollectionList .Where(cc => cc.customizedProductCollectionId == addCatalogueCollectionProductModelView.customizedProductCollectionId).SingleOrDefault(); if (catalogueCollection == null) { throw new ResourceNotFoundException(string.Format( CATALOGUE_COLLECTION_NOT_FOUND_BY_ID, addCatalogueCollectionProductModelView.commercialCatalogueId, addCatalogueCollectionProductModelView.customizedProductCollectionId) ); } //retrieve the instance of CustomizedProduct from the the CustomizedProductCollection linked to the CatalogueCollection CustomizedProduct customizedProduct = catalogueCollection.customizedProductCollection.collectionProducts .Where(cp => cp.customizedProductId == addCatalogueCollectionProductModelView.customizedProductId) .Select(cp => cp.customizedProduct).SingleOrDefault(); if (customizedProduct == null) { throw new ArgumentException(string.Format( CUSTOMIZED_PRODUCT_NOT_FOUND_BY_ID, addCatalogueCollectionProductModelView.customizedProductId, addCatalogueCollectionProductModelView.customizedProductCollectionId )); } catalogueCollection.addCustomizedProduct(customizedProduct); commercialCatalogue = catalogueRepository.update(commercialCatalogue); return(CommercialCatalogueModelViewService.fromEntity(commercialCatalogue)); }
public void ensureApplyChangesContinuousDimensionsLimits() { Color color = Color.valueOf("Open the Missing Link", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 20); Material material = new Material("#12", "K6205", "12.png", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); ContinuousDimensionInterval continuous = new ContinuousDimensionInterval(50.0, 150.0, 20.0); Measurement measurement = new Measurement(new SingleValueDimension(200), continuous, new SingleValueDimension(50)); List <Measurement> measurements = new List <Measurement>() { measurement }; Product component = new Product("#19", "Altair of the Cyclic Coordinate: Time-leap Machine", "19.glb", cat, new List <Material>(new[] { material }), measurements); Product product = new Product("#18", "Altair of Translational Symmetry: Translational Symmetry", "18.glb", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 100, 50); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.9"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); Product alteredProduct = algorithm.apply(custom, component); Assert.True(alteredProduct.productMeasurements[0].measurement.width.getMinValue() == 90); Assert.True(alteredProduct.productMeasurements[0].measurement.width.getMaxValue() == 100); Assert.True(((ContinuousDimensionInterval)alteredProduct.productMeasurements[0].measurement.width).increment == 10); }
public void ensureApplyFailsIfAlgorithmNotReady() { Color color = Color.valueOf("Open the Steins Gate", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 15); Material material = new Material("#12", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); ContinuousDimensionInterval continuous1 = new ContinuousDimensionInterval(110.0, 150.0, 2.0); ContinuousDimensionInterval continuous2 = new ContinuousDimensionInterval(50.0, 80.0, 2.0); Measurement measurement1 = new Measurement(continuous1, continuous1, continuous1); Measurement measurement2 = new Measurement(continuous2, continuous2, continuous2); ContinuousDimensionInterval continuous3 = new ContinuousDimensionInterval(35.0, 45.0, 1.0); ContinuousDimensionInterval continuous4 = new ContinuousDimensionInterval(10.0, 20.0, 2.0); Measurement measurement3 = new Measurement(continuous3, continuous3, continuous3); Measurement measurement4 = new Measurement(continuous4, continuous4, continuous4); List <Measurement> measurements = new List <Measurement>() { measurement1, measurement2 }; List <Measurement> measurements2 = new List <Measurement>() { measurement3, measurement4 }; Product component = new Product("#5", "Solitude of the Astigmatism: Entangled Sheep", "5.glb", cat, new List <Material>(new[] { material }), measurements2); Product product = new Product("#4", "Solitude of the Mournful Flow: A Stray Sheep", "4.gltf", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(110, 110, 110); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Action action = () => algorithm.apply(custom, component); Assert.Throws <ArgumentNullException>(action); }
/// <summary> /// Updates a customized product collection by adding a new customized product to it /// </summary> /// <param name="modelView">model view with the necessary update information</param> /// <returns>Updated customized product collection or throws an exception if an error occurs</returns> public static CustomizedProductCollection update(AddCustomizedProductToCustomizedProductCollectionModelView modelView) { CustomizedProductCollectionRepository customizedProductCollectionRepository = PersistenceContext.repositories() .createCustomizedProductCollectionRepository(); CustomizedProductCollection customizedProductCollection = customizedProductCollectionRepository.find(modelView.customizedProductCollectionId); checkIfCustomizedProductCollectionWasFound( customizedProductCollection, modelView.customizedProductCollectionId ); CustomizedProduct customizedProduct = PersistenceContext.repositories() .createCustomizedProductRepository() .find(modelView.customizedProductId); if (customizedProduct == null) { throw new ArgumentException( string.Format( UNABLE_TO_FIND_CUSTOMIZED_PRODUCT, modelView.customizedProductId) ); } customizedProductCollection.addCustomizedProduct(customizedProduct); CustomizedProductCollection updatedCustomizedProductCollection = customizedProductCollectionRepository.update(customizedProductCollection); checkIfUpdatedCustomizedProductCollectionWasSaved( updatedCustomizedProductCollection, modelView.customizedProductCollectionId ); return(updatedCustomizedProductCollection); }
public void ensureApplyCondensesDiscreteDimensions() { Color color = Color.valueOf("Silver", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 20); Material material = new Material("#12", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 100.0, 150.0 })); Measurement measurement = new Measurement(new SingleValueDimension(200), discrete, new SingleValueDimension(50)); List <Measurement> measurements = new List <Measurement>() { measurement }; Product component = new Product("#21", "Rinascimento of Image Formation: Return of Phoenix", "21.glb", cat, new List <Material>(new[] { material }), measurements); Product product = new Product("#20", "Rinascimento of the Unwavering Promise: Promised Rinascimento", "20.gltf", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 100, 50); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("1235", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.9"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); Product alteredProduct = algorithm.apply(custom, component); Assert.True(alteredProduct.productMeasurements[0].measurement.width.GetType() == typeof(SingleValueDimension)); Assert.True(((SingleValueDimension)alteredProduct.productMeasurements[0].measurement.width).value == 100); }
/// <summary> /// Retrieves all possible components for a certain slot of a customized product /// </summary> /// <param name="customizedProductID">customized product to base restrictions on</param> /// <param name="slotID">selected slot</param> /// <returns>possible components for selected slot</returns> public GetPossibleComponentsModelView fetchPossibleComponents(FindPossibleComponentsModelView findComponentsMV) { CustomizedProductRepository customizedProductRepository = PersistenceContext.repositories().createCustomizedProductRepository(); CustomizedProduct customizedProduct = customizedProductRepository.find(findComponentsMV.customizedProductID); if (customizedProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_CUSTOMIZED_PRODUCT_BY_ID, findComponentsMV.customizedProductID)); } Slot slot = customizedProduct.slots.Where(s => s.Id == findComponentsMV.slotID).SingleOrDefault(); if (slot == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_SLOT, findComponentsMV.slotID)); } List <Product> restrictedProducts = (List <Product>)customizedProduct.product.getRestrictedComponents(customizedProduct, slot); if (Collections.isEnumerableNullOrEmpty(restrictedProducts)) { throw new InvalidOperationException(NO_POSSIBLE_COMPONENTS); } return(ProductModelViewService.possibleComponentsFromCollection(restrictedProducts)); }
public void ensureApplyCondensesContinuousDimensions() { Color color = Color.valueOf("Open the Steins Gate", 100, 100, 100, 100); Finish finish = Finish.valueOf("der alte wurfelt nicht", 45); Material material = new Material("#12", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish })); ProductCategory cat = new ProductCategory("AI"); ContinuousDimensionInterval continuous = new ContinuousDimensionInterval(100.0, 150.0, 2.0); Measurement measurement = new Measurement(new SingleValueDimension(200), continuous, new SingleValueDimension(50)); List <Measurement> measurements = new List <Measurement>() { measurement }; Product component = new Product("#5", "Solitude of the Astigmatism: Entangled Sheep", "5.gltf", cat, new List <Material>(new[] { material }), measurements); Product product = new Product("#4", "Solitude of the Mournful Flow: A Stray Sheep", "4.fbx", cat, new List <Material>(new[] { material }), measurements, new List <Product>() { component }); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 100, 50); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build(); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.9"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); Product alteredProduct = algorithm.apply(custom, component); Assert.True(alteredProduct.productMeasurements[0].measurement.width.GetType() == typeof(SingleValueDimension)); Assert.True(((SingleValueDimension)alteredProduct.productMeasurements[0].measurement.width).value == 100); }
/// <summary> /// Transforms a customized product dto into a customized product via service /// </summary> /// <param name="customizedProductDTO">CustomizedProductDTO with the customized product dto being transformed</param> /// <returns>CustomizedProduct with the of customized products transformed from the dto</returns> public static CustomizedProduct transform(CustomizedProductDTO customizedProductDTO) { CustomizedProduct customizedProduct = null; string reference = customizedProductDTO.reference; string designation = customizedProductDTO.designation; //Fetch the product associated to this customized product by its id long productId = customizedProductDTO.productDTO.id; Product product = PersistenceContext.repositories().createProductRepository().find(productId); //Fetch the material associated to the customized material long materialId = customizedProductDTO.customizedMaterialDTO.material.id; Material material = PersistenceContext.repositories().createMaterialRepository().find(materialId); Finish customizedFinish = customizedProductDTO.customizedMaterialDTO.finish.toEntity(); Color customizedColor = customizedProductDTO.customizedMaterialDTO.color.toEntity(); CustomizedDimensions customizedDimensions = customizedProductDTO.customizedDimensionsDTO.toEntity(); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, customizedColor, customizedFinish); //check if the dto contains slot information /* if (customizedProductDTO.slotListDTO == null) * { * customizedProduct = new CustomizedProduct(reference, designation, customizedMaterial, customizedDimensions, product); * } * else * { * //if the dto contains slot info, then create one with slots * List<Slot> slots = new SlotDTOService().transform(customizedProductDTO.slotListDTO).ToList(); * customizedProduct = new CustomizedProduct(reference, designation, customizedMaterial, customizedDimensions, product, slots); * } */ return(customizedProduct); }
/// <summary> /// Builds a CustomizedProductPriceModelView out of a Customized Product /// </summary> /// <param name="customizedProduct">Customized Product to build the model view out of</param> /// <param name="fetchCustomizedProductPriceModelView">ModelView to know if currency/area conversion is needed</param> /// <returns>CustomizedProductPriceModelView</returns> private static async Task <CustomizedProductPriceModelView> buildCustomizedProductPriceModelView(CustomizedProduct customizedProduct, FetchCustomizedProductPriceModelView fetchCustomizedProductPriceModelView, MaterialPriceTableEntry materialPriceTableEntry, FinishPriceTableEntry finishPriceTableEntry, IHttpClientFactory clientFactory) { CustomizedProductPriceModelView customizedProductPriceModelView = new CustomizedProductPriceModelView(); string defaultCurrency = CurrencyPerAreaConversionService.getBaseCurrency(); string defaultArea = CurrencyPerAreaConversionService.getBaseArea(); bool convertCurrencyPerArea = fetchCustomizedProductPriceModelView.currency != null && fetchCustomizedProductPriceModelView.area != null; customizedProductPriceModelView.customizedProductId = customizedProduct.Id; customizedProductPriceModelView.reference = customizedProduct.reference; customizedProductPriceModelView.productId = customizedProduct.product.Id; string requestedMeasurementUnit = null; if (convertCurrencyPerArea) { requestedMeasurementUnit = new String(fetchCustomizedProductPriceModelView.area.Where(c => Char.IsLetter(c)).ToArray()); } else { requestedMeasurementUnit = new String(CurrencyPerAreaConversionService.getBaseArea().Where(c => Char.IsLetter(c)).ToArray()); } customizedProductPriceModelView.customizedDimensions = new GetCustomizedDimensionsModelView(); customizedProductPriceModelView.customizedDimensions.unit = requestedMeasurementUnit; customizedProductPriceModelView.customizedDimensions.width = MeasurementUnitService.convertToUnit(customizedProduct.customizedDimensions.width, requestedMeasurementUnit); customizedProductPriceModelView.customizedDimensions.height = MeasurementUnitService.convertToUnit(customizedProduct.customizedDimensions.height, requestedMeasurementUnit); customizedProductPriceModelView.customizedDimensions.depth = MeasurementUnitService.convertToUnit(customizedProduct.customizedDimensions.depth, requestedMeasurementUnit); customizedProductPriceModelView.customizedMaterial = new CustomizedMaterialPriceModelView(); customizedProductPriceModelView.customizedMaterial.customizedMaterialId = customizedProduct.customizedMaterial.Id; customizedProductPriceModelView.customizedMaterial.materialId = customizedProduct.customizedMaterial.material.Id; if (customizedProduct.customizedMaterial.finish != null) { customizedProductPriceModelView.customizedMaterial.finish = new FinishPriceModelView(); customizedProductPriceModelView.customizedMaterial.finish.finishId = customizedProduct.customizedMaterial.finish.Id; customizedProductPriceModelView.customizedMaterial.finish.description = customizedProduct.customizedMaterial.finish.description; customizedProductPriceModelView.customizedMaterial.finish.shininess = customizedProduct.customizedMaterial.finish.shininess; customizedProductPriceModelView.customizedMaterial.finish.price = new PriceModelView(); if (convertCurrencyPerArea) { customizedProductPriceModelView.customizedMaterial.finish.price.currency = fetchCustomizedProductPriceModelView.currency; customizedProductPriceModelView.customizedMaterial.finish.price.area = fetchCustomizedProductPriceModelView.area; customizedProductPriceModelView.customizedMaterial.finish.price.value = await convertPriceValue( finishPriceTableEntry.price.value, fetchCustomizedProductPriceModelView.currency, fetchCustomizedProductPriceModelView.area, clientFactory ); } else { customizedProductPriceModelView.customizedMaterial.finish.price.currency = defaultCurrency; customizedProductPriceModelView.customizedMaterial.finish.price.area = defaultArea; customizedProductPriceModelView.customizedMaterial.finish.price.value = finishPriceTableEntry.price.value; } } if (customizedProduct.customizedMaterial.color != null) { customizedProductPriceModelView.customizedMaterial.color = ColorModelViewService.fromEntity(customizedProduct.customizedMaterial.color); } customizedProductPriceModelView.customizedMaterial.price = new PriceModelView(); if (convertCurrencyPerArea) { customizedProductPriceModelView.customizedMaterial.price.currency = fetchCustomizedProductPriceModelView.currency; customizedProductPriceModelView.customizedMaterial.price.area = fetchCustomizedProductPriceModelView.area; customizedProductPriceModelView.customizedMaterial.price.value = await convertPriceValue( materialPriceTableEntry.price.value, fetchCustomizedProductPriceModelView.currency, fetchCustomizedProductPriceModelView.area, clientFactory ); } else { customizedProductPriceModelView.customizedMaterial.price.currency = defaultCurrency; customizedProductPriceModelView.customizedMaterial.price.area = defaultArea; customizedProductPriceModelView.customizedMaterial.price.value = materialPriceTableEntry.price.value; } customizedProductPriceModelView.price = new PriceModelView(); customizedProductPriceModelView.totalArea = new AreaModelView(); if (convertCurrencyPerArea) { customizedProductPriceModelView.price.currency = fetchCustomizedProductPriceModelView.currency; customizedProductPriceModelView.totalArea.area = fetchCustomizedProductPriceModelView.area; } else { customizedProductPriceModelView.price.currency = defaultCurrency; customizedProductPriceModelView.totalArea.area = defaultArea; } calculateTotalAreaAndPriceOfCustomizedMaterial(customizedProductPriceModelView, customizedProduct); return(customizedProductPriceModelView); }
/// <summary> /// Calculates the price of all child customized products of a given customized product /// </summary> /// <param name="customizedProduct">Parent Customized Product</param> /// <param name="fetchCustomizedProductPrice">Information about currency/area conversion</param> /// <param name="materialPriceTableRepository">MaterialPriceTableRepository instance to fetch current material prices</param> /// <param name="finishPriceTableRepository">FinishPriceTableRepository instance to fetch current finish prices</param> /// <param name="clientFactory">Injected HTTP Client Factory</param> /// <returns>IEnumerable containing the prices of all child customized products</returns> private static async Task <IEnumerable <CustomizedProductPriceModelView> > calculatePricesOfChildCustomizedProducts(List <CustomizedProductPriceModelView> childCustomizedProductPrices, CustomizedProduct customizedProduct, FetchCustomizedProductPriceModelView fetchCustomizedProductPrice, MaterialPriceTableRepository materialPriceTableRepository, FinishPriceTableRepository finishPriceTableRepository, IHttpClientFactory clientFactory) { foreach (Slot slot in customizedProduct.slots) { foreach (CustomizedProduct childCustomizedProduct in slot.customizedProducts) { MaterialPriceTableEntry materialPriceTableEntry = getCurrentMaterialPrice(materialPriceTableRepository, childCustomizedProduct.customizedMaterial.material.Id); FinishPriceTableEntry finishPriceTableEntry = null; if (childCustomizedProduct.customizedMaterial.finish != null) { finishPriceTableEntry = getCurrentFinishPrice(finishPriceTableRepository, childCustomizedProduct.customizedMaterial.material.Finishes.Where(f => f.Equals(childCustomizedProduct.customizedMaterial.finish)).SingleOrDefault().Id); } CustomizedProductPriceModelView childCustomizedProductPriceModelView = await buildCustomizedProductPriceModelView(childCustomizedProduct, fetchCustomizedProductPrice, materialPriceTableEntry, finishPriceTableEntry, clientFactory); childCustomizedProductPrices.Add(childCustomizedProductPriceModelView); if (childCustomizedProduct.hasCustomizedProducts()) { await calculatePricesOfChildCustomizedProducts(childCustomizedProductPrices, childCustomizedProduct, fetchCustomizedProductPrice, materialPriceTableRepository, finishPriceTableRepository, clientFactory); } } } return(childCustomizedProductPrices); }
public void ensureApplyAllRestrictionsReturnsRestrictedProduct() { ProductCategory cat = new ProductCategory("All Products"); Color black = Color.valueOf("Deep Black", 0, 0, 0, 0); Color white = Color.valueOf("Blinding White", 255, 255, 255, 0); List <Color> colors = new List <Color>() { black, white }; Finish glossy = Finish.valueOf("Glossy", 100); Finish matte = Finish.valueOf("Matte", 0); List <Finish> finishes = new List <Finish>() { glossy, matte }; Material material = new Material("#001", "Really Expensive Wood", "ola.jpg", colors, finishes); Material material2 = new Material("#002", "Expensive Wood", "ola.jpg", colors, finishes); Dimension heightDimension = new SingleValueDimension(50); Dimension widthDimension = new DiscreteDimensionInterval(new List <double>() { 60, 65, 70, 80, 90, 105 }); Dimension depthDimension = new ContinuousDimensionInterval(10, 25, 5); Measurement measurement = new Measurement(heightDimension, widthDimension, depthDimension); Product product = new Product("Test", "Shelf", "shelf.glb", cat, new List <Material>() { material, material2 }, new List <Measurement>() { measurement }, ProductSlotWidths.valueOf(4, 4, 4)); Product product2 = new Product("Test", "Shelf", "shelf.glb", cat, new List <Material>() { material, material2 }, new List <Measurement>() { measurement }, ProductSlotWidths.valueOf(4, 4, 4)); CustomizedDimensions customDimension = CustomizedDimensions.valueOf(50, 80, 25); CustomizedMaterial customMaterial = CustomizedMaterial.valueOf(material, white, matte); CustomizedProduct customizedProduct = CustomizedProductBuilder.createCustomizedProduct("reference", product, customDimension).build(); customizedProduct.changeCustomizedMaterial(customMaterial); customizedProduct.finalizeCustomization(); RestrictableImpl instance = new RestrictableImpl(); instance.addRestriction(new Restriction("same material", new SameMaterialAndFinishAlgorithm())); WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm(); Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1"); Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1"); Dictionary <Input, string> inputs = new Dictionary <Input, string>(); inputs.Add(minInput, "0.8"); inputs.Add(maxInput, "1.0"); algorithm.setInputValues(inputs); instance.addRestriction(new Restriction("width percentage", algorithm)); Product returned = instance.applyAllRestrictions(customizedProduct, product2); Assert.True(returned.productMaterials.Count == 1); Assert.True(returned.productMaterials[0].material.Equals(material)); Assert.True(returned.productMeasurements[0].measurement.width.getMinValue() == 65); Assert.True(returned.productMeasurements[0].measurement.width.getMaxValue() == 80); }
public void ensureObjectIsNotCreatedForNullCatalogueCollection() { Color color = Color.valueOf("Somebody", 1, 2, 3, 4); List <Color> colors = new List <Color>(); colors.Add(color); Finish finish = Finish.valueOf("once", 1); List <Finish> finishes = new List <Finish>(); finishes.Add(finish); List <Double> values = new List <Double>(); values.Add(500.0); Material material = new Material("told", "me", "ola.jpg", colors, finishes); List <Material> materialList = new List <Material>(); materialList.Add(material); ProductCategory productCategory = new ProductCategory("the"); Dimension heightDimension = new SingleValueDimension(21); Dimension widthDimension = new SingleValueDimension(30); Dimension depthDimension = new SingleValueDimension(17); Measurement measurement = new Measurement(heightDimension, widthDimension, depthDimension); List <Measurement> measurements = new List <Measurement>() { measurement }; IEnumerable <Material> materialEnumerable = materialList; Product product = new Product("world", "is", "world.glb", productCategory, materialEnumerable, measurements); CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish); CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(21, 30, 17); CustomizedProduct customizedProduct = CustomizedProductBuilder .createCustomizedProduct("reference", product, customizedDimensions) .withMaterial(customizedMaterial).build(); customizedProduct.finalizeCustomization(); List <CustomizedProduct> customizedProductList = new List <CustomizedProduct>(); customizedProductList.Add(customizedProduct); CustomizedProductCollection customizedProductCollection = new CustomizedProductCollection("me", customizedProductList); List <CustomizedProductCollection> collectionList = new List <CustomizedProductCollection>(); collectionList.Add(customizedProductCollection); CatalogueCollection catalogueCollection = new CatalogueCollection(customizedProductCollection, customizedProductList); List <CatalogueCollection> catalogueCollectionList = new List <CatalogueCollection>(); catalogueCollectionList.Add(catalogueCollection); CommercialCatalogue commercialCatalogue = new CommercialCatalogue("I", "ain't", catalogueCollectionList); Assert.Throws <ArgumentException>(() => new CommercialCatalogueCatalogueCollection(commercialCatalogue, null)); }
public static void FillWithData(EntityDataModel model) { // allergens var meat = new Allergen() { Title = "Meat", Description = "Dangerous to vegans" }; var gluten = new Allergen() { Title = "Gluten", Description = "Dangerous to sensitive people" }; var cheese = new Allergen() { Title = "Cheese", Description = "Dangerous diary product" }; var corn = new Allergen() { Title = "Corn", Description = "Dangerous diary product" }; // product categories var pizzaCategory = new ProductCategory() { Name = "Pizza" }; var burgerCategory = new ProductCategory() { Name = "Burger" }; // topping categories var doughCategory = new ToppingCategory() { Title = "Dough", Prompt = "Please select exactly one dough", CategorySelection = CategorySelection.Single, Obligation = Obligation.Obligatory, ProductCategory = pizzaCategory, }; var extrasPizzaCategory = new ToppingCategory() { Title = "Extras", Prompt = "Please select an extra topping for your pizza", CategorySelection = CategorySelection.Multiple, Obligation = Obligation.Optional, ProductCategory = pizzaCategory, }; var extrasBurgerCategory = new ToppingCategory() { Title = "Extras", Prompt = "Please select an extra topping for your burger", CategorySelection = CategorySelection.Multiple, Obligation = Obligation.Optional, ProductCategory = burgerCategory, }; // toppings var salami = new Topping() { Title = "Salami", PrepareTime = TimeSpan.FromSeconds(10), ToppingCategory = extrasPizzaCategory, Price = 2, Allergens = new List <Allergen> { meat, gluten } }; var patty = new Topping() { Title = "Grilled Patty", PrepareTime = TimeSpan.FromSeconds(130), ToppingCategory = extrasBurgerCategory, Price = 11, Allergens = new List <Allergen> { meat } }; var thinDough = new Topping() { Title = "Thin dough", PrepareTime = TimeSpan.FromSeconds(480), ToppingCategory = doughCategory, Price = 8, Allergens = new List <Allergen> { gluten } }; var thickDough = new Topping() { Title = "Thick dough", PrepareTime = TimeSpan.FromSeconds(590), ToppingCategory = doughCategory, Price = 13, Allergens = new List <Allergen> { gluten } }; // products var margheritta = new Product() { Title = "Margheritta Pizza Italiano", Allergens = new List <Allergen> { cheese, gluten }, BasePrice = 10, Description = "Delicious and original italian pizza", PrepareTime = TimeSpan.FromSeconds(110), ProductCategory = pizzaCategory, }; var hawaii = new Product() { Title = "Hawaii Pizza", Allergens = new List <Allergen> { corn }, BasePrice = 13, Description = "Astonishing hawaii pizza with a twist", PrepareTime = TimeSpan.FromSeconds(140), ProductCategory = pizzaCategory, }; var cheeseBurger = new Product() { Title = "Cheese Burger", Allergens = new List <Allergen> { }, BasePrice = 5, Description = "Large burger with cheese", PrepareTime = TimeSpan.FromSeconds(55), ProductCategory = burgerCategory, }; // customers var pocztaPolska = new Customer() { Name = "Poczta Polska", Address = "Centrum 123", Email = "*****@*****.**", Telephone = "123 456 789" }; var google = new Customer() { Name = "Google Polska", Address = "Koszykowa 55555", Email = "*****@*****.**", Telephone = "999 888 777" }; var ted = new Customer() { Name = "TED Polska", Address = "Hoża tedowska", Email = "*****@*****.**", Telephone = "+48 999-444-312" }; // employee categories var chefCategory = new EmployeeCategory() { Title = "Chef" }; var deliverymanCategory = new EmployeeCategory() { Title = "Deliveryman" }; // intervals var monday = new TimeInterval() { From = DateTime.Parse("13/11/2017 8:00"), To = DateTime.Parse("13/11/2017 18:00"), }; var wednesday = new TimeInterval() { From = DateTime.Parse("15/11/2017 10:00"), To = DateTime.Parse("15/11/2017 19:00"), }; var thursday = new TimeInterval() { From = DateTime.Parse("16/11/2017 6:00"), To = DateTime.Parse("16/11/2017 12:00"), }; // employees var chef1 = new Employee() { Address = "Mieszkalna 123", BirthDate = DateTime.Parse("10/10/1950"), Category = chefCategory, Email = "*****@*****.**", Name = "John Smith", Salary = 1234500, Telephone = "123-125-865", ProductCategoryCompetency = new List <ProductCategory> { pizzaCategory }, AvailableIntervals = new List <TimeInterval> { monday, wednesday, thursday } }; var chef2 = new Employee() { Address = "Wypiekalna 123", BirthDate = DateTime.Parse("10/10/1980"), Category = chefCategory, Email = "*****@*****.**", Name = "Adam Bezier", Salary = 4624500, Telephone = "437-355-124", ProductCategoryCompetency = new List <ProductCategory> { pizzaCategory, burgerCategory }, AvailableIntervals = new List <TimeInterval> { monday, thursday } }; var deliveryman1 = new Employee() { Address = "Dostarczalna 3", BirthDate = DateTime.Parse("10/10/1990"), Category = deliverymanCategory, Email = "*****@*****.**", Name = "Alfred Courier", Salary = 1224500, Telephone = "214-514-243", AvailableIntervals = new List <TimeInterval> { monday, wednesday, thursday } }; // customized products var customHawaii = new CustomizedProduct() { BaseProduct = hawaii, CustomerWish = "mniej ananasów poproszę", Toppings = new List <Topping> { thinDough, salami }, }; var customBurger1 = new CustomizedProduct() { BaseProduct = cheeseBurger, CustomerWish = "mniej tłuszczu poproszę", Toppings = new List <Topping> { patty }, }; var customBurger2 = new CustomizedProduct() { BaseProduct = cheeseBurger, CustomerWish = "więcej tłuszczu poproszę", Toppings = new List <Topping> { patty }, }; // orders var order1 = new Order() { Chef = chef1, Deliveryman = deliveryman1, CookingDeadline = DateTime.Parse("15/11/2017 9:00"), CustomerWish = "Nie takie przypieczone", Customer = google, DeliveryDeadline = DateTime.Parse("15/11/2017 9:30"), OrderCreated = DateTime.Parse("2/11/2017 19:00"), OrderedProducts = new List <CustomizedProduct> { customHawaii, customBurger1 }, TotalPrice = 23 + 16, OrderStatus = OrderStatus.Pending, }; var order2 = new Order() { Chef = chef2, Deliveryman = deliveryman1, CookingDeadline = DateTime.Parse("15/11/2017 13:00"), CustomerWish = "Poproszę bez sera", Customer = pocztaPolska, DeliveryDeadline = DateTime.Parse("15/11/2017 13:30"), OrderCreated = DateTime.Parse("2/11/2017 14:00"), OrderedProducts = new List <CustomizedProduct> { customBurger2 }, TotalPrice = 16, OrderStatus = OrderStatus.Pending, }; model.Allergens.AddRange(new[] { meat, gluten, cheese }); model.ProductCategories.AddRange(new[] { pizzaCategory, burgerCategory }); model.ToppingCategories.AddRange(new[] { doughCategory, extrasPizzaCategory, extrasBurgerCategory }); model.Toppings.AddRange(new[] { salami, patty, thinDough, thickDough }); model.Products.AddRange(new[] { margheritta, hawaii, cheeseBurger }); model.Customers.AddRange(new[] { pocztaPolska, google, ted }); model.EmployeeCategories.AddRange(new[] { chefCategory, deliverymanCategory }); model.Employees.AddRange(new[] { chef1, chef2, deliveryman1 }); model.CustomizedProducts.AddRange(new[] { customHawaii, customBurger1, customBurger2 }); model.Orders.AddRange(new[] { order1, order2 }); model.SaveChanges(); }
/// <summary> /// Adds an instance of CustomizedProduct. /// </summary> /// <param name="addCustomizedProductModelView">AddCustomizedProductModelView containing the CustomizedProduct's information.</param> /// <returns>GetCustomizedProductModelView with the added CustomizedProduct's information.</returns> public GetCustomizedProductModelView addCustomizedProduct(AddCustomizedProductModelView addCustomizedProductModelView) { CustomizedProduct customizedProduct = CreateCustomizedProductService.create(addCustomizedProductModelView); return(CustomizedProductModelViewService.fromEntity(customizedProduct)); }
public OperationResult ChangeCustomizedProduct(CustomizedProduct oldCustomizedProduct, CustomizedProduct newCustomizedProduct) { var cp = CustomizedProductRepository.First(c => c.CustomizedProductId == oldCustomizedProduct.CustomizedProductId); cp.BaseProduct = newCustomizedProduct.BaseProduct; cp.Toppings = newCustomizedProduct.Toppings; cp.CustomerWish = newCustomizedProduct.CustomerWish; DatabaseContext.SaveChanges(); return(new OperationResult { IsSucceeded = true }); }
/// <summary> /// Updates an instance of CustomizedProduct with the data provided in the given UpdateCustomizedProductModelView. /// </summary> /// <param name="updateCustomizedProductModelView">Instance of UpdateCustomizedProductModelView containing updated CustomizedProduct information.</param> /// <returns>An instance of GetCustomizedProductModelView with the updated CustomizedProduct information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when the CustomizedProduct could not be found.</exception> /// <exception cref="System.ArgumentException">Thrown when none of the CustomizedProduct's properties are updated.</exception> public GetCustomizedProductModelView updateCustomizedProduct(UpdateCustomizedProductModelView updateCustomizedProductModelView) { CustomizedProductRepository customizedProductRepository = PersistenceContext.repositories().createCustomizedProductRepository(); CustomizedProduct customizedProduct = customizedProductRepository.find(updateCustomizedProductModelView.customizedProductId); if (customizedProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_CUSTOMIZED_PRODUCT_BY_ID, updateCustomizedProductModelView.customizedProductId)); } checkUserToken(customizedProduct, updateCustomizedProductModelView.userAuthToken); bool performedAtLeastOneUpdate = false; if (updateCustomizedProductModelView.reference != null) { customizedProduct.changeReference(updateCustomizedProductModelView.reference); performedAtLeastOneUpdate = true; } if (updateCustomizedProductModelView.designation != null) { customizedProduct.changeDesignation(updateCustomizedProductModelView.designation); performedAtLeastOneUpdate = true; } if (updateCustomizedProductModelView.customizedMaterial != null) { //TODO: check if only the finish or the color are being updated CustomizedMaterial customizedMaterial = CreateCustomizedMaterialService.create(updateCustomizedProductModelView.customizedMaterial); customizedProduct.changeCustomizedMaterial(customizedMaterial); performedAtLeastOneUpdate = true; } if (updateCustomizedProductModelView.customizedDimensions != null) { customizedProduct.changeDimensions(CustomizedDimensionsModelViewService.fromModelView(updateCustomizedProductModelView.customizedDimensions)); performedAtLeastOneUpdate = true; } if (updateCustomizedProductModelView.customizationStatus == CustomizationStatus.FINISHED) { customizedProduct.finalizeCustomization(); performedAtLeastOneUpdate = true; } if (!performedAtLeastOneUpdate) { throw new ArgumentException(ERROR_NO_UPDATE_PERFORMED); } customizedProduct = customizedProductRepository.update(customizedProduct); if (customizedProduct == null) { throw new ArgumentException(ERROR_UNABLE_TO_SAVE_CUSTOMIZED_PRODUCT); } return(CustomizedProductModelViewService.fromEntity(customizedProduct)); }
/// <summary> /// Applies the algorithm that restricts a component's width to a certain percentage of the customized father product's width /// </summary> /// <param name="customProduct">customized product</param> /// <param name="product">component product</param> /// <returns>component with restricted dimensions, null if the component is not compatible with any of the allowed dimensions</returns> public override Product apply(CustomizedProduct customProduct, Product originalProduct) { ready(); List <Material> materials = new List <Material>(); foreach (ProductMaterial productMaterial in originalProduct.productMaterials) { materials.Add(productMaterial.material); } List <Measurement> measurements = new List <Measurement>(); foreach (ProductMeasurement productMeasurement in originalProduct.productMeasurements) { measurements.Add(productMeasurement.measurement); } Product copyProduct = null; if (originalProduct.components.Any()) { List <Product> components = new List <Product>(); foreach (Component component in originalProduct.components) { components.Add(component.complementaryProduct); } copyProduct = new Product(originalProduct.reference, originalProduct.designation, originalProduct.modelFilename, originalProduct.productCategory, materials, measurements, components, originalProduct.slotWidths); } else { copyProduct = new Product(originalProduct.reference, originalProduct.designation, originalProduct.modelFilename, originalProduct.productCategory, materials, measurements, originalProduct.slotWidths); } double width = customProduct.customizedDimensions.width; double min = getMinPercentage(); if (min < 0) { throw new ArgumentException(MIN_PERCENTAGE_INVALID); } double max = getMaxPercentage(); if (max < 0) { throw new ArgumentException(MAX_PERCENTAGE_INVALID); } double minWidth = width * getMinPercentage(); double maxWidth = width * getMaxPercentage(); List <Measurement> measurementsToRemove = new List <Measurement>(); List <Measurement> productMeasurements = copyProduct.productMeasurements.Select(m => m.measurement).ToList(); foreach (Measurement measurement in productMeasurements) { Dimension dimension = measurement.width; if (dimension.GetType() == typeof(SingleValueDimension)) { SingleValueDimension single = (SingleValueDimension)dimension; if (single.value < minWidth || single.value > maxWidth) { measurementsToRemove.Add(measurement); } } else if (dimension.GetType() == typeof(DiscreteDimensionInterval)) { DiscreteDimensionInterval discrete = (DiscreteDimensionInterval)dimension; List <DoubleValue> valToRemove = new List <DoubleValue>(); foreach (double value in discrete.values) { if (value < minWidth || value > maxWidth) { valToRemove.Add(value); } } foreach (double val in valToRemove) { discrete.values.Remove(val); } if (discrete.values.Count == 0) { measurementsToRemove.Add(measurement); } else if (discrete.values.Count == 1) { measurement.changeWidthDimension(new SingleValueDimension(discrete.values[0])); } } else if (dimension.GetType() == typeof(ContinuousDimensionInterval)) { ContinuousDimensionInterval continuous = (ContinuousDimensionInterval)dimension; if (continuous.minValue > maxWidth || continuous.maxValue < minWidth) { measurementsToRemove.Add(measurement); } else { double currentMin = continuous.minValue, currentMax = continuous.maxValue; if (continuous.minValue < minWidth) { currentMin = minWidth; } if (continuous.maxValue > maxWidth) { currentMax = maxWidth; } if (currentMin == currentMax) { SingleValueDimension single = new SingleValueDimension(currentMax); measurement.changeWidthDimension(single); } else { double newIncrement = continuous.increment; if (currentMax - currentMin < continuous.increment) { newIncrement = currentMax - currentMin; } ContinuousDimensionInterval newContinuous = new ContinuousDimensionInterval(currentMin, currentMax, newIncrement); measurement.changeWidthDimension(newContinuous); } } } } foreach (Measurement measurement in measurementsToRemove) { try { copyProduct.removeMeasurement(measurement); } catch (InvalidOperationException) { return(null); } catch (ArgumentException) { return(null); } } return(copyProduct); }
/// <summary> /// Converts an instance of CustomizedProduct into an instance of GetCustomizedProductModelView. /// </summary> /// <param name="customizedProduct">Instance of CustomizedProduct being converted.</param> /// <returns>Instance of GetCustomizedProductModelView.</returns> /// <exception cref="System.ArgumentException">Thrown when the provided instance of CustomizedProduct is null.</exception> public static GetCustomizedProductModelView fromEntity(CustomizedProduct customizedProduct) { return(fromEntity(customizedProduct, MeasurementUnitService.getMinimumUnit())); }
public override Product apply(CustomizedProduct customProduct, Product product) { throw new NotImplementedException(); }
/// <summary> /// Calculates the surface area of material and material finish used in a customized product and it's respective prices /// </summary> /// <param name="customizedProductPriceModelView">ModelView of the customized product's price information</param> /// <param name="customizedProduct">Customized product whose price is being calculated</param> private static void calculateTotalAreaAndPriceOfCustomizedMaterial(CustomizedProductPriceModelView customizedProductPriceModelView, CustomizedProduct customizedProduct) { customizedProductPriceModelView.totalArea.value = calculateSurfaceAreaOfRightRectangularPrism( customizedProductPriceModelView.customizedDimensions.width, customizedProductPriceModelView.customizedDimensions.height, customizedProductPriceModelView.customizedDimensions.depth); customizedProductPriceModelView.price.value = calculateMaterialAndFinishPrice( customizedProductPriceModelView.totalArea.value, customizedProductPriceModelView.customizedMaterial ); }
/// <summary> /// Calculates the price /// </summary> /// <param name="fetchCustomizedProductPrice">FetchCustomizedProductModelView with the necessary information to fetch the customized product's price</param> /// <returns>CustomizedProductPriceModelView with the price of the customized product</returns> public static async Task <CustomizedProductFinalPriceModelView> calculatePrice(FetchCustomizedProductPriceModelView fetchCustomizedProductPrice, IHttpClientFactory clientFactory) { if (fetchCustomizedProductPrice.currency != null) { CurrenciesService.checkCurrencySupport(fetchCustomizedProductPrice.currency); } if (fetchCustomizedProductPrice.area != null) { AreasService.checkAreaSupport(fetchCustomizedProductPrice.area); } CustomizedProduct customizedProduct = PersistenceContext.repositories().createCustomizedProductRepository().find(fetchCustomizedProductPrice.id); if (customizedProduct == null) { throw new ResourceNotFoundException ( string.Format(CUSTOMIZED_PRODUCT_NOT_FOUND, fetchCustomizedProductPrice.id) ); } if (customizedProduct.status == CustomizationStatus.PENDING) { throw new ArgumentException ( CUSTOMIZED_PRODUCT_NOT_FINISHED ); } //TODO Should the fetching of prices of customized products that aren't base products be allowed? MaterialPriceTableRepository materialPriceTableRepository = PersistenceContext.repositories().createMaterialPriceTableRepository(); FinishPriceTableRepository finishPriceTableRepository = PersistenceContext.repositories().createFinishPriceTableRepository(); CustomizedProductFinalPriceModelView customizedProductTotalPrice = new CustomizedProductFinalPriceModelView(); List <CustomizedProductPriceModelView> customizedProductPriceList = new List <CustomizedProductPriceModelView>(); MaterialPriceTableEntry materialPriceTableEntry = getCurrentMaterialPrice(materialPriceTableRepository, customizedProduct.customizedMaterial.material.Id); FinishPriceTableEntry finishPriceTableEntry = null; if (customizedProduct.customizedMaterial.finish != null) { finishPriceTableEntry = getCurrentFinishPrice(finishPriceTableRepository, customizedProduct.customizedMaterial.material.Finishes.Where(f => f.Equals(customizedProduct.customizedMaterial.finish)).SingleOrDefault().Id); } //TODO What should we do about doors? //TODO Should we consider that every component has a box geometry? //!For now the surface area of every product is being calculated as if it the product was a SIX FACED RIGHT RECTANGULAR PRISM CustomizedProductPriceModelView parentCustomizedProductModelView = await buildCustomizedProductPriceModelView(customizedProduct, fetchCustomizedProductPrice, materialPriceTableEntry, finishPriceTableEntry, clientFactory); customizedProductPriceList.Add(parentCustomizedProductModelView); if (customizedProduct.hasCustomizedProducts()) { List <CustomizedProductPriceModelView> childCustomizedProducts = new List <CustomizedProductPriceModelView>(); customizedProductPriceList.AddRange(await calculatePricesOfChildCustomizedProducts(childCustomizedProducts, customizedProduct, fetchCustomizedProductPrice, materialPriceTableRepository, finishPriceTableRepository, clientFactory)); } customizedProductTotalPrice.customizedProducts = customizedProductPriceList; customizedProductTotalPrice.finalPrice = calculateFinalPriceOfCustomizedProduct(customizedProductTotalPrice, fetchCustomizedProductPrice); return(customizedProductTotalPrice); }
/// <summary> /// Transforms a CommercialCatalogueDTO into a CommercialCatalogue. /// </summary> /// <param name="commercialCatalogueDTO">CommercialCatalogueDTO with the CommercialCatalogue data.</param> /// <returns>Transformed CommercialCatalogue built with CommercialCatalogueDTO info.</returns> public static CommercialCatalogue transform(CommercialCatalogueDTO commercialCatalogueDTO) { string reference = commercialCatalogueDTO.reference; string designation = commercialCatalogueDTO.designation; CommercialCatalogue newComCatalogue = null; //if no collections are specified, build a catalogue with just the given reference and designation. if (commercialCatalogueDTO.catalogueCollectionDTOs != null) { CustomizedProductCollectionRepository collectionRepository = PersistenceContext.repositories().createCustomizedProductCollectionRepository(); CustomizedProductRepository customizedProductRepository = PersistenceContext.repositories().createCustomizedProductRepository(); //the specified collections should have id's and not the whole collection information List <CatalogueCollection> catalogueCollections = new List <CatalogueCollection>(); foreach (CatalogueCollectionDTO collectionDTO in commercialCatalogueDTO.catalogueCollectionDTOs) { CatalogueCollection catalogueCollection = null; CustomizedProductCollection collection = collectionRepository.find(collectionDTO.customizedProductCollectionDTO.id); //the collection was not found if (collection == null) { throw new ArgumentException(ERROR_CUSTOMIZED_PRODUCT_COLLECTION_NOT_FOUND); } //if no products are specified, then add all contained in the collection if (collectionDTO.customizedProductDTOs == null) { catalogueCollection = new CatalogueCollection(collection); } else { List <CustomizedProduct> customizedProducts = new List <CustomizedProduct>(); foreach (CustomizedProductDTO customizedProductDTO in collectionDTO.customizedProductDTOs) { CustomizedProduct customizedProduct = customizedProductRepository.find(customizedProductDTO.id); //the product was not found if (customizedProduct == null) { throw new ArgumentException(ERROR_CUSTOMIZED_PRODUCT_NOT_FOUND); } customizedProducts.Add(customizedProduct); } catalogueCollection = new CatalogueCollection(collection, customizedProducts); } catalogueCollections.Add(catalogueCollection); } newComCatalogue = new CommercialCatalogue(reference, designation, catalogueCollections); } else { newComCatalogue = new CommercialCatalogue(reference, designation); } return(newComCatalogue); }