/// <summary> /// /// </summary> /// <param name="id"></param> /// <param name="data">VariantDTO</param> /// <returns></returns> public BaseDTO Update(string id, object data) { Response response = new Response(); var type = new VariantDTO(); if (data.GetType() == type.GetType()) { var token = AuthorizationService.Authorize(_authParameters.ClientId, _authParameters.ClientSecret, _authParameters.StoreName); var url = HelperFunctions.CreateUrlFromParts(_authParameters.StoreName, Constants.apiVariant, id, token.access_token); var result = HelperFunctions.HttpPut(url, data).GetAwaiter().GetResult(); if (result != null) { return(result); } else { return(new BaseDTO() { code = (int)HttpStatusCode.BadRequest, }); } } else { throw new System.Exception("Not suppoerted type of parameter"); } }
/// <summary> /// get variant deatils from variant ID /// </summary> /// <param name="VariantID"></param> /// <returns></returns> public VariantDTO getVariantDetails(Guid VariantID) { Variant variantDBData = dbContext.Variants.Where(c => c.ID == VariantID).FirstOrDefault(); Debug.WriteLine(dbContext.Variants.Where(c => c.ID == VariantID).FirstOrDefault()); VariantDTO variantDetails = VariantMapper.Map <Variant, VariantDTO>(variantDBData); return(variantDetails); }
public VariantDTO GetVariant(Guid variantID) { Variant variant = shoppingCartEntities.Variants.Where(v => v.ID == variantID).FirstOrDefault(); Debug.WriteLine(shoppingCartEntities.Variants.Where(v => v.ID == variantID).FirstOrDefault()); VariantDTO variantDTO = VariantMapper.Map <Variant, VariantDTO>(variant); return(variantDTO); }
public async Task <IActionResult> AddVariant([FromBody] VariantDTO variantDTO) { VariantDTO added = await _variantService.AddVariant(variantDTO); if (added == null) { return(BadRequest()); } return(Ok(added)); }
public VariantDTO GetVariant(Guid variantID) { Variant variant = futureKartEntities.Variants.Where(v => v.ID == variantID).FirstOrDefault(); Debug.WriteLine(futureKartEntities.Variants.Where(v => v.ID == variantID).FirstOrDefault()); VariantDTO variantDTO = ProductInfoMapper.Map <Variant, VariantDTO>(variant); variantDTO.VariantString = SetVariantStringFromSKU(variantDTO.SKU); return(variantDTO); }
/// <summary> /// add product to cart business /// </summary> /// <param name="newVariantAdded"></param> /// <returns>true is product is added</returns> public bool AddItemCart(CartVariantDTO newVariantAdded) { ///get the product variants details VariantDTO variantData = cartOrderHelper.GetVariantDetails(newVariantAdded.VariantID); /* * calautale the the selling price * * */ double SellingPrice = variantData.ListingPrice - variantData.Discount; /* * * get the varinat data from cart whther it is present or not in the cart * add the new added Quautity to store quatity * */ CartVariantDTO VariantPresentAtCart = cartOrderHelper.VariantPresentAtCart(newVariantAdded); /* * * Check the inventory is available * */ /*check the variant present at cart*/ if (VariantPresentAtCart != null) { newVariantAdded.Quantity = newVariantAdded.Quantity + VariantPresentAtCart.Quantity; } if (cartOrderHelper.IsInventoryAvaiable(newVariantAdded.Quantity, variantData.Inventory)) { ////check the if user order limit is excedded then the order limit if (cartOrderHelper.IsUserCanOrder(newVariantAdded, variantData)) { if (cartOrderHelper.ProductLimit(variantData.ProductID) >= newVariantAdded.Quantity) { bool added = cartOrderHelper.AddVariantToCart(newVariantAdded, SellingPrice); } else { throw new UserOrderLimitExceddException(); } } else { throw new UserOrderLimitExceddException(); } } else { throw new OutOfStockException(); } return(true); }
/// <summary> /// /// </summary> /// <param name="ItemToBEAdded"></param> /// <param name="variantData"></param> /// <returns></returns> /// public bool IsUserCanOrder(CartVariantDTO newVariantAdded, VariantDTO variantData) { IEnumerable <OrderPlacedVariantDTO> orderPlacedVariants = addvariantDataBase.UserOrderData(newVariantAdded.CartID); int OrderLimit = addvariantDataBase.GetProductOrderLimitByID(variantData.ProductID); int UserOrderdCount = orderPlacedVariants.Where(c => c.VariantID == newVariantAdded.VariantID).Count(); if (UserOrderdCount >= OrderLimit) { return(false); } return(true); }
public ActionResult UpdateVariant(string variantID) { try { ModelState.Clear(); Guid VariantID = new Guid(variantID); VariantDTO variantDTO = productBusinessContext.GetVariant(VariantID); ProductDTO productDTO = productBusinessContext.GetProduct(variantDTO.Product.ID); return(RedirectToAction("ShowVariant", new { variantID = variantDTO.ID })); }catch (Exception ex) { return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex })); } }
public async Task <IActionResult> Update([FromBody] VariantDTO model, [FromHeader] int varId) { var userId = int.Parse(User.Claims.First(c => c.Type == ClaimTypes.NameIdentifier).Value); if (await _db.Variants.Include(v => v.LaboratoryWork).Where(v => v.LaboratoryWork.UserId == userId && v.LaboratoryWorkId == model.LaboratoryWorkId).FirstOrDefaultAsync() != null) { var variantUpdate = await _db.Variants.FirstOrDefaultAsync(v => v.VariantId == varId); if (variantUpdate != null) { // если лабораторная работа содержит шаблон /*try * { * var laboratoryWork = await _db.LaboratoryWorks.Where(lw => lw.UserId == userId && lw.LaboratoryWorkId == model.LaboratoryWorkId).FirstOrDefaultAsync(); * // генерируем описание, ссылку на модель, список входных данных * if (laboratoryWork.TemplateLaboratoryWorkId != null) * await GenNewTask(model, laboratoryWork.TemplateLaboratoryWorkId.Value); * } * catch (Exception ex) * { * // пишем ошибку генератора * await Response.WriteAsync(ex.Message); * // выходим * return BadRequest(ex.Message); * }*/ try { variantUpdate.Description = model.Description; variantUpdate.LaboratoryWorkId = model.LaboratoryWorkId; variantUpdate.InputDataRuns = model.InputDataRuns; variantUpdate.LinkToModel = model.LinkToModel; variantUpdate.VariantNumber = model.VariantNumber; variantUpdate.Constraints = model.Constraints; _db.Variants.Update(variantUpdate); await _db.SaveChangesAsync(); } catch (DbUpdateException e) { await Response.WriteAsync(e.Message); } return(Ok(varId)); } return(NotFound("Вариант не найдент")); } return(BadRequest("Нет прав для проведения изменений")); }
public async Task <VariantDTO> AddVariant(VariantDTO variantDTO) { Variant varianttoAdd = _mapper.Map <Variant>(variantDTO); IEnumerable <Variant> variants = _variantRepository.GetAll(); Variant existedAuthor = variants.FirstOrDefault (v => v.QuestionId == varianttoAdd.QuestionId && v.VariantText == varianttoAdd.VariantText); if (existedAuthor == null) { _variantRepository.Insert(varianttoAdd); _variantRepository.Save(); return(_mapper.Map <VariantDTO>(varianttoAdd)); } return(null); }
public ActionResult ShowVariant(Guid variantID) { try { ModelState.Clear(); VariantDTO variantDTO = productBusinessContext.GetVariant(variantID); ProductDTO productDTO = productBusinessContext.GetProduct(variantDTO.Product.ID); VariantViewModel variantViewModel = ProductViewModelMapper.Map <VariantDTO, VariantViewModel>(variantDTO); ProductViewModel productViewModel = ProductViewModelMapper.Map <ProductDTO, ProductViewModel>(productDTO); productViewModel.variantDisplay = variantViewModel; return(View(productViewModel)); }catch (Exception ex) { return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex })); } }
public async Task GenNewTask(VariantDTO model, int templateId) { //ResultData resOfGen = null; var path = _db.TemplateLaboratoryWorks .FirstOrDefault(twl => twl.TemplateLaboratoryWorkId == templateId).TemplateTask; // если условия соблюдены, генерируем данные if (path != null) { var resOfGen = await _gen.Run(new Uri(path).AbsolutePath, model.LaboratoryWorkId, model.VariantNumber, true); // перезаписываем введеные пользователем данные model.Description = resOfGen.task; model.LinkToModel = resOfGen.code; model.InputDataRuns = resOfGen.tests; } }
//[HttpPost] public ActionResult UpdateVariant(Guid variantID) { try { Guid VariantID = variantID; ProductViewModel productViewModel = new ProductViewModel(); VariantDTO variantDTO = productBusinessContext.GetVariant(VariantID); VariantViewModel variantViewModel = ProductProductVMMapper.Map <VariantDTO, VariantViewModel>(variantDTO); ProductDTO productDTO = productBusinessContext.GetProduct(variantDTO.Product.ID); productViewModel = CategoryProductVMMapper.Map <ProductDTO, ProductViewModel>(productDTO); productViewModel.variantDisplay = variantViewModel; return(View(productViewModel.variantDisplay)); } catch (Exception ex) { return(RedirectToAction("DefaultExceptionCatch", "Default", new { exception = ex.Message })); } }
public IHttpActionResult CreateVariant(VariantDTO variantDto) { if (!ModelState.IsValid) { //throw new HttpResponseException(HttpStatusCode.BadRequest); return(BadRequest()); } var variant = Mapper.Map <VariantDTO, Variant>(variantDto); _varService.Add(variant); _uow.Save(); variantDto.Id = variant.Id; //return variantDto; instead we are returning URI*(unified resource identifier) return(Created(new Uri(Request.RequestUri + "/" + variant.Id), variantDto)); }
/// <summary> /// update variant information on variant change. /// </summary> /// <param name="variantID"></param> /// <returns>ActionResult--> returns updated variant info</returns> public ActionResult UpdateVariant(string variantID) { try { ModelState.Clear(); Guid VariantID = new Guid(variantID); VariantDTO variantDTO = productBusinessContext.GetVariant(VariantID); ProductDTO productDTO = productBusinessContext.GetProduct(variantDTO.Product.ID); VariantViewModel variantViewModel = ProductViewModelMapper.Map <VariantDTO, VariantViewModel>(variantDTO); ProductViewModel productViewModel = ProductViewModelMapper.Map <ProductDTO, ProductViewModel>(productDTO); productViewModel.variantDisplay = variantViewModel; return(View(productViewModel.variantDisplay)); //return RedirectToAction("ShowVariant", new { variantID = variantDTO.ID }); } catch (Exception ex) { return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex.Message })); } }
public IHttpActionResult UpdateVariant(int id, VariantDTO variantDTO) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var variantFromDb = _varService.GetById(id); if (variantFromDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } //Mapper.Map<VariantDTO, Variant>(variantDTO, variantFromDb); Mapper.Map(variantDTO, variantFromDb); _uow.Save(); return(Ok()); }
public async Task <IActionResult> Create([FromBody] VariantDTO model) { var userId = int.Parse(User.Claims.First(c => c.Type == ClaimTypes.NameIdentifier).Value); var laboratoryWork = await _db.LaboratoryWorks.Where(lw => lw.UserId == userId && lw.LaboratoryWorkId == model.LaboratoryWorkId).FirstOrDefaultAsync(); if (laboratoryWork != null) { // если лабораторная работа содержит шаблон try { // генерируем описание, ссылку на модель, список входных данных if (laboratoryWork.TemplateLaboratoryWorkId != null) { await GenNewTask(model, laboratoryWork.TemplateLaboratoryWorkId.Value); } } catch (Exception ex) { return(BadRequest(ex.Message)); } Variant variant = new Variant { VariantNumber = model.VariantNumber, LaboratoryWorkId = model.LaboratoryWorkId, Description = model.Description, LinkToModel = model.LinkToModel, InputDataRuns = model.InputDataRuns, Constraints = model.Constraints }; try { await _db.Variants.AddAsync(variant); await _db.SaveChangesAsync(); } catch (DbUpdateException e) { await Response.WriteAsync(e.InnerException.Message); } return(Ok(model)); } return(BadRequest("Нет прав для проведения изменений")); }
public VariantDTO GetVariant(Guid variantID) { VariantDTO variantDTO = productDatabaseContext.GetVariant(variantID); return(variantDTO); }
/// <summary> /// placeorder of user with address id and userId /// </summary> /// <param name="AddressId"></param> /// <param name="UserId"></param> /// <returns></returns> public bool PlacedOrder(Guid AddressId, Guid UserId) { VariantDTO variantDTO = new VariantDTO(); //validation for variant order //1.get the cart data bool addressVerfiyed = orderDatabase.IsVerfiyAddress(AddressId, UserId); double totalAmount = 0; if (addressVerfiyed) { try { CartsVariantDTO cartsData = cartOrderHelper.GetCartByUserId(UserId); foreach (CartVariantDTO variantAtCart in cartsData.Items) { //2.get each cart varinat data from varinat table variantDTO = cartOrderHelper.GetVariantDetails(variantAtCart.VariantID); //3.check all cart data inventory if (!cartOrderHelper.IsInventoryAvaiable(variantAtCart.Quantity, variantDTO.Inventory)) { throw new OutOfStockException(); } //3.orderlimit if (!cartOrderHelper.IsUserCanOrder(variantAtCart, variantDTO)) { throw new UserOrderLimitExceddException(); } variantAtCart.SellingPrice = variantDTO.ListingPrice - variantDTO.Discount; totalAmount = totalAmount + variantAtCart.SellingPrice * variantAtCart.Quantity; } //validation end OrderVariantDTO order = new OrderVariantDTO(); order.ItemOrders = cartsData; OrderDataDTO orderData = new OrderDataDTO(); orderData.DeliveryAddressID = AddressId; orderData.TotalAmount = totalAmount; orderData.isCancelled = "N"; bool isOrderPlaced = orderDatabase.PlacedOrder(UserId, orderData, order); if (isOrderPlaced) { foreach (CartVariantDTO variant in cartsData.Items) { Guid Id = variant.ID; bool t = cartOrderHelper.DeleteCartVariant(Id, UserId); } return(true); } else { return(false); } } catch (OutOfStockException) { return(false); } catch (UserOrderLimitExceddException) { return(false); } catch (Exception ex) { return(false); } } else { throw new UserDetailIsWrong(); } }