public void AddModifier(IList <ActiveStatsModifier> modifiers, ActiveStatsModifier newModifier)
        {
            if (modifiers.Count > 0)
            {
                newModifier.Id = modifiers.Max(m => m.Id) + 1;
            }
            else
            {
                newModifier.Id = 1;
            }

            newModifier.Active              = true;
            newModifier.CurrentLapCount     = newModifier.LapCount;
            newModifier.CurrentCombatCount  = newModifier.CombatCount;
            newModifier.CurrentTimeDuration = newModifier.TimeDuration;
            modifiers.Add(newModifier);
        }
        public async Task <CreatedActionResult <ActiveStatsModifier> > PostAddModifierAsync(
            [FromServices] NaheulbookExecutionContext executionContext,
            [FromRoute] int monsterId,
            ActiveStatsModifier statsModifier
            )
        {
            try
            {
                var modifier = await _monsterService.AddModifierAsync(executionContext, monsterId, statsModifier);

                return(modifier);
            }
            catch (ForbiddenAccessException ex)
            {
                throw new HttpErrorException(StatusCodes.Status403Forbidden, ex);
            }
            catch (MonsterNotFoundException ex)
            {
                throw new HttpErrorException(StatusCodes.Status404NotFound, ex);
            }
        }
Example #3
0
 public void NotifyMonsterUpdateModifier(int monsterId, ActiveStatsModifier modifier)
 {
     _packets.Add(_packetBuilder.BuildMonsterUpdateModifier(monsterId, modifier));
 }
        public async Task <ActiveStatsModifier> AddModifierAsync(NaheulbookExecutionContext executionContext, int monsterId, ActiveStatsModifier statsModifier)
        {
            using (var uow = _unitOfWorkFactory.CreateUnitOfWork())
            {
                var monster = await uow.Monsters.GetAsync(monsterId);

                if (monster == null)
                {
                    throw new MonsterNotFoundException(monsterId);
                }

                var group = await uow.Groups.GetAsync(monster.GroupId);

                if (group == null)
                {
                    throw new GroupNotFoundException(monster.GroupId);
                }

                _authorizationUtil.EnsureIsGroupOwner(executionContext, group);

                var modifiers = _jsonUtil.Deserialize <List <ActiveStatsModifier> >(monster.Modifiers) ?? new List <ActiveStatsModifier>();
                _activeStatsModifierUtil.AddModifier(modifiers, statsModifier);
                monster.Modifiers = _jsonUtil.Serialize(modifiers);

                await uow.SaveChangesAsync();

                var notificationSession = _notificationSessionFactory.CreateSession();
                notificationSession.NotifyMonsterAddModifier(monster.Id, statsModifier);
                await notificationSession.CommitAsync();

                return(statsModifier);
            }
        }