public async Task <ActionResult <Character> > PostCharacter(CharacterDTO character)
{
character.UserName = User.FindFirst("UserName").Value;
await _character.Create(character);
await _log.CreateLog(HttpContext, User.FindFirst("UserName").Value);
return(CreatedAtAction("GetCharacter", new { id = character.Id }, character));
}
/// <summary>
/// Gets the game character dto.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
internal static CharacterDTO GetDTO(DndDmHelperContext context, int id)
{
return(context.GameCharacters
.Include(e => e.Race)
.Include(e => e.Class)
.Include(e => e.BaseStats)
.ThenInclude(e => e.BaseStat)
.Select(e => CharacterDTO.GenerateDTOFromGameCharacter(e))
.FirstOrDefault(e => e.ID == id));
}
public void EditCharacter(CharacterDTO c)
{
var character = _characters.FindBy(ch => ch.CharacterId == c.CharacterId).Single();
character.Name = c.Name;
character.Level = c.Level;
character.Spellbook = ToSpellList(c.Spellbook);
_characters.Save();
}
public CharacterInfoControl(CharacterDTO character)
{
InitializeComponent();
lblName.Text = character.Name;
ResourceManager resourceManager = new ResourceManager("FableWorld.Resources", GetType().Assembly);
Bitmap image = (Bitmap)resourceManager.GetObject("Warrior");
pbCharacter1.Image = image;
}
private CharacterDTO Update(Character entity, CharacterDTO character, OpenNosContext context)
{
if (entity != null)
{
_mapper.Map(character, entity);
context.SaveChanges();
}
return(_mapper.Map <CharacterDTO>(entity));
}
public async Task <IActionResult> Create(CharacterDTO character)
{
if (ModelState.IsValid)
{
await _character.Create(character);
return(RedirectToAction(nameof(Index)));
}
return(View(character));
}
private Character ToCharacter(CharacterDTO dto)
{
return(new Character()
{
CharacterId = dto.CharacterId,
Name = dto.Name,
Level = dto.Level,
Spellbook = ToSpellList(dto.Spellbook)
});
}
public async Task <ActionResult <CharacterDTO> > GetCharacter(int id)
{
CharacterDTO character = new CharacterDTO(await repository.Read(id));
if (character == null)
{
return(NotFound());
}
return(character);
}
internal Character ConvertCharacter(CharacterDTO character)
{
int maxLength = 20;
if (maxLength < character.Name.Length || string.IsNullOrEmpty(character.Name) || string.IsNullOrEmpty(character.SpecializationName))
{
throw new ArgumentOutOfRangeException();
}
return(new Character(character.CharacterId, character.Name, character.CreatedOn, character.SpecializationName, character.Score));
}
public async Task <IActionResult> Post(CharacterDTO newCharacter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var characterCreationResult = await _characterEditor.Create(newCharacter);
return(HandleResponseDefault(characterCreationResult,
() => CreatedAtAction(nameof(Get), new { id = characterCreationResult.Value.Id }, characterCreationResult.Value)));
}
public void ConvertCharacterDTOFailTest()
{
//Arrange
CharacterCollection characterCollection = new CharacterCollection(new CharacterMemoryContext());
DateTime date = DateTime.Now;
CharacterDTO character = new CharacterDTO(0, "John", date, "Paladin", 200);
//Act
Character convertedCharacter = characterCollection.ConvertCharacter(character);
//Assert
Assert.AreNotEqual(new Character(0, "John", date, "Wizard", 200), convertedCharacter);
}
public void FamilyKick(string packet)
{
string[] packetsplit = packet.Split(' ');
if (packetsplit.Length == 3)
{
if (Session.Character.Family == null || Session.Character.FamilyCharacter == null)
{
return;
}
if (Session.Character.FamilyCharacter.Authority == FamilyAuthority.Member)
{
Session.SendPacket(Session.Character.GenerateInfo(string.Format(Language.Instance.GetMessageFromKey("NOT_ALLOWED_KICK"))));
return;
}
ClientSession kickSession = ServerManager.Instance.GetSessionByCharacterName(packetsplit[2]);
if (kickSession != null && kickSession.Character.Family?.FamilyId == Session.Character.Family.FamilyId)
{
if (kickSession.Character.FamilyCharacter?.Authority == FamilyAuthority.Head)
{
Session.SendPacket(Session.Character.GenerateInfo(Language.Instance.GetMessageFromKey("CANT_KICK_HEAD")));
return;
}
if (kickSession.Character.CharacterId == Session.Character.CharacterId)
{
Session.SendPacket(Session.Character.GenerateInfo(Language.Instance.GetMessageFromKey("CANT_KICK_YOURSELF")));
return;
}
DAOFactory.FamilyCharacterDAO.Delete(packetsplit[2]);
Session.Character.Family.InsertFamilyLog(FamilyLogType.FamilyManage, kickSession.Character.Name, "", "", "", 0, 0, 0, 0, 0);
System.Reactive.Linq.Observable.Timer(TimeSpan.FromMilliseconds(100))
.Subscribe(
o =>
{
kickSession.CurrentMapInstance?.Broadcast(kickSession.Character.GenerateGidx());
});
}
else
{
CharacterDTO dbCharacter = DAOFactory.CharacterDAO.LoadByName(packetsplit[2]);
if (dbCharacter != null)
{
FamilyCharacterDTO dbFamilyCharacter = DAOFactory.FamilyCharacterDAO.LoadByCharacterId(dbCharacter.CharacterId);
if (dbFamilyCharacter != null && dbFamilyCharacter.FamilyId == Session.Character.Family.FamilyId)
{
DAOFactory.FamilyCharacterDAO.Delete(packetsplit[2]);
Session.Character.Family.InsertFamilyLog(FamilyLogType.FamilyManage, dbCharacter.Name, "", "", "", 0, 0, 0, 0, 0);
}
}
}
}
}
public void FamilyKick(string packet)
{
string[] packetsplit = packet.Split(' ');
if (packetsplit.Length == 3)
{
if (Session.Character.Family == null || Session.Character.FamilyCharacter == null)
{
return;
}
if (Session.Character.FamilyCharacter.Authority == FamilyAuthority.Member)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(string.Format(Language.Instance.GetMessageFromKey("NOT_ALLOWED_KICK"))));
return;
}
ClientSession kickSession = ServerManager.Instance.GetSessionByCharacterName(packetsplit[2]);
if (kickSession != null && kickSession.Character.Family?.FamilyId == Session.Character.Family.FamilyId)
{
if (kickSession.Character.FamilyCharacter?.Authority == FamilyAuthority.Head)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("CANT_KICK_HEAD")));
return;
}
if (kickSession.Character.CharacterId == Session.Character.CharacterId)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("CANT_KICK_YOURSELF")));
return;
}
DAOFactory.FamilyCharacterDAO.Delete(packetsplit[2]);
Session.Character.Family.InsertFamilyLog(FamilyLogType.FamilyManaged, kickSession.Character.Name);
kickSession.CurrentMapInstance?.Broadcast(kickSession.Character.GenerateGidx());
}
else
{
CharacterDTO dbCharacter = DAOFactory.CharacterDAO.LoadByName(packetsplit[2]);
if (dbCharacter != null)
{
FamilyCharacterDTO dbFamilyCharacter = DAOFactory.FamilyCharacterDAO.LoadByCharacterId(dbCharacter.CharacterId);
if (dbFamilyCharacter != null && dbFamilyCharacter.FamilyId == Session.Character.Family.FamilyId)
{
if (dbFamilyCharacter.Authority == FamilyAuthority.Head)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("CANT_KICK_HEAD")));
return;
}
DAOFactory.FamilyCharacterDAO.Delete(packetsplit[2]);
Session.Character.Family.InsertFamilyLog(FamilyLogType.FamilyManaged, dbCharacter.Name);
}
}
}
}
}
public IHttpActionResult GetCharacterById(int id)
{
CharacterDTO Character = GameManager.Instance.GetCharacterById(id);
if (Character.Id == -1)
{
return(NotFound());
}
else
{
return(Ok(Character));
}
}
public async Task <ActionResult <CharacterDTO> > DeleteCharacter(int id)
{
Character character = await repository.Delete(id);
if (character == null)
{
return(NotFound());
}
CharacterDTO characterDTO = new CharacterDTO(character);
return(characterDTO);
}
// POST: api/Characters
public IHttpActionResult Post([FromBody] CharacterDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data"));
}
ThronesTournamentManager m = new ThronesTournamentManager();
m.AddCharacter(value.Transform());
return(Ok());
}
private static CharacterDTO insert(CharacterDTO character, OpenNosContext context)
{
Character entity = new Character();
Mapper.Mappers.CharacterMapper.ToCharacter(character, entity);
context.Character.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.CharacterMapper.ToCharacterDTO(entity, character))
{
return(character);
}
return(null);
}
/// <summary>
/// Updates the specified character.
/// </summary>
/// <param name="characterDTO">The character to update.</param>
/// <exception cref="System.NotImplementedException"></exception>
internal static void Update(DndDmHelperContext context, CharacterDTO characterDTO)
{
var character = context.TemplateCharacters.Find(characterDTO.ID);
character.Name = characterDTO.Name;
character.Description = characterDTO.Description;
character.Level = characterDTO.Level;
character.ClassID = characterDTO.Class.ID;
character.RaceID = characterDTO.Race.ID;
context.Attach(character);
context.Entry(character).State = EntityState.Modified;
}
// PUT: api/Characters/{id}
public IHttpActionResult Put(int id, [FromBody] CharacterDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid model"));
}
ThronesTournamentManager m = new ThronesTournamentManager();
m.UpdateCharacter(value.Transform());
return(Ok());
}
public async Task Get_given_non_existing_returns_NotFound()
{
var dto = new CharacterDTO();
var repository = new Mock <ICharacterRepository>();
var controller = new CharactersController(repository.Object);
var get = await controller.Get(42);
var result = get.Result;
Assert.IsType <NotFoundResult>(result);
}
public bool Update()
{
try
{
CharacterDTO characterToUpdate = Mapper.Map <CharacterDTO>(this);
DAOFactory.CharacterDAO.InsertOrUpdate(ref characterToUpdate);
return(true);
}
catch (Exception e)
{
return(false);
}
}
public async Task TestGetCharacter()
{
Mock <IRepository <Character> > mockRepository = new Mock <IRepository <Character> >();
mockRepository.Setup(r => r.Read(1)).ReturnsAsync(TestData.GetCharacters()[0]);
CharactersController controller = new CharactersController(mockRepository.Object);
ActionResult <CharacterDTO> response = await controller.GetCharacter(1);
CharacterDTO character = response.Value;
Assert.IsTrue(TestData.GetCharacters()[0].IsDataEqual(new Character(character)));
}
public async Task TestPostCharacter()
{
Mock <IRepository <Character> > mockRepository = new Mock <IRepository <Character> >();
mockRepository.Setup(r => r.Create(It.IsAny <Character>())).ReturnsAsync(TestData.GetCharacters()[0]);
CharactersController controller = new CharactersController(mockRepository.Object);
ActionResult <CharacterDTO> response = await controller.PostCharacter(new CharacterDTO(TestData.GetCharacters()[0]));
CharacterDTO character = ((CreatedAtActionResult)response.Result).Value as CharacterDTO;
Assert.IsTrue(TestData.GetCharacters()[0].IsDataEqual(new Character(character)));
}
public async Task Get_given_existing_returns_dto()
{
var dto = new CharacterDTO();
var repository = new Mock <ICharacterRepository>();
repository.Setup(s => s.FindAsync(42)).ReturnsAsync(dto);
var controller = new CharactersController(repository.Object);
var get = await controller.Get(42);
Assert.Equal(dto, get.Value);
}
public CharacterDTO GetCharDTO(int characterid)
{
CharacterDTO dto = null;
for (int i = 0; i < chDtos.Count; i++)
{
if (chDtos[i].id == characterid)
{
dto = chDtos[i];
}
}
return(dto);
}
public async Task <CharacterDTO> UpdateCharacter(Character character)
{
var updCharacter = new CharacterDTO
{
Id = character.CharacterRef,
IsRetired = character.IsRetired,
IsActive = character.IsActive,
Name = character.Name,
PlayerId = character.PlayerId,
Xp = character.Xp
};
return(await UpdateCharacter(updCharacter));
}
public CharacterDTO GetCharacterInformation(CharacterDTO character)
{
if (character == null)
{
throw new ArgumentNullException("character");
}
if (String.IsNullOrEmpty(character.Name))
{
throw new ArgumentNullException("character.Name");
}
return(GetCharacterInformation(character.Name));
}
public IEnumerable <CharacterDTO> LoadAllCharactersByAccount(long accountId)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <CharacterDTO> result = new List <CharacterDTO>();
foreach (Character entity in context.Character.Where(c => c.AccountId.Equals(accountId) && c.State.Equals((byte)CharacterState.Active)).OrderByDescending(c => c.Slot))
{
CharacterDTO dto = new CharacterDTO();
Mapper.Mapper.Instance.CharacterMapper.ToCharacterDTO(entity, dto);
result.Add(dto);
}
return(result);
}
}
/// <summary>
/// Returns first 30 occurences of highest Act4Points
/// </summary>
/// <returns></returns>
public List <CharacterDTO> GetTopPoints()
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <CharacterDTO> result = new List <CharacterDTO>();
foreach (Character entity in context.Character.Where(c => c.Account.Authority == AuthorityType.User && !c.Account.PenaltyLog.Any(l => l.Penalty == PenaltyType.Banned && l.DateEnd > DateTime.Now)).OrderByDescending(c => c.Act4Points).Take(30))
{
CharacterDTO dto = new CharacterDTO();
Mapper.Mapper.Instance.CharacterMapper.ToCharacterDTO(entity, dto);
result.Add(dto);
}
return(result);
}
}
private CharacterDTO Update(Character entity, CharacterDTO character, OpenNosContainer context)
{
using (context)
{
var result = context.character.SingleOrDefault(c => c.CharacterId == character.CharacterId);
if (result != null)
{
result = Mapper.Map <CharacterDTO, Character>(character, entity);
context.SaveChanges();
}
}
return(Mapper.Map <CharacterDTO>(entity));
}
