private static void ProcessDeletion(Form AMainWindow, Int32 ALedgerNumber, string ALedgerNameAndNumber)
{
TVerificationResultCollection VerificationResult;
MethodInfo method;
if (!TRemote.MFinance.Setup.WebConnectors.DeleteLedger(ALedgerNumber, out VerificationResult))
{
if (TVerificationHelper.ResultsContainErrorCode(VerificationResult, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else
{
MessageBox.Show(
string.Format(Catalog.GetString("Deletion of Ledger '{0}' failed"), ALedgerNameAndNumber) + "\r\n\r\n" +
VerificationResult.BuildVerificationResultString(),
Catalog.GetString("Deletion failed"),
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(
string.Format(Catalog.GetString("Ledger '{0}' has been deleted"), ALedgerNameAndNumber),
Catalog.GetString("Deletion successful"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
method = AMainWindow.GetType().GetMethod("ShowCurrentLedgerInfoInStatusBar");
if (method != null)
{
method.Invoke(AMainWindow, new object[] { });
}
}
/// <summary>
/// this supports the batch export files from Petra 2.x.
/// Each line starts with a type specifier, B for batch, J for journal, T for transaction
/// The code handles importing from file or clipboard
/// </summary>
public void ImportBatches(TImportDataSourceEnum AImportDataSource)
{
bool ok = false;
bool RefreshGUIAfterImport = false;
OpenFileDialog dialog = null;
if (FPetraUtilsObject.HasChanges)
{
// saving failed, therefore do not try to import
MessageBox.Show(Catalog.GetString("Please save before calling this function!"), Catalog.GetString(
"Failure"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
try
{
FMyForm.FCurrentGLBatchAction = TGLBatchEnums.GLBatchAction.IMPORTING;
bool datesMayBeIntegers = TUserDefaults.GetBooleanDefault(MCommonConstants.USERDEFAULT_IMPORTEDDATESMAYBEINTEGERS, false);
FdlgSeparator = new TDlgSelectCSVSeparator(false);
FdlgSeparator.DateMayBeInteger = datesMayBeIntegers;
if (AImportDataSource == TImportDataSourceEnum.FromClipboard)
{
string importString = Clipboard.GetText(TextDataFormat.UnicodeText);
if ((importString == null) || (importString.Length == 0))
{
MessageBox.Show(Catalog.GetString("Please first copy data from your spreadsheet application!"),
Catalog.GetString("Failure"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
FdlgSeparator.CSVData = importString;
}
else if (AImportDataSource == TImportDataSourceEnum.FromFile)
{
dialog = new OpenFileDialog();
string exportPath = TClientSettings.GetExportPath();
string fullPath = TUserDefaults.GetStringDefault("Imp Filename",
exportPath + Path.DirectorySeparatorChar + "import.csv");
TImportExportDialogs.SetOpenFileDialogFilePathAndName(dialog, fullPath, exportPath);
dialog.Title = Catalog.GetString("Import Batches from CSV File");
dialog.Filter = Catalog.GetString("GL Batch Files (*.csv)|*.csv|Text Files (*.txt)|*.txt");
// This call fixes Windows7 Open File Dialogs. It must be the line before ShowDialog()
TWin7FileOpenSaveDialog.PrepareDialog(Path.GetFileName(fullPath));
if (dialog.ShowDialog() == DialogResult.OK)
{
Boolean fileCanOpen = FdlgSeparator.OpenCsvFile(dialog.FileName);
if (!fileCanOpen)
{
MessageBox.Show(Catalog.GetString("Unable to open file."),
Catalog.GetString("Batch Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Stop);
return;
}
}
else
{
return;
}
}
else
{
// unknown source!!
return;
}
String impOptions = TUserDefaults.GetStringDefault("Imp Options", ";" + TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN);
String dateFormatString = TUserDefaults.GetStringDefault("Imp Date", "MDY");
FdlgSeparator.DateFormat = dateFormatString;
FdlgSeparator.NumberFormat = (impOptions.Length > 1) ? impOptions.Substring(1) : TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN;
FdlgSeparator.SelectedSeparator = StringHelper.GetCSVSeparator(FdlgSeparator.FileContent) ??
((impOptions.Length > 0) ? impOptions.Substring(0, 1) : ";");
if (FdlgSeparator.ShowDialog() == DialogResult.OK)
{
Hashtable requestParams = new Hashtable();
requestParams.Add("ALedgerNumber", FLedgerNumber);
requestParams.Add("Delimiter", FdlgSeparator.SelectedSeparator);
requestParams.Add("DateFormatString", FdlgSeparator.DateFormat);
requestParams.Add("DatesMayBeIntegers", datesMayBeIntegers);
requestParams.Add("NumberFormat", FdlgSeparator.NumberFormat);
requestParams.Add("NewLine", Environment.NewLine);
TVerificationResultCollection AMessages = new TVerificationResultCollection();
Thread ImportThread = new Thread(() => ImportGLBatches(
requestParams,
FdlgSeparator.FileContent,
out AMessages,
out ok,
out RefreshGUIAfterImport));
using (TProgressDialog ImportDialog = new TProgressDialog(ImportThread))
{
ImportDialog.ShowDialog();
}
if (TVerificationHelper.ResultsContainErrorCode(AMessages, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else
{
ShowMessages(AMessages);
}
}
// We save the defaults even if ok is false - because the client will probably want to try and import
// the same file again after correcting any errors
SaveUserDefaults(dialog);
if (ok)
{
MessageBox.Show(Catalog.GetString("Your data was imported successfully!"),
Catalog.GetString("Batch Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
if (ok)
{
FMyUserControl.ReloadBatches();
FMyForm.GetBatchControl().SelectRowInGrid(1);
FPetraUtilsObject.SetChangedFlag();
FMyForm.SaveChangesManual(FMyForm.FCurrentGLBatchAction);
}
else if (RefreshGUIAfterImport)
{
// The import failed and the server needs us to refresh the GUI
FMyUserControl.ReloadBatches(true);
FMyForm.GetBatchControl().SelectRowInGrid(1);
}
}
finally
{
FMyForm.FCurrentGLBatchAction = TGLBatchEnums.GLBatchAction.NONE;
}
}
/// <summary>
/// Main method to post a specified batch
/// </summary>
/// <param name="ACurrentBatchRow">The batch row to post</param>
/// <param name="ARefreshGUIAfterPosting">Will be set to true if the GUI should be updated. Can be true even if Posting fails
/// <param name="AWarnOfInactiveValues">True means user is warned if inactive values exist</param>
/// <param name="ADonorZeroIsValid"></param>
/// <param name="ARecipientZeroIsValid"></param>
/// <param name="APostingAlreadyConfirmed">True means ask user if they want to post</param>
/// if the server gets a SerializableTransactionException</param>
/// <returns>True if the batch was successfully posted</returns>
public bool PostBatch(AGiftBatchRow ACurrentBatchRow,
out bool ARefreshGUIAfterPosting,
bool AWarnOfInactiveValues = true,
bool ADonorZeroIsValid = false,
bool ARecipientZeroIsValid = false,
bool APostingAlreadyConfirmed = false)
{
ARefreshGUIAfterPosting = false;
if ((ACurrentBatchRow == null) || (ACurrentBatchRow.BatchStatus != MFinanceConstants.BATCH_UNPOSTED))
{
return(false);
}
FSelectedBatchNumber = ACurrentBatchRow.BatchNumber;
//Make sure that all control data is in dataset
FMyForm.GetLatestControlData();
//Copy all batch data to new table
GiftBatchTDSAGiftDetailTable BatchGiftDetails = new GiftBatchTDSAGiftDetailTable();
DataView BatchGiftDetailsDV = new DataView(FMainDS.AGiftDetail);
BatchGiftDetailsDV.RowFilter = string.Format("{0}={1}",
AGiftDetailTable.GetBatchNumberDBName(),
FSelectedBatchNumber);
BatchGiftDetailsDV.Sort = string.Format("{0} ASC, {1} ASC, {2} ASC",
AGiftDetailTable.GetBatchNumberDBName(),
AGiftDetailTable.GetGiftTransactionNumberDBName(),
AGiftDetailTable.GetDetailNumberDBName());
foreach (DataRowView drv in BatchGiftDetailsDV)
{
GiftBatchTDSAGiftDetailRow gBRow = (GiftBatchTDSAGiftDetailRow)drv.Row;
BatchGiftDetails.Rows.Add((object[])gBRow.ItemArray.Clone());
}
//Save and check for inactive values and ex-workers and anonymous gifts
if (FPetraUtilsObject.HasChanges)
{
//Keep this conditional check separate from the one above so that it only gets called
// when necessary and doesn't result in the executon of the same method
if (!FMyForm.SaveChangesForPosting(BatchGiftDetails))
{
return(false);
}
else
{
APostingAlreadyConfirmed = true;
}
}
else
{
//This has to be called here because if there are no changes then the DataSavingValidating
// method which calls the method below, will not run.
if (!FMyForm.GetBatchControl().AllowInactiveFieldValues(ref APostingAlreadyConfirmed,
TExtraGiftBatchChecks.GiftBatchAction.POSTING) ||
FMyForm.GiftHasExWorkerOrAnon(BatchGiftDetails)
)
{
return(false);
}
}
//Check hash total validity
if ((ACurrentBatchRow.HashTotal != 0) &&
(ACurrentBatchRow.BatchTotal != ACurrentBatchRow.HashTotal))
{
MessageBox.Show(String.Format(Catalog.GetString(
"The gift batch total ({0}) for batch {1} does not equal the hash total ({2})!"),
StringHelper.FormatUsingCurrencyCode(ACurrentBatchRow.BatchTotal, ACurrentBatchRow.CurrencyCode),
ACurrentBatchRow.BatchNumber,
StringHelper.FormatUsingCurrencyCode(ACurrentBatchRow.HashTotal, ACurrentBatchRow.CurrencyCode)),
"Post Gift Batch");
return(false);
}
//Check for missing international exchange rate
bool IsTransactionInIntlCurrency = false;
FMyForm.WarnAboutMissingIntlExchangeRate = true;
if (FMyForm.InternationalCurrencyExchangeRate(ACurrentBatchRow, out IsTransactionInIntlCurrency, true) == 0)
{
return(false);
}
//Check for zero Donors or Recipients
if (!ADonorZeroIsValid)
{
DataView batchGiftDV = new DataView(FMainDS.AGift);
batchGiftDV.RowFilter = string.Format("{0}={1} And {2}=0",
AGiftTable.GetBatchNumberDBName(),
FSelectedBatchNumber,
AGiftTable.GetDonorKeyDBName());
int numDonorZeros = batchGiftDV.Count;
if (numDonorZeros > 0)
{
string messageListOfOffendingGifts =
String.Format(Catalog.GetString(
"Gift Batch {0} contains {1} gift detail(s) with Donor 0000000. Please fix before posting!{2}{2}"),
FSelectedBatchNumber,
numDonorZeros,
Environment.NewLine);
string listOfOffendingRows = string.Empty;
listOfOffendingRows += "Gift" + Environment.NewLine;
listOfOffendingRows += "------------";
foreach (DataRowView drv in batchGiftDV)
{
AGiftRow giftRow = (AGiftRow)drv.Row;
listOfOffendingRows += String.Format("{0}{1:0000}",
Environment.NewLine,
giftRow.GiftTransactionNumber);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
extendedMessageBox.ShowDialog((messageListOfOffendingGifts + listOfOffendingRows),
Catalog.GetString("Post Batch Error"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
return(false);
}
}
if (!ARecipientZeroIsValid)
{
DataView batchGiftDetailsDV = new DataView(FMainDS.AGiftDetail);
batchGiftDetailsDV.RowFilter = string.Format("{0}={1} And {2}=0",
AGiftDetailTable.GetBatchNumberDBName(),
FSelectedBatchNumber,
AGiftDetailTable.GetRecipientKeyDBName());
int numRecipientZeros = batchGiftDetailsDV.Count;
if (numRecipientZeros > 0)
{
string messageListOfOffendingGifts =
String.Format(Catalog.GetString(
"Gift Batch {0} contains {1} gift detail(s) with Recipient 0000000. Please fix before posting!{2}{2}"),
FSelectedBatchNumber,
numRecipientZeros,
Environment.NewLine);
string listOfOffendingRows = string.Empty;
listOfOffendingRows += "Gift Detail" + Environment.NewLine;
listOfOffendingRows += "-------------------";
foreach (DataRowView drv in batchGiftDetailsDV)
{
AGiftDetailRow giftDetailRow = (AGiftDetailRow)drv.Row;
listOfOffendingRows += String.Format("{0}{1:0000} {2:00}",
Environment.NewLine,
giftDetailRow.GiftTransactionNumber,
giftDetailRow.DetailNumber);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
extendedMessageBox.ShowDialog((messageListOfOffendingGifts + listOfOffendingRows),
Catalog.GetString("Post Batch Error"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
return(false);
}
}
//Check for inactive KeyMinistries
DataTable GiftsWithInactiveKeyMinistries;
bool ModifiedDetails = false;
if (AWarnOfInactiveValues && TRemote.MFinance.Gift.WebConnectors.InactiveKeyMinistriesFoundInBatch(FLedgerNumber, FSelectedBatchNumber,
out GiftsWithInactiveKeyMinistries, false))
{
int numInactiveValues = GiftsWithInactiveKeyMinistries.Rows.Count;
string messageNonModifiedBatch =
String.Format(Catalog.GetString("Gift Batch {0} contains {1} inactive key ministries. Please fix before posting!{2}{2}"),
FSelectedBatchNumber,
numInactiveValues,
Environment.NewLine);
string messageModifiedBatch =
String.Format(Catalog.GetString(
"Reversal/Adjustment Gift Batch {0} contains {1} inactive key ministries. Do you still want to post?{2}{2}"),
FSelectedBatchNumber,
numInactiveValues,
Environment.NewLine);
string listOfOffendingRows = string.Empty;
listOfOffendingRows += "Gift Detail Recipient KeyMinistry" + Environment.NewLine;
listOfOffendingRows += "-------------------------------------------------------------------------------";
foreach (DataRow dr in GiftsWithInactiveKeyMinistries.Rows)
{
listOfOffendingRows += String.Format("{0}{1:0000} {2:00} {3:00000000000} {4}",
Environment.NewLine,
dr[0],
dr[1],
dr[2],
dr[3]);
bool isModified = Convert.ToBoolean(dr[4]);
if (isModified)
{
ModifiedDetails = true;
}
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
if (ModifiedDetails)
{
if (extendedMessageBox.ShowDialog((messageModifiedBatch + listOfOffendingRows),
Catalog.GetString("Post Batch"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbYesNo,
TFrmExtendedMessageBox.TIcon.embiWarning) == TFrmExtendedMessageBox.TResult.embrYes)
{
APostingAlreadyConfirmed = true;
}
else
{
return(false);
}
}
else
{
extendedMessageBox.ShowDialog((messageNonModifiedBatch + listOfOffendingRows),
Catalog.GetString("Post Batch Error"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
return(false);
}
}
// ask if the user really wants to post the batch
if (!APostingAlreadyConfirmed &&
(MessageBox.Show(String.Format(Catalog.GetString("Do you really want to post gift batch {0}?"), FSelectedBatchNumber),
Catalog.GetString("Confirm posting of Gift Batch"),
MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes))
{
return(false);
}
TVerificationResultCollection Verifications = new TVerificationResultCollection();
try
{
FPostingInProgress = true;
Thread postingThread = new Thread(() => PostGiftBatch(out Verifications));
postingThread.SetApartmentState(ApartmentState.STA);
using (TProgressDialog dialog = new TProgressDialog(postingThread))
{
dialog.ShowDialog();
}
if (TVerificationHelper.ResultsContainErrorCode(Verifications, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
ARefreshGUIAfterPosting = true;
return(false);
}
else if (!TVerificationHelper.IsNullOrOnlyNonCritical(Verifications))
{
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
StringBuilder errorMessages = new StringBuilder();
int counter = 0;
errorMessages.AppendLine(Catalog.GetString("________________________Gift Posting Errors________________________"));
errorMessages.AppendLine();
foreach (TVerificationResult verif in Verifications)
{
counter++;
errorMessages.AppendLine(counter.ToString("000") + " - " + verif.ResultText);
errorMessages.AppendLine();
}
extendedMessageBox.ShowDialog(errorMessages.ToString(),
Catalog.GetString("Post Batch Error"),
string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
}
else
{
MessageBox.Show(Catalog.GetString("The batch has been posted successfully!"));
ARefreshGUIAfterPosting = true;
}
}
catch (Exception ex)
{
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
finally
{
FPostingInProgress = false;
}
return(true);
}
private void AsyncProgressCheckThread()
{
String OldLoggingText;
DateTime startTime;
String ErrorMessage = null;
Exception ServersideException;
OldLoggingText = "";
startTime = DateTime.Now;
while (FKeepUpProgressCheck)
{
TProgressState state = FReportingGenerator.Progress;
if (state.JobFinished)
{
this.Duration = DateTime.Now - startTime;
if (FReportingGenerator.GetSuccess() == true)
{
this.Parameters.LoadFromDataTable(FReportingGenerator.GetParameter());
this.Results.LoadFromDataTable(FReportingGenerator.GetResult());
this.Results.SetMaxDisplayColumns(this.Parameters.Get("MaxDisplayColumns").ToInt());
}
else
{
ErrorMessage = FReportingGenerator.GetErrorMessage(out ServersideException);
if (ErrorMessage != null)
{
if (ErrorMessage != String.Empty)
{
if (!ErrorMessage.StartsWith(
SharedConstants.NO_PARALLEL_EXECUTION_OF_XML_REPORTS_PREFIX,
StringComparison.InvariantCulture))
{
TLogging.Log(ErrorMessage, FStatusBarProcedure);
}
else
{
FStatusBarProcedure(ErrorMessage.Substring(
SharedConstants.NO_PARALLEL_EXECUTION_OF_XML_REPORTS_PREFIX.Length));
}
}
else
{
// We get here e.g. when Report Generation was cancelled: this clears anything that the
// Status Bar has previously shown.
FStatusBarProcedure(String.Empty);
}
// Let any Exception that happened server-side escalate to the 'Unhandled Exception Handler'
// to give it visibility
if (ServersideException != null)
{
if (TDBExceptionHelper.IsTransactionSerialisationException(ServersideException))
{
FStatusBarProcedure(string.Empty);
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else
{
throw ServersideException;
}
}
}
}
FKeepUpProgressCheck = false;
}
else
{
if ((state.StatusMessage != null) && (!OldLoggingText.Equals(state.StatusMessage)))
{
TLogging.Log(state.StatusMessage, TLoggingType.ToStatusBar, FStatusBarProcedure);
OldLoggingText = state.StatusMessage;
}
}
if (FKeepUpProgressCheck)
{
// Sleep for some time. Then check again for latest progress information
Thread.Sleep(500);
}
}
}
/// <summary>
/// This is the main routine to import tax data from clipboard or file
/// </summary>
private void BtnOK_Click(Object Sender, EventArgs e)
{
if (!ValidateInputs())
{
return;
}
TDlgSelectCSVSeparator dialog = new TDlgSelectCSVSeparator(chkFirstRowIsHeader.Checked);
if (rbtFromClipboard.Checked)
{
dialog.CSVData = Clipboard.GetText(TextDataFormat.UnicodeText);
dialog.SelectedSeparator = "\t";
}
else
{
if (dialog.OpenCsvFile(txtFileName.Text) == false)
{
MessageBox.Show(Catalog.GetString("Could not open the file you have chosen. Maybe it is already open somewhere else."),
this.Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
// work out what the separator is...
String impOptions = TUserDefaults.GetStringDefault("Imp Options", ";" + TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN);
string separator = StringHelper.GetCSVSeparator(dialog.FileContent) ??
((impOptions.Length > 0) ? impOptions.Substring(0, 1) : ";");
string numberFormat = (impOptions.Length > 1) ? impOptions.Substring(1) : TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN;
// Now we need to convert the multi-column file/clipboard data to a simple two column list
string twoColumnImport;
if (ConvertInputTextToTwoColumns(dialog.FileContent, separator, Convert.ToInt16(nudPartnerKeyColumn.Value - 1),
Convert.ToInt16(nudTaxCodeColumn.Value - 1), out twoColumnImport) == false)
{
// We got an error
return;
}
dialog.CSVData = twoColumnImport;
dialog.SelectedSeparator = separator;
dialog.DateFormat = ""; // This will make the combo box empty
// Show the Preview dialog
DialogResult dialogResult = dialog.ShowDialog();
// Save the settings whether the result was OK or cancel
TUserDefaults.SetDefault("Imp Options", dialog.SelectedSeparator + numberFormat);
TUserDefaults.SaveChangedUserDefaults();
if (dialogResult != DialogResult.OK)
{
// It was cancelled
return;
}
// Set up the inputs for the call to the server to do the actual import
string importString = dialog.FileContent;
string selectedSeparator = dialog.SelectedSeparator;
int emptyCodeAction = rbtFailEmptyTaxCode.Checked ? 0 : rbtSkipEmptyTaxCode.Checked ? 1 : rbtDeleteEmptyTaxCode.Checked ? 2 : -1;
Hashtable requestParams = new Hashtable();
requestParams.Add("Delimiter", dialog.SelectedSeparator);
requestParams.Add("FirstRowIsHeader", chkFirstRowIsHeader.Checked);
requestParams.Add("FailIfNotPerson", chkFailIfNotPerson.Checked);
requestParams.Add("FailIfInvalidPartner", chkFailInvalidPartner.Checked);
requestParams.Add("OverwriteExistingTaxCode", chkOverwriteExistingTaxCode.Checked);
requestParams.Add("CreateExtract", chkCreateExtract.Checked);
requestParams.Add("ExtractName", txtExtractName.Text);
requestParams.Add("ExtractDescription", txtExtractDescription.Text);
requestParams.Add("CreateOutFile", chkCreateOutFile.Checked);
requestParams.Add("EmptyTaxCode", emptyCodeAction);
requestParams.Add("TaxCodeType", FTaxGovIdKeyName);
// we include partner details if the user does not want a output file because we will write a sneaky one in the logs folder
requestParams.Add("IncludePartnerDetails",
(chkCreateOutFile.Checked && chkIncludePartnerDetails.Checked) || (chkCreateOutFile.Checked == false));
// Get the server to parse the file and return our results
bool success = false;
TVerificationResultCollection errorMessages = null;
List <string> outputLines = null;
bool newExtractCreated = false;
int newExtractId = -1;
int newExtractKeyCount = -1;
int taxCodesImported = -1;
int taxCodesDeleted = -1;
int taxCodeMismatchCount = -1;
// Do the import on the server
Thread ImportThread = new Thread(() => ImportPartnerTaxCodes(
requestParams, importString, out success, out errorMessages, out outputLines, out newExtractCreated,
out newExtractId, out newExtractKeyCount, out taxCodesImported, out taxCodesDeleted, out taxCodeMismatchCount));
// Show the progress dialog so that the user can cancel
using (TProgressDialog ImportDialog = new TProgressDialog(ImportThread))
{
ImportDialog.ShowDialog();
}
if (success)
{
// Import was successful
string msg = Catalog.GetString("The Import was successful. ");
msg += string.Format(Catalog.GetPluralString("{0} tax code was imported. ",
"{0} tax codes were imported. ",
taxCodesImported, true), taxCodesImported);
msg += string.Format(Catalog.GetPluralString("{0} tax code was deleted. ",
"{0} tax codes were deleted. ",
taxCodesDeleted, true), taxCodesDeleted);
if (taxCodeMismatchCount > 0)
{
msg +=
string.Format(Catalog.GetPluralString(
"{0} tax code was not imported because it did not match the existing code for the Partner. ",
"{0} tax codes were not imported because they did not match the existing code for the Partner. ",
taxCodeMismatchCount, true), taxCodeMismatchCount);
}
if (chkCreateOutFile.Checked)
{
//msg += " ";
msg += Catalog.GetString("You can see full details in the output file.");
}
if (chkCreateExtract.Checked)
{
msg += Environment.NewLine + Environment.NewLine;
if (newExtractCreated)
{
msg += string.Format(Catalog.GetString("In addition an extract was created containing {0} keys."), newExtractKeyCount);
}
else
{
msg += "WARNING! The creation of a new extract failed. Maybe the name was already in use.";
}
}
MessageBox.Show(msg, this.Text, MessageBoxButtons.OK);
}
else
{
// Import failed
if (TVerificationHelper.ResultsContainErrorCode(errorMessages, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
return;
}
else if (errorMessages.HasCriticalErrors)
{
// A failed import should contain some critical errors.
// Concatenate them and show them in an extended message box with scroll bar
string msg = Catalog.GetString("The import failed") + Environment.NewLine + Environment.NewLine;
for (int i = 0; i < errorMessages.Count; i++)
{
msg += string.Format("[{0}] - {1}", errorMessages[i].ResultContext, errorMessages[i].ResultText);
msg += Environment.NewLine;
}
msg += Catalog.GetString("No data was imported into the database.");
TFrmExtendedMessageBox msgBox = new TFrmExtendedMessageBox(this);
msgBox.ShowDialog(msg, this.Text, "", TFrmExtendedMessageBox.TButtons.embbOK, TFrmExtendedMessageBox.TIcon.embiInformation);
}
else
{
// Should not end up wit a failed import and no error messages
MessageBox.Show("Import failed", this.Text, MessageBoxButtons.OK);
}
}
string pathToOutFile = null;
if (chkCreateOutFile.Checked)
{
pathToOutFile = txtOutputFileName.Text;
}
else
{
// we try and write a log file anyway in the log folder
string logPath = TAppSettingsManager.GetValue("OpenPetra.PathLog", "");
if (logPath.Length > 0)
{
pathToOutFile = logPath + Path.DirectorySeparatorChar + "ImportPartnerTaxCodes.log";
}
}
if (pathToOutFile != null)
{
// Write the output file
using (StreamWriter sw = new StreamWriter(pathToOutFile))
{
for (int i = 0; i < outputLines.Count; i++)
{
sw.WriteLine(outputLines[i]);
}
sw.Close();
}
}
if (chkCreateExtract.Checked)
{
// Tell the client about the new extract
// refresh extract master screen if it is open
TFormsMessage BroadcastMessage = new TFormsMessage(TFormsMessageClassEnum.mcExtractCreated);
BroadcastMessage.SetMessageDataName(txtExtractName.Text);
TFormsList.GFormsList.BroadcastFormMessage(BroadcastMessage);
}
// Save the GUI settings
SaveGUISettings();
}
/// <summary>
/// Posts a batch
/// </summary>
/// <param name="ACurrentBatchRow">The data row corresponding to the batch to post</param>
/// <param name="AEffectiveDate">The effective date for the batch</param>
/// <param name="AStartDateCurrentPeriod">The earliest postable date</param>
/// <param name="AEndDateLastForwardingPeriod">The latest postable date</param>
/// <returns>
/// True if the batch was successfully posted
/// </returns>
public bool PostBatch(ABatchRow ACurrentBatchRow,
DateTime AEffectiveDate,
DateTime AStartDateCurrentPeriod,
DateTime AEndDateLastForwardingPeriod)
{
if ((ACurrentBatchRow == null) || (ACurrentBatchRow.BatchStatus != MFinanceConstants.BATCH_UNPOSTED))
{
return(false);
}
int CurrentBatchNumber = ACurrentBatchRow.BatchNumber;
//Make sure that all control data is in dataset
FMyForm.GetLatestControlData();
if (FPetraUtilsObject.HasChanges)
{
//Keep this conditional check separate so that it only gets called when necessary
// and doesn't result in the executon of the next else if which calls same method
if (!FMyForm.SaveChangesManual(FMyForm.FCurrentGLBatchAction))
{
return(false);
}
}
//This has to be called here as if there are no changes then the DataSavingValidating method
// which calls the method below, will not run.
else if (!FMyForm.GetTransactionsControl().AllowInactiveFieldValues(FLedgerNumber,
CurrentBatchNumber, FMyForm.FCurrentGLBatchAction))
{
return(false);
}
//Load all Batch data
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadABatchAndRelatedTables(FLedgerNumber, CurrentBatchNumber));
if (FCacheDS == null)
{
FCacheDS = TRemote.MFinance.GL.WebConnectors.LoadAAnalysisAttributes(FLedgerNumber, false);
}
if (FAccountTable == null)
{
SetAccountCostCentreTableVariables();
}
if ((AEffectiveDate.Date < AStartDateCurrentPeriod) || (AEffectiveDate.Date > AEndDateLastForwardingPeriod))
{
MessageBox.Show(String.Format(Catalog.GetString(
"The Date Effective is outside the periods available for posting. Enter a date between {0:d} and {1:d}."),
AStartDateCurrentPeriod,
AEndDateLastForwardingPeriod));
return(false);
}
// check that a corportate exchange rate exists
FMyForm.WarnAboutMissingIntlExchangeRate = true;
if (FMyForm.GetInternationalCurrencyExchangeRate() == 0)
{
return(false);
}
if ((MessageBox.Show(String.Format(Catalog.GetString("Are you sure you want to post GL batch {0}?"),
CurrentBatchNumber),
Catalog.GetString("Question"),
MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) != System.Windows.Forms.DialogResult.Yes))
{
return(false);
}
TVerificationResultCollection Verifications = new TVerificationResultCollection();
try
{
Cursor.Current = Cursors.WaitCursor;
Thread postingThread = new Thread(() => PostGLBatch(CurrentBatchNumber, out Verifications));
postingThread.SetApartmentState(ApartmentState.STA);
using (TProgressDialog dialog = new TProgressDialog(postingThread))
{
dialog.ShowDialog();
}
if (TVerificationHelper.ResultsContainErrorCode(Verifications, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else if (!TVerificationHelper.IsNullOrOnlyNonCritical(Verifications))
{
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
StringBuilder errorMessages = new StringBuilder();
int counter = 0;
errorMessages.AppendLine(Catalog.GetString("________________________GL Posting Errors________________________"));
errorMessages.AppendLine();
foreach (TVerificationResult verif in Verifications)
{
counter++;
errorMessages.AppendLine(counter.ToString("000") + " - " + verif.ResultText);
errorMessages.AppendLine();
}
extendedMessageBox.ShowDialog(errorMessages.ToString(),
Catalog.GetString("Post Batch Error"),
string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
}
else
{
MessageBox.Show(Catalog.GetString("The batch has been posted successfully!"),
Catalog.GetString("Success"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
// refresh the grid, to reflect that the batch has been posted (or even maybe had been posted by another user)
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadABatchAndRelatedTables(FLedgerNumber, CurrentBatchNumber));
// make sure that the current dataset is clean,
// otherwise the next save would try to modify the posted batch, even though no values have been changed
FMainDS.AcceptChanges();
// Ensure these tabs will ask the server for updates
FMyForm.GetTransactionsControl().ClearCurrentSelection();
FMyForm.GetJournalsControl().ClearCurrentSelection();
FMyUserControl.UpdateDisplay();
}
catch (Exception ex)
{
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
finally
{
Cursor.Current = Cursors.Default;
}
return(true);
}
/// <summary>
/// this supports the batch export files from Petra 2.x.
/// Each line starts with a type specifier, B for batch, J for journal, T for transaction
/// </summary>
public void ImportBatches(TGiftImportDataSourceEnum AImportSource, GiftBatchTDS AMainDS)
{
bool ImportOK = false;
bool RefreshGUIAfterImport = false;
OpenFileDialog OFileDialog = null;
if (FPetraUtilsObject.HasChanges)
{
// saving failed, therefore do not try to import
MessageBox.Show(Catalog.GetString("Please save before calling this function!"), Catalog.GetString(
"Failure"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
ALedgerRow LedgerRow = (ALedgerRow)AMainDS.ALedger.Rows[0];
int CurrentTopBatchNumber = LedgerRow.LastGiftBatchNumber;
try
{
FMyForm.FCurrentGiftBatchAction = Logic.TExtraGiftBatchChecks.GiftBatchAction.IMPORTING;
bool datesMayBeIntegers = TUserDefaults.GetBooleanDefault(MCommonConstants.USERDEFAULT_IMPORTEDDATESMAYBEINTEGERS, false);
FdlgSeparator = new TDlgSelectCSVSeparator(false);
FdlgSeparator.DateMayBeInteger = datesMayBeIntegers;
if (AImportSource == TGiftImportDataSourceEnum.FromClipboard)
{
string ImportString = Clipboard.GetText(TextDataFormat.UnicodeText);
if ((ImportString == null) || (ImportString.Length == 0))
{
MessageBox.Show(Catalog.GetString("Please first copy data from your spreadsheet application!"),
Catalog.GetString("Failure"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
FdlgSeparator.CSVData = ImportString;
}
else if (AImportSource == TGiftImportDataSourceEnum.FromFile)
{
OFileDialog = new OpenFileDialog();
string exportPath = TClientSettings.GetExportPath();
string fullPath = TUserDefaults.GetStringDefault("Imp Filename",
exportPath + Path.DirectorySeparatorChar + "import.csv");
TImportExportDialogs.SetOpenFileDialogFilePathAndName(OFileDialog, fullPath, exportPath);
OFileDialog.Title = Catalog.GetString("Import Batches from CSV File");
OFileDialog.Filter = Catalog.GetString("Gift Batch Files(*.csv)|*.csv|Text Files(*.txt)|*.txt");
// This call fixes Windows7 Open File Dialogs. It must be the line before ShowDialog()
TWin7FileOpenSaveDialog.PrepareDialog(Path.GetFileName(fullPath));
if (OFileDialog.ShowDialog() == DialogResult.OK)
{
Boolean fileCanOpen = FdlgSeparator.OpenCsvFile(OFileDialog.FileName);
if (!fileCanOpen)
{
MessageBox.Show(Catalog.GetString("Unable to open file."),
Catalog.GetString("Gift Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Stop);
return;
}
}
else
{
return;
}
}
else
{
// unknown source!!
return;
}
String impOptions = TUserDefaults.GetStringDefault("Imp Options", ";" + TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN);
String dateFormatString = TUserDefaults.GetStringDefault("Imp Date", "MDY");
FdlgSeparator.DateFormat = dateFormatString;
FdlgSeparator.NumberFormat = (impOptions.Length > 1) ? impOptions.Substring(1) : TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN;
FdlgSeparator.SelectedSeparator = StringHelper.GetCSVSeparator(FdlgSeparator.FileContent) ??
((impOptions.Length > 0) ? impOptions.Substring(0, 1) : ";");
if (FdlgSeparator.ShowDialog() == DialogResult.OK)
{
Hashtable requestParams = new Hashtable();
requestParams.Add("ALedgerNumber", FLedgerNumber);
requestParams.Add("Delimiter", FdlgSeparator.SelectedSeparator);
requestParams.Add("DateFormatString", FdlgSeparator.DateFormat);
requestParams.Add("DatesMayBeIntegers", datesMayBeIntegers);
requestParams.Add("NumberFormat", FdlgSeparator.NumberFormat);
requestParams.Add("NewLine", Environment.NewLine);
bool Repeat = true;
while (Repeat)
{
Repeat = false;
TVerificationResultCollection AMessages = new TVerificationResultCollection();
GiftBatchTDSAGiftDetailTable NeedRecipientLedgerNumber = new GiftBatchTDSAGiftDetailTable();
Thread ImportThread = new Thread(() => ImportGiftBatches(
requestParams,
FdlgSeparator.FileContent,
out AMessages,
out ImportOK,
out RefreshGUIAfterImport,
out NeedRecipientLedgerNumber));
using (TProgressDialog ImportDialog = new TProgressDialog(ImportThread))
{
ImportDialog.ShowDialog();
}
// If NeedRecipientLedgerNumber contains data then AMessages will only ever contain
// one message alerting the user that no data has been imported.
// We do not want to show this as we will be displaying another more detailed message.
if (NeedRecipientLedgerNumber.Rows.Count == 0)
{
if (TVerificationHelper.ResultsContainErrorCode(AMessages, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else
{
ShowMessages(AMessages);
}
}
// if the import contains gifts with Motivation Group 'GIFT' and that have a Family recipient with no Gift Destination
// then the import will have failed and we need to alert the user
if (NeedRecipientLedgerNumber.Rows.Count > 0)
{
bool OfferToRunImportAgain = true;
bool DoNotShowMessageBoxEverytime = false;
TFrmExtendedMessageBox.TResult Result = TFrmExtendedMessageBox.TResult.embrUndefined;
int count = 1;
// for each gift in which the recipient needs a Git Destination
foreach (GiftBatchTDSAGiftDetailRow Row in NeedRecipientLedgerNumber.Rows)
{
if (!DoNotShowMessageBoxEverytime)
{
string CheckboxText = string.Empty;
// only show checkbox if there is at least one more occurrence of this error
if (NeedRecipientLedgerNumber.Rows.Count - count > 0)
{
CheckboxText = string.Format(
Catalog.GetString(
"Do this for all further occurrences ({0})?"), NeedRecipientLedgerNumber.Rows.Count - count);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FPetraUtilsObject.GetForm());
extendedMessageBox.ShowDialog(string.Format(
Catalog.GetString(
"Gift Import has been cancelled as the recipient '{0}' ({1}) has no Gift Destination assigned."),
Row.RecipientDescription, Row.RecipientKey) +
"\n\r\n\r\n\r" +
Catalog.GetString("Do you want to assign a Gift Destination to this partner now?"),
Catalog.GetString("Import Errors"),
CheckboxText,
TFrmExtendedMessageBox.TButtons.embbYesNo, TFrmExtendedMessageBox.TIcon.embiWarning);
Result = extendedMessageBox.GetResult(out DoNotShowMessageBoxEverytime);
}
if (Result == TFrmExtendedMessageBox.TResult.embrYes)
{
// allow the user to assign a Gift Destingation
TFrmGiftDestination GiftDestinationForm = new TFrmGiftDestination(FPetraUtilsObject.GetForm(), Row.RecipientKey);
GiftDestinationForm.ShowDialog();
}
else
{
OfferToRunImportAgain = false;
if (DoNotShowMessageBoxEverytime)
{
break;
}
}
count++;
}
// if the user has clicked yes to assigning Gift Destinations then offer to restart the import
if (OfferToRunImportAgain &&
(MessageBox.Show(Catalog.GetString("Would you like to import this Gift Batch again?"),
Catalog.GetString("Gift Import"), MessageBoxButtons.YesNo, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2)
== DialogResult.Yes))
{
Repeat = true;
}
}
}
}
// We save the defaults even if ok is false - because the client will probably want to try and import
// the same file again after correcting any errors
SaveUserDefaults(OFileDialog);
if (ImportOK)
{
MessageBox.Show(Catalog.GetString("Your data was imported successfully!"),
Catalog.GetString("Gift Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
if (ImportOK)
{
FMyUserControl.LoadBatchesForCurrentYear();
FMyForm.GetBatchControl().SelectRowInBatchGrid(1);
DataView allNewBatches = new DataView(AMainDS.AGiftBatch);
allNewBatches.RowFilter = String.Format("{0} > {1}",
AGiftBatchTable.GetBatchNumberDBName(),
CurrentTopBatchNumber);
foreach (DataRowView drv in allNewBatches)
{
drv.Row.SetModified();
}
FPetraUtilsObject.SetChangedFlag();
//Force initial inactive values check
FMyForm.SaveChangesManual(FMyForm.FCurrentGiftBatchAction);
}
else if (RefreshGUIAfterImport)
{
FMyUserControl.LoadBatchesForCurrentYear();
FMyForm.GetBatchControl().SelectRowInBatchGrid(1);
}
}
finally
{
FMyForm.FCurrentGiftBatchAction = Logic.TExtraGiftBatchChecks.GiftBatchAction.NONE;
}
}
/// <summary>
/// Import a transactions file or a clipboard equivalent
/// </summary>
/// <param name="ACurrentBatchRow">The batch to import to</param>
/// <param name="AImportSource">The import source - eg File or Clipboard</param>
/// <returns>True if the import was successful</returns>
public bool ImportTransactions(AGiftBatchRow ACurrentBatchRow, TGiftImportDataSourceEnum AImportSource)
{
bool ok = false;
bool RefreshGUIAfterImport = false;
OpenFileDialog dialog = null;
Boolean IsPlainText = false;
if (FPetraUtilsObject.HasChanges)
{
// saving failed, therefore do not try to import
MessageBox.Show(Catalog.GetString("Please save any changes before calling this function!"), Catalog.GetString(
"Gift Import"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
if ((ACurrentBatchRow == null) || (ACurrentBatchRow.BatchStatus != MFinanceConstants.BATCH_UNPOSTED))
{
MessageBox.Show(Catalog.GetString("Please select an unposted batch to import transactions."), Catalog.GetString(
"Gift Import"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
if (ACurrentBatchRow.LastGiftNumber > 0)
{
if (MessageBox.Show(Catalog.GetString(
"The current batch already contains some gift transactions. Do you really want to add more transactions to this batch?"),
Catalog.GetString("Gift Transaction Import"),
MessageBoxButtons.YesNo,
MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2) == DialogResult.No)
{
return(false);
}
}
FdlgSeparator = new TDlgSelectCSVSeparator(false);
FdlgSeparator.DateMayBeInteger = TUserDefaults.GetBooleanDefault(MCommonConstants.USERDEFAULT_IMPORTEDDATESMAYBEINTEGERS, false);
if (AImportSource == TGiftImportDataSourceEnum.FromClipboard)
{
string importString = Clipboard.GetText(TextDataFormat.UnicodeText);
if ((importString == null) || (importString.Length == 0))
{
MessageBox.Show(Catalog.GetString("Please first copy data from your spreadsheet application!"),
Catalog.GetString("Failure"), MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
FdlgSeparator.CSVData = importString;
}
else if (AImportSource == TGiftImportDataSourceEnum.FromFile)
{
dialog = new OpenFileDialog();
string exportPath = TClientSettings.GetExportPath();
string fullPath = TUserDefaults.GetStringDefault("Imp Filename",
exportPath + Path.DirectorySeparatorChar + "import.csv");
TImportExportDialogs.SetOpenFileDialogFilePathAndName(dialog, fullPath, exportPath);
dialog.Title = Catalog.GetString("Import Transactions from CSV File");
dialog.Filter = Catalog.GetString("Gift Transactions files (*.csv)|*.csv|Text Files (*.txt)|*.txt");
// This call fixes Windows7 Open File Dialogs. It must be the line before ShowDialog()
TWin7FileOpenSaveDialog.PrepareDialog(Path.GetFileName(fullPath));
if (dialog.ShowDialog() == DialogResult.OK)
{
Boolean fileCanOpen = FdlgSeparator.OpenCsvFile(dialog.FileName);
if (!fileCanOpen)
{
MessageBox.Show(Catalog.GetString("Unable to open file."),
Catalog.GetString("Gift Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Stop);
return(false);
}
IsPlainText = (Path.GetExtension(dialog.FileName).ToLower() == ".txt");
}
else
{
return(false);
}
}
else
{
// unknown source!! The following need a value...
return(false);
}
String impOptions = TUserDefaults.GetStringDefault("Imp Options", ";" + TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN);
String dateFormatString = TUserDefaults.GetStringDefault("Imp Date", "MDY");
FdlgSeparator.DateFormat = dateFormatString;
FdlgSeparator.NumberFormat = (impOptions.Length > 1) ? impOptions.Substring(1) : TDlgSelectCSVSeparator.NUMBERFORMAT_AMERICAN;
FdlgSeparator.SelectedSeparator = StringHelper.GetCSVSeparator(FdlgSeparator.FileContent) ??
((impOptions.Length > 0) ? impOptions.Substring(0, 1) : ";");
if (IsPlainText || (FdlgSeparator.ShowDialog() == DialogResult.OK))
{
Hashtable requestParams = new Hashtable();
requestParams.Add("ALedgerNumber", FLedgerNumber);
requestParams.Add("Delimiter", FdlgSeparator.SelectedSeparator);
requestParams.Add("DateFormatString", FdlgSeparator.DateFormat);
requestParams.Add("NumberFormat", FdlgSeparator.NumberFormat);
requestParams.Add("NewLine", Environment.NewLine);
bool Repeat = true;
while (Repeat)
{
Repeat = false;
TVerificationResultCollection AMessages = new TVerificationResultCollection();
GiftBatchTDSAGiftDetailTable NeedRecipientLedgerNumber = new GiftBatchTDSAGiftDetailTable();
Thread ImportThread = new Thread(() => ImportGiftTransactions(
requestParams,
FdlgSeparator.FileContent,
ACurrentBatchRow.BatchNumber,
out AMessages,
out ok,
out RefreshGUIAfterImport,
out NeedRecipientLedgerNumber));
using (TProgressDialog ImportDialog = new TProgressDialog(ImportThread))
{
ImportDialog.ShowDialog();
}
// if the import contains gifts with Motivation Group 'GIFT' and that have a Family recipient with no Gift Destination
// then the import will have failed and we need to alert the user
int numberOfMissingGiftDestinations = NeedRecipientLedgerNumber.Rows.Count;
if (numberOfMissingGiftDestinations == 0)
{
if (TVerificationHelper.ResultsContainErrorCode(AMessages, PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
}
else
{
ShowMessages(AMessages);
}
}
if (numberOfMissingGiftDestinations > 0)
{
bool offerToRunImportAgain = true;
int currentMissingGiftDestinationNo = 1;
// for each gift in which the recipient needs a Git Destination
foreach (GiftBatchTDSAGiftDetailRow Row in NeedRecipientLedgerNumber.Rows)
{
//Lookup the partner shortname
string partnerShortName = string.Empty;
TPartnerClass partnerClass;
if (TServerLookup.TMPartner.GetPartnerShortName(Row.RecipientKey, out partnerShortName, out partnerClass))
{
Row.RecipientDescription = partnerShortName;
}
if (MessageBox.Show(string.Format(
Catalog.GetString(
"Error: {0:0000} of {1:0000} - Recipient '{2}' ({3}) has no Gift Destination assigned."),
currentMissingGiftDestinationNo, numberOfMissingGiftDestinations, Row.RecipientDescription,
Row.RecipientKey) +
"\n\n" +
Catalog.GetString("Do you want to assign a Gift Destination to this partner now?"),
Catalog.GetString("Gift Import Cancelled"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning)
== DialogResult.Yes)
{
// allow the user to assign a Gift Destingation
TFrmGiftDestination GiftDestinationForm = new TFrmGiftDestination(FPetraUtilsObject.GetForm(), Row.RecipientKey);
GiftDestinationForm.ShowDialog();
}
else
{
offerToRunImportAgain = false;
}
currentMissingGiftDestinationNo++;
}
// if the user has clicked yes to assigning Gift Destinations then offer to restart the import
if (offerToRunImportAgain &&
(MessageBox.Show(Catalog.GetString("Would you like to import these Gift Transactions again?"),
Catalog.GetString("Gift Import"), MessageBoxButtons.YesNo, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button1)
== DialogResult.Yes))
{
Repeat = true;
}
}
}
}
// We save the defaults even if ok is false - because the client will probably want to try and import
// the same file again after correcting any errors
if (!IsPlainText)
{
SaveUserDefaults(dialog);
}
if (ok)
{
MessageBox.Show(Catalog.GetString("Your data was imported successfully!"),
Catalog.GetString("Gift Import"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
if (ok || RefreshGUIAfterImport)
{
FMyUserControl.LoadBatchesForCurrentYear();
FPetraUtilsObject.DisableSaveButton();
return(true); // This completes the refresh
}
return(false);
}
// starts the merge process
private void BtnOK_Click(Object Sender, EventArgs e)
{
// Title for all message boxes
string mergePartnersTitle = Catalog.GetString("Merge Partners");
string mergeCancelledText = Catalog.GetString("Merge cancelled.");
FFromPartnerKey = Convert.ToInt64(txtMergeFrom.Text);
FToPartnerKey = Convert.ToInt64(txtMergeTo.Text);
if (CheckPartnersCanBeMerged() &&
(MessageBox.Show(Catalog.GetString("WARNING: A Partner Merge operation cannot be undone and the From-Partner will be no longer " +
"accessible after the Partner Merge operation!") + "\n\n" + Catalog.GetString("Are you sure you want to continue?"),
mergePartnersTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes))
{
bool[] Categories = new bool[25];
for (int i = 1; i < 25; i++)
{
Categories[i] = true;
}
FSiteKeys = null;
FLocationKeys = null;
FContactDetails = null;
FMainBankingDetailsKey = -1;
TFrmExtendedMessageBox msgBox = null;
string msg = string.Empty;
bool DifferentFamilies = false;
// open a dialog to select which From Partner's addresses should be merged
if (GetSelectedAddresses() == false)
{
MessageBox.Show(mergeCancelledText, mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
// open a dialog to select which From Partner's contact details should be merged
if (GetSelectedContactDetails() == false)
{
MessageBox.Show(mergeCancelledText, mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
// open a dialog to select which bank account should be set to MAIN (if necessary)
if (GetMainBankAccount() == false)
{
MessageBox.Show(mergeCancelledText, mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//
if ((((FFromPartnerClass == TPartnerClass.FAMILY) && (FToPartnerClass == TPartnerClass.FAMILY)) ||
(FFromPartnerClass == TPartnerClass.PERSON)) &&
(GiftDestinationToMerge(out Categories[0]) == false))
{
MessageBox.Show(mergeCancelledText, mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
Thread t =
new Thread(() => MergeTwoPartners(Categories, ref DifferentFamilies));
using (TProgressDialog dialog = new TProgressDialog(t))
{
if ((dialog.ShowDialog() == DialogResult.Cancel) && (FWebConnectorResult == false))
{
MessageBox.Show(mergeCancelledText, mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
else if ((FWebConnectorResult == false) &&
TVerificationHelper.ResultsContainErrorCode(FVerificationResultsOfMerge,
PetraErrorCodes.ERR_DB_SERIALIZATION_EXCEPTION))
{
TConcurrentServerTransactions.ShowTransactionSerializationExceptionDialog();
return;
}
else if (FWebConnectorResult == false) // if merge is unsuccessful
{
msg = Catalog.GetString("The merge operation failed");
// Anything to display from the verification results?
if (FVerificationResultsOfMerge.Count > 0)
{
for (int i = 0; i < FVerificationResultsOfMerge.Count; i++)
{
if (FVerificationResultsOfMerge[i].ResultSeverity == TResultSeverity.Resv_Critical)
{
msg += Environment.NewLine;
msg += FVerificationResultsOfMerge[i].ResultText;
}
}
msg += Environment.NewLine;
msg += Catalog.GetString("More information is available in the Server.log file on the server at the date and time shown.");
msg += Environment.NewLine;
msg += Catalog.GetString("You can copy this message to the clipboard by clicking the button below.");
}
msgBox = new TFrmExtendedMessageBox(this);
msgBox.ShowDialog(msg, mergePartnersTitle, string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK, TFrmExtendedMessageBox.TIcon.embiError);
dialog.Close();
return;
}
}
if (DifferentFamilies)
{
MessageBox.Show(String.Format(Catalog.GetString("Partners were in different families.")) + "\n\n" +
Catalog.GetString("FAMILY relations of the From Partner are not taken over to the To Partner!") + "\n\n" +
Catalog.GetString("Please check the family relations of the To Partner after completion."),
mergePartnersTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
msg = String.Format(Catalog.GetString("Merge of Partner {0} ({1}) into {2} ({3}) completed successfully."),
txtMergeFrom.LabelText, FFromPartnerKey, txtMergeTo.LabelText, FToPartnerKey);
if (FVerificationResultsOfMerge.Count > 0)
{
msg += Environment.NewLine;
for (int i = 0; i < FVerificationResultsOfMerge.Count; i++)
{
msg += Environment.NewLine;
msg += FVerificationResultsOfMerge[i].ResultText;
}
msg += Environment.NewLine;
}
msg += Environment.NewLine;
msg += Catalog.GetString("If necessary, edit the merged Partner to correct any information that may not have been " +
"merged and correct information that may have been overwritten.") + Environment.NewLine + Environment.NewLine;
msg += Catalog.GetString("Tip: You can use the 'Work with Last Partner' command in the Partner module and the " +
"'Work with Last Person' command in the Personnel module to view and edit the merged Partner.") + Environment.NewLine +
Environment.NewLine;
msg += Catalog.GetString("You can copy this message to the clipboard by clicking the button below.");
msgBox = new TFrmExtendedMessageBox(this);
msgBox.ShowDialog(msg, mergePartnersTitle, string.Empty, TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiInformation);
this.DialogResult = System.Windows.Forms.DialogResult.OK;
this.Close();
}
}
