public void SchemaWriter_AddPropertyTypeToContentListType() { IntegrationTest(() => { var ed = new SchemaEditor(); ed.Load(); var lt = ed.CreateContentListType("LT0" + Guid.NewGuid()); // ACTION var pt0 = ed.CreateContentListPropertyType(DataType.String, GetNextMapping(ed, true)); var pt1 = ed.CreateContentListPropertyType(DataType.Int, GetNextMapping(ed, true)); var pt2 = ed.CreateContentListPropertyType(DataType.String, GetNextMapping(ed, true)); var pt3 = ed.CreateContentListPropertyType(DataType.Int, GetNextMapping(ed, true)); ed.AddPropertyTypeToPropertySet(pt0, lt); ed.AddPropertyTypeToPropertySet(pt1, lt); ed.AddPropertyTypeToPropertySet(pt2, lt); ed.AddPropertyTypeToPropertySet(pt3, lt); ed.Register(); // ASSERT var schema = DP.LoadSchemaAsync(CancellationToken.None).GetAwaiter().GetResult(); var ltData = schema.ContentListTypes.First(x => x.Name == lt.Name); AssertSequenceEqual(new[] { pt0.Name, pt1.Name, pt2.Name, pt3.Name }, ltData.Properties); }); }
public void SchEd_WriterCalling_ModifyNodeType_ChangeParent() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); ed1.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 2); ed1.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 3); NodeType nt1 = ed1.CreateNodeType(null, "NT1", "T1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1); NodeType nt2 = ed1.CreateNodeType(null, "NT2", "T2"); SetSchemaItemId(ed1.NodeTypes["NT2"], 2); NodeType nt3 = ed1.CreateNodeType(nt1, "NT3", "T3"); SetSchemaItemId(ed1.NodeTypes["NT3"], 3); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT2"], ed1.NodeTypes["NT2"]); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT3"], ed1.NodeTypes["NT3"]); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); ed2.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 2); ed2.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 3); nt1 = ed2.CreateNodeType(null, "NT1", "T1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1); nt2 = ed2.CreateNodeType(null, "NT2", "T2"); SetSchemaItemId(ed2.NodeTypes["NT2"], 2); nt3 = ed2.CreateNodeType(nt1, "NT3", "T3"); SetSchemaItemId(ed2.NodeTypes["NT3"], 3); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT2"], ed2.NodeTypes["NT2"]); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT3"], ed2.NodeTypes["NT3"]); //-- edit ed2.ModifyNodeType(ed2.NodeTypes["NT3"], ed2.NodeTypes["NT2"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); ModifyNodeType(nodeType=<NT3>, parent=<NT2>, className=<T3>); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>); AddPropertyTypeToPropertySet(propertyType=<PT2>, owner=<NT3>, isDeclared=<True>); Close(); " .Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog, "#1"); Assert.IsNull(nt1.Parent, "#2"); Assert.IsNull(nt2.Parent, "#3"); Assert.IsTrue(nt3.Parent == nt2, "#4"); Assert.IsTrue(nt1.PropertyTypes.Count == 1, "#5"); Assert.IsTrue(nt2.PropertyTypes.Count == 1, "#6"); Assert.IsTrue(nt3.PropertyTypes.Count == 2, "#7"); Assert.IsNotNull(nt1.PropertyTypes["PT1"], "#8"); Assert.IsNotNull(nt2.PropertyTypes["PT2"], "#9"); Assert.IsNotNull(nt3.PropertyTypes["PT3"], "#10"); Assert.IsNull(nt3.PropertyTypes["PT1"], "#11"); Assert.IsNotNull(nt3.PropertyTypes["PT2"], "#12"); }); }
public void SchEd_WriterCalling_RemoveOverriddenPropertyFromNodeType() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1); NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1); NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2); NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3); NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4); NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5); ed1.AddPropertyTypeToPropertySet(pt1, nt4); ed1.AddPropertyTypeToPropertySet(pt1, nt2); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); //-- edit ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT4"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();UpdatePropertyTypeDeclarationState(propType=<PT1>, newSet=<NT4>, isDeclared=<False>);Close();"); }); }
public void SchemaEditor_RemoveAncestorOfOverriddenPropertyFromNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3", "T3"); NodeType nt4 = editor.CreateNodeType(nt3, "NT4", "T4"); NodeType nt5 = editor.CreateNodeType(nt4, "NT5", "T5"); editor.AddPropertyTypeToPropertySet(pt1, nt4); editor.AddPropertyTypeToPropertySet(pt1, nt2); editor.RemovePropertyTypeFromPropertySet(pt1, nt2); Assert.IsNull(nt1.PropertyTypes["PT1"], "#1"); Assert.IsNull(nt2.PropertyTypes["PT1"], "#2"); Assert.IsNull(nt3.PropertyTypes["PT1"], "#3"); Assert.IsNotNull(nt4.PropertyTypes["PT1"], "#4"); Assert.IsNotNull(nt5.PropertyTypes["PT1"], "#5"); Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"], "#6"); Assert.IsNull(nt2.DeclaredPropertyTypes["PT1"], "#7"); Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"], "#8"); Assert.IsNotNull(nt4.DeclaredPropertyTypes["PT1"], "#9"); Assert.IsNull(nt5.DeclaredPropertyTypes["PT1"], "#10"); }
public void SchemaEditor_RemovePropertyType_FromTopReDeclarerType() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2"); NodeType nt3 = editor.CreateNodeType(nt2, "nt3"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt2); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- meg kell jelenjen mindharmon PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; PropertyType pt3 = nt3.PropertyTypes["slot"]; //-- toroljuk a deklaralas eredeti helyerol PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- el kell tunjon mindkettorol pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; pt3 = nt3.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "#1"); Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2"); Assert.IsNotNull(nt3.PropertyTypes["slot"], "#3"); }
public void SchemaEditor_RemovePropertyType_FromTopReDeclarerType() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1", "t1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2", "t2"); NodeType nt3 = editor.CreateNodeType(nt2, "nt3", "t3"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt2); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- propertyType need to appear in all three nodeTypes PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; PropertyType pt3 = nt3.PropertyTypes["slot"]; //-- delete from the original place PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- propertyType need to disappear from all three nodeTypes pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; pt3 = nt3.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "#1"); Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2"); Assert.IsNotNull(nt3.PropertyTypes["slot"], "#3"); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_Text() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Text, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt, nt); string expectedSql = @"-- Reset property value: NT0.PT0:Text DELETE FROM dbo.TextPropertiesNVarchar WHERE TextPropertyNVarcharId IN (SELECT dbo.TextPropertiesNVarchar.TextPropertyNVarcharId FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.TextPropertiesNVarchar ON dbo.Versions.VersionId = dbo.TextPropertiesNVarchar.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNVarchar.PropertyTypeId = 2)) -- Reset property value: NT0.PT0:Text DELETE FROM dbo.TextPropertiesNText WHERE TextPropertyNTextId IN (SELECT dbo.TextPropertiesNText.TextPropertyNTextId FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.TextPropertiesNText ON dbo.Versions.VersionId = dbo.TextPropertiesNText.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNText.PropertyTypeId = 2)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO "; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_String() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt, nt); string expectedSql = @" -- Reset property values UPDATE dbo.FlatProperties SET nvarchar_1 = NULL WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO" ; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_Reference() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Reference, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt, nt); string expectedSql = @" -- Reset property value: NT0.PT0:Reference DELETE FROM dbo.ReferenceProperties WHERE ReferencePropertyId IN (SELECT dbo.ReferenceProperties.ReferencePropertyId FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.ReferenceProperties ON dbo.Versions.VersionId = dbo.ReferenceProperties.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.ReferenceProperties.PropertyTypeId = 2)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO" ; string sql = writer.GetSqlScript(); AssertScriptsAreEqual(expectedSql, sql);; }
public void SchEd_WriterCalling_CreateNodeType() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); //-- edit ed2.CreateNodeType(null, "NT1", "T1"); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); CreateNodeType(parent=<[null]>, name=<NT1>, className=<T1>); AddPropertyTypeToPropertySet(propertyType=<PT1>, owner=<NT1>, isDeclared=<True>); Close(); " .Replace("\r\n", "").Replace("\t", ""); string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == expectedLog); }); }
public void SchemaEditor_RemovePropertyType_FromDeclarerType() { //-- create a deletable and inherit from it SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1", "t1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2", "t2"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- propertyType need to appear on both nodeType PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; //-- delete from the original place PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- propertyType need to disappear from both nodeType pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "Ancestor PropertyType was not deleted"); Assert.IsNull(nt2.PropertyTypes["slot"], "Inherited PropertyType was not deleted"); }
public void SchEd_WriterCalling_CreateContentListType() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreateContentListPropertyType(DataType.String, 0); SetSchemaItemId(ed1.PropertyTypes["#String_0"], 1); //-- create current ed2.CreateContentListPropertyType(DataType.String, 0); SetSchemaItemId(ed2.PropertyTypes["#String_0"], 1); //-- edit ed2.CreateContentListType("LT1"); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["#String_0"], ed2.ContentListTypes["LT1"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); CreateContentListType(name=<LT1>); AddPropertyTypeToPropertySet(propertyType=<#String_0>, owner=<LT1>, isDeclared=<True>); Close(); " .Replace("\r\n", "").Replace("\t", ""); string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == expectedLog); }); }
public void SchEd_WriterCalling_ModifyNodeType() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); ed1.CreateNodeType(null, "NT1", "T1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); ed2.CreateNodeType(null, "NT1", "T1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); //-- edit ed2.ModifyNodeType(ed2.NodeTypes["NT1"], "ClassName2"); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();ModifyNodeType(nodeType=<NT1>, parent=<[null]>, className=<ClassName2>);Close();"); }); }
public void SchemaEditor_RemovePropertyType_FromDeclarerType() { //-- krealunk egy torolhetot es felulirjuk SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- meg kell jelenjen mindketton PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; //-- toroljuk a deklaralas eredeti helyerol PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- el kell tunjon mindkettorol pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "Ancestor PropertyType was not deleted"); Assert.IsNull(nt2.PropertyTypes["slot"], "Inherited PropertyType was not deleted"); }
private FieldSetting CreateNewFieldType(FieldDescriptor fieldInfo, Dictionary <string, List <string> > newBindings, ContentListType listType, SlotTable slotTable, SchemaEditor editor) { List <string> bindList = new List <string>(); foreach (RepositoryDataType slotType in FieldManager.GetDataTypes(fieldInfo.FieldTypeShortName)) { if (slotType == RepositoryDataType.NotDefined) { continue; } int slotNumber = slotTable.ReserveSlot((DataType)slotType); string binding = EncodeBinding(slotType, slotNumber); bindList.Add(binding); PropertyType pt = editor.PropertyTypes[binding]; if (pt == null) { pt = editor.CreateContentListPropertyType((DataType)slotType, slotNumber); } editor.AddPropertyTypeToPropertySet(pt, listType); } newBindings.Add(fieldInfo.FieldName, bindList); return(FieldSetting.Create(fieldInfo, bindList, null)); }
//================================================= Tools ================================================= private string InstallContentType(string contentTypeDefInstall, string contentTypeDefModify) { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); ContentTypeManagerAccessor ctmAcc = new ContentTypeManagerAccessor(ContentTypeManager.Current); ContentType cts = ctmAcc.LoadOrCreateNew(contentTypeDefInstall); if (contentTypeDefModify != null) { cts.Save(false); var parent = ContentType.GetByName(cts.ParentName); ContentTypeManager.Current.AddContentType(cts); } ctmAcc.ApplyChangesInEditor(cts, ed2); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); ed2Acc.RegisterSchema(ed1, wr); if (contentTypeDefModify != null) { //-- Id-k beallitasa es klonozas SchemaEditor ed3 = new SchemaEditor(); SchemaEditorAccessor ed3Acc = new SchemaEditorAccessor(ed3); SchemaItemAccessor schItemAcc; int id = 1; foreach (PropertyType pt in ed2.PropertyTypes) { PropertyType clone = ed3.CreatePropertyType(pt.Name, pt.DataType, pt.Mapping); schItemAcc = new SchemaItemAccessor(pt); schItemAcc.Id = id++; schItemAcc = new SchemaItemAccessor(clone); schItemAcc.Id = pt.Id; } id = 1; foreach (NodeType nt in ed2.NodeTypes) { NodeType clone = ed3.CreateNodeType(nt.Parent, nt.Name, nt.ClassName); foreach (PropertyType pt in nt.PropertyTypes) { ed3.AddPropertyTypeToPropertySet(ed3.PropertyTypes[pt.Name], clone); } schItemAcc = new SchemaItemAccessor(nt); schItemAcc.Id = id++; schItemAcc = new SchemaItemAccessor(clone); schItemAcc.Id = nt.Id; } cts = ctmAcc.LoadOrCreateNew(contentTypeDefModify); ctmAcc.ApplyChangesInEditor(cts, ed3); wr = new TestSchemaWriter(); ed3Acc.RegisterSchema(ed2, wr); } return(wr.Log); }
public void SchemaEditor_AddWrongPropertyToNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0); NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1"); editor.AddPropertyTypeToPropertySet(pt1, nt1); }
public void SchemaEditor_AddWrongPropertyToContentListType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); var lt1 = editor.CreateContentListType("LT1"); editor.AddPropertyTypeToPropertySet(pt1, lt1); }
public void SchemaEditor_RemovePropertyType_NullPropertyType() { //---- Target item cannot be null SchemaEditor editor = new SchemaEditor(); NodeType nt = editor.CreateNodeType(null, "nt", "t"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt); new SchemaEditor().RemovePropertyTypeFromPropertySet(slot, null); }
public void SchemaEditor_AddPropertyToContentListType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0); var lt1 = editor.CreateContentListType("LT1"); editor.AddPropertyTypeToPropertySet(pt1, lt1); Assert.IsNotNull(lt1.PropertyTypes["#String_0"], "#1"); Assert.IsTrue(lt1.Id == 0, "#2"); }
public void SchemaEditor_RemoveNodeType() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3", "T3"); PropertyType slot1 = editor.CreatePropertyType("Slot1", DataType.String); PropertyType slot2 = editor.CreatePropertyType("Slot2", DataType.String); PropertyType slot3 = editor.CreatePropertyType("Slot3", DataType.String); editor.AddPropertyTypeToPropertySet(slot1, nt1); editor.AddPropertyTypeToPropertySet(slot2, nt2); editor.AddPropertyTypeToPropertySet(slot3, nt3); editor.DeleteNodeType(editor.NodeTypes["NT2"]); Assert.IsTrue(editor.NodeTypes.Count == 1, "#1"); }
public void SchEd_WriterCalling_Complex_01() { Test(() => { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType ptX = CreatePropertyType(ed1, "X", DataType.String, 1); PropertyType ptY = CreatePropertyType(ed1, "Y", DataType.String, 2); PropertyType ptZ = CreatePropertyType(ed1, "Z", DataType.String, 3); NodeType ntA = CreateNodeType(ed1, null, "A", null, 1); NodeType ntB = CreateNodeType(ed1, ntA, "B", null, 2); NodeType ntC = CreateNodeType(ed1, ntB, "C", null, 3); ed1.AddPropertyTypeToPropertySet(ptX, ntB); ed1.AddPropertyTypeToPropertySet(ptY, ntC); ed1.AddPropertyTypeToPropertySet(ptX, ntA); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); ptX = ed2.PropertyTypes["X"]; ptY = ed2.PropertyTypes["Y"]; ptZ = ed2.PropertyTypes["Z"]; ntA = ed2.NodeTypes["A"]; ntB = ed2.NodeTypes["B"]; ntC = ed2.NodeTypes["C"]; //-- edit ed2.RemovePropertyTypeFromPropertySet(ptX, ntA); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();RemovePropertyTypeFromPropertySet(propertyType=<X>, owner=<A>);Close();"); }); }
public void SchemaEditor_RemovePropertySlot() { SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0); NodeType nt = editor.CreateNodeType(null, "NodeType1", "class"); editor.AddPropertyTypeToPropertySet(slot, nt); slot = editor.PropertyTypes["slot1"]; editor.DeletePropertyType(slot); }
public void SchemaEditor_ModifyPropertySlot_RemoveProtected() { //-- vedett elem torlese SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0); NodeType nt = editor.CreateNodeType(null, "NodeType1", "class"); editor.AddPropertyTypeToPropertySet(slot, nt); editor.DeletePropertyType(slot); }
public void SchemaEditor_CreateNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1"); editor.AddPropertyTypeToPropertySet(slot, nt1); NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2"); Assert.IsNotNull(nt2.PropertyTypes["slot"]); Assert.IsTrue(nt1.Id == 0, "Id was not 0"); }
public void SchEd_WriterCalling_RemoveAncestorOfOverriddenPropertyFromNodeType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1); NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1); NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2); NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3); NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4); NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5); ed1.AddPropertyTypeToPropertySet(pt1, nt4); ed1.AddPropertyTypeToPropertySet(pt1, nt2); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); //-- edit ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT2"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT2>); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>); Close();" .Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog); }
public void SchemaEditor_RemoveContentListType() { SchemaEditor editor = new SchemaEditor(); var lt1 = editor.CreateContentListType("LT1"); PropertyType slot1 = editor.CreateContentListPropertyType(DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot1, lt1); editor.DeleteContentListType(editor.ContentListTypes["LT1"]); Assert.IsTrue(editor.ContentListTypes.Count == 0); }
public void SchemaEditor_CreatePropertyType_WrongPropertySlotContext() { //-- wrong context (PropertySlot) SchemaEditor editor1 = new SchemaEditor(); SchemaEditor editor2 = new SchemaEditor(); editor1.CreatePropertyType("slot", DataType.String); editor1.CreateNodeType(null, "nt", "t"); editor2.CreatePropertyType("slot", DataType.String); editor2.CreateNodeType(null, "nt", "t"); NodeType owner = editor1.NodeTypes["nt"]; PropertyType slot = editor2.PropertyTypes["slot"]; editor1.AddPropertyTypeToPropertySet(slot, owner); }
public void SchemaEditor_RemovePropertyType_WrongContext() { //-- wrong context SchemaEditor editor = new SchemaEditor(); NodeType nt = editor.CreateNodeType(null, "nt", "t"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt); SchemaEditor editor1 = new SchemaEditor(); nt = editor1.CreateNodeType(null, "nt", "t"); slot = editor1.CreatePropertyType("slot", DataType.String, 0); editor1.AddPropertyTypeToPropertySet(slot, nt); editor.RemovePropertyTypeFromPropertySet(editor1.PropertyTypes["slot"], editor1.NodeTypes["nt"]); }
public void SchemaEditor_AddPropertyToNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1", "T1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2", "T2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3", "T3"); editor.AddPropertyTypeToPropertySet(pt1, nt2); Assert.IsNull(nt1.PropertyTypes["PT1"]); Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"]); Assert.IsTrue(Object.ReferenceEquals(nt2.PropertyTypes["PT1"], pt1)); Assert.IsTrue(Object.ReferenceEquals(nt2.DeclaredPropertyTypes["PT1"], pt1)); Assert.IsTrue(Object.ReferenceEquals(nt3.PropertyTypes["PT1"], pt1)); Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"]); }
public void SchemaEditor_RemoveContentListType() { SchemaEditor editor = new SchemaEditor(); var lt1 = editor.CreateContentListType("LT1"); PropertyType slot1 = editor.CreateContentListPropertyType(DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot1, lt1); editor.DeleteContentListType(editor.ContentListTypes["LT1"]); Assert.IsTrue(editor.ContentListTypes.Count == 0); }
public void SchEd_WriterCalling_DeleteContentListType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreateContentListPropertyType(DataType.String, 0); SetSchemaItemId(ed1.PropertyTypes["#String_0"], 1); ed1.CreateContentListType("LT1"); SetSchemaItemId(ed1.ContentListTypes["LT1"], 1); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["#String_0"], ed1.ContentListTypes["LT1"]); //-- create current ed2.CreateContentListPropertyType(DataType.String, 0); SetSchemaItemId(ed2.PropertyTypes["#String_0"], 1); ed2.CreateContentListType("LT1"); SetSchemaItemId(ed2.ContentListTypes["LT1"], 1); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["#String_0"], ed2.ContentListTypes["LT1"]); //-- edit ed2.DeleteContentListType(ed2.ContentListTypes["LT1"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); DeleteContentListType(contentListType=<LT1>); Close(); ".Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog); }
public void SchemaEditor_RemovePropertyType_FromTopReDeclarerType() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2"); NodeType nt3 = editor.CreateNodeType(nt2, "nt3"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt2); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- meg kell jelenjen mindharmon PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; PropertyType pt3 = nt3.PropertyTypes["slot"]; //-- toroljuk a deklaralas eredeti helyerol PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- el kell tunjon mindkettorol pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; pt3 = nt3.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "#1"); Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2"); Assert.IsNotNull(nt3.PropertyTypes["slot"], "#3"); }
public void SchemaEditor_CreatePropertyType_WrongPropertySlotContext() { //-- hiba: rossz context (PropertySlot) SchemaEditor editor1 = new SchemaEditor(); SchemaEditor editor2 = new SchemaEditor(); editor1.CreatePropertyType("slot", DataType.String); editor1.CreateNodeType(null, "nt"); editor2.CreatePropertyType("slot", DataType.String); editor2.CreateNodeType(null, "nt"); NodeType owner = editor1.NodeTypes["nt"]; PropertyType slot = editor2.PropertyTypes["slot"]; editor1.AddPropertyTypeToPropertySet(slot, owner); }
public void SchEd_WriterCalling_Complex_01() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType ptX = CreatePropertyType(ed1, "X", DataType.String, 1); PropertyType ptY = CreatePropertyType(ed1, "Y", DataType.String, 2); PropertyType ptZ = CreatePropertyType(ed1, "Z", DataType.String, 3); NodeType ntA = CreateNodeType(ed1, null, "A", null, 1); NodeType ntB = CreateNodeType(ed1, ntA, "B", null, 2); NodeType ntC = CreateNodeType(ed1, ntB, "C", null, 3); ed1.AddPropertyTypeToPropertySet(ptX, ntB); ed1.AddPropertyTypeToPropertySet(ptY, ntC); ed1.AddPropertyTypeToPropertySet(ptX, ntA); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); ptX = ed2.PropertyTypes["X"]; ptY = ed2.PropertyTypes["Y"]; ptZ = ed2.PropertyTypes["Z"]; ntA = ed2.NodeTypes["A"]; ntB = ed2.NodeTypes["B"]; ntC = ed2.NodeTypes["C"]; //-- edit ed2.RemovePropertyTypeFromPropertySet(ptX, ntA); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();RemovePropertyTypeFromPropertySet(propertyType=<X>, owner=<A>);Close();"); }
public void SchemaEditor_RemovePropertyType_Inherited() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt1); PropertyType pt2 = nt2.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt2, nt2); Assert.IsNotNull(nt1.PropertyTypes["slot"], "#1"); Assert.IsNotNull(nt2.PropertyTypes["slot"], "#2"); Assert.IsNotNull(nt1.DeclaredPropertyTypes["slot"], "#3"); Assert.IsNull(nt2.DeclaredPropertyTypes["slot"], "#4"); }
public void SchemaEditor_AddWrongPropertyToContentListType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); var lt1 = editor.CreateContentListType("LT1"); editor.AddPropertyTypeToPropertySet(pt1, lt1); }
public void SchemaEditor_RemovePropertyType_WrongContext() { //-- hiba: hibas context SchemaEditor editor = new SchemaEditor(); NodeType nt = editor.CreateNodeType(null, "nt"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt); SchemaEditor editor1 = new SchemaEditor(); nt = editor1.CreateNodeType(null, "nt"); slot = editor1.CreatePropertyType("slot", DataType.String, 0); editor1.AddPropertyTypeToPropertySet(slot, nt); editor.RemovePropertyTypeFromPropertySet(editor1.PropertyTypes["slot"], editor1.NodeTypes["nt"]); }
public void SchEd_WriterCalling_RemoveAncestorOfOverriddenPropertyFromNodeType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1); NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1); NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2); NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3); NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4); NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5); ed1.AddPropertyTypeToPropertySet(pt1, nt4); ed1.AddPropertyTypeToPropertySet(pt1, nt2); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); //-- edit ed2.RemovePropertyTypeFromPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT2"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT2>); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>); Close();".Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog); }
public void SchemaEditor_RemoveAncestorOfOverriddenPropertyFromNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3"); NodeType nt4 = editor.CreateNodeType(nt3, "NT4"); NodeType nt5 = editor.CreateNodeType(nt4, "NT5"); editor.AddPropertyTypeToPropertySet(pt1, nt4); editor.AddPropertyTypeToPropertySet(pt1, nt2); editor.RemovePropertyTypeFromPropertySet(pt1, nt2); Assert.IsNull(nt1.PropertyTypes["PT1"], "#1"); Assert.IsNull(nt2.PropertyTypes["PT1"], "#2"); Assert.IsNull(nt3.PropertyTypes["PT1"], "#3"); Assert.IsNotNull(nt4.PropertyTypes["PT1"], "#4"); Assert.IsNotNull(nt5.PropertyTypes["PT1"], "#5"); Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"], "#6"); Assert.IsNull(nt2.DeclaredPropertyTypes["PT1"], "#7"); Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"], "#8"); Assert.IsNotNull(nt4.DeclaredPropertyTypes["PT1"], "#9"); Assert.IsNull(nt5.DeclaredPropertyTypes["PT1"], "#10"); }
internal static void ApplyChangesInEditor(ContentType contentType, SchemaEditor editor) { //-- Find ContentHandler Type handlerType = TypeHandler.GetType(contentType.HandlerName); if (handlerType == null) throw new RegistrationException(String.Concat( SR.Exceptions.Registration.Msg_ContentHandlerNotFound, ": ", contentType.HandlerName)); //-- parent type NodeType parentNodeType = null; if (contentType.ParentTypeName != null) { parentNodeType = editor.NodeTypes[contentType.ParentTypeName]; if (parentNodeType == null) throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_UnknownParentContentType, contentType.Name); } //-- handler type NodeType nodeType = editor.NodeTypes[contentType.Name]; if (nodeType == null) nodeType = editor.CreateNodeType(parentNodeType, contentType.Name, contentType.HandlerName); if (nodeType.ClassName != contentType.HandlerName) editor.ModifyNodeType(nodeType, contentType.HandlerName); if (nodeType.Parent != parentNodeType) editor.ModifyNodeType(nodeType, parentNodeType); //-- 1: ContentHandler properties NodeTypeRegistration ntReg = ParseAttributes(handlerType); if (ntReg == null) throw new ContentRegistrationException( SR.Exceptions.Registration.Msg_DefinedHandlerIsNotAContentHandler, contentType.Name); //-- 2: Field properties foreach (FieldSetting fieldSetting in contentType.FieldSettings) { Type[][] slots = fieldSetting.HandlerSlots; int fieldSlotCount = slots.GetLength(0); if (fieldSetting.Bindings.Count != fieldSlotCount) throw new ContentRegistrationException(String.Format(CultureInfo.InvariantCulture, SR.Exceptions.Registration.Msg_FieldBindingsCount_1, fieldSlotCount), contentType.Name, fieldSetting.Name); for (int i = 0; i < fieldSetting.Bindings.Count; i++) { string propName = fieldSetting.Bindings[i]; var dataType = fieldSetting.DataTypes[i]; CheckDataType(propName, dataType, contentType.Name, editor); PropertyInfo propInfo = handlerType.GetProperty(propName); if (propInfo != null) { //-- #1: there is a property under the slot: bool ok = false; for (int j = 0; j < slots[i].Length; j++) { //if (slots[i][j] == propInfo.PropertyType) if (slots[i][j].IsAssignableFrom(propInfo.PropertyType)) { PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propName); if (propInfo.DeclaringType != handlerType) { if (propReg == null) { object[] attrs = propInfo.GetCustomAttributes(typeof(RepositoryPropertyAttribute), false); if (attrs.Length > 0) { propReg = new PropertyTypeRegistration(propInfo, (RepositoryPropertyAttribute)attrs[0]); ntReg.PropertyTypeRegistrations.Add(propReg); } } } if (propReg != null && propReg.DataType != fieldSetting.DataTypes[i]) throw new ContentRegistrationException(String.Concat( "The data type of the field in the content type definition does not match the data type of its content handler's property. ", "Please modify the field type in the content type definition. ", "ContentTypeDefinition: '", contentType.Name, "', FieldName: '", fieldSetting.Name, "', DataType of Field's binding: '", fieldSetting.DataTypes[i], "', ContentHandler: '", handlerType.FullName, "', PropertyName: '", propReg.Name, "', DataType of property: '", propReg.DataType, "'")); ok = true; fieldSetting.HandlerSlotIndices[i] = j; fieldSetting.PropertyIsReadOnly = !PropertyHasPublicSetter(propInfo); break; } } if (!ok) { //if (fieldSetting.ShortName != "Reference") // if (fieldSetting.DataTypes[i] != RepositoryDataType.Reference) // throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_PropertyAndFieldAreNotConnectable, // contentType.Name, fieldSetting.Name); //CheckReference(propInfo, slots[i], contentType, fieldSetting); if (fieldSetting.ShortName == "Reference" || fieldSetting.DataTypes[i] == RepositoryDataType.Reference) CheckReference(propInfo, slots[i], contentType, fieldSetting); //else if (fieldSetting.ShortName == "Choice") // CheckChoice(propInfo, slots[i], contentType, fieldSetting); else throw new ContentRegistrationException(SR.Exceptions.Registration.Msg_PropertyAndFieldAreNotConnectable, contentType.Name, fieldSetting.Name); } } else { //-- #2: there is not a property under the slot: PropertyTypeRegistration propReg = new PropertyTypeRegistration(propName, dataType); ntReg.PropertyTypeRegistrations.Add(propReg); } } } //-- Collect deletables. Check equals foreach (PropertyType propType in nodeType.PropertyTypes.ToArray()) { PropertyTypeRegistration propReg = ntReg.PropertyTypeRegistrationByName(propType.Name); if (propReg == null) { editor.RemovePropertyTypeFromPropertySet(propType, nodeType); } } //-- Register foreach (PropertyTypeRegistration ptReg in ntReg.PropertyTypeRegistrations) { PropertyType propType = nodeType.PropertyTypes[ptReg.Name]; if (propType == null) { propType = editor.PropertyTypes[ptReg.Name]; if (propType == null) propType = editor.CreatePropertyType(ptReg.Name, ConvertDataType(ptReg.DataType)); editor.AddPropertyTypeToPropertySet(propType, nodeType); } } }
public void SchemaEditor_RemovePropertyType_FromDeclarerType() { //-- krealunk egy torolhetot es felulirjuk SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "nt1"); NodeType nt2 = editor.CreateNodeType(nt1, "nt2"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt1); //-- meg kell jelenjen mindketton PropertyType pt1 = nt1.PropertyTypes["slot"]; PropertyType pt2 = nt2.PropertyTypes["slot"]; //-- toroljuk a deklaralas eredeti helyerol PropertyType pt = editor.PropertyTypes["slot"]; editor.RemovePropertyTypeFromPropertySet(pt, nt1); //-- el kell tunjon mindkettorol pt1 = nt1.PropertyTypes["slot"]; pt2 = nt2.PropertyTypes["slot"]; Assert.IsNull(nt1.PropertyTypes["slot"], "Ancestor PropertyType was not deleted"); Assert.IsNull(nt2.PropertyTypes["slot"], "Inherited PropertyType was not deleted"); }
public void SchemaEditor_RemovePropertySlot() { SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0); NodeType nt = editor.CreateNodeType(null, "NodeType1", "class"); editor.AddPropertyTypeToPropertySet(slot, nt); slot = editor.PropertyTypes["slot1"]; editor.DeletePropertyType(slot); }
public void SchemaEditor_AddPropertyToContentListType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0); var lt1 = editor.CreateContentListType("LT1"); editor.AddPropertyTypeToPropertySet(pt1, lt1); Assert.IsNotNull(lt1.PropertyTypes["#String_0"], "#1"); Assert.IsTrue(lt1.Id == 0, "#2"); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_More() { //CreateTestNodeForRemovePropertyType(); SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt0 = CreatePropertyType(ed, "PT0", DataType.String, 2); PropertyType pt1 = CreatePropertyType(ed, "PT1", DataType.String, 3); PropertyType pt2 = CreatePropertyType(ed, "PT2", DataType.String, 4); ed.AddPropertyTypeToPropertySet(pt0, nt); ed.AddPropertyTypeToPropertySet(pt1, nt); ed.AddPropertyTypeToPropertySet(pt2, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt0, nt); writer.RemovePropertyTypeFromPropertySet(pt1, nt); writer.RemovePropertyTypeFromPropertySet(pt2, nt); #region Bad script //-- Reset property value: NT0.PT0:String //UPDATE dbo.FlatProperties SET nvarchar_1 = NULL //WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes // INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId // INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId // WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) //-- Remove PropertyType 'PT0' from PropertySet 'NT0' //DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 //GO //-- Reset property value: NT0.PT1:String //UPDATE dbo.FlatProperties SET nvarchar_2 = NULL //WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes // INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId // INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId // WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) //-- Remove PropertyType 'PT1' from PropertySet 'NT0' //DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 3 AND PropertySetId = 1 //GO //-- Reset property value: NT0.PT2:String //UPDATE dbo.FlatProperties SET nvarchar_3 = NULL //WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes // INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId // INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId // WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) //-- Remove PropertyType 'PT2' from PropertySet 'NT0' //DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 4 AND PropertySetId = 1 //GO #endregion string expectedSql = @" -- Reset property values UPDATE dbo.FlatProperties SET nvarchar_1 = NULL, nvarchar_2 = NULL, nvarchar_3 = NULL WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO -- Remove PropertyType 'PT1' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 3 AND PropertySetId = 1 GO -- Remove PropertyType 'PT2' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 4 AND PropertySetId = 1 GO"; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SchEd_WriterCalling_OverridePropertyOnNodeType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original PropertyType pt1 = CreatePropertyType(ed1, "PT1", DataType.String, 1); NodeType nt1 = CreateNodeType(ed1, null, "NT1", "NT1", 1); NodeType nt2 = CreateNodeType(ed1, nt1, "NT2", "NT2", 2); NodeType nt3 = CreateNodeType(ed1, nt2, "NT3", "NT3", 3); NodeType nt4 = CreateNodeType(ed1, nt3, "NT4", "NT4", 4); NodeType nt5 = CreateNodeType(ed1, nt4, "NT5", "NT5", 5); ed1.AddPropertyTypeToPropertySet(pt1, nt2); //-- create current XmlDocument xd = new XmlDocument(); xd.LoadXml(ed1.ToXml()); ed2.Load(xd); //-- edit ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT4"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();UpdatePropertyTypeDeclarationState(propType=<PT1>, newSet=<NT4>, isDeclared=<True>);Close();"); }
public void SchemaEditor_RemoveNodeType() { SchemaEditor editor = new SchemaEditor(); NodeType nt1 = editor.CreateNodeType(null, "NT1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3"); PropertyType slot1 = editor.CreatePropertyType("Slot1", DataType.String); PropertyType slot2 = editor.CreatePropertyType("Slot2", DataType.String); PropertyType slot3 = editor.CreatePropertyType("Slot3", DataType.String); editor.AddPropertyTypeToPropertySet(slot1, nt1); editor.AddPropertyTypeToPropertySet(slot2, nt2); editor.AddPropertyTypeToPropertySet(slot3, nt3); editor.DeleteNodeType(editor.NodeTypes["NT2"]); Assert.IsTrue(editor.NodeTypes.Count == 1, "#1"); }
//TODO: Change structure: not implemented //[TestMethod()] //public void ContentType_FullInstall_InheritedClass_ChangeParent() //{ // Assembly asm = SchemaTestTools.DynamicAssembly; // //-- Step 1: Install content types: TestType1, TestType2 and TestType1/TestType3 // string contentTypeDef1 = @"<?xml version='1.0' encoding='utf-8'?> // <ContentType name='TestType1' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'> // <Fields> // <Field name='TestField' type='ShortText'> // <DisplayName>TestField1</DisplayName> // </Field> // </Fields> // </ContentType>"; // string contentTypeDef2 = @"<?xml version='1.0' encoding='utf-8'?> // <ContentType name='TestType2' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'> // <Fields> // <Field name='TestField' type='ShortText'> // <DisplayName>TestField2</DisplayName> // </Field> // </Fields> // </ContentType>"; // string contentTypeDef3 = @"<?xml version='1.0' encoding='utf-8'?> // <ContentType name='TestType3' parentType='TestType1' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'> // <Fields> // <Field name='TestField' type='ShortText'></Field> // </Fields> // </ContentType>"; // ContentTypeInstaller installer = ContentTypeInstaller.CreateBatchContentTypeInstaller(); // installer.AddContentType(contentTypeDef1); // installer.AddContentType(contentTypeDef2); // installer.AddContentType(contentTypeDef3); // installer.ExecuteBatch(); // //-- Step 2: Reinstall TestType3 under TestType2 // contentTypeDef3 = @"<?xml version='1.0' encoding='utf-8'?> // <ContentType name='TestType3' parentType='TestType2' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'></ContentType>"; // ContentTypeInstaller.InstallContentType(contentTypeDef3); // NodeType nt1 = ActiveSchema.NodeTypes["TestType1"]; // NodeType nt2 = ActiveSchema.NodeTypes["TestType2"]; // NodeType nt3 = ActiveSchema.NodeTypes["TestType3"]; // ContentType ct1 = ContentTypeManager.Current.GetContentTypeByName(nt1.Name); // ContentType ct2 = ContentTypeManager.Current.GetContentTypeByName(nt2.Name); // ContentType ct3 = ContentTypeManager.Current.GetContentTypeByName(nt3.Name); // SNC.Content c3 = SNC.Content.CreateNew("TestType3", this.TestRoot, "ChangeParentTest3"); // Assert.IsTrue(ct3.Path == Path.Combine(ct2.Path, ct3.Name)); // Assert.IsTrue(c3.Fields["TestField"].Title == "TestField2"); //} //================================================= Tools ================================================= private string InstallContentType(string contentTypeDefInstall, string contentTypeDefModify) { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); ContentTypeManagerAccessor ctmAcc = new ContentTypeManagerAccessor(ContentTypeManager.Current); ContentType cts = ctmAcc.LoadOrCreateNew(contentTypeDefInstall); if (contentTypeDefModify != null) { cts.Save(false); var parent = ContentType.GetByName(cts.ParentName); ContentTypeManager.Current.AddContentType(cts); } ctmAcc.ApplyChangesInEditor(cts, ed2); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); ed2Acc.RegisterSchema(ed1, wr); if (contentTypeDefModify != null) { //-- Id-k beallitasa es klonozas SchemaEditor ed3 = new SchemaEditor(); SchemaEditorAccessor ed3Acc = new SchemaEditorAccessor(ed3); SchemaItemAccessor schItemAcc; int id = 1; foreach (PropertyType pt in ed2.PropertyTypes) { PropertyType clone = ed3.CreatePropertyType(pt.Name, pt.DataType, pt.Mapping); schItemAcc = new SchemaItemAccessor(pt); schItemAcc.Id = id++; schItemAcc = new SchemaItemAccessor(clone); schItemAcc.Id = pt.Id; } id = 1; foreach (NodeType nt in ed2.NodeTypes) { NodeType clone = ed3.CreateNodeType(nt.Parent, nt.Name, nt.ClassName); foreach (PropertyType pt in nt.PropertyTypes) ed3.AddPropertyTypeToPropertySet(ed3.PropertyTypes[pt.Name], clone); schItemAcc = new SchemaItemAccessor(nt); schItemAcc.Id = id++; schItemAcc = new SchemaItemAccessor(clone); schItemAcc.Id = nt.Id; } cts = ctmAcc.LoadOrCreateNew(contentTypeDefModify); ctmAcc.ApplyChangesInEditor(cts, ed3); wr = new TestSchemaWriter(); ed3Acc.RegisterSchema(ed2, wr); } return wr.Log; }
public void SchEd_WriterCalling_ReCreateNodeType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); ed1.CreateNodeType(null, "NT1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); ed2.CreateNodeType(null, "NT1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); //-- edit ed2.DeleteNodeType(ed2.NodeTypes["NT1"]); ed2.CreateNodeType(null, "NT1"); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); DeleteNodeType(nodeType=<NT1>); CreateNodeType(parent=<[null]>, name=<NT1>, className=<>); AddPropertyTypeToPropertySet(propertyType=<PT1>, owner=<NT1>, isDeclared=<True>); Close(); ".Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog); }
public void SchemaEditor_AddPropertyToNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreatePropertyType("PT1", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1"); NodeType nt2 = editor.CreateNodeType(nt1, "NT2"); NodeType nt3 = editor.CreateNodeType(nt2, "NT3"); editor.AddPropertyTypeToPropertySet(pt1, nt2); Assert.IsNull(nt1.PropertyTypes["PT1"]); Assert.IsNull(nt1.DeclaredPropertyTypes["PT1"]); Assert.IsTrue(Object.ReferenceEquals(nt2.PropertyTypes["PT1"], pt1)); Assert.IsTrue(Object.ReferenceEquals(nt2.DeclaredPropertyTypes["PT1"], pt1)); Assert.IsTrue(Object.ReferenceEquals(nt3.PropertyTypes["PT1"], pt1)); Assert.IsNull(nt3.DeclaredPropertyTypes["PT1"]); }
public void SchemaEditor_CreateNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot", DataType.String); NodeType nt1 = editor.CreateNodeType(null, "NT1"); editor.AddPropertyTypeToPropertySet(slot, nt1); NodeType nt2 = editor.CreateNodeType(nt1, "NT2"); Assert.IsNotNull(nt2.PropertyTypes["slot"]); Assert.IsTrue(nt1.Id == 0, "Id was not 0"); }
public void SchemaEditor_AddWrongPropertyToNodeType() { SchemaEditor editor = new SchemaEditor(); PropertyType pt1 = editor.CreateContentListPropertyType(DataType.String, 0); NodeType nt1 = editor.CreateNodeType(null, "NT1"); editor.AddPropertyTypeToPropertySet(pt1, nt1); }
public void SchEd_WriterCalling_ModifyNodeType_ChangeParent() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); ed1.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 2); ed1.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 3); NodeType nt1 = ed1.CreateNodeType(null, "NT1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1); NodeType nt2 = ed1.CreateNodeType(null, "NT2"); SetSchemaItemId(ed1.NodeTypes["NT2"], 2); NodeType nt3 = ed1.CreateNodeType(nt1, "NT3"); SetSchemaItemId(ed1.NodeTypes["NT3"], 3); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT2"], ed1.NodeTypes["NT2"]); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT3"], ed1.NodeTypes["NT3"]); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); ed2.CreatePropertyType("PT2", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 2); ed2.CreatePropertyType("PT3", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 3); nt1 = ed2.CreateNodeType(null, "NT1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1); nt2 = ed2.CreateNodeType(null, "NT2"); SetSchemaItemId(ed2.NodeTypes["NT2"], 2); nt3 = ed2.CreateNodeType(nt1, "NT3"); SetSchemaItemId(ed2.NodeTypes["NT3"], 3); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT2"], ed2.NodeTypes["NT2"]); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT3"], ed2.NodeTypes["NT3"]); //-- edit ed2.ModifyNodeType(ed2.NodeTypes["NT3"], ed2.NodeTypes["NT2"]); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string expectedLog = @" Open(); ModifyNodeType(nodeType=<NT3>, parent=<NT2>, className=<>); RemovePropertyTypeFromPropertySet(propertyType=<PT1>, owner=<NT3>); AddPropertyTypeToPropertySet(propertyType=<PT2>, owner=<NT3>, isDeclared=<True>); Close(); ".Replace("\r\n", "").Replace("\t", "").Replace(" ", ""); string log = wr.Log.Replace("\r\n", "").Replace(" ", ""); Assert.IsTrue(log == expectedLog, "#1"); Assert.IsNull(nt1.Parent, "#2"); Assert.IsNull(nt2.Parent, "#3"); Assert.IsTrue(nt3.Parent == nt2, "#4"); Assert.IsTrue(nt1.PropertyTypes.Count == 1, "#5"); Assert.IsTrue(nt2.PropertyTypes.Count == 1, "#6"); Assert.IsTrue(nt3.PropertyTypes.Count == 2, "#7"); Assert.IsNotNull(nt1.PropertyTypes["PT1"], "#8"); Assert.IsNotNull(nt2.PropertyTypes["PT2"], "#9"); Assert.IsNotNull(nt3.PropertyTypes["PT3"], "#10"); Assert.IsNull(nt3.PropertyTypes["PT1"], "#11"); Assert.IsNotNull(nt3.PropertyTypes["PT2"], "#12"); }
public void SchemaEditor_RemovePropertyType_NullPropertyType() { //---- hiba: Target item cannot be null SchemaEditor editor = new SchemaEditor(); NodeType nt = editor.CreateNodeType(null, "nt"); PropertyType slot = editor.CreatePropertyType("slot", DataType.String, 0); editor.AddPropertyTypeToPropertySet(slot, nt); new SchemaEditor().RemovePropertyTypeFromPropertySet(slot, null); }
public void SqlSchemaWriter_UpdatePropertyTypeDeclarationState() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.UpdatePropertyTypeDeclarationState(pt, nt, true); string expectedSql = @" -- Update PropertyType declaration: NT0.PT0. Set IsDeclared = true UPDATE [dbo].[SchemaPropertySetsPropertyTypes] SET [IsDeclared] = 1 WHERE PropertySetId = 1 AND PropertyTypeId = 2 GO"; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SchemaEditor_ModifyPropertySlot_RemoveProtected() { //-- vedett elem torlese SchemaEditor editor = new SchemaEditor(); PropertyType slot = editor.CreatePropertyType("slot1", DataType.String, 0); NodeType nt = editor.CreateNodeType(null, "NodeType1", "class"); editor.AddPropertyTypeToPropertySet(slot, nt); editor.DeletePropertyType(slot); }
private FieldSetting CreateNewFieldType(FieldDescriptor fieldInfo, Dictionary<string, List<string>> newBindings, ContentListType listType, SlotTable slotTable, SchemaEditor editor) { List<string> bindList = new List<string>(); foreach (RepositoryDataType slotType in FieldManager.GetDataTypes(fieldInfo.FieldTypeShortName)) { if (slotType == RepositoryDataType.NotDefined) continue; int slotNumber = slotTable.ReserveSlot((DataType)slotType); string binding = EncodeBinding(slotType, slotNumber); bindList.Add(binding); PropertyType pt = editor.PropertyTypes[binding]; if (pt == null) pt = editor.CreateContentListPropertyType((DataType)slotType, slotNumber); editor.AddPropertyTypeToPropertySet(pt, listType); } newBindings.Add(fieldInfo.FieldName, bindList); return FieldSetting.Create(fieldInfo, bindList); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_String() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.String, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt, nt); string expectedSql = @" -- Reset property values UPDATE dbo.FlatProperties SET nvarchar_1 = NULL WHERE Id IN (SELECT dbo.FlatProperties.Id FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.FlatProperties ON dbo.Versions.VersionId = dbo.FlatProperties.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.FlatProperties.Page = 0)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO"; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SqlSchemaWriter_RemovePropertyTypeFromNodeType_Text() { SchemaEditor ed = new SchemaEditor(); NodeType nt = CreateNodeType(ed, null, "NT0", "NT0Class", 1); PropertyType pt = CreatePropertyType(ed, "PT0", DataType.Text, 2); ed.AddPropertyTypeToPropertySet(pt, nt); var writer = SqlSchemaWriterAccessor.Create(); writer.Open(); writer.RemovePropertyTypeFromPropertySet(pt, nt); string expectedSql = @"-- Reset property value: NT0.PT0:Text DELETE FROM dbo.TextPropertiesNVarchar WHERE TextPropertyNVarcharId IN (SELECT dbo.TextPropertiesNVarchar.TextPropertyNVarcharId FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.TextPropertiesNVarchar ON dbo.Versions.VersionId = dbo.TextPropertiesNVarchar.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNVarchar.PropertyTypeId = 2)) -- Reset property value: NT0.PT0:Text DELETE FROM dbo.TextPropertiesNText WHERE TextPropertyNTextId IN (SELECT dbo.TextPropertiesNText.TextPropertyNTextId FROM dbo.Nodes INNER JOIN dbo.Versions ON dbo.Versions.NodeId = dbo.Nodes.NodeId INNER JOIN dbo.TextPropertiesNText ON dbo.Versions.VersionId = dbo.TextPropertiesNText.VersionId WHERE (dbo.Nodes.NodeTypeId = 1) AND (dbo.TextPropertiesNText.PropertyTypeId = 2)) -- Remove PropertyType 'PT0' from PropertySet 'NT0' DELETE FROM [dbo].[SchemaPropertySetsPropertyTypes] WHERE PropertyTypeId = 2 AND PropertySetId = 1 GO "; string sql = writer.GetSqlScript(); Assert.IsTrue(ScriptsAreEqual(sql, expectedSql)); }
public void SchEd_WriterCalling_ModifyNodeType() { SchemaEditor ed1 = new SchemaEditor(); SchemaEditor ed2 = new SchemaEditor(); SchemaEditorAccessor ed2Acc = new SchemaEditorAccessor(ed2); TestSchemaWriter wr = new TestSchemaWriter(); //-- create original ed1.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed1.PropertyTypes["PT1"], 1); ed1.CreateNodeType(null, "NT1"); SetSchemaItemId(ed1.NodeTypes["NT1"], 1); ed1.AddPropertyTypeToPropertySet(ed1.PropertyTypes["PT1"], ed1.NodeTypes["NT1"]); //-- create current ed2.CreatePropertyType("PT1", DataType.String); SetSchemaItemId(ed2.PropertyTypes["PT1"], 1); ed2.CreateNodeType(null, "NT1"); SetSchemaItemId(ed2.NodeTypes["NT1"], 1); ed2.AddPropertyTypeToPropertySet(ed2.PropertyTypes["PT1"], ed2.NodeTypes["NT1"]); //-- edit ed2.ModifyNodeType(ed2.NodeTypes["NT1"], "ClassName2"); //-- register ed2Acc.RegisterSchema(ed1, wr); //-- test string log = wr.Log.Replace("\r\n", ""); Assert.IsTrue(log == "Open();ModifyNodeType(nodeType=<NT1>, parent=<[null]>, className=<ClassName2>);Close();"); }