private void CreateAndFillEvents()
{
var creator = new TableBuilder(PostgresFixture.ConnectionString);
creator.CreateTable(typeof(Guid), StreamName);
using (var connection = new NpgsqlConnection(PostgresFixture.ConnectionString))
{
connection.Open();
var id = Guid.NewGuid();
var events = Enumerable
.Range(0, TotalRecords)
.Select(i => i.AsSequence())
.Select(seq => new TestEvent { AggregateID = id, Sequence = seq, Stamp = DefaultStamper.Now() });
using (var writer = connection.BeginBinaryImport("COPY importstream_events(aggregateid, sequence, eventtype, event) from STDIN (format binary)"))
{
foreach (var @event in events)
{
writer.StartRow();
writer.Write(@event.AggregateID.ToString(), NpgsqlDbType.Uuid);
writer.Write((int)@event.Sequence);
writer.Write(@event.GetType().AssemblyQualifiedName);
writer.Write(Serializer.Serialize(@event));
}
}
}
}
public void ForeignKey_should_create_and_add_fk_model()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Foo"
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar"
});
var migration = new TestMigration();
var tableBuilder = new TableBuilder<Columns>(createTableOperation, migration);
tableBuilder.ForeignKey(
"P", c => new
{
c.Foo,
c.Bar
}, true, "my_fk");
Assert.Equal(1, migration.Operations.Count());
var addForeignKeyOperation = migration.Operations.Cast<AddForeignKeyOperation>().Single();
Assert.Equal("P", addForeignKeyOperation.PrincipalTable);
Assert.Equal("Foo", addForeignKeyOperation.DependentColumns.First());
Assert.Equal("Bar", addForeignKeyOperation.DependentColumns.Last());
Assert.True(addForeignKeyOperation.CascadeDelete);
Assert.Equal("my_fk", addForeignKeyOperation.Name);
}
public void PrimaryKey_should_set_key_columns_and_name()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Foo"
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar"
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Baz"
});
var tableBuilder = new TableBuilder<Columns>(createTableOperation, new TestMigration());
tableBuilder.PrimaryKey(
c => new
{
c.Bar,
c.Foo
}, name: "PK_Custom");
Assert.Equal(2, createTableOperation.PrimaryKey.Columns.Count());
Assert.Equal("Bar", createTableOperation.PrimaryKey.Columns.First());
Assert.Equal("Foo", createTableOperation.PrimaryKey.Columns.Last());
Assert.Equal("PK_Custom", createTableOperation.PrimaryKey.Name);
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var urlHelper = new UrlHelper(controllerContext.RequestContext);
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search),
new Link(MaintCultureTextResources.New, urlHelper.Action("Create", "User"), LinkStyle.Button),
new Button(MaintCultureTextResources.Disable, "Disable"),
new Button(MaintCultureTextResources.Enable, "Enable"),
};
var tableBuilder = new TableBuilder<User>();
template.Table = tableBuilder
.Add(tableBuilder.CheckBox(x => x.UserId.Format(), controllerContext, name: "ids"), "", "UserId")
.Add(tableBuilder.Literal(x => x.UserName.Format(), controllerContext), MaintCultureTextResources.AdminUserUserName, "UserName")
.Add(tableBuilder.Literal(x => x.LoginName.Format(), controllerContext), MaintCultureTextResources.AdminUserLoginName, "LoginName")
.Add(tableBuilder.Literal(x => x.Gender.Format(), controllerContext), MaintCultureTextResources.AdminUserGender, "Gender")
.Add(tableBuilder.Literal(x => x.DateOfBirth.Format(), controllerContext), MaintCultureTextResources.AdminUserDateOfBirth, "DateOfBirth")
.Add(tableBuilder.Literal(x => x.IsBuildIn.Format(), controllerContext), MaintCultureTextResources.AdminUserIsBuildIn, "IsBuildIn")
.Add(tableBuilder.Literal(x => x.IsEnabled.Format(), controllerContext), MaintCultureTextResources.AdminUserIsEnabled, "IsEnabled")
.Add(tableBuilder.Literal(x => x.IsSuper.Format(), controllerContext), MaintCultureTextResources.AdminUserIsSuper, "IsSuper")
.Add(x => new ControlCollection(
new Link(MaintCultureTextResources.Edit, urlHelper.Action("Edit", "User", new { id = x.Target.UserId }), LinkStyle.Normal),
new Link(MaintCultureTextResources.UserLoginFailedLogIndex, urlHelper.Action("UserLoginFailedLogIndex", "User", new { UserId = x.Target.UserId }), LinkStyle.Normal)
), MaintCultureTextResources.Operation).Build();
}
public override Column Build(TableBuilder table, ISchemaProvider schemaBuilder, IList<PostProcess> posts)
{
Column col = base.Build(table, schemaBuilder, posts);
col.IsPrimaryKey = true;
col.AllowNull = false;
return col;
}
public void PrimaryKey_should_resolve_names_from_column()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Foo",
ApiPropertyInfo = typeof(Columns).GetProperty("Foo")
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar",
ApiPropertyInfo = typeof(Columns).GetProperty("Bar")
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Baz"
});
var tableBuilder = new TableBuilder<Columns>(createTableOperation, new TestMigration());
tableBuilder.PrimaryKey(
c => new
{
c.Bar,
c.Foo
}, name: "PK_Custom", clustered: false);
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var urlHelper = new UrlHelper(controllerContext.RequestContext);
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search),
new Link(MaintCultureTextResources.New, urlHelper.Action("Create", "Role"), LinkStyle.Button),
new Button(MaintCultureTextResources.Disable, "Disable"),
new Button(MaintCultureTextResources.Enable, "Enable"),
};
var tableBuilder = new TableBuilder<Role>();
template.Table = tableBuilder.Add(tableBuilder.CheckBox(x => x.RoleId.ToString(), controllerContext, "ids"), "", "RoleId")
.Add(tableBuilder.Literal(x => x.Name.Format(), controllerContext), MaintCultureTextResources.RoleName, "Name")
.Add(tableBuilder.Literal(x => x.IsBuildIn.Format(), controllerContext), MaintCultureTextResources.RoleIsBuildIn, "IsBuildIn")
.Add(tableBuilder.Literal(x => x.IsEnabled.Format(), controllerContext), MaintCultureTextResources.RoleIsEnabled, "IsEnabled")
.Add(x =>
{
return new ControlCollection()
{
Controls = new List<Control>
{
new Link(MaintCultureTextResources.Edit, urlHelper.Action("Edit", "Role", new {id = x.Target.RoleId}), LinkStyle.Normal)
}
};
}, MaintCultureTextResources.Operation).Build();
}
public TableInfo CreateTable(string tableName, Action<ITableBuilder> buildAction)
{
var builder = new TableBuilder(tableName);
buildAction(builder);
var tableInfo = builder.Build(_originalSchemaProvider);
return tableInfo;
}
public static TableDescriptor Get()
{
return(TableBuilder <TransactionDisplay> .CreateNew()
.AddColumn(x => x.CreatedTime, new RowOptions
{
SortRenderer = new NoColumnSortRenderer()
})
.AddColumn(x => x.Entity, new RowOptions
{
FilterRenderer =
new ValueObjectColumnFilterRenderer <TransactionDisplay, Entity>(x => x.EntityId,
e => !e.IsSupplier)
})
.AddColumn(x => x.RecipientEntity, new RowOptions
{
FilterRenderer =
new ValueObjectColumnFilterRenderer <TransactionDisplay, Entity>(x => x.RecipientEntityId)
})
.AddColumn(x => x.Amount, new EurRenderer())
.AddColumn(x => x.Note, new RowOptions
{
ColumnRenderer = new NoteRender()
})
.AddColumn(x => x.Category, new RowOptions
{
FilterRenderer =
new ValueObjectColumnFilterRenderer <TransactionDisplay, Category>(x => x.CategoryId)
})
.AddColumn(x => x.Project, new RowOptions
{
FilterRenderer = new ValueObjectColumnFilterRenderer <TransactionDisplay, Project>(x => x.ProjectId)
})
.AddColumn(x => x.Type)
.AddColumn(x => x.Source)
.AddColumn(x => x.Files, new RowOptions
{
ColumnRenderer = new FilesListRenderer(),
SortRenderer = new NoColumnSortRenderer(),
FilterRenderer = new HasFilesFilterRenderer()
})
.QuickMenuAddButton(
new UrlDescriptor(nameof(TransactionsController), nameof(TransactionsController.ExportToCsv)),
"Export to CSV",
MetronicColor.primary)
.QuickMenuAddButton(
null,
"Edit Project and Category",
MetronicColor.primary,
"editProjectAndCategory")
.QuickMenuAddLink(
new UrlDescriptor(nameof(ImportTransactionsController), nameof(ImportTransactionsController.Index)),
"Import Transactions",
"flaticon-cart")
.AddRowsSelect()
.Build());
}
public async Task TestFlexibleColumnNameMatching()
{
var builder = new TableBuilder(nameof(TestFlexibleColumnNameMatching))
.AddColumn("Key_Column1", KuduType.Int32, opt => opt.Key(true))
.AddColumn("key_column2", KuduType.String, opt => opt.Key(true))
.AddColumn("%Columñ 3^&!@#$*", KuduType.String, opt => opt.Nullable(false))
.AddColumn("default.column", KuduType.Double, opt => opt.Nullable(false))
.AddColumn("casetest", KuduType.String, opt => opt.Nullable(false))
.AddColumn("CASETEST", KuduType.String, opt => opt.Nullable(false))
.AddColumn("TakeExact", KuduType.Int32, opt => opt.Nullable(false))
.AddColumn("Take_Exact", KuduType.Int32, opt => opt.Nullable(false));
var values = new[]
{
new UnderscoresRecord(1, "val-1")
{
Column_3 = "test",
DefaultColumn = 1.33d,
CASETEST = "upper-case",
casetest = "lower-case",
TakeExact = 123,
Take_Exact = 456
},
new UnderscoresRecord(2, "val-2")
{
Column_3 = "test-2",
DefaultColumn = 123456789,
CASETEST = "upper-case-2",
casetest = "lower-case-2",
TakeExact = -123,
Take_Exact = -456
}
};
var table = await _client.CreateTableAsync(builder);
var rowsToInsert = values.Select(value =>
{
var insert = table.NewInsert();
insert.SetInt32("Key_Column1", value.KeyColumn1);
insert.SetString("key_column2", value.Key_Column_2_);
insert.SetString("%Columñ 3^&!@#$*", value.Column_3);
insert.SetDouble("default.column", value.DefaultColumn);
insert.SetString("casetest", value.casetest);
insert.SetString("CASETEST", value.CASETEST);
insert.SetInt32("TakeExact", value.TakeExact);
insert.SetInt32("Take_Exact", value.Take_Exact);
return(insert);
});
await _client.WriteAsync(rowsToInsert);
var rows = await ScanAsync <UnderscoresRecord>(table);
Assert.Equal(values, rows);
}
public async Task CacheShouldConsiderColumnName()
{
var builder = new TableBuilder(nameof(CacheShouldConsiderColumnName))
.AddColumn("Column1", KuduType.Int32, opt => opt.Key(true))
.AddColumn("Column2", KuduType.Int32, opt => opt.Key(true));
var values = new[]
{
new SimpleRecord {
Column1 = 1, Column2 = 2
},
new SimpleRecord {
Column1 = 3, Column2 = 4
},
new SimpleRecord {
Column1 = 5, Column2 = 6
},
new SimpleRecord {
Column1 = 7, Column2 = 8
}
};
var table = await _client.CreateTableAsync(builder);
var rowsToInsert = values.Select(value =>
{
var insert = table.NewInsert();
insert.SetInt32("Column1", value.Column1);
insert.SetInt32("Column2", value.Column2);
return(insert);
});
await _client.WriteAsync(rowsToInsert);
var column1Scanner = _client.NewScanBuilder(table)
.SetProjectedColumns("Column1")
.SetReadMode(ReadMode.ReadYourWrites)
.Build();
var column2Scanner = _client.NewScanBuilder(table)
.SetProjectedColumns("Column2")
.SetReadMode(ReadMode.ReadYourWrites)
.Build();
var column1Rows = await column1Scanner.ScanToListAsync <SimpleRecord>();
var column2Rows = await column2Scanner.ScanToListAsync <SimpleRecord>();
Assert.Equal(
values.Select(v => v.Column1),
column1Rows.Select(v => v.Column1));
Assert.Equal(
values.Select(v => v.Column2),
column2Rows.Select(v => v.Column2));
}
protected void Page_Load(object sender, EventArgs e)
{
HelperMethods.ActivityTracker.Track("Activity Tracker", (int)UserActionEnum.Navigated);
if (Page.User.Identity.IsAuthenticated && Session["UserId"] != null && User.IsInRole("Administrator"))
{
if (!IsPostBack)
{
// Declare list of checkbox ids
List <int> activitys = new List <int>();
// CHeck which ones are checked and add to list
if (chkActivityClickedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Clicked);
}
if (chkActivityCreatedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Created);
}
if (chkActivityDeletedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Deleted);
}
if (chkActivityDownloadedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Downloaded);
}
if (chkActivityLoggedInHidden.Checked)
{
activitys.Add((int)UserActionEnum.LoggedIn);
}
if (chkActivityNavigatedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Navigated);
}
if (chkActivitySearchedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Searched);
}
if (chkActivityUpdatedHidden.Checked)
{
activitys.Add((int)UserActionEnum.Updated);
}
// Build dem tables
TableBuilder.BuildUserTrackingTable(tblActivityData, activitys);
// Reinitialized bootstrap sortable table
ScriptManager.RegisterStartupScript(this, this.GetType(), "resortTable", "$.bootstrapSortable(true)", true);
}
}
else
{
Response.Redirect("/Main.aspx");
}
}
public async Task <bool> Export(TrackReportVm source)
{
var saveFileDialog = new SaveFileDialog
{
DefaultExt = @".html",
Filter = @"HTML (.html)|*.html"
};
if (source.Source.SourceTrackFileName != null)
{
saveFileDialog.InitialDirectory = Path.GetDirectoryName(source.Source.SourceTrackFileName);
}
saveFileDialog.FileName = Path.GetFileNameWithoutExtension(source.Source.SourceTrackFileName + "-report.html");
if (saveFileDialog.ShowDialog() != true)
{
return(false);
}
var table = new TableBuilder();
table.Setval(0, 0, Resources.HtmlReportExporter_Export_SectionNumHeader);
table.Setval(1, 0, Resources.HtmlReportExporter_Export_SectionNameHeader);
table.Setval(2, 0, Resources.HtmlReportExporter_Export_SectionDistanceHeader);
table.Setval(3, 0, Resources.HtmlReportExporter_Export_TravelTimeHeader);
table.Setval(4, 0, Resources.HtmlReportExporter_Export_AscentHeader);
table.Setval(5, 0, Resources.HtmlReportExporter_Export_DescentHeader);
table.Setval(6, 0, Resources.HtmlReportExporter_Export_MaxHeightHeader);
foreach (var reportItemVm in source.Results)
{
table.Setval(0, reportItemVm.SectionNumber, reportItemVm.SectionNumber.ToString());
table.Setval(1, reportItemVm.SectionNumber, $@"{reportItemVm.SectionStartName} — {reportItemVm.NextSectionName}");
table.Setval(2, reportItemVm.SectionNumber, (reportItemVm.DistanceMeters / 1e3).ToString(@"0.0", CultureInfo.InvariantCulture));
table.Setval(3, reportItemVm.SectionNumber, (reportItemVm.LebedevHours).ToString(@"0.0", CultureInfo.InvariantCulture));
table.Setval(4, reportItemVm.SectionNumber, (reportItemVm.AscentPerDay).ToString(@"0.0", CultureInfo.InvariantCulture));
table.Setval(5, reportItemVm.SectionNumber, (reportItemVm.DescentPerDay).ToString(@"0.0", CultureInfo.InvariantCulture));
table.Setval(6, reportItemVm.SectionNumber, (reportItemVm.MaxHeight).ToString(@"0.0", CultureInfo.InvariantCulture));
}
var finalrow = source.Results.Count + 2;
table.Setval(0, finalrow, Resources.HtmlReportExporter_Export_TotalsRowLabel);
table.Setval(2, finalrow, source.Totals.DistanceTotalKilometers?.ToString(@"0.0", CultureInfo.InvariantCulture) ?? String.Empty);
table.Setval(4, finalrow, source.Totals.AscentTotalMeters?.ToString(@"0.0", CultureInfo.InvariantCulture) ?? String.Empty);
table.Setval(5, finalrow, source.Totals.DescentTotal?.ToString(@"0.0", CultureInfo.InvariantCulture) ?? String.Empty);
var result = table.Condense();
File.WriteAllText(saveFileDialog.FileName, BuildHtml(result, source));
return(true);
}
public void Get_Info_Or_Default_Not_Registered()
{
ITableBuilder tableBuilder = new TableBuilder();
IEngine engine = new Engine(tableBuilder);
Assert.Null(engine.GetInfoOrDefault(typeof(Person)));
Assert.Null(engine.GetInfoOrDefault(typeof(Employee)));
Assert.Null(engine.GetInfoOrDefault(typeof(Department)));
}
public void Get_Info_Generic_Not_Registered()
{
ITableBuilder tableBuilder = new TableBuilder();
IEngine engine = new Engine(tableBuilder);
Exception ex = Assert.Throws <InvalidConfigurationException>(() => engine.GetInfo <Person>());
Assert.Equal($"The type \"{typeof(Person)}\" is not registered.", ex.Message);
}
public override ISet <Item> CreateSource()
{
var databaseDriver = new SqlDatabaseDriver();
var table = TableBuilder.WithName("Items").WithKeyColumnsFromTypeProperties <Item>().Build();
_fixture.SqlConnectionFixture.DropTable(table.Schema, table.Name);
var mapper = new TypeMapper <Item>(table);
return(new SqlSet <Item>(databaseDriver, _fixture.SqlConnectionFixture.ConnectionString, table, mapper));
}
public void ShouldRunThePhysicsLoop()
{
var table = new TableBuilder()
.AddFlipper("Flipper1")
.Build();
var player = new Player(table).Init();
player.SimulateTime(1000);
}
/// <summary>
/// 配置标题表格
/// </summary>
private void ConfigHeaderTable(TagBuilder builder)
{
var tableBuilder = new TableBuilder();
ConfigTableDefault(tableBuilder);
ConfigSort(tableBuilder);
ConfigContent(tableBuilder);
ConfigHeaderTableRow(tableBuilder);
builder.AppendContent(tableBuilder);
}
/// <summary>
/// Configures the table as temporal.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-temporal">Using SQL Server temporal tables with EF Core</see>
/// for more information.
/// </remarks>
/// <param name="tableBuilder">The builder for the table being configured.</param>
/// <param name="buildAction">An action that performs configuration of the temporal table.</param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static TableBuilder IsTemporal(
this TableBuilder tableBuilder,
Action <TemporalTableBuilder> buildAction)
{
tableBuilder.Metadata.SetIsTemporal(true);
buildAction(new TemporalTableBuilder(tableBuilder.Metadata));
return(tableBuilder);
}
/// <summary>
/// 配置表格
/// </summary>
protected virtual void ConfigTable(TagBuilder builder)
{
var tableBuilder = new TableBuilder();
ConfigTableDefault(tableBuilder);
ConfigSort(tableBuilder);
ConfigContent(tableBuilder);
ConfigRow(tableBuilder);
builder.AppendContent(tableBuilder);
}
// GET: Import
public ActionResult Index()
{
BetterDatabase db = new BetterDatabase();
var season = db.Where<Season>(string.Format("StartYear = {0}", 2014));
var teams = db.Get<Team>();
var matches = db.Where<Falyze.Data.Models.Match>(string.Format("SeasonId = '{0}'", season.First().Id));
ITableBuilder tblBuilder = new TableBuilder(matches, teams);
tblBuilder.AddMatches(matches);
return View();
}
public async Task TestValueTuple()
{
var builder = new TableBuilder(nameof(TestValueTuple))
.AddColumn("key", KuduType.Int32, opt => opt.Key(true))
.AddColumn("column_1", KuduType.Double, opt => opt.Nullable(false))
.AddColumn("column_2", KuduType.Bool, opt => opt.Nullable(false))
.AddColumn("column_3", KuduType.Bool, opt => opt.Nullable(false))
.AddColumn("column_4", KuduType.String);
var values = new[]
/// <summary>
/// 根据条间分页查询所有学员信息
/// </summary>
/// <param name="tab">参数实体</param>
/// <param name="intPageCount">总页数（输出参数）</param>
/// <returns>类型为DataSet的分页学院信息列表集</returns>
public DataSet SelectBypage(TableBuilder tab, out int intPageCount)
{
DataSet ds = pubpro.SelectBypage(tab, out intPageCount);
if (ds != null && ds.Tables[0].Rows.Count > 0)
{
return(ds);
}
return(null);
}
public TableInfo CreateTable(string tableName, Action <ITableBuilder> buildAction)
{
var builder = new TableBuilder(tableName);
buildAction(builder);
var tableInfo = builder.Build(_originalSchemaProvider);
return(tableInfo);
}
public void Get_Info_Or_Default_Generic_Not_Registered()
{
ITableBuilder tableBuilder = new TableBuilder();
IEngine engine = new Engine(tableBuilder);
Assert.Null(engine.GetInfoOrDefault <Person>());
Assert.Null(engine.GetInfoOrDefault <Employee>());
Assert.Null(engine.GetInfoOrDefault <Department>());
}
/// <summary>
/// Configures the table as temporal.
/// </summary>
/// <remarks>
/// See <see href="https://aka.ms/efcore-docs-temporal">Using SQL Server temporal tables with EF Core</see>
/// for more information.
/// </remarks>
/// <typeparam name="TEntity">The entity type being configured.</typeparam>
/// <param name="tableBuilder">The builder for the table being configured.</param>
/// <param name="buildAction">An action that performs configuration of the temporal table.</param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static TableBuilder <TEntity> IsTemporal <TEntity>(
this TableBuilder <TEntity> tableBuilder,
Action <TemporalTableBuilder <TEntity> > buildAction)
where TEntity : class
{
tableBuilder.Metadata.SetIsTemporal(true);
buildAction(new TemporalTableBuilder <TEntity>(tableBuilder.Metadata));
return(tableBuilder);
}
public void NestedTable()
{
//Create a new text document
TextDocument document = new TextDocument();
document.New();
//Create a table for a text document using the TableBuilder
Table table = TableBuilder.CreateTextDocumentTable(
document,
"table1",
"table1",
3,
3,
16.99,
false,
false);
//Create a standard paragraph
Paragraph paragraph = ParagraphBuilder.CreateStandardTextParagraph(document);
//Add some simple text
paragraph.TextContent.Add(new SimpleText(document, "Some cell text"));
Assert.IsNotNull(table.RowCollection, "Must exist.");
Assert.IsTrue(table.RowCollection.Count == 3, "There must be 3 rows.");
//Insert paragraph into the second cell
table.RowCollection[0].CellCollection[1].Content.Add(paragraph);
//Get width of the nested table
double nestedTableWidth = SizeConverter.GetDoubleFromAnOfficeSizeValue(
table.ColumnCollection[0].ColumnStyle.ColumnProperties.Width);
//Create another table using the TableBuilder
Table nestedTable = TableBuilder.CreateTextDocumentTable(
document,
"table1",
"table1",
2,
2,
nestedTableWidth,
false,
false);
//Create a new standard paragraph
paragraph = ParagraphBuilder.CreateStandardTextParagraph(document);
//Add some simple text
paragraph.TextContent.Add(new SimpleText(document, "Some cell text inside the nested table"));
Assert.IsNotNull(nestedTable.RowCollection, "Must exist.");
Assert.IsTrue(nestedTable.RowCollection.Count == 2, "There must be 3 rows.");
//Insert paragraph into the first cell
nestedTable.RowCollection[0].CellCollection[0].Content.Add(paragraph);
//Insert the nested table into the first row and first cell
table.RowCollection[0].CellCollection[0].Content.Add(nestedTable);
Assert.IsTrue(table.RowCollection[0].CellCollection[0].Content[0] is Table, "Must be the nested table.");
//Add table to the document
document.Content.Add(table);
//Save the document
document.SaveTo(AARunMeFirstAndOnce.outPutFolder + "nestedTable.odt");
}
public async Task InitializeAsync()
{
_harness = await new MiniKuduClusterBuilder().BuildHarnessAsync();
_client = _harness.CreateClient();
await using var session = _client.NewSession();
// Create a 4-tablets table for scanning.
var builder = new TableBuilder(_tableName)
.AddColumn("key1", KuduType.String, opt => opt.Key(true))
.AddColumn("key2", KuduType.String, opt => opt.Key(true))
.AddColumn("val", KuduType.String)
.SetRangePartitionColumns("key1", "key2");
for (int i = 1; i < 4; i++)
{
builder.AddSplitRow(splitRow =>
{
splitRow.SetString("key1", i.ToString());
splitRow.SetString("key2", "");
});
}
var table = await _client.CreateTableAsync(builder);
// The data layout ends up like this:
// tablet '', '1': no rows
// tablet '1', '2': '111', '122', '133'
// tablet '2', '3': '211', '222', '233'
// tablet '3', '': '311', '322', '333'
var keys = new[] { "1", "2", "3" };
foreach (var key1 in keys)
{
foreach (var key2 in keys)
{
var insert = table.NewInsert();
insert.SetString(0, key1);
insert.SetString(1, key2);
insert.SetString(2, key2);
await session.EnqueueAsync(insert);
await session.FlushAsync();
}
}
_beforeWriteTimestamp = _client.LastPropagatedTimestamp;
// Reset the client in order to clear the propagated timestamp.
_newClient = _harness.CreateClient();
// Reopen the table using the new client.
_table = await _newClient.OpenTableAsync(_tableName);
_schema = _table.Schema;
}
public void SimpleObjectPrintingTest()
{
var model = new Document
{
Buyer = new Organization
{
Address = "BuyerAddress",
Name = "BuyerName"
},
Supplier = new Organization
{
Address = "SupplierAddress",
Name = "SupplierName"
},
TypeName = "ORDERS"
};
var stringTemplate = new[]
{
new[] { "", "", "", "", "" },
new[] { "", "", "", "", "" },
new[] { "", "Template:RootTemplate:B4:D5", "", "", "" },
new[] { "", "Покупатель:", "Поставщик:", "", "" },
new[] { "", "Value:Organization:Buyer", "Value:Organization:Supplier", "Value::TypeName", "" },
new[] { "", "", "", "", "" },
new[] { "Template:Organization:A8:A9", "", "", "", "" },
new[] { "Value::Name", "", "", "", "" },
new[] { "Value::Address", "", "", "", "" }
};
var template = FakeTable.GenerateFromStringArray(stringTemplate);
var target = new FakeTable(100, 100);
var tableBuilder = new TableBuilder(target, new TableNavigator(new CellPosition("A1"), logger));
var templateEngine = new SkbKontur.Excel.TemplateEngine.TemplateEngine(template, logger);
templateEngine.Render(tableBuilder, model);
target.GetCell(new CellPosition("A1")).StringValue.Should().Be("Покупатель:");
target.GetCell(new CellPosition("B1")).StringValue.Should().Be("Поставщик:");
target.GetCell(new CellPosition("A2")).StringValue.Should().Be("BuyerName");
target.GetCell(new CellPosition("B2")).StringValue.Should().Be("SupplierName");
target.GetCell(new CellPosition("C2")).StringValue.Should().Be("ORDERS");
target.GetCell(new CellPosition("A3")).StringValue.Should().Be("BuyerAddress");
target.GetCell(new CellPosition("B3")).StringValue.Should().Be("SupplierAddress");
((FakeCell)target.GetCell(new CellPosition("A1"))).StyleId.Should().Be("B4");
((FakeCell)target.GetCell(new CellPosition("B1"))).StyleId.Should().Be("C4");
((FakeCell)target.GetCell(new CellPosition("A2"))).StyleId.Should().Be("A8");
((FakeCell)target.GetCell(new CellPosition("B2"))).StyleId.Should().Be("A8");
((FakeCell)target.GetCell(new CellPosition("C2"))).StyleId.Should().Be("D5");
((FakeCell)target.GetCell(new CellPosition("A3"))).StyleId.Should().Be("A9");
((FakeCell)target.GetCell(new CellPosition("B3"))).StyleId.Should().Be("A9");
DebugPrinting(target, new CellPosition(1, 1), new CellPosition(10, 10));
}
public void CanSetBasicProperties()
{
var builder = new TableBuilder()
.SetTableName("table_name")
.SetNumReplicas(3);
var request = builder.Build();
Assert.Equal("table_name", request.Name);
Assert.Equal(3, request.NumReplicas);
}
private void ConfigureDescriptionTable(TableBuilder tableBuilder,
float firstColumnPercent, float secondColumnPercent)
{
tableBuilder
.SetWidth(XUnit.FromPercent(100))
.SetBorder(Stroke.None)
.SetAltRowStyleBackColor(Color.White)
.AddColumnPercentToTable("", firstColumnPercent)
.AddColumnPercentToTable("", secondColumnPercent)
.SetAlignment(HorizontalAlignment.Left);
}
public void TestCase4()
{
var input = "aaaaaaaab";
var expected = new[] { -1, 0, 1, 2, 3, 4, 5, 6, 7 };
var actual = TableBuilder.BuildTable(input.AsReadOnlyList(), EqualityComparer <char> .Default);
_output.WriteLine("Expected:\t{0}", string.Join(", ", expected));
_output.WriteLine("Actual:\t{0}", string.Join(", ", actual));
Assert.Equal(expected, actual);
}
/// <summary>
/// 获取数据
/// </summary>
/// <param name="strWhere">搜索条件</param>
public void getdata(String strWhere)
{
string currentPage = Request.QueryString["currentPage"];
if (currentPage == null || currentPage.Length <= 0)
{
currentPage = "1";
}
string userType = Session["state"].ToString();
string userCollege = "";
//usertype=2 为分院管理员登录
TeacherBll teaBll = new TeacherBll();
if (userType == "2")
{
int userCollegeId = teacher.college.ColID;
if (strWhere == null || strWhere == "")
{
userCollege = "collegeId=" + userCollegeId + "";
}
else
{
userCollege = "collegeId=" + userCollegeId + "and" + "(" + strWhere + ")";
}
TableBuilder tabuilder = new TableBuilder()
{
StrTable = "V_Defence",
StrWhere = userCollege,
IntColType = 0,
IntOrder = 0,
IntPageNum = int.Parse(currentPage),
IntPageSize = pagesize,
StrColumn = "defenGroupId",
StrColumnlist = "*"
};
getCurrentPage = int.Parse(currentPage);
ds = teaBll.SelectBypage(tabuilder, out count);
}
else
{
TableBuilder tabuilder = new TableBuilder()
{
StrTable = "V_Defence",
StrWhere = strWhere == null || strWhere == "" ? "" : strWhere,
IntColType = 0,
IntOrder = 0,
IntPageNum = int.Parse(currentPage),
IntPageSize = pagesize,
StrColumn = "defenGroupId",
StrColumnlist = "*"
};
getCurrentPage = int.Parse(currentPage);
ds = teaBll.SelectBypage(tabuilder, out count);
}
}
public ExamplesBuilder WithExamples(string name, Action <TableBuilder> buildRows)
{
var tableBuilder = new TableBuilder();
buildRows(tableBuilder);
var examples = new Examples(new Tag[0], null, null, name, null, _header, tableBuilder.Rows);
_examples.Add(examples);
return(this);
}
public async Task TestInListHashPartitionPruning()
{
// CREATE TABLE t
// (a INT8, b INT8, c INT8)
// PRIMARY KEY (a, b, c)
// PARTITION BY HASH (a) PARTITIONS 3,
// HASH (b) PARTITIONS 3,
// HASH (c) PARTITIONS 3;
var tableName = nameof(TestInListHashPartitionPruning);
var tableBuilder = new TableBuilder(tableName)
.AddColumn("a", KuduType.Int8, opt => opt.Key(true))
.AddColumn("b", KuduType.Int8, opt => opt.Key(true))
.AddColumn("c", KuduType.Int8, opt => opt.Key(true))
.AddHashPartitions(3, "a")
.AddHashPartitions(3, "b")
.AddHashPartitions(3, "c");
var table = await _client.CreateTableAsync(tableBuilder);
var partitions = await GetTablePartitionsAsync(table);
var a = table.Schema.GetColumn("a");
var b = table.Schema.GetColumn("b");
var c = table.Schema.GetColumn("c");
// a in [0, 1];
await CheckPartitionsAsync(18, 2, table, partitions,
KuduPredicate.NewInListPredicate(a, new byte[] { 0, 1 }));
// a in [0, 1, 8];
await CheckPartitionsAsync(27, 1, table, partitions,
KuduPredicate.NewInListPredicate(a, new byte[] { 0, 1, 8 }));
// b in [0, 1];
await CheckPartitionsAsync(18, 6, table, partitions,
KuduPredicate.NewInListPredicate(b, new byte[] { 0, 1 }));
// c in [0, 1];
await CheckPartitionsAsync(18, 18, table, partitions,
KuduPredicate.NewInListPredicate(c, new byte[] { 0, 1 }));
// b in [0, 1], c in [0, 1];
await CheckPartitionsAsync(12, 12, table, partitions,
KuduPredicate.NewInListPredicate(b, new byte[] { 0, 1 }),
KuduPredicate.NewInListPredicate(c, new byte[] { 0, 1 }));
// a in [0, 1], b in [0, 1], c in [0, 1];
await CheckPartitionsAsync(8, 8, table, partitions,
KuduPredicate.NewInListPredicate(a, new byte[] { 0, 1 }),
KuduPredicate.NewInListPredicate(b, new byte[] { 0, 1 }),
KuduPredicate.NewInListPredicate(c, new byte[] { 0, 1 }));
}
/// <summary>
/// //列表数据获取
/// </summary>
/// <param name="strWhere">查询条件</param>
public void getPage(String strWhere)
{
string currentPage = Request.QueryString["currentPage"];
if (currentPage == null || currentPage.Length <= 0)
{
currentPage = "1";
}
if (userType == "2")
{
//如果登录者是分管 则只查询该分院管理员所在的分院下的专业
Teacher teaAdmin = (Teacher)Session["user"];
int adminCollegeId = teaAdmin.college.ColID;
string addStrWhere = "";
if (strWhere == null || strWhere == "")
{
addStrWhere = "collegeId=" + "'" + adminCollegeId + "'";
}
else
{
addStrWhere = "collegeId=" + "'" + adminCollegeId + "'" + "and " + "(" + strWhere + ")";
}
TableBuilder tabuilder = new TableBuilder()
{
StrTable = "V_Profession",
StrWhere = addStrWhere,
IntColType = 0,
IntOrder = 0,
IntPageNum = int.Parse(currentPage),
IntPageSize = pagesize,
StrColumn = "proId",
StrColumnlist = "*"
};
getCurrentPage = int.Parse(currentPage);
ds = probll2.SelectBypage(tabuilder, out count);
}
else
{
TableBuilder tabuilder = new TableBuilder()
{
StrTable = "V_Profession",
StrWhere = strWhere == null ? "" : strWhere,
IntColType = 0,
IntOrder = 0,
IntPageNum = int.Parse(currentPage),
IntPageSize = pagesize,
StrColumn = "proId",
StrColumnlist = "*"
};
getCurrentPage = int.Parse(currentPage);
ds = probll2.SelectBypage(tabuilder, out count);
}
}
/// <summary>
/// 配置表格
/// </summary>
protected virtual void ConfigTable(TagBuilder builder)
{
var tableBuilder = new TableBuilder();
ConfigTableDefault(tableBuilder);
ConfigStyle(tableBuilder);
ConfigPage(tableBuilder);
AddHead(tableBuilder);
AddRow(tableBuilder);
ConfigContent(tableBuilder);
builder.AppendContent(tableBuilder);
}
/// <summary>
/// 获取基础数据
/// </summary>
/// <returns></returns>
public string getData()
{
//获取分页数据
int currentPage = Convert.ToInt32(Request["page"]);
if (currentPage == 0)
{
currentPage = 1;
}
string search;
if (roleName == "超级管理员")
{
search = "deleteState=0 and state=2";
}
else
{
search = "deleteState=0 and regionId=" + regionId + " and state=2";
}
TableBuilder tb = new TableBuilder();
tb.StrTable = "T_RetailHead";
tb.OrderBy = "dateTime desc";
tb.StrColumnlist = "retailHeadId,kindsNum,number,allTotalPrice,allRealPrice,dateTime";
tb.IntPageSize = pageSize;
tb.IntPageNum = currentPage;
tb.StrWhere = search;
//获取展示的客户数据
ds = retailbll.selectBypage(tb, out totalCount, out intPageCount);
//生成table
StringBuilder strb = new StringBuilder();
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
strb.Append("<tr><td>" + (i + 1 + ((currentPage - 1) * pageSize)) + "</td>");
strb.Append("<td><nobr>" + ds.Tables[0].Rows[i]["retailHeadId"].ToString() + "</nobr></td>");
strb.Append("<td><nobr>" + ds.Tables[0].Rows[i]["kindsNum"].ToString() + "</nobr></td>");
strb.Append("<td>" + ds.Tables[0].Rows[i]["number"].ToString() + "</td>");
strb.Append("<td>" + Double.Parse(ds.Tables[0].Rows[i]["allTotalPrice"].ToString()) + "</td>");
strb.Append("<td>" + ds.Tables[0].Rows[i]["allRealPrice"].ToString() + "</td>");
strb.Append("<td>" + ds.Tables[0].Rows[i]["dateTime"].ToString() + "</td>");
strb.Append("<td style='width:150px;'><button class='btn btn-success btn-sm btn_search'><span class='fa fa-search'></span></button></td></tr>");
}
strb.Append("<input type='hidden' value='" + intPageCount + "' id='intPageCount' />");
string op = Request["op"];
if (op == "paging")
{
Response.Write(strb.ToString());
Response.End();
}
return(strb.ToString());
}
private void FillCallCentersTable(TableBuilder tableBuilder)
{
tableBuilder
.SetBorder(Stroke.None)
.SetWidth(XUnit.FromPercent(70))
.AddColumnPercentToTable("", 40).AddColumnPercent("", 60);
AddCallCenters(tableBuilder, new Field[] {
new Field("TTY:", statementInfo.TTY)
, new Field("Online:", statementInfo.Online)
, new Field("Write:", statementInfo.White)
});
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var tableBuilder = new TableBuilder<ExceptionLog>();
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search),
};
template.Table = tableBuilder
.Add(tableBuilder.Literal(x => x.CreationTime.Format(), controllerContext), MaintCultureTextResources.ExceptionLogCreationTime, "CreationTime")
.Add(tableBuilder.Literal(x => x.RouteData.Format(), controllerContext), MaintCultureTextResources.ExceptionLogRouteData, "RouteData")
.Add(tableBuilder.Literal(x => x.Exception.Format(), controllerContext), MaintCultureTextResources.ExceptionLogException, "Exception")
.Build();
}
public void InheritanceWorks()
{
var fluentMapping = new TableBuilder<Derived>()
.AsPrimaryKey(p => p.Id)
.Build();
SQLiteConnection.RegsiterMappings(new List<TableMapping>{ fluentMapping });
var db = new TestDb();
db.EnsureRegisteredMappings();
var mapping = db.GetMapping<Derived>();
Assert.AreEqual(3, mapping.Columns.Length);
Assert.AreEqual("Id", mapping.PK.Name);
}
public override string Render(int depthLimit, int currentDepth)
{
var tableBuilder = new TableBuilder(base.Metadata);
tableBuilder.AddFragment(
new FragmentBase[]
{
new ComplexTypeTableStartFragment(base.Metadata),
new ComplexTypeTableHeadingFragment(base.Metadata),
new ComplexObjectTableRowsFragment(base.Metadata),
new TableEndFragment(base.Metadata),
});
return tableBuilder.ToString(depthLimit, currentDepth);
}
public bool CreateTable( TableBuilder builder )
{
if ( builder == null ) {
throw new ArgumentException ( "builder cannot be null", "builder" );
}
try {
if ( !TableExists ( builder.Table.Name ) ) {
Console.WriteLine ( "Create Table: {0}", builder.Create ( ) );
this.ExecuteNonQuery ( builder.Create ( ) );
return true;
}
return false;
} catch ( Exception ) {
return false;
}
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var urlHelper = new UrlHelper(controllerContext.RequestContext);
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search),
new Button(MaintCultureTextResources.Delete, "Delete"),
};
var tableBuilder = new TableBuilder<UserLoginFailedLog>();
template.Table = tableBuilder
.Add(tableBuilder.CheckBox(x => x.UserLoginFailedLogId.Format(), controllerContext, name: "ids"), "", "UserLoginFailedLogId")
.Add(x => new Link(x.Target.User.UserName, urlHelper.Action("Edit", "User", new { id = x.Target.UserId })), MaintCultureTextResources.UserLoginFailedLogUser, "CreateTime")
.Add(tableBuilder.Literal(x => x.IpAddress.Format(), controllerContext), MaintCultureTextResources.UserLoginFailedLogIpAddress, "IpAddress")
.Add(tableBuilder.Literal(x => x.CreationTime.Format(), controllerContext), MaintCultureTextResources.UserLoginFailedLogCreateTime, "CreateTime")
.Build();
}
public override Column Build(TableBuilder table, ISchemaProvider schemaProvider, IList<PostProcess> posts)
{
Column col = base.Build(table, schemaProvider, posts);
posts.Add(new PostProcess(
delegate()
{
string fkName = "FK_" +
SchemaUtils.Normalize(table.Name) + "_" +
SchemaUtils.Normalize(col.Name) + "_" +
SchemaUtils.Normalize(targetColName);
schemaProvider.AddForeignKeyConstraint(
table.Name, fkName, col.Name,
targetTable, targetColName);
}));
return col;
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var urlHelper = new UrlHelper(controllerContext.RequestContext);
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search),
new Button(MaintCultureTextResources.Abort, "Abort"),
};
var tableBuilder = new TableBuilder<SystemJob>();
template.Table = tableBuilder
.Add(tableBuilder.CheckBox(x => x.SystemJobId.Format(), controllerContext, name: "ids"), "")
.Add(tableBuilder.Literal(x => x.Title.Format(), controllerContext), MaintCultureTextResources.SystemJobTitle, "Title")
.Add(tableBuilder.Literal(x => x.StartTime.Format(), controllerContext), MaintCultureTextResources.SystemJobStartTime, "StartTime")
.Add(tableBuilder.Literal(x => x.ExecuteTime.Format(), controllerContext), MaintCultureTextResources.SystemJobExecuteTime, "ExecuteTime")
.Add(tableBuilder.Literal(x => x.Status.Format(), controllerContext), MaintCultureTextResources.SystemJobStatus, "Status")
.Add(tableBuilder.Literal(x => x.Result.Format(), controllerContext), MaintCultureTextResources.SystemJobResult, "Result")
.Add(tableBuilder.Literal(x => x.CreationTime.Format(), controllerContext), MaintCultureTextResources.SystemJobCreationTime, "CreationTime")
.Build();
}
partial void OnTemplate(AdministrationSimpleListTemplate template, ControllerContext controllerContext)
{
var urlHelper = new UrlHelper(controllerContext.RequestContext);
template.GlobalButtons = new List<IClickable>
{
new Button(MaintCultureTextResources.Search ),
new Link(MaintCultureTextResources.New, urlHelper.Action("Create", "CultureText", new {cultureId = this.Culture}), LinkStyle.Button),
new Button(MaintCultureTextResources.Delete, "Delete"),
new Link(MaintCultureTextResources.Import, urlHelper.Action("Import", "CultureText", new {cultureId=this.Culture}), LinkStyle.Button),
};
var tableBuilder = new TableBuilder<CultureText>();
template.Table = tableBuilder
.Add(tableBuilder.CheckBox(x => x.CultureTextId.Format(), controllerContext, name: "ids"), "", "CultureTextId")
.Add(tableBuilder.Literal(x => x.Name.Format(), controllerContext), MaintCultureTextResources.AdminUserUserName, "CultureTextName")
.Add(tableBuilder.Literal(x => x.Text.Format(), controllerContext), MaintCultureTextResources.AdminUserLoginName, "CultureTextText")
.Add(tableBuilder.Literal(x => x.IsEdited.Format(), controllerContext), MaintCultureTextResources.AdminUserGender, "CultureTextIsEdited")
.Add(x => new ControlCollection(
new Link(MaintCultureTextResources.Edit, urlHelper.Action("Edit", "CultureText", new { id = x.Target.CultureTextId }), LinkStyle.Normal)
), MaintCultureTextResources.Operation).Build();
}
public void Index_should_add_create_index_operation_to_model()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(new ColumnModel(PrimitiveTypeKind.Guid) { Name = "Foo" });
createTableOperation.Columns.Add(new ColumnModel(PrimitiveTypeKind.Guid) { Name = "Bar" });
var migration = new TestMigration();
var tableBuilder = new TableBuilder<Columns>(createTableOperation, migration);
tableBuilder.Index(c => new { c.Foo, c.Bar }, unique: true);
Assert.Equal(1, migration.Operations.Count());
var createIndexOperation
= migration.Operations.Cast<CreateIndexOperation>().Single();
Assert.Equal("T", createIndexOperation.Table);
Assert.True(createIndexOperation.IsUnique);
Assert.Equal("Foo", createIndexOperation.Columns.First());
Assert.Equal("Bar", createIndexOperation.Columns.Last());
}
public virtual Column Build(TableBuilder table, ISchemaProvider schemaProvider, IList<PostProcess> posts)
{
Column col;
if (colType.HasValue)
{
col = new Column(name, colType.Value, false);
}
else
{
col = new Column(name, type);
}
if (colType.HasValue)
{
col.ColumnType = colType.Value;
}
if (size.HasValue)
{
col.Size = size.Value;
}
if (nullable.HasValue)
{
col.AllowNull = nullable.Value;
}
if (identity.HasValue)
{
col.IsIdentity = identity.Value;
}
if (unique.HasValue)
{
col.IsUnique = unique.Value;
}
colType = col.ColumnType;
return col;
}
public override string Render(int depthLimit, int currentDepth)
{
var tableBuilder = new TableBuilder(base.Metadata);
FragmentBase rowRenderer = base.Metadata.IsEnumerableOfKnownType
? new EnumerableComplexObjectTableRowsFragment(base.Metadata)
: base.Metadata.IsEnumerable && base.Metadata.IsPrimitiveElement
? new PrimitiveEnumerableTableRowsFragment(base.Metadata)
: base.Metadata.IsEnumerable
? new EnumerableObjectTableRowsFragment(base.Metadata) as FragmentBase
: new ComplexObjectTableRowsFragment(base.Metadata);
tableBuilder.AddFragment(
new FragmentBase[]
{
new EnumerableTypeTableStartFragment(base.Metadata),
new EnumerableTypeTableHeadingFragment(base.Metadata),
rowRenderer,
new TableEndFragment(base.Metadata),
});
return tableBuilder.ToString(depthLimit, currentDepth);
}
public void Index_should_add_create_index_operation_to_model()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Foo",
ApiPropertyInfo = typeof(Columns).GetDeclaredProperty("Foo")
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar",
ApiPropertyInfo = typeof(Columns).GetDeclaredProperty("Bar")
});
var migration = new TestMigration();
var tableBuilder = new TableBuilder<Columns>(createTableOperation, migration);
tableBuilder.Index(c => new { c.Foo, c.Bar }, unique: true);
Assert.Equal(1, migration.Operations.Count());
var createIndexOperation = migration.Operations.Cast<CreateIndexOperation>().Single();
Assert.Equal("T", createIndexOperation.Table);
Assert.True(createIndexOperation.IsUnique);
Assert.Equal("Foo", createIndexOperation.Columns.First());
Assert.Equal("Bar", createIndexOperation.Columns.Last());
Assert.False(createIndexOperation.IsClustered);
Assert.True(createIndexOperation.HasDefaultName);
Assert.Equal(createIndexOperation.DefaultName, createIndexOperation.Name);
tableBuilder.Index(c => new { c.Foo, c.Bar }, clustered: true, name: "Goo");
Assert.Equal(2, migration.Operations.Count());
createIndexOperation = migration.Operations.Cast<CreateIndexOperation>().Last();
Assert.Equal("T", createIndexOperation.Table);
Assert.False(createIndexOperation.IsUnique);
Assert.Equal("Foo", createIndexOperation.Columns.First());
Assert.Equal("Bar", createIndexOperation.Columns.Last());
Assert.True(createIndexOperation.IsClustered);
Assert.False(createIndexOperation.HasDefaultName);
Assert.Equal("Goo", createIndexOperation.Name);
}
public void PrimaryKey_should_set_key_columns_name_and_clustered()
{
var createTableOperation = new CreateTableOperation("T");
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Foo",
ApiPropertyInfo = typeof(Columns).GetProperty("Foo")
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Bar",
ApiPropertyInfo = typeof(Columns).GetProperty("Bar")
});
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.Guid)
{
Name = "Baz"
});
var tableBuilder = new TableBuilder<Columns>(createTableOperation, new TestMigration());
tableBuilder.PrimaryKey(
c => new
{
c.Bar,
c.Foo
}, name: "PK_Custom", clustered: false);
Assert.Equal(2, createTableOperation.PrimaryKey.Columns.Count());
Assert.Equal("Bar", createTableOperation.PrimaryKey.Columns.First());
Assert.Equal("Foo", createTableOperation.PrimaryKey.Columns.Last());
Assert.Equal("PK_Custom", createTableOperation.PrimaryKey.Name);
Assert.False(createTableOperation.PrimaryKey.IsClustered);
}
public void CreateTable(string tableName, Action<TableBuilder> table_setup) {
var builder = new TableBuilder(tableName);
table_setup(builder);
builder.Execute(this.Database);
}
static void Main(string[] args)
{
string invokedVerb = null;
object invokedVerbInstance = null;
var options = new Options();
if (!CommandLine.Parser.Default.ParseArguments(args, options,
(verb, subOptions) =>
{
// if parsing succeeds the verb name and correct instance
// will be passed to onVerbCommand delegate (string,object)
invokedVerb = verb;
invokedVerbInstance = subOptions;
}))
{
Environment.Exit(CommandLine.Parser.DefaultExitCodeFail);
}
if (invokedVerb == "list")
{
var listSubOptions = (ListSubOptions)invokedVerbInstance;
if (listSubOptions.Orphaned)
{
Dictionary<CellType, CellInstanceInfo[]> instances = Prison.ListCellInstances();
foreach (CellType cellType in instances.Keys)
{
TableBuilder tb = new TableBuilder();
tb.AddRow(cellType.ToString(), "Info");
tb.AddRow(new string('-', cellType.ToString().Length), "----");
foreach (CellInstanceInfo cellInstance in instances[cellType])
{
tb.AddRow(cellInstance.Name, cellInstance.Info);
}
Console.Write(tb.Output());
Console.WriteLine();
}
}
}
else if (invokedVerb == "list-users")
{
var listUsersSubOptions = (ListUsersSubOptions)invokedVerbInstance;
if (string.IsNullOrWhiteSpace(listUsersSubOptions.Filter))
{
PrisonUser[] users = PrisonUser.ListUsers();
TableBuilder tb = new TableBuilder();
tb.AddRow("Full Username", "Prefix");
tb.AddRow("-------------", "------");
foreach (PrisonUser user in users)
{
tb.AddRow(user.Username, user.UsernamePrefix);
}
Console.Write(tb.Output());
Console.WriteLine();
}
}
}
