private void WriteFields()
{
var properties = this.EntityMeta.EntityProperties;
for (int i = 0, c = properties.Count; i < c; i++)
{
var property = properties[i];
var mp = property.ManagedProperty;
//只为树状实体输出以下两个属性。
if (mp == Entity.TreePIdProperty || mp == Entity.TreeIndexProperty)
{
if (!_entityModel.isTree)
{
continue;
}
}
var serverType = ServerTypeHelper.GetServerType(property.PropertyType);
if (serverType.Name == SupportedServerType.Unknown)
{
continue;
}
var pName = property.Name;
var field = new EntityField
{
name = pName,
type = serverType,
persist = property.Runtime.CanWrite,
};
if (mp != null)
{
//为外键添加一个视图属性
if (mp is IRefProperty)
{
_entityModel.fields.Add(field);
var refMp = mp as IRefProperty;
field = new EntityField
{
name = LabeledRefProperty(pName),
type = ServerTypeHelper.GetServerType(typeof(string)),
persist = false,
};
}
else
{
var v = mp.GetMeta(this.EntityMeta.EntityType).DefaultValue;
field.defaultValue = EntityJsonConverter.ToClientValue(property.PropertyType, v);
}
}
_entityModel.fields.Add(field);
}
}
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);
}
});
private static TreeEntityJson ConvertRecur(Entity entity, EntityViewMeta evm)
{
var jEntity = new TreeEntityJson();
EntityJsonConverter.EntityToJson(evm, entity, jEntity);
foreach (Entity child in entity.TreeChildren)
{
var c = ConvertRecur(child, evm);
jEntity.children.Add(c);
}
return(jEntity);
}
/// <summary>
/// 参数输入
/// </summary>
/// <param name="service"></param>
/// <param name="jsonInput"></param>
/// <param name="properties"></param>
private static void SetInputProperties(IService service, string jsonInput, System.Reflection.PropertyInfo[] properties)
{
var jInput = JObject.Parse(jsonInput);
foreach (var property in properties)
{
if (ServiceHelper.IsInput(property))
{
JToken jToken = null;
if (jInput.TryGetValue(property.Name, out jToken))
{
//如果是一般属性，则直接赋值。
var jValue = jToken as JValue;
if (jValue != null)
{
var value = TypeHelper.CoerceValue(property.PropertyType, jValue.Value);
property.SetValue(service, value, null);
}
else
{
//如果不是一般的属性，则表示这是一个引用属性，
//目前，引用属性只支持实体及实体列表。
var jEntityList = jToken as JObject;
var modelProperty = jEntityList.Property("_model");
if (modelProperty == null)
{
throw new NotSupportedException("目前，服务输入中的引用属性只支持实体及实体列表。");
}
var list = EntityJsonConverter.JsonToEntityList(jEntityList);
//如果有这个属性，表明这只是一个用实体列表包装起来的单个实体。
var isEntity = jEntityList.Property(Consts.isEntityProperty) != null;
if (isEntity)
{
if (list.Count > 0)
{
var entity = list[0];
property.SetValue(service, entity, null);
}
}
else
{
property.SetValue(service, list, null);
}
}
}
}
}
}
private static object ConvertOutputComponent(object value)
{
//服务的输出属性如果类型是一个实体或者实体列表，则需要进行格式转换。
if (value is IDomainComponent)
{
var model = (value as IDomainComponent).GetRepository().EntityType;
//TODO：这里可能存在问题：当一个非默认的视图请求这个服务得到一个默认视图的实体数据时，可能会因为列不一致而出现问题。
var defaultVM = UIModel.Views.CreateBaseView(model);
if (value is EntityList)
{
var listRes = new EntityJsonList {
model = model
};
EntityJsonConverter.EntityToJson(defaultVM, value as EntityList, listRes.entities);
listRes.total = listRes.entities.Count;
value = listRes;
}
else if (value is Entity)
{
var entityJson = new EntityJson();
EntityJsonConverter.EntityToJson(defaultVM, value as Entity, entityJson);
//在纯数据的基础上添加以下两个约定的属性：标记这是一个实体以及它在客户端的类型名称。
entityJson.SetProperty(Consts.isEntityProperty, BooleanBoxes.True);
entityJson.SetProperty(Consts.modelProperty, ClientEntities.GetClientName(model));
value = entityJson;
}
else
{
throw new NotSupportedException("只支持对实体、实体列表进行格式转换。");
}
}
return(value);
}
private JsonModel SaveEntityList(HttpRequest request, EntityMeta meta)
{
var clientResult = new ClientResult();
var entityListJson = request.Form["entityList"];
if (!string.IsNullOrWhiteSpace(entityListJson))
{
var repo = RF.Find(meta.EntityType);
JObject jEntityList = JObject.Parse(entityListJson);
var list = EntityJsonConverter.JsonToEntityList(jEntityList, repo);
if (RafyEnvironment.IsDebuggingEnabled)
{
SaveList(repo, list);
clientResult.Success = true;
}
else
{
try
{
SaveList(repo, list);
clientResult.Success = true;
}
catch (Exception ex)
{
clientResult.Message = ex.Message
.Replace("\"", string.Empty)
.Replace("'", string.Empty)
.Replace(Environment.NewLine, string.Empty);
}
}
}
return(clientResult);
}
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);
}
});
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 SetSetters(ModifiableEntity entity, List <PropertySetter> setters, PropertyRoute route)
{
JsonSerializer serializer = JsonSerializer.Create(SignumServer.JsonSerializerSettings);
foreach (var setter in setters)
{
var pr = route.Add(setter.Property);
EntityJsonConverter.AssertCanWrite(pr, entity);
if (pr.Type.IsMList())
{
var elementPr = pr.Add("Item");
var mlist = pr.GetLambdaExpression <ModifiableEntity, IMListPrivate>(false).Compile()(entity);
switch (setter.Operation)
{
case PropertyOperation.AddElement:
{
var item = (ModifiableEntity)Activator.CreateInstance(elementPr.Type) !;
SetSetters(item, setter.Setters !, elementPr);
((IList)mlist).Add(item);
}
break;
case PropertyOperation.ChangeElements:
{
var predicate = GetPredicate(setter.Predicate !, elementPr, serializer);
var toChange = ((IEnumerable <object>)mlist).Where(predicate.Compile()).ToList();
foreach (var item in toChange)
{
SetSetters((ModifiableEntity)item, setter.Setters !, elementPr);
}
}
break;
case PropertyOperation.RemoveElements:
{
var predicate = GetPredicate(setter.Predicate !, elementPr, serializer);
var toRemove = ((IEnumerable <object>)mlist).Where(predicate.Compile()).ToList();
foreach (var item in toRemove)
{
((IList)mlist).Remove(item);
}
}
break;
default:
break;
}
}
else if (setter.Operation == PropertyOperation.CreateNewEntiy)
{
var subPr = pr.Type.IsEmbeddedEntity() ? pr : PropertyRoute.Root(TypeLogic.GetType(setter.EntityType !));
var item = (ModifiableEntity)Activator.CreateInstance(subPr.Type) !;
SetSetters(item, setter.Setters !, subPr);
SetProperty(entity, pr, route, item);
}
else if (setter.Operation == PropertyOperation.ModifyEntity)
{
var item = GetProperty(entity, pr, route);
if (!(item is ModifiableEntity mod))
{
throw new InvalidOperationException($"Unable to change entity in {pr}: {item}");
}
SetSetters(mod, setter.Setters !, pr);
SetProperty(entity, pr, route, mod);
}
else
{
var value = ConvertObject(setter.Value, pr, serializer);
SetProperty(entity, pr, route, value);
}
}
}
private JsonModel QueryEntityList(HttpRequest request, EntityViewMeta evm)
{
var repo = RF.Find(evm.EntityType);
var pagingInfo = ParsePagingInfo(request, repo);
var entities = QueryEntityListCore(request, repo, pagingInfo);
var list = new EntityJsonList {
model = evm.EntityType
};
if (repo.SupportTree)
{
var roots = entities;
foreach (var rootItem in roots)
{
var i = ConvertRecur(rootItem, evm);
i.expanded = true;
list.entities.Add(i);
}
list.total = (entities as ITreeComponent).CountNodes();
}
else
{
//如果此时，还需要进行统计，表示在数据层查询时，并没有对分页进行处理。这时，只能在内存中对实体进行分页。
if (pagingInfo.IsNeedCount)
{
entities = JumpToPageInMemory(repo, entities, pagingInfo);
}
EntityJsonConverter.EntityToJson(evm, entities, list.entities);
list.total = pagingInfo.TotalCount;
}
return(list);
#region //暂时不用
//var repo = RF.Create(evm.EntityType);
//EntityList entities = QueryEntityListCore(request, repo);
//if (repo.SupportTree)
//{
// entities.EnsureObjectRelations();
// var root = new RootTreeEntityJson();
// var roots = entities.FindRoots();
// foreach (var rootItem in roots)
// {
// var i = ConvertRecur(rootItem, evm);
// root.children.Add(i);
// }
// return root;
//}
//else
//{
// var page = request.GetQueryStringOrDefault("page", 1);
// var limit = request.GetQueryStringOrDefault("limit", 10);
// var pagerInfo = new PagerInfo(page, limit, true);
// entities = JumpToPage(repo, entities, pagerInfo);
// var list = new EntityJsonList
// {
// totalCount = pagerInfo.TotalCount,
// };
// EntityJsonConverter.EntityToJson(evm, entities, list.entities);
// return list;
//}
#endregion
}
