private T createController <T>(Type objectType, bool activate, XPObjectSpace XPObjectSpace, HandleInfo handleInfo) where T : ViewController
{
XafTypesInfo.Instance.RegisterEntity(objectType);
var source = new CollectionSource(XPObjectSpace, objectType);
var listEditor = Isolate.Fake.Instance <ListEditor>();
Isolate.WhenCalled(() => listEditor.RequiredProperties).WillReturn(new string[0]);
var listView = new ListView(source, listEditor);
Isolate.WhenCalled(() => listView.ObjectTypeInfo).WillReturn(XafTypesInfo.CastTypeToTypeInfo(objectType));
Isolate.WhenCalled(() => listView.ObjectSpace).WillReturn(XPObjectSpace);
var controller = Isolate.Fake.Instance <T>(Members.CallOriginal, ConstructorWillBe.Called);
Isolate.WhenCalled(() => controller.Application).WillReturn(Isolate.Fake.Instance <XafApplication>());
controller.Active[""] = false;
controller.SetView(listView);
View view = controller.View;
Isolate.WhenCalled(() => view.ObjectSpace).WillReturn(XPObjectSpace);
if (activate)
{
Activate(controller, handleInfo);
}
return(controller);
}
protected virtual object GetObjectCore(IModelDetailView modelView, object objectKey, IObjectSpace objectSpace)
{
Type type = modelView.ModelClass.TypeInfo.Type;
object obj;
if (XafTypesInfo.CastTypeToTypeInfo(type).IsPersistent)
{
if (objectKey != null && !(objectKey is CriteriaOperator))
{
obj = objectSpace.GetObjectByKey(type, objectKey);
}
else
{
obj = objectSpace.FindObject(type, (CriteriaOperator)objectKey) ?? objectSpace.CreateObject(type);
if (!(objectSpace.IsNewObject(obj)))
{
_application.ViewShown += ApplicationOnViewShown;
}
}
}
else
{
obj = (type.GetConstructor(new[] { typeof(Session) }) != null) ? objectSpace.CreateObject(type) : type.CreateInstance();
}
return(obj);
}
private static IMemberInfo GetDefaultMember(Type type)
{
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(type);
var defaultMember = typeInfo.GetDefaultMember();
return(defaultMember);
}
private static IList GetObjects(IObjectSpace objectSpace, Type dashBoardObjectType)
{
var proxyCollection = new ProxyCollection(objectSpace, XafTypesInfo.CastTypeToTypeInfo(dashBoardObjectType), objectSpace.GetObjects(dashBoardObjectType));
proxyCollection.DisplayableMembers = string.Join(";", proxyCollection.DisplayableMembers.Split(';').Where(s => !s.EndsWith("!")));
return(proxyCollection);
}
public override void UpdateDatabaseBeforeUpdateSchema()
{
base.UpdateDatabaseBeforeUpdateSchema();
if (SequenceGenerator.UseGuidKey && XpandModuleBase.SequenceObjectType != null)
{
var classInfo = XafTypesInfo.CastTypeToTypeInfo(XpandModuleBase.SequenceObjectType).QueryXPClassInfo();
var dbTable = GetDbTable(classInfo.TableName);
var typeNamePropertyName = nameof(ISequenceObject.TypeName);
if (dbTable != null && dbTable.PrimaryKey.Columns.Contains(typeNamePropertyName))
{
if (SequenceGeneratorHelper.IsMySql())
{
throw new NotImplementedException("Set SequenceGenerator.UseGuidKey=false or update the set Oid as key property manually");
}
var memberInfo = classInfo.Members.FirstOrDefault(info => info.IsCollection && typeof(ISequenceReleasedObject).IsAssignableFrom(info.CollectionElementType.ClassType));
if (memberInfo != null)
{
var tableName = memberInfo.CollectionElementType.Table.Name;
if (GetDbTable(tableName) != null)
{
ExecuteNonQueryCommand("drop table " + tableName, false);
}
}
ExecuteNonQueryCommand(String.Format(
CultureInfo.InvariantCulture, "alter table {0} drop constraint PK_{0}", classInfo.TableName), false);
}
}
}
public static TypeDecorator GetTypeDecorator(Type decorator, Position position)
{
IEnumerable <TypeDecorator> typeDecorators = GetTypeDecorators(new List <ITypeInfo> {
XafTypesInfo.CastTypeToTypeInfo(decorator)
});
return(typeDecorators.Where(PredicatePosition(position)).FirstOrDefault());
}
void AddMember(XPMemberInfo memberInfo, List <XPMemberInfo> result)
{
var memberClassInfo = XafTypesInfo.CastTypeToTypeInfo(memberInfo.MemberType).QueryXPClassInfo();
if (memberClassInfo != null && !memberClassInfo.IsPersistent)
{
return;
}
result.Add(memberInfo);
}
protected virtual Type[] EditorTypes()
{
var typeInfo = ReflectionHelper.FindTypeDescendants(XafTypesInfo.CastTypeToTypeInfo(typeof(TreeListEditorVisibilityCalculatorHelper))).SingleOrDefault();
if (typeInfo != null)
{
var visibilityCalculatorHelper = (TreeListEditorVisibilityCalculatorHelper)typeInfo.Type.CreateInstance();
return(visibilityCalculatorHelper.TreelistEditorType());
}
return(Type.EmptyTypes);
}
static string GetPropertiesCode(AttributeInfoAttribute attributeInfoAttribute)
{
if (attributeInfoAttribute.Instance == null)
{
return(null);
}
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(attributeInfoAttribute.Instance.GetType());
var memberInfos = typeInfo.Members.Where(info => info.FindAttribute <AttributeInfoAttribute>() != null);
string Func(string current, IMemberInfo memberInfo) => current + (memberInfo.Name + "=" + GetArgumentCodeCore(memberInfo.GetValue(attributeInfoAttribute.Instance)) + ",");
return(memberInfos.Aggregate(null, (Func <string, IMemberInfo, string>)Func)?.TrimEnd(','));
}
private AssociationAttribute assertMemberCreation(object collection, string name, Type type)
{
Assert.IsNotNull(collection);
ITypeInfo typeInfo = XafTypesInfo.CastTypeToTypeInfo(type);
IMemberInfo memberInfo = typeInfo.FindMember(name);
Assert.IsNotNull(memberInfo);
var attribute = memberInfo.FindAttribute <AssociationAttribute>();
Assert.IsNotNull(attribute);
Assert.AreEqual("association", attribute.Name);
return(attribute);
}
static string GetPropertiesCode(AttributeInfoAttribute attributeInfoAttribute)
{
if (attributeInfoAttribute.Instance == null)
{
return(null);
}
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(attributeInfoAttribute.Instance.GetType());
var memberInfos = typeInfo.Members.Where(info => info.FindAttribute <AttributeInfoAttribute>() != null);
Func <string, IMemberInfo, string> func = (current, memberInfo)
=> current + (memberInfo.Name + "=" + GetArgumentCodeCore(memberInfo.MemberType, memberInfo.GetValue(attributeInfoAttribute.Instance)) + ",");
string code = memberInfos.Aggregate(null, func).TrimEnd(',');
return(string.IsNullOrEmpty(code) ? null : string.Format(",{0}", code));
}
void CreateRefElelement(IClassInfoGraphNode classInfoGraphNode, Type objectType, XElement root,
object theObject, XElement propertyElement, ElementSchema elementSchema)
{
var serializedObjectRefElement = new XElement(elementSchema.SerializedObjectRef);
propertyElement.Add(serializedObjectRefElement);
serializedObjectRefElement.Add(new XAttribute(elementSchema.Type, objectType.Name));
serializedObjectRefElement.Add(new XAttribute(elementSchema.Strategy, classInfoGraphNode.SerializationStrategy));
if (theObject != null)
{
var classInfoGraphNodes = _serializeClassInfoGraphNodesCalculator.GetSerializedClassInfoGraphNodes(theObject, objectType.Name).ToArray();
CreateRefKeyElements(XafTypesInfo.CastTypeToTypeInfo(objectType), classInfoGraphNodes, theObject, serializedObjectRefElement, elementSchema);
if (classInfoGraphNode.SerializationStrategy == SerializationStrategy.SerializeAsObject)
{
ExportCore(theObject, classInfoGraphNodes, root, elementSchema);
}
}
}
public void Generate(ISerializationConfiguration serializationConfiguration)
{
var typeToSerialize = serializationConfiguration.TypeToSerialize;
var castTypeToTypeInfo = XafTypesInfo.CastTypeToTypeInfo(typeToSerialize);
var objectSpace = XPObjectSpace.FindObjectSpaceByObject(serializationConfiguration);
_serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
if (_serializationConfigurationGroup == null)
{
throw new NullReferenceException("_serializationConfigurationGroup");
}
foreach (var descendant in ReflectionHelper.FindTypeDescendants(castTypeToTypeInfo))
{
Generate(objectSpace, descendant.Type);
}
foreach (IClassInfoGraphNode classInfoGraphNode in CreateGraph(objectSpace, castTypeToTypeInfo))
{
serializationConfiguration.SerializationGraph.Add(classInfoGraphNode);
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
InitializeSecurity(ObjectSpace);
new DummyDataBuilder((XPObjectSpace)ObjectSpace).CreateObjects();
var workflowServiceUser = ObjectSpace.FindObject(SecuritySystem.UserType, new BinaryOperator("UserName", "WorkflowService"));
if (workflowServiceUser == null)
{
CriteriaOperator criteriaOperator = CriteriaOperator.Parse("Name=?", SecurityStrategy.AdministratorRoleName);
CreateworkflowServiceUser(ObjectSpace.FindObject <Role>(criteriaOperator));
ObjectSpace.CommitChanges();
var updaters = ReflectionHelper.FindTypeDescendants(XafTypesInfo.CastTypeToTypeInfo(typeof(FCUpdater)));
foreach (var findTypeDescendant in updaters)
{
var updater = (FCUpdater)Activator.CreateInstance(findTypeDescendant.Type, ObjectSpace, CurrentDBVersion);
updater.UpdateDatabaseAfterUpdateSchema();
}
}
}
protected virtual ICollection GetPermissionTypeNames()
{
var typeDescendants = ReflectionHelper.FindTypeDescendants(XafTypesInfo.CastTypeToTypeInfo(typeof(XpandPermissionData)));
return(typeDescendants.Select(info => info.FullName).ToList());
}
