/// <summary>Retrieve WebAdvisor ID and Date Created from a WaiddEntity object</summary>
public async Task <WebAdvisorIdAndDateEntity> GetWebAdvisorIdAndDateAsync
(WebAdvisorIdAndDateEntity WaiddEntity)
{
var request = new URTRequest();
request.ColleagueId = WaiddEntity.ColleagueId;
var response = new URTResponse();
try
{
response = await transactionInvoker.ExecuteAsync
<URTRequest, URTResponse>(request);
}
catch (Exception)
{
var errorText = "Transaction Invoker Execute Error for GetWAIDDRequest";
logger.Error(errorText);
throw new InvalidOperationException(errorText);
}
var entityResponse = BuildWebAdvisorIdAndDate(response, WaiddEntity.ColleagueId);
return(entityResponse);
}
/// <summary>Retrieve WebAdvisor ID and Date Created from a Colleague Id string</summary>
public Task <WebAdvisorIdAndDateEntity> GetWebAdvisorIdAndDateAsync(string ColleagueId)
{
var inputEntity = new WebAdvisorIdAndDateEntity()
{
ColleagueId = ColleagueId
};
return(GetWebAdvisorIdAndDateAsync(inputEntity));
}
/// <summary>An example of how to call a synchronous version of the async method accepting an object</summary>
public WebAdvisorIdAndDateEntity GetWebAdvisorIdAndDate(WebAdvisorIdAndDateEntity WaiddEntity)
{
var x = Task.Run(async() =>
{
return(await GetWebAdvisorIdAndDateAsync(WaiddEntity));
}).GetAwaiter().GetResult();
return(x);
}
/// <summary>An example of how you could call a synchronous version of the async method accepting a string</summary>
public WebAdvisorIdAndDateEntity GetWebAdvisorIdAndDate(string ColleagueId)
{
var inputEntity = new WebAdvisorIdAndDateEntity()
{
ColleagueId = ColleagueId
};
var x = Task.Run(async() =>
{
return(await GetWebAdvisorIdAndDateAsync(inputEntity));
}).GetAwaiter().GetResult();
return(x);
}
/// <summary>Retrieve a WebAdvisor Id and DateCreated from a provided Colleague Id</summary>
/// <param name="ColleagueId"></param>
/// <returns></returns>
public async Task <WebAdvisorIdAndDateDto> GetWebAdvisorIdAndDateFromColleagueIdAsync(string ColleagueId)
{
if (string.IsNullOrWhiteSpace(ColleagueId))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
WebAdvisorIdAndDateEntity result = await webAdvisorRepository.GetWebAdvisorIdAndDateAsync(ColleagueId);
var entityToDtoAdapter = adapterRegistry.GetAdapter <WebAdvisorIdAndDateEntity, WebAdvisorIdAndDateDto>();
WebAdvisorIdAndDateDto responseDto = entityToDtoAdapter.MapToType(result);
return(responseDto);
}
/// <summary>
/// This is not a real POST call, it's not updating anything, but shows you how to handle it.
/// </summary>
/// <param name="WaiddObj"></param>
public async Task <WebAdvisorIdAndDateDto> PostWebAdvisorIdAndDateWaiddObjectAsync(WebAdvisorIdAndDateDto WaiddObj)
{
if (string.IsNullOrWhiteSpace(WaiddObj.ColleagueId))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
//In a normal example we'd not just be going about using the adapter for evertyhing
//here we're using it to demonstrate how to map types both for objects in and out
var dtoToEntityAdapter = adapterRegistry.GetAdapter <WebAdvisorIdAndDateDto, WebAdvisorIdAndDateEntity>();
WebAdvisorIdAndDateEntity requestEntity = dtoToEntityAdapter.MapToType(WaiddObj);
WebAdvisorIdAndDateEntity requestResult = await webAdvisorRepository.GetWebAdvisorIdAndDateAsync(requestEntity);
var entityToDtoAdapter = adapterRegistry.GetAdapter <WebAdvisorIdAndDateEntity, WebAdvisorIdAndDateDto>();
WebAdvisorIdAndDateDto responseDto = entityToDtoAdapter.MapToType(requestResult);
return(responseDto);
}
/// <summary>Create a WebAdvisor ID and Date Entity object from a DataContract response.</summary>
private WebAdvisorIdAndDateEntity BuildWebAdvisorIdAndDate(URTResponse response, string ColleagueId)
{
var entity = new WebAdvisorIdAndDateEntity()
{
WebAdvisorId = response.WebAdvisorId,
ColleagueId = ColleagueId
};
DateTime dateOut;
if (DateTime.TryParse(response.DateCreated, out dateOut))
{
entity.DateCreated = dateOut;
}
else
{
entity.DateCreated = null;
}
return(entity);
}
