private Stream Persist(MethodEnum method, Either <Type> maybeRoot, Stream data)
{
if (maybeRoot.IsFailure)
{
return(maybeRoot.Error);
}
var rootType = maybeRoot.Result;
var array = Utility.ParseObject(Serialization, Either <Type> .Succes(rootType.MakeArrayType()), data, false, Locator);
if (array.IsFailure)
{
return(array.Error);
}
var arg = (object[])array.Result;
return
(Converter.PassThrough <PersistAggregateRoot, PersistAggregateRoot.Argument <object> >(
new PersistAggregateRoot.Argument <object>
{
RootName = rootType.FullName,
ToInsert = method == MethodEnum.Insert ? arg : null,
ToUpdate = method == MethodEnum.Update ? CreateKvMethod.MakeGenericMethod(rootType).Invoke(this, new[] { arg }) : null,
ToDelete = method == MethodEnum.Delete ? arg : null
}));
}
public Stream Create(string root, Stream body)
{
var rootType = Utility.CheckAggregateRoot(DomainModel, root);
var validatedData = Utility.ParseObject(Serialization, rootType, body, false, Locator);
return
(Converter.PassThrough <Create, Create.Argument <object> >(
new Create.Argument <object>
{
Name = rootType.FullName,
Data = validatedData
}));
}
private Stream Persist(MethodEnum method, Type root, Stream data)
{
var array = (object[])Utility.ParseObject(Serialization, root.MakeArrayType(), data, false, Locator);
return
(Converter.PassThrough <PersistAggregateRoot, PersistAggregateRoot.Argument <object> >(
new PersistAggregateRoot.Argument <object>
{
RootName = root.FullName,
ToInsert = method == MethodEnum.Insert ? array : null,
ToUpdate = method == MethodEnum.Update ? CreateKvMethod.MakeGenericMethod(root).Invoke(this, new[] { array }) : null,
ToDelete = method == MethodEnum.Delete ? array : null
}));
}
public Stream PopulateReportQuery(string report)
{
var reportType = Utility.CheckDomainObject(DomainModel, report);
var reportData = Utility.ObjectFromQuery(reportType);
if (reportData.IsFailure)
{
return(reportData.Error);
}
return(Converter.PassThrough <PopulateReport, PopulateReport.Argument <object> >(
new PopulateReport.Argument <object>
{
ReportName = reportType.Result.FullName,
Data = reportData.Result
}));
}
public Stream Create(string root, string result, Stream body)
{
var rootType = Utility.CheckAggregateRoot(DomainModel, root);
var validatedData = Utility.ParseObject(Serialization, rootType, body, false, Locator);
if (validatedData.IsFailure)
{
return(validatedData.Error);
}
return
(Converter.PassThrough <Create, Create.Argument <object> >(
new Create.Argument <object>
{
Name = rootType.Result.FullName,
Data = validatedData.Result,
ReturnInstance = Utility.ReturnInstance(result, ThreadContext.Request)
}));
}
public Stream Find(string domainObject, string uris)
{
Utility.CheckIdentifiable(DomainModel, domainObject);
return
(Converter.PassThrough <GetDomainObject, GetDomainObject.Argument>(
new GetDomainObject.Argument
{
Name = domainObject,
Uri = (uris ?? string.Empty).Split(',')
}));
}
public Stream PopulateReport(string report, Stream body)
{
var reportType = Utility.CheckDomainObject(DomainModel, report);
var validatedData = Utility.ParseObject(Serialization, reportType, body, true, Locator);
return(Converter.PassThrough <PopulateReport, PopulateReport.Argument <object> >(
new PopulateReport.Argument <object>
{
ReportName = reportType.FullName,
Data = validatedData
}));
}
public Stream FindQuery(string domainObject, string uris, string order)
{
Utility.CheckIdentifiable(DomainModel, domainObject);
return
(Converter.PassThrough <GetDomainObject, GetDomainObject.Argument>(
new GetDomainObject.Argument
{
Name = domainObject,
Uri = (uris ?? string.Empty).Split(','),
MatchOrder = order == "match"
}));
}
/// <summary>
/// Pass request to the server command.
/// Request is casted instead of deserialized.
/// Result type is defined with Accept header
/// If Accept header is not defined, XML will be used
/// </summary>
/// <typeparam name="TCommand">server command type</typeparam>
/// <typeparam name="TArgument">server command argument</typeparam>
/// <param name="converter">command converter</param>
/// <param name="argument">argument value</param>
/// <returns>result converted to requested mime type</returns>
public static Stream PassThrough <TCommand, TArgument>(this ICommandConverter converter, TArgument argument)
{
var accept = (ThreadContext.Request.Accept ?? "application/xml").ToLowerInvariant();
return(converter.PassThrough <TCommand, TArgument>(argument, accept));
}
