public async Task UpdateRoom(
[FromServices] UpdateRoomCommand command, [FromBody] RoomInput input,
[FromRoute] Guid roomId
)
{
await command.ExecuteAsync(roomId, input);
}
public void AddNewRoom(RoomInput input)
{
var room = RoomMapping.Map(input);
_repository.Add(room);
_unitOfWork.Commit();
}
public RoomOutput Add(string propertyId, RoomInput newRoom)
{
try
{
Room room = _mapper.Map <Room>(newRoom);
room.Id = Guid.NewGuid();
room.PropertyId = Guid.Parse(propertyId);
room.UpdatedDate = room.CreateDate = DateTime.UtcNow;
Expression <Func <Property, bool> > where = p => p.Id == Guid.Parse(propertyId);
Property property = _unitOfWork.PropertyRepository.GetSingle(where, "Rooms");
if (property.Rooms == null)
{
property.Rooms = new List <Room>();
}
property.Rooms.Add(room);
_unitOfWork.PropertyRepository.Edit(property);
_unitOfWork.Save();
return(_mapper.Map <RoomOutput>(room));
}
catch (Exception e)
{
throw e;
}
}
public void Edit(string propertyId, string roomId, RoomInput newRoom)
{
try
{
Func <QueryContainerDescriptor <Property>, QueryContainer> where =
q => q
.Match(
m => m
.Field(f => f.Id)
.Query(propertyId)
);
Property property = _unitOfWork.PropertyRepository.GetSingle(where);
List <Room> rooms = property.Rooms.ToList();
Room old = rooms.Find(p => p.Id == Guid.Parse(roomId));
property.UpdatedDate = old.UpdatedDate = DateTime.UtcNow;
_mapper.Map(newRoom, old);
_unitOfWork.PropertyRepository.Edit(property);
_unitOfWork.Save();
}
catch (Exception e)
{
throw e;
}
}
public async Task ExecuteAsync(Guid roomId, RoomInput input)
{
var room = await RoomRepository.GetAsync(roomId);
room.Cost = (int)input.Cost;
room.RoomType = input.RoomType;
room.Images = input.Images.ToList();
}
public static Sala Map(RoomInput s)
{
return(new Sala
{
Nome = s.Name,
Descricao = s.Description
});
}
public void UpdateRoom(RoomInput input, int id)
{
var room = RoomMapping.Map(input);
var oldRoom = _repository.Get(id);
oldRoom.Nome = room.Nome;
oldRoom.Descricao = room.Descricao;
_repository.Update(oldRoom);
_unitOfWork.Commit();
}
public IActionResult AddRooms(string id, RoomInput room)
{
try
{
return(Ok(_roomService.Add(id, room)));
}
catch (System.Exception e)
{
_logger.LogError(e, "error: {0}", e.Message);
return(BadRequest());
}
}
protected override void LoadContent()
{
ballTexture = Content.Load <Texture2D>("ball");
gatesTexture = Content.Load <Texture2D>("gates");
_spriteBatch = new SpriteBatch(GraphicsDevice);
inputFont = Content.Load <SpriteFont>("MainFont");
scoreFont = Content.Load <SpriteFont>("ScoreFont");
// TODO: use this.Content to load your game content here
playButton = new MenuButton(Content.Load <Texture2D>("LocalGame"), graphics.GraphicsDevice);
playButton.setPosition(new Vector2(350, 300));
roomInput = new RoomInput(Content.Load <Texture2D>("RoomNumber"), graphics.GraphicsDevice);
roomInput.setPosition(new Vector2(350, 400));
}
public void Edit(string propertyId, string roomId, RoomInput newRoom)
{
try
{
Expression <Func <Property, bool> > where = p => p.Id == Guid.Parse(propertyId);
Property property = _unitOfWork.PropertyRepository.GetSingle(where, "Rooms");
List <Room> rooms = property.Rooms.ToList();
Room old = rooms.Find(p => p.Id == Guid.Parse(roomId));
property.UpdatedDate = old.UpdatedDate = DateTime.UtcNow;
_mapper.Map(newRoom, old);
_unitOfWork.PropertyRepository.Edit(property);
_unitOfWork.Save();
}
catch (Exception e)
{
throw e;
}
}
public RoomOutput Add(string propertyId, RoomInput newRoom)
{
try
{
Room room = _mapper.Map <Room>(newRoom);
room.Id = Guid.NewGuid();
room.PropertyId = Guid.Parse(propertyId);
room.UpdatedDate = room.CreateDate = DateTime.UtcNow;
Func <QueryContainerDescriptor <Property>, QueryContainer> where =
q => q
.Match(
m => m
.Field(f => f.Id)
.Query(propertyId)
);
Property property = _unitOfWork.PropertyRepository.GetSingle(where);
if (property.Rooms == null)
{
property.Rooms = new List <Room>();
}
property.Rooms.Add(room);
_unitOfWork.PropertyRepository.Edit(property);
_unitOfWork.Save();
return(_mapper.Map <RoomOutput>(room));
}
catch (Exception e)
{
throw e;
}
}
public async Task ExecuteAsync(RoomInput input)
{
await RoomRepository.SaveAndFlushAsync(new RoomEntity(input.RoomType, input.Cost, input.Images));
}
public IActionResult PutSala(int id, RoomInput room)
{
_service.UpdateRoom(room, id);
return(Ok());
}
public IActionResult Post(RoomInput room)
{
_service.AddNewRoom(room);
return(Ok());
}
public async Task <ResultDto> Update(int id, RoomInput item)
{
var result = new ResultDto {
Message = ""
};
try
{
var room = await _roomDomainService.Get(id);
if (room == null)
{
result.Message = $"房间 {id} 不存在！";
return(result);
}
var content = room.ComparisonTo(item);
int west = room.West;
int east = room.East;
int south = room.South;
int north = room.North;
_mapper.Map(item, room);
List <int> changedIds = new List <int>();
changedIds.Add(room.Id);
//已修改
if (west != room.West)
{
//原来已设置
if (west > 0)
{
var oldRoomWest = await _roomDomainService.Get(west);
if (oldRoomWest != null)
{
oldRoomWest.East = 0;
oldRoomWest.EastName = "";
changedIds.Add(oldRoomWest.Id);
}
}
}
//已设置
if (room.West > 0 && room.West != room.Id)
{
var roomWest = await _roomDomainService.Get(room.West);
if (roomWest != null && roomWest.MapId == room.MapId)
{
roomWest.East = room.Id;
roomWest.EastName = room.Name;
room.WestName = roomWest.Name;
changedIds.Add(roomWest.Id);
}
else
{
room.West = 0;
room.WestName = "";
}
}
else
{
room.West = 0;
room.WestName = "";
}
if (east != room.East)
{
if (east > 0)
{
var oldRoomEast = await _roomDomainService.Get(east);
if (oldRoomEast != null)
{
oldRoomEast.West = 0;
oldRoomEast.WestName = "";
changedIds.Add(oldRoomEast.Id);
}
}
}
if (room.East > 0 && room.East != room.Id)
{
var roomEast = await _roomDomainService.Get(room.East);
if (roomEast != null && roomEast.MapId == room.MapId)
{
roomEast.West = room.Id;
roomEast.WestName = room.Name;
room.EastName = roomEast.Name;
changedIds.Add(roomEast.Id);
}
else
{
room.East = 0;
room.EastName = "";
}
}
else
{
room.East = 0;
room.EastName = "";
}
if (south != room.South)
{
if (south > 0)
{
var oldRoomSouth = await _roomDomainService.Get(south);
if (oldRoomSouth != null)
{
oldRoomSouth.North = 0;
oldRoomSouth.NorthName = "";
changedIds.Add(oldRoomSouth.Id);
}
}
}
if (room.South > 0 && room.South != room.Id)
{
var roomSouth = await _roomDomainService.Get(room.South);
if (roomSouth != null && roomSouth.MapId == room.MapId)
{
roomSouth.North = room.Id;
roomSouth.NorthName = room.Name;
room.SouthName = roomSouth.Name;
changedIds.Add(roomSouth.Id);
}
else
{
room.South = 0;
room.SouthName = "";
}
}
else
{
room.South = 0;
room.SouthName = "";
}
if (north != room.North)
{
if (north > 0)
{
var oldRoomNorth = await _roomDomainService.Get(north);
if (oldRoomNorth != null)
{
oldRoomNorth.South = 0;
oldRoomNorth.SouthName = "";
changedIds.Add(oldRoomNorth.Id);
}
}
}
if (room.North > 0 && room.North != room.Id)
{
var roomNorth = await _roomDomainService.Get(room.North);
if (roomNorth != null && roomNorth.MapId == room.MapId)
{
roomNorth.South = room.Id;
roomNorth.SouthName = room.Name;
room.NorthName = roomNorth.Name;
changedIds.Add(roomNorth.Id);
}
else
{
room.North = 0;
room.NorthName = "";
}
}
else
{
room.North = 0;
room.NorthName = "";
}
await _operatorLogDomainService.AddSuccess(new OperatorLogEntity
{
Type = OperatorLogType.修改房间,
Content = $"Id = {id},Data = {content}"
});
await Commit();
result.IsSuccess = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
await _operatorLogDomainService.AddError(new OperatorLogEntity
{
Type = OperatorLogType.修改房间,
Content = $"Data={JsonConvert.SerializeObject(item)},ErrorMessage={result.Message}"
});
await Commit();
}
return(result);
}
public async Task CreateRoom([FromServices] CreateRoomCommand command, [FromBody] RoomInput input)
{
await command.ExecuteAsync(input);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int Delete(RoomInput model)
{
int result = 0;
return(result);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int Update(RoomInput model)
{
int result = 0;
return(result);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int Add(RoomInput model)
{
int result = 0;
return(result);
}
public async Task <ResultDto> Add(RoomInput item, int mapId, int roomId, string position)
{
var result = new ResultDto {
Message = ""
};
try
{
var map = await _mapDomainService.Get(mapId);
if (map == null)
{
result.Message = $"参数错误（mapId={mapId}）";
return(result);
}
var room = _mapper.Map <RoomEntity>(item);
room.MapId = mapId;
await _roomDomainService.Add(room);
if (roomId > 0)
{
var oldRoom = await _roomDomainService.Get(roomId);
if (oldRoom != null && oldRoom.MapId == mapId)
{
switch (position)
{
case "west":
if (oldRoom.East == 0)
{
oldRoom.East = room.Id;
oldRoom.EastName = room.Name;
room.West = oldRoom.Id;
room.WestName = oldRoom.Name;
}
break;
case "east":
if (oldRoom.West == 0)
{
oldRoom.West = room.Id;
oldRoom.WestName = room.Name;
room.East = oldRoom.Id;
room.EastName = oldRoom.Name;
}
break;
case "south":
if (oldRoom.South == 0)
{
oldRoom.South = room.Id;
oldRoom.SouthName = room.Name;
room.North = oldRoom.Id;
room.NorthName = oldRoom.Name;
}
break;
case "north":
if (oldRoom.North == 0)
{
oldRoom.North = room.Id;
oldRoom.NorthName = room.Name;
room.South = oldRoom.Id;
room.SouthName = oldRoom.Name;
}
break;
}
}
}
await _operatorLogDomainService.AddSuccess(new OperatorLogEntity
{
Type = OperatorLogType.添加地图,
Content = JsonConvert.SerializeObject(item)
});
await Commit();
result.IsSuccess = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
await _operatorLogDomainService.AddError(new OperatorLogEntity
{
Type = OperatorLogType.添加地图,
Content = $"Data={JsonConvert.SerializeObject(item)},ErrorMessage={result.Message}"
});
await Commit();
}
return(result);
}
public string TryUpdateInputText(string userInput, Keys newInput, int maxLength, RoomInput roomInput)
{
if (!roomInput.isClicked)
{
return(userInput);
}
key = newInput;
if (KeyIsPressed())
{
if (newInput.ToString() != "None")
{
var textLength = userInput.ToString().Length;
if (newInput.ToString() == "Back")
{
if (textLength - 1 > 0)
{
var oldInput = userInput;
userInput = oldInput.Substring(0, oldInput.Length - 1);
return(userInput);
}
else
{
return("");
}
}
else
{
if (userInput.Length < maxLength)
{
userInput += newInput;
}
}
}
}
return(userInput);
}
