public async Task <IActionResult> AddReviewForBook(int id, [FromBody] ReviewForCreationDto reviewForCreationDto) { if (reviewForCreationDto == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var authId = 0; int.TryParse(User.FindFirst(ClaimTypes.NameIdentifier).Value, out authId); var user = await _repo.GetUser(authId); if (user == null) { return(Unauthorized()); } var bookFromRepo = await _repo.GetBook(id); if (bookFromRepo == null) { return(NotFound()); } if (await _repo.ReviewExists(user.Id, id)) { return(BadRequest("You've already reviewed this book")); } var review = new Review() { UserId = user.Id, BookId = bookFromRepo.Id, Content = reviewForCreationDto.Content, Rating = reviewForCreationDto.Rating }; _repo.Add(review); if (!await _repo.SaveAll()) { throw new Exception($"Book review for id {id} failed on save."); } return(StatusCode(201)); }
public void AddstoreTest() { //Add first _repository.Add(storeStub1); _repository.SaveChanges(); //Check whether on database or not store = _repository.GetById(storeStub1.Id); Assert.IsNotNull(store, "Data Store Baru Berhasil Terbuat"); //Delete so this method can be used again _repository.Delete(storeStub1); _repository.SaveChanges(); }
public async Task <IActionResult> Post([FromBody] StoreViewModel store) { var identity = (ClaimsIdentity)User.Identity; IEnumerable <Claim> claims = identity.Claims; var username = claims.Where(c => c.Type == "Username").FirstOrDefault().Value; var _user = await _userRepository.GetSingleAsync(x => x.UserName == username); if (_user == null) { return(new BadRequestResult()); } var _newStore = Mapper.Map <StoreViewModel, Store>(store); _newStore.UserId = _user.Id; _newStore.User = _user; if (_newStore.Id == 0) { _storeRepository.Add(_newStore); } else { _storeRepository.Update(_newStore); } await _storeRepository.Commit(); return(new NoContentResult()); }
public async Task CreateStoreAsync(Store store) { if (store == null) { throw new ArgumentNullException(nameof(store) + " is null"); } if (store.CompanyId == Guid.Empty) { throw new MissingCompanyIdException(nameof(store) + " is missing a company id!"); } var newStore = new DAL.Models.Store { CompanyId = store.CompanyId, Name = store.Name, Address = store.Address, City = store.City, Country = store.Country, Zip = store.Zip, Longitude = store.Longitude, Latitude = store.Latitude }; _storeRepository.Add(newStore); await _unitOfWork.CommitAsync(); }
/// <summary> /// Add Stuff To Store /// </summary> /// <param name="storeViewModel"></param> /// <returns></returns> public Store AddStoreContent(StoreViewModel storeViewModel) { var store = storeViewModel.ConvertToStoreModel(); _storeRepository.Add(store); _storeRepository.SaveChanges(); return(store); }
public async Task Handle(StoreCreateCommand message, CancellationToken cancellationToken) { var e = new Store( message.Id, message.StoreChainId, message.Name, message.Latitude, message.Longitude, message.Address); store.Add(e); }
public async Task <StoreModel> Create(StoreModel model) { model.ID = Guid.NewGuid(); var data = await _repo.Add(model); data = await this.UpdateStoreImage(data, model); return(data); }
public async Task <ActionResult> CreateStoreAsync([FromBody] CreateStoreRequestModel storeModel) { var store = new Store(storeModel.Name, storeModel.StoreTypeId); _storeRepository.Add(store); await _storeRepository.UnitOfWork.SaveChangesAsync(); return(CreatedAtAction(nameof(GetByIdAsync), new { id = store.Id }, null)); }
public ActionResult Create(Category category) { if (ModelState.IsValid) { categoryRepository.Add(category); return(RedirectToAction("List")); } return(View(category)); }
//[ValidateAntiForgeryToken] public IActionResult Create(StorePhotoViewModel viewModel, Stores stores, ApplicationUser app) { if (ModelState.IsValid) { string uniqueFileName = null; if (viewModel.Photo != null) { string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images"); uniqueFileName = Guid.NewGuid().ToString() + "_" + viewModel.Photo.FileName; string filePath = Path.Combine(uploadsFolder, uniqueFileName); viewModel.Photo.CopyTo(new FileStream(filePath, FileMode.Create)); } var test = User.Claims.ToList() .Where(u => u.Type.Equals("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier")) .FirstOrDefault().Value; //var test = _context.Users.Select(x => x.Id).FirstOrDefault(); var newStore = new Stores { Name = viewModel.Name, Description = viewModel.Description, Address = viewModel.Address, states = viewModel.states, Photopath = uniqueFileName, AspNetUsersId = test }; ////Stores storeschoice = storeRepository.GetStoresByViewModel(viewModel); ////if (storeschoice == null) ////{ //// return NotFound(); ////} ////viewModel.Store = storeschoice; ////drugs.Stores = viewModel.Store; ////_drugRepository.Add(drugs); ////viewModel = GetStoreDrugView(storeschoice); ////return View(viewModel); //ApplicationUser applicationUser = _store.GetUserByStore(app); //if(applicationUser==null) //{ // return NotFound(); //} //app.stores = applicationUser.stores; _store.Add(newStore); return(RedirectToAction("Store")); //return RedirectToAction("Store", "Medicine", new //{ // Id = stores.Id //}); } return(View()); }
public async Task <IActionResult> Post([FromBody] Customer model) { if (ModelState.IsValid) { _repository.Add(model); if (await _repository.SaveAsync()) { return(Created($"api/customer", model)); } } return(BadRequest("Failed to create new customer")); }
public IHttpActionResult Post([FromBody] StoreCreateModel storeModel) { if (!ModelState.IsValid) { return(BadRequest()); } var newStore = Mapper.Map <Store>(storeModel); var id = _storeRepository.Add(newStore); var location = new Uri(Request.RequestUri + "/" + id); return(Created(location, id)); }
public GeneralResponse AddStore(AddStoreRequestOld request) { GeneralResponse response = new GeneralResponse(); try { Store store = new Store(); store.ID = Guid.NewGuid(); store.CreateDate = PersianDateTime.Now; store.CreateEmployee = _employeeRepository.FindBy(request.CreateEmployeeID); store.OwnerEmployee = this._employeeRepository.FindBy(request.OwnerEmployeeID); store.StoreName = request.StoreName; store.Note = request.Note; store.RowVersion = 1; // Validation if (store.GetBrokenRules().Count() > 0) { foreach (BusinessRule businessRule in store.GetBrokenRules()) { response.ErrorMessages.Add(businessRule.Rule); } return(response); } _storeRepository.Add(store); _uow.Commit(); ////response.success = true; } catch (Exception ex) { response.ErrorMessages.Add(ex.Message); } return(response); }
public async Task <Store> AddAsync(StoreRequest request) { if (await _repository.Find(request.StoreName, request.Address) != null) { throw new ApiException("Store at given address with given name is already existing!"); } var store = _mapper.Map <Store>(request); var addedStore = await _repository.Add(store); await _repository.SaveChangesAsync(); return(addedStore); }
public async Task <string> CreateStoreAsync() { string result = String.Empty; try { result = await _storeRepository.Add(this); } catch (Exception e) { throw e; } return(result); }
public Task <bool> Handle(CreateStoreCommand request, CancellationToken cancellationToken) { Store store = new Store() { Name = request.Name, Address = request.Address, Region = request.Region, City = request.City, }; _storeRepository.Add(store); _unitOfWork.Commit(); return(Task.FromResult(true)); }
public ActionResult Create(Product p) { SelectList categories = new SelectList(categoryRepository.Items, "Id", "Name"); ViewBag.Categories = categories; if (ModelState.IsValid) { TempData["message"] = $"продукт \"{p.Name}\" был добавлен"; productRepository.Add(p); return(RedirectToAction("Index")); } return(View(p)); }
public ValidationResult CreateNewStore(Store store) { var storeInDb = storeRepo.GetByDistrictName(store.DistrictName); if (storeInDb != null) { validationResult.AddError(new ValidationError($"A loja da {store.DistrictName} já foi cadastrada.", MessageCategory.BusinessRule)); } if (validationResult.IsValid) { storeRepo.Add(store); } return(validationResult); }
public async Task <IActionResult> CreateStore(StoreForCreatingDto storeForCreatingDto) { storeForCreatingDto.Name = storeForCreatingDto.Name.ToLower(); var store = new Store { Name = storeForCreatingDto.Name }; if (await _repo.StoreExists(store)) { return(BadRequest(string.Format("There is already a store with the given information."))); } _repo.Add(store); await _repo.SaveAll(); return(Ok(store)); }
public ResponseMessageModel Save(StoreUpModel model) { var response = new ResponseMessageModel(); if (model.FranchiseStoreId <= EntityConstants.NO_VALUE) { SaveAddress(model); _repositoryStore.Add(model); } else { SaveAddress(model); _repositoryStore.Update(model); } return(response); }
public async Task <IActionResult> Post([FromBody] OrderModel model) { if (ModelState.IsValid) { var customer = _repository.GetCustomer(User.Identity.Name); if (customer != null) { if (!customer.Addresses.Any()) { return(BadRequest("Customer must have at least one address.")); } if (model.Items == null || !model.Items.Any()) { return(BadRequest("Orders must have line items.")); } var order = new Order() { OrderDate = model.OrderDate == DateTime.MinValue ? DateTime.Today : model.OrderDate, Address = customer.Addresses.First(), Customer = customer, OrderNumber = model.OrderNumber ?? Guid.NewGuid().ToString(), Items = model.Items.Select(s => { var product = _repository.GetProductByGTINCode(s.GTINCode); return(new OrderItem() { Product = product, Price = s.Price == 0 ? product.ListPrice : s.Price, Discount = s.Discount, Quantity = s.Quantity == 0 ? 1f : s.Quantity }); }).ToList() }; _repository.Add(order); if (await _repository.SaveAsync()) { return(Created($"api/orders/{order.Id}", order)); } } } return(BadRequest("Request Body incorrect")); }
public async Task <IActionResult> Post([FromBody] CustomerModel model) { if (ModelState.IsValid) { var cust = _mapper.Map <Customer>(model); cust.Addresses.Add(_mapper.Map <Address>(model.Address)); _repository.Add(cust); if (await _repository.SaveAsync()) { return(Created($"api/customer", cust)); } } return(BadRequest(ModelState)); }
public async Task <IActionResult> Post([FromBody] Customer model) { if (ModelState.IsValid) { if (_repository.GetCustomer(User.Identity.Name) != null) { return(BadRequest("Customer Exists. Try updating customer instead.")); } model.Username = User.Identity.Name; _repository.Add(model); if (await _repository.SaveAsync()) { return(Created($"api/customer", model)); } } return(BadRequest("Failed to create new customer")); }
public ICommandResult Execute(CreateStoreCommand command) { try { if (command == null) { throw new ArgumentNullException(); } var store = new Store(); AddStore(command, store); _storeRepository.Add(store); _unitOfWork.Commit(); return(new SuccessResult(StoreCommandMessage.StoreCreatedSuccessfully)); } catch (Exception exception) { _logger.Error(exception.Message); return(new FailureResult(StoreCommandMessage.StoreCreationFailed)); } }
public async Task <IActionResult> Create([FromBody] StoreDTO dto, CancellationToken cancellationToken = default) { var smartZone = await _smartZoneRepository.FindByIdAsync(dto.SmartZoneId); if (smartZone == null) { return(NotFound("No SmartZone Found")); } var store = _mapper.Map <Store>(dto); store.IsDeleted = false; store.OneStarRating = 0; store.TwoStarRating = 0; store.ThreeStarRating = 0; store.FourStarRating = 0; store.FiveStarRating = 0; _storeRepository.Add(store); await _storeRepository.SaveChangesAsync(cancellationToken); return(CreatedAtAction(nameof(GetById), new { store.Id }, _mapper.Map <StoreDTO>(store))); }
// POST api/<controller> public void Post([FromBody] Store value) { Store store = storeRepository.Add(value); }
public async Task <IActionResult> AddOrder([FromBody] OrderForCreationDto orderForCreationDto) { if (orderForCreationDto == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var orderEntity = _mapper.Map <Order>(orderForCreationDto); foreach (var item in orderEntity.OrderItems) { var bookFromRepo = await _repo.GetBook(item.BookId); if (bookFromRepo == null) { return(BadRequest()); } } if (!orderForCreationDto.Guest) { var authId = 0; int.TryParse(User.FindFirst(ClaimTypes.NameIdentifier).Value, out authId); var user = await _repo.GetUser(authId); if (user == null) { return(Unauthorized()); } orderEntity.UserId = user.Id; _repo.Add(orderEntity); if (!await _repo.SaveAll()) { throw new Exception("Failed to create order"); } var authOrderToReturn = _mapper.Map <OrderForUserToReturnDto>(orderEntity); return(CreatedAtRoute("GetOrder", new { orderId = authOrderToReturn.Id }, authOrderToReturn)); } _repo.Add(orderEntity); if (!await _repo.SaveAll()) { throw new Exception("Failed to create order"); } var guestOrderToReturn = _mapper.Map <OrderForGuestToReturnDto>(orderEntity); return(StatusCode(201, guestOrderToReturn)); }
public void CreateStore(Store Store) { StoreRepository.Add(Store); }
public void CreateStore(StoreDto input) { var store = StoreMapper.Map(input); _storeRepository.Add(store); }
public void CreateStore(Stores.Model.Store store) { storesRepository.Add(store); }