Tag: current

I currently have a service class RoutineService.cs that contains methods that each perform one thing, call the repository and return that exact same object.

1. With how simple it is, is my service layer necessary?
2. I feel like it is better to inject the RoutineRepository Service into the controller and skip the service layer. But of course, there may be future extensions that I have not considered. What are some possible reasons (or whataboutisms) to keep the service layer?
3. More questions below code:

using System;
using System.Threading.Tasks;
using Project.Services.Models;
using Project.Services.Interfaces.Services;
using Project.Services.Interfaces.Repositories;
using ProjectContracts.Models.Responses;

namespace Project.Services.Services
{
    public class RoutineService : IRoutineService
    {
        public IRoutineRepository _routineRepository { get; }

        public RoutineService(IRoutineRepository routineRepository)
        {
            
            _routineRepository = routineRepository;
        }

        public async Task<Routine> CreateRoutineAsync(int groupId, Routine routine)
        {
            return await _routineRepository.CreateRoutineAsync(routine, groupId: groupId);
        }
    }
}

I am currently consuming this service in my controller like so:

namespace Project.Controllers
{
    (Route("api/(controller)"))
    (ApiController)
    public class GroupsController : ControllerBase
    {
        public IRoutineService _routineService { get; }

        public GroupsController(IRoutineService routineService)
        {
            _routineService = routineService;
        }

        // POST api/<GroupsController>/{id}/Routine
        (HttpPost("{groupId}/Routine"))
        public async Task<ActionResult<RoutineResponse>> Post(int groupId, RoutineRequest request)
        {
            var routine = new Routine
            {
                Name = request.RoutineName
            };

            var routineCreated = await _routineService.CreateRoutineAsync(groupId, routine);

            return routineCreated == null ? Conflict() : Ok(new RoutineResponse
            {
                RoutineName = routineCreated.Name,
                RoutineId = routineCreated.RoutineId
            });
        }
    }
}

I have Routine, RoutineResponse and RoutineRequest objects. The Routine object is mapped to a RoutineResponse object in the controller.

4. Should the RoutineService return a Routine object or RoutineResponse object? I’ve been reading this for hours but it’s hard to understand what people are saying without the actual code. For instance, this comment describes the different kinds of objects (DTO, Domain Entities, etc) but does not post code:
5. Is the Routine object considered a “Domain Model”?
6. Is it appropriate to call the RoutineResponse and RoutineRequest objects as “Data contract models”? Would a better name be “presentation models”? Or is there already a name of them and please say what the categories are.

public class Routine {
    public int Id { get; set; }
    public string Name { get; set; }
    public string HideFromDataContract { get; set; }
}

public class RoutineResponse {
    public int RoutineId { get; set; }
    public string RoutineName { get; set; }
}

public class RoutineRequest {
    public string RoutineName { get; set; }
}