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); }