public static void Start(IApplicationBuilder app)
{
if (started)
{
return;
}
started = true;
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(QueryTokenEmbedded), () => UserAssetPermission.UserAssetsToXML.IsAuthorized() ||
TypeAuthLogic.GetAllowed(typeof(UserQueryEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None ||
TypeAuthLogic.GetAllowed(typeof(UserChartEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None
);
//EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(QueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx()));
//EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(PinnedQueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx().Pinned));
var pcs = PropertyConverter.GetPropertyConverters(typeof(QueryTokenEmbedded));
pcs.Add("token", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.TryToken == null ? null : new QueryTokenTS(qte.TryToken, true));
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.Add("parseException", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.ParseException?.Message);
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.GetOrThrow("tokenString").CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(qte.TryToken?.FullKey() ?? qte.TokenString);
};
}
public static void Start(HttpConfiguration config)
{
if (started)
{
return;
}
started = true;
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(QueryTokenEmbedded));
var pcs = PropertyConverter.GetPropertyConverters(typeof(QueryTokenEmbedded));
pcs.Add("token", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.TryToken == null ? null : new QueryTokenTS(qte.TryToken, true));
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.Add("parseException", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.ParseException?.Message);
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.GetOrThrow("tokenString").CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(qte.TryToken?.FullKey() ?? qte.TokenString);
};
}
private bool ValidateModifiableEntity(ModifiableEntity mod)
{
using (Validator.ModelBinderScope())
{
bool isValid = true;
var entity = mod as Entity;
using (entity == null ? null : entity.Mixins.OfType <CorruptMixin>().Any(c => c.Corrupt) ? Corruption.AllowScope() : Corruption.DenyScope())
{
foreach (var kvp in PropertyConverter.GetPropertyConverters(mod.GetType()))
{
if (kvp.Value.AvoidValidate)
{
continue;
}
string?error = kvp.Value.PropertyValidator !.PropertyCheck(mod);
if (error != null)
{
isValid = false;
ModelState.AddModelError(this.Key + "." + kvp.Key, error);
}
var val = kvp.Value.GetValue !(mod);
if (val != null && this.CurrentPath.Push(val))
{
using (StateManager.Recurse(this, this.Key + "." + kvp.Key, null, val, null))
{
if (this.SignumValidate() == false)
{
isValid = false;
}
}
}
}
}
if (entity != null && entity.Mixins.Any())
{
foreach (var mixin in entity.Mixins)
{
if (this.CurrentPath.Push(mixin))
{
using (StateManager.Recurse(this, "mixins[" + mixin.GetType().Name + "].element", null, mixin, null))
{
isValid &= ValidateModifiableEntity(mixin);
}
}
}
}
return(isValid);
}
}
public static void Start(IApplicationBuilder app)
{
TypeHelpServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.OverrideIsNamespaceAllowed.Add(typeof(ExchangeVersion).Namespace !, () => TypeAuthLogic.GetAllowed(typeof(EmailSenderConfigurationEntity)).MaxUI() > TypeAllowedBasic.None);
ReflectionServer.OverrideIsNamespaceAllowed.Add(typeof(SmtpDeliveryMethod).Namespace !, () => TypeAuthLogic.GetAllowed(typeof(EmailSenderConfigurationEntity)).MaxUI() > TypeAllowedBasic.None);
TemplatingServer.Start(app);
EntityJsonConverter.AfterDeserilization.Register((EmailTemplateEntity et) =>
{
if (et.Query != null)
{
var qd = QueryLogic.Queries.QueryDescription(et.Query.ToQueryName());
et.ParseData(qd);
}
});
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
if (Schema.Current.IsAllowed(typeof(EmailTemplateEntity), true) == null)
{
var templates = EmailTemplateLogic.GetApplicableEmailTemplates(type, null, EmailTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("emailTemplates", templates);
}
}
};
if (Schema.Current.Tables.ContainsKey(typeof(EmailSenderConfigurationEntity)))
{
var piPassword = ReflectionTools.GetPropertyInfo((SmtpNetworkDeliveryEmbedded e) => e.Password);
var pcs = PropertyConverter.GetPropertyConverters(typeof(SmtpNetworkDeliveryEmbedded));
pcs.GetOrThrow("password").CustomWriteJsonProperty = ctx => { };
pcs.Add("newPassword", new PropertyConverter
{
AvoidValidate = true,
CustomWriteJsonProperty = ctx => { },
CustomReadJsonProperty = ctx =>
{
EntityJsonConverter.AssertCanWrite(ctx.ParentPropertyRoute.Add(piPassword));
var password = (string)ctx.JsonReader.Value !;
((SmtpNetworkDeliveryEmbedded)ctx.Entity).Password = EmailSenderConfigurationLogic.EncryptPassword(password);
}
});
public static void Start(IApplicationBuilder app)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
PropertyConverter.GetPropertyConverters(typeof(FilePathEmbedded)).Add("fullWebPath", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var csp = (FilePathEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, csp.FullWebPath());
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
var s = Schema.Current.Settings;
ReflectionServer.AddPropertyRouteExtension += (mi, pr) =>
{
var dft = s.FieldAttributes(pr)?.OfType <DefaultFileTypeAttribute>().SingleOrDefaultEx();
if (dft != null)
{
if (dft.FileTypeSymbol == null)
{
dft.FileTypeSymbol = SymbolLogic <FileTypeSymbol> .Symbols
.Where(a => a.Key.After(".") == dft.SymbolName && (dft.SymbolContainer == null || dft.SymbolContainer == a.Key.Before(".")))
.SingleEx(
() => $"No FileTypeSymbol with name {dft.SymbolName} is registered",
() => $"More than one FileTypeSymbol with name {dft.SymbolName} are registered. Consider desambiguating using symbolContainer argument in {pr}"
);
}
var alg = FileTypeLogic.GetAlgorithm(dft.FileTypeSymbol);
mi.Extension.Add("defaultFileTypeInfo", new
{
key = dft.FileTypeSymbol.Key,
onlyImages = alg.OnlyImages,
maxSizeInBytes = alg.MaxSizeInBytes,
});
}
};
FilePathEntity.ToAbsolute = FilePathEmbedded.ToAbsolute = url => SignumCurrentContextFilter.Url !.Content(url);
}
private static void CustomizeChartRequest()
{
var converters = PropertyConverter.GetPropertyConverters(typeof(ChartRequestModel));
converters.Remove("queryName");
converters.Add("queryKey", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
((ChartRequestModel)ctx.Entity).QueryName = QueryLogic.ToQueryName((string)ctx.JsonReader.Value);
},
CustomWriteJsonProperty = ctx =>
{
var cr = (ChartRequestModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(QueryLogic.GetQueryEntity(cr.QueryName).Key);
}
});
converters.Add("filters", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = (List <FilterTS>)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(List <FilterTS>));
var cr = (ChartRequestModel)ctx.Entity;
var qd = QueryLogic.Queries.QueryDescription(cr.QueryName);
cr.Filters = list.Select(l => l.ToFilter(qd, canAggregate: true)).ToList();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (ChartRequestModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, cr.Filters.Select(f => FilterTS.FromFilter(f)).ToList());
}
});
}
private static void CustomizeFiltersModel()
{
var converters = PropertyConverter.GetPropertyConverters(typeof(QueryModel));
converters.Remove("queryName");
converters.Add("queryKey", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
((QueryModel)ctx.Entity).QueryName = QueryLogic.ToQueryName((string)ctx.JsonReader.Value !);
},
CustomWriteJsonProperty = ctx =>
{
var cr = (QueryModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(QueryLogic.GetQueryEntity(cr.QueryName).Key);
}
});
public static void Start(IApplicationBuilder app, Func <AuthTokenConfigurationEmbedded> tokenConfig, string hashableEncryptionKey)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
AuthTokenServer.Start(tokenConfig, hashableEncryptionKey);
ReflectionServer.GetContext = () => new
{
Culture = ReflectionServer.GetCurrentValidCulture(),
Role = UserEntity.Current == null ? null : RoleEntity.Current,
};
AuthLogic.OnRulesChanged += () => ReflectionServer.cache.Clear();
if (TypeAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (typeof(Entity).IsAssignableFrom(t))
{
var ta = UserEntity.Current != null?TypeAuthLogic.GetAllowed(t) : null;
ti.Extension.Add("maxTypeAllowed", ta == null ? TypeAllowedBasic.None : ta.MaxUI());
ti.Extension.Add("minTypeAllowed", ta == null ? TypeAllowedBasic.None : ta.MinUI());
ti.RequiresEntityPack |= ta != null && ta.Conditions.Any();
}
};
EntityPackTS.AddExtension += ep =>
{
var typeAllowed =
UserEntity.Current == null ? TypeAllowedBasic.None :
ep.entity.IsNew ? TypeAuthLogic.GetAllowed(ep.entity.GetType()).MaxUI() :
TypeAuthLogic.IsAllowedFor(ep.entity, TypeAllowedBasic.Write, true) ? TypeAllowedBasic.Write :
TypeAuthLogic.IsAllowedFor(ep.entity, TypeAllowedBasic.Read, true) ? TypeAllowedBasic.Read :
TypeAllowedBasic.None;
ep.extension.Add("typeAllowed", typeAllowed);
};
OperationController.AnyReadonly += (Lite <Entity>[] lites) =>
{
return(lites.GroupBy(ap => ap.EntityType).Any(gr =>
{
var ta = TypeAuthLogic.GetAllowed(gr.Key);
if (ta.Min(inUserInterface: true) == TypeAllowedBasic.Write)
{
return false;
}
if (ta.Max(inUserInterface: true) <= TypeAllowedBasic.Read)
{
return true;
}
return giCountReadonly.GetInvoker(gr.Key)() > 0;
}));
};
}
if (QueryAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (ti.QueryDefined)
{
ti.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(t));
}
};
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.DeclaringType !.Name.EndsWith("Query"))
{
mi.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(fi.GetValue(null) !));
}
};
}
if (PropertyAuthLogic.IsStarted)
{
ReflectionServer.AddPropertyRouteExtension += (mi, pr) =>
{
mi.Extension.Add("propertyAllowed", UserEntity.Current == null ? PropertyAllowed.None : pr.GetPropertyAllowed());
};
}
if (OperationAuthLogic.IsStarted)
{
ReflectionServer.AddOperationExtension += (oits, oi, type) =>
{
oits.Extension.Add("operationAllowed",
UserEntity.Current == null ? false :
OperationAuthLogic.GetOperationAllowed(oi.OperationSymbol, type, inUserInterface: true));
};
}
if (PermissionAuthLogic.IsStarted)
{
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.FieldType == typeof(PermissionSymbol))
{
mi.Extension.Add("permissionAllowed",
UserEntity.Current == null ? false :
PermissionAuthLogic.IsAuthorized((PermissionSymbol)fi.GetValue(null) !));
}
};
}
var piPasswordHash = ReflectionTools.GetPropertyInfo((UserEntity e) => e.PasswordHash);
var pcs = PropertyConverter.GetPropertyConverters(typeof(UserEntity));
pcs.GetOrThrow("passwordHash").CustomWriteJsonProperty = ctx => { };
pcs.Add("newPassword", new PropertyConverter
{
AvoidValidate = true,
CustomWriteJsonProperty = ctx => { },
CustomReadJsonProperty = ctx =>
{
EntityJsonConverter.AssertCanWrite(ctx.ParentPropertyRoute.Add(piPasswordHash));
var password = (string)ctx.JsonReader.Value !;
var error = UserEntity.OnValidatePassword(password);
if (error != null)
{
throw new ApplicationException(error);
}
((UserEntity)ctx.Entity).PasswordHash = Security.EncodePassword(password);
}
});
private static void CustomizeFiltersModel()
{
var converters = PropertyConverter.GetPropertyConverters(typeof(QueryModel));
converters.Remove("queryName");
converters.Add("queryKey", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
((QueryModel)ctx.Entity).QueryName = QueryLogic.ToQueryName((string)ctx.JsonReader.Value);
},
CustomWriteJsonProperty = ctx =>
{
var cr = (QueryModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(QueryLogic.GetQueryEntity(cr.QueryName).Key);
}
});
converters.Add("filters", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = (List <FilterTS>)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(List <FilterTS>));
var cr = (QueryModel)ctx.Entity;
var qd = QueryLogic.Queries.QueryDescription(cr.QueryName);
cr.Filters = list.Select(l => l.ToFilter(qd, canAggregate: true)).ToList();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (QueryModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, cr.Filters.Select(f => FilterTS.FromFilter(f)).ToList());
}
});
converters.Add("orders", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = (List <OrderTS>)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(List <OrderTS>));
var cr = (QueryModel)ctx.Entity;
var qd = QueryLogic.Queries.QueryDescription(cr.QueryName);
cr.Orders = list.Select(l => l.ToOrder(qd, canAggregate: true)).ToList();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (QueryModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, cr.Orders.Select(f => new OrderTS
{
token = f.Token.FullKey(),
orderType = f.OrderType
}));
}
});
converters.Add("pagination", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var pagination = (PaginationTS)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(PaginationTS));
var cr = (QueryModel)ctx.Entity;
cr.Pagination = pagination.ToPagination();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (QueryModel)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, new PaginationTS(cr.Pagination));
}
});
}
public static void Start(HttpConfiguration config, Func <AuthTokenConfigurationEmbedded> tokenConfig, string hashableEncryptionKey)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
AuthTokenServer.Start(tokenConfig, hashableEncryptionKey);
ReflectionServer.GetContext = () => new
{
Culture = ReflectionServer.GetCurrentValidCulture(),
Role = UserEntity.Current == null ? null : RoleEntity.Current,
};
AuthLogic.OnRulesChanged += () => ReflectionServer.cache.Clear();
if (TypeAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (typeof(Entity).IsAssignableFrom(t))
{
ti.Extension.Add("typeAllowed", UserEntity.Current == null ? TypeAllowedBasic.None : TypeAuthLogic.GetAllowed(t).MaxUI());
}
};
}
if (QueryAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (ti.QueryDefined)
{
ti.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(t));
}
};
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.DeclaringType.Name.EndsWith("Query"))
{
mi.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(fi.GetValue(null)));
}
};
}
if (PropertyAuthLogic.IsStarted)
{
ReflectionServer.AddPropertyRouteExtension += (mi, pr) =>
{
mi.Extension.Add("propertyAllowed", UserEntity.Current == null ? PropertyAllowed.None : pr.GetPropertyAllowed());
};
}
if (OperationAuthLogic.IsStarted)
{
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.DeclaringType.Name.EndsWith("Operation"))
{
if (fi.GetValue(null) is IOperationSymbolContainer container)
{
mi.Extension.Add("operationAllowed",
UserEntity.Current == null ? false
: OperationAuthLogic.GetOperationAllowed(container.Symbol, inUserInterface: true));
}
}
};
}
if (PermissionAuthLogic.IsStarted)
{
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.FieldType == typeof(PermissionSymbol))
{
mi.Extension.Add("permissionAllowed",
UserEntity.Current == null
? false
: PermissionAuthLogic.IsAuthorized((PermissionSymbol)fi.GetValue(null)));
}
};
}
var piPasswordHash = ReflectionTools.GetPropertyInfo((UserEntity e) => e.PasswordHash);
var pcs = PropertyConverter.GetPropertyConverters(typeof(UserEntity));
pcs.GetOrThrow("passwordHash").CustomWriteJsonProperty = ctx => { };
pcs.Add("newPassword", new PropertyConverter
{
AvoidValidate = true,
CustomWriteJsonProperty = ctx => { },
CustomReadJsonProperty = ctx =>
{
EntityJsonConverter.AssertCanWrite(ctx.ParentPropertyRoute.Add(piPasswordHash));
var password = (string)ctx.JsonReader.Value;
var error = UserEntity.OnValidatePassword(password);
if (error != null)
{
throw new ApplicationException(error);
}
((UserEntity)ctx.Entity).PasswordHash = Security.EncodePassword(password);
}
});
if (TypeAuthLogic.IsStarted)
{
Omnibox.OmniboxServer.IsNavigable += type => TypeAuthLogic.GetAllowed(type).MaxUI() >= TypeAllowedBasic.Read;
}
SchemaMap.GetColorProviders += GetMapColors;
}
public static void Start(HttpConfiguration config)
{
UserAssetServer.Start(config);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
CustomizeChartRequest();
PropertyConverter.GetPropertyConverters(typeof(ChartScriptParameterEmbedded)).Add("enumValues", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var csp = (ChartScriptParameterEmbedded)ctx.Entity;
if (csp.Type == ChartParameterType.Enum)
{
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, csp.GetEnumValues().Select(a => new { name = a.Name, typeFilter = a.TypeFilter }).ToList());
}
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
EntityJsonConverter.AfterDeserilization.Register((ChartRequest cr) =>
{
if (cr.ChartScript != null)
{
cr.ChartScript.SynchronizeColumns(cr);
}
if (cr.QueryName != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(cr.QueryName);
if (cr.Columns != null)
{
foreach (var c in cr.Columns)
{
c.ParseData(cr, qd, SubTokensOptions.CanElement | (c.IsGroupKey == false ? SubTokensOptions.CanAggregate : 0));
}
}
}
});
EntityJsonConverter.AfterDeserilization.Register((UserChartEntity uc) =>
{
if (uc.ChartScript != null)
{
uc.ChartScript.SynchronizeColumns(uc);
}
if (uc.Query != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(uc.Query.ToQueryName());
uc.ParseData(qd);
}
});
UserChartEntity.SetConverters(
query => QueryLogic.ToQueryName(query.Key),
queryName => QueryLogic.GetQueryEntity(queryName));
EntityPackTS.AddExtension += ep =>
{
if (ep.entity.IsNew || !ChartPermission.ViewCharting.IsAuthorized())
{
return;
}
var userCharts = UserChartLogic.GetUserChartsEntity(ep.entity.GetType());
if (userCharts.Any())
{
ep.Extension.Add("userCharts", userCharts);
}
};
}
private static void CustomizeChartRequest()
{
var converters = PropertyConverter.GetPropertyConverters(typeof(ChartRequest));
converters.Remove("queryName");
converters.Add("queryKey", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
((ChartRequest)ctx.Entity).QueryName = QueryLogic.ToQueryName((string)ctx.JsonReader.Value);
},
CustomWriteJsonProperty = ctx =>
{
var cr = (ChartRequest)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(QueryLogic.GetQueryEntity(cr.QueryName).Key);
}
});
converters.Add("filters", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = (List <FilterTS>)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(List <FilterTS>));
var cr = (ChartRequest)ctx.Entity;
var qd = DynamicQueryManager.Current.QueryDescription(cr.QueryName);
cr.Filters = list.Select(l => l.ToFilter(qd, canAggregate: true)).ToList();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (ChartRequest)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, cr.Filters.Select(f => new FilterTS
{
token = f.Token.FullKey(),
operation = f.Operation,
value = f.Value
}).ToList());
}
});
converters.Add("orders", new PropertyConverter()
{
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = (List <OrderTS>)ctx.JsonSerializer.Deserialize(ctx.JsonReader, typeof(List <OrderTS>));
var cr = (ChartRequest)ctx.Entity;
var qd = DynamicQueryManager.Current.QueryDescription(cr.QueryName);
cr.Orders = list.Select(l => l.ToOrder(qd, canAggregate: true)).ToList();
},
CustomWriteJsonProperty = ctx =>
{
var cr = (ChartRequest)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, cr.Orders.Select(f => new OrderTS
{
token = f.Token.FullKey(),
orderType = f.OrderType
}));
}
});
}