private void NewRowManual(ref PartnerEditTDSPBankingDetailsRow ARow)
        {
            ARow.BankingDetailsKey = (FMainDS.PBankingDetails.Rows.Count + 1) * -1;
            ARow.BankingType = MPartnerConstants.BANKINGTYPE_BANKACCOUNT;
            ARow.BankKey = 0;

            // automatically set to main account if it is the only account
            ARow.MainAccount = (grdDetails.Rows.Count == 1);

            PPartnerBankingDetailsRow partnerBankingDetails = FMainDS.PPartnerBankingDetails.NewRowTyped();
            partnerBankingDetails.BankingDetailsKey = ARow.BankingDetailsKey;
            partnerBankingDetails.PartnerKey = FMainDS.PPartner[0].PartnerKey;
            FMainDS.PPartnerBankingDetails.Rows.Add(partnerBankingDetails);

            btnSetMainAccount.Enabled = true;
        }
        private void PostDeleteManual(PartnerEditTDSPBankingDetailsRow ARowToDelete,
            Boolean AAllowDeletion,
            Boolean ADeletionPerformed,
            String ACompletionMessage)
        {
            if (grdDetails.Rows.Count <= 1)
            {
                // disable buttons and make details panel invisible if no record in grid (first row for headings)
                btnSetMainAccount.Enabled = false;
                pnlDetails.Visible = false;
            }

            if (ADeletionPerformed)
            {
                DoRecalculateScreenParts();
            }
        }
        private bool PreDeleteManual(PartnerEditTDSPBankingDetailsRow ARowToDelete, ref String ADeletionQuestion)
        {
            ADeletionQuestion = "";

            // additional message if the bank account to be deleted is shared with one or more other Partners
            if (FAccountSharedWith.Rows.Count > 0)
            {
                if (FAccountSharedWith.Rows.Count == 1)
                {
                    ADeletionQuestion = Catalog.GetString("This bank account is currently shared with the following Partner:\n");
                }
                else if (FAccountSharedWith.Rows.Count > 1)
                {
                    ADeletionQuestion = Catalog.GetString("This bank account is currently shared with the following Partners:\n");
                }

                for (int i = 0; i < FAccountSharedWith.Rows.Count; i++)
                {
                    // do not allow more than 5 partners to be display. Otherwise message box becomes to long.
                    if (i == 5)
                    {
                        int Remaining = FAccountSharedWith.Rows.Count - i;

                        if (Remaining == 1)
                        {
                            ADeletionQuestion += "\n..." + Catalog.GetString("and 1 other Partner.");
                        }
                        else if (Remaining > 1)
                        {
                            ADeletionQuestion += "\n..." + string.Format(Catalog.GetString("and {0} other Partners."), Remaining);
                        }

                        break;
                    }

                    PPartnerRow Row = (PPartnerRow)FAccountSharedWith.Rows[i];
                    ADeletionQuestion += "\n" + Row.PartnerShortName + " [" + Row.PartnerKey + "]";
                }

                if (FAccountSharedWith.Rows.Count == 1)
                {
                    ADeletionQuestion += Catalog.GetString("\n\nThe bank account will not be removed from this other partner.\n\n");
                }
                else if (FAccountSharedWith.Rows.Count > 1)
                {
                    ADeletionQuestion += Catalog.GetString("\n\nThe bank account will not be removed from these other partners.\n\n");
                }
            }

            ADeletionQuestion += Catalog.GetString("Are you sure you want to delete the current row?");
            ADeletionQuestion += String.Format("{0}{0}({1} {2})",
                Environment.NewLine,
                lblAccountName.Text,
                txtAccountName.Text);

            return true;
        }
        private bool DeleteRowManual(PartnerEditTDSPBankingDetailsRow ARowToDelete, ref String ACompletionMessage)
        {
            ACompletionMessage = String.Empty;

            // if there are 2 records in grid but one is deleted... set one remaining record as Main Account
            if (ARowToDelete.MainAccount && (grdDetails.Rows.Count == 3))
            {
                foreach (DataRow Row in FMainDS.PBankingDetails.Rows)
                {
                    PartnerEditTDSPBankingDetailsRow BankingDetailsRow = (PartnerEditTDSPBankingDetailsRow)Row;

                    if ((Row.RowState != DataRowState.Deleted)
                        && (BankingDetailsRow.BankingDetailsKey != ARowToDelete.BankingDetailsKey))
                    {
                        BankingDetailsRow.MainAccount = true;
                        break;
                    }
                }
            }

            FMainDS.PPartnerBankingDetails.DefaultView.Sort = PPartnerBankingDetailsTable.GetBankingDetailsKeyDBName();
            FMainDS.PPartnerBankingDetails.DefaultView.FindRows(ARowToDelete.BankingDetailsKey)[0].Row.Delete();

            // if bank account is a 'Main' account then a record in PBankingDetailsUsage will also need deleted.
            if (FMainDS.PBankingDetailsUsage != null)
            {
                FMainDS.PBankingDetailsUsage.DefaultView.Sort = PBankingDetailsUsageTable.GetBankingDetailsKeyDBName();
                DataRowView[] RowsToDelete = FMainDS.PBankingDetailsUsage.DefaultView.FindRows(ARowToDelete.BankingDetailsKey);

                foreach (DataRowView Row in RowsToDelete)
                {
                    Row.Delete();
                }
            }

            // only delete PBankingDetailsRow if it is not shared with any other Partners
            if (FAccountSharedWith.Rows.Count == 0)
            {
                ARowToDelete.Delete();
            }
            else
            {
                FMainDS.PBankingDetails.Rows.Remove(ARowToDelete);
            }

            return true;
        }
Example #5
0
        public void TestBankingDetails()
        {
            TDataBase               db          = DBAccess.Connect("TestBankingDetails");
            TDBTransaction          Transaction = db.BeginTransaction(IsolationLevel.Serializable);
            TPartnerEditUIConnector connector   = new TPartnerEditUIConnector(db);

            PartnerEditTDS MainDS = new PartnerEditTDS();

            PPartnerRow PartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS, db);

            TCreateTestPartnerData.CreateNewLocation(PartnerRow.PartnerKey, MainDS);

            DataSet ResponseDS = new PartnerEditTDS();
            TVerificationResultCollection VerificationResult;

            TSubmitChangesResult result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);

            CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
                                                                                "There was a critical error when saving:");

            Assert.AreEqual(TSubmitChangesResult.scrOK, result, "TPartnerEditUIConnector SubmitChanges return value");

            Transaction.Commit();
            Transaction = db.BeginTransaction(IsolationLevel.Serializable);

            connector = new TPartnerEditUIConnector(PartnerRow.PartnerKey, db);

            // add a banking detail
            PartnerEditTDSPBankingDetailsRow bankingDetailsRow = MainDS.PBankingDetails.NewRowTyped(true);

            bankingDetailsRow.AccountName       = "account of " + PartnerRow.PartnerShortName;
            bankingDetailsRow.BankAccountNumber = new Random().Next().ToString();
            bankingDetailsRow.BankingDetailsKey = (MainDS.PBankingDetails.Count + 1) * -1;
            bankingDetailsRow.BankKey           = 43005004;
            bankingDetailsRow.MainAccount       = true;
            bankingDetailsRow.BankingType       = MPartnerConstants.BANKINGTYPE_BANKACCOUNT;
            MainDS.PBankingDetails.Rows.Add(bankingDetailsRow);

            PPartnerBankingDetailsRow partnerBankingDetails = MainDS.PPartnerBankingDetails.NewRowTyped(true);

            partnerBankingDetails.PartnerKey        = PartnerRow.PartnerKey;
            partnerBankingDetails.BankingDetailsKey = bankingDetailsRow.BankingDetailsKey;
            MainDS.PPartnerBankingDetails.Rows.Add(partnerBankingDetails);

            result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);

            CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
                                                                                "There was a critical error when saving 2:");

            foreach (DataTable t in MainDS.Tables)
            {
                if ((t == MainDS.PBankingDetails) ||
                    (t == MainDS.PPartnerBankingDetails) ||
                    (t == MainDS.PDataLabelValuePartner))
                {
                    int NumRows = t.Rows.Count;

                    for (int RowIndex = NumRows - 1; RowIndex >= 0; RowIndex -= 1)
                    {
                        DataRow InspectDR = t.Rows[RowIndex];

                        // delete all added Rows.
                        if (InspectDR.RowState == DataRowState.Added)
                        {
                            InspectDR.Delete();
                        }
                    }
                }
            }

            MainDS.AcceptChanges();

            Transaction.Commit();
            Transaction = db.BeginTransaction(IsolationLevel.Serializable);

            Assert.AreEqual(1, PBankingDetailsUsageAccess.CountViaPPartner(PartnerRow.PartnerKey, Transaction), "count of main accounts for partner");

            // add another account
            bankingDetailsRow                   = MainDS.PBankingDetails.NewRowTyped(true);
            bankingDetailsRow.AccountName       = "2nd account of " + PartnerRow.PartnerShortName;
            bankingDetailsRow.BankAccountNumber = new Random().Next().ToString();
            bankingDetailsRow.BankingDetailsKey = (MainDS.PBankingDetails.Count + 1) * -1;
            bankingDetailsRow.BankKey           = 43005004;
            bankingDetailsRow.MainAccount       = false;
            bankingDetailsRow.BankingType       = MPartnerConstants.BANKINGTYPE_BANKACCOUNT;
            MainDS.PBankingDetails.Rows.Add(bankingDetailsRow);

            partnerBankingDetails                   = MainDS.PPartnerBankingDetails.NewRowTyped(true);
            partnerBankingDetails.PartnerKey        = PartnerRow.PartnerKey;
            partnerBankingDetails.BankingDetailsKey = bankingDetailsRow.BankingDetailsKey;
            MainDS.PPartnerBankingDetails.Rows.Add(partnerBankingDetails);

            PartnerEditTDS ChangedDS = MainDS.GetChangesTyped(true);

            result = connector.SubmitChanges(ref ChangedDS, ref ResponseDS, out VerificationResult);
            MainDS.Merge(ChangedDS);

            foreach (DataTable t in MainDS.Tables)
            {
                if ((t == MainDS.PBankingDetails) ||
                    (t == MainDS.PPartnerBankingDetails) ||
                    (t == MainDS.PDataLabelValuePartner))
                {
                    int NumRows = t.Rows.Count;

                    for (int RowIndex = NumRows - 1; RowIndex >= 0; RowIndex -= 1)
                    {
                        DataRow InspectDR = t.Rows[RowIndex];

                        // delete all added Rows.
                        if (InspectDR.RowState == DataRowState.Added)
                        {
                            InspectDR.Delete();
                        }
                    }
                }
            }

            MainDS.AcceptChanges();

            CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
                                                                                "There was a critical error when saving 3:");

            // now delete the main bank account
            PartnerEditTDSPBankingDetailsRow toDelete = null;

            foreach (PartnerEditTDSPBankingDetailsRow row in MainDS.PBankingDetails.Rows)
            {
                if (row.MainAccount)
                {
                    toDelete = row;
                    break;
                }
            }

            Assert.IsNotNull(toDelete, "cannot find main account");
            Assert.AreEqual(true, toDelete.MainAccount, "should be the main account");
            MainDS.PPartnerBankingDetails.Rows.Find(new object[] { PartnerRow.PartnerKey, toDelete.BankingDetailsKey }).Delete();
            toDelete.Delete();

            ChangedDS = MainDS.GetChangesTyped(true);
            result    = connector.SubmitChanges(ref ChangedDS, ref ResponseDS, out VerificationResult);

            Assert.AreEqual(1, VerificationResult.Count, "should fail because we have no main account anymore");
            Assert.AreEqual(
                "One Bank Account of a Partner must be set as the 'Main Account'. Please select the record that should become the 'Main Account' and choose 'Set Main Account'.",
                VerificationResult[0].ResultText,
                "should fail because we have no main account anymore");

            PartnerEditTDSPBankingDetailsRow otherAccount = null;

            foreach (PartnerEditTDSPBankingDetailsRow row in MainDS.PBankingDetails.Rows)
            {
                if ((row.RowState != DataRowState.Deleted) && !row.MainAccount)
                {
                    otherAccount = row;
                    break;
                }
            }

            otherAccount.MainAccount = true;

            ChangedDS = MainDS.GetChangesTyped(true);
            result    = connector.SubmitChanges(ref ChangedDS, ref ResponseDS, out VerificationResult);

            MainDS.Merge(ChangedDS);
            MainDS.AcceptChanges();

            CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
                                                                                "There was a critical error when saving 4:");

            Transaction.Commit();
            Transaction = db.BeginTransaction(IsolationLevel.Serializable);

            // now delete the last remaining bank account
            toDelete = MainDS.PBankingDetails[0];
            Assert.AreEqual(true, toDelete.MainAccount);
            MainDS.PPartnerBankingDetails.Rows.Find(new object[] { PartnerRow.PartnerKey, toDelete.BankingDetailsKey }).Delete();
            toDelete.Delete();
            ChangedDS = MainDS.GetChangesTyped(true);
            result    = connector.SubmitChanges(ref ChangedDS, ref ResponseDS, out VerificationResult);
            MainDS.Merge(ChangedDS);
            MainDS.AcceptChanges();

            CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
                                                                                "There was a critical error when saving 5:");

            Transaction.Commit();
        }