Exemple #1
0
        public async Task <VillainDto> AddVillain(VillainDto villainDto)
        {
            ValidateVillainDto(villainDto);

            var villain = await ToEntity(villainDto);

            villain.OverallStrength  = villain.Powers.Aggregate(0, (acc, power) => acc += power.Power.Strength);
            villain.OverallStrength += villain.MainPower == null ? 0 : villain.MainPower.Power.Strength;
            villain.AvatarPath       = Constants.DEFAULT_IMAGE_VILLAIN;

            if (!string.IsNullOrEmpty(villainDto.Email))
            {
                var user = ConvertVillainToUser(villainDto);

                await _userService.CreateHeroUser(user);

                villain.User = user;
            }

            await _context.Heroes.AddAsync(villain);

            await _context.SaveChangesAsync();

            villainDto.Id = villain.Id;

            return(villainDto);
        }
Exemple #2
0
 private void ValidateVillainDto(VillainDto villainDto)
 {
     if (string.IsNullOrWhiteSpace(villainDto.Name))
     {
         throw new InvalidParameterException("Villain is invalid");
     }
 }
Exemple #3
0
        public PowerDto FindPowerOfHero(VillainDto hero, string powerName)
        {
            if (hero.Powers != null)
            {
                return(hero.Powers.FirstOrDefault(power => power.Name == powerName));
            }

            return(null);
        }
Exemple #4
0
 private User ConvertVillainToUser(VillainDto villain)
 {
     return(new User()
     {
         Email = villain.Email,
         FullName = villain.Name,
         Username = villain.Email,
         Age = 18,
     });
 }
Exemple #5
0
        public async Task <Hero> ToEntity(VillainDto villainDto)
        {
            ValidateVillainDto(villainDto);

            var dbType = await _context.HeroTypes.FirstOrDefaultAsync(ht => ht.Id == villainDto.TypeId);

            var dbMainPower = await _context.Powers.FirstOrDefaultAsync(power => power.Name == villainDto.MainPower.Name);

            var hero = new Hero
            {
                Id   = villainDto.Id,
                Name = villainDto.Name,
                Type = dbType
            };

            hero.MainPower = villainDto.MainPower.Id == 0 ? null : new HeroPower
            {
                Hero  = hero,
                Power = await _powerService.FindById(villainDto.MainPower.Id)
            };

            hero.Powers = new List <HeroPower>();
            if (villainDto.Powers != null)
            {
                foreach (var power in villainDto.Powers)
                {
                    hero.Powers.Add(new HeroPower
                    {
                        Hero  = hero,
                        Power = await _powerService.FindById(power.Id)
                    });
                }
            }
            else
            {
                hero.Powers = null;
            }

            hero.Allies = new List <HeroAlly>();
            if (villainDto.Allies != null)
            {
                foreach (var ally in villainDto.Allies)
                {
                    hero.Allies.Add(new HeroAlly
                    {
                        AllyFrom = hero,
                        AllyTo   = await GetVillainById(ally.Id)
                    });
                }
            }

            hero.IsBadGuy = true;

            return(hero);
        }
Exemple #6
0
        private async Task <ICollection <HeroAlly> > CreateVillainAllies(VillainDto villainDto, Hero hero)
        {
            var heroAllies = new List <HeroAlly>();

            foreach (var ally in villainDto.Allies)
            {
                heroAllies.Add(new HeroAlly
                {
                    AllyFrom = hero,
                    AllyTo   = await GetVillainById(ally.Id)
                });
            }

            return(heroAllies);
        }
Exemple #7
0
        private async Task <ICollection <HeroPower> > CreateVillainPowers(VillainDto villainDto, Hero hero)
        {
            var heroPowers = new List <HeroPower>();

            foreach (var power in villainDto.Powers)
            {
                heroPowers.Add(new HeroPower
                {
                    Hero  = hero,
                    Power = await _powerService.FindById(power.Id)
                });
            }

            return(heroPowers);
        }
Exemple #8
0
        public VillainDto AddBonusStrength(VillainDto hero)
        {
            if (hero.Powers != null)
            {
                int tenPercentIncrease  = hero.OverallStrength + Convert.ToInt32(_appSettings.TEN_PERCENT_BONUS * Convert.ToDouble(hero.OverallStrength));
                int fivePercentIncrease = hero.OverallStrength + Convert.ToInt32(_appSettings.FIVE_PERCENT_BONUS * Convert.ToDouble(hero.OverallStrength));

                foreach (var power in hero.Powers)
                {
                    if (power.Name == Constants.STRENGTH_POWER)
                    {
                        hero.OverallStrength = tenPercentIncrease;
                    }
                    else if (power.Name == Constants.SPEED_POWER || power.Name == Constants.INVISIBILITY_POWER)
                    {
                        hero.OverallStrength = fivePercentIncrease;
                    }
                }
            }
            return(hero);
        }
Exemple #9
0
        public async Task UpdateVillain(VillainDto villainDto)
        {
            ValidateVillainDto(villainDto);

            var villain = await _context.Heroes
                          .FirstOrDefaultAsync(h => h.Id == villainDto.Id);

            if (villain == null)
            {
                throw new EntityNotFoundException($"There is no hero with id: {villainDto.Id}");
            }

            await DeleteAllHeroPowers(villain);
            await DeleteAllHeroAllies(villain);

            villain.Powers = null;

            villain.Name   = villainDto.Name;
            villain.TypeId = villainDto.TypeId;
            villain.Powers = await CreateVillainPowers(villainDto, villain);

            villain.Allies = await CreateVillainAllies(villainDto, villain);

            villain.OverallStrength = villain.Powers.Aggregate(0, (acc, power) => acc += power.Power.Strength);
            villain.MainPower       = villainDto.MainPower.Id == 0 ? null : new HeroPower
            {
                Hero  = villain,
                Power = await _powerService.FindById(villainDto.MainPower.Id)
            };
            villain.Latitude         = villainDto.Latitude;
            villain.Longitude        = villainDto.Longitude;
            villain.OverallStrength += villain.MainPower == null ? 0 : villain.MainPower.Power.Strength;
            villain.Birthday         = DateTime.Parse(villainDto.Birthday).AddHours(5);

            _context.Heroes.Update(villain);
            await _context.SaveChangesAsync();
        }
        public async Task <IActionResult> UpdateVillain(VillainDto villainDto)
        {
            await _villainService.UpdateVillain(villainDto);

            return(Ok());
        }
        public async Task <IActionResult> AddVillain(VillainDto villainDto)
        {
            var villain = await _villainService.AddVillain(villainDto);

            return(Ok(villain));
        }