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);
}
private static void EmulateEditLocking(
string url, API.Constants.HttpMethods httpMethod, ref IResponseRootObject responseRootObject)
{
if (responseRootObject is null)
{
throw new ArgumentNullException(nameof(responseRootObject));
}
if (httpMethod == API.Constants.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 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);
}
public async Task <IEnumerable <Requirement> > GetModelDataAsync(
string authToken, Action <Exception> exceptionHandler)
{
var uri = typeof(Requirement).NameToUriFormat();
IResponseRootObject response = null;
try
{
response = await SimpleIoc.Default.GetInstance <IHttpDataServiceFacade>()
.HttpRequestAsync(uri, authToken);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
var index = new ResponseRootObjectToModelMapper <Requirement>(response).AllMapped();
index = await Decorate(index, exceptionHandler);
return(index);
}
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);
}
public async Task <Requirement> StoreModelAsync(
string authToken, Action <Exception> exceptionHandler, Requirement model)
{
if (!model.IsNew)
{
throw new ArgumentException("Trying to store an existing model!", nameof(model));
}
var uri = typeof(Requirement).NameToUriFormat();
var data = model.GetData();
IResponseRootObject response = null;
try
{
response = await _httpDataServiceFacade.HttpRequestAsync(
uri, User.Current.AuthToken, HttpMethods.Post, data);
}
catch (Exception ex)
{
exceptionHandler(ex);
response = new ResponseRootObject(ex.Message);
}
model = new ResponseRootObjectToModelMapper <Requirement>(response).Mapped();
return(model);
}
public Lookup(string lookupName, IResponseRootObject response)
: this(lookupName, response?.Data)
{
}
