/// <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();
}
}
