private async Task Map(AddExerciseToRoutineRequest request)
        {
            try
            {
                List <Day> days = new();

                foreach (var day in request.Days)
                {
                    days.Add(await _unitOfWork.Days.GetDayByDayNumberAsync(day));
                }

                Exercise = new Exercise()
                {
                    Id           = request.ExerciseId,
                    Name         = request.ExerciseName,
                    ImageUrl     = request.ImageUrl,
                    CategoryName = request.CategoryName
                };

                Routine = new Routine()
                {
                    Id         = Guid.NewGuid(),
                    UserId     = UserId,
                    Exercise   = Exercise,
                    ExerciseId = request.ExerciseId,
                    Days       = days,
                    Sets       = request.Sets
                };
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task <string> AddExerciseToRoutineAsync(string accessToken, AddExerciseToRoutineRequest request)
        {
            try
            {
                var client = _httpClientFactory.CreateClient("Ocelot");

                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);

                var content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json");

                var response = await client.PostAsync("/v1/Routine", content);

                string result = await response.Content.ReadAsStringAsync();

                if (!string.IsNullOrEmpty(result))
                {
                    return(result);
                }

                var error = new
                {
                    statusCode = (int)response.StatusCode,
                    title      = response.ReasonPhrase,
                    succeeded  = false
                };

                return(JsonSerializer.Serialize(error));
            }
            catch (Exception)
            {
                throw;
            }
        }
Exemple #3
0
        public async Task <string> AddExerciseToRoutine([FromBody] AddExerciseToRoutineRequest request)
        {
            try
            {
                if (request is null || (!request.IsValid()))
                {
                    var error = new { succeeded = false, title = "Bad request", statusCode = 400 };
                    return(JsonSerializer.Serialize(error));
                }

                string accessToken = await HttpContext.GetTokenAsync("access_token");

                return(await _routineService.AddExerciseToRoutineAsync(accessToken, request));
            }
            catch (Exception ex)
            {
                return(SendError(ex));
            }
        }
        public async Task <ActionResult <HateoasResponse> > AddExerciseToRoutine(AddExerciseToRoutineRequest request)
        {
            try
            {
                AddExerciseToRoutineCommand command = new(request);

                bool result = await _mediator.Send(command);

                return(Ok(_sender.SendResult(new { ExerciseCreated = result }, GenericLinks.GetRoutineLinks(), "The exercise has been added to your Routine!")));
            }
            catch (Exception ex)
            {
                var errorResponse = _sender.SendError(ex, GenericLinks.GetRoutineLinks());

                Response.StatusCode = errorResponse.StatusCode;

                return(errorResponse);
            }
        }