/// <summary>
        /// Select the relationship types in the visible grid which are in the ARelationshipTypeList
        /// </summary>
        /// <param name="ARelationshipTypeList">A comma separated list with the relationship types which will be selected</param>
        private void SelectRelationshipTypes(String ARelationshipTypeList)
        {
            if (!((FDirectRelationshipTable == null) && (FReciprocalRelationshipTable == null)))
            {
                DataTable UsedTable;

                if (rbtDirectRelationship.Checked)
                {
                    UsedTable = FDirectRelationshipTable;
                }
                else
                {
                    UsedTable = FReciprocalRelationshipTable;
                }

                ARelationshipTypeList = ARelationshipTypeList + ",";
                ARelationshipTypeList = ARelationshipTypeList.Replace("''", "'");

                foreach (DataRow Row in UsedTable.Rows)
                {
                    String CurrentType = Row[PRelationTable.GetRelationNameDBName()] + ",";

                    Row["Selection"] = ARelationshipTypeList.Contains(CurrentType);
                }
            }
        }
 private void UpdateRelationshipGrid(String AVisibleType)
 {
     if (AVisibleType.Length > 0)
     {
         FReciprocalRelationshipTable.DefaultView.RowFilter = PRelationTable.GetRelationCategoryDBName() + " = '" + AVisibleType + "'";
         FDirectRelationshipTable.DefaultView.RowFilter     = PRelationTable.GetRelationCategoryDBName() + " = '" + AVisibleType + "'";
     }
     else
     {
         FReciprocalRelationshipTable.DefaultView.RowFilter = "";
         FDirectRelationshipTable.DefaultView.RowFilter     = "";
     }
 }
示例#3
0
        /// <summary>
        /// Updates Description (normal and reciprocal) for given relation name in row
        /// </summary>
        public void UpdateRelationDescription(PartnerEditTDSPPartnerRelationshipRow ARow, String ANewRelationName)
        {
            PRelationTable relationTable = (PRelationTable)TDataCache.TMPartner.GetCacheablePartnerTable(TCacheablePartnerTablesEnum.RelationList);
            PRelationRow   relationRow;

            if (ARow != null)
            {
                relationRow = (PRelationRow)relationTable.Rows.Find(ANewRelationName);

                if (relationRow != null)
                {
                    ARow.RelationDescription           = relationRow.RelationDescription;
                    ARow.ReciprocalRelationDescription = relationRow.ReciprocalDescription;
                }
                else
                {
                    ARow.RelationDescription           = "";
                    ARow.ReciprocalRelationDescription = "";
                }
            }
        }
        /// <summary>
        /// Returns the visible and selected Relationship types from the visible relationship type grid
        /// </summary>
        /// <returns></returns>
        private string GetSelectedRelationshipsAsCsv(bool directRelationship = false)
        {
            String RelationshipTypeList = "";

            DataTable UsedTable;

            if ((rbtDirectRelationship.Checked && !CalledFromExtracts) || directRelationship)
            {
                UsedTable = FDirectRelationshipTable;
            }
            else
            {
                UsedTable = FReciprocalRelationshipTable;
            }

            DataRow[] VisibleRows = UsedTable.Select(UsedTable.DefaultView.RowFilter);

            for (int Counter = 0; Counter < VisibleRows.Length; ++Counter)
            {
                if ((bool)VisibleRows[Counter]["Selection"])
                {
                    String CurrentType = VisibleRows[Counter][PRelationTable.GetRelationNameDBName()].ToString();
                    RelationshipTypeList = RelationshipTypeList + CurrentType + ',';
                }
            }

            if (RelationshipTypeList.Length > 0)
            {
                // Remove the last comma
                RelationshipTypeList = RelationshipTypeList.Remove(RelationshipTypeList.Length - 1, 1);
                // Check if we have to use escape sequences for '
                // for example G'PARENT to G''PARENT
                RelationshipTypeList = RelationshipTypeList.Replace("'", "''");
            }

            return(RelationshipTypeList);
        }
        private void InitRelationshipList()
        {
            ArrayList RelationTypes = new ArrayList();

            FDirectRelationshipTable = TDataCache.TMPartner.GetCacheablePartnerTable(TCacheablePartnerTablesEnum.RelationList);
            FDirectRelationshipTable.Columns.Add("Selection", Type.GetType("System.Boolean"));

            for (int Counter = 0; Counter < FDirectRelationshipTable.Rows.Count; ++Counter)
            {
                FDirectRelationshipTable.Rows[Counter]["Selection"] = false;
            }

            FReciprocalRelationshipTable = FDirectRelationshipTable.Copy();

            if (grdDirectRelationship.Columns.Count == 0)
            {
                grdDirectRelationship.AddCheckBoxColumn("", FDirectRelationshipTable.Columns["Selection"], 17, false);
                grdDirectRelationship.AddTextColumn(Catalog.GetString("Relationship"),
                                                    FDirectRelationshipTable.Columns[PRelationTable.GetRelationNameDBName()]);
                grdDirectRelationship.AddTextColumn(Catalog.GetString("Description"),
                                                    FDirectRelationshipTable.Columns[PRelationTable.GetRelationDescriptionDBName()]);

                grdReciprocalRelationship.AddCheckBoxColumn("", FReciprocalRelationshipTable.Columns["Selection"], 17, false);
                grdReciprocalRelationship.AddTextColumn(Catalog.GetString("Relationship"),
                                                        FReciprocalRelationshipTable.Columns[PRelationTable.GetRelationNameDBName()]);
                grdReciprocalRelationship.AddTextColumn(Catalog.GetString("Description"),
                                                        FReciprocalRelationshipTable.Columns[PRelationTable.GetReciprocalDescriptionDBName()]);
            }

            FDirectRelationshipTable.DefaultView.AllowNew    = false;
            FDirectRelationshipTable.DefaultView.AllowEdit   = true;
            FDirectRelationshipTable.DefaultView.AllowDelete = false;

            FReciprocalRelationshipTable.DefaultView.AllowNew    = false;
            FReciprocalRelationshipTable.DefaultView.AllowEdit   = true;
            FReciprocalRelationshipTable.DefaultView.AllowDelete = false;

            grdDirectRelationship.DataSource     = new DevAge.ComponentModel.BoundDataView(FDirectRelationshipTable.DefaultView);
            grdReciprocalRelationship.DataSource = new DevAge.ComponentModel.BoundDataView(FReciprocalRelationshipTable.DefaultView);

            grdDirectRelationship.AutoSizeCells();
            grdReciprocalRelationship.AutoSizeCells();

            RelationTypes.Add("");

            foreach (DataRow Row in FDirectRelationshipTable.Rows)
            {
                if (DBNull.Value.Equals(Row[PRelationTable.GetRelationCategoryDBName()]))
                {
                    continue;
                }

                String RelationType = (String)Row[PRelationTable.GetRelationCategoryDBName()];

                if (!RelationTypes.Contains(RelationType))
                {
                    RelationTypes.Add(RelationType);
                }
            }

            foreach (String RelationType in RelationTypes)
            {
                cmbRelationCategory.Items.Add(RelationType);
            }
        }