/// <summary> /// format a date in a form that will be adjusted /// for each database in FormatQueryRDBMSSpecific; /// (correct order of month/day etc) /// </summary> /// <param name="value"></param> /// <returns></returns> public static TVariant FormatDate(TVariant value) { String list; String day; String month; String year; String resultString; if (value.TypeVariant == eVariantTypes.eDateTime) { resultString = "#" + value.DateToString("yyyy/MM/dd") + "#"; // it seems, the separators (e.g. , /, .) are not considered resultString = resultString.Replace(value.DateToString("yyyy/MM/dd")[4], '-'); } else { list = value.ToString(); // try all available separators, defined in Ict.Common.StringHelper day = StringHelper.GetNextCSV(ref list, ".", true); if (list.Length == 0) { throw new Exception("Ict.Petra.Server.MReporting.FormatQuery: Cannot decode date " + value.ToString()); } month = StringHelper.GetNextCSV(ref list, ".", true); year = StringHelper.GetNextCSV(ref list, ".", true); resultString = String.Format("#{0:4}-{1:2}-{2:2}#", year, month, day); } return new TVariant(resultString, true); // explicit string }
/// <summary> /// print a currency value (actually all sorts of values, e.g. dates) into a string /// </summary> /// <param name="value">the value to be printed</param> /// <param name="format">the format to be used; can be dayofyear for birthdays, currency, etc</param> /// <returns>the formatted string</returns> public static String FormatCurrency(TVariant value, String format) { String ReturnValue; decimal d; DateTime ThisYearDate; // for partnerkey String OrigFormat; ReturnValue = ""; if (format.ToLower() == "dayofyear") { if (value.IsZeroOrNull()) { ReturnValue = "N/A"; } else { ThisYearDate = new DateTime(DateTime.Today.Year, value.ToDate().Month, value.ToDate().Day); ReturnValue = DateToStr(ThisYearDate, "dd-MMM").ToUpper(); } return ReturnValue; } if (format == null) { format = ""; } OrigFormat = format; if (value.TypeVariant == eVariantTypes.eString) { format = ""; } else { format = GetFormatString(value.FormatString, format); } if (value != null) { if ((format == null) || (format.Length == 0)) { return value.ToString(); } String formatPositive = GetNextCSV(ref format, ";"); String formatNegative = GetNextCSV(ref format, ";"); String formatZero = GetNextCSV(ref format, ";"); String formatNil = GetNextCSV(ref format, ";"); if ((OrigFormat.ToLower() == "partnerkey") || (value.FormatString == "partnerkey")) { if (value.ToInt64() <= 0) { ReturnValue = FormatCurrencyInternal(0, "0000000000"); } else { ReturnValue = FormatCurrencyInternal(value.ToDecimal(), formatPositive); } } else if ((value.TypeVariant == eVariantTypes.eDecimal) || (value.TypeVariant == eVariantTypes.eCurrency) || (value.TypeVariant == eVariantTypes.eInteger)) { d = value.ToDecimal(); if (d > 0) { ReturnValue = FormatCurrencyInternal(d, formatPositive); } else if (d < 0) { ReturnValue = FormatCurrencyInternal(Math.Abs(d), formatNegative); } else { // (d == 0) ReturnValue = FormatCurrencyInternal(d, formatZero); } } else if (value.IsZeroOrNull()) { ReturnValue = FormatCurrencyInternal(0, formatNil); } else { ReturnValue = value.ToString(); } } return ReturnValue; }
/// <summary> /// todoComment /// </summary> /// <param name="orig"></param> /// <param name="searchOpen"></param> /// <param name="searchClose"></param> /// <param name="newOpen"></param> /// <param name="newClose"></param> /// <param name="convert"></param> /// <returns></returns> protected TVariant ReplaceVariablesPattern(TVariant orig, String searchOpen, String searchClose, String newOpen, String newClose, TConvertProc convert) { int position = 0; String resultString = orig.ToString(); TVariant ReturnValue = null; int bracket = resultString.IndexOf(searchOpen, position); if (bracket == -1) { // no brackets, therefore use the original TVariant, so that the type information is not lost ReturnValue = orig; } while (bracket != -1) { int firstRealChar = bracket + searchOpen.Length; int paramEndIdx = resultString.IndexOf(searchClose, firstRealChar); if (paramEndIdx <= 0) { // missing closing bracket; can happen with e.g. #testdate; should be #testdate# if (resultString.Length > bracket + 20) { throw new Exception("Cannot find closing bracket " + searchClose + " for " + resultString.Substring(bracket, 20)); } else { throw new Exception("Cannot find closing bracket " + searchClose + " for " + resultString.Substring(bracket)); } } String parameter = resultString.Substring(firstRealChar, paramEndIdx - firstRealChar); bool ParameterExists = false; TVariant newvalue; if (parameters != null) { if (parameter.IndexOf("GLOBAL:") == 0) { newvalue = parameters.Get(parameter.Substring(7), -1, -1, eParameterFit.eExact); } else if (parameter.IndexOf("ALLLEVELS:") == 0) { newvalue = parameters.Get(parameter.Substring(10), -1, depth, eParameterFit.eBestFitEvenLowerLevel); } else { newvalue = parameters.Get(parameter, column, depth, eParameterFit.eBestFitEvenLowerLevel); } ParameterExists = (newvalue.TypeVariant != eVariantTypes.eEmpty); } else { newvalue = new TVariant(); } if (!ParameterExists) { // if date is given, use the parameter itself if ((parameter[0] >= '0') && (parameter[0] <= '9')) { newvalue = new TVariant(parameter); } else { int CountWarning = 1; // do not print warning too many times for the same variable if (!VariablesNotFound.ContainsKey(parameter)) { VariablesNotFound.Add(parameter, 1); } else { VariablesNotFound[parameter] = VariablesNotFound[parameter] + 1; CountWarning = VariablesNotFound[parameter]; } if (CountWarning < 5) { // this can be alright, for empty values; for example method of giving can be empty; for report GiftTransactions TLogging.Log( "Variable " + parameter + " empty or not found (column: " + column.ToString() + "; level: " + depth.ToString() + "). " + resultString); } else if (CountWarning % 20 == 0) { TLogging.Log("20 times: Variable " + parameter + " empty or not found."); } } } try { if (resultString.Length == (searchOpen + parameter + searchClose).Length) { // replace the whole value, return as a TVariant ReturnValue = convert(newvalue); } resultString = resultString.Replace(searchOpen + parameter + searchClose, newOpen + convert(newvalue).ToString() + newClose); } catch (Exception e) { throw new Exception( "While trying to format parameter " + parameter + ", there was a problem with formatting." + Environment.NewLine + e.Message); } bracket = resultString.IndexOf(searchOpen, position); } // while if (ReturnValue == null) { // there has not been just a single value ReturnValue = new TVariant(resultString, true); // explicit string } return ReturnValue; }
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; }
/// <summary> /// This formats the caption of a column, into up to 3 rows /// /// </summary> /// <returns>void</returns> protected void FormatCaption(String AParameterName, TVariant ACaption, System.Int32 AColumn) { int br; String caption; // v, newValue: TVariant; // Counter: integer; // TODO: client side formatting of column captions? e.g. month names should be localised // problems: there can be \n inside strings; // need to split strings by the \n caption = ACaption.ToString(); br = caption.IndexOf("\\n"); if (br != -1) { Parameters.Add(AParameterName, new TVariant(caption.Substring(0, br), true), AColumn); // Tlogging.Log(parameters.Get(AParameterName).EncodeToString()); caption = caption.Substring(br + 2, caption.Length - br - 2); br = caption.IndexOf("\\n"); if (br != -1) { Parameters.Add(AParameterName + '2', new TVariant(caption.Substring(0, br), true), AColumn); // Tlogging.Log(parameters.Get(AParameterName+'2').EncodeToString()); caption = caption.Substring(br + 2, caption.Length - br - 2); Parameters.Add(AParameterName + '3', new TVariant(caption, true), AColumn); } else { Parameters.Add(AParameterName + '2', new TVariant(caption, true), AColumn); } } else { Parameters.Add(AParameterName, new TVariant(caption, true), AColumn); } }
/// <summary> /// this is only called when we know for sure that we need to know the value of this operand /// </summary> /// <returns>void</returns> private TVariant EvaluateOperand(TVariant op) { int after; if (op != null) { if (op.ToString().IndexOf("SUBCALL:") == 0) { after = -1; op = EvaluateOperator(op.ToString().Substring(8), 0, out after); } ReplaceFunctionVariables(ref op); } return op; }
private void ReplaceFunctionVariables(ref TVariant v) { String s; TVariant testS; TVariant[] ops = new TVariant[ReportingConsts.MAX_FUNCTION_PARAMETER + 1 - 0 + 1]; Int32 counter; if (v.TypeVariant == eVariantTypes.eString) { s = v.ToString().Trim(); s = s.Replace("{{lineId}}", StringHelper.IntToStr(LineId)); s = s.Replace("{{column}}", StringHelper.IntToStr(column)); s = s.Replace("{{level}}", StringHelper.IntToStr(Depth)); // make sure that e.g. HasChildRows is evaluated for (counter = 1; counter <= ReportingConsts.MAX_FUNCTION_PARAMETER; counter += 1) { ops[counter] = null; } testS = FunctionSelector(s, ops); if (testS != null) { s = testS.ToString(); } v = ReplaceVariables(s, false); } }
/// <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> /// 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> /// print one value, into the given column /// </summary> /// <param name="columnNr"></param> /// <param name="level"></param> /// <param name="column"></param> /// <returns></returns> protected override bool PrintColumn(Int32 columnNr, Int32 level, TVariant column) { String s; float position; float width; bool linePrinted; linePrinted = false; position = GetPosition(columnNr, level, 0); width = GetWidth(columnNr, level, 0); s = column.ToString(); if (s.Length != 0) { linePrinted = true; if (FParameters.Get("LineAbove", columnNr, level, eParameterFit.eAllColumnFit).ToBool() == true) { FPrinter.DrawLine(position, position + width, eLinePosition.eAbove, eFont.eDefaultFont); } if (FWrapColumn) { FPrinter.PrintStringWrap(s, eFont.eDefaultFont, position, width, GetAlignment(columnNr, level, eAlignment.eRight)); } else { FPrinter.PrintString(s, eFont.eDefaultFont, position, width, GetAlignment(columnNr, level, eAlignment.eRight)); } if (FParameters.Get("LineBelow", columnNr, level, eParameterFit.eAllColumnFit).ToBool() == true) { FPrinter.DrawLine(position, position + width, eLinePosition.eBelow, eFont.eDefaultFont); } FPrinter.LineFeed(eFont.eDefaultFont); } return linePrinted; }
/// <summary> /// compare case insenstive /// </summary> /// <param name="v"></param> /// <returns></returns> public System.Int16 CompareToI(TVariant v) { if (TypeVariant == eVariantTypes.eString) { // test if perhaps boolean values are compared; trouble is, yes and no and true and false are used if (ComparingBooleanValues(v)) { return CompareTo(v); } else { return (short)String.Compare(ToString().ToLower(), v.ToString().ToLower()); } } else { return CompareTo(v); } }
/// <summary> /// </summary> /// <returns>s 0 if equal, -1 if this object is less than the parameter, +1 if it is greater /// </returns> public System.Int16 CompareTo(TVariant v) { System.Int16 ReturnValue; ReturnValue = 0; if ((TypeVariant == eVariantTypes.eDecimal) || (TypeVariant == eVariantTypes.eInteger) || (TypeVariant == eVariantTypes.eInt64) || (TypeVariant == eVariantTypes.eCurrency)) { if (ToDecimal() == v.ToDecimal()) { ReturnValue = 0; } else if (ToDecimal() < v.ToDecimal()) { ReturnValue = -1; } else { ReturnValue = +1; } } else if (TypeVariant == eVariantTypes.eDateTime) { ReturnValue = (short)System.DateTime.Compare(ToDate(), v.ToDate()); } else if (TypeVariant == eVariantTypes.eString) { // test if perhaps boolean values are compared; trouble is, yes and no and true and false are used if (ComparingBooleanValues(v)) { if (ToBool() == v.ToBool()) { ReturnValue = 0; } else if (ToBool() == false) { ReturnValue = -1; } else { ReturnValue = 1; } } else { ReturnValue = (short)String.Compare(ToString(), v.ToString()); } } else if (TypeVariant == eVariantTypes.eBoolean) { if (ToBool() == v.ToBool()) { ReturnValue = 0; } else if (ToBool() == false) { ReturnValue = -1; } else { ReturnValue = 1; } } else if (TypeVariant == eVariantTypes.eComposite) { // just compare the first elements ReturnValue = FirstCompositeValue().CompareTo(v.FirstCompositeValue()); } return ReturnValue; }
private bool ComparingBooleanValues(TVariant v) { return ((ToString().ToLower() == "true") || (ToString().ToLower() == "yes") || (ToString().ToLower() == "false") || (ToString().ToLower() == "no")) && ((v.ToString().ToLower() == "true") || (v.ToString().ToLower() == "yes") || (v.ToString().ToLower() == "false") || (v.ToString().ToLower() == "no")); }
/// <summary> /// todoComment /// </summary> /// <param name="precalculatedColumns"></param> /// <returns></returns> public TVariant Precalculate(TVariant[] precalculatedColumns) { TVariant ReturnValue; String strCalculation; TRptDataCalcCalculation rptDataCalcCalculation; TRptCalculation rptCalculation; DataTable tab; ReturnValue = new TVariant(); // calculation is used for display in the GUI, formula is used for adding ledgers if ((!GetParameters().Exists("param_calculation", column, Depth))) { return ReturnValue; } if (GetParameters().Exists("param_formula", column, Depth)) { strCalculation = GetParameters().Get("param_formula", column, Depth).ToString(); } else { strCalculation = GetParameters().Get("param_calculation", column, Depth).ToString(); } rptCalculation = ReportStore.GetCalculation(CurrentReport, strCalculation); if (rptCalculation == null) { ReturnValue = EvaluateFunctionCalculation(strCalculation, precalculatedColumns); } else { rptDataCalcCalculation = new TRptDataCalcCalculation(this); if (!rptDataCalcCalculation.EvaluateCalculationFunction(rptCalculation.rptGrpQuery, ref precalculatedColumns, ref ReturnValue)) { ReturnValue = rptDataCalcCalculation.EvaluateCalculationAll(rptCalculation, null, rptCalculation.rptGrpTemplate, rptCalculation.rptGrpQuery); if (ReturnValue.IsZeroOrNull()) { ReturnValue.ApplyFormatString(rptCalculation.strReturnsFormat); return ReturnValue; } int SelectPos = ReturnValue.ToString().ToUpper().IndexOf("SELECT"); if ((SelectPos >= 0) && (SelectPos <= 3)) { // this is an sql statement and not a function result tab = DatabaseConnection.SelectDT(ReturnValue.ToString(), "", DatabaseConnection.Transaction); if (tab.Rows.Count > 0) { if (tab.Rows[0][0].GetType() == typeof(String)) { ReturnValue = new TVariant(Convert.ToString(tab.Rows[0][0])); } else { ReturnValue = new TVariant(tab.Rows[0][0]); } } } } ReturnValue.ApplyFormatString(rptCalculation.strReturnsFormat); } return ReturnValue; }