public ValueTask CreateAsync(CreateCharacterDto dto, CancellationToken cancellationToken)
{
return(_serviceClient.PostAsync(
ServiceConfiguration.ServiceName,
$"{RoutePrefix}",
EndpointAuthentication.Profile,
dto,
cancellationToken));
}
public async Task <IActionResult> PostAsync([FromBody] CreateCharacterDto item)
{
await _mediator.Send(new CreateCharacterCommand()
{
CreateCharacter = item
});
return(Ok());
}
public long CreateCharacter(CreateCharacterDto dto)
{
using (var db = DataAccessUtil.CreateSqlConnection()) {
db.Open();
var command = GetCreateCharacterCommand(db, dto, UniqueIdUtil.GenerateUniqueId(), false);
command.ExecuteNonQuery();
return(QueryUtil.GetLastInsertedPrimaryKey(db));
}
}
public async ValueTask <ActionResult> Create(CreateCharacterDto dto)
{
var name = new CharacterName(dto.Name);
var characterId = await _characterRepository.NextIdAsync();
var character = new Character(characterId, ProfileId, name);
await _characterRepository.SaveAsync(character);
return(CreatedAtAction(
nameof(GetByCharacterId),
new { characterId = characterId.Value },
character.ToCharacterResource()));
}
public async Task <ApiResponse <object> > Create(CreateCharacterDto request)
{
var command = new CreateCharacterCommand
{
Name = request.Name,
Class = request.Class
};
await _operationMediator.HandleAsync(command);
var location = Url.Link(GetByIdRouteName, new { id = command.GeneratedId });
return(ApiResponse.Created(location, command.GeneratedId));
}
public async Task <IActionResult> CreateCharacter(CreateCharacterDto newCharacter)
{
// return Ok(await _characterService.CreateCharacter(newCharacter));
// call createCharacter and wrap object with service response object to get additonal info (success/message)
ServiceResponse <List <GetCharacterDto> > response = await _characterService.CreateCharacter(newCharacter);
// if success is false then creating a character failed
if (response.Success == false)
{
return(Conflict(response));
}
// creation successful
return(Ok(response));
}
public async Task <Response <Model.Character> > CreateAsync(CreateCharacterDto dto)
{
var response = Response <Model.Character> .Create();
if (dto == null)
{
return(response.WithBusinessError("Character is invalid"));
}
var houseResponse = await HouseService.GetHouseAsync(dto.House);
if (houseResponse.HasError)
{
return(response.WithMessages(houseResponse.Messages));
}
return(await CharacterFactory.CreateAsync(dto, houseResponse));
}
public async Task <Response <CharacterModel> > CreateAsync(CreateCharacterDto dto, HouseModel house)
{
var response = Response <CharacterModel> .Create();
var characterHouse = new CharacterHouse(house);
var createCharacterResponse = CharacterModel.Create(dto.Name, dto.Role, dto.School, characterHouse, dto.Patronus);
if (createCharacterResponse.HasError)
{
return(response.WithMessages(createCharacterResponse.Messages));
}
await CharacterRepository.AddAsync(createCharacterResponse);
if (!await Uow.CommitAsync())
{
return(response.WithCriticalError("Failed to try to save the character"));
}
return(response.SetValue(createCharacterResponse));
}
private SqliteCommand GetCreateCharacterCommand(SqliteConnection db, CreateCharacterDto dto, string guid, bool ignoreDuplicates)
{
var ignoreClause = ignoreDuplicates ? "OR IGNORE" : "";
var command = new SqliteCommand();
command.Connection = db;
command.CommandText = $"INSERT {ignoreClause} INTO character(name, description, library_id, birth_date, career_start_date, career_end_date, rating, deleted, deletion_due_to_cascade, cover_file_id, calendar_id, creator, unique_id) VALUES(@Name, @Description, @LibraryId, @BirthDate, @CareerStartDate, @CareerEndDate, @Rating, false, false, @CoverFileId, @CalendarId, @IsCreator, @UniqueId)";
command.Parameters.AddWithValue("@Name", dto.Name);
command.Parameters.AddWithValue("@Description", dto.Description);
command.Parameters.AddWithValue("@LibraryId", dto.LibraryId);
command.Parameters.AddWithValue("@BirthDate", QueryUtil.GetNullableValueForStorage(dto.BirthDate));
command.Parameters.AddWithValue("@CareerStartDate", QueryUtil.GetNullableValueForStorage(dto.CareerStartDate));
command.Parameters.AddWithValue("@CareerEndDate", QueryUtil.GetNullableValueForStorage(dto.CareerEndDate));
command.Parameters.AddWithValue("@Rating", dto.Rating);
command.Parameters.AddWithValue("@CoverFileId", QueryUtil.GetNullableIdForStorage(dto.CoverMediaId));
command.Parameters.AddWithValue("@CalendarId", QueryUtil.GetNullableIdForStorage(dto.CalendarId));
command.Parameters.AddWithValue("@IsCreator", dto.IsCreator);
command.Parameters.AddWithValue("@UniqueId", guid);
return(command);
}
private Character CreateAndRetrieveCharacter(CreateCharacterDto dto)
{
var characterId = characterRepository.CreateCharacter(dto);
return(characterRepository.GetCharacter(characterId));
}
public async Task <ServiceResponse <List <GetCharacterDto> > > CreateCharacter(CreateCharacterDto newCharacter)
{
// Wrapper
ServiceResponse <List <GetCharacterDto> > serviceResponse = new ServiceResponse <List <GetCharacterDto> >();
try
{
// map CreateCharacterDto to character
Character character = _mapper.Map <Character>(newCharacter);
// set character property User to user with the userId from the IHttpContext
character.User = await _context.Users.FirstOrDefaultAsync(u => u.Id == GetUserId());
// add character to database and save changes
await _context.Characters.AddAsync(character);
await _context.SaveChangesAsync();
// after adding new character to db, return all characters from db
serviceResponse.Data = (_context.Characters.Where(u => u.Id == GetUserId()).Select(c => _mapper.Map <GetCharacterDto>(c))).ToList();
serviceResponse.Message = "Character has been created.";
}
catch (Exception ex)
{
// creation failed
serviceResponse.Success = false;
serviceResponse.Message = "Character could not be created: " + ex.Message;
}
return(serviceResponse);
}
public Character CreateAndRetrieveCharacter(CreateCharacterDto dto)
{
long libraryId = CreateCharacter(dto);
return(new Character(libraryId, dto));
}
public long CreateCharacter(CreateCharacterDto dto)
{
return(characterRepository.CreateCharacter(dto));
}
