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