public void InsertContentPrefixTest()
{
var table = TableDescriptor.Create <ContentCategory <int, Guid> >();
Assert.Equal("Content_Categories", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentSource <int, Guid> >();
Assert.Equal("Content_Sources", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentClaim <int, int, Guid> >();
Assert.Equal("Content_Claims", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentTag <int, Guid> >();
Assert.Equal("Content_Tags", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentUnit <Guid, int, int, int, Guid> >();
Assert.Equal("Content_Units", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentUnitClaim <int, Guid, int, Guid> >();
Assert.Equal("Content_UnitClaims", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentUnitTag <int, Guid, int> >();
Assert.Equal("Content_UnitTags", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentUnitVisitCount <Guid> >();
Assert.Equal("Content_UnitVisitCounts", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentPane <int, Guid> >();
Assert.Equal("Content_Panes", table.InsertContentPrefix().Name);
table = TableDescriptor.Create <ContentPaneClaim <int, int, int, Guid> >();
Assert.Equal("Content_PaneUnits", table.InsertContentPrefix().Name);
}
private TableDescriptor GetTableDescriptor <T>()
{
var t = typeof(T);
// Descriptor exists, return it.
if (_tableDescriptors.ContainsKey(t))
{
return(_tableDescriptors[t]);
}
// Descriptor doesn't exist, create it, then return it.
lock (_tableDescriptors)
{
// Descriptor was created by the time we got a lock on the collection.
if (_tableDescriptors.ContainsKey(t))
{
return(_tableDescriptors[t]);
}
// Create a new descriptor.
var tableDescriptor = new TableDescriptor(t);
_tableDescriptors.Add(t, tableDescriptor);
return(tableDescriptor);
}
}
protected override ExecutedTable ExecuteCore(HttpExecuteArg args)
{
//{"error":"NO_DATA unknown airline INVALID"}
var result = HttpExecutor.AirlineInfo(args);
if (result.Error != null && result.Error.Type != ApiExecuteErrorType.NoData)
{
Errors.Add(result.Error);
}
if (QueryArgs.ContainsVariable("airlineCode"))
{
result.Data.airlineCode = (string)QueryArgs["airlineCode"].PropertyValue.Value;
}
TableDescriptor tableDescriptor = PropertyDescriptor.GenerateRunDescriptor(typeof(AirlineInfo));
var rows = new List <Row>();
if (result.Error == null)
{
rows.Add(new Row()
{
Values = ToValues(result.Data, tableDescriptor)
});
}
return(new ExecutedTable(tableDescriptor)
{
Rows = rows.ToArray()
});
}
public TableViewModel(TableDescriptor tableDescriptor)
{
Details = tableDescriptor;
LoadColumns();
LoadDataCmd = new RelayCommand(LoadData);
}
private DataTable BuildDataTableDefinition(TableDescriptor table)
{
var dataTable = new DataTable();
foreach (var col in table.Columns)
{
dataTable.Columns.Add(new DataColumn(col.Name.GetName()));
}
dataTable.AcceptChanges();
dataTable.RowChanged += (sender, args) =>
{
dataTable.ExtendedProperties["Changed"] = true;
};
dataTable.TableNewRow += (sender, args) =>
{
dataTable.ExtendedProperties["Changed"] = true;
};
dataTable.RowDeleting += (sender, args) =>
{
dataTable.ExtendedProperties["Changed"] = true;
};
return(dataTable);
}
protected override ExecutedTable ExecuteCore(HttpExecuteArg args)
{
var result = HttpExecutor.GetInFlightInfo(args);
if (result.Error != null && result.Error.Type != ApiExecuteErrorType.NoData)
{
Errors.Add(result.Error);
}
TableDescriptor tableDescriptor = PropertyDescriptor.GenerateRunDescriptor(typeof(InFlightInfo));
var dto = result.Data;
var rows = new List <Row>();
if (result.Error == null)
{
rows.Add(new Row()
{
Values = ToValues(dto, tableDescriptor)
});
}
return(new ExecutedTable(tableDescriptor)
{
Rows = rows.ToArray()
});
}
public MergeDescriptor.Merge Build(TableDescriptor table, string scriptFile, DataTable data = null)
{
var merge = new MergeDescriptor.Merge();
merge.Name = table.Name.ToIdentifier();
if (data == null)
{
merge.Data = BuildDataTableDefinition(table);
}
else
{
merge.Data = data;
}
merge.ScriptDescriptor = new InScriptDescriptor(0, 0, scriptFile);
merge.Statement = new MergeStatement();
merge.Table = table;
merge.Data.AcceptChanges();
merge.Option = new MergeOptions(true, true, true, merge.Table.Columns.Any(p => p.IsKey));
return(merge);
}
public List <MSSQLTable <TableContent, ColumnContent> > Load(params string[] contentFiles)
{
Contract.Requires(contentFiles != null);
Contract.Requires(contentFiles.Length != 0);
List <MSSQLTable <TableContent, ColumnContent> > tables;
#region Load
{
var rows = DataSheetManager.Read(contentFiles[0], TableDescriptor.GetRead("Tables{T}", 3)).Tables[0].Rows.Cast <DataRow>();
if (!string.IsNullOrEmpty(_tableGroupFilter))
{
rows = rows.Where(row => string.Equals(row[2].ToString(), _tableGroupFilter, StringComparison.InvariantCultureIgnoreCase));
}
var tableNames = rows.Select(row => row[1].ToString()).ToArray();
tables = _loader.Load(tableFilter: table => !table.IsView && table.Schema == "DATA" && tableNames.Contains(table.Name));
}
#endregion
#region Prepare content
tables.Handle(PrepareEntityName);
tables.SelectMany(table => table.Columns).Handle(PrepareEntityPropertyName);
#endregion
#region Content load
var contentLoader = MSSQLLoadManager <TableContent, ColumnContent> .Instance.GetContentLoader(tables);
foreach (var contentFile in contentFiles)
{
contentLoader.Load(contentFile);
}
#endregion
return(tables);
}
protected override ExecutedTable ExecuteCore(HttpExecuteArg args)
{
var result = HttpExecutor.AirportInfo(args);
if (result.Error != null)
{
Errors.Add(result.Error);
}
if (QueryArgs.ContainsVariable("airportCode"))
{
result.Data.airportCode = (string)QueryArgs["airportCode"].PropertyValue.Value;
}
TableDescriptor tableDescriptor = PropertyDescriptor.GenerateRunDescriptor(typeof(AirportInfo));
var rows = new List <Row>();
if (result.Error == null)
{
rows.Add(new Row()
{
Values = ToValues(result.Data, tableDescriptor)
});
}
return(new ExecutedTable(tableDescriptor)
{
Rows = rows.ToArray()
});
}
/// <summary>
/// This code works with base engine, no dependency on GridEngine / GridSummaryColumnDescriptor etc.
/// </summary>
string GetAverageSummary(SummaryDescriptor summaryDescriptor, Group group)
{
Table table = group.ParentTable;
TableDescriptor td = table.TableDescriptor;
string summaryText = "";
bool use31Code = true;
if (use31Code)
{
// Option 1: Strong typed access to DoubleAggregateSummary.
DoubleAggregateSummary summary1 = (DoubleAggregateSummary)group.GetSummary(summaryDescriptor);
summaryText = string.Format("{0:c}", summary1.Average);
// or Option 2: Use reflection to get "Average" property of summary
summaryText = string.Format("{0:c}", group.GetSummaryProperty(summaryDescriptor, "Average"));
}
else
{
// This is the code you had to use in version 3.0 and earlier (still working but bit more complicate)
if (summaryDescriptor != null)
{
int indexOfSd1 = table.TableDescriptor.Summaries.IndexOf(summaryDescriptor);
// strong typed - you have to cast to DoubleAggregateSummary.
DoubleAggregateSummary summary1 = (DoubleAggregateSummary)group.GetSummaries(table)[indexOfSd1];
summaryText = string.Format("{0:c}", summary1.Average);
}
}
return(summaryText);
}
public ForeignKeyDescriptor(TableDescriptor descriptor,
ForeignKeyMultplicity multplicity = ForeignKeyMultplicity.OneToOne,bool embedded = false)
{
Descriptor = descriptor;
Multplicity = multplicity;
Embedded = embedded;
}
public ITableBuilder Create(TableDescriptor tableDescriptor)
{
var builder = new FakeTableBuilder();
this.CreatedBuilders.Add(builder);
return(builder);
}
public List <MSSQLTable <TableContent, ColumnContent> > Load(params string[] contentFiles)
{
Contract.Requires(contentFiles != null);
Contract.Requires(contentFiles.Length != 0);
List <MSSQLTable <TableContent, ColumnContent> > tables;
#region Load
{
var rows = DataSheetManager.Read(contentFiles[0], TableDescriptor.GetRead("Tables{T}", 5)).Tables[0].Rows.Cast <DataRow>();
rows = rows.AddFilter(_tableContext, 2).AddFilter(_tableGroup, 3).AddFilter(_tableSubGroup, 4);
var tableNames = rows.Select(row => GetFullTableName(row[0].ToString(), row[1].ToString())).ToArray();
tables = _loader.Load(tableFilter: table => /*!table.IsView &&*/ tableNames.Contains(GetFullTableName(table.Schema, table.Name)));
}
#endregion
#region Prepare content
tables.Handle(PrepareEntityName);
tables.SelectMany(table => table.Columns).Handle(PrepareEntityPropertyName);
#endregion
#region Content load
var contentLoader = MSSQLLoadManager <TableContent, ColumnContent> .Instance.GetContentLoader(tables);
foreach (var contentFile in contentFiles)
{
contentLoader.Load(contentFile);
}
#endregion
return(tables);
}
public static void Table(this IContainer element, Action <TableDescriptor> handler)
{
var descriptor = new TableDescriptor();
handler(descriptor);
element.Element(descriptor.CreateElement());
}
protected override void OnPrepareRemoving(object row)
{
// Save values for all fields where we need to be able to access the
// old value (e.g. Delta for TotalSummaries).
TableDescriptor td = TableDescriptor;
IManualTotalSummaryArraySource tsa = this.TopLevelGroup as IManualTotalSummaryArraySource;
if (tsa != null)
{
foreach (string name in this.totalSummaries)
{
FieldDescriptor fd = td.Fields[name];
if (fd.IsPropertyField())
{
PropertyDescriptor pd = fd.GetPropertyDescriptor();
object value = GetValue(row, pd);
ChangedFieldInfo ci = new ChangedFieldInfo(td, pd.Name, value, null);
this.AddChangedField(ci);
}
}
}
base.OnPrepareRemoving(row);
}
private static bool CutTables(
TableDescriptor descriptor, string reader,
string inputDir, string outputDir)
{
// check reader
if (descriptor.Readers.ContainsKey(reader) == false)
{
Console.Error.WriteLine(string.Format(
"error: reader `{0}` is not defined", reader));
return(false);
}
for (int i = 0; i < descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef tableDef = descriptor.Tables[i];
if (tableDef.Readers.Count == 0 ||
tableDef.Readers.ContainsKey(reader))
{
if (CutTable(tableDef, reader,
inputDir, outputDir) == false)
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Returns list of all tables for current schema and adds empty table to that list.
/// </summary>
/// <returns>
/// Returns list of all tables for current schema and adds empty table to that list.
/// </returns>
private DataTable ReadAllTables()
{
// Enumerate all tables for current schema
DataTable allTables = TableDescriptor.Enumerate(Connection, new object[] { null, Connection.Schema });
if (allTables == null)
{
Debug.Fail("Failed to enumerate all tables");
return(null);
}
// Create new row for empty table value
/*DataRow emptyTable = allTables.NewRow();
* if (emptyTable == null)
* {
* Debug.Fail("Failed to create new row for empty table");
* return allTables;
* }
*
* // Set properties for empty table
* emptyTable[Table.Schema] = Connection.Schema;
* emptyTable[Table.Name] = String.Empty;
*
* // Insert empty table at the begining of all tables and accept changes
* allTables.Rows.InsertAt(emptyTable, 0);
* allTables.AcceptChanges();*/
// Return result
return(allTables);
}
protected override ExecutedTable ExecuteCore(HttpExecuteArg args)
{
var result = HttpExecutor.AirlineFlightSchedule(args);
if (result.Error != null && result.Error.Type != ApiExecuteErrorType.NoData)
{
Errors.Add(result.Error);
}
TableDescriptor tableDescriptor = PropertyDescriptor.GenerateRunDescriptor(typeof(AirlineFlightSchedule));
var rows = new List <Row>();
if (result.Data != null && result.Error == null)
{
foreach (var d in result.Data)
{
var row = new Row()
{
Values = ToValues(d, tableDescriptor)
};
rows.Add(row);
}
}
return(new ExecutedTable(tableDescriptor)
{
Rows = rows.ToArray()
});
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataTableBuilder"/>
/// class for the given table.
/// </summary>
/// <param name="tableDescriptor">
/// A <see cref="TableDescriptor"/> describing the metadata table being
/// built.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="tableDescriptor"/> is <c>null</c>.
/// </exception>
public MetadataTableBuilder(
TableDescriptor tableDescriptor)
{
Guard.NotNull(tableDescriptor, nameof(tableDescriptor));
this.TableDescriptor = tableDescriptor;
}
/// <summary>
/// Sets a potential attachment
/// </summary>
internal void SetAttachmentCandidate(Collection <FeatureTargetGeometry> targetGeometryCollection)
{
if (IsAttachPossible)
{
FeatureTargetGeometry newTo = null;
// Set the target geometry from the full collection of candidates
var attachCandidate = targetGeometryCollection != null && targetGeometryCollection.Count == 1
? targetGeometryCollection[0]
: null;
if (attachCandidate != null)
{
var candidateTables = TableDescriptor.CandidateTableDescriptorsForAttach();
if (candidateTables != null)
{
foreach (var attach in candidateTables)
{
if (attachCandidate.Feature.TableDescriptor.Name == attach.Name)
{
newTo = attachCandidate;
}
}
}
}
AttachTo = newTo;
CalculateState();
}
}
/// <summary>
/// Creates a new <see cref="ITableBuilder"/> to build
/// the metadata table represented by the given descriptor.
/// </summary>
/// <param name="tableDescriptor">
/// The <see cref="TableDescriptor"/> defining the metadata
/// table being built.
/// </param>
/// <returns>
/// A new <see cref="ITableBuilder"/> instance that can be
/// used to build a metadata table.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="tableDescriptor"/> is <c>null</c>.
/// </exception>
public ITableBuilder Create(TableDescriptor tableDescriptor)
{
var builder = new MetadataTableBuilder(tableDescriptor);
this.createdTables.Add(builder);
return(builder);
}
protected override void BuildTableCore(
TableDescriptor tableDescriptor,
Action <ITableBuilder, IDataExtensionRetrieval> createTable,
ITableBuilder tableBuilder)
{
this.BuildTableCoreCalls.Add(Tuple.Create(tableDescriptor, createTable, tableBuilder));
}
public TableItemViewModel(Authentication authentication, TableDescriptor descriptor, object owner)
: base(authentication, descriptor, owner)
{
this.contentDescriptor = descriptor.ContentDescriptor;
this.InsertCommand = new DelegateCommand(async(p) => await this.NewRowAsync());
}
protected override void OnPrepareItemAdded(object row)
{
// Get new values for which delta information is needed
IManualTotalSummaryArraySource tsa = this.TopLevelGroup as IManualTotalSummaryArraySource;
if (tsa != null)
{
TableDescriptor td = TableDescriptor;
foreach (string name in this.totalSummaries)
{
FieldDescriptor fd = td.Fields[name];
if (fd.IsPropertyField())
{
PropertyDescriptor pd = fd.GetPropertyDescriptor();
object value = GetValue(row, pd);
ChangedFieldInfo ci = new ChangedFieldInfo(td, pd.Name, null, value);
this.AddChangedField(ci);
}
}
}
base.OnPrepareItemAdded(row);
}
public void uses_correct_literal_type()
{
var table = _model.GetObject <TSqlTable>(new ObjectIdentifier("dbo", "TheTable"), DacQueryScopes.UserDefined);
Assert.IsNotNull(table);
var descriptor = new TableDescriptor(table);
Assert.AreEqual(LiteralType.Integer, descriptor.Columns.First().DataType);
}
private TableViewerViewModel ViewTable(Authentication authentication, TableDescriptor descriptor, string tableName)
{
this.ValidateViewTable(authentication, descriptor);
var document = new TableViewerViewModel(authentication, descriptor);
document.SelectedTable = document.Tables.FirstOrDefault(item => item.TableName == tableName);
this.Items.Add(document);
return(document);
}
private static void AssertAttributeTranslated(
TableDescriptor original,
TableDescriptor returned)
{
Assert.IsNotNull(original);
Assert.IsNotNull(returned);
Assert.AreEqual(original, returned);
}
protected override void BuildTableCore(
TableDescriptor tableDescriptor,
ITableBuilder tableBuilder)
{
if (tableDescriptor.IsMetadataTable)
{
BuildMetadataTable(tableDescriptor, tableBuilder);
}
}
public TableItemViewModel(Authentication authentication, TableDescriptor descriptor, object owner)
: base(authentication, descriptor, owner)
{
this.contentDescriptor = descriptor.ContentDescriptor;
//if (this.contentDescriptor.TargetDomain is IDomain domain && domain.Source is CremaDataSet dataSet)
//{
// this.dataTable = dataSet.Tables[this.Name];
//}
}
public void InsertContentPrefixTest()
{
var table = TableDescriptor.Create <PortalEditor <Guid, Guid, Guid> >();
Assert.Equal("Portal_Editors", table.InsertPortalPrefix().Name);
table = TableDescriptor.Create <PortalInternalUser <Guid, Guid> >();
Assert.Equal("Portal_InternalUsers", table.InsertPortalPrefix().Name);
}
public void uses_sets_identity_on_identity_columns()
{
var table = _model.GetObject <TSqlTable>(new ObjectIdentifier("dbo", "TheTable"), DacQueryScopes.UserDefined);
Assert.IsNotNull(table);
var descriptor = new TableDescriptor(table);
Assert.IsTrue(descriptor.Columns.First().IsIdentity);
Assert.IsFalse(descriptor.Columns.Last().IsIdentity);
}
