/// <summary> /// Make the Restaurant DTO from a restaurant object /// </summary> /// <param name="restaurant"></param> /// <returns>A new RestaurantDTO</returns> private RestaurantDTO MakeRestaurantDTOFromRestaurant(Restaurant restaurant) { var restaurantDTO = new RestaurantDTO { //RestaurantName = restaurant.RestaurantName, //FullAddress = GetRestaurantFullAddress(restaurant), //MapPoint = new MapPoint //{ // Latitude = restaurant.Latitude, // Longitude = restaurant.Longitude //} }; //if(restaurant.RestaurantHour != null) { // restaurantDTO.RestaurantHour = new RestaurantHour // { // Sunday_Open_Time = restaurant.RestaurantHour.Sunday_Open_Time, // Sunday_Close_Time = restaurant.RestaurantHour.Sunday_Close_Time, // Monday_Open_Time = restaurant.RestaurantHour.Monday_Open_Time, // Monday_Close_Time = restaurant.RestaurantHour.Monday_Close_Time, // Tuesday_Open_Time = restaurant.RestaurantHour.Tuesday_Open_Time, // Tuesday_Close_Time = restaurant.RestaurantHour.Tuesday_Close_Time, // Wednesday_Open_Time = restaurant.RestaurantHour.Wednesday_Open_Time, // Wednesday_Close_Time = restaurant.RestaurantHour.Wednesday_Close_Time, // Thursday_Open_Time = restaurant.RestaurantHour.Thursday_Open_Time, // Thursday_Close_Time = restaurant.RestaurantHour.Thursday_Close_Time, // Friday_Open_Time = restaurant.RestaurantHour.Friday_Open_Time, // Friday_Close_Time = restaurant.RestaurantHour.Friday_Close_Time, // Saturday_Open_Time = restaurant.RestaurantHour.Saturday_Open_Time, // Saturday_Close_Time = restaurant.RestaurantHour.Saturday_Close_Time // }; //}; return(restaurantDTO); }
public Restaurant GetRestaurant(int id) { RestaurantDTO restaurantDto = _repo.GetRestaurant(id); Restaurant restaurant = _mapper.Map <Restaurant>(restaurantDto); return(restaurant); }
public int PostRestaurant(Restaurant restaurant) { RestaurantDTO restaurantDto = _mapper.Map <RestaurantDTO>(restaurant); int id = _repo.Post(restaurantDto); return(id); }
public async Task <IActionResult> Index() { var listResDto = new List <RestaurantDTO>(); var listRestaurant = await iRestaurantService.LoadRestaurant(4); foreach (var item in listRestaurant) { var restDto = new RestaurantDTO { Restaurant = item }; if (item.IdTag != null) { var tag = await tagService.Find(item.IdTag); restDto.Tag = tag.NameTag; } listResDto.Add(restDto); } ViewBag.restaurants = listResDto; ViewBag.foods = await iFoodService.GetFoodNumber(12); ViewBag.categories = await categoryService.GetListCategory(10); return(View("index")); }
public async Task AddRestaruantAsync(RestaurantDTO newRestaurant) { using (var context = getContext()) { try { context.Restaurants.Add(_translator.DtoToEntity(newRestaurant)); await context.SaveChangesAsync(); } catch (DbUpdateException ex) { //If exception was caused by Foriegn Key Constraints or Unique Constraints // throw validation exception that will be proccessed to an HTTPResponse with clear failure reason in Abstract Controller if (!await context.Cities.AnyAsync(c => c.Id == newRestaurant.CityId)) { throw new ValidationException(String.Format("City with id {0} does not exists", newRestaurant.CityId), ex); } if (await context.Restaurants.AnyAsync(r => r.Name == newRestaurant.Name && r.Address == newRestaurant.Address)) { throw new ValidationException(String.Format("Restaurant with name, {0}, and address, {1}, already exists", newRestaurant.Name, newRestaurant.Address), ex); } throw; } } }
public async Task <IEnumerable <RestaurantDTO> > GetRestaurants(int cityId, int limit, int offset) { var lstRestaurant = new List <RestaurantDTO>(); using (var connection = new SQLiteConnection(_connectionString)) { connection.Open(); var com = connection.CreateCommand(); com.CommandText = _sqlSelectRestaurants; com.Parameters.AddRange(new[] { new SQLiteParameter("@cityId", cityId), new SQLiteParameter("@limit", limit), new SQLiteParameter("@offset", offset), }); using (var r = await com.ExecuteReaderAsync()) { while (r.Read()) { var restaurant = new RestaurantDTO { Id = r.GetInt32(0), Name = r.GetString(1), CityId = r.GetInt32(2) }; lstRestaurant.Add(restaurant); } } } return(lstRestaurant); }
public RestaurantDTO GetRestaurant(int id) { List <SqlParameter> sqlParams = new List <SqlParameter>(); sqlParams.Add("@id", SqlDbType.Int, (object)id); string sql = " SELECT REST_ID, REST_NAME, (REST_POSITION.ToString()) AS 'REST_POSITION', REST_ADDRESS "; sql += " FROM Restaurants "; sql += " WHERE REST_ID = @id "; DataTable retTbl = m_DataAccess.FillTable(sql, sqlParams); if (retTbl.Rows.Count == 0) { return(null); } RestaurantDTO ret = new RestaurantDTO() { Id = (int)retTbl.Rows[0]["REST_ID"], Name = (string)retTbl.Rows[0]["REST_NAME"], Position = (string)retTbl.Rows[0]["REST_POSITION"], Address = (string)retTbl.Rows[0]["REST_ADDRESS"] }; return(ret); }
public IActionResult CreateRestaurant(RestaurantClient reqObj) { if (reqObj == null) { BadRequest(); } JSONRetObj <int?> retObj = new JSONRetObj <int?>(); try { retObj.IsSuccess = true; retObj.Message = ""; Restaurant restaurant = Mapper.Map <Restaurant>(reqObj); RestaurantDTO restaurantDto = Mapper.Map <RestaurantDTO>(restaurant); int foodMarkerId = _repoRestaurant.Post(restaurantDto); retObj.ResponseObj = foodMarkerId; } catch (Exception ex) { retObj.IsSuccess = false; retObj.Message = ex.Message; retObj.ResponseObj = null; } ViewData["RetObj"] = retObj; return(View("_Success")); }
public static Restaurant Create(RestaurantDTO restaurantDTO) { if (restaurantDTO.Name == null) { throw new Exception(); } return(Create(restaurantDTO.Name, restaurantDTO.Address, restaurantDTO.Description)); }
/// <summary> /// Checks that logged in user is in role admin or one of reastaurant users. /// </summary> /// <param name="restaurant">RestaurantDTO</param> /// <returns>true, if user is in role admin or one of reastaurant users</returns> private Boolean IsAuthorized(RestaurantDTO restaurant) { var users = _restaurantService.GetRestaurantUsersById(restaurant.RestaurantId); var userIds = new ArrayList(); users.ForEach(u => userIds.Add(u.UserId)); return(User.IsInRole("admin") || userIds.Contains(User.Identity.GetUserId())); }
public async Task <ActionResult> Search(RestaurantDTO searchModel) { var result = await this.Mediator.Send(new GetRestaurantsQuery { SearchModel = searchModel ?? new RestaurantDTO() }); return(ResponseHelper.ResponseOutcome <RestaurantDTO>(result, this)); }
public ActionResult AddRestaurant(RestaurantDTO restaurantDTO) { if (!ModelState.IsValid) { return(BadRequest("bad request")); } _restaurantRepository.AddRestaurant(Restaurant.Create(restaurantDTO)); return(Created(nameof(Restaurant), "posted")); }
public async Task <IActionResult> AddRestaurant([FromBody] RestaurantDTO newRestaurant) { Task validateThenAdd() { _payloadValidator.ValidateData(newRestaurant); return(_restaurantRepository.AddRestaruantAsync(newRestaurant)); } return(await toHttpResponse(() => validateThenAdd(), _logger)); }
public ActionResult AddOrUpdateRestaurant(RestaurantDTO dto) { var result = _Service.AddOrUpdateRestaurant(dto); if (result.HasError) { ModelState.AddModelError("error", result.ToErrorMsg()); return(PartialView("_AddRestaurant", dto)); } return(RedirectToAction("Index")); }
public Response <bool> AddOrUpdateRestaurant(RestaurantDTO dto) { bool result = false; BusinessProcess.Current.Process(p => { result = IoC.Get <IRestaurantBusiness>().AddOrUpdateRestaurant(dto); }); return(BusinessProcess.Current.ToResponse(result)); }
public IActionResult Post([FromBody] RestaurantDTO restaurantDTO) { try { return(new OkObjectResult(_appService.Insert(restaurantDTO))); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public Response <RestaurantDTO> GetRestaurant(int restaurantId) { RestaurantDTO result = null; BusinessProcess.Current.Process(p => { result = IoC.Get <IRestaurantBusiness>().GetRestaurant(restaurantId); }); return(BusinessProcess.Current.ToResponse(result)); }
public ActionResult GetRestaurant(int Id) { var result = _Service.GetRestaurant(Id); if (result.HasError) { RestaurantDTO dto = new RestaurantDTO(); ModelState.AddModelError("error", result.ToErrorMsg()); return(PartialView("_AddRestaurant", dto)); } return(PartialView("_AddRestaurant", result.Data)); }
private void ValidateRestaurant(RestaurantDTO restaurantDto, long userId) { foreach (var restaurantName in restaurantDto.RestaurantNameDictionary) { if (string.IsNullOrEmpty(restaurantName.Value)) { throw new ValidationException(ErrorCodes.EmptyRestaurantName); } if (restaurantName.Value.Length > 300) { throw new ValidationException(ErrorCodes.RestaurantNameExceedLength); } if (_restaurantTranslationService.CheckRestaurantNameExist(restaurantName.Value, restaurantName.Key, restaurantDto.RestaurantId, userId)) { throw new ValidationException(ErrorCodes.RestaurantNameAlreadyExist); } if (Strings.SupportedLanguages.All(x => x.ToLower() != restaurantName.Key.ToLower())) { throw new ValidationException(ErrorCodes.UnSupportedLanguage); } } foreach (var restaurantDescription in restaurantDto.RestaurantDescriptionDictionary) { if (string.IsNullOrEmpty(restaurantDescription.Value)) { throw new ValidationException(ErrorCodes.EmptyRestaurantDescription); } if (Strings.SupportedLanguages.All(x => x.ToLower() != restaurantDescription.Key.ToLower())) { throw new ValidationException(ErrorCodes.UnSupportedLanguage); } } if (string.IsNullOrEmpty(restaurantDto.RestaurantAdminUserName)) { throw new ValidationException(ErrorCodes.EmptyRestaurantAdminUserName); } if (string.IsNullOrEmpty(restaurantDto.RestaurantAdminPassword)) { throw new ValidationException(ErrorCodes.EmptyRestaurantAdminPassword); } if (restaurantDto.RestaurantAdminPassword.Length < 8 || restaurantDto.RestaurantAdminPassword.Length > 25) { throw new ValidationException(ErrorCodes.RestaurantAdminPasswordLengthNotMatched); } if (_restaurantAdminService.CheckUserNameDuplicated(restaurantDto.RestaurantAdminUserName, restaurantDto.RestaurantId)) { throw new ValidationException(ErrorCodes.RestaurantAdminUserNameAlreadyExist); } //if (_userService.CheckUserNameDuplicated(restaurantDto.RestaurantAdminUserName)) // throw new ValidationException(ErrorCodes.RestaurantAdminUserNameAlreadyExist); }
public IActionResult Put([FromBody] RestaurantDTO restaurantDTO) { try { _appService.Update(restaurantDTO); return(new OkResult()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public bool AddOrUpdateRestaurant(RestaurantDTO dto) { try { // check authenticate if (dto.Context == null) { base.AddError("Authenticate failed !"); return(false); } var m_restaurantRepository = UnitOfWork.Repository <DB_TB_RESTAURANT>(); var m_accountRestaurantRepository = UnitOfWork.Repository <DB_TB_ACCOUNT_RESTAURANT>(); if (dto.Id > 0) { //update var m_restaurant = m_restaurantRepository.Get(a => a.Id == dto.Id); m_restaurant.Name = dto.Name; m_restaurant.MenuUrl = dto.MenuUrl; m_restaurant.Address = dto.MenuUrl; m_restaurant.IsDelivery = dto.IsDelivery; m_restaurantRepository.Update(m_restaurant); } else { var m_restaurant = new DB_TB_RESTAURANT() { CreatedDate = DateTime.Now, OwnerId = dto.Context.Id, Address = dto.Address, Latitude = (double)dto.Latitude, Longitude = (double)dto.Longitude, IsDelivery = dto.IsDelivery, MenuUrl = dto.MenuUrl, Name = dto.Name, Phone = dto.Phone }; m_restaurantRepository.Add(m_restaurant); m_accountRestaurantRepository.Add(new DB_TB_ACCOUNT_RESTAURANT() { AccountId = m_restaurant.OwnerId, DB_TB_RESTAURANT = m_restaurant, CreatedDate = DateTime.Now }); } UnitOfWork.Commit(); return(!this.HasError); } catch (Exception) { return(false); } }
public RestaurantDTO Register(RestaurantDTO restaurantDTO, int userID) { if (restaurantDTO != null) { using (IEateryDbContext context = _unitOfWork.GetEateryDbContext()) { using (var dbContextTransaction = ((IDbContext)context).GetDataBase().BeginTransaction()) { try { if (userID > 0) { Restaurant restaurant = ObjectTypeConverter.Convert <RestaurantDTO, Restaurant>(restaurantDTO); restaurant.UserID = userID; restaurant.CreatedBy = userID; restaurant.CreatedDate = DateTime.Now; this._RestaurantRepository.Add(context, restaurant); _unitOfWork.Commit(context); if (restaurant.ID > 0) { foreach (var operationTimingsDTO in restaurantDTO.OperationTimings) { OperationTiming operationTiming = ObjectTypeConverter.Convert <OperationTimingDTO, OperationTiming>(operationTimingsDTO); operationTiming.RestaurantID = restaurant.ID; operationTiming.CreatedBy = userID; operationTiming.CreatedDate = DateTime.Now; this._OperationTimingRepository.Add(context, operationTiming); _unitOfWork.Commit(context); } dbContextTransaction.Commit(); restaurantDTO = ObjectTypeConverter.Convert <Restaurant, RestaurantDTO>(restaurant); } else { dbContextTransaction.Rollback(); } } else { dbContextTransaction.Rollback(); } } catch (Exception ex) { dbContextTransaction.Rollback(); } } } } return(restaurantDTO); }
/// <summary> /// </summary> /// <param name="restaurantDTO"></param> /// <returns>name of the restaurant</returns> /// /// /// <exception cref="ArgumentException"></exception> public async Task <string> AddRestaurant(RestaurantDTO restaurantDTO) { if (await _restaurantRepo.RestaurantExists(restaurantDTO.Name)) { throw new ArgumentException("Restaurant exists"); } await _restaurantRepo.AddRestaurantAsync(_mapper.Map <Restaurant>(restaurantDTO)); await _unitOfWork.SaveAsync(); return(restaurantDTO.Name); }
public IHttpActionResult AddOrUpdatePlace(RestaurantDTO request) { try { var result = _Service.AddOrUpdateRestaurant(request); return(Ok(result.ToJsonResult(result.Data))); } catch (Exception ex) { logger.Error("AddOrUpdatePlace Exception is {0}", ex); return(null); } }
public void UpdateRestaurant(RestaurantDTO restaurantDto, string path, long userId) { Restaurant restaurant = _restaurantService.Find(restaurantDto.RestaurantId); if (restaurant == null) { throw new NotFoundException(ErrorCodes.RestaurantNotFound); } ValidateRestaurant(restaurantDto, userId); var restaurantType = _restaurantTypeService.Find(restaurantDto.RestaurantTypeId); if (Strings.SupportedLanguages.Any(x => !restaurantType.RestaurantTypeTranslations .Select(m => m.Language.ToLower()) .Contains(x.ToLower()))) { throw new ValidationException(ErrorCodes.RestaurantTypeIsNotTranslated); } restaurant.RestaurantTypeId = restaurantDto.RestaurantTypeId; restaurant.RestaurantAdmin.UserName = restaurantDto.RestaurantAdminUserName; restaurant.RestaurantAdmin.Password = PasswordHelper.Encrypt(restaurantDto.RestaurantAdminPassword); //restaurant.WaitersLimit = restaurantDto.WaitersLimit; foreach (var restaurantName in restaurantDto.RestaurantNameDictionary) { var restaurantTranslation = restaurant.RestaurantTranslations.FirstOrDefault(x => x.Language.ToLower() == restaurantName.Key.ToLower()); if (restaurantTranslation == null) { restaurant.RestaurantTranslations.Add(new RestaurantTranslation { Language = restaurantName.Key.ToLower(), RestaurantName = restaurantName.Value, RestaurantDescription = restaurantDto.RestaurantDescriptionDictionary[restaurantName.Key] }); } else { restaurantTranslation.RestaurantName = restaurantName.Value; restaurantTranslation.RestaurantDescription = restaurantDto.RestaurantDescriptionDictionary[restaurantName.Key]; } } _restaurantService.Update(restaurant); SaveChanges(); if (restaurantDto.IsLogoChange) { _manageStorage.UploadImage(path + "\\" + "Restaurant-" + restaurant.RestaurantId, restaurantDto.Image, restaurant.RestaurantId.ToString()); } }
public async Task AddRestaurant(RestaurantDTO restaurant) { using (var connection = new SQLiteConnection(_connectionString)) { connection.Open(); var com = connection.CreateCommand(); com.CommandText = _sqlInsertRestaurant; com.Parameters.AddRange(new[] { new SQLiteParameter("@name", restaurant.Name), new SQLiteParameter("@cityId", restaurant.CityId), }); await com.ExecuteNonQueryAsync(); } }
internal static Models.Restaurants MapNewRestaurantDTO(RestaurantDTO restaurant) { var newRestaurant = new Models.Restaurants { Address = restaurant.Address, Position = GetGeometry(restaurant.Position), Email = restaurant.Email, Enabled = true, IdRestaurantType = restaurant.IdRestaurantType, Name = restaurant.Name, PhoneNumber = restaurant.PhoneNumber }; return(newRestaurant); }
public ActionResult <RestaurantDTO> Update(RestaurantDTO restaurantDTO) { try { var restaurant = mapper.Map <Restaurant>(restaurantDTO); repository.Update(restaurant); return(NoContent()); } catch (Exception ex) { logger.LogError(ex, ex.Message); return(BadRequest(ex.Message)); } }
public static Restaurant Map(this RestaurantDTO dto) => (dto != null) ? new Restaurant { Id = dto.Id, Address = dto.Address, City = dto.Address, Description = dto.Description, DateCreated = dto.DateCreated, IsActive = dto.IsActive ?? dto.IsActive.Value, Name = dto.Name, PictureUrl = dto.PictureUrl, PostalCode = dto.PostalCode, Province = dto.Province } : null;
public IHttpActionResult Post(RestaurantDTO model) { Restaurant newRestaurant = new Restaurant(); if (!ModelState.IsValid) { return(BadRequest("Model state is not valid.")); } newRestaurant.Name = model.Name; newRestaurant.Address = model.Address; _context.Restaurants.Add(newRestaurant); _context.SaveChanges(); return(Ok()); }