/// <summary>
/// Binds <see cref="IColumns"/> to <see cref="ValidationPlaceholder"/>.
/// </summary>
/// <param name="source">The source <see cref="IColumns"/>.</param>
/// <param name="bindings">The bindings to determine whether the <see cref="ValidationPlaceholder"/> is active.</param>
/// <returns>The row binding object.</returns>
public static RowBinding <ValidationPlaceholder> BindToValidationPlaceholder(this IColumns source, params RowBinding[] bindings)
{
source.VerifyNotNull(nameof(source));
source = source.Seal();
var result = new RowBinding <ValidationPlaceholder>(onSetup: (v, p) =>
{
if (bindings != null && bindings.Length > 0)
{
var containingElements = new UIElement[bindings.Length];
for (int i = 0; i < containingElements.Length; i++)
{
containingElements[i] = bindings[i].GetSettingUpElement();
}
v.Setup(containingElements);
}
}, onRefresh: null, onCleanup: (v, p) =>
{
v.Cleanup();
});
var input = result.BeginInput(new ValueChangedTrigger <ValidationPlaceholder>(source, result));
foreach (var column in source)
{
input.WithFlush(column, (r, v) => true);
}
return(input.EndInput());
}
private void ExpandColumns(IColumns columns, TreeNode node)
{
if (HasBlankNode(node))
{
foreach (IColumn column in columns)
{
TreeNode n = new TreeNode(column.Name);
n.Tag = new NodeData(NodeType.COLUMN, column);
if (!column.IsInPrimaryKey)
{
n.SelectedImageIndex = n.ImageIndex = 10;
}
else
{
n.SelectedImageIndex = n.ImageIndex = 26;
}
node.Nodes.Add(n);
if (column.ForeignKeys.Count > 0)
{
TreeNode nn = new TreeNode("ForeignKeys");
nn.Tag = new NodeData(NodeType.FOREIGNKEYS, column.ForeignKeys);
nn.SelectedImageIndex = nn.ImageIndex = 11;
n.Nodes.Add(nn);
nn.Nodes.Add(this.BlankNode);
}
}
}
}
/// <summary>
/// Setup the flushing operation.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="valueBagGetter">The delegate to get column value bag.</param>
/// <returns>This row input for fluent coding.</returns>
public RowInput <T> WithFlush(Column column, Func <T, ColumnValueBag> valueBagGetter)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (valueBagGetter == null)
{
throw new ArgumentNullException(nameof(valueBagGetter));
}
VerifyNotSealed();
_target = _target.Union(column);
_flushFuncs.Add((rowPresenter, element) =>
{
if (valueBagGetter == null)
{
return(false);
}
var value = valueBagGetter(element)[column];
if (object.Equals(rowPresenter[column], value))
{
return(false);
}
rowPresenter[column] = value;
return(true);
});
return(this);
}
private bool HasError(RowPresenter rowPresenter, IColumns columns)
{
if (ErrorsByRow.Count == 0)
{
return(false);
}
IDataValidationErrors errors;
if (!ErrorsByRow.TryGetValue(rowPresenter, out errors))
{
return(false);
}
for (int i = 0; i < errors.Count; i++)
{
var message = errors[i];
if (message.Source.SetEquals(columns))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Setup the flushing operation.
/// </summary>
/// <typeparam name="TData">Data type of column.</typeparam>
/// <param name="column">The column.</param>
/// <param name="getValue">The delegate to return data value.</param>
/// <returns>This row input for fluent coding.</returns>
public RowInput <T> WithFlush <TData>(Column <TData> column, Func <T, TData> getValue)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
VerifyNotSealed();
_target = _target.Union(column);
_flushFuncs.Add((p, v) =>
{
if (getValue == null)
{
return(false);
}
var value = getValue(v);
if (column.AreEqual(p.GetValue(column), value))
{
return(false);
}
p.EditValue(column, value);
return(true);
});
return(this);
}
/// <summary>Determines whether the current columns is a proper (strict) subset of the specified columns.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns><see langword="true"/> if the current set is a proper subset of the specified collection; otherwise, <see langword="false" />.</returns>
public static bool IsProperSubsetOf(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
return(source.Count < other.Count ? other.ContainsAll(source) : false);
}
/// <summary>Determines whether the current columns is a superset of a specified columns.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns><see langword="true"/> if the current set is a superset of the specified collection; otherwise, <see langword="false" />.</returns>
public static bool IsSupersetOf(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
return(source.Count >= other.Count ? source.ContainsAll(other) : false);
}
/// <summary>Ensures set contain only elements that are present either in the current columns or in the specified columns, but not both.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns>A new set if there is any modification to current sealed set; otherwise, the current set.</returns>
public static IColumns SymmetricExcept(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
IColumns removedColumnSet = Columns.Empty;
foreach (var column in source)
{
if (other.Contains(column))
{
removedColumnSet = removedColumnSet.Add(column);
source = source.Remove(column);
}
}
foreach (var column in other)
{
if (removedColumnSet.Contains(column))
{
source = source.Add(column);
}
}
return(source);
}
private static void AddModel(IColumns databaseObject)
{
string schema;
if (mappingRuleManager.IsIncluded(databaseObject))
{
schema = databaseObject.Schema.ToPascalCase();
if (!mapping.ModelNamespaces.Contains(schema))
{
mapping.ModelNamespaces.Add(new ModelNamespace()
{
Name = schema
});
}
Model model = new Model()
{
Namespace = schema,
Name = mappingRuleManager.TrimPrefix(databaseObject).ToPascalCase().ToSingular(),
Description = databaseObject.Description,
IsView = databaseObject is View,
MappingName = databaseObject.ToString()
};
LoadProperties(model.Properties, databaseObject);
mapping.ModelNamespaces[schema].Models.Add(model);
}
}
internal bool HasError(RowPresenter rowPresenter, IColumns source, bool isAsync)
{
IReadOnlyDictionary <RowPresenter, IDataValidationErrors> dictionary = isAsync ? _asyncErrorsByRow : _errorsByRow;
if (dictionary != null)
{
IDataValidationErrors errors;
if (dictionary.TryGetValue(rowPresenter, out errors))
{
if (errors != null && errors.Count > 0 && HasError(rowPresenter, errors, source, !isAsync))
{
return(true);
}
}
}
if (isAsync && rowPresenter == CurrentRow)
{
foreach (var asyncValidator in AsyncValidators)
{
if (asyncValidator.GetFault(source) != null)
{
return(true);
}
}
}
return(false);
}
/// <summary>Determines whether the current columns and the specified columns contain the same elements.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns><see langword="true"/> if the current set and the specified columns contain the same elements; otherwise, <see langword="false" />.</returns>
public static bool SetEquals(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
return(source.Count == other.Count ? source.ContainsAll(other) : false);
}
/// <summary>
/// ���캯��
/// </summary>
/// <param name="name">��ͼ����</param>
/// <param name="comment">��ע</param>
public View(string name, string comment)
{
this.name = name;
this.comment = comment;
this.code = string.Empty;
columns = null;
}
private string name; // ����
#endregion Fields
#region Constructors
/// <summary>
/// Ĭ�Ϲ��캯��
/// </summary>
public View()
{
this.name = string.Empty;
this.comment = string.Empty;
this.code = string.Empty;
columns = null;
}
public static void ImportChildRelations(ITable srcTab, TableDefinitionDataTable destTabs)
{
foreach (IForeignKey srcFK in srcTab.ForeignKeys)
{
if (srcTab == srcFK.PrimaryTable) // use only childrelations
{
TableDefinitionRow childTab = destTabs.FindByTableName(srcFK.ForeignTable.Name);
TableDefinitionRow parentTab = destTabs.FindByTableName(srcFK.PrimaryTable.Name);
if ((childTab == null) || (parentTab == null))
{
return; // both tables are not included
}
String relationName =
parentTab.Table.DataSet.RelationDefinition.CreateUniqueRelationName(srcFK.Name, childTab.TableName, parentTab.TableName);
RelationDefinitionRow curRelation = parentTab.InsertNewRelation(relationName, childTab.TableName);
IColumns parentColums = srcFK.PrimaryColumns;
IColumns childColums = srcFK.ForeignColumns;
FieldRelationDefinitionRow curFieldRelation = null;
for (int colNo = 0; colNo < parentColums.Count; colNo++)
{
curFieldRelation = curRelation.InsertNewFieldRelation(parentColums[colNo].Name, childColums[colNo].Name);
}
} // if (srcTab == srcFK.PrimaryTable) // use only childrelations
} // foreach (IForeignKey srcFK in srcTab.ForeignKeys)
}
private static string GetName(IColumns databaseObject, string columnName)
{
if (databaseObject is Table)
{
var foreignKeys = (databaseObject as Table).ForeignKeys;
foreach (ForeignKey fk in foreignKeys)
{
if (fk.Columns.Count == 1 && fk.Columns[0].Name == columnName)
{
return(MappingHelper.GetPascalCase(MappingHelper.TrimId(columnName)));
}
}
}
if (columnName.EndsWith("_Id", StringComparison.OrdinalIgnoreCase))
{
string referenceName = MappingHelper.TrimId(columnName);
foreach (Table tb in database.Tables)
{
if (mappingConfig.Model.TrimName(tb) == referenceName)
{
return(MappingHelper.GetPascalCase(referenceName));
}
}
}
return(MappingHelper.GetPascalCase(columnName));
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectRequest" /> class. Initialise une nouvelle instance de la
/// classe <see cref="SelectRequest" />.
/// </summary>
/// <param name="nomTable">The nomTable.</param>
internal SelectRequest(string nomTable)
: this()
{
this.listeColumns = new List <string>();
this.PrincipalTable = new Table(nomTable);
this.selectColumns = new Columns(this.PrincipalTable);
this.joins = new Joins();
}
private void UpdateAsyncErrors(IColumns changedColumns)
{
Debug.Assert(CurrentRow != null);
var errors = GetErrors(_asyncErrorsByRow, CurrentRow);
errors = Remove(errors, x => x.Source.Overlaps(changedColumns));
UpdateAsyncErrors(CurrentRow, errors);
}
public static void ImportFields(IColumns srcColumns, TableDefinitionRow destTab)
{
nextPkNumber = 1;
foreach (IColumn srcCol in srcColumns)
{
ImportField(srcCol, destTab);
}
}
public Extractor(Func <object> construct, IColumns columns)
{
Construct = construct;
Columns = columns;
Properties = _Properties();
Converters = Default;
}
/// <summary>
/// Setup the flushing operation.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="flush">The delegate to flush input.</param>
/// <returns>This row input for fluent coding.</returns>
public RowInput <T> WithFlush(Column column, Func <RowPresenter, T, bool> flush)
{
column.VerifyNotNull(nameof(column));
flush.VerifyNotNull(nameof(flush));
VerifyNotSealed();
_target = _target.Union(column);
_flushFuncs.Add(flush);
return(this);
}
private static bool ContainsAll(this IColumns source, IColumns other)
{
foreach (var column in other)
{
if (!source.Contains(column))
{
return(false);
}
}
return(true);
}
private static void Restore(IColumns progress, Dictionary <RowPresenter, IColumns> progressByRow, RowPresenter currentRow)
{
if (progress == Columns.Empty && progressByRow.ContainsKey(currentRow))
{
progressByRow.Remove(currentRow);
}
else
{
progressByRow[currentRow] = progress;
}
}
private static string GetDefaultDisplayName(IColumns sourceColumns)
{
if (sourceColumns.Count == 1)
{
return(sourceColumns.First <Column>().DisplayName);
}
else
{
return(string.Format("[{0}]", string.Join(", ", sourceColumns.Select(x => x.DisplayName))));
}
}
/// <summary>Ensures set contain all elements that are present in either the current columns or in the specified columns.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The collection to add elements from.</param>
/// <returns>A new set if there is any modification to current set and current set sealed; otherwise, the current set.</returns>
public static IColumns Union(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
foreach (var column in other)
{
source = source.Add(column);
}
return(source);
}
private static JsonWriter WriteColumns(this JsonWriter jsonWriter, IColumns columns)
{
if (columns == null)
{
jsonWriter.WriteNameValuePair(SOURCE, JsonValue.Null);
}
else
{
jsonWriter.WriteNameStringPair(SOURCE, columns.Serialize());
}
return(jsonWriter);
}
internal void OnValueChanged(Column column)
{
if (IsValueChangedNotificationSuspended)
{
if (_pendingValueChangedColumns != null)
{
_pendingValueChangedColumns = _pendingValueChangedColumns.Add(column);
}
return;
}
NotifyValueChanged(column);
}
private int CountUniqueFields(IColumns Columns)
{
int i = 0;
foreach (IColumn c in Columns)
{
if (!c.IsNullable && c.IsInPrimaryKey)
{
i++;
}
}
return(i);
}
private int CountNullableFields(IColumns Columns)
{
int i = 0;
foreach (IColumn c in Columns)
{
if (c.IsNullable)
{
i++;
}
}
return(i);
}
/// <summary>Removes the columns to ensure the set contains only columns both exist in the current columns and the specified columns.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns>A new set of columns if there is any modification to current sealed set; otherwise, the current set.</returns>
public static IColumns Intersect(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
foreach (var column in source)
{
if (!other.Contains(column))
{
source = source.Remove(column);
}
}
return(source);
}
/// <summary>Determines whether the current columns overlaps with the specified columns.</summary>
/// <param name="source">The current columns.</param>
/// <param name="other">The columns to compare to the current columns.</param>
/// <returns><see langword="true"/> if the current set overlaps with the specified columns; otherwise, <see langword="false" />.</returns>
public static bool Overlaps(this IColumns source, IColumns other)
{
source.VerifyNotNull(nameof(source));
other.VerifyNotNull(nameof(other));
foreach (var column in source)
{
if (other.Contains(column))
{
return(true);
}
}
return(false);
}
private string GetDisplayNames(IColumns columns)
{
if (columns.Count == 0)
{
return(null);
}
else if (columns.Count == 1)
{
return(columns.Single().DisplayName);
}
else
{
return(string.Format("({0})", string.Join(", ", columns.Select(x => x.DisplayName))));
}
}
/// <summary>
/// Determines whether validation error is visible.
/// </summary>
/// <param name="rowPresenter">The <see cref="RowPresenter"/>.</param>
/// <param name="columns">The columns.</param>
/// <returns><see langword="true"/> if validation error is visible, otherwise <see langword="false"/>.</returns>
public bool IsVisible(RowPresenter rowPresenter, IColumns columns)
{
rowPresenter.VerifyNotNull(nameof(rowPresenter));
if (columns == null || columns.Count == 0)
{
return(false);
}
if (_progress == null)
{
return(true);
}
return(Exists(_progress, rowPresenter, columns));
}
private void BuildPublicAccessors(IColumns Columns)
{
if (Columns.Count > 0)
{
output.writeln("\t\t#region Public Properties");
foreach (IColumn field in Columns)
{
if (IsInColumns(field))
{
string fieldAccessor = ColumnToPropertyName(field);
string fieldName = ColumnToMemberVariable(field);
string fieldType = (field.IsInForeignKey && !field.IsInPrimaryKey ? ToPascalCase(field.ForeignKeys[0].PrimaryTable.Alias.Replace(" ", "")) : ColumnToNHibernateType(field));
output.writeln("");
//output.writeln( "\t\t/// <summary>" );
//foreach( string s in field.Description.Split( new char[] { '\n' } ) )
//{
// output.writeln( "\t\t/// " + s );
//}
//output.writeln( "\t\t/// </summary>" );
output.write(ActiveRecordColumnAttributes(field));
if (field.IsNullable && IsValueType(field.LanguageType))
output.writeln("\t\tpublic " + fieldType + "? " + fieldAccessor + "{ get; set; }");
else
output.writeln("\t\tpublic " + fieldType + " " + fieldAccessor + "{ get; set; }");
}
}
output.writeln("\n\t\t#endregion");
}
}
private int CountRequiredFields(IColumns Columns)
{
return Columns.Count - CountNullableFields(Columns);
}
private int CountUniqueFields(IColumns Columns)
{
int i = 0;
foreach (IColumn c in Columns)
{
if (!c.IsNullable && c.IsInPrimaryKey)
{
i++;
}
}
return i;
}
private void GenerateClassTableHeader(IColumns Columns)
{
output.writeln("/*");
output.writeln(" * This class maps to " + _tableName + " with the following columns:");
foreach (IColumn field in Columns)
{
string propertyName = field.Name + "(" + ColumnToPropertyName(field) + ")";
string fpname = String.Format("{0,-40}", propertyName);
output.write(" * \t " + fpname);
output.write("| Type:" + String.Format("{0,-10}", field.DataTypeName));
output.write("| Len:" + String.Format("{0,-4}", field.CharacterMaxLength));
output.write("| Nullable:" + String.Format("{0,-1}", field.IsNullable ? "T" : "F"));
output.write("| PK:" + String.Format("{0,-1}", field.IsInPrimaryKey ? "T" : "F"));
output.write("| FK:=" + String.Format("{0,-1}", field.IsInForeignKey ? "T" : "F"));
output.writeln("");
}
output.writeln(" */");
}
public static void ImportFields(IColumns srcColumns, TableDefinitionRow destTab)
{
nextPkNumber = 1;
foreach(IColumn srcCol in srcColumns)
ImportField(srcCol, destTab);
}
private int CountNullableFields(IColumns Columns)
{
int i = 0;
foreach (IColumn c in Columns)
{
if (c.IsNullable)
{
i++;
}
}
return i;
}
private void ExpandColumns(IColumns columns, TreeNode node)
{
if(HasBlankNode(node))
{
foreach(IColumn column in columns)
{
TreeNode n = new TreeNode(column.Name);
n.Tag = new NodeData(NodeType.COLUMN, column);
if(!column.IsInPrimaryKey)
n.SelectedImageIndex = n.ImageIndex = 10;
else
n.SelectedImageIndex = n.ImageIndex = 13;
node.Nodes.Add(n);
if(column.ForeignKeys.Count > 0)
{
TreeNode nn = new TreeNode("ForeignKeys");
nn.Tag = new NodeData(NodeType.FOREIGNKEYS, column.ForeignKeys);
nn.SelectedImageIndex = nn.ImageIndex = 11;
n.Nodes.Add(nn);
nn.Nodes.Add(this.BlankNode);
}
}
}
}
public CategoryTable(IColumns columns, IDatabase database)
{
this._database = database;
this._columns = columns;
}
