/// <summary> /// updates a building by a dto /// </summary> /// <param name="dto"></param> /// <returns></returns> public async Task <AlpApiResponse> UpdateBuilding(BuildingDto dto) { var response = new AlpApiResponse(); try { _logger.LogDebug(new { action = nameof(UpdateBuilding), dto = dto?.ToString() }.ToString()); dto.Validate(); var updatedEntity = await _context.Building.Include(building => building.Location).FirstOrDefaultAsync(building => building.BuildingId == dto.Id); updatedEntity.UpdateEntityByDto(dto); await _context.SaveChangesAsync(); } catch (Exception e) { _logger.LogError(new { exception = e, message = e.Message, innerException = e, innerExceptionMessage = e.InnerException?.Message }.ToString()); response.Message = e.Message; response.Success = false; } return(response); }
private static IReadOnlyList <string> CalculateFullMatch(BuildingDto building, string searchQuery) { var fullyMatchedProperties = new List <string>(); if (searchQuery.ContainsInvariant(building.Name)) { building.Weight += NameWeight * FullMatchMultiplier; building.TransitoryWeight += NameTransitoryWeight * FullMatchMultiplier; fullyMatchedProperties.Add(nameof(building.Name)); } if (searchQuery.ContainsInvariant(building.Description)) { building.Weight += DescriptionWeight * FullMatchMultiplier; fullyMatchedProperties.Add(nameof(building.Description)); } if (searchQuery.ContainsInvariant(building.ShortCut)) { building.Weight += ShortCutWeight * FullMatchMultiplier; building.TransitoryWeight += ShortCutTransitoryWeight * FullMatchMultiplier; fullyMatchedProperties.Add(nameof(building.ShortCut)); } return(fullyMatchedProperties); }
public async Task <IActionResult> Post([FromBody] BuildingDto buildingDto) { //Get header token if (Request.Headers.TryGetValue("Authorization", out StringValues headerValues)) { var token = _customEncoder.DecodeBearerAuth(headerValues.First()); if (token != null) { var user = await _userService.GetUserAsyncByToken(token); if (user != null) { //Verify if the token exist and is not expire if ((await _authenticationService.CheckIfTokenIsValidAsync(token) && user.IsAdmin == 1) || await _authenticationService.CheckIfTokenIsValidAsync(token, user.UserId)) { var buildingApiDto = await _buildingService.PostAsyncBuilding(buildingDto); if (buildingApiDto == null) { return(StatusCode(404, "Unable to create building.")); } return(Ok(buildingApiDto)); } return(StatusCode(401, "Invalid token.")); } return(StatusCode(403, "Invalid user.")); } return(StatusCode(401, "Invalid authorization.")); } return(StatusCode(401, "Invalid authorization.")); }
private static void CalculatePartialMatches(BuildingDto buildingDto, IReadOnlyList <string> searchTerms, IReadOnlyList <string> fullyMatched) { foreach (var searchTerm in searchTerms) { if (!fullyMatched.Contains(nameof(buildingDto.Name)) && (buildingDto.Name?.ContainsInvariant(searchTerm) ?? false)) { buildingDto.Weight += NameWeight; buildingDto.TransitoryWeight += NameTransitoryWeight; } if (!fullyMatched.Contains(nameof(buildingDto.Description)) && (buildingDto.Description?.ContainsInvariant(searchTerm) ?? false)) { buildingDto.Weight += DescriptionWeight; } if (!fullyMatched.Contains(buildingDto.ShortCut) && (buildingDto.ShortCut?.ContainsInvariant(searchTerm) ?? false)) { buildingDto.Weight += ShortCutWeight; buildingDto.TransitoryWeight += ShortCutTransitoryWeight; } } }
public async Task DeleteAsync(BuildingDto dto, CancellationToken token = default) { using (var db = new GuoGuoCommunityContext()) { if (!Guid.TryParse(dto.Id, out var uid)) { throw new NotImplementedException("楼宇信息不正确!"); } var building = await db.Buildings.Where(x => x.Id == uid && x.IsDeleted == false).FirstOrDefaultAsync(token); if (building == null) { throw new NotImplementedException("该楼宇不存在!"); } if (await OnDeleteAsync(db, dto, token)) { throw new NotImplementedException("该楼宇信息存在下级数据!"); } building.LastOperationTime = dto.OperationTime; building.LastOperationUserId = dto.OperationUserId; building.DeletedTime = dto.OperationTime; building.IsDeleted = true; await db.SaveChangesAsync(token); } }
public void InsertBuilding(BuildingDto b) { try { //check if exist building with the same name var exist = _buildingRepository.GetAll().Any(x => x.Name.ToLower() == b.Name.ToLower()); if (!exist) { var newB = new Building() { Name = b.Name, Address = b.Address, City = b.City, IsAvailable = b.IsAvailable, CreatedOn = DateTime.Now, UpdatedOn = DateTime.Now }; _buildingRepository.Add(newB); LogManager.Debug($"Inserito nuovo edificio (Nome:{newB.Name}, Indirizzo:{newB.Address}, Citta':{newB.City})"); } else { throw new Exception($"E' già presente un edificio con nome '{b.Name}'"); } } catch (Exception ex) { LogManager.Error(ex); throw ex; } }
public async Task <List <Building> > GetListIncludeAsync(BuildingDto dto, CancellationToken token = default) { using (var db = new GuoGuoCommunityContext()) { return(await db.Buildings.Include(x => x.SmallDistrict.Community.StreetOffice).Where(x => x.IsDeleted == false && x.SmallDistrictId.ToString() == dto.SmallDistrictId).ToListAsync(token)); } }
public BuildingDto FetchBusinessCenter(int id) { try { Building building = _uow.Repository <Building>().Get(i => i.Id == id && i.IsDeleted == false); Builder builder = _uow.Repository <Builder>().Get(i => i.Id == id && i.IsDeleted == false); if (building == null) { throw new Exception("Building Not Found!"); } BuildingDto buildingDto = new BuildingDto { Id = building.Id, Name = building.Name, Height = building.Height, Floors = building.Floors, Address = building.Address, Price = building.Price, Builder = builder }; return(buildingDto); } catch (Exception exception) { throw new Exception(exception.Message); } }
private void ValidateBuilding(BuildingDto buildingDto, long adminId) { if (_buildingService.CheckBuildingRepeated(buildingDto, adminId)) { throw new ValidationException(ErrorCodes.BuildingNameRepeated); } }
public async Task <Building> AddAsync(BuildingDto dto, CancellationToken token = default) { using (var db = new GuoGuoCommunityContext()) { if (!Guid.TryParse(dto.SmallDistrictId, out var smallDistrictId)) { throw new NotImplementedException("小区信息不正确!"); } var smallDistricts = await db.SmallDistricts.Where(x => x.Id == smallDistrictId && x.IsDeleted == false).FirstOrDefaultAsync(token); if (smallDistricts == null) { throw new NotImplementedException("小区信息不存在!"); } var duilding = await db.Buildings.Where(x => x.Name == dto.Name && x.IsDeleted == false && x.SmallDistrictId == smallDistrictId).FirstOrDefaultAsync(token); if (duilding != null) { throw new NotImplementedException("该楼宇信息已存在!"); } var entity = db.Buildings.Add(new Building { Name = dto.Name, SmallDistrictId = smallDistrictId, CreateOperationTime = dto.OperationTime, CreateOperationUserId = dto.OperationUserId, LastOperationTime = dto.OperationTime, LastOperationUserId = dto.OperationUserId }); await db.SaveChangesAsync(token); return(entity); } }
private static IBuilding Map(BuildingDto c) { IBuilding result; if (c.Type == "LivingHouse") { result = new LivingHouseClientSideEntity { Type = c.Type, Guid = c.Guid } } ; else if (c.Type == "SaltEvaporationFactory") { result = new SaltEvaporationFactoryClientSideEntity { Type = c.Type, Guid = c.Guid } } ; else { throw new Exception($"Unexpected building type='{c.Type}'"); } foreach (var cargoDto in c.Cargos) { result.Cargos.Add(Map(cargoDto)); } return(result); }
public async Task <bool> Update(BuildingDto model) { var building = _mapper.Map <Building>(model); _repoBuilding.Update(building); return(await _repoBuilding.SaveAll()); }
// Extract relevant buildings private void GetRelevantBuildings() { // check all the buildings foreach (var buildingObj in _dataService.GetEntitiesData().buildings) { // calculate the weight of a building record buildingObj.CalculateEntityWeight(_searchText); // Adding WeightT to all child Entities of building if (buildingObj.WeightT > 0) { // Iterate over all the locks and add the weightT foreach (var lockobj in buildingObj.Locks) { if (_dataRecordsDict.ContainsKey(lockobj)) { // update the weight of lock _dataRecordsDict[lockobj].Weight = buildingObj.WeightT; } } // for next search make the calculated weightT zero buildingObj.WeightT = 0; } // if weight is not 0 then add this building in the result search array if (buildingObj.Weight > 0) { var buildingTemp = new BuildingDto(); buildingTemp.Put(buildingObj); _searchResults.Add(buildingTemp); // for next search make the calculated weight zero buildingObj.Weight = 0; } } }
public void Building_Name_Cannot_Be_Null_Or_Empty() { BuildingDto building = new BuildingDto { BuildingId = 0, Name = string.Empty, NumberOfUnits = 10 }; Assert.CatchAsync(() => buildingManager.AddBuildingAsync(building)); }
public async Task <IActionResult> Update(BuildingDto update) { if (await _buildingService.Update(update)) { return(NoContent()); } return(BadRequest($"Updating the building {update.ID} failed on save")); }
/// <summary> /// 更新 /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task UpdateAsync(BuildingDto input) { var entity = await _repository.GetAsync(input.Id); var building = input.MapTo(entity); await _repository.UpdateAsync(building); }
public void AddBuilding(BuildingDto buildingDto, long adminId) { ValidateBuilding(buildingDto, adminId); var building = Mapper.Map <Building>(buildingDto); building.AdminId = adminId; _buildingService.Insert(building); SaveChanges(); }
public void UpdateBuilding(BuildingDto buildingDto, long adminId) { ValidateBuilding(buildingDto, adminId); var building = _buildingService.Find(buildingDto.BuildingId); building.BuildingName = buildingDto.BuildingName; _buildingService.Update(building); SaveChanges(); }
public async Task <ActionResult <ApiResponse> > AddNewBuilding(BuildingDto buildingDto) { if (buildingDto.CountAppartaments < buildingDto.Appartaments.Count) { return(BadRequest(new ApiResponse(400, "The number of apartments cannot be greater than the number of possible ones"))); } return(await _buildingPresentation.AddNewBuildingAsync(buildingDto)); }
public static BuildingInfo ToEntry(this BuildingDto building) { return(new BuildingInfo { BuildingId = building.BuildingId, BuildingName = building.Name, ApartmentCount = building.NumberOfUnits }); }
public async Task AddBuildingAsync(BuildingDto building) { var entry = building.ToEntry(); await _baseInfoContext.BuildingInfos.AddAsync(entry); await _baseInfoContext.SaveChangesAsync(); building.BuildingId = entry.BuildingId; }
public async Task <IActionResult> PostAsync([FromBody] BuildingDto buildingDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } return(Created("", await _buildingService.CreateAsync(HttpContext.User.GetAccountId(), buildingDto))); }
private async Task <bool> OnDeleteAsync(GuoGuoCommunityContext db, BuildingDto dto, CancellationToken token = default) { //楼宇单元信息 if (await db.BuildingUnits.Where(x => x.BuildingId.ToString() == dto.Id && x.IsDeleted == false).FirstOrDefaultAsync(token) != null) { return(true); } return(false); }
public FakeBuildingRepository() { _buildings = new List <BuildingDto>(); BuildingDto building = new BuildingDto { BuildingId = 0, Name = "Test", NumberOfUnits = 10 }; _buildings.Add(building); _apartments = new List <ApartmentDto>(); }
public static BuidlingResponse ToModel(this BuildingDto building) { return(new BuidlingResponse { BuildingId = building.BuildingId, Name = building.Name, ApartmentCount = building.NumberOfUnits, OcuupantCount = 0, Budget = 0 }); }
public IHttpActionResult PostBuilding([FromBody] BuildingDto rc) { BuildingsManager rm = new BuildingsManager(); IMapper iMapper = AutomapperInitialize(); var source = rc; var destination = iMapper.Map <BuildingDto, Building>(source); rm.CreateBuilding(destination); return(Ok()); }
public async Task <IActionResult> GetAsync(int id) { BuildingDto building = await _buildingService.GetByIdAsync(id); if (building == null) { return(NotFound(id)); } return(Json(building)); }
public async Task <BuildingDto> UpdateAsync(int id, BuildingDto dto) { dto.Character = null; dto.Group = null; BuildingModel model = await _unitOfWork.BuildingsRepository.GetAsync(id); _mapper.Map(dto, model); await _unitOfWork.SaveAsync(); return(dto); }
public IHttpActionResult Post([FromBody] BuildingDto buildingDto) { int createdId = _buildingService.Post(buildingDto); return(Ok(createdId)); /*if (companyBuildingsList) * return Ok(companyDto); * else * return NotFound();*/ }
public async void ConquerBuilding(BuildingDto building) { await SetHeader(); var message = JsonConvert.SerializeObject(building); var result = await client.PostAsync("/api/buildings", new StringContent(message)); string resultContent = await result.Content.ReadAsStringAsync(); Debug.Log("Send Result" + resultContent); }