/// <summary>
/// Edit a record utilizing a generic parameter type to house the fields to be edited.
/// </summary>
/// <typeparam name="T">Type parameter for this edit.</typeparam>
/// <param name="req">The edit request object.</param>
/// <returns></returns>
public override async Task <IEditResponse> SendAsync <T>(IEditRequest <T> req)
{
if (string.IsNullOrEmpty(req.Layout))
{
throw new ArgumentException("Layout is required on the request.");
}
if (req.RecordId <= 0)
{
throw new ArgumentException("RecordId is required on the request and non negative.");
}
HttpResponseMessage response = await ExecuteRequestAsync(req);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(new BaseResponse("404", "Error") as EditResponse);
}
try
{
var responseJson = await response.Content.ReadAsStringAsync();
var responseObject = JsonConvert.DeserializeObject <EditResponse>(responseJson);
return(responseObject);
}
catch (Exception ex)
{
// something bad happened. TODO: improve non-OK response handling
throw new Exception($"Non-OK Response: Status = {response.StatusCode}.", ex);
}
}
/// <summary>
/// Adds a script to the request, with a parameter.
/// </summary>
/// <param name="request">The request. This is the 'this' parameter.</param>
/// <param name="scriptName">Name of the script to be called.</param>
/// <param name="scriptParameter">Script parameter.</param>
/// <returns>The request instanced that was implicitly passed in which is useful for method chaining.</returns>
public static IEditRequest <T> SetScript <T>(
this IEditRequest <T> request,
string scriptName,
string scriptParameter = null)
{
request.Script = scriptName;
if (!string.IsNullOrEmpty(scriptParameter))
{
request.ScriptParameter = scriptParameter;
}
return(request);
}
/// <summary>
/// Executes an edit request.
/// </summary>
public override async Task <IEditResponse> SendAsync <T>(IEditRequest <T> req)
{
HttpResponseMessage response = await ExecuteRequestAsync(req);
if (response.IsSuccessStatusCode)
{
// process response data return OK
var resp = new EditResponse
{
Messages = new List <ResponseMessage> {
new ResponseMessage {
Code = "", Message = "OK"
}
}
};
return(resp);
}
throw new Exception("Unable to complete request");
}
/// <summary> /// Send an Edit Record request to the FileMaker API. /// </summary> public abstract Task <IEditResponse> SendAsync <T>(IEditRequest <T> req) where T : class, new();
/// <summary>
/// Helper For Getting Raw Responses from Data API.
/// </summary>
public Task <HttpResponseMessage> ExecuteRequestAsync <T>(IEditRequest <T> req) => ExecuteRequestAsync(new HttpMethod("PATCH"), UpdateEndpoint(req.Layout, req.RecordId), req);
/// <summary>
/// Specify a layout to use for this request.
/// </summary>
/// <param name="request">The request. This is the 'this' parameter.</param>
/// <param name="instance">Object to pull the layout from using its DataContract attribute.</param>
/// <typeparam name="T">The type used for the edit request/response.</typeparam>
/// <returns>The request instanced that was implicitly passed in which is useful for method chaining.</returns>
public static IEditRequest <T> UseLayout <T>(this IEditRequest <T> request, T instance)
{
request.Layout = FileMakerApiClientBase.GetLayoutName(instance);
return(request);
}
/// <summary>
/// Specify a layout to use for this request.
/// </summary>
/// <param name="request">The request. This is the 'this' parameter.</param>
/// <param name="layout">Name of the layout to use</param>
/// <typeparam name="T">The type used for the edit request/response.</typeparam>
/// <returns>The request instanced that was implicitly passed in which is useful for method chaining.</returns>
public static IEditRequest <T> UseLayout <T>(this IEditRequest <T> request, string layout)
{
request.Layout = layout;
return(request);
}
/// <summary>
/// Set the data for this request.
/// </summary>
/// <param name="request">The request. This is the 'this' parameter.</param>
/// <param name="data">Object containing the data for this find request record.</param>
/// <typeparam name="T">The type used for the edit request/response.</typeparam>
/// <returns>The request instanced that was implicitly passed in which is useful for method chaining.</returns>
public static IEditRequest <T> SetData <T>(this IEditRequest <T> request, T data)
{
request.Data = data;
return(request);
}
