private void RecalculateTransactionAmounts(decimal ANewExchangeRate = 0)
        {
            string   CurrencyCode  = FPreviouslySelectedDetailRow.CurrencyCode;
            DateTime EffectiveDate = FPreviouslySelectedDetailRow.GlEffectiveDate;

            if (ANewExchangeRate == 0)
            {
                if (CurrencyCode == FMainDS.ALedger[0].BaseCurrency)
                {
                    ANewExchangeRate = 1;
                }
                else
                {
                    ANewExchangeRate = TExchangeRateCache.GetDailyExchangeRate(
                        CurrencyCode,
                        FMainDS.ALedger[0].BaseCurrency,
                        EffectiveDate);
                }
            }

            //Need to get the exchange rate
            FPreviouslySelectedDetailRow.ExchangeRateToBase = ANewExchangeRate;

            ((TFrmGiftBatch)ParentForm).GetTransactionsControl().UpdateCurrencySymbols(CurrencyCode);
            ((TFrmGiftBatch)ParentForm).GetTransactionsControl().UpdateBaseAmount(false);
        }
        private void ResetCurrencyExchangeRate(object sender, EventArgs e)
        {
            bool CurrencyCodeHasChanged = false;

            if (FPetraUtilsObject.SuppressChangeDetection || (FPreviouslySelectedDetailRow == null) ||
                (GetBatchRow().BatchStatus != MFinanceConstants.BATCH_UNPOSTED))
            {
                return;
            }

            CurrencyCodeHasChanged = (FTransactionCurrency != cmbDetailTransactionCurrency.GetSelectedString());

            if (CurrencyCodeHasChanged)
            {
                FTransactionCurrency = cmbDetailTransactionCurrency.GetSelectedString();

                FPreviouslySelectedDetailRow.TransactionCurrency = FTransactionCurrency;

                FPreviouslySelectedDetailRow.ExchangeRateToBase = TExchangeRateCache.GetDailyExchangeRate(
                    FTransactionCurrency,
                    FMainDS.ALedger[0].BaseCurrency,
                    FBatchRow.DateEffective);

                if (FPreviouslySelectedDetailRow.ExchangeRateToBase > 0)
                {
                    RefreshCurrencyAndExchangeRate();
                }
                else
                {
                    txtDetailExchangeRateToBase.NumberValueDecimal = 0M;
                    btnGetSetExchangeRate.Enabled = true;
                }
            }
        }
        private void LookupExchangeRate(Object sender, EventArgs e)
        {
            TFrmSetupDailyExchangeRate setupDailyExchangeRate =
                new TFrmSetupDailyExchangeRate(FPetraUtilsObject.GetForm());

            decimal  selectedExchangeRate;
            DateTime selectedEffectiveDate;
            int      selectedEffectiveTime;

            if (setupDailyExchangeRate.ShowDialog(
                    FLedgerNumber,
                    DateTime.Now,
                    txtCurrency.Text,
                    1.0m,
                    out selectedExchangeRate,
                    out selectedEffectiveDate,
                    out selectedEffectiveTime) == DialogResult.Cancel)
            {
                return;
            }

            txtExchangeRate.NumberValueDecimal = selectedExchangeRate;

            // Put the rate in our client-side cache
            if (FLedgerRow != null)
            {
                TExchangeRateCache.SetDailyExchangeRate(txtCurrency.Text, FLedgerRow.BaseCurrency, selectedEffectiveDate, selectedExchangeRate);
            }
        }
        private void LookupCurrencyExchangeRates(DateTime ADate)
        {
            FExchangeRateToBase = TExchangeRateCache.GetDailyExchangeRate(
                FBatchRow.CurrencyCode,
                FMainDS.ALedger[0].BaseCurrency,
                ADate, true);

            txtExchangeRateToBase.NumberValueDecimal = FExchangeRateToBase;

            FExchangeRateIntlToBase = InternationalCurrencyExchangeRate(ADate);
        }
        private void LookupCurrencyExchangeRates(DateTime ADate)
        {
            FExchangeRateToBase = TExchangeRateCache.GetDailyExchangeRate(
                FCurrencyCode,
                FMainDS.ALedger[0].BaseCurrency,
                ADate);

            txtExchangeRateToBase.Text = FExchangeRateToBase.ToString();

            FExchangeRateIntlToBase = InternationalCurrencyExchangeRate(ADate);
        }
        private void RunOnceOnActivationManual()
        {
            rbtPayFullOutstandingAmount.CheckedChanged += new EventHandler(EnablePartialPayment);
            chkClaimDiscount.Visible     = false;
            txtExchangeRate.TextChanged += new EventHandler(UpdateTotalAmount);

            ALedgerRow LedgerRow =
                ((ALedgerTable)TDataCache.TMFinance.GetCacheableFinanceTable(TCacheableFinanceTablesEnum.LedgerDetails, FLedgerNumber))[0];

            FCurrencyTable = (ACurrencyTable)TDataCache.TMCommon.GetCacheableCommonTable(TCacheableCommonTablesEnum.CurrencyCodeList);

            //txtExchangeRate.SetControlProperties(10);
            txtBaseAmount.CurrencyCode = LedgerRow.BaseCurrency;

            TExchangeRateCache.ResetCache();
            FocusedRowChanged(null, null);
        }
        private void LookupCurrencyExchangeRates(DateTime ADate, String ACurrencyCode)
        {
            decimal ExchangeRateToBase = 1;

            if (ACurrencyCode != FBaseCurrencyCode)
            {
                ExchangeRateToBase = TExchangeRateCache.GetDailyExchangeRate(
                    ACurrencyCode,
                    FBaseCurrencyCode,
                    ADate, true);
            }

            if ((txtDetailExchangeRateToBase.NumberValueDecimal.Value != ExchangeRateToBase) ||
                (FPreviouslySelectedDetailRow.ExchangeRateToBase != ExchangeRateToBase))
            {
                txtDetailExchangeRateToBase.NumberValueDecimal  = ExchangeRateToBase;
                FPreviouslySelectedDetailRow.ExchangeRateToBase = ExchangeRateToBase;
            }

            FExchangeRateIntlToBase = InternationalCurrencyExchangeRate(ADate);
        }
        private void FocusedRowChanged(System.Object sender, SourceGrid.RowEventArgs e)
        {
            DataRowView[] SelectedGridRow = grdPayments.SelectedDataRowsAsDataRowView;

            if (SelectedGridRow.Length >= 1)
            {
                FSelectedPaymentRow = (AccountsPayableTDSAApPaymentRow)SelectedGridRow[0].Row;

                if (!FSelectedPaymentRow.IsSupplierKeyNull())
                {
                    AApSupplierRow supplier = TFrmAPMain.GetSupplier(FMainDS.AApSupplier, FSelectedPaymentRow.SupplierKey);
                    txtCurrency.Text = supplier.CurrencyCode;

                    decimal CurrentRate = TExchangeRateCache.GetDailyExchangeRate(supplier.CurrencyCode, FLedgerRow.BaseCurrency, DateTime.Now);
                    txtExchangeRate.NumberValueDecimal = CurrentRate;
                    cmbPaymentType.SetSelectedString(supplier.PaymentType);

                    if (txtCurrency.Text == FLedgerRow.BaseCurrency)
                    {
                        txtExchangeRate.Enabled       = false;
                        btnLookupExchangeRate.Enabled = false;
                    }
                    else
                    {
                        txtExchangeRate.Enabled       = true;
                        btnLookupExchangeRate.Enabled = true;
                    }
                }

                cmbBankAccount.SetSelectedString(FSelectedPaymentRow.BankAccount);

                FMainDS.AApDocumentPayment.DefaultView.RowFilter = AccountsPayableTDSAApDocumentPaymentTable.GetPaymentNumberDBName() +
                                                                   " = " + FSelectedPaymentRow.PaymentNumber.ToString();

                grdDocuments.DataSource = new DevAge.ComponentModel.BoundDataView(FMainDS.AApDocumentPayment.DefaultView);
                grdDocuments.Refresh();
                grdDocuments.Selection.SelectRow(1, true);
                FocusedRowChangedDetails(null, null);
            }
        }
        /// load transactions from a CSV file into the currently selected batch
        private void CreateBatchFromCSVFile(string ADataFilename,
                                            XmlNode ARootNode,
                                            AJournalRow ARefJournalRow,
                                            Int32 AFirstTransactionRow,
                                            string ADefaultCostCentre,
                                            out DateTime ALatestTransactionDate)
        {
            StreamReader dataFile = new StreamReader(ADataFilename, System.Text.Encoding.Default);

            XmlNode ColumnsNode        = TXMLParser.GetChild(ARootNode, "Columns");
            string  Separator          = TXMLParser.GetAttribute(ARootNode, "Separator");
            string  DateFormat         = TXMLParser.GetAttribute(ARootNode, "DateFormat");
            string  ThousandsSeparator = TXMLParser.GetAttribute(ARootNode, "ThousandsSeparator");
            string  DecimalSeparator   = TXMLParser.GetAttribute(ARootNode, "DecimalSeparator");
            Int32   lineCounter;

            // read headers
            for (lineCounter = 0; lineCounter < AFirstTransactionRow - 1; lineCounter++)
            {
                dataFile.ReadLine();
            }

            decimal sumDebits  = 0.0M;
            decimal sumCredits = 0.0M;

            ALatestTransactionDate = DateTime.MinValue;

            do
            {
                string line = dataFile.ReadLine();
                lineCounter++;

                GLBatchTDSATransactionRow NewTransaction = FMainDS.ATransaction.NewRowTyped(true);
                FMyForm.GetTransactionsControl().NewRowManual(ref NewTransaction, ARefJournalRow);
                FMainDS.ATransaction.Rows.Add(NewTransaction);

                foreach (XmlNode ColumnNode in ColumnsNode.ChildNodes)
                {
                    string Value = StringHelper.GetNextCSV(ref line, Separator);
                    string UseAs = TXMLParser.GetAttribute(ColumnNode, "UseAs");

                    if (UseAs.ToLower() == "reference")
                    {
                        NewTransaction.Reference = Value;
                    }
                    else if (UseAs.ToLower() == "narrative")
                    {
                        NewTransaction.Narrative = Value;
                    }
                    else if (UseAs.ToLower() == "dateeffective")
                    {
                        NewTransaction.SetTransactionDateNull();

                        if (Value.Trim().ToString().Length > 0)
                        {
                            try
                            {
                                NewTransaction.TransactionDate = XmlConvert.ToDateTime(Value, DateFormat);

                                if (NewTransaction.TransactionDate > ALatestTransactionDate)
                                {
                                    ALatestTransactionDate = NewTransaction.TransactionDate;
                                }
                            }
                            catch (Exception exp)
                            {
                                MessageBox.Show(Catalog.GetString("Problem with date in row " + lineCounter.ToString() + " Error: " + exp.Message));
                            }
                        }
                    }
                    else if (UseAs.ToLower() == "account")
                    {
                        if (Value.Length > 0)
                        {
                            if (Value.Contains(" "))
                            {
                                // cut off currency code; should have been defined in the data description file, for the whole batch
                                Value = Value.Substring(0, Value.IndexOf(" ") - 1);
                            }

                            Value = Value.Replace(ThousandsSeparator, "");
                            Value = Value.Replace(DecimalSeparator, ".");

                            NewTransaction.TransactionAmount    = Convert.ToDecimal(Value, System.Globalization.CultureInfo.InvariantCulture);
                            NewTransaction.CostCentreCode       = ADefaultCostCentre;
                            NewTransaction.AccountCode          = ColumnNode.Name;
                            NewTransaction.DebitCreditIndicator = true;

                            if (TXMLParser.HasAttribute(ColumnNode,
                                                        "CreditDebit") && (TXMLParser.GetAttribute(ColumnNode, "CreditDebit").ToLower() == "credit"))
                            {
                                NewTransaction.DebitCreditIndicator = false;
                            }

                            if (NewTransaction.TransactionAmount < 0)
                            {
                                NewTransaction.TransactionAmount   *= -1.0M;
                                NewTransaction.DebitCreditIndicator = !NewTransaction.DebitCreditIndicator;
                            }

                            if (TXMLParser.HasAttribute(ColumnNode, "AccountCode"))
                            {
                                NewTransaction.AccountCode = TXMLParser.GetAttribute(ColumnNode, "AccountCode");
                            }

                            if (NewTransaction.DebitCreditIndicator)
                            {
                                sumDebits += NewTransaction.TransactionAmount;
                            }
                            else if (!NewTransaction.DebitCreditIndicator)
                            {
                                sumCredits += NewTransaction.TransactionAmount;
                            }
                        }
                    }
                }

                if (!NewTransaction.IsTransactionDateNull())
                {
                    NewTransaction.AmountInBaseCurrency = GLRoutines.CurrencyMultiply(NewTransaction.TransactionAmount,
                                                                                      TExchangeRateCache.GetDailyExchangeRate(
                                                                                          ARefJournalRow.TransactionCurrency,
                                                                                          FMainDS.ALedger[0].BaseCurrency,
                                                                                          NewTransaction.TransactionDate,
                                                                                          false));
                    //
                    // The International currency calculation is changed to "Base -> International", because it's likely
                    // we won't have a "Transaction -> International" conversion rate defined.
                    //
                    NewTransaction.AmountInIntlCurrency = GLRoutines.CurrencyMultiply(NewTransaction.AmountInBaseCurrency,
                                                                                      TExchangeRateCache.GetDailyExchangeRate(
                                                                                          FMainDS.ALedger[0].BaseCurrency,
                                                                                          FMainDS.ALedger[0].IntlCurrency,
                                                                                          NewTransaction.TransactionDate,
                                                                                          false));
                }
            } while (!dataFile.EndOfStream);

            // create a balancing transaction; not sure if this is needed at all???
            if (Convert.ToDecimal(sumCredits - sumDebits) != 0)
            {
                GLBatchTDSATransactionRow BalancingTransaction = FMainDS.ATransaction.NewRowTyped(true);
                FMyForm.GetTransactionsControl().NewRowManual(ref BalancingTransaction, ARefJournalRow);
                FMainDS.ATransaction.Rows.Add(BalancingTransaction);

                BalancingTransaction.TransactionDate      = ALatestTransactionDate;
                BalancingTransaction.DebitCreditIndicator = true;
                BalancingTransaction.TransactionAmount    = sumCredits - sumDebits;

                if (BalancingTransaction.TransactionAmount < 0)
                {
                    BalancingTransaction.TransactionAmount   *= -1;
                    BalancingTransaction.DebitCreditIndicator = !BalancingTransaction.DebitCreditIndicator;
                }

                if (BalancingTransaction.DebitCreditIndicator)
                {
                    sumDebits += BalancingTransaction.TransactionAmount;
                }
                else
                {
                    sumCredits += BalancingTransaction.TransactionAmount;
                }

                BalancingTransaction.AmountInIntlCurrency = GLRoutines.CurrencyMultiply(BalancingTransaction.TransactionAmount,
                                                                                        TExchangeRateCache.GetDailyExchangeRate(
                                                                                            ARefJournalRow.TransactionCurrency,
                                                                                            FMainDS.ALedger[0].IntlCurrency,
                                                                                            BalancingTransaction.TransactionDate,
                                                                                            false));
                BalancingTransaction.AmountInBaseCurrency = GLRoutines.CurrencyMultiply(BalancingTransaction.TransactionAmount,
                                                                                        TExchangeRateCache.GetDailyExchangeRate(
                                                                                            ARefJournalRow.TransactionCurrency,
                                                                                            FMainDS.ALedger[0].BaseCurrency,
                                                                                            BalancingTransaction.TransactionDate,
                                                                                            false));
                BalancingTransaction.Narrative      = Catalog.GetString("Automatically generated balancing transaction");
                BalancingTransaction.CostCentreCode = TXMLParser.GetAttribute(ARootNode, "CashCostCentre");
                BalancingTransaction.AccountCode    = TXMLParser.GetAttribute(ARootNode, "CashAccount");
            }

            ARefJournalRow.JournalCreditTotal = sumCredits;
            ARefJournalRow.JournalDebitTotal  = sumDebits;
            ARefJournalRow.JournalDescription = Path.GetFileNameWithoutExtension(ADataFilename);

            ABatchRow RefBatch = (ABatchRow)FMainDS.ABatch.Rows[FMainDS.ABatch.Rows.Count - 1];

            RefBatch.BatchCreditTotal = sumCredits;
            RefBatch.BatchDebitTotal  = sumDebits;
            // todo RefBatch.BatchControlTotal = sumCredits  - sumDebits;
            // csv !
        }
        /// <summary>
        /// Reads the selected values from the controls,
        /// and stores them into the parameter system of FCalculator
        ///
        /// </summary>
        /// <param name="ACalculator"></param>
        /// <param name="AReportAction"></param>
        /// <returns>void</returns>
        public void ReadControls(TRptCalculator ACalculator, TReportActionEnum AReportAction)
        {
            int      Year      = 0;
            DateTime EndDate   = DateTime.Now;
            DateTime StartDate = DateTime.Now;

            // TODO
            int DiffPeriod = 0;             //(System.Int32)CbB_YearEndsOn.SelectedItem;

            //            DiffPeriod = DiffPeriod - 12;
            ACalculator.AddParameter("param_diff_period_i", DiffPeriod);
            ACalculator.AddParameter("param_start_period_i", 0);
            ACalculator.AddParameter("param_end_period_i", 0);

            ACalculator.AddParameter("param_account_hierarchy_c", this.cmbAccountHierarchy.GetSelectedString());

            String CurrencyName = "";

            String CurrencySelection = this.cmbCurrency.GetSelectedString();

            ACalculator.AddParameter("param_currency", CurrencySelection);

            if (CurrencySelection == Catalog.GetString("Base"))
            {
                CurrencyName = FLedgerRow.BaseCurrency;
            }
            else if (CurrencySelection == Catalog.GetString("International"))
            {
                CurrencyName = FLedgerRow.IntlCurrency;
            }

            ACalculator.AddParameter("param_currency_name", CurrencyName);

            ACalculator.AddParameter("param_period", rbtPeriod.Checked);
            ACalculator.AddParameter("param_period_breakdown", rbtBreakdown.Checked && rbtBreakdown.Visible);

            ACalculator.AddParameter("param_period_checked", rbtPeriod.Checked);
            ACalculator.AddParameter("param_date_checked", rbtDate.Checked);
            ACalculator.AddParameter("param_quarter_checked", rbtQuarter.Checked);

            if (rbtQuarter.Checked)
            {
                Year = cmbQuarterYear.GetSelectedInt32();
                ACalculator.AddParameter("param_year_i", Year);
                ACalculator.AddParameter("param_real_year", cmbQuarterYear.GetSelectedString(1));
                ACalculator.AddParameter("param_real_year_ending", cmbPeriodYear.GetSelectedString(2));

                int Quarter = (Int32)StringHelper.TryStrToInt(txtQuarter.Text, 1);
                ACalculator.AddParameter("param_quarter", (System.Object)(Quarter));
                ACalculator.AddParameter("param_start_period_i", (System.Object)(Quarter * 3 - 2));
                ACalculator.AddParameter("param_end_period_i", (System.Object)(Quarter * 3));
                ACalculator.AddParameter("param_start_date",
                                         TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, Quarter * 3 - 2));
                EndDate = TRemote.MFinance.GL.WebConnectors.GetPeriodEndDate(FLedgerNumber, Year, DiffPeriod, Quarter * 3);
                ACalculator.AddParameter("param_end_date", EndDate);

                //VerificationResult = TFinancialPeriodChecks.ValidQuarter(DiffPeriod, Year, Quarter, "Quarter");
                if (AReportAction == TReportActionEnum.raGenerate)
                {
                    CheckQuarter(Year, Quarter);
                }

                dtpStartDate.Date = TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, (Quarter * 3 - 2));
                dtpEndDate.Date   = TRemote.MFinance.GL.WebConnectors.GetPeriodEndDate(FLedgerNumber, Year, DiffPeriod, Quarter * 3);
            }
            else if (rbtPeriod.Checked)
            {
                Year = cmbPeriodYear.GetSelectedInt32();
                ACalculator.AddParameter("param_year_i", Year);
                ACalculator.AddParameter("param_real_year", cmbPeriodYear.GetSelectedString(1));
                ACalculator.AddParameter("param_real_year_ending", cmbPeriodYear.GetSelectedString(2));

                int EndPeriod = (Int32)StringHelper.TryStrToInt(txtEndPeriod.Text, 1);
                ACalculator.AddParameter("param_end_period_i", EndPeriod);
                StartDate = TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, EndPeriod);
                ACalculator.AddParameter("param_start_date", StartDate);
                EndDate = TRemote.MFinance.GL.WebConnectors.GetPeriodEndDate(FLedgerNumber, Year, DiffPeriod, EndPeriod);
                ACalculator.AddParameter("param_end_date", EndDate);

                CheckPeriod(Year, EndPeriod);
                dtpEndDate.Date = TRemote.MFinance.GL.WebConnectors.GetPeriodEndDate(FLedgerNumber, Year, DiffPeriod, EndPeriod);

                if (!OnlyEndPeriodShown)
                {
                    int StartPeriod = (Int32)StringHelper.TryStrToInt(txtStartPeriod.Text, 1);
                    ACalculator.AddParameter("param_start_period_i", StartPeriod);
                    ACalculator.AddParameter("param_start_date",
                                             TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, StartPeriod));

                    if (AReportAction == TReportActionEnum.raGenerate)
                    {
                        CheckPeriod(Year, StartPeriod);

                        if (StartPeriod > EndPeriod)
                        {
                            FPetraUtilsObject.AddVerificationResult(new TVerificationResult(
                                                                        Catalog.GetString("Start Period must not be bigger than End Period."),
                                                                        Catalog.GetString("Invalid Data entered."),
                                                                        TResultSeverity.Resv_Critical));
                        }
                    }

                    dtpStartDate.Date = TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, StartPeriod);
                }
            }
            else if (rbtDate.Checked)
            {
                if (dtpStartDate.Date.HasValue && dtpEndDate.Date.HasValue)
                {
                    if (dtpStartDate.Date.Value > dtpEndDate.Date.Value)
                    {
                        FPetraUtilsObject.AddVerificationResult(new TVerificationResult(
                                                                    Catalog.GetString("Start Date must not be later than End Date"),
                                                                    Catalog.GetString("Invalid Data entered."),
                                                                    TResultSeverity.Resv_Critical));
                    }
                    else
                    {
                        ACalculator.AddParameter("param_start_date", dtpStartDate.Date.Value);
                        EndDate = dtpEndDate.Date.Value;
                        ACalculator.AddParameter("param_end_date", EndDate);
                        ACalculator.AddParameter("param_real_year", dtpEndDate.Date.Value.Year);
                    }
                }
            }
            else if (rbtBreakdown.Checked)
            {
                Year = cmbBreakdownYear.GetSelectedInt32();
                ACalculator.AddParameter("param_real_year", cmbBreakdownYear.GetSelectedString(1));
                ACalculator.AddParameter("param_year_i", Year);
                ACalculator.AddParameter("param_start_date", TRemote.MFinance.GL.WebConnectors.GetPeriodStartDate(FLedgerNumber, Year, DiffPeriod, 1));
                EndDate = TRemote.MFinance.GL.WebConnectors.GetPeriodEndDate(FLedgerNumber, Year, DiffPeriod, 12);
                ACalculator.AddParameter("param_end_date", EndDate);
            }

            // true if the selected date is in the current financial year
            ACalculator.AddParameter("param_current_financial_year", FLedgerRow.CurrentFinancialYear == Year);

            //
            // I may need to check whether the selected currency has an exchange rate I can use!

            if (CurrencyName == FLedgerRow.IntlCurrency)
            {
                Decimal IntlRate = TExchangeRateCache.GetDailyExchangeRate(FLedgerRow.BaseCurrency, FLedgerRow.IntlCurrency, EndDate);

                if (IntlRate == 0) // No exchange rate has been specified
                {
                    FPetraUtilsObject.AddVerificationResult(new TVerificationResult(
                                                                Catalog.GetString("International Exchange Rate"),
                                                                Catalog.GetString("No Exchange Rate is available for the requested period."),
                                                                TResultSeverity.Resv_Critical));
                }
            }

            if (Year < 0)
            {
                FPetraUtilsObject.AddVerificationResult(new TVerificationResult(
                                                            Catalog.GetString("Accounting Year was not specified"),
                                                            Catalog.GetString("Invalid Data entered."),
                                                            TResultSeverity.Resv_Critical));
            }
        }