//http://localhost:6600/api/camps/ObtenerCampamentosNormal
public async Task <IActionResult> ObtenerCampamentosNormal()
{
try
{
var resultado = await campamentoRepositorio.GetAllCampsAsync();
return(Ok(resultado));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Falla de la Base de Datos"));
}
}
public async Task <ActionResult <List <CampModel> > > Get(bool IncludeTalks = false)
{
try
{
var camps = await campRepository.GetAllCampsAsync(IncludeTalks);
return(mapper.Map <List <CampModel> >(camps));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "database failure"));
}
}
public async Task <ActionResult <CampModel[]> > GetCampsAsync(bool includeTalks = false)
{
try
{
var results = await campRepository.GetAllCampsAsync(includeTalks);
CampModel[] model = mapper.Map <CampModel[]>(results);
return(model);
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "GetCampsAsync - " + e.ToString()));
}
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
_logger.LogInformation("Get list of all camps");
var results = await _repository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampModel[]>(results));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public async Task <CampViewModel[]> GetAllCampsAsync(bool includeTalks = false)
{
var listEntity = await _repository.GetAllCampsAsync(includeTalks);
CampViewModel[] listViewModel = _mapper.Map <CampViewModel[]>(listEntity);
return(listViewModel);
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
var results = await _repository.GetAllCampsAsync(includeTalks);
// CampModel[] models = _mapper.Map<CampModel[]>(results); // Create or map a CampModel Array from results
// return Ok(results);
// return Ok(models);
// Since ActionResult returns a type that matches models, it returns Ok for us
// return models;
return(_mapper.Map <CampModel[]>(results));
}
catch (Exception e)
{
// return status 500 for database failure
// ModelState.AddModelError("", e.Message);
_logger.LogInformation(e.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Database Failure, \n {e.Message}"));
}
// return Ok(new { Moniker = "LAG2018", Name = "Made In Lagos Camp" });
}
public async Task <ActionResult <CampModel[]> > Get()
{
try {
return(_mapper.Map <CampModel[]>(await _repository.GetAllCampsAsync()));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try {
var result = await campRepository.GetAllCampsAsync(includeTalks);
return(mapper.Map <CampModel[]>(result));
}
catch (Exception) {
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
//added return with status code.
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false) //need to change method to async method/addping includeTalk parameter to use query string
{ //added try catch block
try
{
var results = await _repository.GetAllCampsAsync(includeTalks); //used async method in the repository/adding includeTalks to enable query string
return(_mapper.Map <CampModel[]>(results)); //results map to CampModel
} catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure")); //added exception status code with meaningful exception
}
}
public async Task <ActionResult <Camp[]> > Get(bool includeTalks = false)
{
try
{
return(await _repository.GetAllCampsAsync(includeTalks));
}
catch (Exception e)
{
Console.WriteLine(e);
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public async Task <ActionResult <CampsModel[]> > GetCamps(bool includeTalks = false)
{
try
{
var result = await _campRepository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampsModel[]>(result));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Something wrong on our end."));
}
}
public async Task <IHttpActionResult> Get(bool includeTalks = false)
{
try {
var rs = await cr.GetAllCampsAsync(includeTalks);
var mr = mp.Map <IEnumerable <CampModel> >(rs);
return(Ok(mr));
}
catch (Exception e) {
return(InternalServerError(e));
}
return(BadRequest("NF"));
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
var results = await _campRepository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampModel[]>(results));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong on the server"));
}
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
var results = await _repository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampModel[]>(results));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public async Task <ActionResult <CampModels[]> > GetCamps(bool includeTalks = false)
{
try
{
var listCamps = await _campRepository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampModels[]>(listCamps));
}
catch (Exception)
{
return(this.StatusCode(500, "Database Failure"));
}
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
var results = await repository.GetAllCampsAsync(true);
return(mapper.Map <CampModel[]>(results));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Camps Could not be found"));
}
}
public async Task <IActionResult> GetCamps()
{
try
{
var results = await _repository.GetAllCampsAsync();
return(Ok(results));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public async Task <ActionResult <CampModel[]> > Get(bool includeTalks = false)
{
try
{
var results = await _repository.GetAllCampsAsync(includeTalks);
return(Ok(_mapper.Map <CampModel[]>(results)));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure: " + ex));
}
}
public async Task <ActionResult <CampDomain[]> > Get(bool includeTalks = false)
{
try
{
var results = await _repository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampDomain[]>(results));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ActionResult <CampModel[]> > GETCamps()
{
try
{
var result = await _campRepository.GetAllCampsAsync();
return(_mapper.Map <CampModel[]>(result));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "DataBase Failure"));
}
}
// async Task<ActionResult<IEnumerable<Camp>>>
public async Task <ActionResult <CampModel[]> > GetCamps(bool includeTalks = false)
{
try
{
var results = await _repository.GetAllCampsAsync(includeTalks);
return(_mapper.Map <CampModel[]>(results));
}
catch (Exception e)
{
Console.WriteLine(e);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "It's not you, it's us"));
}
}
public async Task <IActionResult> GetCamps()
{
try
{
var result = await _repository.GetAllCampsAsync();
CampModel[] models = _mapper.Map <CampModel[]>(result);
return(Ok(models));
}
catch (Exception)
{
return(BadRequest("database fails"));
}
}
public async Task <ActionResult <IEnumerable <CampModel> > > Get(bool includeTalks = false)
{
try
{
var result = await _repository.GetAllCampsAsync(includeTalks);
var map = _mapper.Map <CampModel[]>(result);
return(map);
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database is down"));
}
}
public async Task <ActionResult <CampDto[]> > GetCamps(bool includeTalks = false)
{
try
{
var result = await _campRepository.GetAllCampsAsync(includeTalks);
CampDto[] camps = _mapper.Map <CampDto[]>(result);
return(camps);
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Failure retrieving camps\n" + ex.Message + "\n" + ex.InnerException ?? ""));
}
}
public async Task <ActionResult <CampModel[]> > GetCamps(bool includeTalks = false)
{
try
{
var results = await _campRepository.GetAllCampsAsync(includeTalks);
CampModel[] campModels = _mapper.Map <CampModel[]>(results);
return(campModels.Select(camp => CreateLinksForCamp(camp)).ToArray());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task <ActionResult <CampModels[]> > GetCamp(bool includeTalks = false)
{
try
{
var ListCapms = await campRepository.GetAllCampsAsync(includeTalks);
CampModels[] campModels = mapper.Map <CampModels[]>(ListCapms);
return(campModels);
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public async Task <IHttpActionResult> Get(bool includeTalks = false)
{
try
{
var camps = await _repository.GetAllCampsAsync(includeTalks);
return(Ok(_mapper.Map <IEnumerable <CampModel> >(camps)));
}
catch (Exception e)
{
//TODO: add logging
return(InternalServerError());
}
}
public async Task <IHttpActionResult> Get(bool includeTalks = false)
{
try
{
var result = await _campRepository.GetAllCampsAsync(includeTalks);
var mapperResult = _mapper.Map <IEnumerable <CampResDto> >(result);
return(Ok(mapperResult));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> Get(bool includeTalks = false)
{
try
{
var result = await _campRepository.GetAllCampsAsync(includeTalks);
return(Ok(_mapper.Map <IEnumerable <CampModel> >(result)));
}
catch
{
// TODO Add Logging
return(InternalServerError());
}
}
public async Task <IHttpActionResult> Get(bool includeTalks = false)
{
try
{
var result = await _iCampRepository.GetAllCampsAsync(includeTalks);
var mapresult = Mapper.Map <CampModel[]>(result);
return(Ok(mapresult));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
