/// <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;
}
