internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition,
bool finalResults)
{
lock (resultHolders)
{
foreach (CResultHolder holder in resultHolders)
{
if (holder.WClass == wclass &&
holder.UClass == uclass &&
holder.NorwegianCount == competition.NorwegianCount &&
holder.FinalResults == finalResults)
{
return(holder.Results);
}
}
ResultsReturn[] results = result.GetResults(wclass,
uclass,
competition,
finalResults);
CResultHolder newHolder = new CResultHolder(
wclass,
uclass,
competition.NorwegianCount,
finalResults,
results);
resultHolders.Add(newHolder);
return(results);
}
}
internal string ExportResults(bool finalResults)
{
//database = myInterface.databaseClass.database;
StringBuilder html = new StringBuilder();
html.Length = 0;
html.Append(createHtmlHeader());
html.Append(createCompetitionHeader());
html.Append("<h1>Individuella resultat</h1>");
// Get results for the competitors
for (int i = 1; i < Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass wclass =
(Structs.ResultWeaponsClass)i;
if (i.ToString() != wclass.ToString())
{
// A real resultweaponsclass
for (int j = 1; j <= Structs.ShootersClassMax; j++)
{
Structs.ShootersClass uclass =
(Structs.ShootersClass)j;
if (j.ToString() != uclass.ToString())
{
// TODO fixa en bättre räknare
if (myInterface.GetCompetitorResultsExist(wclass, uclass))
{
html.Append(createCompetitorResults(wclass,
uclass, finalResults));
}
}
}
}
}
// Get results for the teams
for (int i = 1; i < Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass wclass =
(Structs.ResultWeaponsClass)i;
if (i.ToString() != wclass.ToString())
{
// A real resultweaponsclass
Structs.ResultsReturnTeam[] teamresults =
myInterface.resultTeamClass.GetTeamResults(wclass, myInterface.GetCompetitions()[0].NorwegianCount);
if (teamresults.Length > 0)
{
html.Append(createTeamResults(teamresults, wclass));
}
}
}
html.Append(createHtmlFooter());
return(html.ToString());
}
internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition)
{
return(GetResults(
wclass,
uclass,
competition,
false));
}
internal string ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
StringBuilder html = new StringBuilder();
html.Append(createHtmlHeader());
html.Append(createCompetitionHeader());
html.Append(createCompetitorResults(wclass, uclass, finalResults));
html.Append(createHtmlFooter());
return(html.ToString());
}
private void getCurrentResults()
{
Structs.ShootersClass temp =
(Structs.ShootersClass) this.currentUClass;
Structs.Competition comp = CommonCode.GetCompetitions()[0];
results =
CommonCode.ResultsGet(wclass, temp,
comp,
!printPrelResults);
}
internal CResultHolder(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
bool norwegianCount,
bool finalResults,
ResultsReturn[] results)
{
WClass = wclass;
UClass = uclass;
NorwegianCount = norwegianCount;
FinalResults = finalResults;
Results = results;
}
private double writeResultsClassHeader(pdfPage page, double yPos,
Structs.ResultWeaponsClass wclass, Structs.ShootersClass uclass)
{
Structs.ShootersClassShort uclassshort = (Structs.ShootersClassShort)(int) uclass;
string klass = uclassshort.ToString().Replace("Klass", "") +
wclass.ToString();
addText(page, "Klass:", leftMargin, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = addText(page, klass,
leftMargin + 30, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = yPos + 4;
return(yPos);
}
private void calculateStandardMedals(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass)
{
List <ResultsReturn> results;
Structs.Competition competition = myInterface.CompetitionCurrent;
results = getAllCompetitors(
wclass,
uclass,
true);
results.Sort();
calculateMedals(results);
}
internal byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
if (finalResults != true)
{
throw new ApplicationException("Not implemented yet");
}
double yPos = topMargin;
sharpPDF.pdfPage page = null;
return(ExportResults(wclass, uclass, finalResults, true, ref page, ref yPos));
}
internal CPrintResultlist(ref Common.Interface newCommon,
Structs.ResultWeaponsClass wclasswanted,
Structs.ShootersClass uclasswanted,
bool prelResults,
string clubIdwanted) : base()
{
CommonCode = newCommon;
wclass = wclasswanted;
uclass = uclasswanted;
printPrelResults = prelResults;
clubId = clubIdwanted;
competition = CommonCode.GetCompetitions()[0];
CompetitionType = competition.Type;
}
internal CPrintResultlist(ref Common.Interface newCommon,
Structs.ResultWeaponsClass wclasswanted,
Structs.ShootersClass uclasswanted,
bool prelResults,
string clubIdwanted) : base ()
{
CommonCode = newCommon;
wclass = wclasswanted;
uclass = uclasswanted;
printPrelResults = prelResults;
clubId = clubIdwanted;
competition = CommonCode.GetCompetitions()[0];
CompetitionType = competition.Type;
}
internal byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
ResultsReturn[] results =
myInterface.resultClass.GetResults(
wclass,
uclass,
myInterface.CompetitionCurrent);
string resultString = RenderResults(results);
Encoding enc = ASCIIEncoding.GetEncoding(1252);
return(enc.GetBytes(resultString));
}
private byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults, bool returnDocument,
ref pdfPage page, ref double yPos)
{
if (yPos + conversionPixelsToMM * 3 * fontSize >= bottomMargin)
{
page = this.getNewPage(ref yPos);
}
// Write headers
yPos = writeResultsClassHeader(page, yPos, wclass, uclass);
if (yPos < TextStart)
{
yPos = TextStart;
}
yPos = writeResultsHeader(page, yPos);
ResultsReturn[] results = myInterface.resultClass.GetResults(wclass, uclass,
myInterface.CompetitionCurrent, true);
int i = 0;
foreach (ResultsReturn result in results)
{
if (yPos + conversionPixelsToMM * fontSize >= bottomMargin)
{
page = this.getNewPage(ref yPos);
yPos = writeResultsClassHeader(page, yPos, wclass, uclass);
if (yPos < TextStart)
{
yPos = TextStart;
}
yPos = writeResultsHeader(page, yPos);
}
i++;
yPos = writeResultsUser(page, yPos, result, i);
}
// Return what we've created
if (returnDocument)
{
return(returnPdfInBytes());
}
else
{
return(new byte[0]);
}
}
private bool moreClassesPages()
{
if (uclass != Structs.ShootersClass.Okänd)
{
return(false);
}
bool nextClass = false;
// We're talking multiple classes here...
for (int i = 0; i <= Structs.ShootersClassMax; i++)
{
Structs.ShootersClass thisuclass =
(Structs.ShootersClass)i;
try
{
int.Parse(thisuclass.ToString());
}
catch (Exception)
{
// A class, since we couldn't parse int
if (nextClass)
{
if (CommonCode.GetCompetitorResultsCount(
wclass, thisuclass) > 0)
{
competitorsDone = -1;
this.currentUClass = (int)thisuclass;
getCurrentResults();
return(true);
}
}
// Check if next class should be checked
if ((int)thisuclass == this.currentUClass)
{
nextClass = true;
}
}
}
return(false);
}
private Structs.ShootersClass getCurrentShootersClass()
{
try
{
if (this.ddUClasses.SelectedIndex == -1)
{
return(Structs.ShootersClass.Okänd);
}
int selectedValue = (int)this.ddUClasses.SelectedValue;
Structs.ShootersClass thisClass =
(Structs.ShootersClass)selectedValue;
return(thisClass);
}
catch (System.Exception exc)
{
Trace.WriteLine("FResultsView.getCurrentShootersClass " +
"Exception:\r\n" + exc.ToString());
throw;
}
}
private List <ResultsReturn> getAllCompetitors(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool standardMedalsCalculation)
{
List <ResultsReturn> results = new List <ResultsReturn>();
Structs.Competition competition = myInterface.CompetitionCurrent;
Hashtable shooters = new Hashtable();
Hashtable weapons = new Hashtable();
string selectString = "";
string standardClass = "ShooterClass=" + ((int)Structs.ShootersClass.Klass1).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Klass2).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Klass3).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Öppen).ToString();
string damClass = "ShooterClass=" + ((int)Structs.ShootersClass.Damklass1).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Damklass2).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Damklass3).ToString();
string extraClasses = "ShooterClass=" + ((int)Structs.ShootersClass.Juniorklass).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassYngre).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassÄldre).ToString();
if (standardMedalsCalculation)
{
if (wclass == Structs.ResultWeaponsClass.C &&
(competition.Championship == Structs.CompetitionChampionshipEnum.SM |
competition.Championship == Structs.CompetitionChampionshipEnum.Landsdel))
{
switch (uclass)
{
case Structs.ShootersClass.Klass:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass1:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass2:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass3:
selectString = standardClass;
break;
case Structs.ShootersClass.Öppen:
selectString = "ShooterClass=" + ((int)uclass).ToString();
break;
case Structs.ShootersClass.Damklass:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass1:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass2:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass3:
selectString = damClass;
break;
case Structs.ShootersClass.Juniorklass:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.Juniorklass).ToString();
break;
case Structs.ShootersClass.VeteranklassYngre:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassYngre).ToString();
break;
case Structs.ShootersClass.VeteranklassÄldre:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassÄldre).ToString();
break;
default:
throw new NotImplementedException("uclass: " + uclass.ToString());
}
}
else
{
selectString = ""; // Everyone in one calculation
}
}
else
{
// Fetch the shooters
switch (uclass)
{
case Structs.ShootersClass.Damklass:
selectString = damClass;
break;
case Structs.ShootersClass.Klass:
selectString = standardClass;
break;
case Structs.ShootersClass.Okänd:
selectString = "";
break;
default:
selectString = "ShooterClass=" + ((int)uclass).ToString();
break;
}
}
foreach (DatabaseDataset.CompetitorsRow row in database.Competitors.Select(selectString))
{
// What shootersclass is current user?
#if DEBUG
Structs.ShootersClass currentUclass =
(Structs.ShootersClass)row.ShooterClass; // TODO Remove
#endif
// Setup a cache for weapons.
Structs.Weapon weapon;
if (weapons.ContainsKey(row.WeaponId))
{
weapon = (Structs.Weapon)weapons[row.WeaponId];
}
else
{
weapon = myInterface.GetWeapon(row.WeaponId);
weapons.Add(row.WeaponId, weapon);
}
// For each competitor, find the result (competitorresults)
// and add together
/*if ( (myInterface.ConvertWeaponsClassToResultClass(
* weapon.WClass) == wclass |
* wclass == Structs.ResultWeaponsClass.Unknown)
* &
* ( uclass == currentUclass | uclass == Structs.ShootersClass.Okänd))*/
if (myInterface.ConvertWeaponsClassToResultClass(
weapon.WClass) == wclass |
wclass == Structs.ResultWeaponsClass.Unknown)
{
ResultsReturn thisResult = ResultsGetCompetitor(row.CompetitorId);
if (thisResult.HitsTotal > 0)
{
results.Add(thisResult);
}
}
}
return(results);
}
internal Structs.ShootersClass[] ResultsGetUClasses(
Structs.ResultWeaponsClass wclass)
{
Trace.WriteLine("CResult.ResultsGetUClasses(\"" +
wclass.ToString() + "\") " +
"started on thread \"" +
System.Threading.Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
DateTime start = DateTime.Now;
database = myInterface.databaseClass.Database;
List <int> sClassesIntTable = new List <int>();
List <Structs.ShootersClass> shooterClasses = new List <Structs.ShootersClass>();
foreach (DatabaseDataset.CompetitorsRow row in
database.Competitors)
{
Structs.Weapon weapon = myInterface.GetWeapon(row.WeaponId);
if (myInterface.ConvertWeaponsClassToResultClass(weapon.WClass) ==
wclass)
{
if (row.GetChildRows("CompetitorsCompetitorResults").Length > 0)
{
if (!sClassesIntTable.Contains(row.ShooterClass))
{
sClassesIntTable.Add(row.ShooterClass);
Structs.ShootersClass uclass =
(Structs.ShootersClass)row.ShooterClass;
shooterClasses.Add(uclass);
}
}
}
}
if (myInterface.CompetitionCurrent.OneClass)
{
if (shooterClasses.Contains(Structs.ShootersClass.Klass1) ||
shooterClasses.Contains(Structs.ShootersClass.Klass2) ||
shooterClasses.Contains(Structs.ShootersClass.Klass3))
{
shooterClasses.Add(Structs.ShootersClass.Klass);
shooterClasses.Remove(Structs.ShootersClass.Klass1);
shooterClasses.Remove(Structs.ShootersClass.Klass2);
shooterClasses.Remove(Structs.ShootersClass.Klass3);
}
if (shooterClasses.Contains(Structs.ShootersClass.Damklass1) ||
shooterClasses.Contains(Structs.ShootersClass.Damklass2) ||
shooterClasses.Contains(Structs.ShootersClass.Damklass3))
{
shooterClasses.Add(Structs.ShootersClass.Damklass);
shooterClasses.Remove(Structs.ShootersClass.Damklass1);
shooterClasses.Remove(Structs.ShootersClass.Damklass2);
shooterClasses.Remove(Structs.ShootersClass.Damklass3);
}
}
/*for(int i=0 ; i<=Structs.ShootersClassMax ; i++)
* {
* try
* {
* if (sClassesIntTable.Contains(i))
* {
* int.Parse(((Structs.ShootersClass)i).ToString());
* }
* }
* catch(System.FormatException)
* {
* // Ok, we got a class
* Structs.ShootersClass uclass =
* (Structs.ShootersClass)i;
* shooterClasses.Add(uclass);
* }
* }*/
shooterClasses.Sort();
Trace.WriteLine("CResult.ResultsGetUClasses(\"" +
wclass.ToString() + "\") " +
"ending after " +
(DateTime.Now - start).TotalMilliseconds.ToString() +
" ms.");
return(shooterClasses.ToArray());
}
private string createCompetitorResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
StringBuilder html = new StringBuilder();
html.Append("<p><table>");
html.Append("<tr>");
html.Append("<td width=" + internalTableWidthcol1.ToString() +
"><b>Vapenklass:</b></td>");
html.Append("<td>" + wclass.ToString() + "</td>");
html.Append("</tr>");
html.Append("<tr>");
html.Append("<td width=" + internalTableWidthcol1.ToString() +
"><b>Klass:</b></td>");
html.Append("<td>" + uclass.ToString() + "</td>");
html.Append("</tr>");
html.Append("</table>");
if (this.useWidth)
{
html.Append("<table width=100% border=0 cellspacing=5 cellpadding=0>");
}
else
{
html.Append("<table border=0 cellspacing=0>");
}
foreach (string columnName in this.colOrder)
{
html.Append("<th");
if (useWidth)
{
html.Append(" width=");
}
switch (columnName)
{
case "Place":
if (useWidth)
{
html.Append(this.colPlaceWidth.ToString() + "%");
}
html.Append(" align=center>Pl");
break;
case "Name":
if (useWidth)
{
html.Append(this.colNameWidth.ToString() + "%");
}
html.Append(" align=left>Namn");
break;
case "Club":
if (useWidth)
{
html.Append(this.colClubWidth.ToString() + "%");
}
html.Append(" align=left>Klubb");
break;
case "Result":
if (useWidth)
{
html.Append(this.colResultWidth.ToString() + "%");
}
html.Append(" align=left colSpan=" +
(3 + myInterface.GetStationsCount()).ToString() +
">Result");
break;
case "ResultTot":
if (useWidth)
{
html.Append(this.colResultTotWidth.ToString() + "%");
}
html.Append(" align=center>Tot");
break;
case "Points":
if (useWidth)
{
html.Append(this.colPointsWidth.ToString() + "%");
}
html.Append(" align=center>" + HttpUtility.HtmlEncode("Poäng"));
break;
case "StdMed":
if (useWidth)
{
html.Append(this.colStdMedWidth.ToString() + "%");
}
html.Append(" align=center>Stm");
break;
case "PriceMoney":
if (finalResults)
{
html.Append(" align=center>Pris");
}
else
{
html.Append(">");
}
break;
}
html.Append("</th>");
}
Structs.ResultsReturn[] results =
myInterface.resultClass.GetResults(
wclass,
uclass,
myInterface.GetCompetitions()[0].NorwegianCount, finalResults);
int place = 0;
foreach (Structs.ResultsReturn result in results)
{
place++;
html.Append("<tr>");
foreach (string columnName in this.colOrder)
{
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\" ");
}
else
{
html.Append(" class=\"resultoddline\" ");
}
if (useWidth)
{
html.Append(" width=");
}
switch (columnName)
{
case "Place":
if (useWidth)
{
html.Append(this.colPlaceWidth.ToString() + "%");
}
html.Append(" align=center>" + place.ToString());
break;
case "Name":
if (useWidth)
{
html.Append(this.colNameWidth.ToString() + "%");
}
html.Append(" align=left>" +
HttpUtility.HtmlEncode(result.ShooterName));
break;
case "Club":
if (useWidth)
{
html.Append(this.colClubWidth.ToString() + "%");
}
html.Append(" align=left>" +
HttpUtility.HtmlEncode(
myInterface.GetClub(result.ClubId).Name));
break;
case "Result":
if (useWidth)
{
html.Append(this.colResultWidth.ToString() + "%");
}
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append(" align=left></td>");
foreach (string str in result.HitsPerStn.Split(';'))
{
if (str.Length > 0)
{
string[] resparts = str.Split('/');
int temp = int.Parse(resparts[0]) +
int.Parse(resparts[1]);
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>" +
temp.ToString() + "</td>");
}
}
}
else
{
html.Append(" align=left></td>");
foreach (string str in result.HitsPerStn.Split(';'))
{
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>" + str + "</td>");
}
}
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>");
if (result.FinalShootingPlace < 100 &
result.FinalShootingPlace > 0)
{
html.Append("( " + result.FinalShootingPlace.ToString() +
" )");
}
html.Append("</td>");
break;
case "Points":
if (useWidth)
{
html.Append(this.colPointsWidth.ToString() + "%");
}
html.Append(" align=center>" + result.Points);
break;
case "ResultTot":
if (useWidth)
{
html.Append(this.colResultTotWidth.ToString() + "%");
}
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append(" align=center>" +
(result.Hits + result.FigureHits).ToString());
}
else
{
html.Append(" align=center>" +
result.Hits.ToString() + "/" +
result.FigureHits.ToString());
}
break;
case "StdMed":
if (useWidth)
{
html.Append(this.colStdMedWidth.ToString() + "%");
}
html.Append(" align=center>");
switch (result.Medal)
{
case (int)Structs.Medal.StandardSilver:
html.Append("S");
break;
case (int)Structs.Medal.StardardBrons:
html.Append("B");
break;
}
break;
case "PriceMoney":
if (finalResults)
{
html.Append(" align=right>");
if (result.PriceMoney > 0)
{
html.Append(result.PriceMoney.ToString() + ":-");
}
}
else
{
html.Append(">");
}
break;
}
if (columnName != "Result")
{
html.Append("</td>");
}
}
html.Append("</tr>");
}
html.Append("</table></p>");
return(html.ToString());
}
internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition,
bool finalResults)
{
Trace.WriteLine("CResults.GetResults(" + wclass.ToString()
+ ", " + uclass.ToString() +
") started on thread \"" +
System.Threading.Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
while (resultsAlreadyRunning)
{
System.Threading.Thread.Sleep(50);
}
Trace.WriteLine("CResults: GetResults() " +
" locking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (GetResultsLock)
{
Trace.WriteLine("CResults: GetResults() " +
" locked \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
try
{
resultsAlreadyRunning = true;
database = myInterface.databaseClass.Database;
useNorwegianCount = competition.NorwegianCount;
// First find out about the standard medals
calculateStandardMedals(wclass, uclass);
// Ok, now lets count the real ones
if (competition.OneClass)
{
switch (uclass)
{
case Structs.ShootersClass.Damklass:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass1:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass2:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass3:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Juniorklass:
break;
case Structs.ShootersClass.Klass:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass1:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass2:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass3:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.VeteranklassYngre:
break;
case Structs.ShootersClass.VeteranklassÄldre:
break;
case Structs.ShootersClass.Öppen:
break;
default:
throw new NotSupportedException("Structs.ShootersClass." +
uclass.ToString() + " is not supported");
}
}
List <ResultsReturn> results = getAllCompetitors(wclass, uclass, false);
results.Sort();
if (myInterface.CompetitionCurrent.Championship !=
Structs.CompetitionChampionshipEnum.Club)
{
results = markMedals(results);
}
else
{
// Mark all as not having medals
foreach (ResultsReturn row in results)
{
row.Medal = Structs.Medal.None;
}
}
if (finalResults)
{
results = markPriceMoney(results);
}
return(results.ToArray());
}
finally
{
Trace.WriteLine("CResults: GetResults() " +
" unlocking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Trace.WriteLine("CResults.GetResults ended.");
resultsAlreadyRunning = false;
}
}
}
private void updateDatasetwithThread()
{
try
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() " +
"started on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
if (populateDatasetwithThreadsCount > 0)
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() " +
" already has threads waiting");
return;
}
Interlocked.Increment(ref populateDatasetwithThreadsCount);
Trace.WriteLine("FResultsView.populateDatasetwithThread() locking \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (lockObject)
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() locked \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Thread.Sleep(100);
DateTime start = DateTime.Now;
if (CommonCode.GetCompetitions().Length == 0)
{
return;
}
this.datasetResults1 = new DatasetResults();
this.datasetResults1.DataSetName = "DatasetResults";
this.datasetResults1.Locale =
new System.Globalization.CultureInfo("sv");
Structs.ResultWeaponsClass wclass = getCurrentWeaponClass();
Structs.ShootersClass uclass = getCurrentShootersClass();
if (uclass == Structs.ShootersClass.Okänd)
{
return;
}
ResultsReturn[] results = CommonCode.ResultsGet(wclass,
uclass,
CommonCode.GetCompetitions()[0],
false);
datasetResults1 = new Allberg.Shooter.Windows.DatasetResults();
int i = 1;
bool useNorwegian = CommonCode.GetCompetitions()[0].NorwegianCount;
Hashtable clubs = new Hashtable();
foreach (ResultsReturn result in results)
{
DatasetResults.ResultsRow newRow =
this.datasetResults1.Results.NewResultsRow();
newRow.Place = i;
if (clubs.ContainsKey(result.ClubId))
{
newRow.Club = (string)clubs[result.ClubId];
}
else
{
string clubName = getClubName(result.ClubId);
newRow.Club = clubName;
clubs.Add(result.ClubId, clubName);
}
switch ((Structs.Medal)result.Medal)
{
case Structs.Medal.StandardSilver:
newRow.Medal = "S";
break;
case Structs.Medal.StardardBrons:
newRow.Medal = "B";
break;
default:
newRow.Medal = "";
break;
}
newRow.Points = result.PointsTotal;
newRow.ShooterName = result.ShooterName;
switch (CommonCode.GetCompetitions()[0].Type)
{
case Structs.CompetitionTypeEnum.Field:
{
if (useNorwegian)
{
newRow.Hits = (result.HitsTotal + result.FigureHitsTotal).ToString();
newRow.HitsPerStation = "";
foreach (string str in result.HitsPerStnString.Split(';'))
{
if (str != "")
{
newRow.HitsPerStation += str + " ";
}
}
newRow.HitsPerStation = newRow.HitsPerStation.TrimEnd();
}
else
{
newRow.Hits = result.HitsTotal.ToString() + " / " +
result.FigureHitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
}
break;
}
case Structs.CompetitionTypeEnum.MagnumField:
{
newRow.Hits = result.HitsTotal.ToString() + " / " +
result.FigureHitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
break;
}
case Structs.CompetitionTypeEnum.Precision:
{
newRow.Hits = result.HitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
break;
}
default:
throw new ApplicationException("Unknown CompetitionType");
}
if (result.FinalShootingPlace != 100)
{
newRow.HitsPerStation += " (" + result.FinalShootingPlace.ToString() + ")";
}
this.datasetResults1.Results.AddResultsRow(newRow);
i++;
}
if (this.InvokeRequired)
{
this.Invoke(DatasetBindToDataGrid);
}
else
{
DatasetBindToDataGrid();
}
Trace.WriteLine("FResultsView.populateDatasetwithThread took " +
(DateTime.Now - start).TotalMilliseconds.ToString() +
" ms.");
}
Trace.WriteLine("FResultsView.populateDatasetwithThread() unlocking \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
}
finally
{
Interlocked.Decrement(ref populateDatasetwithThreadsCount);
Trace.WriteLine("FResultsView.populateDatasetwithThread() ended");
}
}
private void ImportDatasetThread()
{
Trace.WriteLine("CFileImport: ImportDatasetThread started " +
"on thread \"" + Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
int i = -1;
foreach (DataRow row in this.ViewDatatable.Rows)
{
i++;
string classString = null;
Trace.WriteLine("CFileImport: ImportDatasetThread calling " +
"updatedFileImportCount(" + i.ToString() + ", " +
ViewDatatable.Rows.Count.ToString() + ")");
myInterface.updatedFileImportCount(
i, ViewDatatable.Rows.Count);
// Get shooter
string shooterCard = (string)row[viewTableColumnNames.Skyttekort.ToString().Trim()];
// Get shooter from DB
Structs.Shooter shooter;
try
{
shooter = myInterface.GetShooter(shooterCard);
classString = (string)row[viewTableColumnNames.Klass.ToString()];
if (classString.IndexOf("1") >= 0)
{
shooter.Class = Structs.ShootersClass.Klass1;
}
if (classString.IndexOf("2") >= 0)
{
shooter.Class = Structs.ShootersClass.Klass2;
}
if (classString.IndexOf("3") >= 0)
{
shooter.Class = Structs.ShootersClass.Klass3;
}
myInterface.UpdateShooter(shooter);
}
catch (CannotFindIdException)
{
// Add user to DB with values from file.
shooter = new Structs.Shooter();
// What class?
classString = (string)row[viewTableColumnNames.Klass.ToString()];
Structs.ShootersClass sclass = Structs.ShootersClass.Klass1;
if (classString.IndexOf("1") >= 0)
{
sclass = Structs.ShootersClass.Klass1;
}
if (classString.IndexOf("2") >= 0)
{
sclass = Structs.ShootersClass.Klass2;
}
if (classString.IndexOf("3") >= 0)
{
sclass = Structs.ShootersClass.Klass3;
}
if (shooterCard == "")
{
try
{
Random rnd = new Random();
while (true)
{
shooterCard = (-rnd.Next(100000)).ToString();
myInterface.GetShooter(shooterCard);
}
}
catch (CannotFindIdException)
{
}
}
// Create shooter and insert into database
shooter.Automatic = false;
shooter.CardNr = shooterCard.ToString();
shooter.Class = sclass;
shooter.ClubId = ((string)row[viewTableColumnNames.Klubb.ToString()]).Trim();
shooter.Email = ((string)row[viewTableColumnNames.Epost.ToString()]).Trim();
shooter.Givenname = ((string)row[viewTableColumnNames.Efternamn.ToString()]).Trim();
shooter.Surname = ((string)row[viewTableColumnNames.Fornamn.ToString()]).Trim();
shooter.Payed = 0;
shooter.ToAutomatic = false;
shooter.ShooterId = myInterface.NewShooter(shooter, false);
if (shooter.ShooterId < 0)
{
throw new ApplicationException("ShooterId is " + shooter.ShooterId);
}
}
// Ok, shooter is done. Create competitor
classString = (string)row[viewTableColumnNames.Klass.ToString().ToUpper()];
Structs.ShootersClass cclass = shooter.Class;
if (classString.IndexOf("D") >= 0)
{
cclass = (Structs.ShootersClass)(
(int)Structs.ShootersClass.Damklass1 - 1 +
(int)cclass);
}
if (classString.IndexOf("J") >= 0)
{
cclass = Structs.ShootersClass.Juniorklass;
}
if (classString.IndexOf("VY") >= 0)
{
cclass = Structs.ShootersClass.VeteranklassYngre;
}
if (classString.IndexOf("VÄ") >= 0)
{
cclass = Structs.ShootersClass.VeteranklassÄldre;
}
if (classString.IndexOf("Ö") >= 0)
{
cclass = Structs.ShootersClass.Öppen;
}
// Phu, class is done. Continue with competitor
Structs.Competitor competitor = new Structs.Competitor();
competitor.CompetitionId = myInterface.GetCompetitions()[0].CompetitionId;
competitor.ShooterId = shooter.ShooterId;
competitor.WeaponId = (string)row[viewTableColumnNames.Vapen.ToString()];
competitor.PatrolId = -1;
competitor.Lane = -1;
competitor.ShooterClass = cclass;
if (!row.IsNull(viewTableColumnNames.Patrull.ToString()) &&
((string)row[viewTableColumnNames.Patrull.ToString()]).Trim() != "")
{
try
{
// Patrol defined in importfile
string patrolString = (string)row[viewTableColumnNames.Patrull.ToString()];
int patrolId = -1;
patrolId = int.Parse(patrolString);
while (patrolId > myInterface.GetPatrolsCount())
{
myInterface.PatrolAddEmpty(false);
}
competitor.PatrolId = patrolId;
string laneString = null;
if (!row.IsNull(viewTableColumnNames.Bana.ToString()))
{
laneString = (string)row[viewTableColumnNames.Bana.ToString()];
}
if (laneString != null &&
laneString.Trim() != "")
{
competitor.Lane = int.Parse(laneString);
}
else
{
competitor.Lane = myInterface.PatrolGetNextLane(patrolId);
}
}
catch (System.FormatException)
{
// If this occurres, just ignore. It really shouldn't, since
// it has already been checked
}
}
myInterface.NewCompetitor(competitor, false);
}
myInterface.updatedFileImportCount(
ViewDatatable.Rows.Count,
ViewDatatable.Rows.Count);
myInterface.updatedShooter(new Structs.Shooter());
myInterface.updatedCompetitor(new Structs.Competitor());
myInterface.updatedPatrol();
}
