public async Task <ActionResult> UpdateReferee(int id, [FromBody] RefereeRequest refereeRequest)
        {
            if (id < 1 || refereeRequest == null)
            {
                return(BadRequest());
            }

            var refereeToUpdate = await this.refereeService.FindAsync(id);

            if (refereeToUpdate == null)
            {
                return(NotFound());
            }

            var referee = this.mapper.Map(refereeRequest, refereeToUpdate);

            if (!validator.Validate(referee).IsValid)
            {
                return(BadRequest());
            }

            await this.refereeService.UpdateAsync(referee);

            logger.LogInformation($"UpdateReferee {referee.Id}");

            return(Ok());
        }
Exemple #2
0
        public async Task <IActionResult> PutReferee(int id, RefereeRequest referee)
        {
            // TODO: Refactor in Request and Reponce (Quico fix)
            // referee.Id = id;

            if (referee == null)
            {
                return(BadRequest());
            }
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            var existingReferee = await _context.Referee.FindAsync(id);

            if (existingReferee == null)
            {
                return(NotFound());
            }

            var mapper = _mappingConfiguration.CreateMapper();

            // _context.Entry(referee).State = EntityState.Modified;

            try
            {
                mapper.Map(referee, existingReferee);
                _context.Referee.Update(existingReferee);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RefereeExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemple #3
0
        public async Task <ActionResult <RefereeResponse> > PostReferee(RefereeRequest referee)
        {
            // TODO: Refactor in Request and Reponce (Quico fix)
            // referee.Id = 0;
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            var mapper        = _mappingConfiguration.CreateMapper();
            var createdRefere = mapper.Map <Referee>(referee);

            _context.Referee.Add(createdRefere);
            await _context.SaveChangesAsync();

            // TODO: Return 200????
            return(CreatedAtAction("GetReferee", new { id = createdRefere.Id }, mapper.Map <RefereeResponse>(createdRefere)));
        }
        public async Task <ActionResult> CreateReferee([FromBody] RefereeRequest refereeRequest)
        {
            if (refereeRequest == null)
            {
                return(BadRequest());
            }

            var referee = this.mapper.Map <RefereeRequest, Referee>(refereeRequest);

            if (!validator.Validate(referee).IsValid)
            {
                return(BadRequest());
            }

            await this.refereeService.AddAsync(referee);

            logger.LogInformation($"CreateReferee {referee.Id}");

            return(CreatedAtAction(nameof(CreateReferee), new { id = referee.Id, version = this.HttpContext.GetRequestedApiVersion().ToString() }, referee.Id));
        }
Exemple #5
0
 private void ChangeToSend(RefereeRequest m) => m.Name = "Referee 11";