private JObject?GetStructDefaultValue(SimpleMember m)
{
if (m.Type != DataType.Struct)
{
return(null);
}
string structName = m.TypeConstraints;
StructInfo structInfo = structTypes[structName];
JObject obj = new JObject();
foreach (var sm in structInfo.Member)
{
string dv;
if (sm.DefaultValue.HasValue)
{
dv = sm.DefaultValue.Value.JSON;
}
else if (sm.Dimension == Dimension.Optional)
{
dv = "null";
}
else
{
dv = DataValue.FromDataType(sm.Type, 1).JSON;
}
obj[sm.Name] = new JRaw(dv);
}
return(obj);
}
private async Task <List <ObjectMember> > GetObjectMembers(string id, string type)
{
ObjectRef obj = ObjectRef.FromEncodedString(id);
ClassInfo info = objTypes[type];
MemberRef[] members = info.SimpleMember.Select(m => MemberRef.Make(obj, m.Name)).ToArray();
List <MemberValue> memValues = await Connection.GetMemberValues(members);
var values = new List <ObjectMember>();
for (int i = 0; i < info.SimpleMember.Count; ++i)
{
SimpleMember m = info.SimpleMember[i];
if (m.Type == DataType.LocationRef && !hasLocations)
{
continue;
}
MemberValue v = memValues[i];
string defaultValue = "";
if (m.DefaultValue.HasValue && m.Dimension != Dimension.Array)
{
defaultValue = m.DefaultValue.Value.JSON;
}
else if (m.Type == DataType.Struct)
{
defaultValue = StdJson.ObjectToString(GetStructDefaultValue(m) !, indented: true, ignoreShouldSerializeMembers: false);
//Console.WriteLine("=> " + m.Name + ": " + defaultValue);
}
else if (m.Type == DataType.LocationRef && rootLocation.HasValue)
{
defaultValue = DataValue.FromLocationRef(rootLocation.Value).JSON;
}
else
{
defaultValue = DataValue.FromDataType(m.Type, 1).JSON;
}
var member = new ObjectMember()
{
Key = obj.ToEncodedString() + "__" + m.Name,
Name = m.Name,
Type = m.Type.ToString(),
IsScalar = m.Dimension == Dimension.Scalar,
IsOption = m.Dimension == Dimension.Optional,
IsArray = m.Dimension == Dimension.Array,
Category = m.Category,
Browseable = m.Browseable,
Value = new JRaw(v.Value.JSON),
ValueOriginal = new JRaw(v.Value.JSON),
EnumValues = ResolveEnum(m),
StructMembers = ResolveStruct(m),
DefaultValue = defaultValue
};
values.Add(member);
}
return(values);
}
private string[] ResolveEnum(SimpleMember m)
{
if (m.Type != DataType.Enum)
{
return(new string[0]);
}
string enumName = m.TypeConstraints;
EnumInfo enumInfo = enumTypes[enumName];
return(enumInfo.Values.Select(ev => ev.Description).ToArray());
}
/// <summary>
/// </summary>
/// <param name="member"></param>
/// <param name="attributes"></param>
/// <returns></returns>
private bool CheckRole(SimpleMember member, IReadOnlyCollection <AdminAuthAttribute> attributes)
{
var allRoles = attributes.Where(t => !t.Roles.IsNullOrEmpty()).SelectMany(t =>
{
var rolesAry = new[] { t.Roles };
if (t.Roles.Contains(","))
{
rolesAry = t.Roles.Split(",");
}
return(rolesAry);
}).ToList();
return(!allRoles.Any() || allRoles.Any(member.InRole));
}
private bool CheckPermission(SimpleMember member, IEnumerable <AdminAuthAttribute> attributes)
{
var allPermissions = attributes
.Where(t => !t.Permissions.IsNullOrEmpty())
.SelectMany(t =>
{
var permissionNameAry = new[] { t.Permissions };
if (t.Permissions.Contains(","))
{
permissionNameAry = t.Permissions.Split(",");
}
return(permissionNameAry);
}).ToList();
return(allPermissions.All(member.HasPermission));
}
public void TestSimpleMember()
{
var instance = new SimpleMember {
FloatValue = 1.0f
};
var context = BuildContext(instance);
var root = context.Factory.CreateNodeHierarchy(context.RootNode, new GraphNodePath(context.RootNode));
var member = root[nameof(SimpleMember.FloatValue)];
Assert.Equal(0, member.Children.Count);
Assert.Equal(nameof(SimpleMember.FloatValue), member.DisplayName);
Assert.Equal(Index.Empty, member.Index);
Assert.False(member.IsEnumerable);
Assert.False(member.IsReadOnly);
Assert.True(member.IsVisible);
Assert.Equal(nameof(SimpleMember.FloatValue), member.Name);
Assert.Null(member.Order);
Assert.Equal(root, member.Parent);
Assert.Equal(1.0f, member.Value);
}
private StructMember[] ResolveStruct(SimpleMember m)
{
if (m.Type != DataType.Struct)
{
return(new StructMember[0]);
}
string structName = m.TypeConstraints;
StructInfo structInfo = structTypes[structName];
return(structInfo.Member.Select(sm => new StructMember()
{
Name = sm.Name,
Type = sm.Type.ToString(),
IsScalar = sm.Dimension == Dimension.Scalar,
IsOption = sm.Dimension == Dimension.Optional,
IsArray = sm.Dimension == Dimension.Array,
EnumValues = ResolveEnum(sm),
StructMembers = ResolveStruct(sm)
}).ToArray());
}
