private IXLWorksheet exportAllCompetitors(XLWorkbook workBook, int competitionId)
{
var worksheet = workBook.Worksheets.Add("Popis Igrača");
using (var competitorsService = new CompetitorService())
{
var categoryId = DbContext.Competitions.Where(x => x.Id == competitionId).Select(x => x.IdCategory).First();
var competitions = DbContext.Competitions.Where(x => x.IdCategory == categoryId).ToList();
var startRow = 2;
foreach (var competition in competitions)
{
worksheet.Cell(startRow, 2).Value = competition.DisplayName;
worksheet.Range(startRow, 2, startRow, 4).Merge().AddToNamed("Titles");
startRow++;
var competitors = competitorsService.GetCompetitors(competition.Id);
var dataTable = ColumnDefinitionFactory.GenerateDataTable(competitors);
worksheet.Cell(startRow, 2).InsertTable(dataTable.AsEnumerable());
startRow += dataTable.Rows.Count + 2;
}
}
worksheet.Columns().AdjustToContents();
return(worksheet);
}
public void FromDataTypeString()
{
var factory = new ColumnDefinitionFactory();
DataType dataType = new DataType(SqlDbType.VarChar);
ColumnDefinition actual = factory.FromDataType(dataType, "n1");
Assert.IsInstanceOfType(actual, typeof(StringColumnDefinition));
}
public void FromDataTypeInteger()
{
var factory = new ColumnDefinitionFactory();
DataType dataType = new DataType(SqlDbType.Int);
ColumnDefinition actual = factory.FromDataType(dataType, "n1");
Assert.IsInstanceOfType(actual, typeof(IntegerColumnDefinition));
}
public void FromDataTypeDecimal()
{
var factory = new ColumnDefinitionFactory();
DataType dataType = new DataType(SqlDbType.Decimal);
ColumnDefinition actual = factory.FromDataType(dataType, "n1");
Assert.IsInstanceOfType(actual, typeof(DecimalColumnDefinition));
}
public void FromDataTypeDateTime()
{
var factory = new ColumnDefinitionFactory();
DataType dataType = new DataType(SqlDbType.DateTime);
ColumnDefinition actual = factory.FromDataType(dataType, "n1");
Assert.IsInstanceOfType(actual, typeof(StandardColumnDefinition));
}
public void ConstructedColumnHasUniqueId()
{
// Act
var c1 = ColumnDefinitionFactory.Construct(ColumnType.Activity, new ulong[] { 1 }, new ulong[] { 2 });
var c2 = ColumnDefinitionFactory.Construct(ColumnType.Activity, new ulong[] { 1 }, new ulong[] { 2 });
// Assert
Assert.AreNotEqual(Guid.Empty, c1.Id);
Assert.AreNotEqual(Guid.Empty, c2.Id);
Assert.AreNotEqual(c1.Id, c2.Id);
}
protected override void ExecuteFinishCommand()
{
var type = GetProperty <ColumnType>(ColumnTypeKey);
var sourceAccounts = GetProperty <ulong[]>(SourceAccountsKey);
var targetAccounts = GetProperty <ulong[]>(TargetAccountsKey);
var newCol = ColumnDefinitionFactory.Construct(type, sourceAccounts, targetAccounts);
ColumnList.AddColumns(new[] { newCol });
base.ExecuteFinishCommand();
}
public static void Main(string[] args)
{
try {
if (!ReadSettings(args))
{
Console.ReadKey();
return;
}
string[] tableNames = Parameters.Singleton.Tables;
/*new[] {
* "ce1bp01.2016", "ce1bp01.2017", "ce2bp01.2016", "ce2bp01.2017", "cobk.2016_001", "cobk.2017_001", "coep.2016_001", "coep.2017_001",
* "faglflexa.2016_001", "faglflexa.2017_001", "faglflext.2016", "faglflext.2017",
* "tvkot", "tvtwt", "tvkbt", "tvgrt", "t171t", "tbrct", "t179t", "t001w", "csks", "cskst", "t001", "t001b", "cska", "csku", "skat",
* "cepct", "setheader", "setheadert", "setnode", "setleaf", "fagl_011pc", "fagl_011zc", "fagl_011sc", "fagl_011qt", "aufk", "mara"
* };*/
IOutputWriter writer = new SingleFileWriter(Parameters.Singleton.CreateFileName, Parameters.Singleton.InsertFileName);
foreach (string tableName in tableNames)
{
Console.WriteLine($"Processing file {tableName}");
string tableDefinition = CreateTableDefinition(tableName);
string formatFile;
string bulkInsert;
string create;
using (DataSourceFactory factory = new DataSourceFactory()) {
ITableDataSource source = factory.GetDataSourceForTable(tableName);
List <ColumnDefinition> colDefinition = ColumnDefinitionFactory.GetColumnDefinitionsForTable(tableDefinition)
.Where(col => source.UsesColumn(col)).ToList();
List <ColumnDefinition> sourceOrderedColumnDefinitions = source.Reorder(colDefinition);
CreateGenerator createGenerator = new CreateGenerator(tableDefinition, colDefinition);
create = createGenerator.BuildCreate(out formatFile, source.IsQuoteEnclosed);
IInsertGenerator insertGenerator = new BulkInsertGenerator(tableDefinition, source, tableName);
if (source is ExcelTableDataSource)
{
insertGenerator = new InlineInsertGenerator(tableDefinition, source, colDefinition, sourceOrderedColumnDefinitions);
}
bulkInsert = insertGenerator.BuildInsert();
}
writer.TableName = tableName;
writer.TableDefinition = tableDefinition;
writer.CreateScript = create;
writer.Format = formatFile;
writer.BulkInsertScript = bulkInsert;
writer.Write();
}
Console.WriteLine("Completed all tables successfully");
} catch (Exception e) {
Console.WriteLine(e);
Console.ReadKey();
}
}
public async Task <ColumnDefinition[]> SelectAccountColumnTypes(ulong accountId)
{
ulong[] sourceAccounts = { accountId };
ulong[] targetAccounts = { accountId };
Func <IColumnTypeSelectionDialogViewModel, ColumnDefinition[]> resultSetup = vm =>
{
return(vm.AvailableColumnTypes.Where(c => c.IsSelected).Select(c => c.Content.Type)
.Select(type => ColumnDefinitionFactory.Construct(type, sourceAccounts, targetAccounts)).ToArray());
};
return(await ShowWindow <AccountColumnsDialog, IColumnTypeSelectionDialogViewModel, ColumnDefinition[]>(resultSetup));
}
public async Task <IHttpActionResult> GetCompetitors(int competitionId)
{
using (var competitorService = new CompetitorService())
{
var competitorColumns = ColumnDefinitionFactory.ExtractColumnDefinitions(typeof(CompetitionInfo));
var competitors = competitorService.GetCompetitors(competitionId);
return(Ok(new CompetitiorInfoDTO()
{
Columns = competitorColumns,
Competitors = competitors
}));
}
}
public void FromRawDateTime()
{
var source = new ColumnDefinitionRaw
{
Name = "C1",
DataType = "DateTime",
AllowNulls = false,
};
var factory = new ColumnDefinitionFactory();
var actual = factory.FromRaw(new[] { source }).ToList();
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(source.Name, actual[0].Name);
Assert.IsInstanceOfType(actual[0], typeof(StandardColumnDefinition));
Assert.AreEqual(SqlDbType.DateTime, actual[0].DataType.SqlType);
Assert.AreEqual(source.AllowNulls, actual[0].AllowNulls);
}
public List <ColumnDefinition> GetPlayerViewModelColumns()
{
return(ColumnDefinitionFactory.ExtractColumnDefinitions(typeof(TableTennisTournamentPlayerVM)));
}
public void FromRawDecimal()
{
var source = new ColumnDefinitionRaw
{
Name = "C1",
DataType = "Decimal",
Size = 10,
DecimalPlaces = 2
};
var factory = new ColumnDefinitionFactory();
var actual = factory.FromRaw(new[] { source }).ToList();
Assert.AreEqual(SqlDbType.Decimal, actual[0].DataType.SqlType);
Assert.IsInstanceOfType(actual[0], typeof(DecimalColumnDefinition));
Assert.AreEqual(source.Size, ((DecimalColumnDefinition)actual[0]).Precision);
Assert.AreEqual(source.DecimalPlaces, ((DecimalColumnDefinition)actual[0]).Scale);
}
public void FromRawStringWithSize()
{
var source = new ColumnDefinitionRaw
{
Name = "C1",
DataType = "VarChar",
Size = 10
};
var factory = new ColumnDefinitionFactory();
var actual = factory.FromRaw(new[] { source }).ToList();
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(SqlDbType.VarChar, actual[0].DataType.SqlType);
Assert.IsInstanceOfType(actual[0], typeof(StringColumnDefinition));
Assert.AreEqual(source.Size, ((StringColumnDefinition)actual[0]).Size);
}
public void FromRawNumeric()
{
var source = new ColumnDefinitionRaw
{
Name = "C1",
DataType = "Numeric",
};
var factory = new ColumnDefinitionFactory();
var actual = factory.FromRaw(new[] { source }).ToList();
Assert.AreEqual(SqlDbType.Decimal, actual[0].DataType.SqlType);
}
public void FromRawIntegerWithIdentity()
{
var source = new ColumnDefinitionRaw
{
Name = "C1",
DataType = "Int",
AllowNulls = false,
IdentitySeed = 1
};
var factory = new ColumnDefinitionFactory();
var actual = factory.FromRaw(new[] { source }).ToList();
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(SqlDbType.Int, actual[0].DataType.SqlType);
Assert.IsInstanceOfType(actual[0], typeof(IntegerColumnDefinition));
Assert.AreEqual(source.IdentitySeed, ((IntegerColumnDefinition)actual[0]).IdentitySeed);
}
