private void grdCommitmentStatusChoices_ReadControls(TRptCalculator ACalc, TReportActionEnum AReportAction) { // TODO // The reason that the status choices listbox is not // filled in with saved data is that Parameter.Save() // and Parameter.Load() do not use // TVariant.EncodeToString() and // TVariant.DecodeFromString() when storing a saved set // of parameters. Composites survive fine over the // remoting interface, though. I (binki) am allowed to // change the behavior of TParameterList.Save() and // TParameterList.Load() _if_ I change the // XmlReports/Settings/.../standard.xml files to support // DecodeFromString(). TVariant param_grdCommitmentStatusChoices = new TVariant(); foreach (DataRow ARow in FCommitmentStatusTable.Rows) { if ((bool)ARow["Selection"]) { param_grdCommitmentStatusChoices.Add(new TVariant((String)ARow[PmCommitmentStatusTable.GetCodeDBName()]), "", false); } } ACalc.AddParameter("param_commitment_status_choices", param_grdCommitmentStatusChoices); }
public static List <TVariant>TestPostGLBatch(Int32 ALedgerNumber, Int32 ABatchNumber, out TVerificationResultCollection AVerifications) { GLPostingTDS MainDS = null; TVerificationResultCollection Verifications = null; int BatchPeriod = -1; TDBTransaction Transaction = null; bool SubmissionOK = false; bool Success = false; DBAccess.GDBAccessObj.BeginAutoTransaction(IsolationLevel.Serializable, ref Transaction, ref SubmissionOK, delegate { Success = TGLPosting.TestPostGLBatch(ALedgerNumber, ABatchNumber, Transaction, out Verifications, out MainDS, ref BatchPeriod); }); AVerifications = Verifications; List <TVariant>Result = new List <TVariant>(); if (Success) { MainDS.AGeneralLedgerMaster.DefaultView.RowFilter = string.Empty; MainDS.AAccount.DefaultView.RowFilter = string.Empty; MainDS.ACostCentre.DefaultView.RowFilter = string.Empty; MainDS.AGeneralLedgerMaster.DefaultView.Sort = AGeneralLedgerMasterTable.GetGlmSequenceDBName(); MainDS.ACostCentre.DefaultView.Sort = ACostCentreTable.GetCostCentreCodeDBName(); MainDS.AAccount.DefaultView.Sort = AAccountTable.GetAccountCodeDBName(); foreach (AGeneralLedgerMasterPeriodRow glmpRow in MainDS.AGeneralLedgerMasterPeriod.Rows) { if ((glmpRow.PeriodNumber == BatchPeriod) && (glmpRow.RowState != DataRowState.Unchanged)) { AGeneralLedgerMasterRow masterRow = (AGeneralLedgerMasterRow)MainDS.AGeneralLedgerMaster.Rows.Find(glmpRow.GlmSequence); ACostCentreRow ccRow = (ACostCentreRow)MainDS.ACostCentre.Rows.Find(new object[] { ALedgerNumber, masterRow.CostCentreCode }); // only consider the posting cost centres // TODO or consider only the top cost centre? if (ccRow.PostingCostCentreFlag) { AAccountRow accRow = (AAccountRow) MainDS.AAccount.DefaultView[MainDS.AAccount.DefaultView.Find(masterRow.AccountCode)].Row; // only modified accounts have been loaded to the dataset, therefore report on all accounts available if (accRow.PostingStatus) { decimal CurrentValue = 0.0m; if (glmpRow.RowState == DataRowState.Modified) { CurrentValue = (decimal)glmpRow[AGeneralLedgerMasterPeriodTable.ColumnActualBaseId, DataRowVersion.Original]; } decimal DebitCredit = 1.0m; if (accRow.DebitCreditIndicator && (accRow.AccountType != MFinanceConstants.ACCOUNT_TYPE_ASSET) && (accRow.AccountType != MFinanceConstants.ACCOUNT_TYPE_EXPENSE)) { DebitCredit = -1.0m; } // only return values, the client compiles the message, with Catalog.GetString TVariant values = new TVariant(accRow.AccountCode); values.Add(new TVariant(accRow.AccountCodeShortDesc), "", false); values.Add(new TVariant(ccRow.CostCentreCode), "", false); values.Add(new TVariant(ccRow.CostCentreName), "", false); values.Add(new TVariant(CurrentValue * DebitCredit), "", false); values.Add(new TVariant(glmpRow.ActualBase * DebitCredit), "", false); Result.Add(values); } } } } } return Result; }
public void TestVariantComposite() { CultureInfo oldCulture; TVariant v; TVariant v2; TVariant v3; String encodedString; String s; oldCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = new CultureInfo("en-GB", false); v = new TVariant("test"); Assert.AreEqual("eString:test", v.EncodeToString(), "before EncodeToString1"); v.Add(new TVariant(true)); Assert.AreEqual("eComposite::\"eString:test|eBoolean:true\"", v.EncodeToString(), "EncodeToString1"); v.Add(new TVariant(2.23M, "Currency")); v.Add(new TVariant(2.23M)); v.Add(new TVariant(2)); Assert.AreEqual( "eComposite::\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2\"", v.EncodeToString(), "EncodeToString2"); v.Add(new TVariant(" test ")); Assert.AreEqual( "eComposite::\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|eString: test \"", v.EncodeToString(), "EncodeToString3"); v.Add(new TVariant(new DateTime(2004, 03, 29))); v2 = new TVariant(v); // copy constructor Assert.AreEqual( "eComposite::\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|eString: test |\"\"eDateTime:\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"", v2.EncodeToString(), "EncodeToString4"); Assert.AreEqual("eComposite::\"eString:test|eBoolean:true\"", TVariant.DecodeFromString( "eComposite::\"eString:test|eBoolean:true\"").EncodeToString(), "DecodeFromString"); Assert.AreEqual("eComposite::\"eString: test |eBoolean:true\"", TVariant.DecodeFromString( "eComposite::\"eString: test |eBoolean:true\"").EncodeToString(), "DecodeFromString with spaces in string"); Assert.AreEqual(v2.EncodeToString(), TVariant.DecodeFromString(v2.EncodeToString()).EncodeToString(), "DecodeFromString2"); v = new TVariant(); v.Add(new TVariant(2)); Assert.AreEqual(2.00, v.ToDouble(), "Variant Composite Double"); v.Add(new TVariant(" test ")); v3 = new TVariant(); v3.Add(new TVariant(1)); v3.Add(v); v3.Add(v2); s = "eInteger:1|\"eComposite::\"\"eInteger:2|\"\"\"\"eString:\"\"\"\"\"\"\"\" test \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"|\"eComposite::\"\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|\"\"\"\"eString:\"\"\"\"\"\"\"\" test \"\"\"\"\"\"\"\"\"\"\"\"|\"\"\"\"eDateTime:\"\"\"\"\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"\"\"\"\"\"\"\"\""; Assert.AreEqual("eInteger:1", StringHelper.GetNextCSV(ref s, "|"), "split composite CSV 1"); Assert.AreEqual("eComposite::\"eInteger:2|\"\"eString:\"\"\"\" test \"\"\"\"\"\"\"", StringHelper.GetNextCSV(ref s, "|"), "split composite CSV 2"); Assert.AreEqual( "\"eComposite::\"\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|\"\"\"\"eString:\"\"\"\"\"\"\"\" test \"\"\"\"\"\"\"\"\"\"\"\"|\"\"\"\"eDateTime:\"\"\"\"\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"", s, "split composite CSV 4"); Assert.AreEqual( "eComposite::\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|\"\"eString:\"\"\"\" test \"\"\"\"\"\"|\"\"eDateTime:\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"", StringHelper.GetNextCSV(ref s, "|"), "split composite CSV 6"); Assert.AreEqual( "eComposite::\"eInteger:1|\"\"eComposite::\"\"\"\"eInteger:2|eString: test \"\"\"\"\"\"|\"\"eComposite::\"\"\"\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|eString: test |\"\"\"\"\"\"\"\"eDateTime:\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"", v3.EncodeToString(), "EncodeToString1 with Composite containing Composite"); Assert.AreEqual(v3.EncodeToString(), TVariant.DecodeFromString( v3.EncodeToString()).EncodeToString(), "DecodeFromString with Composite containing Composite"); v = new TVariant(); v.Add(new TVariant(2)); v.Add(new TVariant(" test")); v3 = new TVariant(); v3.Add(v); v3.Add(v2); Assert.AreEqual( "eComposite::\"eInteger:2|eString: test|\"\"eComposite::\"\"\"\"eString:test|eBoolean:true|eCurrency:Currency:4612203932384535511|eDecimal:4612203932384535511|eInteger:2|eString: test |\"\"\"\"\"\"\"\"eDateTime:\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"2004-03-29T00:00:00\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"", v3.EncodeToString(), "EncodeToString2 with Composite containing Composite"); Assert.AreEqual(v3.EncodeToString(), TVariant.DecodeFromString( v3.EncodeToString()).EncodeToString(), "DecodeFromString with Composite containing Composite"); v = new TVariant("test\"1"); v.Add(new TVariant(" test\"2")); v2 = new TVariant("test\"3"); v2.Add(new TVariant("test\"4")); Assert.AreEqual("eString:\"test\"\"3test\"\"4\"", v2.EncodeToString(), "Test Cascading Composite 1"); Assert.AreEqual("eString:\"test\"\"3test\"\"4\"", TVariant.DecodeFromString( v2.EncodeToString()).EncodeToString(), "Test Cascading Composite 2"); v.Add(v2); Assert.AreEqual("eString:\"test\"\"1 test\"\"2test\"\"3test\"\"4\"", v.EncodeToString(), "Test Cascading Composite 3"); Assert.AreEqual("eString:\"test\"\"1 test\"\"2test\"\"3test\"\"4\"", TVariant.DecodeFromString( v.EncodeToString()).EncodeToString(), "Test Cascading Composite 4"); v = new TVariant("test1\""); v.Add(new TVariant(" test2\"")); v2 = new TVariant(); v2.Add(new TVariant("2900")); v.Add(v2); v.Add(new TVariant("test3")); Assert.AreEqual("eComposite::\"\"\"eString:\"\"\"\"test1\"\"\"\"\"\"\"\" test2\"\"\"\"\"\"\"\"\"\"\"\"\"\"|eInteger:2900|eString:test3\"", v.EncodeToString(), "Test Cascading Composite2"); Assert.AreEqual("eString:\"\"\" ) ))\"", TVariant.DecodeFromString("eString:\"\"\" ) ))\"").EncodeToString(), "problem decoding string"); v = new TVariant(); v.Add(new TVariant("test\"")); v.Add(new TVariant("2900")); v.Add(new TVariant("test")); Assert.AreEqual("eComposite::\"\"\"eString:\"\"\"\"test\"\"\"\"\"\"\"\"\"\"\"\"\"\"|eInteger:2900|eString:test\"", v.EncodeToString(), "problem encoding 1b"); Assert.AreEqual(v.EncodeToString(), TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "problem encoding1a"); v = new TVariant(); v.Add(new TVariant("SELECT DISTINCT WHERE ( ( cc.a_cost_centre_code_c = \"")); v.Add(new TVariant("2900")); v.Add(new TVariant("\" ) ))")); encodedString = "eComposite::\"\"\"eString:\"\"\"\"SELECT DISTINCT " + " WHERE ( ( cc.a_cost_centre_code_c = \"\"\"\"\"\"\"\"\"\"\"\"\"\"|eInteger:2900|\"\"eString:\"\"\"\"\"\"\"\"\"\"\"\" ) ))\"\"\"\"\"\"\""; Assert.AreEqual(encodedString, v.EncodeToString(), "problem encoding1"); Assert.AreEqual(v.EncodeToString(), TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "problem encoding2"); Assert.AreEqual(encodedString, TVariant.DecodeFromString(encodedString).EncodeToString(), "problem encoding3"); v = new TVariant(); v.Add(new TVariant("29001234", "partnerkey")); v.Add(new TVariant("29001235", "partnerkey")); v.Add(new TVariant("29001236", "partnerkey")); v.FormatString = "csvlistslash"; Assert.AreEqual("eComposite:csvlistslash:\"eInteger:partnerkey:29001234|eInteger:partnerkey:29001235|eInteger:partnerkey:29001236\"", v.EncodeToString(), "format list with slash separator 1"); Assert.AreEqual("0029001234/0029001235/0029001236", v.ToFormattedString(""), "format list with slash separator 2"); v = new TVariant(435082450); Assert.AreEqual("eInteger:435082450", v.EncodeToString(), "test integer with text format 1"); v.ApplyFormatString("text"); Assert.AreEqual("eString:text:435082450", v.EncodeToString(), "test integer with text format 2"); Assert.AreEqual("eString:text:435082450", TVariant.DecodeFromString( v.EncodeToString()).EncodeToString(), "test integer with text format 3"); v2 = new TVariant(v); Assert.AreEqual("eString:text:435082450", v2.EncodeToString(), "test integer with text format 4"); v = new TVariant(); v.Add(new TVariant((Object)(29015041.0))); v.Add(new TVariant((Object)(29017453.0))); Assert.AreEqual("eComposite:Currency:\"eCurrency:Currency:4718553875991232512|eCurrency:Currency:4718554523457552384\"", v.EncodeToString(), "test composite partner key"); Assert.AreEqual("eComposite:Currency:\"eCurrency:Currency:4718553875991232512|eCurrency:Currency:4718554523457552384\"", TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "test composite partner key 4"); v.ApplyFormatString("csvlistslash:partnerkey"); Assert.AreEqual("eComposite:csvlistslash:\"eInt64:partnerkey:29015041|eInt64:partnerkey:29017453\"", v.EncodeToString(), "test composite partner key 2"); Assert.AreEqual("0029015041/0029017453", v.ToFormattedString(" "), "test composite partner key 3"); v = TVariant.DecodeFromString("eComposite:csvlistslash:\"eString:text:de Vries, Rianne|eString:text:Visser, W. and K.K.J.\""); Assert.AreEqual("de Vries, Rianne/Visser, W. and K.K.J.", v.ToFormattedString("")); Assert.AreEqual("de Vries, Rianne/Visser, W. and K.K.J.", v.ToFormattedString("", "CSV")); v = new TVariant(); v.Add(new TVariant("From Gift-Batch#: ")); v.Add(new TVariant(8351)); Assert.AreEqual("From Gift-Batch#: 8351", v.ToFormattedString(""), "colon in text"); Assert.AreEqual("eComposite::\"\"\"eString:\"\"\"\"From Gift-Batch#: \"\"\"\"\"\"|eInteger:8351\"", v.EncodeToString(), "colon in text2"); Assert.AreEqual("From Gift-Batch#: 8351", TVariant.DecodeFromString(v.EncodeToString()).ToFormattedString(""), "colon in text3"); v = new TVariant(); v.Add(new TVariant("Total for Account ")); v.Add(new TVariant(1000)); v.Add(new TVariant(':')); Assert.AreEqual("Total for Account 1000:", v.ToFormattedString(), "colon in text on its own"); Assert.AreEqual(v.EncodeToString(), TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "colon in text on its own 2"); Assert.AreEqual(TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), v.EncodeToString(), "Composite with two empty strings encoding decoding encoding"); v = new TVariant(); v.Add(new TVariant("t"), "", false); v.Add(new TVariant("|"), "", false); Assert.AreEqual("eComposite::\"eString:t|\"\"eString:|\"\"\"", v.EncodeToString(), "Composite with pipe encoding"); Assert.AreEqual(TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), v.EncodeToString(), "Composite with pipe encoding decoding encoding"); v = new TVariant("", true); Assert.AreEqual("eString:text:", v.EncodeToString(), "empty string encoding"); Assert.AreEqual(v.EncodeToString(), TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "empty string decoding"); Assert.AreEqual(v.ToString(), "", "empty string identity"); Assert.AreEqual("", TVariant.DecodeFromString(v.EncodeToString()).ToString(), "empty string decoding identity"); Assert.AreEqual(eVariantTypes.eString, TVariant.DecodeFromString(v.EncodeToString()).TypeVariant, "empty string decoding type"); v = new TVariant(" ", true); Assert.AreEqual(v.ToString(), " ", "one-space string identity"); Assert.AreEqual("eString:text: ", v.EncodeToString(), "one-space string encoding"); Assert.AreEqual(v.EncodeToString(), TVariant.DecodeFromString(v.EncodeToString()).EncodeToString(), "one-space string decoding"); Assert.AreEqual(" ", TVariant.DecodeFromString(v.EncodeToString()).ToString(), "one-space string decoding identity"); Assert.AreEqual(eVariantTypes.eString, TVariant.DecodeFromString(v.EncodeToString()).TypeVariant, "one-space string decoding type"); Thread.CurrentThread.CurrentCulture = oldCulture; }
public void TestVariantCurrencies() { CultureInfo oldCulture; ArrayList cultures; String DecimalSeparator; String ThousandsOperator; TVariant v; oldCulture = Thread.CurrentThread.CurrentCulture; cultures = new ArrayList(); cultures.Add("en-GB"); cultures.Add("en-US"); cultures.Add("de-DE"); /* opposite meaning of , and . */ cultures.Add("ru-RU"); /* funny thousand separator: space */ foreach (string s in cultures) { Thread.CurrentThread.CurrentCulture = new CultureInfo(s, false); DecimalSeparator = CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator; ThousandsOperator = CultureInfo.CurrentCulture.NumberFormat.CurrencyGroupSeparator; Assert.AreEqual("#,##0;(#,##0);0;0", StringHelper.GetFormatString("Currency", "CurrencyWithoutDecimals"), "find correct format string, CurrencyWithoutDecimals"); Assert.AreEqual("#,#;(#,#);0;0", StringHelper.GetFormatString("Currency", "CurrencyThousands"), "find correct format string thousands"); Assert.AreEqual("#,##0.00;(#,##0.00);0.00;0", StringHelper.GetFormatString("", "Currency"), "Problem currency string"); /* console.writeLine(CultureInfo.CurrentCulture.TwoLetterISOLanguageName); */ Assert.AreEqual("0", new TVariant(0.00M, "Currency").ToFormattedString( "CurrencyWithoutDecimals"), "format currency 0 without decimals"); Assert.AreEqual("0", new TVariant(0.00M, "Currency").ToFormattedString("CurrencyThousands"), "format currency 0 thousands"); Assert.AreEqual("0", new TVariant(0.00M, "->>>,>>>,>>>,>>9.99").ToFormattedString( "CurrencyWithoutDecimals"), "format progress currency 0 without decimals"); Assert.AreEqual("0", new TVariant(0.00M, "->>>,>>>,>>>,>>9.99").ToFormattedString( "CurrencyThousands"), "format progress currency 0 thousands"); Assert.AreEqual("", new TVariant("", true).ToFormattedString( "Currency"), "format empty string in the column heading of a column that has currency values"); Assert.AreEqual("eString:text:", new TVariant(new TVariant("", true)).EncodeToString(), "format empty string in the column heading of a column that has currency values 2"); Assert.AreEqual("", new TVariant(new TVariant("", true)).ToFormattedString( "Currency"), "format empty string in the column heading of a column that has currency values 3"); Assert.AreEqual("eString:text:", new TVariant("", true).EncodeToString(), "format empty string in the column heading of a column that has currency values 4"); v = new TVariant("", true); Assert.AreEqual("eString:text:", v.EncodeToString(), "format empty string in the column heading of a column that has currency values 5"); v = new TVariant(); v.Add(new TVariant("", true)); Assert.AreEqual("eEmpty:text:", v.EncodeToString(), "format empty string in the column heading of a column that has currency values 6"); Assert.AreEqual("", v.ToFormattedString( "Currency"), "format empty string in the column heading of a column that has currency values 7"); v = new TVariant(); v.ApplyFormatString("partnerkey"); Assert.AreEqual("eInt64:partnerkey:-1", v.EncodeToString(), "format empty partnerkey 1"); Assert.AreEqual("0000000000", v.ToFormattedString(), "format empty partnerkey 2"); v = new TVariant(0.00M, "Currency"); v.ApplyFormatString("partnerkey"); Assert.AreEqual("eInt64:partnerkey:0", v.EncodeToString(), "format empty partnerkey 3"); Assert.AreEqual("0000000000", v.ToFormattedString(), "format empty partnerkey 4"); Assert.AreEqual("100" + DecimalSeparator + "00%", TVariant.DecodeFromString( "eDecimal:percentage2decimals:4636737291354636288").ToFormattedString(), "format percentage"); v = new TVariant(-1003.25M, "Currency"); Assert.AreEqual("eCurrency:Currency:-4571336140711264256", v.EncodeToString(), "format negative number with format that only prints negative values 1"); Assert.AreEqual("(1" + ThousandsOperator + "003" + DecimalSeparator + "25)", v.ToFormattedString(), "format negative number with format that only prints negative values 2"); v.ApplyFormatString("#,##0.00; ; ; ;"); Assert.AreEqual("eEmpty:#,##0.00; ; ; ;:", v.EncodeToString(), "format negative number with format that only prints negative values 3"); Assert.AreEqual("", v.ToFormattedString(), "format negative number with format that only prints negative values 4"); Assert.AreEqual("12" + ThousandsOperator + "346", new TVariant(12345.67M, "Currency").ToFormattedString( "CurrencyWithoutDecimals"), "Problem D format currency"); Assert.AreEqual("eCurrency:Currency:4668012718187306025", new TVariant(12345.67M, "Currency").EncodeToString(), "Problem E format currency"); Assert.AreEqual("12" + ThousandsOperator + "345" + DecimalSeparator + "67", StringHelper.FormatCurrency(new TVariant(12345.67), "Currency"), "Problem F format currency"); Assert.AreEqual("12345" + DecimalSeparator + "67", new TVariant(12345.67).ToString(), "Problem G format currency"); Assert.AreEqual("12" + ThousandsOperator + "345" + DecimalSeparator + "67", TVariant.DecodeFromString(new TVariant(12345.67M, "Currency").EncodeToString()).ToFormattedString( "Currency"), "Problem H format currency"); Assert.AreEqual("12", TVariant.DecodeFromString(new TVariant(12345.67M, "Currency").EncodeToString()).ToFormattedString( "CurrencyThousands"), "Problem I format currency"); Assert.AreEqual("12", TVariant.DecodeFromString(new TVariant(12345.67M, "CurrencyThousands").EncodeToString()).ToFormattedString( ""), "Problem J format currency"); Assert.AreEqual("12", TVariant.DecodeFromString(new TVariant(12345.67M, "#,##0.00;(#,##0.00);0.00;0").EncodeToString()).ToFormattedString( "CurrencyThousands"), "Problem J2 access format currency thousands"); /* we don't support thousands only with the progress format, too complicated */ /* Assert.AreEqual('12', TVariant.DecodeFromString(TVariant.CreateCurrency(12345.67,'>>>,>>>,>>>,>>9.99').EncodeToString("CurrencyThousands")).toFormattedString(''), 'Problem J3 progress format currency thousands'); */ Assert.AreEqual("12" + ThousandsOperator + "346", TVariant.DecodeFromString(new TVariant(12345.67M, "#,##0.00;(#,##0.00);0.00;0").EncodeToString()).ToFormattedString( "CurrencyWithoutDecimals"), "Problem J2 access format currency w/o decimals"); Assert.AreEqual("12" + ThousandsOperator + "346", TVariant.DecodeFromString(new TVariant(12345.67M, "->>>,>>>,>>>,>>9.99").EncodeToString()).ToFormattedString( "CurrencyWithoutDecimals"), "Problem J3 progress format currency w/o decimals"); Assert.AreEqual("12" + ThousandsOperator + "346", TVariant.DecodeFromString(new TVariant(12345.67M, "CurrencyWithoutDecimals").EncodeToString()).ToFormattedString( ""), "Problem K format currency"); } Thread.CurrentThread.CurrentCulture = oldCulture; }
/// <summary> /// todoComment /// </summary> /// <param name="rptGrpValue"></param> /// <param name="AWithSpaceBetweenValues"></param> /// <returns></returns> public TVariant Calculate(List <TRptValue>rptGrpValue, Boolean AWithSpaceBetweenValues) { TVariant ReturnValue; String listValue; String listText; Boolean first; TRptDataCalcCalculation rptDataCalcCalculation; ReturnValue = new TVariant(); foreach (TRptValue rptValue in rptGrpValue) { if (EvaluateCondition(rptValue.strCondition)) { if ((AWithSpaceBetweenValues == true) && (ReturnValue.TypeVariant != eVariantTypes.eEmpty)) { ReturnValue.Add(new TVariant(' ')); } if (rptValue.strFunction == "csv") { // this is only for sql queries listValue = Parameters.Get(rptValue.strVariable, column, Depth).ToString(); if ((listValue.Length > 3) && (listValue.Substring(0, 4) == "CSV:")) { listValue = listValue.Substring(4); } first = true; ReturnValue.Add(new TVariant(" (")); if (listValue.Length == 0) { // this would make the sql query invalid; so insert a false condition to at least make it run, and return no records ReturnValue.Add(new TVariant(" 1 = 0 ")); } while (listValue.Length != 0) { bool IsFirstPair = true; string value = StringHelper.GetNextCSV(ref listValue).Trim(); if (first) { first = false; } else { ReturnValue.Add(new TVariant(" OR ")); } if (rptValue.strText.IndexOf(',') != -1) { // there are two things to compare (e.g. motivation group and motivation detail) // motivation group and detail come in pairs, separated by comma, enclosed by quotes (getNextCSV strips the quotes) string valuePair = value; listText = rptValue.strText; string calculationText = rptValue.strCalculation; // if the format is defined in the xml file, it overwrites the value we get from (new TVariant(value).TypeVariant == eVariantTypes.xxx bool ValueIsNumber = (rptValue.strFormat == "Number"); bool ValueIsText = (rptValue.strFormat == "Text"); ReturnValue.Add(new TVariant('(')); while (listText.Length != 0) { if (IsFirstPair) { // we have taken out the first value already from listValue value = valuePair; IsFirstPair = false; } else { value = StringHelper.GetNextCSV(ref listValue).Trim(); } if (listText.Length < rptValue.strText.Length) { if (calculationText.Length > 0) { ReturnValue.Add(new TVariant(" " + calculationText + " ")); } else { ReturnValue.Add(new TVariant(" AND ")); } } //todo: allow integer as well; problem with motivation detail codes that are just numbers; //todo: specify type with text, variable names and type //if (new TVariant(value).TypeVariant == eVariantTypes.eString) if (!ValueIsNumber || ValueIsText) { ReturnValue.Add(new TVariant(StringHelper.GetNextCSV(ref listText).Trim() + " = '")); ReturnValue.Add(new TVariant(value)); ReturnValue.Add(new TVariant("' ")); } else { ReturnValue.Add(new TVariant(StringHelper.GetNextCSV(ref listText).Trim() + " = ")); ReturnValue.Add(new TVariant(value)); ReturnValue.Add(new TVariant(' ')); } } ReturnValue.Add(new TVariant(')')); } else { // if the format is defined in the xml file, it overwrites the value we get from (new TVariant(value).TypeVariant == eVariantTypes.xxx bool ValueIsNumber = (rptValue.strFormat == "Number"); bool ValueIsText = (rptValue.strFormat == "Text"); if ((ValueIsText || (new TVariant(value).TypeVariant == eVariantTypes.eString)) && !ValueIsNumber) { ReturnValue.Add(new TVariant(' ' + rptValue.strText + " = '")); ReturnValue.Add(new TVariant(value)); ReturnValue.Add(new TVariant("' ")); } else { ReturnValue.Add(new TVariant(' ' + rptValue.strText + " = ")); ReturnValue.Add(new TVariant(value)); ReturnValue.Add(new TVariant(' ')); } } } ReturnValue.Add(new TVariant(") ")); } else { if (rptValue.strText.Length != 0) { ReturnValue.Add(new TVariant(rptValue.strText), rptValue.strFormat); } if (rptValue.strVariable.Length != 0) { ReturnValue.Add(Parameters.Get(rptValue.strVariable, column, Depth), rptValue.strFormat); } if (rptValue.strCalculation.Length != 0) { rptDataCalcCalculation = new TRptDataCalcCalculation(this); ReturnValue.Add(rptDataCalcCalculation.EvaluateHelperCalculation(rptValue.strCalculation), rptValue.strFormat); } if (rptValue.strFunction.Length != 0) { ReturnValue.Add(EvaluateFunctionString(rptValue.strFunction), rptValue.strFormat); } } } } return ReturnValue; }
public static List <TVariant>TestPostGLBatch(Int32 ALedgerNumber, Int32 ABatchNumber, out TVerificationResultCollection AVerifications) { #region Validate Arguments if (ALedgerNumber <= 0) { throw new EFinanceSystemInvalidLedgerNumberException(String.Format(Catalog.GetString( "Function:{0} - The Ledger number must be greater than 0!"), Utilities.GetMethodName(true)), ALedgerNumber); } else if (ABatchNumber <= 0) { throw new EFinanceSystemInvalidBatchNumberException(String.Format(Catalog.GetString( "Function:{0} - The Batch number must be greater than 0!"), Utilities.GetMethodName(true)), ALedgerNumber, ABatchNumber); } #endregion Validate Arguments GLPostingTDS MainDS = null; TVerificationResultCollection Verifications = null; int BatchPeriod = -1; TDBTransaction Transaction = null; bool SubmissionOK = false; bool Success = false; try { DBAccess.GDBAccessObj.BeginAutoTransaction(IsolationLevel.Serializable, ref Transaction, ref SubmissionOK, delegate { Success = TGLPosting.TestPostGLBatch(ALedgerNumber, ABatchNumber, Transaction, out Verifications, out MainDS, ref BatchPeriod); }); } catch (Exception ex) { TLogging.Log(String.Format("Method:{0} - Unexpected error!{1}{1}{2}", Utilities.GetMethodSignature(), Environment.NewLine, ex.Message)); throw ex; } AVerifications = Verifications; List <TVariant>Result = new List <TVariant>(); if (Success) { MainDS.AGeneralLedgerMaster.DefaultView.RowFilter = string.Empty; MainDS.AGeneralLedgerMaster.DefaultView.Sort = AGeneralLedgerMasterTable.GetGlmSequenceDBName(); MainDS.AAccount.DefaultView.RowFilter = string.Empty; MainDS.AAccount.DefaultView.Sort = AAccountTable.GetAccountCodeDBName(); MainDS.ACostCentre.DefaultView.RowFilter = string.Empty; MainDS.ACostCentre.DefaultView.Sort = ACostCentreTable.GetCostCentreCodeDBName(); foreach (AGeneralLedgerMasterPeriodRow glmpRow in MainDS.AGeneralLedgerMasterPeriod.Rows) { if ((glmpRow.PeriodNumber == BatchPeriod) && (glmpRow.RowState != DataRowState.Unchanged)) { AGeneralLedgerMasterRow masterRow = (AGeneralLedgerMasterRow)MainDS.AGeneralLedgerMaster.Rows.Find(glmpRow.GlmSequence); #region Validate Data 1 if ((MainDS.AGeneralLedgerMaster == null) || (MainDS.AGeneralLedgerMaster.Count == 0) || (masterRow == null)) { throw new EFinanceSystemDataTableReturnedNoDataException(String.Format(Catalog.GetString( "Function:{0} - General Ledger Master data for GLM sequence {1} does not exist or could not be accessed!"), Utilities.GetMethodName(true), glmpRow.GlmSequence)); } #endregion Validate Data 1 ACostCentreRow ccRow = (ACostCentreRow)MainDS.ACostCentre.Rows.Find(new object[] { ALedgerNumber, masterRow.CostCentreCode }); #region Validate Data 2 if ((MainDS.ACostCentre == null) || (MainDS.ACostCentre.Count == 0) || (ccRow == null)) { throw new EFinanceSystemDataTableReturnedNoDataException(String.Format(Catalog.GetString( "Function:{0} - Cost Centre data for Cost Centre {1} does not exist or could not be accessed!"), Utilities.GetMethodName(true), masterRow.CostCentreCode)); } #endregion Validate Data 2 // only consider the posting cost centres // TODO or consider only the top cost centre? if (ccRow.PostingCostCentreFlag) { AAccountRow accRow = (AAccountRow) MainDS.AAccount.DefaultView[MainDS.AAccount.DefaultView.Find(masterRow.AccountCode)].Row; #region Validate Data 3 if ((MainDS.AAccount == null) || (MainDS.AAccount.Count == 0) || (accRow == null)) { throw new EFinanceSystemDataTableReturnedNoDataException(String.Format(Catalog.GetString( "Function:{0} - Account data for Account {1} does not exist or could not be accessed!"), Utilities.GetMethodName(true), masterRow.AccountCode)); } #endregion Validate Data 3 // only modified accounts have been loaded to the dataset, therefore report on all accounts available if (accRow.PostingStatus) { decimal CurrentValue = 0.0m; if (glmpRow.RowState == DataRowState.Modified) { CurrentValue = (decimal)glmpRow[AGeneralLedgerMasterPeriodTable.ColumnActualBaseId, DataRowVersion.Original]; } decimal DebitCredit = 1.0m; if (accRow.DebitCreditIndicator && (accRow.AccountType != MFinanceConstants.ACCOUNT_TYPE_ASSET) && (accRow.AccountType != MFinanceConstants.ACCOUNT_TYPE_EXPENSE)) { DebitCredit = -1.0m; } // only return values, the client compiles the message, with Catalog.GetString TVariant values = new TVariant(accRow.AccountCode); values.Add(new TVariant(accRow.AccountCodeShortDesc), "", false); values.Add(new TVariant(ccRow.CostCentreCode), "", false); values.Add(new TVariant(ccRow.CostCentreName), "", false); values.Add(new TVariant(CurrentValue * DebitCredit), "", false); values.Add(new TVariant(glmpRow.ActualBase * DebitCredit), "", false); Result.Add(values); } } } } } return Result; }
/// <summary> /// calculate the value of a switch /// </summary> /// <param name="rptSwitch"></param> /// <returns></returns> public TVariant Calculate(TRptSwitch rptSwitch) { TVariant ReturnValue; TRptDataCalcField rptDataCalcField; TRptDataCalcValue rptDataCalcValue; TRptDataCalcSwitch rptDataCalcSwitch; TRptCase rptCase; ReturnValue = new TVariant(); rptCase = GetFittingCase(rptSwitch); if (rptCase == null) { return ReturnValue; } if (rptCase.rptSwitch != null) { rptDataCalcSwitch = new TRptDataCalcSwitch(this); ReturnValue.Add(rptDataCalcSwitch.Calculate(rptCase.rptSwitch)); } else { if (rptCase.rptGrpField != null) { rptDataCalcField = new TRptDataCalcField(this); rptDataCalcField.Calculate(rptCase.rptGrpField); } if (rptCase.rptGrpValue != null) { rptDataCalcValue = new TRptDataCalcValue(this); ReturnValue.Add(rptDataCalcValue.Calculate(rptCase.rptGrpValue)); } } return ReturnValue; }
/// <summary> /// todoComment /// </summary> /// <param name="rptGrpFieldDetail"></param> /// <returns></returns> public TVariant Calculate(List <TRptFieldDetail>rptGrpFieldDetail) { TVariant ReturnValue; TRptDataCalcValue rptDataCalcValue; TRptDataCalcSwitch rptDataCalcSwitch; ReturnValue = new TVariant(); foreach (TRptFieldDetail rptFieldDetail in rptGrpFieldDetail) { if (EvaluateCondition(rptFieldDetail.strCondition)) { if (rptFieldDetail.rptGrpValue != null) { rptDataCalcValue = new TRptDataCalcValue(this); ReturnValue.Add(rptDataCalcValue.Calculate(rptFieldDetail.rptGrpValue)); } else { rptDataCalcSwitch = new TRptDataCalcSwitch(this); ReturnValue.Add(rptDataCalcSwitch.Calculate(rptFieldDetail.rptSwitch)); } } } return ReturnValue; }
/// <summary> /// this function can be used in calculations and other places as well /// </summary> public TVariant Calculate(List <TRptSwitch>rptGrpSwitch) { TVariant ReturnValue; ReturnValue = new TVariant(); foreach (TRptSwitch rptSwitch in rptGrpSwitch) { ReturnValue.Add(Calculate(rptSwitch)); } return ReturnValue; }
/// <summary> /// This procedure adds the returned values from the sql query to the Parameters, /// according to the returns attribute of the calculation /// </summary> /// <returns>void</returns> public void AddResultsToParameter(String AStrReturns, String AStrReturnsFormat, DataRow ARow, Int32 ADepth) { // the results of each column should be added to one variable per column String strReturns = AStrReturns; Boolean AddToList = AStrReturnsFormat.ToLower() == "list"; while (strReturns.Length != 0) { String strName = StringHelper.GetNextCSV(ref strReturns).Trim(); // in sqlite, eg. accountdetailcommon.xml, select j.a_transaction_currency_c will keep the j; other db's will remove the table name if (!ARow.Table.Columns.Contains(strName)) { foreach (DataColumn col in ARow.Table.Columns) { if (col.ColumnName.Contains("." + strName)) { strName = col.ColumnName; } } } TVariant value; // the parameters are stored first if (ARow[strName].GetType() == typeof(String)) { value = new TVariant(Convert.ToString(ARow[strName])); } else { value = new TVariant(ARow[strName]); } Boolean ClearParameter = true; if ((AddToList) && (!value.IsNil())) { TVariant newValue = new TVariant(Parameters.Get(strName, -1, ADepth)); newValue.Add(value, "", false); // no format given, that needs to be done in the column calculation or field value Parameters.Add(strName, newValue, -1, ADepth, null, null, ReportingConsts.CALCULATIONPARAMETERS); ClearParameter = false; } else { value.ApplyFormatString(AStrReturnsFormat); // only add values that are displayed on the sheet; required for the credit and debit columns on an account detail report; the sum would be wrong if (value.ToFormattedString().Length != 0) { if (value.IsNil()) { // eg. Sql Sum should return 0, not null. AStrReturnsFormat is Currency value = new TVariant(value.ToFormattedString()); } Parameters.Add(strName, value, -1, ADepth, null, null, ReportingConsts.CALCULATIONPARAMETERS); ClearParameter = false; } } if (ClearParameter == true) { // make sure that the variable is empty; otherwise the calculator would perhaps use the values from previous rows. // this is important for all columns that are directly based on results from the query Parameters.Add(strName, "", -1, ADepth, null, null, ReportingConsts.CALCULATIONPARAMETERS); } } }
/// <summary> /// todoComment /// </summary> /// <param name="rptCalculation"></param> /// <param name="rptGrpParameter"></param> /// <param name="rptGrpTemplate"></param> /// <param name="rptGrpQuery"></param> /// <returns></returns> public TVariant EvaluateCalculationAll(TRptCalculation rptCalculation, List <TRptParameter>rptGrpParameter, List <TRptQuery>rptGrpTemplate, List <TRptQuery>rptGrpQuery) { TVariant ReturnValue; TRptDataCalcValue rptDataCalcValue; TRptDataCalcSwitch rptDataCalcSwitch; ReturnValue = new TVariant(); if (rptGrpQuery == null) { return ReturnValue; } foreach (TRptQuery rptQuery in rptGrpQuery) { if (EvaluateCondition(rptQuery.strCondition)) { if (rptQuery.rptGrpValue != null) { rptDataCalcValue = new TRptDataCalcValue(this); if (!ReturnValue.IsZeroOrNull()) { ReturnValue.Add(new TVariant(" ")); } ReturnValue.Add(rptDataCalcValue.Calculate(rptQuery.rptGrpValue, true)); } if (rptQuery.rptGrpParameter != null) { // insert template with parameters ReturnValue.Add(new TVariant(" ")); ReturnValue.Add(EvaluateCalculationAll(rptCalculation, rptQuery.rptGrpParameter, null, rptGrpTemplate)); } if (rptQuery.rptGrpSwitch != null) { if (!ReturnValue.IsZeroOrNull()) { ReturnValue.Add(new TVariant(" ")); } rptDataCalcSwitch = new TRptDataCalcSwitch(this); ReturnValue.Add(new TVariant(rptDataCalcSwitch.Calculate(rptQuery.rptGrpSwitch))); } } } if ((ReturnValue.TypeVariant == eVariantTypes.eString) || (ReturnValue.ToString().IndexOf("{") != -1)) { ReturnValue = new TVariant(ApplyParametersToQuery(rptGrpParameter, ReturnValue.ToString()), true); // explicit string ReturnValue = ReplaceVariables(ReturnValue.ToString(), true); } // TLogging.log('Result of TRptDataCalcCalculation.evaluateCalculationAll: '+result.encodetostring()); return ReturnValue; }
/// <summary> /// todoComment /// </summary> /// <param name="calculation"></param> /// <returns></returns> public TVariant EvaluateHelperCalculation(String calculation) { TVariant ReturnValue; TRptCalculation rptCalculation; DataTable tab; string strReturns; Boolean firstRow; ReturnValue = new TVariant(); rptCalculation = ReportStore.GetCalculation(CurrentReport, calculation); if (rptCalculation == null) { TLogging.Log("calculation " + calculation + " could not be found."); return ReturnValue; } ReturnValue = Calculate(rptCalculation, null); if (ReturnValue.IsZeroOrNull() || (ReturnValue.ToString().Trim().ToUpper().IndexOf("SELECT") != 0)) { return ReturnValue; } if (rptCalculation.strReturnsFormat.ToLower() == "list") { // reset the variables, so we are able to start a new list strReturns = rptCalculation.strReturns; while (strReturns.Length != 0) { Parameters.Add(StringHelper.GetNextCSV(ref strReturns).Trim(), "", -1, Depth, null, null, ReportingConsts.CALCULATIONPARAMETERS); } } String strSql = ReturnValue.ToString(); strSql = ReplaceQuotesForSql(strSql, rptCalculation.strId); tab = DatabaseConnection.SelectDT(strSql, "EvaluateHelperCalculation", DatabaseConnection.Transaction); if ((tab == null) || (tab.Rows.Count == 0)) { // reset the variables, we don't want to display the results of the previous calculation strReturns = rptCalculation.strReturns; while (strReturns.Length != 0) { Parameters.Add(StringHelper.GetNextCSV(ref strReturns).Trim(), "", -1, Depth, null, null, ReportingConsts.CALCULATIONPARAMETERS); } } ReturnValue = new TVariant(); firstRow = true; foreach (DataRow row in tab.Rows) { if (!firstRow) { ReturnValue.Add(new TVariant(", ")); } firstRow = false; if (Convert.ToString(row[0]) != new TVariant(row[0]).ToString()) { ReturnValue.Add(new TVariant(Convert.ToString(row[0]))); } else { ReturnValue.Add(new TVariant(row[0])); } AddResultsToParameter(rptCalculation.strReturns, rptCalculation.strReturnsFormat, row, Depth); } return ReturnValue; }
/// <summary> /// This static function is used to create a variant with the correct type, /// when the variant is restored from an encoded string, /// that could e.g. be stored in a datatable (only strings) /// /// </summary> /// <returns>void</returns> public static TVariant DecodeFromString(String encodedValue) { TVariant ReturnValue; TVariant value; String typestr; String valuestr; String currencyFormat; String originalEncodedValue; String BeforeTryingFormat; String compositeEncodedValue; ReturnValue = new TVariant(); originalEncodedValue = encodedValue; try { typestr = StringHelper.GetNextCSV(ref encodedValue, ":"); currencyFormat = ""; if (typestr == eVariantTypes.eComposite.ToString()) { currencyFormat = StringHelper.GetNextCSV(ref encodedValue, ":"); valuestr = StringHelper.GetNextCSV(ref encodedValue, ":"); value = new TVariant(); while (valuestr.Length > 0) { compositeEncodedValue = StringHelper.GetNextCSV(ref valuestr, "|"); value.Add(DecodeFromString(compositeEncodedValue), "", false); // don't add strings up when decoding } } else { BeforeTryingFormat = encodedValue; currencyFormat = StringHelper.GetNextCSV(ref encodedValue, ":"); // if there was no format in the encoded value, undo the previous step if (encodedValue.Length == 0) { // there was no format encodedValue = BeforeTryingFormat; currencyFormat = ""; } valuestr = StringHelper.GetNextCSV(ref encodedValue, ":"); if (typestr == eVariantTypes.eDateTime.ToString()) { try { value = new TVariant(DateTime.ParseExact(valuestr, DATETIME_UNAMBIGUOUS_FORMAT, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeLocal)); } catch (Exception) { value = new TVariant(DateTime.MinValue); } value.FormatString = currencyFormat; } else if ((typestr == eVariantTypes.eDecimal.ToString()) || (typestr == "eDouble")) { value = new TVariant(BitConverter.Int64BitsToDouble(Convert.ToInt64(valuestr))); } else if (typestr == eVariantTypes.eCurrency.ToString()) { value = new TVariant((decimal)BitConverter.Int64BitsToDouble(Convert.ToInt64(valuestr)), "Currency"); } else if (typestr == eVariantTypes.eInteger.ToString()) { value = new TVariant(Convert.ToInt32(valuestr)); } else if (typestr == eVariantTypes.eInt64.ToString()) { value = new TVariant(Convert.ToInt64(valuestr)); } else if (typestr == eVariantTypes.eBoolean.ToString()) { value = new TVariant(Convert.ToBoolean(valuestr)); } else if (typestr == eVariantTypes.eString.ToString()) { value = new TVariant((String)valuestr, true); } else if (typestr == eVariantTypes.eEmpty.ToString()) { value = new TVariant(); } else { value = new TVariant(valuestr); } } value.FormatString = currencyFormat; ReturnValue = value; } catch (Exception e) { TLogging.Log("problem decoding " + originalEncodedValue + Environment.NewLine + e.Message); ReturnValue = new TVariant(); } return ReturnValue; }