private void PopulateCharactersIfNoExist()
{
if (!_characterRepository.GetAll().Any())
{
_characterRepository.Add(new Character("Vvv Nnnn"));
_characterRepository.Add(new Character("123 456"));
_characterRepository.Add(new Character("Ivan Pereb"));
}
}
private void PopulateCharactersIfNoneExist()
{
if (!_characterRepository.ListAll().Any())
{
_characterRepository.Add(new Character("Darth Maul"));
_characterRepository.Add(new Character("Darth Vader"));
_characterRepository.Add(new Character("Yoda"));
_characterRepository.Add(new Character("Mace Windu"));
}
}
private void PopulateCharactersIfNoneExist()
{
// 如果不存在则添加
if (!_characterRepository.ListAll().Any())
{
_characterRepository.Add(new Character("Tom"));
_characterRepository.Add(new Character("Jack"));
_characterRepository.Add(new Character("Kevin"));
}
}
// GET: /characters/
public IActionResult Index()
{
var characters = _characterRepository.ListAll();
if (!characters.Any())
{
_characterRepository.Add(new Character("Darth Maul"));
_characterRepository.Add(new Character("Darth Vader"));
_characterRepository.Add(new Character("Yoda"));
_characterRepository.Add(new Character("Mace Windu"));
characters = _characterRepository.ListAll();
}
return(View(characters));
}
public IActionResult CreateCharacter(CreateCharacterViewModel character)
{
if (!_loginManager.IsLoggedIn(HttpContext?.Session))
{
return(RedirectToAction("Login", "Player"));
}
if (
_repo.Read()
.Count(c => c.OwningPlayerid == HttpContext.Session.GetInt32(ContextData.PlayerId.ToString())) > 3)
{
ModelState.TryAddModelError(String.Empty, "You already own too many characters.");
}
if (ModelState.IsValid)
{
_repo.Add(new Character()
{
Name = character.Name,
Classid = character.ClassId,
OwningPlayerid = HttpContext?.Session.GetInt32(ContextData.PlayerId.ToString())
});
return(RedirectToAction("Index"));
}
ViewBag.Classes = _classRepo.Read().Select(c
=> new SelectListItem()
{
Text = c.Name, Value = c.Id.ToString()
});
return(RedirectToAction("CreateCharacter"));
}
public async Task <Guid> Handle(CreateCharacter command)
{
var id = Guid.NewGuid();
await _repo.Add(new Character(id, command.Name, command.Description, command.Traits));
return(id);
}
public void CharacterRepository_AddCharacter_ValidCall()
{
//Arrange
List <CharacterDM> charList = CreateTestData.GetListOfCharacters();
var mockSet = new Mock <DbSet <CharacterDM> >()
.SetupData(charList, o =>
{
return(charList.Single(x => x.Character_id.CompareTo(o.First()) == 0));
});
using (var mockContext = AutoMock.GetLoose())
{
mockContext.Mock <CharacterContext>()
.Setup(x => x.Set <CharacterDM>()).Returns(mockSet.Object);
ICharacterRepository toTest = mockContext.Create <CharacterRepository>();
var expected = CreateTestData.getSampleCharacter();
expected.Character_id = Guid.Parse("33855fe6-807a-46e3-850f-ada7dacfc435");
//Act
toTest.Add(expected);
var actual = toTest.Get(expected.Character_id);
//Assert
actual.Should().NotBeNull();
expected.Should().NotBeNull();
actual.Should().BeOfType <CharacterDM>();
expected.Should().BeOfType <CharacterDM>();
actual.Should().BeEquivalentTo(expected);
}
}
public IActionResult Create([FromBody] Character item)
{
logger.LogInformation("Entered POST /api/character");
// Todo Validate item
var added = repository.Add(item);
return(new CreatedAtRouteResult(nameof(Create), added));
}
public async Task <CreateCharacterResponse> Handle(CreateCharacterRequest request, CancellationToken cancellationToken)
{
var entity = new Character
{
Name = request.Name
};
await _characterRepository.Add(entity);
return(new CreateCharacterResponse {
Character = entity
});
}
public IActionResult Create([FromBody] Personagem personagem)
{
if (personagem == null)
{
return(BadRequest());
}
personagem.Criador = User.Identity.Name;
//personagem.Vida = qtd vida da classe
_characterRepository.Add(personagem);
return(CreatedAtRoute("GetPersonagem", new { id = personagem.Id }, personagem));
}
private void PopulateCharactersIfNoneExist()
{
if (!characterRepository.ListAll().Any())
{
characterRepository.Add(new Character()
{
Name = "lukasz"
});
characterRepository.Add(new Character()
{
Name = "Anita"
});;
characterRepository.Add(new Character()
{
Name = "Stefan"
});
characterRepository.Add(new Character()
{
Name = "Kunegunda"
});
}
}
private async Task <bool> InsertCharacter(VoiceActingRole voiceActingRole)
{
var existingCharacter = await characterRepository.GetAsync(voiceActingRole.Character.MalId);
if (existingCharacter == null)
{
try
{
JikanDotNet.Character characterFullData = await SendSingleCharacterRequest(voiceActingRole.Character.MalId, 0);
string nicknames = string.Empty;
if (characterFullData != null)
{
logger.Log($"Parsed id:{characterFullData.MalId}");
if (characterFullData.Nicknames.Any())
{
nicknames = string.Join(';', characterFullData.Nicknames.ToArray());
}
characterRepository.Add(
new Data.Model.Character
{
MalId = characterFullData.MalId,
ImageUrl = EmptyStringIfPlaceholder(characterFullData.ImageURL),
Name = characterFullData.Name,
Popularity = characterFullData.MemberFavorites,
About = characterFullData.About,
NameKanji = characterFullData.NameKanji,
Nicknames = nicknames
}
);
await characterRepository.CommitAsync();
return(true);
}
return(false);
}
catch (Exception ex)
{
logger.Log($"Error during inserting character {voiceActingRole.Anime.Name} with id {voiceActingRole.Anime.MalId}: {ex.Message}");
return(false);
}
}
else
{
return(true); //already inserted
}
}
public async Task <IEntityCreateResult> CreateCharacterAsync(ICreateCharacterModel createModel)
{
if (createModel is null)
{
throw new ArgumentNullException(nameof(createModel));
}
await _createCharacterValidator.ValidateAndThrowAsync(createModel);
Character characterToAdd = await _createCharacterFactory.CreateAsync(createModel);
IEntityCreateResult identity = _characterRepository.Add(characterToAdd);
return(identity);
}
private void SaveBtn_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(characterCmb.Text) || characterCmb.Text.Equals("<character name>"))
{
MessageBox.Show("choose character name to save");
}
else if (string.IsNullOrWhiteSpace(character.CharacterName))
{
character.CharacterName = characterCmb.Text;
_characterRepository.Add(character);
}
else
{
_characterRepository.Save();
}
}
public async Task <IActionResult> AddIfNotExistsCharacter(CharacterToAddDTO characterToAdd)
{
if (await _characterRepository.CharacterExists(characterToAdd))
{
// 409 conflict seems to be most appropriate status code
return(StatusCode(409));
}
var character = new Character
{
Name = characterToAdd.Name,
Realm = characterToAdd.Realm,
Region = characterToAdd.Region,
Class = characterToAdd.Class,
FullName = characterToAdd.FullName,
};
var addedCharacter = await _characterRepository.Add(character);
return(StatusCode(201));
}
public IActionResult Add(CharacterModel model)
{
//add parameter model object to the collection
var ff = model.Picture;
var filePath = Path.GetTempFileName();
var path = Path.Combine(
Directory.GetCurrentDirectory(), "wwwroot/HeroImages",
ff.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
//await ff.CopyToAsync(stream);
ff.CopyToAsync(stream);
}
model.ImageUrl = ff.FileName;
_repo.Add(model);
_repo.Export();
return(RedirectToAction("Index"));
}
public IHttpActionResult Post([FromBody] FullCharacterDTO fullCharacterDTO, string playerName)
{
if (ModelState.IsValid)
{
var character = CharacterMapper.CharacterFromFullDTO(fullCharacterDTO);
if (!_characterRepository.Contains(character))
{
character.PlayerAccountName = playerName;
_characterRepository.Add(character);
var basicDTO = CharacterMapper.BasicDTOFromCharacter(character);
return(Ok(basicDTO));
}
else
{
return(Conflict());
}
}
else
{
return(BadRequest(ModelState));
}
}
public Character RetrieveCharacter(string realm, string name)
{
Character character = _blizzardConnectionRepository.GetCharacter(name, realm, getGuild: true);
Character oldCharacter = _characterRepository.GetCharacter(realm, name);
if (character.Guild != null)
{
Guild guild = _guildRepository.GetGuild(character.Guild.Realm, character.Guild.Name);
character.Guild = guild;
}
if (oldCharacter == null)
{
_characterRepository.Add(character);
}
else
{
character.Key = oldCharacter.Key;
_characterRepository.Update(character.Key.ToString(), character);
}
return(_characterRepository.GetCharacter(character.Key.ToString()));
}
