public static IDependencyInjectionFlowBuilderContext <T> ConfirmFilesFor <T>(this IDependencyInjectionFlowBuilderContext <T> builder, Func <IServiceProvider, T, Task <IEnumerable <string> > > findFiles)
{
return(builder.Pipe <T, IServiceProvider>(async(sp, model) =>
{
var fm = sp.GetRequiredService <Hcs.Platform.File.IFileManager>();
foreach (var file in ParseFileString(await findFiles(sp, model)))
{
await fm.ConfirmFile(file);
}
return model;
}));
}
public static IDependencyInjectionFlowBuilderContext <IActionResult> Ok(this IDependencyInjectionFlowBuilderContext <object> builder, bool outputCurrentValue = true)
{
return(builder.StatusCode(200, outputCurrentValue));
}
public static IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > Unique <TEntity>(this IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > builder, Action <UniqueValidateConfigurator <TEntity, PlatformDbContext> > options) where TEntity : class
{
return(builder.Unique <TEntity, PlatformDbContext>(options));
}
public static IDependencyInjectionFlowBuilderContext <TNOutput> Then <TOutput, TNOutput>(this IDependencyInjectionFlowBuilderContext <TOutput> builder, IFlowProcessor <TOutput, TNOutput> processor)
{
return(builder.Then(() => processor));
}
public static IDependencyInjectionFlowBuilderContext <T> SaveChildsFor <T, TChild>(this IDependencyInjectionFlowBuilderContext <T> builder, Expression <Func <T, IEnumerable <TChild> > > getChildsExp)
where T : class where TChild : class => builder.SaveChildsFor <PlatformDbContext, T, TChild>(getChildsExp);
public static IDependencyInjectionFlowBuilderContext <IActionResult> QueryOutout <T>(this IDependencyInjectionFlowBuilderContext <IEnumerable <T> > builder, Action <ExportSettings <object> > settings)
{
return(builder.Pipe(new Func <IHttpContextAccessor, IEnumerable <T>, IActionResult>((IHttpContextAccessor httpCtx, IEnumerable <T> data) =>
{
var req = httpCtx.HttpContext.Request;
if (req.Query.ContainsKey("export") && req.Query["export"] == "true")
{
if (!req.Query.ContainsKey("columns"))
{
return new ObjectResult("columns not define")
{
StatusCode = 400
};
}
var contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
var exportColumns = ExportColumn.Parse(req.Query["columns"]);
var set = new ExportSettings <object>();
settings(set);
var selset = new XlsxSerializeSettings <IEnumerable <object> >();
var processes = new List <IXlsxProcess <IEnumerable <object> > >();
var head = new WriteXlsxConst <IEnumerable <object> >(0, 0, 0, exportColumns.Select(x => x.DisplayName).ToArray());
head.PostSetValue = c => c.Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Center;
processes.Add(head);
if (data.Any())
{
if (data.First() is Microsoft.AspNet.OData.Query.ISelectExpandWrapper)
{
var listOfWriters = exportColumns.Select(c => new OdataCellWriter(c.PropertyName)).ToArray();
set.ConfigCellWriter(listOfWriters);
var rowp = new ObjectWriteXlsxRow <Microsoft.AspNet.OData.Query.ISelectExpandWrapper>(0, 1, 0, listOfWriters);
processes.Add(rowp);
}
else
{
var listOfWriters = exportColumns.Select(c => new PropertyCellWriter <object>(c.PropertyName, data.First().GetType())).ToArray();
set.ConfigCellWriter(listOfWriters);
var rowp = new WriteXlsxRow <object>(0, 1, 0, listOfWriters);
processes.Add(rowp);
}
}
processes.Add(new AutoFitColumns <IEnumerable <object> >(0));
selset.Processes = set.MapProcess(processes.ToArray());
selset.Template = set.MapTemplate(null);
return new FileStreamResult(new XlsxSerializer <IEnumerable <object> >(selset).Serialize(data.Cast <object>()), contentType);
}
return new OkObjectResult(data);
})));
}
public static IDependencyInjectionFlowBuilderContext <IQueryable <TEntity> > Filter <TEntity>(this IDependencyInjectionFlowBuilderContext <IQueryable <TEntity> > builder, System.Linq.Expressions.Expression <Func <TEntity, bool> > filter) => builder.Then(new FilterQueryData <TEntity>(filter));
public static IDependencyInjectionFlowBuilderContext <object[]> ApplyOdataFilter <TEntity>(this IDependencyInjectionFlowBuilderContext <IQueryable <TEntity> > builder) where TEntity : class => builder.Then <object[], ApplyOdataFilter <TEntity> >();
public static IDependencyInjectionFlowBuilderContext <GetKeyAndModelOutput <T, TKey, TEntity> > GetKeyAndModel <T, TKey, TEntity>(this IDependencyInjectionFlowBuilderContext <T> c) => c.Then <GetKeyAndModelOutput <T, TKey, TEntity>, GetKeyAndModel <T, TKey, TEntity> >();
public static IDependencyInjectionFlowBuilderContext <IActionResult> EndValidation <TEntity>(this IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > c, DIFlowBuilderHandler <TEntity, IActionResult> ifPass) where TEntity : class
{
return(c.Branch <IActionResult>(cases =>
{
cases.AddCase(x => x.ValidationErrors.Any(), builder => builder.Pipe(x => x.ValidationErrors).BadRequest(true));
cases.AddCase(x => !x.ValidationErrors.Any(), builder => ifPass(builder.Pipe(x => x.Data)));
}));
}
public static IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > StartValidation <TEntity>(this IDependencyInjectionFlowBuilderContext <TEntity> c) where TEntity : class => c.Then <EntityValidationResult <TEntity> >(() => new ValidationStart <TEntity>());
public static IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > Validate <TEntity>(this IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > c, Func <TEntity, Action <ValidationError>, Task> validate) where TEntity : class => c.Then <EntityValidationResult <TEntity> >(() => new DelegateValidationProcessor <TEntity>(validate));
public static IDependencyInjectionFlowBuilderContext <T> Then <T>(this IDependencyInjectionFlowBuilderContext <T> context, DIFlowBuilderHandler <T, T> insert) => insert(context);
public static IDependencyInjectionFlowBuilderContext <IActionResult> StatusCode(this IDependencyInjectionFlowBuilderContext <object> builder, int statusCode, bool outputCurrentValue = false)
{
if (outputCurrentValue)
{
return(builder.Pipe(x => new ObjectResult(x)
{
StatusCode = statusCode
}));
}
else
{
return(builder.Pipe(x => new StatusCodeResult(statusCode)));
}
}
public static IDependencyInjectionFlowBuilderContext <IActionResult> BadRequest(this IDependencyInjectionFlowBuilderContext <object> builder, bool outputCurrentValue = false)
{
return(builder.StatusCode(400, outputCurrentValue));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> UpdateData <TEntity>(this IDependencyInjectionFlowBuilderContext <TEntity> c) where TEntity : class => c.UpdateData <TEntity, PlatformDbContext>();
public static IDependencyInjectionFlowBuilderContext <IQueryable <TEntity> > Query <TCurrnet, TEntity, TDbContext>(this IDependencyInjectionFlowBuilderContext <TCurrnet> builder) where TDbContext : DbContext where TEntity : class => builder.Then <IQueryable <TEntity>, QueryData <TCurrnet, TEntity, TDbContext> >();
public static IDependencyInjectionFlowBuilderContext <TKey> GetRequestKey <TKey>(this IDependencyInjectionFlowBuilderContext <HttpRequest> c) => c.GetService <KeyRequestContext <TKey> >().Pipe(x => x.Service.Key);
public static IDependencyInjectionFlowBuilderContext <IQueryable <TEntity> > Query <TEntity>(this IDependencyInjectionFlowBuilderContext <HttpRequest> builder) where TEntity : class => builder.Query <TEntity, PlatformDbContext>();
public static IDependencyInjectionFlowBuilderContext <TEntity> GetRequestModel <TEntity>(this IDependencyInjectionFlowBuilderContext <HttpRequest> c) => c.GetService <InputRequestContext <TEntity> >().Pipe(x => x.Service.Input);
public static IDependencyInjectionFlowBuilderContext <IActionResult> OkOrNotFound(this IDependencyInjectionFlowBuilderContext <object> builder)
{
return(builder.Branch <IActionResult>(sCase =>
{
sCase.AddCase(x => x == null, cb => cb.NotFound());
sCase.AddCase(x => x != null, cb => cb.Ok());
}));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> SetModelKey <TKey, TEntity, TDbContext>(this IDependencyInjectionFlowBuilderContext <TEntity> c) where TDbContext : DbContext where TEntity : class => c.Then <TEntity, SetModelKey <TKey, TEntity, TDbContext> >();
public static IDependencyInjectionFlowBuilderContext <T> QueryChildFor <TDbContext, T, TChild>(this IDependencyInjectionFlowBuilderContext <T> builder,
Expression <Func <T, IEnumerable <TChild> > > getChildsExp)
where TDbContext : DbContext where T : class where TChild : class
{
return(builder.Pipe(async(IScopedDbContext <TDbContext> scopedContext, T model) =>
{
await scopedContext.DbContext.Entry(model).Collection(getChildsExp).LoadAsync();
}));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> SetModelKey <TKey, TEntity>(this IDependencyInjectionFlowBuilderContext <TEntity> c) where TEntity : class => c.SetModelKey <TKey, TEntity, PlatformDbContext>();
public static IDependencyInjectionFlowBuilderContext <T> SaveChildsFor <TDbContext, T, TChild>(this IDependencyInjectionFlowBuilderContext <T> builder, Expression <Func <T, IEnumerable <TChild> > > getChildsExp)
where TDbContext : DbContext where T : class where TChild : class
{
return(builder.Pipe(async(IScopedDbContext <TDbContext> scopedContext,
IModelInfo <TDbContext, TChild> mit,
IModelInfo <TDbContext, T> mi,
UpdateData <TChild, TDbContext> upd,
CreateData <TChild, TDbContext> cre,
DeleteData <TChild, TDbContext> del,
T model) =>
{
var getChilds = getChildsExp.Compile();
var childs = getChilds(model).ToArray();
var p = Expression.Parameter(typeof(T), "x");
var w = Expression.Lambda <Func <T, bool> >(Expression.Equal(Expression.Property(p, mi.PrimaryKey.Properties[0].PropertyInfo), Expression.Constant(mi.PrimaryKeyAccessor.GetValue(model))), p);
var old = await scopedContext.DbContext.Set <T>().AsNoTracking().Include(getChildsExp).Where(w).SelectMany(getChildsExp).ToArrayAsync();
upd.SaveChanges = false;
cre.SaveChanges = false;
del.SaveChanges = false;
var newIds = childs.Select(x => mit.PrimaryKeyAccessor.GetValue(x)).Where(x => x != null).ToArray();
foreach (var child in old.Where(x => !newIds.Any(y => y.Equals(mit.PrimaryKeyAccessor.GetValue(x)))))
{
await del.Run(child);
}
foreach (var child in childs)
{
if (mit.PrimaryKeyAccessor.IsNotDefault(child))
{
await upd.Run(child);
}
else
{
await cre.Run(child);
}
}
await scopedContext.DbContext.SaveChangesAsync();
}));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> GetData <TKey, TEntity, TDbContext>(this IDependencyInjectionFlowBuilderContext <TKey> builder) where TEntity : class where TDbContext : DbContext => builder.Then <TEntity, GetData <TKey, TEntity, TDbContext> >();
public static IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > Unique <TEntity, TDbContext>(this IDependencyInjectionFlowBuilderContext <EntityValidationResult <TEntity> > builder, Action <UniqueValidateConfigurator <TEntity, TDbContext> > options) where TEntity : class where TDbContext : DbContext
{
return(builder.Then((IServiceProvider sp) =>
{
var validator = new UniqueValidate <TEntity, TDbContext>(sp.GetRequiredService <IScopedDbContext <TDbContext> >());
var optionContext = new UniqueValidateConfigurator <TEntity, TDbContext>(validator);
options(optionContext);
return validator;
}));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> GetData <TKey, TEntity>(this IDependencyInjectionFlowBuilderContext <TKey> builder) where TEntity : class => builder.GetData <TKey, TEntity, PlatformDbContext>();
public static IDependencyInjectionFlowBuilderContext <EntityValidationResult <HttpRequest> > ValidOdata <TEntity>(this IDependencyInjectionFlowBuilderContext <EntityValidationResult <HttpRequest> > builder) where TEntity : class
{
return(builder.Pipe <Odata.IOdataValidator <TEntity>, Odata.IOdataQueryPermission, Core.OdataQueryRequestContext <TEntity> >((validator, permissions, context, errors) =>
{
var result = validator.Validate(context.ODataQueryOptions, permissions);
if (!result.Valid)
{
errors.AddError(new Core.ValidationError
{
Title = nameof(Odata.IOdataValidator <TEntity>),
Message = result.Message
});
}
}));
}
public static IDependencyInjectionFlowBuilderContext <TEntity> UpdateData <TEntity, TDbContext>(this IDependencyInjectionFlowBuilderContext <TEntity> c) where TEntity : class where TDbContext : DbContext => c.Then <TEntity, UpdateData <TEntity, TDbContext> >();
