public async Task <IActionResult> CreateCharacter([FromBody] CreateCharacterRequest request)
{
var userId = Guid.Parse(User?.Identity?.Name ?? "");
_logger.LogInformation("Try to create character {firstName} {lastName} for user {User}",
request.FirstName, request.LastName, userId);
try
{
var character = await _mediator.Send(new CreateCharacterCommand(userId,
request.FirstName, request.LastName, request.Sex));
_logger.LogInformation("Character {CharacterId} created", character.Id);
return(Created(string.Empty, character));
}
catch (BusinessRuleValidationException e)
{
if (e.BrokenRule.GetType() == typeof(UserCanOnlyHaveOneCharacter))
{
var existingCharacter = await _mediator.Send(new GetUserCharacterQuery(userId));
_logger.LogWarning("User {User} already has a character {FirstName} {LastName} ({CharacterId})",
userId, existingCharacter?.FirstName, existingCharacter?.LastName, existingCharacter?.Id);
return(Conflict(existingCharacter));
}
throw;
}
}
public async Task CreateCharacterAsync_CreateANewCharacterInDatabase_SettingOwnerToCurrentUserId()
{
const int userId = 10;
var createCharacterRequest = new CreateCharacterRequest {
Name = "some-name"
};
var naheulbookExecutionContext = new NaheulbookExecutionContext {
UserId = userId
};
var createdCharacter = new Character();
var initialInventory = new List <Item>();
_characterFactory.CreateCharacter(createCharacterRequest)
.Returns(createdCharacter);
_itemUtil.CreateInitialPlayerInventoryAsync(createCharacterRequest.Money)
.Returns(initialInventory);
var actualCharacter = await _service.CreateCharacterAsync(naheulbookExecutionContext, createCharacterRequest);
Received.InOrder(() =>
{
_unitOfWorkFactory.GetUnitOfWork().Characters.Add(createdCharacter);
_unitOfWorkFactory.GetUnitOfWork().SaveChangesAsync();
});
actualCharacter.OwnerId.Should().Be(userId);
createdCharacter.Should().BeSameAs(actualCharacter);
createdCharacter.Items.Should().BeSameAs(initialInventory);
}
public Character Create(CreateCharacterRequest character)
{
var CreatedCharacter = _mapper.Map <Character>(character);
_chars.Create(CreatedCharacter);
return(CreatedCharacter);
}
public ActionResult InsertCharacter([FromBody]CreateCharacterRequest request)
{
request.Validate();
if (request.Invalid)
return BadRequest($"Favor informar valores válidos para: {ErrorHelper.GetErrors(request)}");
_characterService.InsertCharacter(request.Name, request.Role, request.Patronus, request.House);
return Ok();
}
public async Task CreateAsync(CreateCharacterRequest request)
{
var entity = new CharacterEntity
{
PlayerFullName = request.PlayerFullName,
CharacterFullName = request.CharacterFullName,
AccruedDowntimeDays = 0
};
await(await _container).CreateItemAsync(await _entityMutator.CreateMetadataAsync(entity, request.SharedWith));
}
/// <summary>
/// Handles the creation of a character.
/// </summary>
/// <param name="session">The session instance</param>
/// <param name="length">The length of the packet</param>
/// <param name="opcode">The opcode of the incoming packet</param>
/// <param name="requestId"></param>
/// <param name="data">The packet data</param>
/// <returns></returns>
public override bool Handle(ServerSession session, int length, int opcode, int requestId, byte[] data)
{
var request = new CreateCharacterRequest();
int serverId = data[0];
int userId = (data[1] & 0xFF) + ((data[2] & 0xFF) << 8) + ((data[3] & 0xFF) << 16) + ((data[4] & 0xFF) << 24);
request = Serializer.Deserialize <CreateCharacterRequest>(data.Skip(5).ToArray());
using (SqlConnection connection = new DatabaseConnector().GetConnection("origin_gamedata"))
{
var cmd = new SqlCommand("create_character", connection);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue(":server_id", serverId);
cmd.Parameters.AddWithValue(":user_id", userId);
cmd.Parameters.AddWithValue(":character_name", Encoding.UTF8.GetString(request.name).TrimEnd('\0'));
cmd.Parameters.AddWithValue(":race", request.race);
cmd.Parameters.AddWithValue(":mode", request.mode);
cmd.Parameters.AddWithValue(":profession", request.profession);
cmd.Parameters.AddWithValue(":hair", request.hair);
cmd.Parameters.AddWithValue(":face", request.face);
cmd.Parameters.AddWithValue(":height", request.height);
cmd.Parameters.AddWithValue(":sex", request.sex);
connection.Open();
// Execute the prepared statement
var reader = cmd.ExecuteReader();
// Loop through the results
while (reader.Read())
{
var bldr = new PacketBuilder(opcode);
bldr.WriteInt(requestId);
// Write the result
bldr.WriteByte((byte)reader.GetInt32(0));
session.Write(bldr.ToPacket());
}
reader.Close();
}
return(true);
}
public IActionResult CreateCharacter(CreateCharacterRequest request)
{
if (_charService.NameExists(request.Name))
{
return(UnprocessableEntity(new {
Message = $"There's already a character with the name ({request.Name})"
}));
}
var createdChar = _charService.Create(request);
return(Ok(new {
Message = "Character created successfully!",
Character = _mapper.Map <CharacterResponse>(createdChar)
}));
}
public async Task PostCreateCharacterAsync_ShouldCreateCharacterWithCharacterService_ThenReturnCharacterResponse()
{
var createCharacterRequest = new CreateCharacterRequest();
var createdCharacter = new Character();
var characterResponse = new CreateCharacterResponse();
_characterService.CreateCharacterAsync(_executionContext, createCharacterRequest)
.Returns(createdCharacter);
_mapper.Map <CreateCharacterResponse>(createdCharacter)
.Returns(characterResponse);
var result = await _controller.PostCreateCharacterAsync(_executionContext, createCharacterRequest);
result.Value.Should().BeSameAs(characterResponse);
result.StatusCode.Should().Be(StatusCodes.Status201Created);
}
public async Task CreateCharacter(CreateCharacterRequest request)
{
var identityView = IdentityView.FromObjectId(_dbContext, (SHIdentity.FromPrincipal(Context.User)).ObjectId);
if (identityView.Identity == null)
{
return;
}
if (!Context.User.Identity.IsAuthenticated)
{
return;
}
if (request == null || String.IsNullOrEmpty(request.Name))
{
return;
}
if (_dbContext.Mob.Count(e => e.AccountId == identityView.Identity.Id) > 2)
{
return;
}
var mob = new Mob()
{
MobClassId = request.MobClassId,
MobRaceId = request.MobRaceId,
AccountId = identityView.Identity.Id,
Name = request.Name,
ZoneId = 1
};
if (_dbContext.Mob.Any(e => e.AccountId == identityView.Identity.Id && e.Name.Equals(mob.Name)))
{
return;
}
mob = _dbContext.Mob.Add(mob).Entity;
_dbContext.SaveChanges();
var response = new CreateCharacterResponse();
response.Mob = mob;
await Clients.Client(Context.ConnectionId).SendAsync("CreateCharacterResponse", "", JsonConvert.SerializeObject(response));
}
public async Task <CreatedActionResult <CreateCharacterResponse> > PostCreateCharacterAsync(
[FromServices] NaheulbookExecutionContext executionContext,
CreateCharacterRequest request
)
{
try
{
var character = await _characterService.CreateCharacterAsync(executionContext, request);
return(_mapper.Map <CreateCharacterResponse>(character));
}
catch (ForbiddenAccessException ex)
{
throw new HttpErrorException(StatusCodes.Status403Forbidden, ex);
}
catch (GroupNotFoundException ex)
{
throw new HttpErrorException(StatusCodes.Status400BadRequest, ex);
}
}
/// <summary>
/// Handles an incoming character creation request.
/// </summary>
/// <param name="session">The session instance</param>
/// <param name="length">The length of the packet</param>
/// <param name="opcode">The opcode of the incoming packet</param>
/// <param name="data">The packet data</param>
/// <returns></returns>
public override bool Handle(ServerSession session, int length, int opcode, byte[] data)
{
var request = new CreateCharacterRequest();
request.unknown = data[0];
request.race = data[1];
request.mode = data[2];
request.hair = data[3];
request.face = data[4];
request.height = data[5];
request.profession = data[6];
request.sex = data[7];
Array.Copy(data, 8, request.name, 0, length - 8);
var player = GameService.GetPlayerForIndex(session.GetGameIndex());
GameService.PushTask(new CreateCharacterTask(player, request));
return(true);
}
public void CreateCharacterAsync_WhenGroupIdIsGiven_CheckIsGroupOwner()
{
const int groupId = 8;
var createCharacterRequest = new CreateCharacterRequest {
Name = "some-name", GroupId = groupId
};
var naheulbookExecutionContext = new NaheulbookExecutionContext();
var createdCharacter = new Character();
var group = new Group();
_characterFactory.CreateCharacter(createCharacterRequest)
.Returns(createdCharacter);
_unitOfWorkFactory.GetUnitOfWork().Groups.GetAsync(groupId)
.Returns(group);
_authorizationUtil.When(x => x.EnsureIsGroupOwner(naheulbookExecutionContext, group))
.Throw(new ForbiddenAccessException());
Func <Task> act = () => _service.CreateCharacterAsync(naheulbookExecutionContext, createCharacterRequest);
act.Should().Throw <ForbiddenAccessException>();
}
public async Task CreateCharacterAsync_WhenGroupIdIsGiven_PutCharacterInGroup()
{
const int userId = 10;
const int groupId = 8;
var createCharacterRequest = new CreateCharacterRequest {
Name = "some-name", GroupId = groupId
};
var naheulbookExecutionContext = new NaheulbookExecutionContext {
UserId = userId
};
var createdCharacter = new Character();
var group = new Group();
_characterFactory.CreateCharacter(createCharacterRequest)
.Returns(createdCharacter);
_itemUtil.CreateInitialPlayerInventoryAsync(createCharacterRequest.Money)
.Returns(new List <Item>());
_unitOfWorkFactory.GetUnitOfWork().Groups.GetAsync(groupId)
.Returns(group);
var actualCharacter = await _service.CreateCharacterAsync(naheulbookExecutionContext, createCharacterRequest);
actualCharacter.Group.Should().BeSameAs(group);
}
public async Task CreateAsync(CreateCharacterRequest request) => await _service.CreateAsync(request);
public async Task <IActionResult> CreateCharacter([FromBody] CreateCharacterRequest request)
{
request.SetData(_usersRepository, _customerGuid);
return(await request.Handle());
}
/// <summary>
/// The constructor for this task, which will define the player instance
/// to operate on.
/// </summary>
/// <param name="player">The player instance</param>
public CreateCharacterTask(Player player, CreateCharacterRequest request)
{
_player = player;
_request = request;
}
public async Task CreateAsync(CreateCharacterRequest request) => await _writeRepository.CreateAsync(request);
public static void HandlePacket(byte[] Data, byte Module, PacketType Type, UInt32 Unk01, TORGameClient Client)
{
// TODO: Check for packet drop
IPacket iPacket = null;
ClientState State = Client.State;
switch (State)
{
case ClientState.CONNECTING:
switch (Type)
{
case PacketType.ConnectionHandshake:
iPacket = new ConnectionHandshake();
break;
default:
Log.Write(LogLevel.Warning, "Received Unknown Packet [{0:X}] on State '{1}'\n{2}", Type, State.ToString(), Data.ToHEX());
break;
}
break;
case ClientState.CONNECTED:
switch (Type)
{
case PacketType.ObjectReply:
iPacket = new ObjectReply();
break;
case PacketType.Ping:
iPacket = new Ping();
break;
default:
Log.Write(LogLevel.Warning, "Received Unknown Packet [{0:X}] on State '{1}'\n{2}", Type, State.ToString(), Data.ToHEX());
break;
}
break;
case ClientState.AUTHED:
switch (Type)
{
case PacketType.CreateCharacterRequest:
Log.Write(LogLevel.Warning, "\n{0}", Data.ToHEX());
iPacket = new CreateCharacterRequest();
break;
case PacketType.ObjectReply:
iPacket = new ObjectReply();
break;
case PacketType.ServiceRequest:
iPacket = new ServiceRequest();
break;
case PacketType.RequestClose:
iPacket = new RequestClose();
break;
case PacketType.TimeRequesterRequest:
iPacket = new TimeRequesterRequest();
break;
case PacketType.HackNotifyData:
iPacket = new HackNotifyData();
break;
case PacketType.CMsgC26464A9:
iPacket = new CMsgC26464A9();
break;
case PacketType.CMsg7CB9A193:
iPacket = new CMsg7CB9A193();
break;
case PacketType.ModulesList:
iPacket = new ModulesList();
break;
case PacketType.AreaModulesList:
iPacket = new AreaModulesList();
break;
case PacketType.SetTrackingInfo:
iPacket = new SetTrackingInfo();
break;
case PacketType.CharacterListRequest:
iPacket = new CharacterListRequest();
break;
case PacketType.SelectCharacterRequest:
iPacket = new SelectCharacterRequest();
break;
case PacketType.Ping:
iPacket = new Ping();
break;
default:
Log.Write(LogLevel.Warning, "Received Unknown Packet [{0:X}] on State '{1}'\n{2}", Type, State.ToString(), Data.ToHEX());
break;
}
break;
case ClientState.IN_GAME:
switch (Type)
{
case PacketType.RequestClose:
iPacket = new RequestClose();
break;
case PacketType.SetTrackingInfo:
iPacket = new SetTrackingInfo();
break;
case PacketType.Ping:
iPacket = new Ping();
break;
// TODO: Implement Game Packets
default:
Log.Write(LogLevel.Warning, "Received Unknown Packet [{0:X}] on State '{1}'\n{2}", Type, State.ToString(), Data.ToHEX());
break;
}
break;
}
if (iPacket != null)
{
iPacket.SetClient(Client);
iPacket.SetBuffers(Data);
//Log.Write(LogLevel.EDebug, "{0}", Data.ToHEX());
iPacket.Read();
iPacket.Run();
}
}
public async Task <IActionResult> Create(CreateCharacterRequest request)
{
return(Ok());
}
public async Task <Character> CreateCharacterAsync(NaheulbookExecutionContext executionContext, CreateCharacterRequest request)
{
using (var uow = _unitOfWorkFactory.CreateUnitOfWork())
{
var character = _characterFactory.CreateCharacter(request);
if (request.GroupId.HasValue)
{
var group = await uow.Groups.GetAsync(request.GroupId.Value);
if (group == null)
{
throw new GroupNotFoundException(request.GroupId.Value);
}
_authorizationUtil.EnsureIsGroupOwner(executionContext, group);
character.Group = group;
}
character.OwnerId = executionContext.UserId;
character.Items = await _itemUtil.CreateInitialPlayerInventoryAsync(request.Money);
uow.Characters.Add(character);
await uow.SaveChangesAsync();
return(character);
}
}
public Character CreateCharacter(CreateCharacterRequest characterRequest)
{
var character = new Character
{
Name = characterRequest.Name,
Sex = characterRequest.Sex,
IsActive = true,
IsNpc = characterRequest.IsNpc,
Ad = characterRequest.Stats.Ad,
Cha = characterRequest.Stats.Cha,
Cou = characterRequest.Stats.Cou,
Fo = characterRequest.Stats.Fo,
Int = characterRequest.Stats.Int,
Notes = characterRequest.Notes,
Level = 1,
Experience = 0,
FatePoint = characterRequest.FatePoint,
OriginId = characterRequest.OriginId,
Modifiers = new List <CharacterModifier>(),
};
if (characterRequest.JobId.HasValue)
{
character.Jobs = new List <CharacterJob>
{
new CharacterJob
{
JobId = characterRequest.JobId.Value
}
}
}
;
character.Skills = characterRequest.SkillIds
.Select(x => new CharacterSkill
{
SkillId = x
})
.ToList();
foreach (var modifiedStat in characterRequest.ModifiedStat.Values)
{
character.Modifiers.Add(new CharacterModifier
{
Name = modifiedStat.Name,
IsActive = true,
Permanent = true,
DurationType = "forever",
Values = modifiedStat.Stats.Select(s => new CharacterModifierValue
{
StatName = s.Key,
Value = (short)s.Value,
Type = "ADD",
}).ToList()
});
}
if (characterRequest.SpecialityId.HasValue)
{
character.Specialities = new List <CharacterSpeciality>
{
new CharacterSpeciality
{
SpecialityId = characterRequest.SpecialityId.Value
}
}
}
;
return(character);
}
