I'm working in a new project under a typical three layer architecture: business, data and client using Angular as a front.
In this project we will have a repetitive task that we want to automate: The creation of CRUD. What we want to do is generate models and controllers(put, get, post, delete) as well as other basic project information from an entity and its properties.
What is my best option here? I had thought about templates T4, but my ignorance towards them make me doubt if it is the best option.
For example, from this entity:
public class User
{
public int Id { get; set; }
public string Name {get;set;}
public string Email{ get; set; }
public IEnumerable<Task> Task { get; set; }
}
I want to generate the following model:
public class UserModel
{
public int Id { get; set; }
public string Name {get;set;}
public string Email{ get; set; }
public IEnumerable<Task> Task { get; set; }
}
And also the controller:
{
/// <summary>
/// User controller
/// </summary>
[Route("api/[controller]")]
public class UserController: Controller
{
private readonly LocalDBContext localDBContext;
private UnitOfWork unitOfWork;
/// <summary>
/// Constructor
/// </summary>
public UserController(LocalDBContext localDBContext)
{
this.localDBContext = localDBContext;
this.unitOfWork = new UnitOfWork(localDBContext);
}
/// <summary>
/// Get user by Id
/// </summary>
[HttpGet("{id}")]
[Produces("application/json", Type = typeof(UserModel))]
public IActionResult GetById(int id)
{
var user = unitOfWork.UserRepository.GetById(id);
if (user == null)
{
return NotFound();
}
var res = AutoMapper.Mapper.Map<UserModel>(user);
return Ok(res);
}
/// <summary>
/// Post an user
/// </summary>
[HttpPost]
public IActionResult Post([FromBody]UserModel user)
{
Usuario u = AutoMapper.Mapper.Map<User>(user);
var res = unitOfWork.UserRepository.Add(u);
if (res?.Id > 0)
{
return Ok(res);
}
return BadRequest();
}
/// <summary>
/// Edit an user
/// </summary>
[HttpPut]
public IActionResult Put([FromBody]UserModel user)
{
if (unitOfWork.UserRepository.GetById(user.Id) == null)
{
return NotFound();
}
var u = AutoMapper.Mapper.Map<User>(user);
var res = unitOfWork.UserRepository.Update(u);
return Ok(res);
}
/// <summary>
/// Delete an user
/// </summary>
[HttpDelete("{id}")]
public IActionResult Delete(int id)
{
if (unitOfWork.UserRepository.GetById(id) == null)
{
return NotFound();
}
unitOfWork.UserRepository.Delete(id);
return Ok();
}
Also, we need to add AutoMapper mappings:
public AutoMapper()
{
CreateMap<UserModel, User>();
CreateMap<User, UserModel>();
}
And the UnitOfWork:
private GenericRepository<User> userRepository;
public GenericRepository<User> UserRepository
{
get
{
if (this.userRepository== null)
{
this.userRepository= new GenericRepository<User>(context);
}
return userRepository;
}
}
Most of the structures are going to be the same, except some specific cases of controllers that will have to be done manually.