public async Task <ActionResult> AddSkills(AddSkillDTO addSkillDTO)
        {
            ServiceWrapper <GetCharacterDTO> response = await _skillService.AddSkill(addSkillDTO);

            // if(response.Data == null){

            //     return NotFound(response);
            // }
            return(Ok(response));
        }
Esempio n. 2
0
        public async Task <IActionResult> PostSkill(AddSkillDto newSkill)
        {
            ServiceResponse <GetSkillDto> response = await _skillService.AddSkill(newSkill);

            if (!response.Success)
            {
                return(BadRequest(response));
            }
            return(Ok(response));
        }
        public async Task <IActionResult> CreateSkill(SkillVM skillVM)
        {
            if (!(ModelState.IsValid && await skillService.GetUniqueName(skillVM.Name)))
            {
                ModelState.AddModelError("", "Invalid name or skill already exists");
                return(RedirectToAction("SkillList"));
            }
            var mappedSkill = mapper.Map <SkillVM, Skill>(skillVM);
            await skillService.AddSkill(mappedSkill);

            return(RedirectToAction("SkillList"));
        }
Esempio n. 4
0
        public async Task <ActionResult <Player> > Create([FromBody] Skill skill)
        {
            try
            {
                var skillSaved = await _skillService.AddSkill(skill);

                _log.LogInformation($"Returning new skill with id {skillSaved.Id}");
                return(Ok(skillSaved));
            }
            catch (Exception ex)
            {
                _log.LogError($"Something went wrong: {ex}");
                return(StatusCode(500, ex));
            }
        }
Esempio n. 5
0
        public IActionResult Post(SkillViewModel skillVM)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Invalid Data"));
            }

            try
            {
                if (skillVM == null)
                {
                    return(BadRequest("Data cannot null"));
                }

                var data = _skillService.AddSkill(skillVM);

                return(Ok(data));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
        public SkillVM SkillCreate()
        {
            var skillVM = SkillHelper.SkillFullData();

            if (validator.Validate(skillVM).IsValid)
            {
                var mappedSkill = mapper.Map <SkillVM, Skill>(skillVM);
                skillService.AddSkill(mappedSkill);

                Dye.Succsess();
                Console.WriteLine("Skill has successfully added");
                Console.ResetColor();
                return(skillVM);
            }
            else
            {
                Dye.Fail();
                Console.WriteLine(validator.Validate(skillVM));
                Console.ResetColor();
                SkillCreate();
                return(null);
            }
        }
Esempio n. 7
0
 public async Task <int> AddSkill(SkillDto skillData)
 {
     return(await _skillService.AddSkill(skillData));
 }
Esempio n. 8
0
        public async Task <IHttpActionResult> Post([FromBody] SkillViewModel skill)
        {
            var addedSkill = await Task.Run(() => _skillService.AddSkill(skill));

            return(CreatedAtRoute("GetSkillById", new { id = addedSkill.Id }, addedSkill));
        }
 public async Task <IActionResult> AddSkill(AddSkillDto newSkill)
 {
     return(Ok(await _skillService.AddSkill(newSkill)));
 }