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