public ApartmentDTO Get(int id)
{
Apartment Apartment = IApartmentRepository.Get(id);
ApartmentDTO MyApartments = new ApartmentDTO()
{
id = Apartment.id,
apartmentName = Apartment.apartmentName,
numberOfRooms = Apartment.numberOfRooms,
description = Apartment.description,
maxPersons = Apartment.maxPersons,
pricePerNight = Apartment.pricePerNight,
propertyId = Apartment.propertyId
};
IEnumerable <Photo> Photos = IPhotoRepository.GetAll().Where(x => x.apartmentId == Apartment.id);
if (Photos != null)
{
List <string> PhotosPathsList = new List <string>();
foreach (Photo Photo in Photos)
{
PhotosPathsList.Add(Photo.path);
}
MyApartments.photos = PhotosPathsList;
}
return(MyApartments);
}
public List <ApartmentDTO> GetAvailableApartments(Guid propertyId, DateTime checkin, DateTime checkout, int persons)
{
IEnumerable <Apartment> availableApartments = IPropertyRepository.GetAvailableApartments(propertyId, checkin, checkout, persons);
List <ApartmentDTO> ApartmentsDTO = new List <ApartmentDTO>();
foreach (Apartment ap in availableApartments)
{
IEnumerable <Photo> Photos = IPhotoRepository.GetAll().Where(x => x.apartmentId == ap.id);
if (Photos != null)
{
List <string> PhotosPathsList = new List <string>();
foreach (Photo Photo in Photos)
{
PhotosPathsList.Add(Photo.path);
}
ApartmentDTO apartmentDTO = new ApartmentDTO()
{
id = ap.id,
apartmentName = ap.apartmentName,
numberOfRooms = ap.numberOfRooms,
description = ap.description,
pricePerNight = ap.pricePerNight,
maxPersons = ap.maxPersons,
propertyId = ap.propertyId,
photos = PhotosPathsList
};
ApartmentsDTO.Add(apartmentDTO);
}
}
return(ApartmentsDTO);
}
public void AddApartament(ApartmentDTO apartment)
{
if (apartment == null)
{
throw new ValidationException("Empty arpartment instance argument", "");
}
var appsWithExistingNumber = FindApartment(a => a.Number == apartment.Number);
if (appsWithExistingNumber != null)
{
throw new ValidationException("Apartment with " + apartment.Number.ToString() + " number is already existing", "");
}
Apartment newApartment = new Apartment
{
ApartmentClassId = apartment.ApartmentClassId,
Floor = apartment.Floor,
Number = apartment.Number,
NumberOfPlaces = apartment.NumberOfPlaces,
NumberOfRooms = apartment.NumberOfRooms,
PricePerDay = apartment.PricePerDay
};
try
{
DataBase.Apartments.Create(newApartment);
DataBase.Save();
}
catch (Exception ex)
{
// Залогировать "Exceptin: " + ex.Message + " in AppartmentService in AddApartment method"
throw ex;
}
}
// get: MakeAdvert
public ActionResult MakeAdvert(int?id)
{
try
{
ApartmentDTO apartment = advertService.GetAdvert(id);
Mapper.Initialize(cfg =>
{
cfg.CreateMap <ApartmentDTO, ApartmentViewModel>().ForMember("SalesmanId", opt => opt.MapFrom(src => src.Id));
cfg.CreateMap <SalesmanDTO, SalesmanViewModel>();
cfg.CreateMap <BalconyDTO, BalconyViewModel>();
cfg.CreateMap <ToiletTypeDTO, ToiletTypeViewModel>();
cfg.CreateMap <RepairTypeDTO, RepairTypeViewModel>();
cfg.CreateMap <ElevatorDTO, ElevatorViewModel>();
cfg.CreateMap <BuildingTypeDTO, BuildingTypeViewModel>();
cfg.CreateMap <HouseDTO, HouseViewModel>();
cfg.CreateMap <ApartmentIncludeDTO, ApartmentIncludeViewModel>();
cfg.CreateMap <ImagesIncludeDTO, ImagesIncludeViewModel>();
});
var advert = Mapper.Map <ApartmentDTO, ApartmentViewModel>(apartment);
return(View(advert));
}
catch (ValidationException ex)
{
return(Content(ex.Message));
}
}
public Apartment Put(Guid id, ApartmentDTO value)
{
Apartment model = IApartmentRepository.Get(id);
if (value.apartmentName != null)
{
model.apartmentName = value.apartmentName;
}
if (value.maxPersons != 0)
{
model.maxPersons = value.maxPersons;
}
if (value.description != null)
{
model.description = value.description;
}
if (value.numberOfRooms != 0)
{
model.numberOfRooms = value.numberOfRooms;
}
if (value.pricePerNight != 0)
{
model.pricePerNight = value.pricePerNight;
}
return(IApartmentRepository.Update(model));
}
public IHttpActionResult post([FromBody] ApartmentDTO apartment)
{
vacationApartment apartment1;
apartment1 = apartmentBL.InsertVacationApartment(apartment.convertToVacationApartment());
return(Ok(new ApartmentDTO(apartment1)));
}
/// <summary>
/// получает объект для сохранения с уровня представления и создает по нему объект Apartment и сохраняет его в базу данных.
/// </summary>
/// <param name="appartmentDto"></param>
public void MakeAdvert(ApartmentDTO appartmentDto)
{
Salesman salesman = Database.Salesmans.Get(appartmentDto.SalesmanId);
// валидация
if (salesman == null)
{
throw new ValidationException("Арендодатель не найден", "");
}
// смотрим состояние проплаченных сервисов арендодателя
bool salesmanPayedState = new SalesmanState(30.0).GetSalesmanPayedState(salesman.PayedDate);
// применяем автомаппер для проекции HouseDTO на House
Mapper.Initialize(cfg => cfg.CreateMap <HouseDTO, House>());
House house = Mapper.Map <HouseDTO, House>(appartmentDto.House);
Mapper.Initialize(cfg => cfg.CreateMap <ToiletTypeDTO, ToiletType>());
ToiletType toiletType = Mapper.Map <ToiletTypeDTO, ToiletType>(appartmentDto.ToiletType);
Mapper.Initialize(cfg => cfg.CreateMap <BalconyDTO, Balcony>());
Balcony balcony = Mapper.Map <BalconyDTO, Balcony>(appartmentDto.Balcony);
Mapper.Initialize(cfg => cfg.CreateMap <RepairTypeDTO, RepairType>());
RepairType repairType = Mapper.Map <RepairTypeDTO, RepairType>(appartmentDto.RepairType);
Mapper.Initialize(cfg => cfg.CreateMap <ElevatorDTO, Elevator>());
Elevator elevator = Mapper.Map <ElevatorDTO, Elevator>(appartmentDto.Elevator);
// применяем автомаппер для проекции одной коллекции на другую
Mapper.Initialize(cfg => cfg.CreateMap <ApartmentIncludeDTO, ApartmentInclude>());
var includes = Mapper.Map <IEnumerable <ApartmentIncludeDTO>, List <ApartmentInclude> >(appartmentDto.ApartmentIncludes);
Mapper.Initialize(cfg => cfg.CreateMap <ImagesIncludeDTO, ImagesInclude>());
var images = Mapper.Map <IEnumerable <ImagesIncludeDTO>, List <ImagesInclude> >(appartmentDto.ImagesIncludes);
Apartment apartment = new Apartment
{
PublishDate = DateTime.Now,
Salesman = salesman,
SalesmanPayedState = salesmanPayedState,
Price = appartmentDto.Price,
PriceInfo = appartmentDto.PriceInfo,
Floor = appartmentDto.Floor,
TotalArea = appartmentDto.TotalArea,
LivingArea = appartmentDto.LivingArea,
KitchenArea = appartmentDto.KitchenArea,
OtherInfo = appartmentDto.OtherInfo,
House = house,
ToiletType = toiletType,
Balcony = balcony,
RepairType = repairType,
Elevator = elevator,
ApartmentIncludes = includes,
ImagesIncludes = images
};
Database.Apartments.Create(apartment);
Database.Save();
}
public ActionResult Edit(ApartmentDTO apartment)
{
if (ModelState.IsValid)
{
apartmentService.AddOrUpdate(apartment);
return(RedirectToAction("Index"));
}
return(View(apartment));
}
public ActionResult Delete(int id)
{
try
{
ApartmentDTO apartment = apartmentService.Get(id);
apartmentService.Delete(apartment);
return(Json("OK"));
}
catch { return(Json("Error")); }
}
public async Task <IActionResult> Post([FromBody] ApartmentDTO body)
{
var apartment = new Apartment()
{
ApartmentBlock = body.ApartmentBlock,
Number = body.Number
};
await _repository.AddAsync(apartment);
return(Ok(ApartmentDTO.FromApartment(apartment)));
}
public async Task <IActionResult> GetById(int id)
{
var apartment = await _repository.GetByIdAsync <Apartment>(id);
if (apartment == null)
{
return(NotFound("Apartment not found"));
}
return(Ok(ApartmentDTO.FromApartment(apartment)));
}
public ActionResult Edit(int id)
{
ApartmentDTO apartment = (id == 0) ? new ApartmentDTO() : apartmentService.Get(id);
ViewBag.Benefits = new SelectList(benefitService.GetAll().Select(b => new SelectListItem {
Value = b.BenefitId.ToString(), Text = b.BenefitName
}), "Value", "Text",
new SelectListItem {
Value = apartment.BenefitId.ToString(), Text = apartment.BenefitName
});
return(View(apartment));
}
public static bool IsCloseableApartment(ApartmentDTO apartment, List <BookingDTO> apartmentBookigns)
{
foreach (var b in apartmentBookigns)
{
if (b.DateOfArrival.AddDays(b.DaysOfArrival) >= DateTime.Today.Date)
{
return(false);
}
}
return(true);
}
public Apartment Post(ApartmentDTO value)
{
Apartment model = new Apartment()
{
apartmentName = value.apartmentName,
numberOfRooms = value.numberOfRooms,
description = value.description,
pricePerNight = value.pricePerNight,
propertyId = value.propertyId
};
return(IApartmentRepository.Create(model));
}
public void CleanTest()
{
driver.Close();
ApartmentDTO dto = new ApartmentDTO();
dto.APARTMENT_CODE = "Ap008";
dto.APARTMENT_NAME = "Căn hộ 08";
dto.APARTMENT_TYPE_ID = "ApartmentType0000001";
dto.BUILDING_ID = "BUILDING000000000032";
dto.Floor_ID = "Floor000000000000033";
dto.APARTMENT_ROOMS = 4;
//dto.Apartment_ow = "Tung";
dto.APARTMENT_PRICE = 5000000;
dto.APARTMENT_STATUS = "0";
dto.APARTMENT_AREA = 200;
DataProvider.Instance.GetData <dynamic>("Apartment_Insert", dto);
}
public void EditApartament(ApartmentDTO apartment)
{
if (apartment == null)
{
throw new ValidationException("Empty apartment instance argument", "");
}
try
{
//Mapper.Initialize(cfg => cfg.CreateMap<ApartmentDTO, Apartment>());
DataBase.Apartments.Update(Mapper.Map <ApartmentDTO, Apartment>(apartment));
}
catch (Exception ex)
{
// Залогировать "Exceptin: " + ex.Message + " in AppartmentService in EditApartament method"
throw ex;
}
}
public IHttpActionResult GetApartmentsByCriteria(JObject criteria)
{
string city = criteria["city"].ToObject <string>();
string neighborhood = criteria["neighborhood"].ToObject <string>();
Nullable <int> minimumBeds = criteria["minimumBeds"].ToObject <Nullable <int> >();
Nullable <int> minimumRooms = criteria["minimumRooms"].ToObject <Nullable <int> >();
Nullable <Boolean> yard = criteria["yard"].ToObject <Nullable <Boolean> >();
Nullable <Boolean> jacuzzi = criteria["jacuzzi"].ToObject <Nullable <Boolean> >();
Nullable <Boolean> pool = criteria["pool"].ToObject <Nullable <Boolean> >();
Nullable <Boolean> aSynagogueNearby = criteria["aSynagogueNearby"].ToObject <Nullable <Boolean> >();
Nullable <Boolean> eruvAnTheNeighborhood = criteria["eruvAnTheNeighborhood"].ToObject <Nullable <Boolean> >();
Nullable <int> maximumPrice = criteria["maximumPrice"].ToObject <Nullable <int> >();
apartments = apartmentBL.GetApartmentsByCriteria(
city, neighborhood, minimumBeds, minimumRooms, yard, jacuzzi, pool,
aSynagogueNearby, eruvAnTheNeighborhood, maximumPrice);
apartments1 = ApartmentDTO.convertToListApartmentDTO(apartments);
return(Ok(apartments1));
}
public async Task <ActionResult> Register(RegisterModel model)
{
ViewBag.Apartments = new SelectList(apartmentService.GetAll().Select(ap => new SelectListItem {
Value = ap.ApartmentNumber.ToString(), Text = ap.ApartmentNumber.ToString()
}), "Value", "Text");
if (ModelState.IsValid)
{
var user = new AppUser
{
Email = model.Email,
UserName = model.Email,
PhoneNumber = model.PhoneNumber,
ApartmentNumber = model.ApartmnentNumber
};
ApartmentDTO apartment = apartmentService.FindBy(ap => ap.ApartmentNumber == user.ApartmentNumber).FirstOrDefault();
if (apartment.Username != null)
{
ModelState.AddModelError("", "Ця квартира вже має зареєстрованого користувача");
return(View(model));
}
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
apartment.Username = user.UserName;
apartmentService.AddOrUpdate(apartment);
await userManager.AddToRoleAsync(user.Id, "OSBB_User");
TempData["user"] = user;
return(RedirectToAction("VerifyUser"));
}
AddErrors(result);
}
return(View(model));
}
public Apartment Put(int id, ApartmentDTO value)
{
Apartment model = IApartmentRepository.Get(id);
if (value.description != null)
{
model.description = value.description;
}
if (value.numberOfRooms != 0)
{
model.numberOfRooms = value.numberOfRooms;
}
if (value.propertyId != 0)
{
model.propertyId = value.propertyId;
}
if (value.pricePerNight != 0)
{
model.pricePerNight = value.pricePerNight;
}
return(IApartmentRepository.Update(model));
}
public IHttpActionResult GetApartmentsByApartmentsId([FromBody] List <Nullable <int> > apartmentsId)
{
List <vacationApartment> apartments = apartmentBL.GetApartmentsByApartmentsId(apartmentsId);
return(Ok(ApartmentDTO.convertToListApartmentDTO(apartments)));
}
public List <dynamic> ApartmentInsert([FromBody] ApartmentDTO dto)
{
return(apartmentAppService.Apartment_Insert(dto));
}
public List <dynamic> ApartmentUpdate([FromBody] ApartmentDTO dto)
{
return(apartmentAppService.Apartment_Update(dto));
}
public HttpResponseMessage PostApartment(ApartmentDTO apartment)
{
try
{
var respList = new List <string>();
ResponseDTO resp;
// Check Apartment is not NULL
if (apartment == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, RespH.Create(RespH.SRV_APARTMENT_NULL)));
}
// Check Apartment Name is not NULL
resp = CheckHelper.IsNull(apartment.Name, "Name", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Apartment Adress is not NULL
resp = CheckHelper.IsNull(apartment.Adress, "Adress", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Apartment Type is not NULL
resp = CheckHelper.IsNull(apartment.Type, "Type", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Current User
var currentUser = User as ServiceUser;
if (currentUser == null)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, RespH.Create(RespH.SRV_UNAUTH)));
}
var account = AuthUtils.GetUserAccount(_context, currentUser);
if (account == null)
{
respList.Add(currentUser.Id);
return(Request.CreateResponse(HttpStatusCode.Unauthorized,
RespH.Create(RespH.SRV_USER_NOTFOUND, respList)));
}
// Generate
var apartmentGuid = SequentialGuid.NewGuid().ToString();
_context.Apartments.Add(new Apartment
{
Id = apartmentGuid,
Name = apartment.Name,
Type = apartment.Type,
Options = apartment.Options,
UserId = account.UserId,
Adress = apartment.Adress,
Latitude = apartment.Latitude,
Longitude = apartment.Longitude,
Lang = apartment.Lang
});
_context.SaveChanges();
respList.Add(apartmentGuid);
return(Request.CreateResponse(HttpStatusCode.OK, RespH.Create(RespH.SRV_CREATED, respList)));
}
catch (Exception ex)
{
Debug.WriteLine(ex.InnerException);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_EXCEPTION, new List <string> {
ex.InnerException.ToString()
})));
}
}
public HttpResponseMessage PutApartment(string id, ApartmentDTO apartment)
{
try
{
var respList = new List <string>();
ResponseDTO resp;
// Check Apartment is not NULL
if (apartment == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, RespH.Create(RespH.SRV_APARTMENT_NULL)));
}
// Check Current Apartment is not NULL
var apartmentCurrent = _context.Apartments.SingleOrDefault(a => a.Id == id);
if (apartmentCurrent == null)
{
respList.Add(id);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_APARTMENT_NOTFOUND, respList)));
}
// Check Apartment Name is not NULL
resp = CheckHelper.IsNull(apartment.Name, "Name", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Apartment Adress is not NULL
resp = CheckHelper.IsNull(apartment.Adress, "Adress", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Apartment Type is not NULL
resp = CheckHelper.IsNull(apartment.Type, "Type", RespH.SRV_APARTMENT_REQUIRED);
if (resp != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, resp));
}
// Check Current User
var currentUser = User as ServiceUser;
if (currentUser == null)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, RespH.Create(RespH.SRV_UNAUTH)));
}
var account = AuthUtils.GetUserAccount(_context, currentUser);
if (account == null)
{
respList.Add(currentUser.Id);
return(Request.CreateResponse(HttpStatusCode.Unauthorized,
RespH.Create(RespH.SRV_USER_NOTFOUND, respList)));
}
// Check Apartment User
if (apartment.UserId != account.UserId)
{
respList.Add(apartment.UserId);
respList.Add(account.UserId);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_APARTMENT_WRONG_USER, respList)));
}
if (apartmentCurrent.UserId != account.UserId)
{
respList.Add(apartmentCurrent.UserId);
respList.Add(account.UserId);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_APARTMENT_WRONG_USER, respList)));
}
// Update Apartment
apartmentCurrent.Name = apartment.Name;
apartmentCurrent.Adress = apartment.Adress;
apartmentCurrent.Type = apartment.Type;
apartmentCurrent.Options = apartment.Options;
apartmentCurrent.Latitude = apartment.Latitude;
apartmentCurrent.Longitude = apartment.Longitude;
apartmentCurrent.Lang = apartment.Lang;
_context.MarkAsModified(apartmentCurrent);
_context.SaveChanges();
respList.Add(apartment.Id);
return(Request.CreateResponse(HttpStatusCode.OK, RespH.Create(RespH.SRV_UPDATED, respList)));
}
catch (Exception ex)
{
Debug.WriteLine(ex.InnerException);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_EXCEPTION, new List <string> {
ex.InnerException.ToString()
})));
}
}
