public MultiOperationResponse ConstructFromMultiple([Required, FromBody] MultiOperationRequest request)
{
var errors = ForeachMultiple(request.lites, lite =>
OperationLogic.ServiceConstructFromLite(lite, request.GetOperationSymbol(lite.EntityType), request.args));
return(new MultiOperationResponse(errors));
}
public MultiOperationResponse ConstructFromMultiple([Required, FromBody] MultiOperationRequest request)
{
if (request.Setters.HasItems())
{
var errors = ForeachMultiple(request.Lites, lite =>
{
var entity = lite.RetrieveAndForget();
MultiSetter.SetSetters(entity, request.Setters, PropertyRoute.Root(entity.GetType()));
var op = request.GetOperationSymbol(entity.GetType());
OperationLogic.ServiceConstructFrom(entity, op, request.ParseArgs(op));
});
return(new MultiOperationResponse(errors));
}
else
{
var errors = ForeachMultiple(request.Lites, lite =>
{
var op = request.GetOperationSymbol(lite.EntityType);
OperationLogic.ServiceConstructFromLite(lite, op, request.ParseArgs(op));
});
return(new MultiOperationResponse(errors));
}
}
public EntityPackTS?ConstructFromLite([Required, FromBody] LiteOperationRequest request)
{
var op = request.GetOperationSymbol(request.lite.EntityType);
var entity = OperationLogic.ServiceConstructFromLite(request.lite, op, request.ParseArgs(op));
return(entity == null ? null : SignumServer.GetEntityPack(entity));
}
public ActionResult ConstructFrom()
{
OperationSymbol operationSymbol;
Entity entity = null;
if (this.IsLite())
{
Lite <Entity> lite = this.ExtractLite <Entity>();
entity = OperationLogic.ServiceConstructFromLite(lite, operationSymbol = this.GetOperationKeyAssert(lite.EntityType));
}
else
{
MappingContext context = this.UntypedExtractEntity().UntypedApplyChanges(this).UntypedValidate();
entity = (Entity)context.UntypedValue;
if (context.HasErrors())
{
return(context.ToJsonModelState());
}
try
{
entity = OperationLogic.ServiceConstructFrom(entity, operationSymbol = this.GetOperationKeyAssert(entity.GetType()));
}
catch (IntegrityCheckException e)
{
context.ImportErrors(e.Errors);
return(context.ToJsonModelState());
}
}
return(this.DefaultConstructResult(entity, operation: operationSymbol));
}
public MultiOperationResponse ConstructFromMultiple(MultiOperationRequest request)
{
var errors = ForeachMultiple(request.lites, lite =>
OperationLogic.ServiceConstructFromLite(lite, request.operarionSymbol, request.args));
return(new MultiOperationResponse {
errors = errors
});
}
public ActionResult ConstructFromMultiple()
{
OperationSymbol operationSymbol = this.GetOperationKeyAssert();
var lites = this.ParseLiteKeys <Entity>();
foreach (var item in lites)
{
OperationLogic.ServiceConstructFromLite(item, operationSymbol);
}
return(null);
}
public ActionResult ConstructFromMultiple()
{
var lites = this.ParseLiteKeys <Entity>();
OperationSymbol operationSymbol = lites.Select(a => a.EntityType).Distinct().Select(type => this.GetOperationKeyAssert(type)).Distinct().SingleEx();
foreach (var item in lites)
{
try
{
OperationLogic.ServiceConstructFromLite(item, operationSymbol);
}
catch (Exception ex)
{
ex.LogException();
}
}
return(null);
}
public EntityPackTS ConstructFromLite(LiteOperationRequest request)
{
var entity = OperationLogic.ServiceConstructFromLite(request.lite, request.GetOperationSymbol(request.lite.EntityType), request.args);
return(entity == null ? null: SignumServer.GetEntityPack(entity));
}
public Entity ConstructFromLite(Lite <IEntity> lite, OperationSymbol operationSymbol, params object[] args)
{
return(Return(MethodInfo.GetCurrentMethod(), operationSymbol.ToString(),
() => OperationLogic.ServiceConstructFromLite(lite, operationSymbol, args)));
}
public EntityPackTS ConstructFromLite(LiteOperationRequest request)
{
var entity = OperationLogic.ServiceConstructFromLite(request.lite, request.operarionSymbol, request.args);
return(SignumServer.GetEntityPack(entity));
}
