public CSIProductConfigurationSqlServerRepository(ISqlServerDataProvider dataProvider, ICSIProductConfigurationSqlServerDataMapper <T> mapper)
: base(dataProvider, (ISqlServerDataMapper <T>)mapper)
{
_dataProvider = dataProvider;
_mapper = mapper;
_tableName = typeof(T).Name;
}
public CSIProductConfigurationSqlServerRepository(ISqlServerDataProvider provider, ICSIProductConfigurationSqlServerDataMapper <T> mapper, string tableName)
: base(provider, (ISqlServerDataMapper <T>)mapper)
{
_dataProvider = provider;
_mapper = mapper;
_tableName = tableName;
}
public JSONImporter(ISqlServerDataProvider dataProvider)
{
if (dataProvider == null)
{
throw new ArgumentNullException("SqlServerDataProvider");
}
this.fullPath = baseDir + jsonPath + jsonFileName;
this.dataProvider = dataProvider;
}
public PdfReportGenerator(ISqlServerDataProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException("SqlServerDataProvider");
}
this.provider = provider;
this.ReportType = reportType;
}
public ExcelImporter(ISqlServerDataProvider dataProvider, IModelsFactory modelsFactory)
{
this.dataProvider = dataProvider;
this.modelsFactory = modelsFactory;
this.pointDistributionsFilePath = this.solutionDirectory + "\\Data\\Excel\\Sample Data\\TournamentCategoryPoints.xlsx";
this.playersFilePath = this.solutionDirectory + "\\Data\\Excel\\Sample Data\\players-2016.xlsx";
this.matchesFilePath = this.solutionDirectory + "\\Data\\Excel\\Sample Data\\matches-2016.xlsx";
this.tournamentsFilePath = this.solutionDirectory + "\\Data\\Excel\\Sample Data\\tournaments-2016.xlsx";
}
public ImportMatchesCommand(ISqlServerDataProvider dataProvider,
IModelsFactory modelsFactory,
IExcelImporter excelImporter,
IWriter writer,
ILogger logger)
{
this.dataProvider = dataProvider;
this.modelsFactory = modelsFactory;
this.excelImporter = excelImporter;
this.writer = writer;
this.logger = logger;
}
public ImportSampleDataCommand(ISqlServerDataProvider dataProvider,
IModelsFactory modelsFactory,
IExcelImporter excelImporter,
IWriter writer,
ILogger logger,
ICommandFactory commandsFactory)
{
this.dataProvider = dataProvider;
this.modelsFactory = modelsFactory;
this.excelImporter = excelImporter;
this.writer = writer;
this.logger = logger;
this.commandsFactory = commandsFactory;
}
public AddCityCommand(ISqlServerDataProvider sqlDP, IWriter writer)
{
if (sqlDP == null)
{
throw new ArgumentNullException("Data provider cannot be null!");
}
if (writer == null)
{
throw new ArgumentNullException("Writer cannot be null!");
}
this.dp = sqlDP;
this.writer = writer;
}
private void InitialiseRepositories(ISqlServerDataProvider dataProvider)
{
ExpressionRepository = new GenericSqlServerRepository <Expression>(dataProvider, new SqlServerDataMapper <Expression>());
CaseRepository = new GenericSqlServerRepository <Case>(dataProvider, new SqlServerDataMapper <Case>());
CaseValueRepository = new GenericSqlServerRepository <CaseValue>(dataProvider, new SqlServerDataMapper <CaseValue>());
ConditionRepository = new GenericSqlServerRepository <Condition>(dataProvider, new SqlServerDataMapper <Condition>());
ConfigurationRepository = new GenericSqlServerRepository <Configuration>(dataProvider, new SqlServerDataMapper <Configuration>());
ConfigurationParameterValueRepository = new GenericSqlServerRepository <ConfigurationParameterValue>(dataProvider, new SqlServerDataMapper <ConfigurationParameterValue>());
ConfigurationTypeRepository = new GenericSqlServerRepository <ConfigurationType>(dataProvider, new SqlServerDataMapper <ConfigurationType>());
ConfigurationTypeOutputRepository = new GenericSqlServerRepository <ConfigurationTypeOutput>(dataProvider, new SqlServerDataMapper <ConfigurationTypeOutput>());
ConfigurationTypeParameterRepository = new GenericSqlServerRepository <ConfigurationTypeParameter>(dataProvider, new SqlServerDataMapper <ConfigurationTypeParameter>());
ConstantRepository = new GenericSqlServerRepository <Constant>(dataProvider, new SqlServerDataMapper <Constant>());
CustomerRepository = new GenericSqlServerRepository <Customer>(dataProvider, new SqlServerDataMapper <Customer>());
ParameterRepository = new GenericSqlServerRepository <Parameter>(dataProvider, new SqlServerDataMapper <Parameter>());
ParameterValueRepository = new GenericSqlServerRepository <ParameterValue>(dataProvider, new SqlServerDataMapper <ParameterValue>());
}
public AddPlayerCommand(ISqlServerDataProvider sqlDP, IWriter writer, IModelsFactory factory)
{
if (sqlDP == null)
{
throw new ArgumentNullException("Data provider cannot be null!");
}
if (writer == null)
{
throw new ArgumentNullException("Writer cannot be null!");
}
if (factory == null)
{
throw new ArgumentNullException("Writer cannot be null!");
}
this.dp = sqlDP;
this.writer = writer;
this.factory = factory;
}
public CommandFactory(IReportGenerator reporter,
ILogger logger,
IReader reader,
IWriter writer,
IPostgresDataProvider pgDp,
ISqlServerDataProvider sqlDp,
ISqliteDataProvider sqliteDp,
IModelsFactory modelsFactory,
ITicketModelsFactory ticketFactory,
IExcelImporter excelImporter)
{
this.pgDp = pgDp;
this.sqlDp = sqlDp;
this.sqliteDp = sqliteDp;
this.reader = reader;
this.writer = writer;
this.logger = logger;
this.reporter = reporter;
this.modelsFactory = modelsFactory;
this.ticketFactory = ticketFactory;
this.excelImporter = excelImporter;
}
public ShowMatchesCommand(ISqlServerDataProvider sqlDP, IWriter writer)
{
this.dp = sqlDP;
this.writer = writer;
}
/// <summary>
/// Overloaded constructor, you can pass in your own data context
/// </summary>
/// <param name="dataContext"></param>
public CSIProductConfigurationRepositoryFactory(ISqlServerDataProvider dataProvider)
{
InitialiseRepositories(dataProvider);
}
public DeleteMatchCommand(ISqlServerDataProvider sqlDP, IReader reader, IWriter writer)
{
this.dp = sqlDP;
this.reader = reader;
this.writer = writer;
}
public ShowTournamentsCommand(ISqlServerDataProvider sqlDP, IWriter writer)
{
this.dp = sqlDP;
this.writer = writer;
}
public ModelsFactory(ISqlServerDataProvider dataProvider)
{
this.dataProvider = dataProvider;
}
private void ExportToPdf(ISqlServerDataProvider sqlProvider, string pathToSave, string reportFileName, PdfReportType reportType)
{
if (!string.IsNullOrEmpty(reportFileName))
{
CreateDirectoryIfNotExists(pathToSave);
}
var reportName = Enum.GetName(typeof(PdfReportType), reportType);
reportFileName += reportName + ".pdf";
Document doc = new Document();
PdfWriter.GetInstance(doc, new FileStream(pathToSave + reportFileName, FileMode.Create));
doc.Open();
BaseFont font = BaseFont.CreateFont(BaseFont.HELVETICA, BaseFont.CP1252, false);
Font helvetica25 = new Font(font, ReportTitleFontSize, Font.BOLD);
Paragraph heading = new Paragraph("ATP Tennis Stat Report", helvetica25);
heading.SpacingAfter = 18f;
heading.Alignment = Element.ALIGN_CENTER;
doc.Add(heading);
var tableColumnsNumber = MatchesTableColumnsNumber;
if (reportType == PdfReportType.Ranking)
{
tableColumnsNumber = RankingTableColumnsNumber;
}
PdfPTable table = CreateTable(tableColumnsNumber, reportType);
if (reportType == PdfReportType.Matches)
{
var matches = sqlProvider.Matches.GetAll()
.OrderBy(m => m.DatePlayed);
AddHeadingTitle(table, reportName, FontSize, MatchesTableColumnsNumber);
AddHeaders(table, reportType, FontSize);
foreach (var match in matches)
{
var matchTournament = CreateColumn(match.Tournament.Name, ColumnAlignment, FontSize);
matchTournament.PaddingBottom = PaddingBottom;
table.AddCell(matchTournament);
var datePlayed = match.DatePlayed.ToString();
var parsedDate = datePlayed.Split(' ')[0];
var matchDate = CreateColumn(parsedDate, ColumnAlignment, FontSize);
matchDate.PaddingBottom = PaddingBottom;
table.AddCell(matchDate);
var matchWinner = CreateColumn(match.Winner.FirstName + " " + match.Winner.LastName, ColumnAlignment, FontSize);
matchWinner.PaddingBottom = PaddingBottom;
table.AddCell(matchWinner);
var matchLoser = CreateColumn(match.Loser.FirstName + " " + match.Loser.LastName, ColumnAlignment, FontSize);
matchLoser.PaddingBottom = PaddingBottom;
table.AddCell(matchLoser);
var matchResult = CreateColumn(match.Result, ColumnAlignment, FontSize);
matchResult.PaddingBottom = PaddingBottom;
table.AddCell(matchResult);
}
}
else if (reportType == PdfReportType.Ranking)
{
var ranking = sqlProvider.Players.GetAll()
.Where(p => p.Ranking != null)
.OrderBy(p => p.Ranking);
AddHeadingTitle(table, reportName, FontSize, RankingTableColumnsNumber);
AddHeaders(table, reportType, FontSize);
foreach (var player in ranking)
{
var playerRanking = CreateColumn(player.Ranking.ToString() ?? NotProvidedInfo, ColumnAlignment, FontSize);
playerRanking.PaddingBottom = PaddingBottom;
table.AddCell(playerRanking);
var playerName = CreateColumn(player.FirstName + " " + player.LastName, ColumnAlignment, FontSize);
playerName.PaddingBottom = PaddingBottom;
table.AddCell(playerName);
var playerHeight = CreateColumn(player.Height.ToString() ?? NotProvidedInfo, ColumnAlignment, FontSize);
playerHeight.PaddingBottom = PaddingBottom;
table.AddCell(playerHeight);
var playerWeight = CreateColumn(player.Weight.ToString() ?? NotProvidedInfo, ColumnAlignment, FontSize);
playerWeight.PaddingBottom = PaddingBottom;
table.AddCell(playerWeight);
var playerCityName = "";
if (player.City != null)
{
playerCityName = player.City.Name;
}
else
{
playerCityName = NotProvidedInfo;
}
var playerCity = CreateColumn(playerCityName, ColumnAlignment, FontSize);
playerCity.PaddingBottom = PaddingBottom;
table.AddCell(playerCity);
var playerCountryName = "";
if (player.City != null)
{
playerCountryName = player.City.Country.Name;
}
else
{
playerCountryName = NotProvidedInfo;
}
var playerCountry = CreateColumn(playerCountryName, ColumnAlignment, FontSize);
playerCountry.PaddingBottom = PaddingBottom;
table.AddCell(playerCountry);
}
}
else
{
throw new ArgumentException("Invalid Report Type");
}
doc.Add(table);
doc.Close();
}
public UpdatePlayerCommand(ISqlServerDataProvider sqlDP, IWriter writer)
{
this.dp = sqlDP;
this.writer = writer;
}
