Ejemplo n.º 1
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto character)
        {
            var serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                var newCharacter = await _context.Characters.FirstOrDefaultAsync(c => c.Id == character.Id && c.User.Id == GetUserId());

                if (newCharacter != null)
                {
                    foreach (var prop in newCharacter.GetType().GetProperties())
                    {
                        prop.SetValue(newCharacter, character.GetType().GetProperty(prop.Name)?.GetValue(character));
                    }

                    await _context.SaveChangesAsync();

                    var returnValue = _mapper.Map <GetCharacterDto>(newCharacter);
                    serviceResponse.Data = returnValue;
                }
                else
                {
                    serviceResponse.Message = "no such character";
                    serviceResponse.Success = false;
                }
            }
            catch (Exception e)
            {
                serviceResponse.Message = e.Message;
                serviceResponse.Success = false;
            }

            return(serviceResponse);
        }
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto character)
        {
            var serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                var newCharacter = characters.FirstOrDefault(c => c.Id == character.Id && c.User.Id == GetUserId());

                foreach (var prop in newCharacter.GetType().GetProperties())
                {
                    prop.SetValue(newCharacter, character.GetType().GetProperty(prop.Name)?.GetValue(character));
                }

                var returnValue = _mapper.Map <GetCharacterDto>(newCharacter);

                serviceResponse.Data = returnValue;
            }
            catch (Exception e)
            {
                serviceResponse.Message = e.Message;
                serviceResponse.Success = false;
            }

            return(serviceResponse);
        }
Ejemplo n.º 3
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            ServiceResponse <GetCharacterDto> serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character character = await _context.Characters.FirstOrDefaultAsync(c => c.Id == updatedCharacter.Id);

                character.Name         = updatedCharacter.Name;
                character.Class        = updatedCharacter.Class;
                character.Defense      = updatedCharacter.Defense;
                character.HitPoints    = updatedCharacter.HitPoints;
                character.Intelligence = updatedCharacter.Intelligence;
                character.Strength     = updatedCharacter.Strength;

                _context.Characters.Update(character);
                await _context.SaveChangesAsync();

                serviceResponse.Message = "Character saved successfully.";
                serviceResponse.Data    = _mapper.Map <GetCharacterDto>(character);
            }
            catch (Exception ex)
            {
                serviceResponse.Success = false;
                serviceResponse.Message = ex.Message;
            }
            return(serviceResponse);
        }
Ejemplo n.º 4
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            var serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character character = characters.FirstOrDefault(c => c.Id == updatedCharacter.Id);

                character.Name           = updatedCharacter.Name;
                character.healthpoints   = updatedCharacter.healthpoints;
                character.attack         = updatedCharacter.attack;
                character.defense        = updatedCharacter.defense;
                character.specialattack  = updatedCharacter.specialattack;
                character.specialdefense = updatedCharacter.specialdefense;
                character.speed          = updatedCharacter.speed;
                character.PrimaryType    = updatedCharacter.PrimaryType;
                character.SecondaryType  = updatedCharacter.SecondaryType;

                serviceResponse.Data = _mapper.Map <GetCharacterDto>(character);
            } catch (Exception e)
            {
                serviceResponse.Success = false;
                serviceResponse.Message = e.Message;
            }
            return(serviceResponse);
        }
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto newCharacter)
        {
            ServiceResponse <GetCharacterDto> response = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character character = await _context.Characters.Include(m => m.User).FirstOrDefaultAsync(m => m.Id == newCharacter.Id);

                if (character != null && character.User.Id == GetUserId())
                {
                    character.Name         = newCharacter.Name;
                    character.Strength     = newCharacter.Strength;
                    character.Class        = newCharacter.Class;
                    character.Defence      = newCharacter.Defence;
                    character.HitPoints    = newCharacter.HitPoints;
                    character.Intelligence = newCharacter.Intelligence;
                    _context.Update(character);
                    await _context.SaveChangesAsync();

                    response.Data = _mapper.Map <GetCharacterDto>(character);
                }
                else
                {
                    response.Success = false;
                    response.Message = "not able to update";
                }
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }
            return(response);
        }
Ejemplo n.º 6
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto toUpdate)
        {
            ServiceResponse <GetCharacterDto> response = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character character = await _context.Characters.FirstOrDefaultAsync(c => c.Id == toUpdate.Id);

                if (character != null)
                {
                    character.Name     = toUpdate.Name.Equals("nochange") ? character.Name : toUpdate.Name;
                    character.CodeName = toUpdate.CodeName.Equals("nochange") ? character.CodeName : toUpdate.CodeName;
                    character.Origin   = toUpdate.Origin.Equals("nochange") ? character.Origin : toUpdate.Origin;
                    character.Type     = toUpdate.Type == 0 ? character.Type : toUpdate.Type;

                    _context.Characters.Update(character);
                    await _context.SaveChangesAsync();

                    response.Data    = _mapper.Map <GetCharacterDto>(character);
                    response.Message = "character updated";
                }
                else
                {
                    response.Success = false;
                    response.Message = "character not found";
                }
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }
            return(response);
        }
Ejemplo n.º 7
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <GetCharacterDto> serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character character = await _dataContext.Characters.Include(c => c.User).FirstOrDefaultAsync(c => c.Id == updateCharacter.Id);

                if (character.User.Id == GetUserId())
                {
                    character.Name         = updateCharacter.Name;
                    character.Class        = updateCharacter.Class;
                    character.Defense      = updateCharacter.Defense;
                    character.HitPoints    = updateCharacter.HitPoints;
                    character.Intelligence = updateCharacter.Intelligence;
                    character.Strength     = updateCharacter.Strength;

                    _dataContext.Update(character);
                    await _dataContext.SaveChangesAsync();

                    serviceResponse.Data = _mapper.Map <GetCharacterDto>(character);
                }
                else
                {
                    serviceResponse.Success = false;
                    serviceResponse.Message = "Character not found.";
                }
            }
            catch (Exception e)
            {
                serviceResponse.Success = false;
                serviceResponse.Message = e.Message;
            }
            return(serviceResponse);
        }
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            ServiceResponse <GetCharacterDto> serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                // context-> characters table -> select(lambda expression -> find by id)
                Character character = await _context.Characters.FirstOrDefaultAsync(c => c.id == updatedCharacter.id);

                character.name         = updatedCharacter.name;
                character.hitpoints    = updatedCharacter.hitpoints;
                character.strenght     = updatedCharacter.strenght;
                character.defense      = updatedCharacter.defense;
                character.intelligence = updatedCharacter.intelligence;
                character.playClass    = updatedCharacter.playClass;

                // update
                _context.Characters.Update(character);
                //save db
                await _context.SaveChangesAsync();

                serviceResponse.data = _mapper.Map <GetCharacterDto>(character);
            }
            catch (System.Exception ex)
            {
                serviceResponse.success = false;
                serviceResponse.message = ex.Message;
            }
            return(serviceResponse);
        }
Ejemplo n.º 9
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <GetCharacterDto> serviceResponse = new ServiceResponse <GetCharacterDto>();

            try
            {
                Character candidate = characters.FirstOrDefault(c => c.Id == updateCharacter.Id);

                candidate.Name        = updateCharacter.Name;
                candidate.Inteligence = updateCharacter.Inteligence;
                candidate.Class       = updateCharacter.Class;
                candidate.Defence     = updateCharacter.Defence;
                candidate.HitPoint    = updateCharacter.HitPoint;
                candidate.Stringth    = updateCharacter.Stringth;

                serviceResponse.Data = _mapper.Map <GetCharacterDto>(candidate);
            }
            catch (Exception ex)
            {
                serviceResponse.Succes  = false;
                serviceResponse.Message = ex.Message;
            }

            return(serviceResponse);
        }
Ejemplo n.º 10
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            var result = new ServiceResponse <GetCharacterDto>();

            try
            {
                var character = await _context.Characters.FirstOrDefaultAsync(c => c.Id == updatedCharacter.Id);

                character.Name         = updatedCharacter.Name;
                character.Class        = updatedCharacter.Class;
                character.Defense      = updatedCharacter.Defense;
                character.HitPoints    = updatedCharacter.HitPoints;
                character.Intelligence = updatedCharacter.Intelligence;
                character.Strength     = updatedCharacter.Strength;

                _context.Characters.Update(character);
                await _context.SaveChangesAsync();

                result.Data = _mapper.Map <GetCharacterDto>(character);
            }
            catch (Exception e)
            {
                result.Success = false;
                result.Message = e.Message;
            }

            return(result);
        }
Ejemplo n.º 11
0
        public async Task <ServiceResponse <GetCharacterDto> > UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            Character character = await _context.Characters.Include(ch => ch.User)
                                  .FirstOrDefaultAsync(ch => ch.Id == updatedCharacter.Id && ch.User.Id == GetUserId());

            if (character == null)
            {
                return new ServiceResponse <GetCharacterDto>
                       {
                           Success = false,
                           Message = "Character not found!"
                       }
            }
            ;

            PropertyInfo[] newProperty = typeof(UpdateCharacterDto).GetProperties();
            for (int i = 0; i < newProperty.Length; i++)
            {
                typeof(Character).GetProperties()[i].SetValue(character, typeof(UpdateCharacterDto).GetProperties()[i].GetValue(updatedCharacter));
            }

            _context.Characters.Update(character);
            await _context.SaveChangesAsync();

            return(new ServiceResponse <GetCharacterDto>
            {
                Data = _mapper.Map <GetCharacterDto>(character),
            });
        }
Ejemplo n.º 12
0
        public async Task <ServiceResponse <Character> > UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <Character> serviceResponse = new ServiceResponse <Character>();

            try
            {
                Character dbcharacter = await _dataContext.Characters.FirstOrDefaultAsync(x => x.Id == updateCharacter.Id);

                dbcharacter.Name        = updateCharacter.Name;
                dbcharacter.Strength    = updateCharacter.Strength;
                dbcharacter.Points      = updateCharacter.Points;
                dbcharacter.Inteligence = updateCharacter.Inteligence;
                dbcharacter.RpgClassId  = updateCharacter.RpgClassId;
                dbcharacter.DocumentPDF = updateCharacter.DocumentPDF;
                _dataContext.Characters.Update(dbcharacter);
                await _dataContext.SaveChangesAsync();

                serviceResponse.Data    = _mapper.Map <Character>(dbcharacter);
                serviceResponse.Success = true;
            }
            catch (Exception ex)
            {
                serviceResponse.Success = false;
                serviceResponse.Message = ex.Message;
            }
            return(serviceResponse);
        }
Ejemplo n.º 13
0
 public async Task<IActionResult> UpdateCharacter(UpdateCharacterDto updatedCharacter)
 {
     ServiceResponse<GetCharacterDto> response = await _characterService.UpdateCharacter(updatedCharacter);
     if(response.Data == null) {
         return NotFound(response);
     }
     return Ok(response);
 }
        public async Task <IActionResult> PutAsync(int id, [FromBody] UpdateCharacterDto item)
        {
            await _mediator.Send(new UpdateCharacterCommand()
            {
                CharacterId     = id,
                UpdateCharacter = item
            });

            return(Ok());
        }
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto character)
        {
            ServiceResponse <GetCharacterDto> response = await _characterService.UpdateCharacter(character);

            if (response.Data == null)
            {
                return(BadRequest(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 16
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto character)
        {
            ServiceResponse <GetCharacterDto> updatedCharacter = await _characterService.UpdateCharacter(character);

            if (updatedCharacter.Success)
            {
                return(Ok(updatedCharacter));
            }
            return(NotFound(updatedCharacter));
        }
Ejemplo n.º 17
0
        public async Task <IActionResult> updateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <GetCharacterDto> serviceResponse = await _characterservices.UpdateCharacter(updateCharacter);

            if (serviceResponse.data == null)
            {
                return(NotFound(serviceResponse));
            }
            return(Ok(serviceResponse));
        }
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <GetCharacterDto> response = await _repoCharacter.UpdateCharacter(updateCharacter);

            if (response == null)
            {
                return(NotFound(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 19
0
        public async Task <IActionResult> UpdateCharcter(UpdateCharacterDto updateCharacterDto)
        {
            ServiceResponse <GetCharacterDto> response = await _CharacterServices.UpdateCharacter(updateCharacterDto);

            if (response.Data == null)
            {
                return(NotFound());
            }
            return(Ok(response));
        }
Ejemplo n.º 20
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <GetCharacterDto> response = await _characterService.UpdateCharacter(updateCharacter);

            if (response.Success == false)
            {
                return(NotFound(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 21
0
        public async Task <IActionResult> UpdateCharacter([FromBody] UpdateCharacterDto character)
        {
            ServiceResponse <GetCharacterDto> response = await _characterService.UpdateCharacter(character);

            if (response.Data == null)
            {
                return(NotFound(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 22
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto character)
        {
            var response = await _characterService.UpdateCharacter(character);

            if (response.data == null)
            {
                return(NotFound(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 23
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            var result = await _characterService.UpdateCharacter(updatedCharacter);

            if (result.Data == null)
            {
                return(NotFound(result));
            }

            return(Ok(result));
        }
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto updateCharacter)
        {
            ServiceResponse <List <GetCharacterDto> > lsCharacter = await _characterService.UpdateCharacter(updateCharacter);

            if (!lsCharacter.Data.Any())
            {
                return(NotFound(lsCharacter));
            }

            return(Ok(lsCharacter));
        }
Ejemplo n.º 25
0
        public async Task <IActionResult> UpdateCharacter(int id, UpdateCharacterDto toon)
        {
            var response = await _characterService.UpdateCharacter(id, toon);

            if (response.Data == null)
            {
                return(NotFound(response));
            }

            return(NoContent());
        }
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto character)
        {
            var serviceResponse = await _service.UpdateCharacter(character);

            if (!serviceResponse.Success)
            {
                return(NotFound(serviceResponse));
            }

            return(Ok(serviceResponse));
        }
Ejemplo n.º 27
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto baru)
        {
            var character = await _characterService.UpdateCharacter(baru);

            if (character.Success)
            {
                return(Ok(character));
            }

            return(NotFound(character));
        }
        public async Task <ActionResult <ServiceResponse <List <GetCharacterDto> > > > UpdateCharacter(
            UpdateCharacterDto updatedCharacter)
        {
            var response = await _characterService.UpdateCharacter(updatedCharacter);

            if (response.Data == null)
            {
                return(NotFound(response));
            }
            return(Ok(response));
        }
Ejemplo n.º 29
0
        public async Task <IActionResult> UpdateCharacter(UpdateCharacterDto updatedCharacter)
        {
            var response = await _characterService.UpdateCharacter(updatedCharacter);

            if (response.Success)
            {
                return(Ok(response));
            }

            return(BadRequest(response));
        }
Ejemplo n.º 30
0
        public async Task <ApiResponse> Update(Guid id, UpdateCharacterDto request)
        {
            var command = new UpdateCharacterCommand
            {
                Id    = id,
                Name  = request.Name,
                Class = request.Class
            };
            await _operationMediator.HandleAsync(command);

            return(ApiResponse.Ok());
        }