private void AddToNewlyCreated(ActiveRecordDescriptor descriptor) { if (!_newlyCreated.Contains(descriptor)) { _newlyCreated.Add(descriptor); } }
public ActiveRecordPropertyRelationDescriptor(String columnName, String columnTypeName, String propertyName, String relationType, ActiveRecordDescriptor targetType) : base(columnName, columnTypeName, propertyName) { _relationType = relationType; _targetType = targetType; }
public void AddPendentDescriptor(object key, ActiveRecordDescriptor descriptor) { if (!_key2Desc.Contains(key)) { _key2Desc[key] = descriptor; } }
public void PostBelongsToBlog() { InitKernel(); IRelationshipInferenceService relService = ObtainService(); TableDefinition blogTable; TableDefinition postTable; BuildBlogPostsStructure(out blogTable, out postTable); BuildContext context = new BuildContext(); ActiveRecordDescriptor arDesc = new ActiveRecordDescriptor(); ActiveRecordPropertyDescriptor[] descs = relService.InferRelations( arDesc, postTable, context ); Assert.IsNotNull(descs); Assert.AreEqual( 1, descs.Length ); ActiveRecordBelongsToDescriptor desc1 = descs[0] as ActiveRecordBelongsToDescriptor; Assert.IsNotNull(desc1); Assert.IsNotNull(desc1.TargetType); Assert.IsNull(desc1.PropertyType); Assert.AreEqual( "Blog", desc1.PropertyName ); Assert.AreEqual( "blog_id", desc1.ColumnName ); ActiveRecordDescriptor targetARDescriptor = context.GetNextPendent(); Assert.AreSame( blogTable, targetARDescriptor.Table ); }
public EditRelationDialog(ActiveRecordDescriptor descriptor, Project project, ActiveRecordPropertyRelationDescriptor prop) : base(descriptor, project) { // This call is required by the Windows Form Designer. InitializeComponent(); AssociationEnum assoc = AssociationEnum.Undefined; if (prop is ActiveRecordHasManyDescriptor) { hasManyButton.Checked = true; assoc = AssociationEnum.HasMany; } else if (prop is ActiveRecordBelongsToDescriptor) { belongsToButton.Checked = true; assoc = AssociationEnum.BelongsTo; } else if (prop is ActiveRecordHasAndBelongsToManyDescriptor) { hasAndBelongsToManyButton.Checked = true; assoc = AssociationEnum.HasAndBelongsToMany; } SelectedTarget = prop.TargetType; SwitchViewTo(assoc); }
public ActiveRecordHasAndBelongsToManyDescriptor(String columnName, String associationtable, String propertyName, ActiveRecordDescriptor targetType, String columnKey) : base(columnName, String.Empty, propertyName, "HasAndBelongsToMany", targetType) { _associationtable = associationtable; _columnKey = columnKey; _propertyType = typeof(IList); }
public RelationshipInfo(AssociationEnum association, ActiveRecordDescriptor descriptor, ActiveRecordDescriptor targetDescriptor) { if (association == AssociationEnum.Undefined) throw new ArgumentException("association"); if (descriptor == null) throw new ArgumentNullException("descriptor"); if (targetDescriptor == null) throw new ArgumentNullException("targetDescriptor"); this.association = association; this.descriptor = descriptor; this.targetDescriptor = targetDescriptor; }
public ActiveRecordDescriptor[] Build(BuildContext context) { while(context.HasPendents) { ActiveRecordDescriptor pendent = context.GetNextPendent(); Build(pendent.Table, context); } ActiveRecordDescriptor[] array = new ActiveRecordDescriptor[context.NewlyCreatedDescriptors.Count]; context.NewlyCreatedDescriptors.CopyTo(array, 0); return array; }
public void RemovePendent(ActiveRecordDescriptor descriptor) { foreach(DictionaryEntry entry in _key2Desc) { if (entry.Value == descriptor) { _key2Desc.Remove(entry.Key); break; } } AddToNewlyCreated(descriptor); }
private void AddProperties(ActiveRecordDescriptor arDescriptor, CodeTypeDeclaration declaration) { foreach(ActiveRecordPropertyDescriptor property in arDescriptor.Properties) { if (!property.Generate) continue; CodeMemberProperty memberProperty = CreatePropertyMember(property, declaration); AddAppropriateAttribute(memberProperty, property); declaration.Members.Add( memberProperty ); } }
public void Run(ActiveRecordDescriptor descriptor) { using(NewSubClassDialog dialog = new NewSubClassDialog()) { if (dialog.ShowDialog(Workspace.ActiveWindow) == DialogResult.OK) { ActiveRecordDescriptorSubClass subclass = new ActiveRecordDescriptorSubClass(descriptor); subclass.Table = descriptor.Table; subclass.DiscriminatorValue = dialog.DiscriminatorValue; subclass.ClassName = dialog.ClassName; Model.CurrentProject.AddActiveRecordDescriptor(subclass); Model.Update(); } } }
public ActiveRecordPropertyRelationDescriptor[] InferRelations(ActiveRecordDescriptor desc, TableDefinition tableDef, BuildContext context) { if (desc == null) throw new ArgumentNullException("desc"); if (tableDef == null) throw new ArgumentNullException("tableDef"); if (context == null) throw new ArgumentNullException("context"); // if (tableDef.RelatedDescriptor != null && tableDef.RelatedDescriptor != desc) { // throw new ArgumentException("Different descriptors"); // } ArrayList list = new ArrayList(); CreateHasManyRelations(desc, tableDef, list, context); CreateBelongsToRelations(desc, tableDef, list, context); return (ActiveRecordPropertyRelationDescriptor[]) list.ToArray( typeof(ActiveRecordPropertyRelationDescriptor) ); }
public ActiveRecordPropertiesDialog(ActiveRecordDescriptor descriptor, Project project) { _project = project; _descriptor = descriptor; if (descriptor is ActiveRecordDescriptorSubClass) { _parent = ((ActiveRecordDescriptorSubClass) descriptor).BaseClass; } InitializeComponent(); Title = descriptor.ClassName + " Properties"; FillClassDetails(descriptor); FillClassProperties(descriptor); FillClassRelationships(descriptor); }
public AddRelationDialog(ActiveRecordDescriptor descriptor, Project project) : this() { _descriptor = descriptor; _project = project; _relationBuilder = (IRelationshipBuilder) ServiceRegistry.Instance[ typeof(IRelationshipBuilder) ]; className.Text = _descriptor.ClassName; targetTableList.ValueMember = "ClassName"; foreach(IActiveRecordDescriptor desc in _project.Descriptors) { if (desc is ActiveRecordBaseDescriptor) continue; if (desc.ClassName == null) continue; targetTableList.Items.Add( desc ); } }
public NewARClassWizard(Model model) : base(model) { // if (shape.ActiveRecordDescriptor == null) // { // throw new ArgumentException("No AR instance in shape"); // } _arDesc = new ActiveRecordDescriptor(); Context["ardesc"] = _arDesc; InitializeComponent(); Title = "New ActiveRecord class"; AddPage(new WelcomePage()); AddPage(new TableSelectionPage()); AddPage(new MappingPage()); AddPage(new RelationsPage()); AddPage(new ClassNamePage()); }
private void CreateBelongsToRelations(ActiveRecordDescriptor desc, TableDefinition tableDef, IList list, BuildContext context) { foreach(ColumnDefinition col in tableDef.Columns) { if (col.RelatedTable != null) { bool pendentNecessary = false; String propertyName = _namingService.CreateClassName(col.RelatedTable.Name); ActiveRecordDescriptor targetType = null; if (col.RelatedTable.RelatedDescriptor == null && col.RelatedTable != tableDef) { col.RelatedTable.RelatedDescriptor = new ActiveRecordDescriptor(col.RelatedTable); pendentNecessary = true; } else if (col.RelatedTable == tableDef) { targetType = desc; } if (targetType == null) { targetType = col.RelatedTable.RelatedDescriptor; } ActiveRecordBelongsToDescriptor belongsTo = new ActiveRecordBelongsToDescriptor(col.Name, propertyName, targetType); list.Add(belongsTo); if (pendentNecessary) { context.AddPendentDescriptor(belongsTo, col.RelatedTable.RelatedDescriptor); } } } }
public void HasMany() { InitKernel(); IRelationshipBuilder relService = ObtainService(); TableDefinition blogTable; TableDefinition postTable; BuildBlogPostsStructure(out blogTable, out postTable); ActiveRecordDescriptor desc = new ActiveRecordDescriptor("Blog"); ActiveRecordDescriptor targetDesc = new ActiveRecordDescriptor("Post"); RelationshipInfo info = new RelationshipInfo( AssociationEnum.HasMany, desc, targetDesc ); info.ChildCol = new ColumnDefinition("blog_id", false, true, true, false, OleDbType.Numeric); ActiveRecordPropertyRelationDescriptor propDesc = relService.Build( info ); Assert.IsNotNull(propDesc); Assert.IsNotNull(propDesc as ActiveRecordHasManyDescriptor); Assert.AreEqual( "Posts", propDesc.PropertyName ); Assert.AreEqual( targetDesc, propDesc.TargetType ); Assert.AreEqual( "blog_id", propDesc.ColumnName ); }
public void CreateJoinedSubClass(ActiveRecordDescriptor descriptor) { createJoinedSub.Run(descriptor); }
public ActiveRecordDescriptorSubClass(ActiveRecordDescriptor baseClass) { _baseClass = baseClass; }
public void HasÁndBelongsToMany() { InitKernel(); IRelationshipBuilder relService = ObtainService(); DatabaseDefinition dbdef = new DatabaseDefinition("alias"); TableDefinition compTable = new TableDefinition("companies", dbdef ); compTable.AddColumn( new ColumnDefinition("id", true, false, true, false, OleDbType.Integer) ); compTable.AddColumn( new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar) ); TableDefinition peopleTable = new TableDefinition("people", dbdef ); peopleTable.AddColumn( new ColumnDefinition("id", true, false, true, false, OleDbType.Integer) ); peopleTable.AddColumn( new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar) ); TableDefinition assocTable = new TableDefinition("companiespeople", dbdef ); assocTable.AddColumn( new ColumnDefinition("comp_id", true, true, true, false, OleDbType.Integer) ); assocTable.AddColumn( new ColumnDefinition("person_id", true, true, false, false, OleDbType.Integer) ); ActiveRecordDescriptor desc = new ActiveRecordDescriptor("Company"); ActiveRecordDescriptor targetDesc = new ActiveRecordDescriptor("Person"); RelationshipInfo info = new RelationshipInfo( AssociationEnum.HasAndBelongsToMany, desc, targetDesc ); info.AssociationTable = assocTable; info.ParentCol = new ColumnDefinition("comp_id", false, true, false, true, OleDbType.Integer); info.ChildCol = new ColumnDefinition("person_id", false, true, false, true, OleDbType.Integer); ActiveRecordPropertyRelationDescriptor propDesc = relService.Build( info ); Assert.IsNotNull(propDesc as ActiveRecordHasAndBelongsToManyDescriptor); Assert.IsNotNull(propDesc); Assert.AreEqual( "People", propDesc.PropertyName ); Assert.AreEqual( targetDesc, propDesc.TargetType ); Assert.AreEqual( "person_id", propDesc.ColumnName ); Assert.AreEqual( "comp_id", (propDesc as ActiveRecordHasAndBelongsToManyDescriptor).ColumnKey); }
private void FillClassProperties(ActiveRecordDescriptor descriptor) { listView1.Items.Clear(); IList added = new ArrayList(); foreach(ActiveRecordPropertyDescriptor prop in descriptor.Properties) { ListViewItem item = listView1.Items.Add(prop.PropertyName); item.Tag = prop; item.Checked = prop.Generate; item.SubItems.Add( prop.PropertyType.ToString() ); item.SubItems.Add( prop.ColumnName ); item.SubItems.Add( prop.ColumnTypeName ); item.SubItems.Add( (prop is ActiveRecordPrimaryKeyDescriptor) ? "Yes" : "" ); added.Add(prop); } if (descriptor is ActiveRecordDescriptorSubClass) { // This code might look strange, but we're // only showing the fields on the parent class that haven't been // marked for generation, so the user might have the // oportunity to add them foreach(ActiveRecordPropertyDescriptor prop in _parent.Properties) { if (prop.Generate || added.Contains(prop)) continue; ListViewItem item = listView1.Items.Add(prop.PropertyName); item.Tag = prop; item.Checked = prop.Generate; item.SubItems.Add( prop.PropertyType.ToString() ); item.SubItems.Add( prop.ColumnName ); item.SubItems.Add( prop.ColumnTypeName ); item.SubItems.Add( (prop is ActiveRecordPrimaryKeyDescriptor) ? "Yes" : "" ); } } }
public ActiveRecordHasManyDescriptor(String columnName, String propertyName, ActiveRecordDescriptor targetType) : base(columnName, String.Empty, propertyName, "HasMany", targetType) { _propertyType = typeof(IList); }
private void FillClassRelationships(ActiveRecordDescriptor descriptor) { listView2.Items.Clear(); IList added = new ArrayList(); foreach(ActiveRecordPropertyRelationDescriptor prop in descriptor.PropertiesRelations) { ListViewItem item = listView2.Items.Add(prop.PropertyName); item.Tag = prop; item.Checked = prop.Generate; if (prop.TargetType == null) { throw new ApplicationException("Information missing"); } item.SubItems.Add( prop.TargetType.ClassName ); item.SubItems.Add( prop.RelationType ); item.SubItems.Add( prop.ColumnName ); added.Add(prop); } if (descriptor is ActiveRecordDescriptorSubClass) { // This code might look strange, but we're // only showing the fields on the parent class that haven't been // marked for generation, so the user might have the // oportunity to add them foreach(ActiveRecordPropertyRelationDescriptor prop in _parent.PropertiesRelations) { if (prop.Generate || added.Contains(prop)) continue; ListViewItem item = listView2.Items.Add(prop.PropertyName); item.Tag = prop; item.Checked = prop.Generate; if (prop.TargetType == null) { throw new ApplicationException("Information missing"); } item.SubItems.Add( prop.TargetType.ClassName ); item.SubItems.Add( prop.RelationType ); item.SubItems.Add( prop.ColumnName ); } } }
private void CreateHasManyRelations(ActiveRecordDescriptor desc, TableDefinition tableDef, IList list, BuildContext context) { foreach(TableDefinition fkTable in tableDef.TablesReferencedByHasRelation) { String propertyName = _namingService.CreateRelationName(fkTable.Name); ActiveRecordDescriptor targetType = null; String colName = null; bool pendentNecessary = false; ColumnDefinition selectedCol = null; foreach(ColumnDefinition col in fkTable.Columns) { if (col.RelatedTable == tableDef) { colName = col.Name; if (col.RelatedTable.RelatedDescriptor == null && col.RelatedTable != fkTable) { col.RelatedTable.RelatedDescriptor = new ActiveRecordDescriptor(fkTable); pendentNecessary = true; } else if (col.RelatedTable == tableDef) { targetType = desc; } if (targetType == null) { targetType = col.RelatedTable.RelatedDescriptor; } selectedCol = col; break; } } // Just to protect ourselves from awkward conditions if (colName == null) continue; ActiveRecordHasManyDescriptor hasMany = new ActiveRecordHasManyDescriptor(colName, propertyName, targetType); if (pendentNecessary) { context.AddPendentDescriptor(hasMany, selectedCol.RelatedTable.RelatedDescriptor); } list.Add(hasMany); } }
public void Run(ActiveRecordDescriptor descriptor) { throw new NotImplementedException(); }
private void FillClassDetails(ActiveRecordDescriptor descriptor) { className.Text = descriptor.ClassName; parentClass.Items.Add( "ActiveRecordBase" ); foreach(TableDefinition table in descriptor.Table.DatabaseDefinition.Tables) { if (table.RelatedDescriptor == null) continue; if (table.RelatedDescriptor.ClassName == null) continue; if (table.RelatedDescriptor == descriptor) continue; parentClass.Items.Add( table.RelatedDescriptor.ClassName ); } parentClass.Enabled = false; groupBox2.Enabled = false; discColumn.ValueMember = "Name"; foreach(ColumnDefinition col in descriptor.Table.Columns) { discColumn.Items.Add( col ); if (col.Name.Equals(descriptor.DiscriminatorField)) { discColumn.SelectedItem = col; } } useDiscriminator.Checked = descriptor.DiscriminatorField != null; if (descriptor.DiscriminatorValue != null) { discValue.Text = descriptor.DiscriminatorValue; } if (descriptor is ActiveRecordDescriptorSubClass || descriptor is ActiveRecordDescriptorJoinedSubClass ) { useDiscriminator.Enabled = false; isJoinedSubClass.Enabled = false; } }
public void SelfReference() { InitKernel(); IRelationshipInferenceService relService = ObtainService(); DatabaseDefinition dbdef = new DatabaseDefinition("alias"); TableDefinition categoryTable = new TableDefinition("categories", dbdef ); categoryTable.AddColumn( new ColumnDefinition("id", true, false, true, false, OleDbType.Integer) ); categoryTable.AddColumn( new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar) ); categoryTable.AddColumn( new ColumnDefinition("parent_id", false, true, false, false, OleDbType.Integer, categoryTable) ); categoryTable.AddManyRelation(categoryTable); BuildContext context = new BuildContext(); ActiveRecordDescriptor arDesc = new ActiveRecordDescriptor(); ActiveRecordPropertyDescriptor[] descs = relService.InferRelations( arDesc, categoryTable, context ); Assert.IsFalse(context.HasPendents); Assert.IsNotNull(descs); Assert.AreEqual( 2, descs.Length ); ActiveRecordHasManyDescriptor desc1 = descs[0] as ActiveRecordHasManyDescriptor; Assert.IsNotNull(desc1); Assert.IsNotNull(desc1.TargetType); Assert.IsNotNull(desc1.PropertyType); Assert.AreEqual( "Categories", desc1.PropertyName ); Assert.AreEqual( "parent_id", desc1.ColumnName ); Assert.AreEqual( typeof(IList), desc1.PropertyType ); ActiveRecordBelongsToDescriptor desc2 = descs[1] as ActiveRecordBelongsToDescriptor; Assert.IsNotNull(desc2); Assert.IsNotNull(desc2.TargetType); Assert.IsNull(desc2.PropertyType); Assert.AreEqual( "Category", desc2.PropertyName ); Assert.AreEqual( "parent_id", desc2.ColumnName ); }
private void AddActiveRecordAttribute(CodeTypeDeclaration declaration, ActiveRecordDescriptor descriptor) { CodeAttributeDeclaration att = new CodeAttributeDeclaration("ActiveRecord"); if (!(descriptor is ActiveRecordDescriptorSubClass)) { att.Arguments.Add( new CodeAttributeArgument( new CodeSnippetExpression(Quote(descriptor.Table.Name)) ) ); if (descriptor.DiscriminatorField != null && descriptor.DiscriminatorField.Length != 0) { att.Arguments.Add( new CodeAttributeArgument( "DiscriminatorColumn", new CodeSnippetExpression(Quote(descriptor.DiscriminatorField)) ) ); } if (descriptor.DiscriminatorType != null && descriptor.DiscriminatorType.Length != 0) { att.Arguments.Add( new CodeAttributeArgument( "DiscriminatorType", new CodeSnippetExpression(Quote(descriptor.DiscriminatorType)) ) ); } } if (descriptor.DiscriminatorValue != null && descriptor.DiscriminatorValue.Length != 0) { att.Arguments.Add( new CodeAttributeArgument( "DiscriminatorValue", new CodeSnippetExpression(Quote(descriptor.DiscriminatorValue)) ) ); } declaration.CustomAttributes.Add( att ); }
public ActiveRecordBelongsToDescriptor(String columnName, String propertyName, ActiveRecordDescriptor targetType) : base(columnName, String.Empty, propertyName, "BelongsTo", targetType) { }
private void AddRelations(ActiveRecordDescriptor descriptor, CodeTypeDeclaration declaration) { foreach(ActiveRecordPropertyRelationDescriptor property in descriptor.PropertiesRelations) { if (!property.Generate) continue; CodeAttributeDeclaration att = null; CodeMemberProperty memberProperty = CreatePropertyMember(property, declaration);; if (property is ActiveRecordBelongsToDescriptor) { att = new CodeAttributeDeclaration("BelongsTo"); att.Arguments.Add( new CodeAttributeArgument(new CodeSnippetExpression(Quote(property.ColumnName)) ) ); } else if (property is ActiveRecordHasAndBelongsToManyDescriptor) { att = new CodeAttributeDeclaration("HasAndBelongsToMany"); ActiveRecordHasAndBelongsToManyDescriptor hasAndBelongsProp = property as ActiveRecordHasAndBelongsToManyDescriptor; att.Arguments.Add( new CodeAttributeArgument(new CodeTypeOfExpression(property.TargetType.ClassName) ) ); // att.Arguments.Add( new CodeAttributeArgument(new CodeSnippetExpression("RelationType.Bag") ) ); // att.Arguments.Add( new CodeAttributeArgument("Key", new CodeSnippetExpression(Quote(property.PropertyName)) ) ); att.Arguments.Add( new CodeAttributeArgument("Table", new CodeSnippetExpression(Quote(property.TargetType.Table.Name)) ) ); att.Arguments.Add( new CodeAttributeArgument("ColumnRef", new CodeSnippetExpression(Quote(property.ColumnName)) ) ); att.Arguments.Add( new CodeAttributeArgument("ColumnKey", new CodeSnippetExpression(Quote(hasAndBelongsProp.ColumnKey)) ) ); } else if (property is ActiveRecordHasManyDescriptor) { att = new CodeAttributeDeclaration("HasMany"); att.Arguments.Add( new CodeAttributeArgument(new CodeTypeOfExpression(property.TargetType.ClassName) ) ); // att.Arguments.Add( new CodeAttributeArgument(new CodeSnippetExpression("RelationType.Bag") ) ); att.Arguments.Add( new CodeAttributeArgument("Table", new CodeSnippetExpression(Quote(property.TargetType.Table.Name)) ) ); att.Arguments.Add( new CodeAttributeArgument("ColumnKey", new CodeSnippetExpression(Quote(property.ColumnName)) ) ); } else if (property is ActiveRecordHasOneDescriptor) { att = new CodeAttributeDeclaration("HasOne"); } if (property.Cascade != null && property.Cascade != String.Empty) { att.Arguments.Add( new CodeAttributeArgument("Cascade", new CodeSnippetExpression(Quote(property.Cascade)) ) ); } if (property.Where != null && property.Where != String.Empty) { att.Arguments.Add( new CodeAttributeArgument("Where", new CodeSnippetExpression(Quote(property.Where)) ) ); } if (property.OrderBy != null && property.OrderBy != String.Empty) { att.Arguments.Add( new CodeAttributeArgument("OrderBy", new CodeSnippetExpression(Quote(property.OrderBy)) ) ); } if (property.OuterJoin != null && !"auto".Equals(property.OuterJoin)) { att.Arguments.Add( new CodeAttributeArgument("OuterJoin", new CodeSnippetExpression(Quote(property.OuterJoin)) ) ); } if (property.Proxy == true) { att.Arguments.Add( new CodeAttributeArgument("Proxy", new CodeSnippetExpression("true") ) ); } if (property.Inverse == true) { att.Arguments.Add( new CodeAttributeArgument("Inverse", new CodeSnippetExpression("true") ) ); } memberProperty.CustomAttributes.Add(att); declaration.Members.Add(memberProperty); } }
public ActiveRecordHasOneDescriptor(String _columnName, String _propertyName, ActiveRecordDescriptor _targetType) : base(_columnName, String.Empty, _propertyName, "HasOne", _targetType) { }
private void AddOperations(ActiveRecordDescriptor descriptor, CodeTypeDeclaration declaration) { CodeMemberMethod deleteAll = new CodeMemberMethod(); deleteAll.Name = "DeleteAll"; deleteAll.Attributes = MemberAttributes.Static|MemberAttributes.Public; deleteAll.Statements.Add( new CodeExpressionStatement( new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("ActiveRecordBase"), "DeleteAll", new CodeTypeOfExpression(descriptor.ClassName) ) )); declaration.Members.Add(deleteAll); CodeMemberMethod findAll = new CodeMemberMethod(); findAll.Name = "FindAll"; findAll.ReturnType = new CodeTypeReference( descriptor.ClassName, 1 ); findAll.Attributes = MemberAttributes.Static|MemberAttributes.Public; findAll.Statements.Add( new CodeMethodReturnStatement( new CodeCastExpression(findAll.ReturnType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("ActiveRecordBase"), "FindAll", new CodeTypeOfExpression(descriptor.ClassName) ) ))); declaration.Members.Add(findAll); CodeMemberMethod find = new CodeMemberMethod(); ActiveRecordPrimaryKeyDescriptor primaryKey = descriptor.PrimaryKeyProperty; if (primaryKey != null) { find.Name = "Find"; find.ReturnType = new CodeTypeReference( descriptor.ClassName ); find.Attributes = MemberAttributes.Static|MemberAttributes.Public; find.Parameters.Add( new CodeParameterDeclarationExpression(primaryKey.PropertyType, primaryKey.PropertyName) ); find.Statements.Add( new CodeMethodReturnStatement( new CodeCastExpression(find.ReturnType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("ActiveRecordBase"), "FindByPrimaryKey", new CodeTypeOfExpression(descriptor.ClassName), new CodeArgumentReferenceExpression(primaryKey.PropertyName) ) ))); declaration.Members.Add(find); } }
protected void SwitchViewTo(AssociationEnum association) { // Nothing's changed? if (_oldDescSelection == SelectedTarget && association == _association) { // Aparently not return; } // Saves _oldDescSelection = SelectedTarget; _association = association; // Disabling associationTable.Enabled = associationTableLabel.Enabled = false; parentCols.Enabled = parentColsLabel.Enabled = false; relatedCols.Enabled = relatedColsLabel.Enabled = false; if (association == AssociationEnum.BelongsTo) { parentCols.Enabled = parentColsLabel.Enabled = true; PopulateColumnsInListBox( parentCols, _descriptor.Table); } else if (association == AssociationEnum.HasAndBelongsToMany) { associationTable.Enabled = associationTableLabel.Enabled = true; parentCols.Enabled = parentColsLabel.Enabled = true; relatedCols.Enabled = relatedColsLabel.Enabled = true; associationTable.SelectedIndex = -1; parentCols.Items.Clear(); relatedCols.Items.Clear(); PopulateTablesInComboBox(associationTable, _descriptor.Table.DatabaseDefinition); } else if (association == AssociationEnum.HasMany) { relatedCols.Enabled = relatedColsLabel.Enabled = true; PopulateColumnsInListBox( relatedCols, SelectedTarget.Table); } }
public ActiveRecordDescriptorJoinedSubClass(ActiveRecordDescriptor baseClass, String keyColumn) { _baseClass = baseClass; _keyColumn = keyColumn; }