/// <summary>
/// Get the strings for csv file for different data types.
/// </summary>
/// <param name="type">DatabaseType</param>
/// <param name="cellValue">string</param>
/// <param name="col">ReportColumn</param>
/// <returns>string</returns>
public static string GetCsvCellValue(DatabaseType type, string cellValue, ReportColumn col)
{
//convert cell value to its particular type
object value = DatabaseTypeHelper.ConvertFromString(type, cellValue);
if (cellValue == null)
{
return("");
}
if (type is BoolType)
{
return(GetBooleanCellValue(( bool )value));
}
if (type is AutoIncrementType)
{
return(DatabaseTypeHelper.ConvertToString(type, value, col.AutoNumberDisplayPattern));
}
if (type is DateType || type is DateTimeType)
{
return(cellValue);
}
if (type is TimeType)
{
return((( DateTime )value).ToUniversalTime( ).TimeOfDay.ToString( ));
}
if (type is StructureLevelsType)
{
return(GetStructureLevelCellValue(cellValue, false));
}
return(value.ToString( ));
}
public void ConvertFromString_String_Null()
{
const string originalData = null;
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.StringType, originalData);
var convertedData = (string)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_Xml()
{
const string originalData = "<xml></xml>";
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.XmlType, originalData);
var convertedData = (string)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_ConvertToString_String()
{
const string originalData = "string data";
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.StringType, originalData);
object convertedStringData = DatabaseTypeHelper.ConvertToString(DatabaseType.StringType, objectData);
Assert.AreEqual(originalData, convertedStringData, "The converted data is invalid.");
}
public void ConvertFromString_Guid()
{
Guid originalData = Guid.NewGuid();
string originalStringData = originalData.ToString();
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.GuidType, originalStringData);
var convertedData = (Guid)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_Decimal()
{
const decimal originalData = 83673838.3335M;
string originalStringData = originalData.ToString(CultureInfo.InvariantCulture);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.DecimalType, originalStringData);
var convertedData = (Decimal)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_Date_NotCustomFormat()
{
var originalData = new DateTime(2011, 4, 4);
string originalStringData = originalData.ToString(CultureInfo.InvariantCulture);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.DateType, originalStringData);
var convertedData = (DateTime)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_DateTime_NotCustomFormat()
{
var originalData = new DateTime(2011, 4, 4, 4, 6, 7);
string originalStringData = originalData.ToUniversalTime().ToString("u");
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.DateTimeType, originalStringData);
var convertedData = (DateTime)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_Currency()
{
const decimal originalData = 74845739.345M;
string originalStringData = originalData.ToString(CultureInfo.InvariantCulture);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.CurrencyType, originalStringData);
var convertedData = (Decimal)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_ConvertToString_Time()
{
var originalData = new TimeSpan(13, 4, 13);
string originalStringData = originalData.ToString("c");
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.TimeType, originalStringData);
object convertedStringData = DatabaseTypeHelper.ConvertToString(DatabaseType.TimeType, objectData);
Assert.AreEqual(originalStringData, convertedStringData, "The converted data is invalid.");
}
public void ConvertFromString_ConvertToString_DateTime()
{
var originalData = new DateTime(2011, 4, 4, 4, 6, 7, DateTimeKind.Utc);
string originalStringData = originalData.ToString(DateTimeType.DateTimeFormatString);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.DateTimeType, originalStringData);
object convertedStringData = DatabaseTypeHelper.ConvertToString(DatabaseType.DateTimeType, objectData);
Assert.AreEqual(originalStringData, convertedStringData, "The converted data is invalid.");
}
public void ConvertFromString_Int32()
{
const int originalData = 12387352;
string originalStringData = originalData.ToString(CultureInfo.InvariantCulture);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.Int32Type, originalStringData);
var convertedData = (Int32)objectData;
Assert.AreEqual(originalData, convertedData, "The converted data is invalid.");
}
public void ConvertFromString_ConvertToString_Bool()
{
const bool originalData = true;
string originalStringData = originalData.ToString();
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.BoolType, originalStringData);
object convertedStringData = DatabaseTypeHelper.ConvertToString(DatabaseType.BoolType, objectData);
Assert.AreEqual(originalStringData, convertedStringData, "The converted data is invalid.");
}
public void ConvertFromString_TimeLegacy()
{
var originalData = new TimeSpan(13, 4, 13);
string originalStringData = "05/02/2013 13:04:13";
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.TimeType, originalStringData);
var convertedData = (DateTime)objectData; // TODO: DateTime here, but TimeSpan elsewhere!!
Assert.AreEqual(originalData, convertedData.TimeOfDay, "The converted data is invalid.");
}
public void ConvertFromString_ConvertToString_Binary()
{
var originalData = new byte[]
{
1, 2, 3, 4, 0x8
};
string originalStringData = Convert.ToBase64String(originalData);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.BinaryType, originalStringData);
string convertedStringData = DatabaseTypeHelper.ConvertToString(DatabaseType.BinaryType, objectData);
Assert.AreEqual(originalStringData, convertedStringData, "The converted data is invalid.");
}
/// <summary>
/// Builds a predicate that examines the raw data (as its native .Net type) to determine if
/// it passes the specified filter.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="currencyType">Type of the currency.</param>
/// <returns>A predicate that accepts a data value and returns true if the value is acceptable on the basis of the filter.</returns>
/// <remarks>This overload assumes that the values will not be null.</remarks>
private static object ConvertCurrencyCell(object value, DatabaseType currencyType)
{
if (value.ToString().StartsWith("$"))
{
try
{
return(DatabaseTypeHelper.ConvertFromString(currencyType, value.ToString().Replace("$", "")));
}
catch
{
return(value);
}
}
return(value);
}
public void ConvertFromString_Binary()
{
var originalData = new byte[]
{
1, 2, 3, 4, 0x8
};
string originalStringData = Convert.ToBase64String(originalData);
object objectData = DatabaseTypeHelper.ConvertFromString(DatabaseType.BinaryType, originalStringData);
var convertedData = (byte[])objectData;
Assert.AreEqual(originalData.Length, convertedData.Length, "The converted data length is invalid.");
for (int i = 0; i < originalData.Length; i++)
{
Assert.AreEqual(originalData[i], convertedData[i], "The converted data is invalid.");
}
}
//DatabaseType.BinaryType
//DatabaseType.StructureLevelsType
private static void TestType <T>(DatabaseType type, T value, string sValue,
bool testDatabaseTypeHelper = true, bool testTypeOverrides = true, bool testFromString = true, bool testToString = true) where T : IComparable
{
if (testDatabaseTypeHelper)
{
if (testFromString)
{
// Test DatabaseTypeHelper.ConvertFromString
object actualValue = DatabaseTypeHelper.ConvertFromString(type, sValue);
Assert.IsTrue(value.CompareTo(actualValue) == 0, "DatabaseTypeHelper.ConvertFromString");
}
if (testToString)
{
// Test DatabaseTypeHelper.ConvertToString
string actualString = DatabaseTypeHelper.ConvertToString(type, value);
Assert.AreEqual(sValue, actualString, "DatabaseTypeHelper.ConvertToString");
}
}
if (testTypeOverrides)
{
if (testFromString)
{
// Test type.ConvertFromString
object actualValue2 = type.ConvertFromString(sValue);
Assert.IsTrue(value.CompareTo(actualValue2) == 0, "DatabaseTypeHelper.ConvertFromString");
}
if (testToString)
{
// Test type.ConvertToString
string actualString2 = type.ConvertToString(value);
Assert.AreEqual(sValue, actualString2, "DatabaseTypeHelper.ConvertToString");
}
}
}
public void Test_Unknown_FromString_Empty()
{
object result = DatabaseTypeHelper.ConvertFromString(DatabaseType.UnknownType, "");
Assert.IsNull(result);
}
/// <summary>
/// Get the formatted cell value for the different data types.
/// </summary>
public static string GetFormattedCellValue(DatabaseType type, string cellValue, ReportColumn col)
{
string result;
//convert cell value to its particular type
object value = DatabaseTypeHelper.ConvertFromString(type, cellValue);
if (cellValue == null)
{
return("");
}
if (type is BoolType)
{
result = GetBooleanCellValue(( bool )value);
return(result);
}
if (type is AutoIncrementType)
{
result = DatabaseTypeHelper.ConvertToString(type, value, col.AutoNumberDisplayPattern);
return(result);
}
if (type is DateType)
{
return((( DateTime )value).ToString("d/MM/yyyy"));
}
if (type is TimeType)
{
return((( DateTime )value).ToUniversalTime( ).ToString("h:mm tt"));
}
if (type is DateTimeType)
{
return((( DateTime )value).ToString("d/MM/yyyy h:mm tt"));
}
if (type is Int32Type)
{
return(Convert.ToInt32(value).ToString("#,##0"));
}
if (type is DecimalType)
{
long? decimalPlaces = col.DecimalPlaces;
NumberFormatInfo numberFormatInfo = new CultureInfo("en-US", false).NumberFormat;
numberFormatInfo.NumberDecimalDigits = decimalPlaces != null?Convert.ToInt32(decimalPlaces) : 3;
decimal temp = Convert.ToDecimal(value);
return(temp.ToString("N", numberFormatInfo));
}
if (type is CurrencyType)
{
long? decimalPlaces = col.DecimalPlaces;
NumberFormatInfo numberFormatInfo = new CultureInfo("en-US", false).NumberFormat;
numberFormatInfo.CurrencyDecimalDigits = decimalPlaces != null?Convert.ToInt32(decimalPlaces) : 2;
numberFormatInfo.CurrencySymbol = "$";
numberFormatInfo.CurrencyNegativePattern = 1;
decimal temp = Convert.ToDecimal(value);
return(temp.ToString("C", numberFormatInfo));
}
if (type is StructureLevelsType)
{
return(GetStructureLevelCellValue(cellValue, true));
}
result = value.ToString( );
return(result);
}
public void ConvertFromString_Null()
{
object obj = DatabaseTypeHelper.ConvertFromString(DatabaseType.XmlType, null);
Assert.IsNull(obj, "Failed to convert null value");
}
/// <summary>
/// Create content row of the datatable.
/// </summary>
private static Row CreateContentRow(ReportResult reportResults, DataRow contentRow, int rowIndex)
{
Row row = new Row
{
RowIndex = (UInt32)rowIndex
};
int columnIndex = 0;
int dataColumnIndex = 0;
foreach (ReportColumn col in reportResults.Metadata.ReportColumns.Values)
{
if (!col.IsHidden && col.Type != "Image")
{
Cell cell;
string cellValue = ExportDataHelper.GetCellValue(contentRow, dataColumnIndex);
DatabaseType cellType = DatabaseTypeHelper.ConvertFromDisplayName(col.Type);
if (!string.IsNullOrEmpty(col.AutoNumberDisplayPattern))
{
cellType = DatabaseType.AutoIncrementType;
col.Type = "AutoIncrement";
}
object value = DatabaseTypeHelper.ConvertFromString(cellType, cellValue);
if (string.IsNullOrEmpty(cellValue))
{
cell = CreateTextCell(null);
sharedStrings.TryAdd(sharedStringIndex, null);
}
else
{
DateTime dateValue;
switch (col.Type)
{
case "DateTime":
dateValue = Convert.ToDateTime(value);
cell = CreateDateValueCell(dateValue, 4);
break;
case "Date":
dateValue = Convert.ToDateTime(value);
cell = CreateDateValueCell(dateValue, 1);
break;
case "Time":
dateValue = OADateOrigin + (Convert.ToDateTime(value)).ToUniversalTime().TimeOfDay;
cell = CreateDateValueCell(dateValue, 10);
break;
case "Int32":
cell = CreateNumericCell(value, 5);
break;
case "Decimal":
cell = CreateNumericCell(value, 6);
break;
case "Currency":
cell = CreateNumericCell(value, 9);
break;
case "AutoIncrement":
cellValue = ExportDataHelper.GetFormattedCellValue(cellType, cellValue, col);
cell = CreateTextCell(null);
sharedStrings.TryAdd(sharedStringIndex, cellValue);
break;
case "StructureLevels":
cellValue = ExportDataHelper.GetStructureLevelCellValue(cellValue, true);
cell = CreateTextCell(8);
sharedStrings.TryAdd(sharedStringIndex, cellValue);
break;
default:
cellValue = ExportDataHelper.GetFormattedCellValue(cellType, cellValue, col);
cell = CreateTextCell(8);
sharedStrings.TryAdd(sharedStringIndex, cellValue);
break;
}
}
// Append the cell
SetCellLocation(cell, columnIndex, rowIndex);
row.AppendChild(cell);
columnIndex++;
}
dataColumnIndex++;
}
return(row);
}
