Walkthrough Generated Code GetList

BasicCRUD Part 2

Now let us walk through the generated code for the GetList. Let start with the generated output api model.

public class GetCustomersForLookupOutputAPIModel : IFlexOutputAPIModel
{
public string Id { get; set; }
public string Name { get; set; }
public DateTime DateOfBirth { get; set; }
}

So if you see here in web controller we have the GetCustomersForLookup is the GetList.

public partial class CustomerController : FlexControllerBridge
{
/// <summary>
///
/// </summary>
/// <returns></returns>
[HttpGet()]
[Route("GetCustomersForLookup")]
[ProducesResponseType(typeof(IEnumerable<GetCustomersForLookupOutputAPIModel>), 200)]
public IActionResult GetCustomersForLookup([FromQuery]GetCustomersForLookupParams parameters)
{
FlexHostContextInfoBridge hostContextInfo = new FlexHostContextInfoBridge();
hostContextInfo.Populate<IFlexHostHttpContextAccesorBridge>(_appHttpContextAccessor);
parameters.SetHostContextInfo(hostContextInfo);
return Ok(ProcessCustomerService.GetCustomersForLookup(parameters));
}
}

Since the parameter get customer by lookup uses the same ContextInfo, we cannot expose those parameter to the API. So its implemented as protected. That is the ideal way that works like that. So to avoid exposing the parameter to the API. This particular parameter is made protected.

Lets look at the Services layer.

public partial class ProcessCustomerService : IProcessCustomerService
{
/// <summary>
/// YourRemarksForMethod
/// </summary>
/// <param name="params"></param>
/// <returns></returns>
public IEnumerable<GetCustomersForLookupOutputAPIModel> GetCustomersForLookup(GetCustomersForLookupParams @params)
{
return _flexHost.GetFlexiQuery<GetCustomersForLookup>().AssignParameters(@params).Fetch();
}
}

Lets look at the Query:

public class GetCustomersForLookup : FlexiQueryEnumerableBridge<Customer, GetCustomersForLookupOutputAPIModel>
{
private IFlexQueryRepositoryBridge _repoFlex;
readonly ILogger<GetCustomersForLookup> _logger;
readonly IReadDbConnectionProviderBridge _connectionProvider;
private GetCustomersForLookupParams _params;
IMapper _mapper;
/// <summary>
///
/// </summary>
/// <param name="repoFlex"></param>
/// <param name="logger"></param>
public GetCustomersForLookup(IFlexQueryRepositoryBridge repoFlex, ILogger<GetCustomersForLookup> logger, IMapper mapper, IReadDbConnectionProviderBridge connectionProvider)
{
_repoFlex = repoFlex;
_logger = logger;
_mapper = mapper;
_connectionProvider = connectionProvider;
}
/// <summary>
///
/// </summary>
/// <param name="params"></param>
/// <returns></returns>
public GetCustomersForLookup AssignParameters(GetCustomersForLookupParams @params)
{
_params = @params;
return this;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override IEnumerable<GetCustomersForLookupOutputAPIModel> Fetch()
{
var stopwatch = Stopwatch.StartNew();
var result = Build<Customer>().ProjectTo<GetCustomersForLookupOutputAPIModel>(_mapper.ConfigurationProvider).ToList();
Trace.WriteLine($"Query GetCustomersForLookup execution time: {stopwatch.ElapsedMilliseconds} ms");
return result;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
protected override IQueryable<T> Build<T>()
{
_connectionProvider.ConfigureDbConnectionString(_params.GetHostContextInfo());
_repoFlex.InitializeConnection(_connectionProvider);
IQueryable<T> query = _repoFlex.FindAll<T>();
if (!String.IsNullOrEmpty(_params.Name))
query = query.Where(c => c.Name == _params.Name);
//Build Your Query Here
return query;
}
}
/// <summary>
///
/// </summary>
public class GetCustomersForLookupParams : FlexiQueryParameterBridge
{
public string Name { get; set; }
}

GetList implements the FlexiQueryEnumerableBridge. The same way we have the Fetch and we have the ProjectTo so do the mapping for the customer model to this output API model. So once the query is executed the control flows back to the services and the controller gives the result back to the consumer of the API.