private object GetUniqueValue(string tableName,
ColumnConfig columnConfig,
IDictionary <string, object> obj,
Name.Gender?gender)
{
object existingValue = obj[columnConfig.Name];
//create a unique key
string uniqueCacheKey = $"{tableName}.{columnConfig.Name}";
//if this table/column combination hasn't been seen before add an empty hash set
if (!_uniqueValues.ContainsKey(uniqueCacheKey))
{
_uniqueValues.AddOrUpdate(uniqueCacheKey, new HashSet <object>(), (a, b) => b);
}
//grab the hash set for this table/column
HashSet <object> uniqueValues = _uniqueValues[uniqueCacheKey];
int totalIterations = 0;
do
{
IDataProvider dataProvider = this.GetDataProvider(columnConfig.Type);
existingValue = dataProvider.GetValue(columnConfig, obj, gender);
totalIterations++;
if (totalIterations >= MAX_UNIQUE_VALUE_ITERATIONS)
{
throw new Exception($"Unable to generate unique value for {uniqueCacheKey}, attempt to resolve value {totalIterations} times");
}
}while (uniqueValues.Contains(existingValue));
uniqueValues.Add(existingValue);
return(existingValue);
}
protected virtual int?GetSequence(Playlist playlist, int sequence, QueryOperator @operator, OrderByDirection direction)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
var query = this.SequenceQueries.GetOrAdd(
new Tuple <QueryOperator, OrderByDirection>(@operator, direction),
key =>
{
var table = database.Tables.PlaylistItem;
var column = table.GetColumn(ColumnConfig.By("Sequence"));
var builder = database.QueryFactory.Build();
builder.Output.AddColumn(column);
builder.Source.AddTable(table);
builder.Filter.AddColumn(table.GetColumn(ColumnConfig.By("Playlist_Id")));
builder.Filter.AddColumn(column).Operator = builder.Filter.CreateOperator(@operator);
builder.Sort.AddColumn(column).Direction = direction;
return(builder.Build());
}
);
return(database.ExecuteScalar <int?>(query, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["playlistId"] = playlist.Id;
parameters["sequence"] = sequence;
break;
}
}, transaction));
}
}
}
private void PrepopulatedFiltering(ColumnConfig config, PropertyInfo propInfo, TableNode filter,
IEnumerable <string> filterValues)
{
TableNode dropDown = this.CreateAndAppend("div", filter);
TagBuilder dropDownBtn = new TagBuilder("button");
TagBuilder dropDownMenu = new TagBuilder("ul");
TagBuilder dropDownCaret = new TagBuilder("span");
dropDown.Element.AddCssClass("dropdown");
dropDown.Element.InnerHtml.AppendHtml(dropDownBtn);
this.AddCssClasses(config.Filtering.CssClasses, dropDownMenu);
dropDownBtn.AddCssClass("btn");
dropDownBtn.AddCssClass("btn-default");
dropDownBtn.AddCssClass("dropdown-toggle");
dropDownBtn.Attributes.Add("type", "button");
dropDownBtn.Attributes.Add("data-toggle", "dropdown");
dropDownBtn.Attributes.Add("aria-haspopup", "true");
dropDownBtn.Attributes.Add("aria-expanded", "false");
if (_tableState.Filters.ContainsKey(propInfo.Name))
{
// Currently selected filter value.
dropDownBtn.InnerHtml.Append(_tableState.Filters[propInfo.Name].Value);
}
dropDownBtn.InnerHtml.AppendHtml(dropDownCaret);
dropDown.Element.InnerHtml.AppendHtml(dropDownMenu);
dropDownMenu.AddCssClass("dropdown-menu");
dropDownCaret.AddCssClass("caret");
this.AddFilterSelection(dropDownMenu, propInfo.Name, " ", true);
foreach (var filterValue in filterValues)
{
this.AddFilterSelection(dropDownMenu, propInfo.Name, filterValue);
}
}
public void Log_AutonumberSeedAlreadySet_AutoNumberSeedRequestNotAdded()
{
// Arrage
this.crmServiceAdapterMock
.Setup(x => x.Execute(It.IsAny <GetAutoNumberSeedRequest>()))
.Returns(() =>
{
return(new GetAutoNumberSeedResponse {
Results = { { "AutoNumberSeedValue", 1000L } }
});
});
List <TableConfig> tableConfigs = new List <TableConfig>();
ColumnConfig[] tableColumns = new ColumnConfig[]
{
GetAutonumberColumnConfig("test_autonumberone", 1000),
};
tableConfigs.Add(GetTableConfig("test_table", tableColumns));
// Act
this.tableColumnProcessingService.ProcessTables(tableConfigs);
// Assert
this.loggerMock.VerifyLog(x => x.LogInformation("Auto-number seed test_autonumberone for test_table is already set to value: 1000"));
this.loggerMock.VerifyLog(x => x.LogInformation("No requests for Auto-number seeds were added."));
this.crmServiceAdapterMock.Verify(svc => svc.Execute(It.IsAny <GetAutoNumberSeedRequest>()));
this.crmServiceAdapterMock.VerifyNoOtherCalls();
}
public LegalObject CheckLegal(ColumnConfig colConfig, ObjectData data)
{
return(new LegalObject()
{
IsLegal = true
});
}
public async Task Refresh()
{
using (var database = this.DatabaseFactory.Create())
{
var table = database.Tables.PlaylistItem;
var query = database.QueryFactory.Build();
var column = table.GetColumn(ColumnConfig.By("Sequence"));
query.Output.AddColumn(column);
query.Source.AddTable(table);
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
using (var reader = database.ExecuteReader(query, transaction))
{
using (var sequence = reader.GetAsyncEnumerator())
{
this.Sequences.Clear();
this.Position = 0;
while (await sequence.MoveNextAsync().ConfigureAwait(false))
{
this.Sequences.Add(sequence.Current.Get <int>(column));
}
this.Sequences.Shuffle();
}
}
}
}
}
/// <summary>
/// 初始化列渲染器
/// </summary>
/// <param name="config">配置</param>
public ColumnRender(ColumnConfig config) : base(config)
{
_config = config;
_tableId = config.TableId;
_autoCreateHeaderCell = config.AutoCreateHeaderCell();
_autoCreateCell = config.AutoCreateCell();
}
public void Initialize(PageConfigView pageView, FormConfigView formView, ColumnConfig columnConfig, PageStyle style)
{
this.PageView = pageView;
this.FormView = formView;
this.Config = columnConfig;
this.ViewPageStyle = style;
}
public static void Format(ColumnConfig cc, TableDefinition table, SnapshotColumnInfo column)
{
cc.Heading(column.Name);
if (column.ObservedTypes.All(NumericTypeHelper.IsNumeric))
{
cc.RightAlign();
}
}
public ColumnBuilderTest()
{
_columnConfig = new ColumnConfig {
Filtering = new FilteringConfig()
};
_builderFactory = Substitute.For <IBuilderFactory>();
_builder = new ColumnBuilder(_columnConfig, _builderFactory);
}
private static void SetCommonColumnOptions(ColumnConfig source, SqlColumn target)
{
SetProperty.IfProvidedNotEmpty <string>(source, nameof(target.ColumnName), value => target.ColumnName = value);
SetProperty.IfProvided <string>(source, nameof(target.DataType), value => target.SetDataTypeFromConfigString(value));
SetProperty.IfProvided <bool>(source, nameof(target.AllowNull), value => target.AllowNull = value);
SetProperty.IfProvided <int>(source, nameof(target.DataLength), value => target.DataLength = value);
SetProperty.IfProvided <bool>(source, nameof(target.NonClusteredIndex), value => target.NonClusteredIndex = value);
}
public void DefaultColumnFormatHasNoFixedWidth()
{
//Arrange
var format = new ColumnConfig(null);
format.MakeFormat<int>();
//Assert
Assert.That(format.ColumnFormat.FixedWidth, Is.EqualTo(0));
}
public void DefaultColumnFormatCorrectColumnType()
{
//Arrange
var format = new ColumnConfig(null);
format.MakeFormat<int>();
//Assert
Assert.That(format.ColumnFormat.Type, Is.EqualTo(typeof(int)));
}
public void DefaultColumnFormatHasNoHeading()
{
//Arrange
var format = new ColumnConfig(null);
format.MakeFormat<int>();
//Assert
Assert.That(format.ColumnFormat.Heading, Is.Null);
}
private static SqlDbType GetTypeForColumn(ColumnConfig columnConfig)
{
return(columnConfig.DataType switch
{
"string" => SqlDbType.VarChar,
"decimal" => SqlDbType.Decimal,
"int" => SqlDbType.Int,
_ => throw new ArgumentOutOfRangeException(nameof(columnConfig), "DataType " + columnConfig.DataType + " not supported")
});
private async Task <IEnumerable <T> > FindAllFilteredByIsDeleted(ColumnConfig isDeletedColumnProprety)
{
StringBuilder query = GenerateFindQuery();
List <(string, object)> parameter;
(query, parameter) = AddFilterToQuery(query, null, (isDeletedColumnProprety, false));
return(await QueryAsync <T>(query.ToString(), parameter.ToArray()));
}
/// <summary>
/// Configures a column.
/// </summary>
/// <typeparam name="TVal"></typeparam>
/// <param name="expression">Column property expression.</param>
/// <returns>Column builder.</returns>
public MvcCoreBootstrapTableColumnBuilder Column <TVal>(Expression <Func <T, TVal> > expression)
{
string columnProperty = ((MemberExpression)expression.Body).Member.Name;
ColumnConfig columnConfig = new ColumnConfig();
_columnConfigs.Add(columnProperty, columnConfig);
return(_builderFactory.ColumnBuilder(columnConfig));
}
/// <summary>
/// Sets a place holder text for the text input.
/// </summary>
/// <param name="placeHolder">Place holder text.</param>
/// <returns>The form row builder instance.</returns>
public MvcCoreBootstrapFormRowBuilder Column(ColumnWidth width, IHtmlContent content)
{
ColumnConfig column = new ColumnConfig {
Width = width, Content = content
};
_config.Columns.Add(column);
return(this);
}
public async Task <bool> Update(Guid id, T entity)
{
ColumnConfig idColumnProprety = _entityMappingConfig.GetPrimaryKeyColumnProprety();
(StringBuilder query, List <(string, object)> parameter) = GenerateUpdateQuery(entity);
(query, parameter) = AddFilterToQuery(query, parameter, (idColumnProprety, id));
return((await ExecuteAsync(query.ToString(), parameter.ToArray())) > 0);
}
public async Task <T> FindById(Guid id)
{
ColumnConfig idColumnProprety = _entityMappingConfig.GetPrimaryKeyColumnProprety();
StringBuilder query = GenerateFindQuery();
List <(string, object)> parameter;
(query, parameter) = AddFilterToQuery(query, null, (idColumnProprety, id));
return(await QueryFirstOrDefaultAsync <T>(query.ToString(), parameter.ToArray()));
}
/// <summary>
/// Gets the value mapping.
/// </summary>
/// <param name="columnConfig">The column configuration.</param>
/// <param name="existingValue">The existing value.</param>
/// <returns></returns>
private object GetValueMapping(
ColumnConfig columnConfig,
object existingValue)
{
if (columnConfig.UseGlobalValueMappings)
{
return(_globalValueMappings[columnConfig.Name][existingValue]);
}
return(columnConfig.ValueMappings[existingValue]);
}
public void ColumnWidthCanBeSet()
{
//Arrange
var config = new ColumnConfig(_stringExp);
config.MakeFormat<string>();
//Act
config.Width(6);
//Assert
Assert.That(config.ColumnFormat.FixedWidth, Is.EqualTo(6));
}
public void ColumnProportionalWidthCanBeSet()
{
//Arrange
var config = new ColumnConfig(_stringExp);
config.MakeFormat<string>();
//Act
config.ProportionalWidth(8.4);
//Assert
Assert.That(config.ColumnFormat.ProportionalWidth, Is.EqualTo(8.4));
}
/// <summary>
/// Determines whether [has value mapping] [the specified column configuration].
/// </summary>
/// <param name="columnConfig">The column configuration.</param>
/// <param name="existingValue">The existing value.</param>
/// <returns>
/// <c>true</c> if [has value mapping] [the specified column configuration]; otherwise, <c>false</c>.
/// </returns>
private bool HasValueMapping(
ColumnConfig columnConfig,
object existingValue)
{
if (columnConfig.UseGlobalValueMappings)
{
return(_globalValueMappings.ContainsKey(columnConfig.Name) &&
_globalValueMappings[columnConfig.Name]
.ContainsKey(existingValue));
}
return(columnConfig.UseLocalValueMappings && columnConfig.ValueMappings.ContainsKey(existingValue));
}
public async Task <IEnumerable <T> > FindAll(bool ignoreLogicDeletation = false)
{
ColumnConfig isDeletedColumnProprety = _entityMappingConfig.GetLogicalDeletionColumnProprety();
if (!ignoreLogicDeletation && isDeletedColumnProprety != null)
{
return(await FindAllFilteredByIsDeleted(isDeletedColumnProprety));
}
StringBuilder query = GenerateFindQuery();
return(await QueryAsync <T>(query.ToString()));
}
public object GetValue(ColumnConfig columnConfig, IDictionary <string, object> obj, Name.Gender?gender)
{
DynamicParameters dynamicParameters = new DynamicParameters(obj);
object newValue = _connection.ExecuteScalar(columnConfig.SqlValue.Query, dynamicParameters);
if (newValue == null && columnConfig.SqlValue.ValueHandling == NotFoundValueHandling.KeepValue)
{
newValue = obj[columnConfig.Name];
}
return(newValue);
}
public string GetGridData(DataTableAjaxPostModel model)
{
try
{
ColumnConfig columnConfig = new ColumnConfig(model);
var aaData = columnConfig.gridParams.GetData();
return(aaData);
}
catch (Exception ex)
{
return(ex.ToString());
}
}
private void IterateProperties(T entity, Action <PropertyInfo, ColumnConfig> action)
{
foreach (var property in entity.GetType().GetProperties())
{
ColumnConfig columnConfig = _config.Columns.ContainsKey(property.Name)
? _config.Columns[property.Name]
: null;
if (columnConfig == null || columnConfig.Visible)
{
action(property, columnConfig);
}
}
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="columnConfig">The column configuration.</param>
/// <param name="existingValue">The existing value.</param>
/// <param name="gender">The gender.</param>
/// <returns></returns>
public object GetValue(
ColumnConfig columnConfig,
IDictionary <string, object> obj,
Name.Gender?gender)
{
object existingValue = obj[columnConfig.Name];
if (columnConfig.ValueMappings == null)
{
columnConfig.ValueMappings = new Dictionary <object, object>();
}
if (!string.IsNullOrEmpty(columnConfig.UseValue))
{
return(ConvertValue(columnConfig.Type, columnConfig.UseValue));
}
if (columnConfig.RetainNullValues &&
existingValue == null)
{
return(null);
}
if (columnConfig.RetainEmptyStringValues &&
(existingValue is string && string.IsNullOrWhiteSpace((string)existingValue)))
{
return(existingValue);
}
if (existingValue == null)
{
return(GetValue(columnConfig, gender));
}
if (HasValueMapping(columnConfig, existingValue))
{
return(GetValueMapping(columnConfig, existingValue));
}
object newValue = GetValue(columnConfig, gender);
if (columnConfig.UseGlobalValueMappings ||
columnConfig.UseLocalValueMappings)
{
AddValueMapping(columnConfig, existingValue, newValue);
}
return(newValue);
}
private void refreshList()
{
// Setup Columns
ColorColumnConfig = new ColumnConfig();
var columns = new ObservableCollection <Column>();
columns.Add(new Column()
{
DataField = "DominoColor.mediaColor", Header = ""
});
columns.Add(new Column()
{
DataField = "DominoColor.name", Header = "Name"
});
columns.Add(new Column()
{
DataField = "DominoColor.count", Header = "Total"
});
columns.Add(new Column()
{
DataField = "ProjectCount[0]", Header = "Used", HighlightDataField = "DominoColor.count"
});
columns.Add(new Column()
{
DataField = "ProjectCount[1]", Header = "Selected"
});
ColorColumnConfig.Columns = columns;
_DominoList.Clear();
int counter = 0;
foreach (DominoColor domino in CurrentProject.colors.RepresentionForCalculation.OfType <DominoColor>())
{
_DominoList.Add(new ColorListEntry()
{
DominoColor = domino, SortIndex = CurrentProject.colors.Anzeigeindizes[counter]
});
counter++;
}
if (CurrentProject.colors.RepresentionForCalculation.OfType <EmptyDomino>().Count() == 1)
{
_DominoList.Add(new ColorListEntry()
{
DominoColor = CurrentProject.colors.RepresentionForCalculation.OfType <EmptyDomino>().First(), SortIndex = -1
});
}
}
private async Task <bool> LogicDeletation(Guid id, ColumnConfig isDeletedColumnProprety)
{
ColumnConfig idColumnProprety = _entityMappingConfig.GetPrimaryKeyColumnProprety();
StringBuilder query = new StringBuilder();
List <(string, object)> parameter = new List <(string, object)>();
query.AppendLine("UPDATE " + _tableName + " set ");
query.AppendLine(isDeletedColumnProprety.ColumnName + " = @" + isDeletedColumnProprety.ColumnName);
parameter.Add(("@" + isDeletedColumnProprety.ColumnName, true));
(query, parameter) = AddFilterToQuery(query, parameter, (idColumnProprety, id));
return((await ExecuteAsync(query.ToString(), parameter.ToArray())) > 0);
}
public void SetUp()
{
_collection = new SnapshotCollection();
_collection.DefineTable(TestTableName).CompareKey("Id");
_table = _collection.GetTableDefinition(TestTableName);
_snapshot = _collection.NewSnapshot("Test");
//Borrow a column config so that we can test with it.
void ExtractColumnDefForTest(ColumnConfig config)
{
_cc = config;
}
var report = new[] { "T" }.AsReport(rep => rep.AddColumn(t => t, ExtractColumnDefForTest));
}
private static UIElement ResolveNewElement(ColumnConfig columnConfig, string content)
{
switch (columnConfig.ItemType)
{
case Enums.ItemType.Text:
{
var newTextblock = new TextBlock()
{
Text = $"TextBlock: {content}",
Margin = new Thickness(5)
};
return(newTextblock);
};
case Enums.ItemType.TextArea:
{
var newTextBox = new TextBox()
{
Text = $"TextBox: {content}",
Margin = new Thickness(5)
};
return(newTextBox);
};
case Enums.ItemType.Checkbox:
{
var newCheckbox = new CheckBox()
{
IsChecked = content == "true" ? true : false,
Margin = new Thickness(5)
};
return(newCheckbox);
};
case Enums.ItemType.ComboBox:
{
var newComboBox = new ComboBox()
{
Text = content,
Margin = new Thickness(5)
};
return(newComboBox);
};
default: return(null);
}
}
public IHtmlContent Render()
{
TagBuilder row = new TagBuilder("div")
{
TagRenderMode = TagRenderMode.StartTag
};
//IList<TagBuilder> columns = new List<TagBuilder>();
TextWriter writer = new StringWriter();
row.AddCssClass("row");
row.WriteTo(writer, HtmlEncoder.Default);
for (var i = 0; i < _config.Columns.Count; i++)
{
ColumnConfig columnConfig = _config.Columns.ElementAt(i);
TagBuilder column = new TagBuilder("div");
column.AddCssClass(columnConfig.Width.CssClass());
column.InnerHtml.AppendHtml(columnConfig.Content);
column.WriteTo(writer, HtmlEncoder.Default);
}
/*foreach(ColumnConfig columnConfig in _config.Columns)
* {
* TagBuilder column = new TagBuilder("div") {TagRenderMode = TagRenderMode.StartTag};
*
* column.AddCssClass(columnConfig.Width.CssClass());
* columns.Add(column);
* row.WriteTo(writer, HtmlEncoder.Default);
* }
*
* //_contentWriter.WriteLine(row.AsString());
* for(var i = 0; i < columns.Count; i++)
* {
* TagBuilder column = columns.ElementAt(i);
*
* _contentWriter.WriteLine(column.AsString());
* _contentWriter.WriteLine(_config.Columns.ElementAt(i).Content.AsString());
* column.TagRenderMode = TagRenderMode.EndTag;
* _contentWriter.WriteLine(column.AsString());
* }*/
row.TagRenderMode = TagRenderMode.EndTag;
row.WriteTo(writer, HtmlEncoder.Default);
//_contentWriter.WriteLine(row.AsString());
return(new HtmlString(writer.ToString()));
}
public void Log_NoAutonumbersProcessed_NoRequestsAdded()
{
// Arrange
List <TableConfig> tableConfigs = new List <TableConfig>();
ColumnConfig[] tableColumns = new ColumnConfig[]
{
GetAutonumberColumnConfig("test_name", null),
};
tableConfigs.Add(GetTableConfig("test_table", tableColumns));
// Act
this.tableColumnProcessingService.ProcessTables(tableConfigs);
// Assert
this.loggerMock.VerifyLog(x => x.LogInformation("No requests for Auto-number seeds were added."));
}
public static BaseRuleProcessor GetRuleProcessor(ColumnConfig columnConfig, GenProcessor engine)
{
BaseRuleProcessor processor = null;
switch (columnConfig.RuleType)
{
case "RegularExpressionRuleProcessor":
processor = RegularExpressionRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "AutoGenIntRuleProcessor":
processor = AutoGenIntRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "ArithmeticRuleProcessor":
processor = ArithmeticRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "DriverLabelRuleProcessor":
processor = DriverLabelRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "FilesTypeRuleProcessor":
processor = FilesTypeRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "ConditionalRuleProcessor":
processor = ConditionalRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
case "SimpleReplacementRuleProcess":
processor = SimpleReplacementRuleProcess.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
default:
processor = DefaultRuleProcessor.CreateOrGetProcessor(engine);
processor.Rule = columnConfig.Rule;
break;
}
return processor;
}
public void HeadingCanBeSet()
{
//Arrange
var config = new ColumnConfig(_stringExp);
config.MakeFormat<string>();
//Act
config.Heading("text");
//Assert
Assert.That(config.ColumnFormat.Heading, Is.EqualTo("text"));
}
public void LeftAlignmentCanBeSet()
{
//Arrange
var config = new ColumnConfig(_intExp);
config.MakeFormat<int>();
//Act
config.LeftAlign();
//Assert
Assert.That(config.ColumnFormat.Alignment, Is.EqualTo(ColumnAlign.Left));
}
public void DecimalPlacesCanBeSet()
{
//Arrange
var config = new ColumnConfig(_doubleExp);
config.MakeFormat<double>();
//Act
config.DecimalPlaces(6);
//Assert
Assert.That(config.ColumnFormat.DecimalPlaces, Is.EqualTo(6));
}
public void RightAlignmentCanBeSet()
{
//Arrange
var config = new ColumnConfig(_stringExp);
config.MakeFormat<string>();
//Act
config.RightAlign();
//Assert
Assert.That(config.ColumnFormat.Alignment, Is.EqualTo(ColumnAlign.Right));
}
internal void AddColumn(ColumnConfig config)
{
_columns.Add(config.ColumnFormat);
}
