/// <summary> /// method to get the current capacity of a given date /// </summary> /// <param name="dateTime"></param> /// <returns></returns> private async Task <int> findCurrCapDate(DateTime dateTime) { int value = 0; //List<AssociateDto> assoc = await consumerHelper.ConsumeAssociatesFromAPI(); //FIND THE APARTMENT List <HousingDataDto> dataList = await logicHelper.HousingDataGetAll(); List <HousingDataDto> returnList = new List <HousingDataDto>(); foreach (var item in dataList) { int b1 = (item.MoveInDate.CompareTo(dateTime)); int b2 = (dateTime.CompareTo(item.MoveOutDate)); if ((b1 == -1 || b1 == 0) && (b2 == 0 || b2 == 1)) { returnList.Add(item); } } List <ApartmentDto> aptDto = await logicHelper.ApartmentsGetAll(); foreach (var item in returnList) { if (item.RoomID != null) { ApartmentDto temp = aptDto.Find(id => id.RoomID.Equals(item.RoomID)); value += temp.CurrentCapacity; } } return(value); }
/// <summary> /// this method removes an assocaite from a room and decrease the current capacity /// </summary> /// <param name="associate"></param> /// <returns></returns> public async Task <bool> RemoveAssocFromRoom(InsertAssociateDto associate) { //FIND THE ASSOCIATE FROM A LIST OF ASSOCIATES AssociateDto assoc = (await consumerHelper.ConsumeAssociatesFromAPI()).Find(id => id.AssociateID.Equals(associate.AssociateId)); //FIND THE APARTMENT ApartmentDto aptDto = (await logicHelper.ApartmentsGetAll()).Find(id => id.RoomID.Equals(associate.RoomId)); //FIND THE HousingData HousingDataDto data = (await logicHelper.HousingDataGetAll()).Find(id => id.AssociateID.Equals(associate.AssociateId)); //update the status to 3 WHERE THREE MEANS TO DELETE data.StatusID = 3; if (aptDto.CurrentCapacity > 0) { aptDto.CurrentCapacity--; } else { return(false); } bool passed = await logicHelper.UpdateApartment(aptDto); bool passed3 = await logicHelper.UpdateHousingData(data); return(passed && passed3); }
public async Task <IActionResult> LiversAdd(AddUserToFlateModel model) { string toReturn = ""; IEnumerable <ApartmentDto> app = serviceAps.findAllWithFilter(apartment => apartment.ApartmentId == model.FlatId); int a = app.Count(); ApartmentDto appp = app.First(); IEnumerable <UserAppartmenDto> result = serviceUserAps.findAllWithFilter(apartment => apartment.ApartmentId == model.FlatId); if (appp.ApartmentSpace / (result.Count() + 1) > minMetersOnLiver) { UserAppartmenDto toSave = new UserAppartmenDto(); toSave.ApartmentId = model.FlatId; toSave.UserId = model.UserID; serviceUserAps.Create(toSave); toReturn = "saved"; ViewData["CityWhichUserLooking"] = toReturn; return(View()); } toReturn = "notEnogfPlace"; ViewData["CityWhichUserLooking"] = toReturn; return(View()); }
public static ApartmentDto Map(Domain.Read.Models.ApartmentModel apartment) { var dto = new ApartmentDto { Id = apartment.Id, ForRentalDates = apartment.ForRentalDates, AvailableDates = apartment.AvailableDates, CheckInTime = apartment.CheckInTime, CheckOutTime = apartment.CheckOutTime, ActivityState = apartment.ActivityState, Rating = apartment.Rating, Title = apartment.Title, PricePerNight = apartment.PricePerNight, ApartmentType = apartment.ApartmentType, NumberOfGuests = apartment.NumberOfGuests, NumberOfRooms = apartment.NumberOfRooms }; dto.Amenities = apartment.Amenities.Select(a => Map <AmenityDto>(a)).ToList(); dto.Images = apartment.Images.Select(i => Map <ImageDto>(i)).ToList(); dto.Comments = apartment.Comments.Select(c => Map <CommentDto>(c)).ToList(); dto.Location = Map(apartment.Location); dto.HostId = apartment.HostId; return(dto); }
public ApartmentDto Update(ApartmentDto tenant) { Apartment tenantToUpdate = Get(tenant.Id); _dbContext.Entry(tenantToUpdate).CurrentValues.SetValues(_mapper.Map <Apartment>(tenant)); _dbContext.SaveChanges(); return(_mapper.Map <ApartmentDto>(tenantToUpdate)); }
/// <summary> /// This method recieves an ApartmentDto model that we expect to delete based off of the primary key /// </summary> /// <param name="oldApartment"></param> /// <returns>Task<bool></returns> public async Task <bool> DeleteApartment(ApartmentDto oldApartment) { Apartment ApartmentVnM = new Apartment(); //validate the incoming DTO first before converting into DAO //STILL NEED TO VALIDATE return(await graceService.DeleteApartmentAsync(ApartmentVnM.MapToDao(oldApartment))); }
public async Task AddApartmentAsync(ApartmentDto apartment) { var entry = apartment.ToEntry(); await _baseInfoContext.ApartmentInfos.AddAsync(entry); await _baseInfoContext.SaveChangesAsync(); apartment.ApartmentId = entry.ApartmentId; }
public ApartmentDto Add(ApartmentDto item) { Apartment tenant = _mapper.Map <Apartment>(item); _dbContext.Apartment.Add(tenant); _dbContext.SaveChanges(); return(GetDto(tenant.Id)); }
public static ApartmentResponse ToModel(this ApartmentDto apartment) { return(new ApartmentResponse { ApartmentId = apartment.ApartmentId, Area = apartment.Area, CurrentOccupant = "NoOne", Number = apartment.Number }); }
public static ApartmentInfo ToEntry(this ApartmentDto apartment) { return(new ApartmentInfo { ApartmentId = apartment.ApartmentId, Area = apartment.Area, BuildingId = apartment.BuildingId, Number = apartment.Number }); }
public IActionResult Single(int id) { ApartmentDto apartment = _apartmentRepository.GetDto(id); if (apartment == null) { return(NotFound()); } return(Ok(apartment)); }
public IActionResult Remove(int id) { ApartmentDto apartment = _apartmentRepository.GetDto(id); if (apartment == null) { return(NotFound()); } _apartmentRepository.Delete(id); return(NoContent()); }
/// <summary> /// this method inserts an assocaite into a room and increase the current capacity /// </summary> /// <param name="associate"></param> /// <returns></returns> public async Task <bool> InsertAssociateToRoom(InsertAssociateDto associate) { //FIND THE ASSOCIATE FROM A LIST OF ASSOCIATES AssociateDto assoc = (await consumerHelper.ConsumeAssociatesFromAPI()).Find(id => id.AssociateID.Equals(associate.AssociateId)); //FIND THE APARTMENT ApartmentDto aptDto = (await logicHelper.ApartmentsGetAll()).Find(id => id.RoomID.Equals(associate.RoomId)); List <HousingDataDto> tt = await logicHelper.HousingDataGetAll(); HousingDataDto data = new HousingDataDto() { AssociateID = assoc.AssociateID, MoveInDate = associate.MoveInDate, MoveOutDate = associate.MoveOutDate, RoomID = associate.RoomId, StatusID = 1 }; string RoomsGender = "Male"; if (aptDto.GenderID == 2) //Female on gender table { RoomsGender = "Female"; } if ((aptDto.CurrentCapacity < aptDto.MaxCapacity) && (RoomsGender == assoc.Gender)) { aptDto.CurrentCapacity++; } else { return(false); } bool passed = false; bool passed2 = false; if (tt.Exists(id => id.AssociateID.Equals(data.AssociateID))) { passed2 = await logicHelper.UpdateHousingData(data); } else { passed2 = await logicHelper.AddHousingData(data); } if (passed2) { passed = await logicHelper.UpdateApartment(aptDto); } return(passed && passed2); }
public virtual IActionResult GetItem([FromBody] int id) { ApartmentDto dto = service.GetById(id); if (dto == null) { return(BadRequest()); } ApartmentModel model = mapper.Map <ApartmentModel>(dto); return(Ok(model)); }
public async Task <HttpResponseMessage> Get([FromUri] ApartmentDto apartment) { try { var Response = Request.CreateResponse(HttpStatusCode.OK, await traineeConsumer.ConsumeAssociatesFromAPI()); log.Info("GetAssociates Get Successsful"); return(Response); } catch (Exception ex) { LogHelper.SendError(log, ex); return(Request.CreateResponse(HttpStatusCode.BadRequest)); } }
public async Task <IActionResult> CreateApartment(ApartmentDto apartmentDto) { if (apartmentDto.Title == null || apartmentDto.NbOfRooms == null || apartmentDto.Address == null) { return(BadRequest("Missing field")); } var apartmentToCreate = new Apartment(); var createdApartment = await _repo.CreateApartment(apartmentToCreate, apartmentDto.Title, (int)apartmentDto.NbOfRooms, apartmentDto.Address); return(StatusCode(201)); }
/// <summary> /// this method inserts a new apartment by calling on the soap service. /// The "graceService.insert" returns a bool value so we just return /// that since it depends on its pass or fail /// </summary> /// <param name="newApt"></param> /// <returns></returns> public async Task <bool> AddApartment(ApartmentDto newApt) { try { Apartment apartmentVnM = new Apartment(); //validate the incoming DTO first before converting into DAO //STILL NEED TO VALIDATE return(await graceService.InsertApartmentAsync(apartmentVnM.MapToDao(newApt))); } catch (Exception) { return(false); } }
public IActionResult Add([FromBody] ApartmentDto apartment) { if (apartment == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ApartmentDto apartmentAdded = _apartmentRepository.Add(apartment); return(Ok(apartmentAdded)); }
public virtual IActionResult UpdateItem([FromBody] ApartmentModel model) { if (model == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ApartmentDto dto = mapper.Map <ApartmentDto>(model); service.Update(dto); return(Ok()); }
/// <summary> /// put method for apartment /// </summary> /// <param name="apartment"></param> /// <returns></returns> public async Task <HttpResponseMessage> Put([FromBody] ApartmentDto apartment) { try { if (await logicHelper.UpdateApartment(apartment)) { var Response1 = Request.CreateResponse(HttpStatusCode.OK, "successful update"); log.Info("Apartment Put Successful"); return(Response1); } var Response2 = Request.CreateResponse(HttpStatusCode.BadRequest, "failed to update"); log.Info("Apartment Put Unsuccessful"); return(Response2); } catch (Exception ex) { LogHelper.SendError(log, ex); return(Request.CreateResponse(HttpStatusCode.BadRequest)); } }
public void Apartment_Map_To_Entry() { ApartmentDto otdto = new ApartmentDto { BuildingId = 1, Area = 29, ApartmentId = 4, Number = 34 }; ApartmentInfo ow = otdto.ToEntry(); bool check = false; if (otdto.Number == ow.Number && otdto.BuildingId == ow.BuildingId && otdto.ApartmentId == ow.ApartmentId && ow.Area == otdto.Area) { check = true; } Assert.IsTrue(check); }
/// <summary> /// post method for inserting a new apartment /// </summary> /// <param name="newApartmentDto"></param> /// <returns></returns> public async Task <HttpResponseMessage> Post([FromBody] ApartmentDto newApartmentDto) { try { newApartmentDto.ActiveBit = true; newApartmentDto.CurrentCapacity = 0; if (await logicHelper.AddApartment(newApartmentDto)) { var Response1 = Request.CreateResponse(HttpStatusCode.OK, "successful insert"); log.Info("Apartment Post Successful"); return(Response1); } var Response2 = Request.CreateResponse(HttpStatusCode.BadRequest, "failed to insert"); log.Info("Apartment Post Unsuccessful"); return(Response2); } catch (Exception ex) { LogHelper.SendError(log, ex); return(Request.CreateResponse(HttpStatusCode.BadRequest)); } }
public IActionResult Update(int id, [FromBody] ApartmentDto apartment) { var apartmentToCheck = _apartmentRepository.Get(id); if (apartmentToCheck == null) { return(NotFound()); } if (id != apartment.Id) { return(BadRequest("Ids do not match")); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ApartmentDto updatedapartment = _apartmentRepository.Update(apartment); return(Ok(updatedapartment)); }
private async Task ValidateApartment(ApartmentDto apartment) { const int MIN_AREA_FOR_UNIT = 20; if (apartment.Area < MIN_AREA_FOR_UNIT) { throw new ValidationException(ErrorCodes.Invalid_Area, $"Area of an Apartment can not be smaller than 20"); } var building = await _buildingrepository.GetBuildingAsync(apartment.BuildingId); if (building.NumberOfUnits < apartment.Number) { throw new ValidationException(ErrorCodes.Max_Apartment_Number, $"Number Unit should not be greater than counts of building aparment"); } foreach (var c in await _buildingrepository.GetBuildingApartments(building.BuildingId)) { if (c.Number == apartment.Number) { throw new ValidationException(ErrorCodes.Invalid_Apartment_Number, $"This apartment Number Already exists"); } } }
/// <summary> /// This method maps from a ApartmentDto to a ApartmentDao /// </summary> /// <param name="apt"></param> /// <returns>ApartmentDao</returns> public ApartmentDao MapToDao(ApartmentDto apt) { var mapper = apartmentMapper.CreateMapper(); return(mapper.Map <ApartmentDao>(apt)); }
public async Task AddAppartment(ApartmentDto apartment) { await ValidateApartment(apartment); await _buildingrepository.AddApartmentAsync(apartment); }
public async Task AddApartmentAsync(ApartmentDto apartment) { apartment.ApartmentId = _apartments.Max(a => a.ApartmentId) + 1; _apartments.Add(apartment); }