public RuleBookTemplateModel(string name, string baseClassName, RuleEngineRule[] rules, LookupTable[] tables)
{
Name = name;
BaseClassName = baseClassName;
_rules = rules;
Tables = tables;
}
public void CreateAndDropTableMultipleDatabases()
{
var table = new LookupTable("TestTable");
var keyColumns = new[]
{
new FactorTableColumnDefinition("ColumnA", true)
{
LookupType = LookupType.ExactMatch
},
new FactorTableColumnDefinition("ColumnB", true)
{
LookupType = LookupType.ExactMatch
}
};
var dataColumns = new[]
{
new FactorTableColumnDefinition("IntColumn", false)
{
DataType = typeof(int)
},
new FactorTableColumnDefinition("DecimalColumn", false)
{
DataType = typeof(decimal)
}
};
table.Keys = keyColumns;
table.Columns = dataColumns;
table.Properties.Schema = "dbo";
table.Properties.Context = "ISO";
_multipleRepository.ImportTables(new[] { table }, false);
var addedTable =
_multipleRepository.GetRatingTables(
t => t.Name.Equals("TestTable", StringComparison.InvariantCultureIgnoreCase) &&
t.Properties.Schema == "dbo").FirstOrDefault();
Assert.IsTrue(addedTable != null);
_multipleRepository.DropTables(new[] { _multipleRepository.GetLookupTable(addedTable.ChangeId) });
var noTable = _multipleRepository.GetRatingTables(
t => t.Name.Equals("TestTable", StringComparison.InvariantCultureIgnoreCase) &&
t.Properties.Schema == "dbo");
Assert.IsTrue(!noTable.Any());
}
public ActionResult AddLookupTable(string name, string keys, string columns, string data = null)
{
//var columnsLine = lines.First();
var keyColumns = keys.Split("|".ToCharArray());
var valueColumns = columns.Split("|".ToCharArray());
var allColumns = keyColumns.Concat(valueColumns);
// Create the table
//var ftId = Guid.NewGuid();
var rt = new LookupTable()
{
Name = name,
Keys = (from key in keyColumns
select new FactorTableColumnDefinition(key, true)).ToArray(),
Columns = (from valueColumn in valueColumns
select new FactorTableColumnDefinition(valueColumn, false)).ToArray(),
};
TableStrategy.ImportTables(new LookupTable[] { rt }, false);
// Import and data
if (data != null)
{
var lines = data.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var dataLines = lines.Skip(1);
foreach (var dataLine in dataLines)
TableStrategy.SaveLookupTableRow(new LookupTableRowModel()
{
ChangeId = Guid.NewGuid(),
TableName = name,
EffectiveDate = MissionControlDate,
//RowId = Guid.NewGuid().ToString(),
Active = true,
Values =
dataLine.Split("|".ToCharArray()).Select(p => p.Trim())
.ToArray()
});
}
return View("Index", TableStrategy.GetRatingTables());
}
public bool IsMatch(LookupTable table, params object[] keyValues)
{
for (int index = 0; index < keyValues.Length; index++)
{
// The key value
var key = keyValues[index];
// The definition of this key
var keyDefinition = table.Keys[index];
// How should we match the keyValues
var matcher = GetMatcher(keyDefinition.LookupType);
// Sort the rows in the correct order based on the lookuptype
var rowKeyValue = KeyValues[index];
if (!matcher(key, rowKeyValue)) return false;
}
return true;
}
private LookupTable DecorateFlatTable(string name, GetTableColumns_Result[] tableColumns, bool includeRows = true)
{
var ratingTable = new LookupTable(name)
{
Keys =
tableColumns.Where(p => p.IsKey != null && p.IsKey == true).Select(
p => new FactorTableColumnDefinition(p.ColumnName, true)
{
LookupType = (LookupType)Enum.Parse(typeof(LookupType), p.LookupType, true)
}).ToArray(),
Columns =
tableColumns.Where(p => p.IsKey != null && p.IsKey == false).Select(
p => new FactorTableColumnDefinition(p.ColumnName, false)).ToArray()
};
if (includeRows)
{
var allColumns = ratingTable.Keys.Concat(ratingTable.Columns).ToArray();
//RatingTablesDb.Connection.Open();
RatingTableQuery(
FlatTableQueries.BuildVersionedQuery(ratingTable.Name, allColumns.Select(p => p.Name).ToArray(), EffectiveDate),
reader => ReadLookupTableRows(ratingTable, reader));
}
return ratingTable;
}
private static void ReadLookupTableRows(LookupTable ratingTable, SqlDataReader reader)
{
if (reader.HasRows)
{
while (reader.Read())
{
var LookupTableRow = new LookupTableRow();
var index = 0;
LookupTableRow.RowId = reader.GetInt64(index++).ToString();
LookupTableRow.ChangeId = reader.GetGuid(index++).ToString();
LookupTableRow.EffectiveDate = reader.GetDateTime(index++);
LookupTableRow.Active = reader.GetBoolean(index++);
foreach (var key in ratingTable.Keys)
{
var value = reader.GetString(index);
if (value.Contains("::"))
{
var lhValues = value.Split("::".ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
LookupTableRow.KeyValues.Add(new LookupTableKey(lhValues[0],
lhValues[1]));
}
else
{
LookupTableRow.KeyValues.Add(new LookupTableKey(value, null));
}
index++;
}
foreach (var column in ratingTable.Columns)
{
LookupTableRow.ColumnValues.Add(column.Name, reader.GetString(index));
index++;
}
ratingTable.Rows.Add(LookupTableRow);
}
}
}
//public LookupTable ToLookupTable(DataTable table)
//{
// if (!table.Rows.Cast<DataRow>().Any())
// return new LookupTable();
// var lookupTable = new LookupTable();
// var xml = XElement.Parse(table.Rows.Cast<DataRow>().First()[0].ToString());
// var tableXml = xml.Element("table");
// if (tableXml != null)
// {
// lookupTable.Name = tableXml.Element("name").Value;
// lookupTable.Properties.Schema = tableXml.Element("schema").Value;
// lookupTable.Properties.EffectiveDate = tableXml.Element("effectiveDate").Value;
// foreach (var row in tableXml.Element("rows").Elements("row"))
// {
// var columns = row.Elements().Where(x => !MetadataColumnNames.Contains(x.Name.ToString()));
// }
// }
// return lookupTable;
//}
public LookupTable ToLookupTable(IDictionary<string, object> parameters, DataTable table)
{
var dataTableColumns = table.Columns.Cast<DataColumn>().ToList();
var metadataXml = XElement.Parse(Convert.ToString(parameters["Metadata"]));
var factorKeyColumns = new List<FactorTableColumnDefinition>();
var factorNonKeyColumns = new List<FactorTableColumnDefinition>();
var metadataColumns = new List<FactorTableColumnDefinition>();
var columnXml = metadataXml.Elements("ColumnMetadata");
foreach (var column in columnXml.Elements("Column"))
{
//get the base properties
var columnName = column.Element("Name");
var columnDefinition = new FactorTableColumnDefinition
{
Name = columnName != null ? columnName.Value : string.Empty
};
columnDefinition.DataType =
dataTableColumns.Single(c => c.ColumnName == columnDefinition.Name).DataType;
//get the extended properties
if (column.Elements("Properties").Descendants().Any())
{
foreach (var property in column.Elements("Properties").Elements("Property"))
{
var propertyName = property.Element("Name");
if (propertyName != null)
{
var propertyValue = property.Element("Value");
if (propertyValue != null && !string.IsNullOrEmpty(propertyValue.Value))
{
if (propertyName.Value == "IsKey")
columnDefinition.IsKey = propertyValue.Value == "1";
else if (propertyName.Value == "LookupType")
columnDefinition.LookupType =
(LookupType)Enum.Parse(typeof(LookupType), propertyValue.Value);
}
}
}
}
if (MetadataColumnNames.Contains(columnDefinition.Name))
metadataColumns.Add(columnDefinition);
else if (columnDefinition.IsKey)
factorKeyColumns.Add(columnDefinition);
else
factorNonKeyColumns.Add(columnDefinition);
}
var properties = new ExpandoObject() as IDictionary<string, object>;
foreach (var property in metadataXml.Elements().Where(e => e.Name != "ColumnMetadata"))
{
properties.Add(property.Name.ToString(), property.Value);
}
var lookupTable = new LookupTable(properties["Table"].ToString(),
metadataColumns.ToArray(),
factorKeyColumns.ToArray(),
factorNonKeyColumns.ToArray())
{
Id = parameters["ChangeId"].ToString(),
Properties = properties
};
foreach (var row in table.Rows.Cast<DataRow>())
{
var lookupTableRow = new LookupTableRow
{
Active = Convert.ToBoolean(row["Active"]),
EffectiveDate = Convert.ToDateTime(row["EffectiveDate"]),
ExpirationDate = Convert.ToDateTime(row["ExpirationDate"]),
RowId = row["Id"].ToString(),
Sequence = Convert.ToInt32(row["Sequence"]),
ChangeId = row["ChangeId"].ToString(),
IsOverride = Convert.ToBoolean(row["IsOverride"].ToString())
};
foreach (var key in lookupTable.Keys)
{
lookupTableRow.KeyValues.Add(new LookupTableKey(key.Name, row[key.Name].ToString(), null));
}
foreach (var col in lookupTable.Columns)
{
lookupTableRow.ColumnValues.Add(col.Name, row[col.Name]);
}
lookupTable.Rows.Add(lookupTableRow);
}
return lookupTable;
}
public LookupTableRowModel ToLookupTableRowModel(LookupTable table, LookupTableRow row)
{
if (row == null)
return null;
var metadata = new Dictionary<string, object>
{
{ "Id", row.RowId },
{ "Sequence", row.Sequence },
{ "ChangeId", row.ChangeId },
{ "EffectiveDate", row.EffectiveDate },
{ "ExpirationDate", row.ExpirationDate },
{ "Active", row.Active },
{ "IsOverride", row.IsOverride }
};
for (var x = 0; x < row.KeyValues.Count(); x++)
{
metadata[table.Keys[x].Name] = row.KeyValues[x].LowValue;
if (!string.IsNullOrEmpty(row.KeyValues[x].HighValue))
metadata[table.Keys[x].Name] += "::" + row.KeyValues[x].HighValue;
}
for (var x = 0; x < row.ColumnValues.Count; x++)
{
metadata[table.Columns[x].Name] = row.ColumnValues[table.Columns[x].Name];
}
return new LookupTableRowModel
{
RowId = Convert.ToInt64(row.RowId),
ChangeId = Guid.Parse(row.ChangeId),
Sequence = row.Sequence,
IsOverride = row.IsOverride,
EffectiveDate = row.EffectiveDate,
Active = row.Active,
Values = metadata.Select(v => v.Value.ToString()).ToArray(),
ItemValues = metadata,
TableId = table.Id,
TableName = table.Name
};
}
public LookupTableModel ToLookupTableModel(LookupTable table)
{
var model = new LookupTableModel
{
Id = table.Id,
ChangeId = table.Id,
Name = table.Name,
Description = table.Name,
IsoName = table.Name,
Active = table.Properties.Active == "1"
};
model.Properties.EffectiveDate = Convert.ToDateTime(table.Properties.EffectiveDate);
model.Properties.Schema = Convert.ToString(table.Properties.Schema);
model.Properties.TableType = Convert.ToString(table.Properties.TableType);
model.Properties.Context = Convert.ToString(table.Properties.Context);
return model;
}
public RuleBookTemplateModel(string name, RuleEngineRule[] rules, LookupTable[] tables)
: this(name, "CompiledRuleBookBase", rules, tables)
{
}
