private static string BuildHeader(RelationalColumn column)
{
var sb = new StringBuilder();
sb.Append(column.Index);
if (!string.IsNullOrWhiteSpace(column.Name))
{
sb.AppendFormat(": {0}", column.Name);
}
sb.Append(Environment.NewLine);
sb.Append(column.Reader.Type.Name);
if (column.ValueType != column.Reader.Name)
{
sb.AppendFormat(" > {0}", column.ValueType);
}
if (Settings.Default.ShowOffsets)
{
if (column.Reader is PackedBooleanDataReader)
{
sb.AppendFormat(" [{0:X}&{1:X2}]", column.Offset, ((PackedBooleanDataReader)column.Reader).Mask);
}
else
{
sb.AppendFormat(" [{0:X}]", column.Offset);
}
}
return(sb.ToString());
}
private object ProcessSingleColumn(RelationalColumn column, XivRow row)
{
if (column.Name != null)
{
if (column.ValueType == "Item" && _Columns.Count > 0 && (_Columns.Peek()?.Name?.ToLower()?.StartsWith("amount")).GetValueOrDefault())
{
var amountCol = _Columns.Dequeue();
if (row[column.Index] != null)
{
var itemName = row[column.Index].ToString();
var itemAmount = row[amountCol.Index].ToString();
if (string.IsNullOrWhiteSpace(itemName) && (string.IsNullOrWhiteSpace(itemAmount) || itemAmount == "0"))
{
return(null);
}
return(new JObject {
{ "item", itemName },
{ "amount", itemAmount }
});
}
}
else if (row[column.Index] != null)
{
return(row[column.Index].ToString());
}
}
return(null);
}
public override string ToString()
{
RelationalColumn defCol = Sheet.Header.DefaultColumn;
return(defCol == null
? string.Format("{0}#{1}", Sheet.Header.Name, Key)
: string.Format("{0}", this[defCol.Index]));
}
private static Binding CreateCellBinding(RelationalColumn column)
{
return(new Binding {
Converter = CellConverterInstance,
ConverterParameter = column.Index,
Mode = BindingMode.OneWay
});
}
public static int?GetLimitedStringLength(this RelationalColumn column)
{
if (column.GetAdditionalData("MaxLength") is int length)
{
return(length);
}
return(null);
}
private static void SetRelationalSqlParameters(KeyValuePair <object, object> itemChildKeyPair, string tableName, ref string columnList, ref string relationList)
{
string relation;
RelationalColumn relationConfig = itemChildKeyPair.Key as RelationalColumn;
columnList += string.Format("{0}.{1} ", relationConfig.TableName.ToLower(), relationConfig.ColumnName);
if (!string.IsNullOrEmpty(relationConfig.ColumnAlias))
{
columnList += string.Format(SQLStatements.SQL_Action_ColumnAlias, relationConfig.ColumnAlias);
}
columnList += ", ";
if (relationConfig.JunctionType == RelationalJunctionType.Mandatory)
{
relation = string.Format(SQLStatements.SQL_Action_RelationateMandatorily,
relationConfig.TableName.ToLower(),
string.Concat(tableName, ".", relationConfig.KeyColumn),
string.Concat(relationConfig.TableName, ".",
relationConfig.ForeignKeyColumn, " "));
}
else
{
if (!string.IsNullOrEmpty(relationConfig.IntermediaryColumnName))
{
relation = string.Format(SQLStatements.SQL_Action_RelationateOptionally,
relationConfig.IntermediaryColumnName.ToLower(),
string.Concat(tableName, ".", relationConfig.ForeignKeyColumn),
string.Concat(relationConfig.IntermediaryColumnName, ".",
relationConfig.ForeignKeyColumn));
relation += string.Format(SQLStatements.SQL_Action_RelationateOptionally,
relationConfig.TableName,
string.Concat(relationConfig.IntermediaryColumnName, ".", relationConfig.KeyColumn),
string.Concat(relationConfig.TableName, ".", relationConfig.ForeignKeyColumn, " "));
}
else
{
relation = string.Format(SQLStatements.SQL_Action_RelationateOptionally,
relationConfig.TableName,
string.Concat(tableName, ".", relationConfig.KeyColumn),
string.Concat(relationConfig.TableName, ".", relationConfig.ForeignKeyColumn));
}
}
if (relation.Contains(relationList) ||
string.IsNullOrEmpty(relationList))
{
relationList = relation;
}
else if (!relationList.Contains(relation))
{
relationList += relation;
}
}
object IRelationalRow.GetRaw(string columnName)
{
RelationalColumn column = Sheet.Header.FindColumn(columnName);
if (column == null)
{
throw new KeyNotFoundException();
}
return(column.ReadRaw(Sheet.GetBuffer(), this));
}
private object GetColumnValue(string columnName)
{
RelationalColumn col = Sheet.Header.FindColumn(columnName);
if (col == null)
{
throw new KeyNotFoundException();
}
return(this[col.Index]);
}
object IRelationalRow.GetRaw(string columnName)
{
RelationalColumn column = Sheet.Header.FindColumn(columnName);
if (column == null)
{
throw new KeyNotFoundException();
}
return(this.GetRaw(column.Index));
}
public object this[string columnName] {
get {
RelationalColumn col = Sheet.Header.FindColumn(columnName);
if (col == null)
{
throw new KeyNotFoundException();
}
return(this[col.Index]);
}
}
public RawDataGridTextColumn(RelationalColumn column)
{
_Column = column;
_ContextMenu = new ContextMenu();
var mi = new MenuItem {
Header = "Copy",
};
mi.Click += OnCopyClick;
_ContextMenu.Items.Add(mi);
}
public RawDataGridImageColumn(RelationalColumn column)
{
_Column = column;
_ContextMenu = new ContextMenu();
var mi = new MenuItem {
Header = "Save image",
};
mi.Click += OnSaveImageClick;
_ContextMenu.Items.Add(mi);
}
public static DataGridColumn Create(RelationalColumn column)
{
var sheetDef = column.Header.SheetDefinition;
Type defType = null;
if (sheetDef != null)
{
defType = sheetDef.GetValueType(column.Index);
}
var targetType = defType ?? column.Reader.Type;
var header = BuildHeader(column);
var binding = CreateCellBinding(column);
DataGridColumn target;
if (typeof(SaintCoinach.Imaging.ImageFile).IsAssignableFrom(targetType))
{
target = new RawDataGridImageColumn(column)
{
Binding = binding,
}
}
;
else if (typeof(System.Drawing.Color).IsAssignableFrom(targetType))
{
target = new RawDataGridColorColumn(column)
{
Binding = binding
}
}
;
else
{
target = new RawDataGridTextColumn(column)
{
Binding = binding
}
};
target.Header = header;
target.IsReadOnly = true;
target.CanUserSort = true;
return(target);
}
private static string BuildHeader(RelationalColumn column)
{
var sb = new StringBuilder();
sb.Append(column.Index);
if (!string.IsNullOrWhiteSpace(column.Name))
{
sb.AppendFormat(": {0}", column.Name);
}
sb.Append(Environment.NewLine);
sb.Append(column.Reader.Type.Name);
if (column.ValueType != column.Reader.Name)
{
sb.AppendFormat(" > {0}", column.ValueType);
}
return(sb.ToString());
}
private void AddItemToRecord(object element, RelationalColumn column, ref JObject record)
{
var columnName = CleanColumnName(column.Name);
// Check if it's a repeating item. If it is, look for an existing element with that name. If one cannot be found, create a new array and add it to the object
// If it is not a repeating item, add it as is to the record
if (column.Definition.InnerDefinition is RepeatDataDefinition def && def.RepeatCount > 1)
{
// First try to get the existing item
JArray itemArray;
if (record.ContainsKey(columnName))
{
itemArray = (JArray)record[columnName];
}
else
{
itemArray = new JArray();
record.Add(columnName, itemArray);
}
itemArray.Add(element);
}
private static void SetFilterSqlParameters(IDictionary <object, object> entitySqlFilter, string tableName, PersistenceAction action, IDictionary <string, double[]> rangeValues, ref string columnFilterList)
{
foreach (var filter in entitySqlFilter)
{
if (!filter.Key.Equals("TableName") && !filter.Key.Equals("RelatedEntity"))
{
object filterColumnName = null;
object filterColumnValue = null;
object columnName = null;
string columnNameStr = string.Empty;
var itemChildKeyPair = (KeyValuePair <object, object>)filter.Value;
if (!(itemChildKeyPair.Key is RelationalColumn))
{
columnName = itemChildKeyPair.Key;
filterColumnName = string.Concat(tableName, ".", columnName);
filterColumnValue = itemChildKeyPair.Value;
}
else
{
RelationalColumn relationConfig = itemChildKeyPair.Key as RelationalColumn;
if ((action == PersistenceAction.List) && relationConfig.Filterable)
{
filterColumnName = string.Concat(relationConfig.TableName.ToLower(), ".", relationConfig.ColumnName);
filterColumnValue = itemChildKeyPair.Value;
}
}
var rangeFilter = false;
if (rangeValues != null)
{
columnNameStr = columnName.ToString();
rangeFilter = rangeValues.ContainsKey(columnNameStr);
}
if (((filterColumnValue != null) &&
(filterColumnValue.ToString() != SqlDefaultValue.Null) &&
(filterColumnValue.ToString() != SqlDefaultValue.Zero)) ||
rangeFilter)
{
long fake;
bool compareRule = ((action == PersistenceAction.List) ||
(action == PersistenceAction.Count)) &&
!long.TryParse(filterColumnValue.ToString(), out fake) &&
!filterColumnName.ToString().ToLower().Contains("date") &&
!filterColumnName.ToString().ToLower().StartsWith("id") &&
!filterColumnName.ToString().ToLower().EndsWith("id") &&
!filterColumnName.ToString().ToLower().Contains(".id");
string comparation = string.Empty;
if (!rangeFilter)
{
comparation = (compareRule)
? string.Format(SqlOperator.Contains, filterColumnValue.ToString().Replace("'", string.Empty))
: string.Concat(SqlOperator.Equal, filterColumnValue);
if (filterColumnValue.Equals(true))
{
comparation = " = 1";
}
if ((action == PersistenceAction.Edit) && filterColumnValue.Equals(false))
{
comparation = " = 0";
}
if (!filterColumnValue.Equals(false))
{
columnFilterList += filterColumnName + comparation +
((compareRule) ? SqlOperator.Or : SqlOperator.And);
}
}
else
{
double rangeFrom = rangeValues[columnNameStr][0];
double rangeTo = rangeValues[columnNameStr][1];
comparation = string.Format(SqlOperator.Between, rangeFrom, rangeTo);
columnFilterList += string.Concat(filterColumnName, " ", comparation, SqlOperator.And);
}
}
}
}
}
public static RelationalColumn SetLimitedStringLength(this RelationalColumn column, int length)
{
column.SetAdditionalData("MaxLength", length);
return(column);
}
public static RelationalColumn SetUsedByEtlRunInfo(this RelationalColumn column, bool value = true)
{
column.SetFlag("EtlRunInfo", value);
return(column);
}
internal RelationalColumnPair(RelationalColumn sourceColumn, RelationalColumn targetColumn)
{
SourceColumn = sourceColumn;
TargetColumn = targetColumn;
}
public static RelationalColumn SetHistoryDisabled(this RelationalColumn column, bool value = true)
{
column.SetFlag("NoHistory", value);
return(column);
}
public static bool GetHistoryDisabled(this RelationalColumn column)
{
return(column.GetFlag("NoHistory"));
}
public static bool GetUsedByEtlRunInfo(this RelationalColumn column)
{
return(column.GetFlag("EtlRunInfo"));
}
public static string NameEscaped(this RelationalColumn column, NamedConnectionString connectionString)
{
return(connectionString.Escape(column.Name));
}
public static RelationalColumn SetRecordTimestampIndicator(this RelationalColumn column, bool value = true)
{
column.SetFlag("TimestampIndicator", value);
return(column);
}
private static CustomSqlAdoNetDbReader CreateAutoValidity_ExpandDeferredReaderProcess(AutoValidityRangeBuilder builder, RelationalColumn matchColumn, RelationalColumn[] valueColumns, IReadOnlySlimRow[] rows)
{
var parameters = new Dictionary <string, object>
{
["keyList"] = rows
.Select(row => row.FormatToString(matchColumn.Name))
.Distinct()
.ToArray(),
};
if (builder.TableBuilder.DwhBuilder.Configuration.InfiniteFutureDateTime != null)
{
parameters.Add("InfiniteFuture", builder.TableBuilder.DwhBuilder.Configuration.InfiniteFutureDateTime);
}
return(new CustomSqlAdoNetDbReader(builder.TableBuilder.ResilientTable.Topic, "PreviousValueReader")
{
ConnectionString = builder.TableBuilder.DwhBuilder.ConnectionString,
MainTableName = builder.TableBuilder.Table.EscapedName(builder.TableBuilder.DwhBuilder.ConnectionString),
Sql = "SELECT " + matchColumn.NameEscaped(builder.TableBuilder.DwhBuilder.ConnectionString)
+ "," + string.Join(", ", valueColumns.Select(c => c.NameEscaped(builder.TableBuilder.DwhBuilder.ConnectionString)))
+ " FROM " + builder.TableBuilder.Table.EscapedName(builder.TableBuilder.DwhBuilder.ConnectionString)
+ " WHERE "
+ matchColumn.NameEscaped(builder.TableBuilder.DwhBuilder.ConnectionString) + " IN (@keyList)"
+ " and " + builder.TableBuilder.ValidToColumnNameEscaped + (builder.TableBuilder.DwhBuilder.Configuration.InfiniteFutureDateTime == null ? " IS NULL" : "=@InfiniteFuture"),
InlineArrayParameters = true,
Parameters = parameters,
});
}
public static bool GetRecordTimestampIndicator(this RelationalColumn column)
{
return(column.GetFlag("TimestampIndicator"));
}
