public static PBankingDetailsTable GetPartnerBankingDetails(long AFromPartnerKey, long AToPartnerKey)
{
PBankingDetailsTable ReturnTable = new PBankingDetailsTable();
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
PBankingDetailsTable FromBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
PBankingDetailsTable ToBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AToPartnerKey, Transaction);
// clone the data in each table and add them to a new table to combine the data
foreach (DataRow Row in FromBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
foreach (DataRow Row in ToBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
});
return(ReturnTable);
}
/// <summary>
/// Populates the grid for the dialog for selecting which bank account should be the main one.
/// </summary>
public bool InitializeBankAccountGrid(long AFromPartnerKey, long AToPartnerKey)
{
// set text for label
lblInfo.Text = Catalog.GetString("Please choose the Bank Account that should become the Main Account for the merged Partner.");
PBankingDetailsTable BankingDetailsTable = TRemote.MPartner.Partner.WebConnectors.GetPartnerBankingDetails(
AFromPartnerKey, AToPartnerKey);
if ((BankingDetailsTable != null) && (BankingDetailsTable.Rows.Count > 0))
{
clbRecords.Columns.Clear();
clbRecords.AddTextColumn("Account Name", BankingDetailsTable.ColumnAccountName);
clbRecords.AddTextColumn("Account Number", BankingDetailsTable.ColumnBankAccountNumber);
clbRecords.AddTextColumn("IBAN", BankingDetailsTable.ColumnBankingDetailsKey);
DataView MyDataView = BankingDetailsTable.DefaultView;
MyDataView.AllowNew = false;
clbRecords.DataSource = new DevAge.ComponentModel.BoundDataView(MyDataView);
clbRecords.AutoResizeGrid();
return(true);
}
else
{
return(false);
}
}
public static int CanFamilyMergeIntoDifferentClass(long APartnerKey)
{
int ReturnValue = 0;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
PPersonTable PersonTable = PPersonAccess.LoadViaPFamily(APartnerKey, Transaction);
if (PersonTable.Rows.Count > 0)
{
ReturnValue = 1;
}
AGiftDetailTable GiftDetailTable = AGiftDetailAccess.LoadViaPPartnerRecipientKey(APartnerKey, Transaction);
if (GiftDetailTable.Rows.Count > 0)
{
ReturnValue = 2;
}
PBankingDetailsTable BankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction);
if (BankingDetailsTable.Rows.Count > 0)
{
ReturnValue = 3;
}
});
return(ReturnValue);
}
public static PBankingDetailsTable GetBankingDetailsRow(int ABankingDetailsKey)
{
PBankingDetailsTable ReturnRow = null;
TDBTransaction Transaction = new TDBTransaction();
DBAccess.ReadTransaction(
ref Transaction,
delegate
{
ReturnRow = PBankingDetailsAccess.LoadByPrimaryKey(ABankingDetailsKey, Transaction);
});
return(ReturnRow);
}
public static PBankingDetailsTable GetBankingDetailsRow(int ABankingDetailsKey)
{
PBankingDetailsTable ReturnRow = null;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
ReturnRow = PBankingDetailsAccess.LoadByPrimaryKey(ABankingDetailsKey, Transaction);
});
return(ReturnRow);
}
public static PBankingDetailsTable GetPartnerBankingDetails(long AFromPartnerKey, long AToPartnerKey)
{
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
PBankingDetailsTable ReturnTable = new PBankingDetailsTable();
try
{
PBankingDetailsTable FromBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
PBankingDetailsTable ToBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AToPartnerKey, Transaction);
// clone the data in each table and add them to a new table to combine the data
foreach (DataRow Row in FromBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
foreach (DataRow Row in ToBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
}
catch (Exception e)
{
TLogging.Log(e.ToString());
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
TLogging.LogAtLevel(7, "TMergePartnersWebConnector.GetPartnerBankingDetails: rollback own transaction.");
}
return(ReturnTable);
}
public static int CanFamilyMergeIntoDifferentClass(long APartnerKey)
{
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
PPersonTable PersonTable = PPersonAccess.LoadViaPFamily(APartnerKey, Transaction);
if (PersonTable.Rows.Count > 0)
{
return(1);
}
AGiftDetailTable GiftDetailTable = AGiftDetailAccess.LoadViaPPartnerRecipientKey(APartnerKey, Transaction);
if (GiftDetailTable.Rows.Count > 0)
{
return(2);
}
PBankingDetailsTable BankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction);
if (BankingDetailsTable.Rows.Count > 0)
{
return(3);
}
}
catch (Exception e)
{
TLogging.Log(e.ToString());
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
TLogging.LogAtLevel(7, "TMergePartnersWebConnector.CanFamilyMergeIntoDifferentClass: rollback own transaction.");
}
return(0);
}
public static PBankingDetailsTable GetBankingDetailsRow(int ABankingDetailsKey)
{
PBankingDetailsTable ReturnRow = null;
TDBTransaction ReadTransaction;
Boolean NewTransaction;
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
try
{
ReturnRow = PBankingDetailsAccess.LoadByPrimaryKey(ABankingDetailsKey, ReadTransaction);
}
finally
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(7, "TPartnerDataReaderWebConnector.GetBankingDetailsRow: committed own transaction.");
}
}
return(ReturnRow);
}
public void TestDeleteBank()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow BankPartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank record");
// check if Bank partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// set up details (e.g. bank account) for this Bank so deletion is not allowed
PBankingDetailsTable BankingDetailsTable = new PBankingDetailsTable();
PBankingDetailsRow BankingDetailsRow = BankingDetailsTable.NewRowTyped();
BankingDetailsRow.BankKey = BankPartnerRow.PartnerKey;
BankingDetailsRow.BankingType = 0;
BankingDetailsRow.BankingDetailsKey = Convert.ToInt32(TSequenceWebConnector.GetNextSequence(TSequenceNames.seq_bank_details));
BankingDetailsTable.Rows.Add(BankingDetailsRow);
PBankingDetailsAccess.SubmitChanges(BankingDetailsTable, DBAccess.GDBAccessObj.Transaction);
// now deletion must not be possible since a bank account is set up for the bank
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of venue partner
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
PartnerKey = BankPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank partner for deletion");
// check if Venue record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Bank record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeleteBank()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow BankPartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank record");
// check if Bank partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// set up details (e.g. bank account) for this Bank so deletion is not allowed
PBankingDetailsTable BankingDetailsTable = new PBankingDetailsTable();
PBankingDetailsRow BankingDetailsRow = BankingDetailsTable.NewRowTyped();
BankingDetailsRow.BankKey = BankPartnerRow.PartnerKey;
BankingDetailsRow.BankingType = 0;
BankingDetailsRow.BankingDetailsKey = Convert.ToInt32(TSequenceWebConnector.GetNextSequence(TSequenceNames.seq_bank_details));
BankingDetailsTable.Rows.Add(BankingDetailsRow);
PBankingDetailsAccess.SubmitChanges(BankingDetailsTable, DBAccess.GDBAccessObj.Transaction);
// now deletion must not be possible since a bank account is set up for the bank
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of venue partner
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
PartnerKey = BankPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank partner for deletion");
// check if Venue record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Bank record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public static bool DeletePartner(Int64 APartnerKey, out TVerificationResultCollection AVerificationResult)
{
string ShortName;
TPartnerClass PartnerClass;
TStdPartnerStatusCode PartnerStatusCode;
bool ResultValue = false;
AVerificationResult = null;
ResultValue = true;
TDBTransaction Transaction = null;
bool SubmissionOK = false;
DBAccess.GDBAccessObj.GetNewOrExistingAutoTransaction(IsolationLevel.Serializable, TEnforceIsolationLevel.eilMinimum,
ref Transaction, ref SubmissionOK,
delegate
{
ResultValue =
MCommonMain.RetrievePartnerShortName(APartnerKey, out ShortName, out PartnerClass, out PartnerStatusCode, Transaction);
/* s_user - delete not allowed by CanPartnerBeDeleted */
if (ResultValue)
{
ResultValue = DeleteEntries(PRecentPartnersTable.GetTableDBName(),
PRecentPartnersTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerGraphicTable.GetTableDBName(),
PPartnerGraphicTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
/* Delete extract entries before possibly attempting to delete a */
/* location record referenced in the extract. Decrease key count */
/* in m_extract_master. */
if (ResultValue)
{
// first make sure that extract master tables are up to date
// (decrease key count by number of rows to be deleted)
MExtractMasterTable ExtractMasterTable;
MExtractMasterRow ExtractMasterRow;
MExtractTable ExtractTable = MExtractAccess.LoadViaPPartner(APartnerKey, Transaction);
foreach (DataRow Row in ExtractTable.Rows)
{
ExtractMasterTable = MExtractMasterAccess.LoadByPrimaryKey(((MExtractRow)Row).ExtractId, Transaction);
ExtractMasterRow = (MExtractMasterRow)ExtractMasterTable.Rows[0];
ExtractMasterRow.KeyCount = ExtractMasterRow.KeyCount - 1;
MExtractMasterAccess.SubmitChanges(ExtractMasterTable, Transaction);
}
// now delete the actual extract entries
ResultValue = DeleteEntries(MExtractTable.GetTableDBName(),
MExtractTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
// Delete Partner Location. If locations were only used by this partner then also delete location record.
if (ResultValue)
{
PPartnerLocationTable PartnerLocationTable = PPartnerLocationAccess.LoadViaPPartner(APartnerKey, Transaction);
PPartnerLocationTable OtherPartnerLocationTable;
PPartnerLocationRow PartnerLocationRow;
PLocationRow LocationRow;
PLocationTable LocationTableToDelete = new PLocationTable();
foreach (DataRow Row in PartnerLocationTable.Rows)
{
PartnerLocationRow = (PPartnerLocationRow)Row;
OtherPartnerLocationTable = PPartnerLocationAccess.LoadViaPLocation(PartnerLocationRow.SiteKey,
PartnerLocationRow.LocationKey,
Transaction);
// if there is only one partner left using this location (which must be this one) then delete location
if ((OtherPartnerLocationTable.Count == 1)
&& (PartnerLocationRow.LocationKey != 0))
{
LocationRow = LocationTableToDelete.NewRowTyped();
LocationRow.SiteKey = PartnerLocationRow.SiteKey;
LocationRow.LocationKey = PartnerLocationRow.LocationKey;
LocationTableToDelete.Rows.Add(LocationRow);
}
}
// now first delete the partner locations
ResultValue = DeleteEntries(PPartnerLocationTable.GetTableDBName(),
PPartnerLocationTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
// and now locations if they don't refer to any partners any longer
foreach (DataRow RowToDelete in LocationTableToDelete.Rows)
{
LocationRow = (PLocationRow)RowToDelete;
PLocationAccess.DeleteByPrimaryKey(LocationRow.SiteKey, LocationRow.LocationKey, Transaction);
}
}
if (ResultValue)
{
TSearchCriteria[] PartnerAttributeAccessSC = new TSearchCriteria[] {
new TSearchCriteria(PPartnerAttributeTable.GetPartnerKeyDBName(),
APartnerKey)
};
if (PPartnerAttributeAccess.CountUsingTemplate(PartnerAttributeAccessSC, Transaction) > 0)
{
PPartnerAttributeAccess.DeleteUsingTemplate(PartnerAttributeAccessSC, Transaction);
}
}
if (ResultValue)
{
ResultValue = ZeroEntries(PChurchTable.GetTableDBName(),
PChurchTable.GetContactPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(POrganisationTable.GetTableDBName(),
POrganisationTable.GetContactPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PBankTable.GetTableDBName(),
PBankTable.GetContactPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PVenueTable.GetTableDBName(),
PVenueTable.GetContactPartnerKeyDBName(),
APartnerKey, Transaction);
}
// Delete Partner Banking Details.
// If Banking Details were only used by this partner then also delete Banking Details record.
if (ResultValue)
{
PPartnerBankingDetailsTable PartnerBankingDetailsTable =
PPartnerBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction);
PPartnerBankingDetailsTable OtherPartnerBankingDetailsTable;
PPartnerBankingDetailsRow PartnerBankingDetailsRow;
PBankingDetailsRow BankingDetailsRow;
PBankingDetailsTable BankingDetailsTableToDelete = new PBankingDetailsTable();
foreach (DataRow Row in PartnerBankingDetailsTable.Rows)
{
PartnerBankingDetailsRow = (PPartnerBankingDetailsRow)Row;
OtherPartnerBankingDetailsTable = PPartnerBankingDetailsAccess.LoadViaPBankingDetails(
PartnerBankingDetailsRow.BankingDetailsKey,
Transaction);
// if there is only one partner left using this banking details record (which must be this one) then delete banking details
if (OtherPartnerBankingDetailsTable.Count == 1)
{
BankingDetailsRow = BankingDetailsTableToDelete.NewRowTyped();
BankingDetailsRow.BankingDetailsKey = PartnerBankingDetailsRow.BankingDetailsKey;
BankingDetailsTableToDelete.Rows.Add(BankingDetailsRow);
}
}
// now first delete the partner banking details
ResultValue = DeleteEntries(PPartnerBankingDetailsTable.GetTableDBName(),
PPartnerBankingDetailsTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
// and now banking details if they don't refer to any partners any longer
foreach (DataRow RowToDelete in BankingDetailsTableToDelete.Rows)
{
BankingDetailsRow = (PBankingDetailsRow)RowToDelete;
PBankingDetailsAccess.DeleteByPrimaryKey(BankingDetailsRow.BankingDetailsKey, Transaction);
}
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerTypeTable.GetTableDBName(),
PPartnerTypeTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerRelationshipTable.GetTableDBName(),
PPartnerRelationshipTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerRelationshipTable.GetTableDBName(),
PPartnerRelationshipTable.GetRelationKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PCustomisedGreetingTable.GetTableDBName(),
PCustomisedGreetingTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PSubscriptionTable.GetTableDBName(),
PSubscriptionTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
// delete reminders before contacts
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerReminderTable.GetTableDBName(),
PPartnerReminderTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
var partnerContacts = MPartner.Partner.WebConnectors.TContactsWebConnector.GetPartnerContactLogData(APartnerKey).PPartnerContact
.AsEnumerable().Select(r =>
{
var id = r.ItemArray[PPartnerContactTable.ColumnContactLogIdId];
return new { ContactLogId = id, deleteThis = !TContactsWebConnector.IsContactLogAssociatedWithMoreThanOnePartner((long)id) };
});
// Delete contact attributes before deleting contacts
if (ResultValue)
{
String SqlStmt;
foreach (var row in partnerContacts)
{
if (row.deleteThis)
{
try
{
// build sql statement for deletion
SqlStmt = "DELETE FROM " + PPartnerContactAttributeTable.GetTableDBName() +
" WHERE " + PPartnerContactAttributeTable.GetContactIdDBName() +
" IN (SELECT " + PPartnerContactTable.GetContactLogIdDBName() +
" FROM " + PPartnerContactTable.GetTableDBName() +
" WHERE " + PPartnerContactTable.GetPartnerKeyDBName() + " = " + APartnerKey.ToString() +
" AND " + PPartnerContactTable.GetContactLogIdDBName() + " = " + row.ContactLogId + ")";
DBAccess.GDBAccessObj.ExecuteNonQuery(SqlStmt, Transaction);
}
catch (Exception Exc)
{
TLogging.Log(
"An Exception occured during the deletion of " + PPartnerContactAttributeTable.GetTableDBName() +
" while deleting a partner: " + Environment.NewLine + Exc.ToString());
throw;
}
}
}
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerContactTable.GetTableDBName(),
PPartnerContactTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
// Delete any would-be orphaned ContactLog records
if (ResultValue)
{
foreach (var r in partnerContacts.Where(p => p.deleteThis))
{
PContactLogAccess.DeleteByPrimaryKey((long)r.ContactLogId, Transaction);
}
}
if (ResultValue)
{
ResultValue = DeleteEntries(AEmailDestinationTable.GetTableDBName(),
AEmailDestinationTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(AMotivationDetailTable.GetTableDBName(),
AMotivationDetailTable.GetRecipientKeyDBName(),
APartnerKey, Transaction);
}
/* a_recurring_gift - delete not allowed by CanPartnerBeDeleted */
/* a_recurring_gift_detail - delete not allowed by CanPartnerBeDeleted */
/* a_gift - delete not allowed by CanPartnerBeDeleted */
/* a_gift_detail - delete not allowed by CanPartnerBeDeleted */
/* a_ap_supplier - delete not allowed by CanPartnerBeDeleted */
if (ResultValue)
{
ResultValue = ZeroEntries(PmDocumentTable.GetTableDBName(),
PmDocumentTable.GetContactPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PDataLabelValuePartnerTable.GetTableDBName(),
PDataLabelValuePartnerTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PDataLabelValuePartnerTable.GetTableDBName(),
PDataLabelValuePartnerTable.GetValuePartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PDataLabelValueApplicationTable.GetTableDBName(),
PDataLabelValueApplicationTable.GetValuePartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PmJobAssignmentTable.GetTableDBName(),
PmJobAssignmentTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PTaxTable.GetTableDBName(),
PTaxTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerInterestTable.GetTableDBName(),
PPartnerInterestTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerMergeTable.GetTableDBName(),
PPartnerMergeTable.GetMergeFromDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerMergeTable.GetTableDBName(),
PPartnerMergeTable.GetMergeToDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerGiftDestinationTable.GetTableDBName(),
PPartnerGiftDestinationTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerCommentTable.GetTableDBName(),
PPartnerCommentTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PFoundationTable.GetTableDBName(),
PFoundationTable.GetContactPartnerDBName(),
APartnerKey, Transaction);
}
if (ResultValue)
{
ResultValue = ZeroEntries(PFoundationProposalTable.GetTableDBName(),
PFoundationProposalTable.GetPartnerSubmittedByDBName(),
APartnerKey, Transaction);
}
// now delete partner class specific information
if (ResultValue)
{
switch (PartnerClass)
{
case TPartnerClass.FAMILY:
ResultValue = DeleteFamily(APartnerKey, Transaction);
break;
case TPartnerClass.PERSON:
ResultValue = DeletePerson(APartnerKey, Transaction);
break;
case TPartnerClass.UNIT:
ResultValue = DeleteUnit(APartnerKey, Transaction);
break;
case TPartnerClass.ORGANISATION:
ResultValue = DeleteOrganisation(APartnerKey, Transaction);
break;
case TPartnerClass.CHURCH:
ResultValue = DeleteChurch(APartnerKey, Transaction);
break;
case TPartnerClass.BANK:
ResultValue = DeleteBank(APartnerKey, Transaction);
break;
case TPartnerClass.VENUE:
ResultValue = DeleteVenue(APartnerKey, Transaction);
break;
default:
break;
}
}
// finally delete p_partner record itself
if (ResultValue)
{
ResultValue = DeleteEntries(PPartnerTable.GetTableDBName(),
PPartnerTable.GetPartnerKeyDBName(),
APartnerKey, Transaction);
SubmissionOK = true;
}
});
return ResultValue;
}
public static PBankingDetailsTable GetPartnerBankingDetails(long AFromPartnerKey, long AToPartnerKey)
{
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
PBankingDetailsTable ReturnTable = new PBankingDetailsTable();
try
{
PBankingDetailsTable FromBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
PBankingDetailsTable ToBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AToPartnerKey, Transaction);
// clone the data in each table and add them to a new table to combine the data
foreach (DataRow Row in FromBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
foreach (DataRow Row in ToBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
}
catch (Exception e)
{
TLogging.Log(e.ToString());
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
TLogging.LogAtLevel(7, "TMergePartnersWebConnector.GetPartnerBankingDetails: rollback own transaction.");
}
return ReturnTable;
}
/// <summary>
/// Validates the Banking Details screen data.
/// </summary>
/// <param name="AContext">Context that describes where the data validation failed.</param>
/// <param name="ARow">The <see cref="DataRow" /> which holds the the data against which the validation is run.</param>
/// <param name="ABankingDetails">test if there is only one main account</param>
/// <param name="ACountryCode">Country Code for ARow's corresponding Bank's country</param>
/// <param name="AVerificationResultCollection">Will be filled with any <see cref="TVerificationResult" /> items if
/// data validation errors occur.</param>
/// <param name="AValidationControlsDict">A <see cref="TValidationControlsDict" /> containing the Controls that
/// display data that is about to be validated.</param>
public static void ValidateBankingDetails(object AContext, PBankingDetailsRow ARow,
PBankingDetailsTable ABankingDetails, string ACountryCode,
ref TVerificationResultCollection AVerificationResultCollection, TValidationControlsDict AValidationControlsDict)
{
DataColumn ValidationColumn;
TValidationControlsData ValidationControlsData;
TVerificationResult VerificationResult = null;
// Don't validate deleted DataRows
if (ARow.RowState == DataRowState.Deleted)
{
return;
}
// 'BankKey' must be a valid BANK partner
ValidationColumn = ARow.Table.Columns[PBankingDetailsTable.ColumnBankKeyId];
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (ARow.BankKey != 0)
{
VerificationResult = IsValidPartner(
ARow.BankKey, new TPartnerClass[] { TPartnerClass.BANK }, false, string.Empty,
AContext, ValidationColumn, ValidationControlsData.ValidationControl
);
}
// Since the validation can result in different ResultTexts we need to remove any validation result manually as a call to
// AVerificationResultCollection.AddOrRemove wouldn't remove a previous validation result with a different
// ResultText!
AVerificationResultCollection.Remove(ValidationColumn);
AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn);
}
// validate that there are not multiple main accounts
ValidationColumn = ARow.Table.Columns[PartnerEditTDSPBankingDetailsTable.ColumnMainAccountId];
int countMainAccount = 0;
foreach (PartnerEditTDSPBankingDetailsRow bdrow in ABankingDetails.Rows)
{
if (bdrow.RowState != DataRowState.Deleted)
{
if (bdrow.MainAccount)
{
countMainAccount++;
}
}
}
if (countMainAccount > 1)
{
// will we ever get here?
AVerificationResultCollection.Add(
new TScreenVerificationResult(
new TVerificationResult(
AContext,
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_BANKINGDETAILS_ONLYONEMAINACCOUNT)),
((PartnerEditTDSPBankingDetailsTable)ARow.Table).ColumnMainAccount,
ValidationControlsData.ValidationControl
));
}
VerificationResult = null;
// validate the account number (if validation exists for bank's country)
ValidationColumn = ARow.Table.Columns[PBankingDetailsTable.ColumnBankAccountNumberId];
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
CommonRoutines Routines = new CommonRoutines();
if (!string.IsNullOrEmpty(ARow.BankAccountNumber) && (Routines.CheckAccountNumber(ARow.BankAccountNumber, ACountryCode) <= 0))
{
VerificationResult = new TScreenVerificationResult(
new TVerificationResult(
AContext,
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_ACCOUNTNUMBER_INVALID)),
((PartnerEditTDSPBankingDetailsTable)ARow.Table).ColumnBankAccountNumber,
ValidationControlsData.ValidationControl);
}
AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn);
}
VerificationResult = null;
// validate the IBAN (if it exists)
ValidationColumn = ARow.Table.Columns[PBankingDetailsTable.ColumnIbanId];
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
AVerificationResultCollection.Remove(ValidationColumn);
if (!string.IsNullOrEmpty(ARow.Iban) && (CommonRoutines.CheckIBAN(ARow.Iban, out VerificationResult) == false))
{
VerificationResult = new TScreenVerificationResult(
new TVerificationResult(AContext, VerificationResult.ResultText, VerificationResult.ResultCode,
VerificationResult.ResultSeverity),
ValidationColumn, ValidationControlsData.ValidationControl);
}
AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn);
}
}
private static void FindDonorKeysByBankAccount(BankImportTDS AMainDS)
{
if (AMainDS.PBankingDetails.Rows.Count == 0)
{
// First collect all IBANs in this statement
List <string> IBANs = new List <string>();
foreach (BankImportTDSAEpTransactionRow transaction in AMainDS.AEpTransaction.Rows)
{
if (transaction.Iban.Length > 0)
{
IBANs.Add(transaction.Iban);
}
}
// load all banking details by IBAN into AMainDS
if (IBANs.Count > 0)
{
string sql = "SELECT " + PPartnerBankingDetailsTable.GetPartnerKeyDBName() + " as PartnerKey, " +
"bd.* " +
"FROM " + PBankingDetailsTable.GetTableDBName() + " bd, " + PPartnerBankingDetailsTable.GetTableDBName() + " pbd " +
"WHERE pbd." + PPartnerBankingDetailsTable.GetBankingDetailsKeyDBName() + " = bd." + PBankingDetailsTable.GetBankingDetailsKeyDBName() + " " +
"AND " + BankImportTDSPBankingDetailsTable.GetIbanDBName() + " IN (";
List <OdbcParameter> parameters = new List <OdbcParameter>();
foreach (string iban in IBANs)
{
if (parameters.Count > 0)
{
sql += ",";
}
sql += "?";
OdbcParameter p = new OdbcParameter("IBAN" + parameters.Count.ToString(), OdbcType.VarChar);
p.Value = iban;
parameters.Add(p);
}
sql += ")";
TDataBase db = DBAccess.Connect("FindDonorKeysByBankAccount");
TDBTransaction transaction = db.BeginTransaction(IsolationLevel.ReadUncommitted);
db.SelectDT(AMainDS.PBankingDetails, sql, transaction, parameters.ToArray());
transaction.Rollback();
db.CloseDBConnection();
}
}
AMainDS.PBankingDetails.DefaultView.Sort = BankImportTDSPBankingDetailsTable.GetIbanDBName();
foreach (BankImportTDSAEpTransactionRow transaction in AMainDS.AEpTransaction.Rows)
{
// find the donor for this transaction, by his IBAN number
Int64 DonorKey = GetDonorByIBAN(AMainDS, transaction.Iban);
if (transaction.Iban.Length == 0)
{
// useful for NUnit testing for csv import: partnerkey in description
try
{
DonorKey = Convert.ToInt64(transaction.Description);
}
catch (Exception)
{
DonorKey = -1;
}
}
transaction.DonorKey = DonorKey;
}
}
public static PBankingDetailsTable GetDonorBankingDetails(long APartnerKey, int ABankingDetailsKey = 0)
{
#region Validate Arguments
if (APartnerKey < 0)
{
throw new ArgumentException(String.Format(Catalog.GetString("Function:{0} - The Partner Key cannot be negative!"),
Utilities.GetMethodName(true)));
}
#endregion Validate Arguments
PBankingDetailsTable DonorBankingDetails = new PBankingDetailsTable();
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
if (ABankingDetailsKey == 0)
{
PBankingDetailsTable BankingDetailsTable =
PBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction);
// Find partner's 'main' bank account
foreach (PBankingDetailsRow Row in BankingDetailsTable.Rows)
{
if (PBankingDetailsUsageAccess.Exists(APartnerKey, Row.BankingDetailsKey, "MAIN", Transaction))
{
DonorBankingDetails.Rows.Add((object[])Row.ItemArray.Clone());
break;
}
}
}
else
{
DonorBankingDetails = PBankingDetailsAccess.LoadByPrimaryKey(ABankingDetailsKey, Transaction);
}
});
if (DonorBankingDetails != null)
{
DonorBankingDetails.AcceptChanges();
}
return DonorBankingDetails;
}
public static PBankingDetailsTable GetPartnerBankingDetails(long AFromPartnerKey, long AToPartnerKey)
{
PBankingDetailsTable ReturnTable = new PBankingDetailsTable();
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
PBankingDetailsTable FromBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
PBankingDetailsTable ToBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AToPartnerKey, Transaction);
// clone the data in each table and add them to a new table to combine the data
foreach (DataRow Row in FromBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
foreach (DataRow Row in ToBankingDetailsTable.Rows)
{
object[] RowArray = Row.ItemArray;
object[] RowArrayClone = (object[])RowArray.Clone();
DataRow RowClone = ReturnTable.NewRowTyped(false);
RowClone.ItemArray = RowArrayClone;
ReturnTable.Rows.Add(RowClone);
}
});
return ReturnTable;
}
public static PBankingDetailsTable GetDonorBankingDetails(long APartnerKey, int ABankingDetailsKey = 0)
{
PBankingDetailsTable ReturnValue = null;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
if (ABankingDetailsKey == 0)
{
PBankingDetailsTable BankingDetailsTable =
PBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction);
// Find partner's 'main' bank account
foreach (PBankingDetailsRow Row in BankingDetailsTable.Rows)
{
if (PBankingDetailsUsageAccess.Exists(APartnerKey, Row.BankingDetailsKey, "MAIN", Transaction))
{
ReturnValue = new PBankingDetailsTable();
ReturnValue.Rows.Add((object[])Row.ItemArray.Clone());
break;
}
}
}
else
{
ReturnValue = PBankingDetailsAccess.LoadByPrimaryKey(ABankingDetailsKey, Transaction);
}
});
return ReturnValue;
}
