/// <summary>
/// Initialises a new instance of the <see cref="AthleteConfigurationViewModel"/> class.
/// </summary>
/// <param name="model">handicap model</param>
/// <param name="seriesConfigManager">series configutation manager</param>
public AthleteConfigurationViewModel(
IModel model,
ISeriesConfigMngr seriesConfigManager)
{
this.model = model;
this.athleteCollection = new ObservableCollection <AthleteType>();
this.changePredeclaredHandicap = string.Empty;
this.numberPrefix = seriesConfigManager.ReadNumberPrefix();
LoadAthleteInformation();
ClubCollection.Add(new ClubType()
{
Club = string.Empty
});
// Order clubs alphabetically.
List <string> clubs = model.GetClubList().OrderBy(club => club).ToList();
foreach (string club in clubs)
{
ClubCollection.Add(new ClubType()
{
Club = club
});
}
this.newRaceNumber = this.NextRunningNumber;
this.addRaceNumber = this.NextRunningNumber;
// Search parameters
this.searchString = string.Empty;
this.surnameLetterSelectorCollection = new List <string>()
{
"", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "X", "Y", "Z"
};
this.surnameSelectorIndex = 0;
AthleteAddNumberCommand = new AthleteConfigAddNumberCmd(this);
//AthleteChangeCommand = new AthleteConfigChangeCmd(this);
this.AthleteChangeCommand =
new SimpleCommand(
this.ChangeAthlete,
this.CanChange);
//AthleteDeleteCommand = new AthleteConfigDeleteCmd(this);
this.AthleteDeleteCommand =
new SimpleCommand(
this.DeleteAthlete,
this.CanDelete);
this.AthleteNewCommand =
new SimpleCommand(
this.AddNewAthlete,
this.CanAdd);
//AthleteNewCommand = new AthleteConfigNewCmd(this);
//AthleteSaveCommand = new AthleteConfigSaveCmd(this);
this.AthleteSaveCommand =
new SimpleCommand(
this.SaveAthletes,
this.CanSave);
}
/// <summary>
/// Initialises a new instance of the <see cref="SeriesConfigViewModel"/> class.
/// </summary>
/// <param name="seriesConfigurationManager">series configuration manager</param>
/// <param name="logger">application logger</param>
public SeriesConfigViewModel(
ISeriesConfigMngr seriesConfigurationManager,
IJHcLogger logger)
{
this.logger = logger;
this.seriesConfigManager = seriesConfigurationManager;
SeriesConfigType config =
this.seriesConfigManager.ReadSeriesConfiguration();
if (config == null)
{
this.logger.WriteLog(
"Series Config VM not initialised, Config reader has failed.");
return;
}
numberPrefix = config.NumberPrefix;
numberPrefixOrig = this.NumberPrefix;
this.SaveCommand = new SeriesConfigSaveCmd(this);
this.jointSecondThird = !config.AllPositionsShown;
this.allPositions = config.AllPositionsShown;
}
/// <summary>
/// Initialises a new instance of the <see cref="LabelGenerationViewModel"/> class.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="normalisationConfigManager">normalisation configuration manager</param>
/// <param name="seriesConfigManager">series configuration manager</param>
/// <param name="logger">application logger</param>
/// <param name="saveFolder">folder to save the output to</param>
public LabelGenerationViewModel(
IModel model,
INormalisationConfigMngr normalisationConfigManager,
ISeriesConfigMngr seriesConfigManager,
IJHcLogger logger,
string saveFolder)
{
this.model = model;
this.seriesConfigManager = seriesConfigManager;
this.logger = logger;
SaveFolder = saveFolder;
NormalisationConfigType hcConfiguration =
normalisationConfigManager.ReadNormalisationConfiguration();
// TODO, this is repeated code, see HandicapWriter.cs
foreach (AthleteDetails athlete in model.Athletes.AthleteDetails)
{
TimeType newHandicap = model.CurrentSeason.GetAthleteHandicap(athlete.Key, hcConfiguration);
// Only look at active athletes.
if (athlete.Active)
{
List <string> runningNumbers = model.Athletes.GetAthleteRunningNumbers(athlete.Key);
// Use default handicap, if the athlete is not registered for the current season.
// TODO, I suspect this should never happen???
if (newHandicap == null)
{
newHandicap = athlete.RoundedHandicap;
}
// Ensure that the athlete is registered for the season.
if (runningNumbers.Count > 0)
{
AthleteLabel modelAthlete =
new AthleteLabel(
athlete.Name,
athlete.Club,
runningNumbers[0],
newHandicap,
athlete.Appearances == 0);
modelAthlete.AthleteLabelWidth = A4Details.GetLabelWidth96DPI(NoColumns);
modelAthlete.AthleteLabelHeight = A4Details.GetLabelHeight96DPI(NoRows);
this.AthleteDetails.Add(modelAthlete);
}
}
}
// Order the athletes alphabetically.
this.AthleteDetails =
this.AthleteDetails.OrderBy(athlete => athlete.Forename).ToList();
this.AthleteDetails =
this.AthleteDetails.OrderBy(athlete => athlete.Surname).ToList();
this.saveDirectory = saveFolder;
this.CreateRaceLabelsCommand = new CreateAndSaveRaceLabelsCmd(this);
this.CreateSpareLabelsCommand = new CreateAndSaveSpareLabelsCmd(this);
this.CreateAllLabelsCommand = new CreateAndSaveAllLabelsCmd(this);
}
/// <summary>
/// Creates a new instance of the <see cref="PrimaryDisplayViewModel"/> class
/// </summary>
/// <param name="model">application model</param>
/// <param name="businessLayerManager">business layer manager</param>
/// <param name="normalisationConfigurationManager">normalisation configuration manager</param>
/// <param name="resultsConfigurationManager">results configuration manager</param>
/// <param name="seriesConfigurationManager">series configuration manager</param>
/// <param name="generalIo">general IO manager</param>
/// <param name="commonIo">Common IO manager</param>
/// <param name="logger">application logger</param>
public PrimaryDisplayViewModel(
IModel model,
IBLMngr businessLayerManager,
INormalisationConfigMngr normalisationConfigurationManager,
IResultsConfigMngr resultsConfigurationManager,
ISeriesConfigMngr seriesConfigurationManager,
IGeneralIo generalIo,
ICommonIo commonIo,
IJHcLogger logger)
{
this.logger = logger;
this.logger.WriteLog("HandicapMainViewModel created");
this.model = model;
this.normalisationConfigManager = normalisationConfigurationManager;
this.resultsConfigurationManager = resultsConfigurationManager;
this.seriesConfigManager = seriesConfigurationManager;
this.businessLayerManager = businessLayerManager;
this.generalIo = generalIo;
this.commonIo = commonIo;
this.isValidLocation = this.businessLayerManager.IsValid;
Messenger.Default.Register <HandicapErrorMessage>(this, this.PopulateErrorInformation);
Messenger.Default.Register <HandicapProgressMessage>(this, this.PopulateProgressInformation);
Messenger.Default.Register <ValidLocationMessage>(this, this.InvalidLocationMessage);
this.InitialiseViewModels();
this.InitialiseOpenAppCommands();
}
/// <summary>
/// Initialises a new instance of the <see cref="AthleteDataReader"/> class.
/// </summary>
/// <param name="normalisationConfigManager">Normalisation config manager</param>
/// <param name="seriesConfigManager">series config manager</param>
/// <param name="logger">application logger</param>
public AthleteDataReader(
INormalisationConfigMngr normalisationConfigManager,
ISeriesConfigMngr seriesConfigManager,
IJHcLogger logger)
{
this.logger = logger;
this.normalisationConfigManager = normalisationConfigManager;
this.seriesConfigManager = seriesConfigManager;
}
/// <summary>
/// Initialises a new instance of the <see cref="CalculateResultsMngr"/> class.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="normalisationConfigurationManager">
/// normalisation configuration manager
/// </param>
/// <param name="resultsConfigurationManager">
/// results configuration manager
/// </param>
/// <param name="seriesConfigurationManager">
/// series configuration manager
/// </param>
/// <param name="logger">application logger</param>
public CalculateResultsMngr(
IModel model,
INormalisationConfigMngr normalisationConfigurationManager,
IResultsConfigMngr resultsConfigurationManager,
ISeriesConfigMngr seriesConfigurationManager,
IJHcLogger logger)
: base(model)
{
this.logger = logger;
this.resultsConfiguration = resultsConfigurationManager;
this.hcConfiguration = normalisationConfigurationManager.ReadNormalisationConfiguration();
this.seriesConfiguration = seriesConfigurationManager.ReadSeriesConfiguration();
}
/// <summary>
/// Initialises a new instance of the <see cref="BLMngr"/> class.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="normalisationConfigurationManager">the normalisation config manager</param>
/// <param name="resultsConfigurationManager">the results config manager</param>
/// <param name="seriesConfigurationManager">the series config manager</param>
/// <param name="athleteData">athlete data</param>
/// <param name="clubData">club data</param>
/// <param name="eventData">event data</param>
/// <param name="summaryData">summary data</param>
/// <param name="seasonIO">season IO manager</param>
/// <param name="eventIo">event IO manager</param>
/// <param name="generalIo">general IO manager</param>
/// <param name="logger">application logger</param>
public BLMngr(
IModel model,
INormalisationConfigMngr normalisationConfigurationManager,
IResultsConfigMngr resultsConfigurationManager,
ISeriesConfigMngr seriesConfigurationManager,
IAthleteData athleteData,
IClubData clubData,
IEventData eventData,
ISummaryData summaryData,
ISeasonIO seasonIO,
IEventIo eventIo,
IGeneralIo generalIo,
IJHcLogger logger)
{
this.logger = logger;
this.model = model;
this.normalisationConfigurationManager = normalisationConfigurationManager;
this.resultsConfigurationManager = resultsConfigurationManager;
this.seriesConfigurationManager = seriesConfigurationManager;
this.athleteData = athleteData;
this.clubData = clubData;
this.eventData = eventData;
this.summaryData = summaryData;
this.seasonIO = seasonIO;
this.eventIo = eventIo;
this.generalIo = generalIo;
this.ModelRootDirectory = RootIO.LoadRootFile();
this.currentSeason = string.Empty;
this.resultsCalculator =
new CalculateResultsMngr(
this.model,
this.normalisationConfigurationManager,
this.resultsConfigurationManager,
this.seriesConfigurationManager,
this.logger);
this.IsValid =
this.generalIo.DataFolderExists && this.generalIo.ConfigurationFolderExists;
Messenger.Default.Register <LoadNewSeasonMessage>(this, this.NewCurrentSeason);
Messenger.Default.Register <LoadNewEventMessage>(this, this.NewCurrentEvent);
Messenger.Default.Register <LoadNewSeriesMessage>(this, this.LoadNewSeries);
Messenger.Default.Register <CreateNewSeriesMessage>(this, this.CreateNewSeries);
Messenger.Default.Register <ReinitialiseRoot>(this, this.ReinitialiseRoot);
}
/// <summary>
/// Creates a set of images containing spare barcodes on a crib sheet.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="seriesConfigurationManager">series configuration manager</param>
/// <param name="savePath">path to save the images to</param>
/// <param name="numberOfSpareSheets">number of spare sheets to create</param>
/// <param name="numberOfLabelColumns">number of columns of labels</param>
/// <param name="numberOfLabelRow">number of rows of labels</param>
public static void CreateSpareLabelsCribSheet(
IModel model,
ISeriesConfigMngr seriesConfigurationManager,
string savePath,
int numberOfSpareSheets,
int numberOfLabelColumns,
int numberOfLabelRow)
{
SeriesConfigType config = seriesConfigurationManager.ReadSeriesConfiguration();
int summarySheetNumber = 1;
int raceNumber = model.Athletes.NextAvailableRaceNumber;
int numberOfSpareLabels = numberOfLabelColumns * numberOfLabelRow * numberOfSpareSheets;
int numberOfCribPerSheet = numberOfCribSheetColumns * numberOfCribSheetRows;
ObservableCollection <AthleteLabel> labels = new ObservableCollection <AthleteLabel>();
for (int labelIndex = 0; labelIndex < numberOfSpareLabels; ++labelIndex)
{
labels.Add(new AthleteLabel("________________________________________________________________________",
string.Empty,
GetRaceNumber(config?.NumberPrefix, raceNumber),
null,
false));
if (labels.Count == numberOfCribPerSheet)
{
CreateSingleCribSheet(
new LabelsSheetViewModel(labels),
savePath + Path.DirectorySeparatorChar + spareLabelsCribName + summarySheetNumber.ToString() + ".png");
++summarySheetNumber;
labels = new ObservableCollection <AthleteLabel>();
}
// TODO UpdateString
++raceNumber;
}
if (labels.Count > 0)
{
CreateSingleCribSheet(new LabelsSheetViewModel(labels),
savePath + Path.DirectorySeparatorChar + spareLabelsCribName + summarySheetNumber.ToString() + ".png");
}
}
/// <summary>
/// Write the next runner to a file.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="folder">output model</param>
/// <param name="seriesConfigMngr">series configuraton manager</param>
/// <param name="logger">application logger</param>
/// <returns>success flag</returns>
public static bool WriteNextRunnerTable(
IModel model,
string folder,
ISeriesConfigMngr seriesConfigMngr,
IJHcLogger logger)
{
bool success = true;
Messenger.Default.Send(
new HandicapProgressMessage(
"Printing next runner."));
SeriesConfigType config =
seriesConfigMngr.ReadSeriesConfiguration();
try
{
using (StreamWriter writer = new StreamWriter(Path.GetFullPath(folder) +
Path.DirectorySeparatorChar +
model.CurrentSeason.Name +
model.CurrentEvent.Name +
ResultsPaths.nextNewRunner +
ResultsPaths.csvExtension))
{
writer.WriteLine(config?.NumberPrefix + model.Athletes.NextAvailableRaceNumber.ToString("000000"));
}
}
catch (Exception ex)
{
logger.WriteLog("Error, failed to print next runner: " + ex.ToString());
Messenger.Default.Send(
new HandicapErrorMessage(
"Failed to print next runner"));
success = false;
}
return(success);
}
/// <summary>
/// Creates a set of image files, each containing a spare barcodes.
/// </summary>
/// <param name="model">junior handicap model</param>
/// <param name="seriesConfigManager">series configuration manager</param>
/// <param name="savePath">path to save the images to</param>
/// <param name="numberOfSpareSheets">number of spare sheets to create</param>
/// <param name="numberOfColumns">number of columns of labels</param>
/// <param name="numberOfRow">number of rows of labels</param>
/// <param name="eventDetails">details of the event, name and date</param>
public static void CreateSpareLabels(
IModel model,
ISeriesConfigMngr seriesConfigManager,
string savePath,
int numberOfSpareSheets,
int numberOfColumns,
int numberOfRow,
string eventDetails)
{
int raceNumber = model.Athletes.NextAvailableRaceNumber;
SeriesConfigType config = seriesConfigManager.ReadSeriesConfiguration();
for (int sheetNumber = 0; sheetNumber < numberOfSpareSheets; ++sheetNumber)
{
ObservableCollection <AthleteLabel> sheet = new ObservableCollection <AthleteLabel>();
for (int labelIndex = 0; labelIndex < numberOfColumns * numberOfRow; ++labelIndex)
{
AthleteLabel newLabel =
new AthleteLabel(
string.Empty,
string.Empty,
GetRaceNumber(config?.NumberPrefix, raceNumber),
null,
false);
newLabel.EventDetails = eventDetails;
newLabel.AthleteLabelWidth = A4Details.GetLabelWidth96DPI(numberOfColumns);
newLabel.AthleteLabelHeight = A4Details.GetLabelHeight96DPI(numberOfRow);
sheet.Add(newLabel);
// TODO UpdateString
++raceNumber;
}
CreateSingleSheet(new LabelsSheetViewModel(sheet),
savePath + Path.DirectorySeparatorChar + spareLabelsName + sheetNumber.ToString() + ".png");
}
}
/// <summary>
/// Initialises a new instance of the <see cref="AthleteData"/> class.
/// </summary>
/// <param name="generalIo">general IO manager</param>
/// <param name="logger">application logger</param>
public AthleteData(
IGeneralIo generalIo,
INormalisationConfigMngr normalisationConfigManager,
ISeriesConfigMngr seriesConfigManager,
IJHcLogger logger)
{
this.generalIo = generalIo;
this.logger = logger;
this.athleteDataReader =
new AthleteDataReader(
normalisationConfigManager,
seriesConfigManager,
this.logger);
this.athleteSeasonDataReader =
new AthleteSeasonDataReader(
this.logger);
string rootDirectory = RootIO.LoadRootFile();
this.dataPath = $"{rootDirectory}{Path.DirectorySeparatorChar}{IOPaths.dataPath}{Path.DirectorySeparatorChar}";
Messenger.Default.Register <ReinitialiseRoot>(this, this.ReinitialiseRoot);
}
/// <summary>
/// Initialises a new instance of the <see cref="Athletes"/> class.
/// </summary>
/// <param name="seriesConfigMngr">series configuration manager</param>
public Athletes(ISeriesConfigMngr seriesConfigMngr)
{
this.seriesConfigManager = seriesConfigMngr;
this.AthleteDetails = new List <AthleteDetails>();
}
