public DrinkDbModel ToDbModel(DrinkDto item)
{
var alcoholType = Enum.TryParse(typeof(AlcoholType), item.AlcoholType, out var result);
if (alcoholType)
{
if (item.Id == 0)
{
return(new DrinkDbModel
{
Name = item.Name, Type = (AlcoholType)result, AlcoholPercentage = item.AlcoholPercentage,
Flavor = item.Flavor, BrandId = item.BrandId, PricePerMl = item.PricePerMl,
PhotoPath = item.PhotoPath
});
}
else
{
return(new DrinkDbModel
{
Id = item.Id, Name = item.Name, Type = (AlcoholType)result,
AlcoholPercentage = item.AlcoholPercentage, Flavor = item.Flavor, BrandId = item.BrandId,
PricePerMl = item.PricePerMl, PhotoPath = item.PhotoPath
});
}
}
else
{
throw new InvalidCastException(nameof(result));
}
}
public async Task <IActionResult> Add(DrinkDto newDrink, IFormFile photo)
{
if (ModelState.IsValid)
{
if (photo == null || photo.Length == 0)
{
newDrink.Photo = "no-image.png";
}
else
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/img/Drinks", photo.FileName);
var stream = new FileStream(path, FileMode.Create);
await photo.CopyToAsync(stream);
newDrink.Photo = photo.FileName;
}
var addDrink = _mapper.Map <DrinkDto, Drink>(newDrink);
await _unitOfWork.DrinkRepository.AddDrinkAsync(addDrink);
await _unitOfWork.SaveAsync();
return(RedirectToAction("Index"));
}
else
{
var categories = await _unitOfWork.CategoryRepository.GetCategoriesAsync();
ViewData["categories"] = new SelectList(categories, "Id", "CategoryName");
return(View());
}
}
public void CreateDrink(int machineId, DrinkDto drinkDto)
{
var machine = _wendingMachineRepository.GetMachineBy();
machine.Drinks.Add(Mapper.Map <Drink>(drinkDto));
_wendingMachineRepository.Update(machine);
}
public void Map_MapFromDrinkDtoToDrink_CorrectType()
{
var drinkDto = new DrinkDto();
var drink = uut.Map <Drink>(drinkDto);
Assert.That(drink, Is.TypeOf <Drink>());
}
private async Task <bool> TryUpdateDrink(DrinkDto drink)
{
try
{
var drinkDbModelToUpdate = await _context.DrinksSet.FindAsync(drink.Id);
_context.Entry(drinkDbModelToUpdate).State = EntityState.Detached;
var fileRoute = drinkDbModelToUpdate.PhotoPath;
drinkDbModelToUpdate = _drinkMapper.ToDbModel(drink);
if (!string.IsNullOrEmpty(drink.PhotoPath))
{
drinkDbModelToUpdate.PhotoPath = (await _storageService.EditFile(
Convert.FromBase64String(PhotoPathHelper.GetBase64String(drink.PhotoPath)), "jpg", "drinks",
fileRoute));
}
else
{
drinkDbModelToUpdate.PhotoPath = fileRoute;
}
_context.Entry(drinkDbModelToUpdate).State = EntityState.Modified;
return(true);
}
catch (Exception)
{
return(false);
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
string name = txtName.Text;
var categoryId = GetCategoryId();
string descript = txtDescript.Text;
decimal price = (txtPrice.Text == "")? 0 : decimal.Parse(txtPrice.Text);
byte[] img = null;
if (!string.IsNullOrEmpty(fileImg))
{
img = ImageStatic.ConvertImg2Binary(pictureBox1.BackgroundImage);
}
var drink = new DrinkDto
{
Name = name,
DrinkCategoryId = categoryId,
Descript = descript,
Price = price,
Img = img,
Status = true
};
drinkController.Create(drink);
MessageBox.Show("You added drink successfully", "Notification");
loadTable();
}
public SellSummaryDto[] GetShopBeerValues(int shopId, DrinkDto beerType, DateTime dateStart, DateTime dateEnd)
{
return(_clientProxyBeerData.Execute(a => a.GetMarketSummary(UserPass, shopId, dateStart, dateEnd)
.Where(b => b.Key.Id == beerType.Id)
.Select(b => b.Value)
.ToArray()));
}
public void UpdateDrink(DrinkDto drinkDto)
{
var drink = drinkRepository.GetBy(drinkDto.Id);
drinkDto.MappingDrink(drink);
drinkRepository.Update(drink);
}
public async Task <ActionResult> UpdateDrink(int id, [FromBody] DrinkDto drinkdto)
{
try
{
if (id != drinkdto.DrinkId)
{
return(BadRequest());
}
var actuaDrink = _uof.DrinkRepository.GetById(x => x.DrinkId == id);
await Delete(actuaDrink.Id);
var drink = _mapper.Map <Drink>(drinkdto);
_uof.DrinkRepository.Update(drink);
await _uof.Commit();
return(StatusCode(200, drink));
}
catch (Exception)
{
return(StatusCode(400,
String.Format("There is no {0} item", drinkdto.Name)
));
}
}
public async Task <JsonResult> Add(
[FromServices] IMediator mediator,
[FromBody] DrinkDto drinkDto)
{
var command = new AddDrinkCommand(drinkDto);
AddDrinkResult data = await mediator.Send(command);
return(new JsonResult(data.Drink));
}
public static void MappingDrink(this DrinkDto drinkDto, Drink drink)
{
drink.Id = drinkDto.Id;
drink.Name = drinkDto.Name;
drink.DrinkCategoryId = drinkDto.DrinkCategoryId;
drink.Descript = drinkDto.Descript;
drink.Price = drinkDto.Price;
drink.Img = drinkDto.Img;
drink.Status = drinkDto.Status;
}
public void UpdateDrink(int type, int quantity)
{
DrinkDto currentDrink = _drinkRepository.Get(type);
if (currentDrink.Quantity < quantity)
{
throw new NotEnoughSugarException();
}
currentDrink.Quantity -= quantity;
_drinkRepository.Store(currentDrink);
}
public async Task <IActionResult> AddNewDrink(DrinkDto drinkDto)
{
var drink = mapper.Map <DrinkModel>(drinkDto);
drink.LastUpdatedBy = 1;
drink.LastUpdatedOn = DateTime.Now;
uow.DrinkRepository.AddDrink(drink);
await uow.SaveAsync();
return(StatusCode(201));
}
public static Drink MappingDrink(this DrinkDto drinkDto)
{
return(new Drink
{
Id = drinkDto.Id,
Name = drinkDto.Name,
DrinkCategoryId = drinkDto.DrinkCategoryId,
Descript = drinkDto.Descript,
Price = drinkDto.Price,
Img = drinkDto.Img,
Status = drinkDto.Status
});
}
public IActionResult EditDrink([FromBody] DrinkDto drinkDto)
{
try
{
var drink = _mapper.Map <Drink>(drinkDto);
_unitOfWork.DrinkRepository.Edit(drink);
_unitOfWork.Complete();
return(Created(string.Format($"api/bars/{drink.BarName}/Drinks"), drinkDto));
}
catch (Exception e)
{
return(BadRequest());
}
}
public IHttpActionResult createDrink(DrinkDto drinkDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var drink = Mapper.Map <DrinkDto, Drink>(drinkDto);
_context.Drinks.Add(drink);
_context.SaveChanges();
drinkDto.Id = drink.Id;
return(Created(new Uri(Request.RequestUri + "/" + drink.Id), drinkDto));
}
public DrinkDto GetDrinkById(int drinkId)
{
Drink _drink = _drinkRepository.Get(drinkId);
if (_drink == null)
{
throw new ArgumentNullException($"Не найден напиток с Id = {drinkId}");
}
var result = new DrinkDto
{
Id = _drink.Id,
Title = _drink.Title,
Price = _drink.Price
};
return(result);
}
public IActionResult AddDrink([FromBody] DrinkDto drinkDto)
{
try
{
var drink = _mapper.Map <Drink>(drinkDto);
_unitOfWork.DrinkRepository.Add(drink);
_unitOfWork.Complete();
return(Created(string.Format($"api/bars/{drink.BarName}/Drinks"), drinkDto));
}
catch (Exception e)
{
if (e.InnerException is SqlException exception && exception.Number == 2627)
{
return(BadRequest("Duplicate Key"));
}
return(BadRequest());
}
}
public IHttpActionResult updateDrink(DrinkDto drinkDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("ModelState is not Valid"));
}
var drink = _context.Drinks.SingleOrDefault(d => d.Id == drinkDto.Id);
if (drink == null)
{
return(BadRequest("Drink has not been found"));
}
Mapper.Map(drinkDto, drink);
_context.SaveChanges();
return(Ok());
}
public async Task <ActionResult> AddDrinks([FromBody] DrinkDto drinkdto)
{
try
{
_uof.DrinkRepository.Add(_mapper.Map <Drink>(drinkdto));
await _uof.Commit();
var drink = _mapper.Map <DrinkDto>(drinkdto);
return(new CreatedAtRouteResult("GetDrink",
new { id = drink.DrinkId }, drink));//return StatusCode(201);
}
catch (Exception)
{
return(StatusCode(400,
String.Format("There is no {0} item", drinkdto.Name)
));
}
}
private void Create_pnl(DrinkDto drink)
{
var pic = new PictureBox();
pic.Width = 235;
pic.Height = 235;
pic.BackgroundImageLayout = ImageLayout.Stretch;
pic.Cursor = Cursors.Hand;
Image img = null;
if (drink.Img != null)
{
img = ImageStatic.ConvertBinary2Img(drink.Img);
}
pic.BackgroundImage = img;
var _lblname = new Label();
_lblname.Text = drink.Name;
_lblname.Dock = DockStyle.Bottom;
_lblname.Height = 55;
_lblname.TextAlign = ContentAlignment.MiddleCenter;
_lblname.BackColor = Color.FromArgb(241, 242, 246);
_lblname.ForeColor = Color.FromArgb(0, 0, 0);
_lblname.Font = new Font("Segoe UI Symbol", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
pic.Controls.Add(_lblname);
var _lblprice = new Label();
_lblprice.Text = drink.Price.ToString("#,##");
_lblprice.TextAlign = ContentAlignment.MiddleCenter;
_lblprice.Height = 35;
_lblprice.Width = 100;
_lblprice.BackColor = Color.FromArgb(55, 66, 250);
_lblprice.ForeColor = Color.FromArgb(255, 255, 255);
_lblprice.Font = new Font("Segoe UI Symbol", 10F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
pic.Controls.Add(_lblprice);
flowLayoutPanel1.Controls.Add(pic);
pic.Tag = drink.Id.ToString();
pic.Click += new EventHandler(OnClick);
}
public async Task <IActionResult> PutDrink(int id, DrinkDto drink)
{
if (id != drink.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!DrinkExists(id))
{
return(NotFound());
}
var updateDrinkSucceed = await TryUpdateDrink(drink);
if (!updateDrinkSucceed)
{
return(BadRequest());
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DrinkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Update(int Id, [FromBody] DrinkDto drinkDto)
{
var drink = _mapper.Map <Drink>(drinkDto);
if (ModelState.IsValid)
{
try
{
// save
_drinkRepository.Update(drink);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
return(BadRequest(ModelState));
}
public async Task <ActionResult <DrinkDto> > PostDrink(DrinkDto drink)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!string.IsNullOrEmpty(drink.PhotoPath))
{
drink.PhotoPath = await _storageService.SaveFile(
Convert.FromBase64String(PhotoPathHelper.GetBase64String(drink.PhotoPath)), "jpg", "drinks");
}
var drinkDbModel = _drinkMapper.ToDbModel(drink);
await _context.DrinksSet.AddAsync(drinkDbModel);
await _context.SaveChangesAsync();
var createdDrink = _context.DrinksSet.OrderByDescending(e => e.Id).First();
return(CreatedAtAction(nameof(GetDrink), new { id = createdDrink.Id }, _drinkMapper.ToDto(createdDrink)));
}
public void Update(DrinkDto drinkDto)
{
drinkService.UpdateDrink(drinkDto);
}
public void Create(DrinkDto drinkDto)
{
drinkService.CreateDrink(drinkDto);
}
public AddDrinkCommand(DrinkDto dto)
{
DrinkDto = dto ?? throw new ArgumentNullException(nameof(dto));
}
public string GetReportFileNameExcel(DateTime dateStart, DateTime dateEnd, MarketDto shop, DrinkDto beerType)
{
return("fakeExcel.xlsx");
}
public void Store(DrinkDto drink)
{
throw new NotImplementedException();
}
public void CreateDrink(DrinkDto drinkDto)
{
var drink = drinkDto.MappingDrink();
drinkRepository.Add(drink);
}
