public async Task AddAsync(QuestDto quest)
{
var dataModel = _mapper.Map <Quest>(quest);
await _repository.AddAsync(dataModel);
await _repository.SaveChangesAsync();
}
public async Task Assign(MiniLocationDto miniLocation, QuestDto quest)
{
var edited = Mapper.Map <MiniLocationEditDto>(miniLocation);
edited.QuestId = quest.Id;
await Update(edited);
}
public async Task <Guid> CreateQuest(QuestDto quest)
{
using (var uow = UnitOfWorkProvider.Create())
{
quest.Id = _questService.Create(quest);
await uow.Commit();
return(quest.Id);
}
}
public bool Sync(QuestDto quest, string chapter, int index)
{
if (Url == quest.Url)
{
return(Question.Sync(quest.Question));
}
LogUtil.Log("Video URL is changed. Clearing downladed video from cache");
//filQuest(2).mp4
ClearCache(string.Format("{0}Quest({1}).mp4", chapter, index + 1));
Url = quest.Url;
Question.Sync(quest.Question);
return(false);
}
public void Initialize(QuestDto questDto, QuestData questData)
{
QuestData = questData;
ID = questDto.ID;
CurrentObjective = questDto.CurrentObjective;
CurrentTask = questDto.CurrentTask;
CurrentProgress = questDto.CurrentProgress;
State = questDto.QuestState;
SpawnDependencies();
QuestManager.Instance.Subscribe(questData.objectiveDatas[CurrentObjective].TaskDatas[CurrentTask], UpdateTaskProgress);
QuestHandler.Instance.AddQuest(this);
}
/// <summary>
/// Converts the given <see cref="QuestDto"/> to a <see cref="Quest"/> entity.
/// </summary>
/// <param name="dto">The dto to transform into its entity object equivalent.</param>
/// <exception cref="ArgumentNullException">Thrown if dto is null.</exception>
public static Quest ToEntity(this QuestDto dto)
{
if (dto == null)
{
throw new ArgumentNullException(nameof(dto));
}
return(new Quest
{
AccountKey = dto.AccountKey,
Description = dto.Description.JsonCleanUp(),
Name = dto.Name.JsonCleanUp(),
QuestKey = dto.QuestKey
});
}
public async Task <bool> AssignAsync(MiniLocationDto miniLocation, QuestDto quest)
{
using (var uow = UnitOfWorkProvider.Create())
{
if ((await _miniLocationService.GetAsync(miniLocation.Id, false)) == null)
{
return(false);
}
await _miniLocationService.Assign(miniLocation, quest);
await uow.Commit();
return(true);
}
}
public async Task <bool> AssignAsync(QuestDto quest, MonsterDto monster, ItemDto item)
{
using (var uow = UnitOfWorkProvider.Create())
{
if ((await _questService.GetAsync(quest.Id, false)) == null)
{
return(false);
}
await _questService.Assign(quest, monster, item);
await uow.Commit();
return(true);
}
}
public async Task <ActionResult> Create(MiniLocationDto model)
{
var q = new QuestDto()
{
Id = model.QuestId.GetValueOrDefault()
};
model.QuestId = null;
model.Id = await MiniLocationFacade.CreateMiniLocation(model);
await MiniLocationFacade.AssignAsync(model, q);
return(RedirectToAction("Index"));
}
public async Task Edit(QuestDto quest)
{
var questToEdit = await _repository.GetEntityAsync(q => q.Id.Equals(quest.Id));
questToEdit.Image = quest.Image;
questToEdit.Name = quest.Name;
questToEdit.Description = quest.Description;
questToEdit.Distance = quest.Distance;
questToEdit.Time = quest.Time;
questToEdit.Price = quest.Price;
questToEdit.Country = quest.Country;
questToEdit.Town = quest.Town;
questToEdit.Street = quest.Street;
questToEdit.Number = quest.Number;
questToEdit.Bonus = quest.Bonus;
_repository.Update(questToEdit);
await _repository.SaveChangesAsync();
}
public IActionResult Post([FromBody] QuestDto questData)
{
if (ModelState.IsValid)
{
try
{
_logger.LogDebug("Trying to create quest");
var questModel = Mapper.Map <Quest>(questData);
questRepository.CreateQuest(questModel);
questRepository.SaveChanges();
return(Ok());
}
catch (Exception e)
{
_logger.LogExceptions(e, this);
return(this.HandleErrors(e));
}
}
return(BadRequest(new ErrorDto(ModelState)));
}
public async Task <ActionResult> PostQuestAsync(QuestDto questDto)
{
if (questDto == null)
{
throw new ArgumentNullException(nameof(questDto));
}
if (questDto.AccountKey == Guid.Empty)
{
return(BadRequest());
}
try
{
questDomain.SaveQuest(questDto);
await Task.CompletedTask;
return(Ok());
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ActionResult> Create(QuestDto model)
{
var monster = new MonsterDto()
{
Id = model.MonsterId.GetValueOrDefault()
};
var item = new ItemDto()
{
Id = model.ItemId.GetValueOrDefault()
};
model.ItemId = null;
model.MonsterId = null;
model.Id = await QuestFacade.CreateQuest(new QuestDto()
{
Experience = model.Experience, Gold = model.Gold
});
await QuestFacade.AssignAsync(model, monster, item);
return(RedirectToAction("Index"));
}
/// <summary>
/// Saves the given quest.
/// </summary>
/// <param name="questDto">Transfer object representing the quest to save.</param>
public void SaveQuest(QuestDto questDto)
{
var entity = questDto.ToEntity();
questRepository.Save(entity, ctx => ctx.Quest, q => q.QuestKey == questDto.QuestKey);
}
public void Put(int id, [FromBody] QuestDto QuestDto)
{
}
public async Task PostAsync([FromBody] QuestDto quest)
{
await _questService.CreateQuestAsync(quest);
}
public Task UpdateQuestAsync(int id, QuestDto quest)
{
throw new NotImplementedException();
}
public async Task <Tuple <bool, List <string> > > FightAsync(CharacterDto character, MonsterDto monster, QuestDto quest)
{
var log = new List <string>();
_random = new Random();
if (character.Sickness > DateTime.Now)
{
var diff = Math.Abs(Math.Floor((character.Sickness - DateTime.Now).Value.TotalSeconds));
log.Add($"You can't fight at the moment. You are too tired and will not be able to fight for {diff} seconds.");
return(new Tuple <bool, List <string> >(false, log));
}
if (character.CurrentHp <= 0)
{
log.Add("You can't fight at the moment. You should get some rest, because you are too devasteted.");
return(new Tuple <bool, List <string> >(false, log));
}
var characterAttr = character.CalculateAttributes();
characterAttr.Hp = character.CurrentHp / 10; //setting hp to current value
var combat = Task.Run(() => Combat(characterAttr, monster.Attributes, log));
var result = await combat;
using (var uow = UnitOfWorkProvider.Create())
{
var updatedUser = new CharacterUpdateDto()
{
Name = character.Name,
CurrentHp = result.Item2,
Experience = character.Experience,
Gold = character.Gold,
Id = character.Id,
SkillPoints = character.SkillPoints,
Sickness = DateTime.Now.AddMinutes(10)
};
if (result.Item1)
{
updatedUser.Experience += quest.Experience;
updatedUser.Gold += quest.Gold;
}
await _characterService.Update(updatedUser);
await uow.Commit();
}
return(new Tuple <bool, List <string> >(result.Item1, log));
}
public async Task CreateQuestAsync(QuestDto quest)
{
await _context.AddAsync(_mapper.Map <Quest>(quest));
await _context.SaveChangesAsync();
}
