public async Task <IActionResult> PostRequirement([FromBody] Requirement requirement)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Requirement.Add(requirement);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to store new model in db");
throw;
}
var root = new ResponseRootObject(201, requirement);
return(CreatedAtAction("GetRequirement", new { id = requirement.RequirementID }, root));
}
private ResponseRootObject DeserializeResponseRootObject(string rawResponseContent, string url)
{
ResponseRootObject responseRootObject;
try
{
responseRootObject =
JsonConvert.DeserializeObject <ResponseRootObject>(rawResponseContent, new ResponseConverter());
}
catch (JsonReaderException)
{
Log.Error(
$"The raw response could not be read by Json Reader. Raw: [{rawResponseContent}]");
responseRootObject = new ResponseRootObject(rawResponseContent)
{
Success = true
};
}
catch (JsonSerializationException ex)
{
var msg = "Deserialisation 'error' on response from: " +
url + ". NOTE FOR DEV: " +
"Check the API method is defined to return an array of " +
"objects in 'data' even if there is just one. However, " +
"this may simply be that no data was returned. This can " +
"happen with a call to an API Create method which has " +
"no templating. " +
"Here is the JsonSerializationException: " + ex.Message;
Log.Error(msg);
responseRootObject = new ResponseRootObject(msg);
}
return(responseRootObject);
}
public async Task <IActionResult> PutRequirement([FromRoute] int id, [FromBody] Requirement requirement)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != requirement.RequirementID)
{
return(BadRequest());
}
_context.Entry(requirement).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequirementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var root = new ResponseRootObject(200, requirement);
return(Ok(root));
}
public ResponseRootObject GetRequirementEstimation()
{
var index = _context.RequirementEstimation;
var root = new ResponseRootObject(200, index);
return(root);
}
public async Task <Requirement> EditModelAsync(
string authToken, Action <Exception> exceptionHandler, int modelId)
{
var isNew = modelId < 1;
if (isNew)
{
throw new NotSupportedException(
"Trying to edit a new model! Use the store method instead.");
}
var uri = $"{typeof(Requirement).NameToUriFormat()}/{modelId}/edit";
IResponseRootObject response = null;
try
{
response = await _httpDataServiceFacade.HttpRequestAsync(uri, authToken);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
var model = new ResponseRootObjectToModelMapper <Requirement>(response).Mapped();
return(model);
}
public ResponseRootObject GetRequirementStatus()
{
var index = _context.RequirementStatus;
var root = new ResponseRootObject(200, index);
return(root);
}
private ResponseRootObject MockPut(string uri, IDictionary <string, object> data)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
var id = GetIdFromUri(uri);
var requirement = MockRequirementDb.FirstOrDefault(r => r.Id == id);
if (requirement != null)
{
MockRequirementDb.Remove(requirement);
requirement = new Requirement();
var dto = Convert(data, uri);
requirement.Initialise(dto);
MockRequirementDb.Add(requirement);
}
responseRootObject = Convert(requirement);
break;
default:
throw new NotSupportedException();
}
return(responseRootObject);
}
private static void AnticipatedStatusCodeErrorCheck(
int statusCode, ResponseRootObject responseRootObject)
{
if (allowedStatusCodes.Contains(statusCode))
{
if (!successCodes.Contains(statusCode))
{
if (responseRootObject is null)
{
throw new HttpDataServiceException(
statusCode, "Unexpected result: API with an allowed status code returned null!");
}
if (string.IsNullOrEmpty(responseRootObject.Error))
{
throw new HttpDataServiceException(
statusCode,
"Unexpected result: API with an allowed status code returned" +
" response root object with null or empty Error property!");
}
throw new HttpDataServiceException(statusCode, responseRootObject.Error);
}
else if (!responseRootObject.Success)
{
// Unexpected state from API that can be resolved locally
responseRootObject.Success = true;
}
}
}
private ResponseRootObject MockGet(string uri)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
responseRootObject = Convert(MockRequirementDb);
break;
case "requirementestimation":
responseRootObject = DeserializeResponseRootObject(
MockLookupDb["RequirementEstimation"], 200, $"Mocked/RequirementEstimation");
break;
case "requirementpriority":
responseRootObject = DeserializeResponseRootObject(
MockLookupDb["RequirementPriority"], 200, $"Mocked/RequirementPriority");
break;
case "requirementstatus":
responseRootObject = DeserializeResponseRootObject(
MockLookupDb["RequirementStatus"], 200, $"Mocked/RequirementStatus");
break;
}
return(responseRootObject);
}
public async Task <IActionResult> DeleteRequirement([FromRoute] int id)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var requirement = await _context.Requirement.FindAsync(id);
if (requirement == null)
{
return(NotFound());
}
_context.Requirement.Remove(requirement);
await _context.SaveChangesAsync();
var root = new ResponseRootObject(202);
return(AcceptedAtAction("GetRequirement", new { id = requirement.RequirementID }, root));
}
private static void EmulateEditLocking(
string url, HttpMethods httpMethod, ref ResponseRootObject responseRootObject)
{
if (responseRootObject == null)
{
throw new ArgumentNullException(nameof(responseRootObject));
}
if (httpMethod == HttpMethods.Get && (url.EndsWith("edit") || url.Contains("create")))
{
foreach (var dto in responseRootObject.Data)
{
var prop = typeof(DataTransferObject).GetProperty(
"Fields", BindingFlags.NonPublic | BindingFlags.Instance);
var fields = (IDictionary <string, object>)prop.GetValue(dto);
var key = "IsLockedForEditing";
if (fields.ContainsKey(key))
{
fields[key] = true;
}
else
{
fields.Add(key, true);
}
}
}
}
public ResultDTO Process()
{
// Get all new failed transactions
var proCampaignTransactions = ProCampaignTransactionManager.GetByStatus(ProCampaignTransactionStatusKeys.NEW);
foreach (var proCampaignTransaction in proCampaignTransactions)
{
// Deserialise transaction object
ProCampaignStatus proCampaignStatus = proCampaignTransaction.ProCampaignStatus;
var transactionObject = (APIUtility)JsonConvert.DeserializeObject(
proCampaignTransaction.TransactionObject,
new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
}
);
// Send the transaction object to Consultix
ResponseRootObject apiResult = null;
try
{
apiResult = ProCampaignFactory.ConfigureProCampaignService(proCampaignTransaction.Database)
.ConsumerClient
.SubscribeWithRequestConsumerId(transactionObject);
if (apiResult != null && apiResult.IsSuccessful == true)
{
// Update proCampaignTransaction
proCampaignTransaction.Status = ProCampaignTransactionStatusKeys.SENT;
proCampaignTransaction.TransactionObject = String.Empty;
proCampaignTransaction.UpdatedOn = DateTime.UtcNow;
ProCampaignTransactionManager.Update(proCampaignTransaction);
// Update proCampaignStatus
proCampaignStatus.IsSuccessful = apiResult.IsSuccessful;
proCampaignStatus.ResponseCode = apiResult.StatusCode;
proCampaignStatus.ResponseText = apiResult.StatusMessage;
proCampaignStatus.HttpStatusCode = apiResult.HttpStatusCode;
proCampaignStatus.HttpStatusMessage = apiResult.HttpStatusMessage;
proCampaignStatus.UpdatedOn = DateTime.UtcNow;
ProCampaignStatusManager.Update(proCampaignStatus);
// Update participant
Participant participant = proCampaignStatus.Entry.Participant;
participant.ConsumerId = apiResult.Data.ConsumerId;
participant.UpdatedOn = DateTime.UtcNow;
ParticipantManager.Update(participant);
}
}
catch (WebException ex)
{
proCampaignTransaction.UpdatedOn = DateTime.UtcNow;
ProCampaignTransactionManager.Update(proCampaignTransaction);
}
}
Result.HttpStatusCode = HttpStatusCode.OK;
return(Result);
}
public async Task <IActionResult> PostLogin(
[FromForm] string username,
[FromForm] string password)
{
var token = await _auth.AuthenticateAsync(username, password);
var root = new ResponseRootObject(200, token);
return(Ok(root));
}
/// <summary>
/// We can move this into the API if we feel it is needed.
/// The ResponseRootObject argument passed in with its editable flag set.
/// </summary>
/// <param name="url"></param>
/// <param name="httpMethod"></param>
/// <param name="responseRootObject"></param>
/// <returns></returns>
private static void EmulateEditLocking(
string url, HttpMethods httpMethod, ref ResponseRootObject responseRootObject)
{
if (responseRootObject == null)
{
throw new ArgumentNullException(nameof(responseRootObject));
}
if (httpMethod == HttpMethods.Get && (url.EndsWith("edit") || url.Contains("create")))
{
responseRootObject.__SetIsLockedForEditing();
}
}
public async Task <IActionResult> CreateRequirement()
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
var root = new ResponseRootObject(200, new Requirement());
await Task.CompletedTask;
return(Ok(root));
}
private async Task <IRootObject> Query(string url)
{
if (!string.IsNullOrEmpty(_sortingAttribute) && _endpoint != Endpoint.Status.ToString())
{
if (!url.Contains("?"))
{
url += "?";
}
url += "sort=";
if (!_sortingOrder)
{
url += "-";
}
url += _sortingAttribute;
}
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_apiUrl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Authorization", _apiKey);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.api+json"));
HttpResponseMessage response = await client.GetAsync(url);
_status = (int)response.StatusCode;
_statusText = response.StatusCode.ToString();
string jsonString = await response.Content.ReadAsStringAsync();
ResponseRootObject returnObject = null;
if (_isSuccessStatusCode = response.IsSuccessStatusCode)
{
ResponseRootObject responseData = (ResponseRootObject)JsonConvert.DeserializeObject(jsonString);
returnObject = Helpers.ConvertToEndpointType(responseData, (Endpoint)Enum.Parse(typeof(Endpoint), _endpoint));
_rootObject = returnObject;
_nextUrl = returnObject.Links.Next.Replace(_apiUrl, "");
_previousUrl = returnObject.Links.Previous.Replace(_apiUrl, "");
_firstUrl = returnObject.Links.First.Replace(_apiUrl, "");
return(responseData);
}
else
{
ErrorsRootObject responseError = (ErrorsRootObject)JsonConvert.DeserializeObject(jsonString);
//TODO: Error handling including throttling (errorcode 4XX)
return(responseError);
}
}
}
public ResponseRootObject GetRequirement()
{
ResponseRootObject root;
if (!User.Identity.IsAuthenticated)
{
root = new ResponseRootObject(401);
return(root);
}
var index = _context.Requirement;
root = new ResponseRootObject(200, index);
return(root);
}
public ResultDTO Process()
{
try
{
// Build request
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(
string.Format(
"https://api.procampaignapi.com/Consumer/Documents/{0}/{1}?apiKey={2}",
TermsAndConditionsName,
TermsAndConditionsName,
ProCampaignKeyRepository.GetApiKey(Locale, Environment)
));
request.Method = "Get";
request.KeepAlive = true;
// Get response
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
request.ContentType = "application/json";
Result.HttpStatusCode = HttpStatusCode.OK;
using (StreamReader streamReader = new StreamReader(response.GetResponseStream()))
{
string responseValue = streamReader.ReadToEnd();
ResponseRootObject responseResult = JsonConvert.DeserializeObject <ResponseRootObject>(responseValue);
if (responseResult.IsSuccessful)
{
Result.HttpStatusCode = HttpStatusCode.OK;
Result.Meta = new
{
PolicyText = String.Empty,
PolicyVersion = String.Empty,
TnCText = responseResult.Data.Html,
TnCVersion = responseResult.Data.Versions[0].Version
};
}
else
{
Result.HttpStatusCode = HttpStatusCode.InternalServerError;
Result.Code = CodeKeys.SYSTEM_ERROR_01;
}
}
}
catch (Exception ex)
{
Result.HttpStatusCode = HttpStatusCode.InternalServerError;
Result.Code = CodeKeys.SYSTEM_ERROR_01;
}
return(Result);
}
private ResponseRootObject MockCreate(string uri)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
var @new = new Requirement();
responseRootObject = Convert(@new);
break;
default:
throw new NotSupportedException();
}
return(responseRootObject);
}
private ResponseRootObject MockEdit(string uri)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
var id = GetIdFromUri(uri);
var requirement = MockRequirementDb.FirstOrDefault(r => r.Id == id);
responseRootObject = Convert(requirement);
break;
default:
throw new NotSupportedException();
}
return(responseRootObject);
}
public async Task <IActionResult> EditRequirement([FromRoute] int id)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
var requirement = await _context.Requirement.FindAsync(id);
if (requirement == null)
{
return(NotFound());
}
// Could lock the record here but EF Core handles concurrency just fine.
var root = new ResponseRootObject(200, requirement);
return(Ok(root));
}
private static void AnticipatedStatusCodeErrorCheck(
int statusCode, ResponseRootObject responseRootObject)
{
if (allowedStatusCodes.Contains(statusCode) && statusCode != 200)
{
if (responseRootObject == null)
{
throw new HttpDataServiceException(
statusCode, "Unexpected result: API with an allowed status code returned null!");
}
if (string.IsNullOrEmpty(responseRootObject.Error))
{
throw new HttpDataServiceException(
statusCode,
"Unexpected result: API with an allowed status code returned" +
" response root object with null or empty Error property!");
}
throw new HttpDataServiceException(statusCode, responseRootObject.Error);
}
}
public async Task <Requirement> CreateModelAsync(
string authToken, Action <Exception> exceptionHandler)
{
var uri = $"{typeof(Requirement).NameToUriFormat()}/create";
IResponseRootObject response = null;
try
{
response = await _httpDataServiceFacade.HttpRequestAsync(
uri, User.Current.AuthToken);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
var model = new ResponseRootObjectToModelMapper <Requirement>(response).Mapped();
return(model);
}
private static ResponseRootObject DeserializeResponseRootObject(
string rawResponseContent, int statusCode, string url)
{
ResponseRootObject responseRootObject;
try
{
responseRootObject =
JsonConvert.DeserializeObject <ResponseRootObject>(
rawResponseContent, new ResponseConverter());
}
catch (JsonReaderException ex)
{
var msg = $"The raw response could not be read by Json Reader: {ex.Message}." +
$" Raw: [{rawResponseContent}]";
Log.Error(msg);
responseRootObject = new ResponseRootObject(msg);
}
catch (JsonSerializationException ex)
{
var msg = "Deserialisation 'error' on response from: " +
$"{url}. NOTE FOR DEV: " +
"Check the API method is defined to return an array of " +
"objects in 'data' even if there is just one. However, " +
"this may simply be that no data was returned. This can " +
"happen with a call to an API Create method which has " +
"no templating. " +
$"Here is the JsonSerializationException: {ex.Message}" +
$"{Environment.NewLine}And here is the raw response: " +
$"{rawResponseContent}";
Log.Error(msg);
responseRootObject = new ResponseRootObject(msg);
}
if (responseRootObject is null)
{
throw new Exception(
$"Expected the {nameof(rawResponseContent)} to convert but it has returned null! " +
$"Contents: [{rawResponseContent}]");
}
return(responseRootObject);
}
public async Task <IEnumerable <Requirement> > GetModelDataAsync(
string authToken, Action <Exception> exceptionHandler)
{
var uri = typeof(Requirement).NameToUriFormat();
ResponseRootObject response = null;
try
{
response = await ServiceLocator.Current.GetInstance <IHttpDataServiceFacade>()
.HttpRequestAsync(uri, authToken);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
var index = new ResponseRootObjectToModelMapper <Requirement>(response).AllMapped();
return(index);
}
public async Task <IActionResult> GetRequirement([FromRoute] int id)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var requirement = await _context.Requirement.FindAsync(id);
if (requirement == null)
{
return(NotFound());
}
var root = new ResponseRootObject(200, requirement);
return(Ok(root));
}
private ResponseRootObject MockDelete(string uri)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
var id = GetIdFromUri(uri);
var requirement = MockRequirementDb.FirstOrDefault(r => r.Id == id);
if (requirement != null)
{
MockRequirementDb.Remove(requirement);
}
responseRootObject = JustSuccess(uri);
break;
default:
throw new NotSupportedException();
}
return(responseRootObject);
}
private ResponseRootObject MockPost(string uri, IDictionary <string, object> data)
{
var resource = GetResourceNameFromUri(uri);
ResponseRootObject responseRootObject = null;
switch (resource)
{
case "requirement":
var requirement = new Requirement();
var dto = Convert(data, uri);
requirement.Initialise(dto);
requirement.RequirementID = MockRequirementDb
.OrderByDescending(r => r.Id).FirstOrDefault().Id + 1;
MockRequirementDb.Add(requirement);
responseRootObject = Convert(requirement);
break;
default:
throw new NotSupportedException();
}
return(responseRootObject);
}
public async Task <bool> DeleteModelAsync(
string authToken, Action <Exception> exceptionHandler, Requirement model)
{
if (model.IsNew)
{
throw new ArgumentException("Trying to delete a new model!", nameof(model));
}
var uri = $"{typeof(Requirement).NameToUriFormat()}/{model.Id}";
var data = model.GetData();
IResponseRootObject response = null;
try
{
response = await _httpDataServiceFacade.HttpRequestAsync(
uri, User.Current.AuthToken, HttpMethods.Delete, null);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
return(response.Success);
}
private ResponseRootObject GetResponse(
HttpMethods httpMethod, string uri, IDictionary <string, object> data)
{
ResponseRootObject responseRootObject = null;
switch (httpMethod)
{
case HttpMethods.Post:
responseRootObject = MockPost(uri, data);
break;
case HttpMethods.Put:
responseRootObject = MockPut(uri, data);
break;
case HttpMethods.Delete:
responseRootObject = MockDelete(uri);
break;
default:
if (uri.EndsWith("create"))
{
responseRootObject = MockCreate(uri);
}
else if (uri.EndsWith("edit"))
{
responseRootObject = MockEdit(uri);
}
else
{
responseRootObject = MockGet(uri);
}
break;
}
return(responseRootObject);
}
