public IActionResult PutBuilding([FromBody] BuildingDTO buildingDTO)
{
try
{
Building building = _context.Buildings.FirstOrDefault(b => b.Id == buildingDTO.Id);
if (building == null) // ha nincs ilyen azonosító, akkor hibajelzést küldünk
{
return(NotFound());
}
building.Name = buildingDTO.Name;
building.CityId = buildingDTO.City.Id;
building.SeaDistance = buildingDTO.SeaDistance;
building.ShoreId = buildingDTO.ShoreId.Value;
building.LocationX = buildingDTO.LocationX;
building.LocationY = buildingDTO.LocationY;
building.Comment = buildingDTO.Comment;
_context.SaveChanges(); // elmentjük a módosított épületet
return(Ok());
}
catch
{
// Internal Server Error
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
/// <summary>
/// Épület törlése.
/// </summary>
/// <param name="building">Az épület.</param>
public void DeleteBuilding(BuildingDTO building)
{
if (building == null)
{
throw new ArgumentNullException(nameof(building));
}
// keresés azonosító alapján
BuildingDTO buildingToDelete = _buildings.FirstOrDefault(b => b.Id == building.Id);
if (buildingToDelete == null)
{
throw new ArgumentException("The building does not exist.", nameof(building));
}
// külön kezeljük, ha egy adat újonnan hozzávett (ekkor nem kell törölni a szerverről)
if (_buildingFlags.ContainsKey(buildingToDelete) && _buildingFlags[buildingToDelete] == DataFlag.Create)
{
_buildingFlags.Remove(buildingToDelete);
}
else
{
_buildingFlags[buildingToDelete] = DataFlag.Delete;
}
_buildings.Remove(buildingToDelete);
}
public async Task <bool> EditBuildingAsync(BuildingDTO building)
{
var path = Properties.Resources.editBuildingPath;
var result = await _apiHelper.Put(path, building);
return(result != null && result.ResponseType == ResponseType.Success);
}
private void openRoomManagementWindow()
{
BuildingDTO current = (BuildingDTO)buildinglist.SelectedItem;
RoomWindow newRoomWindow = new RoomWindow(current.BuildingID);
newRoomWindow.ShowDialog();
}
public void AddBuilding(BuildingDTO buildingDTO)
{
var building = MapperExtension.mapper.Map <BuildingDTO, Building>(buildingDTO);
_db.Buildings.Add(building);
_db.SaveChanges();
}
public IActionResult PostBuilding([FromBody] BuildingDTO buildingDTO)
{
try
{
var addedBuilding = _context.Buildings.Add(new Building
{
Name = buildingDTO.Name,
CityId = buildingDTO.City.Id,
SeaDistance = buildingDTO.SeaDistance,
ShoreId = buildingDTO.ShoreId.Value,
LocationX = buildingDTO.LocationX,
LocationY = buildingDTO.LocationY,
Comment = buildingDTO.Comment
});
_context.SaveChanges(); // elmentjük az új épületet
buildingDTO.Id = addedBuilding.Entity.Id;
// visszaküldjük a létrehozott épületet
return(Created(Request.GetUri() + addedBuilding.Entity.Id.ToString(), buildingDTO));
}
catch
{
// Internal Server Error
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
/// <summary>
/// Получает объект "Здание".
/// </summary>
/// <param name= "id"> Идентификатор записи</param>
/// <returns>Объект BuildingDTO</returns>
public BuildingDTO GetBuilding(long id)
{
Building build = _listBuilding.Where(x => x.Id == id).FirstOrDefault <Building>();
BuildingDTO result = _mapper.Map <BuildingDTO>(build);
return(result);
}
async private void InitializeTitle()
{
BuildingDTO building_of_room = await core.GetBuildingByIdAsync(this.BuildingID);
// add building name and address to the window title so it is easier to know which room is edited
this.Title = this.Title + " - " + building_of_room.Name + ", " + building_of_room.Address;
}
/// <summary>
/// Kép hozzáadása.
/// </summary>
/// <param name="buildingId">Épület azonosító.</param>
/// <param name="imageSmall">Kis kép.</param>
/// <param name="imageLarge">Nagy kép.</param>
public void CreateImage(Int32 buildingId, Byte[] imageSmall, Byte[] imageLarge)
{
BuildingDTO building = _buildings.FirstOrDefault(b => b.Id == buildingId);
if (building == null)
{
throw new ArgumentException("The building does not exist.", nameof(buildingId));
}
// létrehozzuk a képet
ImageDTO image = new ImageDTO
{
Id = _buildings.Max(b => b.Images.Any() ? b.Images.Max(im => im.Id) : 0) + 1,
BuildingId = buildingId,
ImageSmall = imageSmall,
ImageLarge = imageLarge
};
// hozzáadjuk
building.Images.Add(image);
_imageFlags.Add(image, DataFlag.Create);
// jellezzük a változást
OnBuildingChanged(building.Id);
}
public async Task <BuildingDTO> GetBuildingByIdAsync(int id)
{
SqlDataReader reader;
BuildingDTO result;
using (var connection = new SqlConnection(_connectionString))
{
using (var cmd = new SqlCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[SpBuildingGet]";
cmd.Parameters.AddWithValue("@buildingId", id);
cmd.Connection = connection;
cmd.Connection.Open();
reader = await cmd.ExecuteReaderAsync();
await reader.ReadAsync();
result = new BuildingDTO
{
Id = id,
Name = Convert.ToString(reader["Name"]),
NumberOfUnits = Convert.ToInt32(reader["NumberOfUnits"]),
Address = Convert.ToString(reader["Address"])
};
}
}
return(result);
}
public async Task <IEnumerable <BuildingDTO> > GetBuildingsAsync(int userId)
{
var result = new List <BuildingDTO>();
using (var connection = new SqlConnection(_connectionString))
{
using (var cmd = new SqlCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[SpBuildingsGetAll]";
cmd.Parameters.AddWithValue("@userId", userId);
cmd.Connection = connection;
cmd.Connection.Open();
using (var dataReader = await cmd.ExecuteReaderAsync())
{
while (await dataReader.ReadAsync())
{
var building = new BuildingDTO {
Id = Convert.ToInt32(dataReader["BuildingId"]),
Name = Convert.ToString(dataReader["Name"]),
NumberOfUnits = Convert.ToInt32(dataReader["NumberOfUnits"]),
Address = Convert.ToString(dataReader["Address"]),
};
result.Add(building);
}
}
}
}
return(result);
}
/// <summary>
/// Nézetmodell példányosítása.
/// </summary>
/// <param name="model">A modell.</param>
public MainViewModel(ITravelAgencyModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
_model = model;
_model.BuildingChanged += Model_BuildingChanged;
_isLoaded = false;
CreateBuildingCommand = new DelegateCommand(param =>
{
EditedBuilding = new BuildingDTO(); // a szerkesztett épület új lesz
OnBuildingEditingStarted();
});
CreateImageCommand = new DelegateCommand(param => OnImageEditingStarted((param as BuildingDTO).Id));
UpdateBuildingCommand = new DelegateCommand(param => UpdateBuilding(param as BuildingDTO));
DeleteBuildingCommand = new DelegateCommand(param => DeleteBuilding(param as BuildingDTO));
DeleteImageCommand = new DelegateCommand(param => DeleteImage(param as ImageDTO));
SaveChangesCommand = new DelegateCommand(param => SaveChanges());
CancelChangesCommand = new DelegateCommand(param => CancelChanges());
LoadCommand = new DelegateCommand(param => LoadAsync());
SaveCommand = new DelegateCommand(param => SaveAsync());
ExitCommand = new DelegateCommand(param => OnExitApplication());
}
public async Task AddBuildingAsync(BuildingDTO building)
{
ValidateBuilding(building);
var gateway = _gatewayFactory.CreateBuildingTableGateway();
var id = await gateway.InsertBuildingAsync(building).ConfigureAwait(false);
building.Id = id;
}
public void EditBuilding(BuildingDTO buildingDTO)
{
var building = MapperExtension.mapper.Map <BuildingDTO, Building>(buildingDTO);
_db.Entry(_db.Buildings.Find(buildingDTO.BuildingID)).CurrentValues.SetValues(building);
_db.SaveChanges();
}
async private void deletebuildingbutton_Click(object sender, RoutedEventArgs e)
{
BuildingDTO buildingtodelete = (BuildingDTO)buildinglist.SelectedItem;
await core.DeleteBuildingAsync(buildingtodelete.BuildingID);
LoadBuildingList();
HideButtonsOnUnselectedCell();
}
public async Task <IActionResult> Add([FromBody] BuildingDTO building)
{
await _mediator.Send(new CreateBuildingCommand
{
Name = building.Name
});
return(Ok());
}
public async Task <int> CreateBuildingAsync(string name, int numberofUnits, string address)
{
var buildingDto = new BuildingDTO {
Name = name, NumberOfUnits = numberofUnits, Address = address
};
await _buildingManager.AddBuildingAsync(buildingDto);
return(buildingDto.Id);
}
public async Task <IActionResult> Update([FromRoute] string id, [FromBody] BuildingDTO building)
{
await _mediator.Send(new UpdateBuildingCommand
{
BuildingExternalId = id,
Name = building.Name
});
return(Ok());
}
public async Task <int> CreateBuilding(string Name, int numberofUnits)
{
BuildingManager buildingManager = new BuildingManager(tableGatwayFactory);
var buildingDto = new BuildingDTO {
Name = Name, NumberOfUnits = numberofUnits
};
await buildingManager.AddBuilding(buildingDto);
return(buildingDto.Id);
}
/// <summary>
/// Épület törlése.
/// </summary>
/// <param name="building">Az épület.</param>
private void DeleteBuilding(BuildingDTO building)
{
if (building == null || !Buildings.Contains(building))
{
return;
}
Buildings.Remove(building);
_model.DeleteBuilding(building);
}
private void ValidateBuilding(BuildingDTO building)
{
if (building.Name == "")
{
throw new ArgumentNullException("Building Cannot be empty!");
}
if (building.NumberOfUnits < 2)
{
throw new ArgumentOutOfRangeException("Building cannot have less than two units!");
}
}
public async Task <BuildingDTO> Update(BuildingDTO model)
{
var result = await _repository.Update(_mapper.Map <BuildingDTO, Building>(model));
if (result != null)
{
return(_mapper.Map <Building, BuildingDTO>(result));
}
return(null);
}
public IHttpActionResult EditBuilding([FromBody] BuildingDTO building)
{
if (string.IsNullOrEmpty(building.Name) || string.IsNullOrEmpty(building.Address))
{
return(BadRequest());
}
if (_bll.EditBuilding(building))
{
return(Ok());
}
return(InternalServerError());
}
public async Task <BuildingDTO> Insert(BuildingDTO model)
{
var result = await _repository.Insert(_mapper.Map <BuildingDTO, Building>(model));
if (result != null)
{
return(_mapper.Map <Building, BuildingDTO>(result));
}
// throw exception
return(null);
}
public static BuildingResponse ToModel(this BuildingDTO building)
{
BuildingResponse model = new BuildingResponse
{
Id = building.Id,
Name = building.Name,
NumberOfUnits = building.NumberOfUnits,
Address = building.Address
};
return(model);
}
public EditBuildingWindow(BuildingDTO edited_building)
{
originalAtomic = edited_building;
InitializeComponent();
WindowHelper.SmallWindowSettings(this);
core = new RoomCore();
initializeData();
buildingNameTextBox.Text = originalName;
addressTextBox.Text = originalAddress;
updateButton.IsEnabled = false;
}
public bool EditBuilding(BuildingDTO building)
{
try
{
_repository.EditBuilding(building);
}
catch
{
return(false);
}
return(true);
}
/// <inheritdoc cref="IUpdatable{TDto}.Update(TDto)"/>
public void Update(BuildingDTO dto)
{
_unitOfWork.BeginTrasaction();
try
{
_unitOfWork.Building.Update(dto);
_unitOfWork.CommitTrasaction();
}
catch (Exception ex)
{
_unitOfWork.RollBackTrasaction();
}
}
/// <summary>
/// Épület törlése.
/// </summary>
/// <param name="building">Épület.</param>
public async Task <Boolean> DeleteBuildingAsync(BuildingDTO building)
{
try
{
HttpResponseMessage response = await _client.DeleteAsync("api/buildings/" + building.Id);
return(response.IsSuccessStatusCode);
}
catch (Exception ex)
{
throw new PersistenceUnavailableException(ex);
}
}
public async Task Building_Added_Successfuly()
{
//A => Arange
BuildingManager buildingManager = new BuildingManager(new MyFakes.TableGatewyFactory());
BuildingDTO building = new BuildingDTO {
Id = 0, Name = "My Building", NumberOfUnits = 10
};
//A => Act
await buildingManager.AddBuilding(building);
//A => Assert
Assert.AreEqual(1, building.Id);
}
