internal void PatrolRemoveLast()
{
Trace.WriteLine("CPatrolManagement: patrolRemoveLast() started on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() +
" )");
try
{
database = myInterface.databaseClass.Database;
if (database.Patrols.Count == 0)
{
return;
}
Trace.WriteLine("CPatrolManagement: PatrolRemoveLast() " +
" locking \"PatrolRemoveLastLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (PatrolRemoveLastLock)
{
Trace.WriteLine("CPatrolManagement: PatrolRemoveLast() " +
" locked \"PatrolRemoveLastLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
if (database.Patrols.Count == 0)
{
return;
}
int pid = getHighestPatrolId();
if (myInterface.GetCompetitorsCountPatrol(myInterface.GetPatrol(pid)) > 0)
{
throw new ApplicationException("CompetitorsExist");
}
Structs.Patrol patrol =
myInterface.GetPatrol(pid);
myInterface.DelPatrol(patrol, false);
Trace.WriteLine("CPatrolManagement: PatrolRemoveLast() " +
" locked \"PatrolRemoveLastLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
}
}
catch (System.Data.DeletedRowInaccessibleException)
{
Trace.WriteLine("CPatrolManagement: PatrolRemoveLast DeletedRowInaccessibleException. Retrying.");
PatrolRemoveLast();
}
finally
{
Trace.WriteLine("CPatrolManagement: PatrolRemoveLast ended.");
}
}
private static void addConstraint(string constraintName, DatabaseDataset database, OleDbConnection conn)
{
Trace.WriteLine("CDatabase: Entering createDatabaseConstraints()");
StringBuilder sqlCreate = new StringBuilder("");
foreach (System.Data.DataRelation rel in database.Relations)
{
if (rel.RelationName == constraintName)
{
sqlCreate = new StringBuilder("");
sqlCreate.Append("ALTER TABLE " + rel.ChildTable.TableName + " ADD " +
"CONSTRAINT " + rel.RelationName + " FOREIGN KEY " +
"(" + rel.ChildColumns[0].ColumnName + ")" +
" REFERENCES " + rel.ParentTable +
" (" + rel.ParentColumns[0].ColumnName +
")");
// Execute against database
Trace.WriteLine("CDatabase: Running SQL to create relation: " + sqlCreate.ToString());
OleDbCommand SQL = new OleDbCommand(sqlCreate.ToString(), conn);
SQL.ExecuteNonQuery();
SQL.Dispose();
}
}
}
/*private ResultsReturn[] convertIntoArray(ResultsReturn results)
* {
* ResultsReturn[] returnArray =
* new ResultsReturn[results.Count];
* int i = 0;
* Structs.Competition competition = myInterface.GetCompetitions()[0];
* foreach(DSResults.ResultsRow row in results)
* {
* returnArray[i] = new ResultsReturn(competition.Type, competition.NorwegianCount);
* returnArray[i].ClubId = row.ClubId;
* returnArray[i].CompetitorId = row.CompetitorId;
* returnArray[i].HitsTotal = row.Hits;
* returnArray[i].Medal = row.Medal;
* returnArray[i].PointsTotal = row.Points;
* returnArray[i].ShooterName = row.ShooterName;
* returnArray[i].FigureHitsTotal = row.FigureHits;
* returnArray[i].HitsPerStnString = row.HitsPerStn;
* returnArray[i].FinalShootingPlace = row.FinalShootingPlace;
* returnArray[i].PriceMoney = row.PriceMoney;
* i++;
* }
* return returnArray;
* }*/
internal Structs.ResultWeaponsClass[] ResultsGetWClasses()
{
database = myInterface.databaseClass.Database;
ArrayList list = new ArrayList();
for (int i = 1; i <= Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass thisClass =
(Structs.ResultWeaponsClass)i;
try
{
int.Parse(thisClass.ToString());
}
catch (Exception)
{
// thisClass is a string, which means it is a valid class
if (myInterface.GetCompetitorResultsExist(thisClass))
{
list.Add(thisClass);
}
}
}
return((Structs.ResultWeaponsClass[])list.ToArray(typeof(Structs.ResultWeaponsClass)));
}
internal void PatrolAddEmpty(bool notifyGui)
{
database = myInterface.databaseClass.Database;
DateTime compStart = myInterface.GetCompetitions()[0].StartTime;
int timeBetweenPatrols = database.Competition[0].PatrolTimeBetween;
int lastStart = 0 - timeBetweenPatrols;
int patrolId = 0;
foreach (DatabaseDataset.PatrolsRow row in database.Patrols)
{
if (row.StartDateTime > lastStart)
{
lastStart = row.StartDateTime;
}
if (row.PatrolId > patrolId)
{
patrolId = row.PatrolId;
}
}
Structs.Patrol patrol = new Structs.Patrol();
patrol.PatrolId = patrolId + 1;
patrol.StartDateTime = compStart.AddMinutes((int)(lastStart + timeBetweenPatrols));
patrol.CompetitionId = database.Competition[0].CompetitionId;
myInterface.NewPatrol(patrol, notifyGui);
}
internal byte[] ExportResults()
{
database = myInterface.databaseClass.Database;
MemoryStream memStream = new MemoryStream();
database.WriteXml(memStream);
return(memStream.ToArray());
}
internal ResultsReturnTeam[] GetTeamResults(Structs.ResultWeaponsClass wclass,
Structs.Competition competition)
{
Trace.WriteLine("CResults.GetResults(" + wclass.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;
CompetitionType = myInterface.CompetitionCurrent.Type;
database = myInterface.databaseClass.Database;
useNorwegianCount = competition.NorwegianCount;
// Ok, now lets count the real ones
DSResults results = getAllTeams(wclass);
results = sortTeams(results);
ResultsReturnTeam[] toReturn =
convertIntoArray(results);
return(toReturn);
}
finally
{
Trace.WriteLine("CResultsTeam: GetResults() " +
" unlocking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Trace.WriteLine("CResults.GetResults ended.");
resultsAlreadyRunning = false;
}
}
}
internal byte[] ExportResults()
{
database = myInterface.databaseClass.Database;
StringBuilder toReturn = new StringBuilder();
foreach (DatabaseDataset.CompetitorsRow competitor in
database.Competitors)
{
toReturn.Append(createCompetitorLine(competitor));
}
Encoding encoding = Encoding.GetEncoding(1252);
byte[] bytes = encoding.GetBytes(toReturn.ToString());
return(bytes);
}
internal void PatrolAddAutomaticCompetitors(bool CleanPatrols, bool preserveCompetitorOrder)
{
Trace.WriteLine("CPatrolManagement: PatrolAddAutomaticCompetitors(" +
CleanPatrols.ToString() + ") started on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() +
" )");
database = myInterface.databaseClass.Database;
// First clean patrols if instructed
if (CleanPatrols)
{
cleanPatrols();
myInterface.updatedPatrol();
}
// Check there is any competitors
if (this.database.Competitors
.Select("PatrolId is null").Length == 0)
{
return;
}
this.myInterface.updatedPatrolAddAutomaticCompetitors(
0, 3 * database.Shooters.Count);
// Create list
DSPatrolManagement dblist = createList();
// Sort list
dblist = sortList(dblist);
// Spread list evenly
spreadList(dblist, preserveCompetitorOrder);
// Update interface
this.myInterface.updatedPatrolAddAutomaticCompetitors(
3 * database.Shooters.Count,
3 * database.Shooters.Count);
Trace.WriteLine("CPatrolManagement: PatrolAddAutomaticCompetitors ended.");
}
internal byte[] ExportClubs()
{
database = myInterface.databaseClass.Database;
StringBuilder toReturn = new StringBuilder();
toReturn.Append("Klubbid;Namn;Land;Epost;Bankgiro;Plusgiro;\r\n");
foreach (DatabaseDataset.ClubsRow club in
database.Clubs)
{
toReturn.Append(createClubsLine(club));
}
Encoding encoding = Encoding.GetEncoding(1252);
byte[] bytes = encoding.GetBytes(toReturn.ToString());
return(bytes);
}
internal byte[] ExportWeapons()
{
database = myInterface.databaseClass.Database;
StringBuilder toReturn = new StringBuilder();
toReturn.Append("WeaponId;Tillverkare;Modell;Kaliber;\r\n");
foreach (DatabaseDataset.WeaponsRow weapon in
database.Weapons)
{
toReturn.Append(createWeaponsLine(weapon));
}
Encoding encoding = Encoding.GetEncoding(1252);
byte[] bytes = encoding.GetBytes(toReturn.ToString());
return(bytes);
}
private void UpgradeVersion1_1()
{
if (checkTableExist("Teams", dbconn))
{
dropTable("Teams", dbconn);
}
// Create table Teams
CDatabase.CreateTable(new DatabaseDataset.TeamsDataTable(), dbconn);
string sqlCreate;
OleDbCommand SQL;
// Create restrictions for table Teams
DatabaseDataset dbtemp = new DatabaseDataset();
foreach (System.Data.DataRelation rel in dbtemp.Relations)
{
if (rel.RelationName.IndexOf("Teams") > -1)
{
sqlCreate = "ALTER TABLE " + rel.ChildTable.TableName + " ADD " +
"CONSTRAINT " + rel.RelationName + " FOREIGN KEY " +
"(" + rel.ChildColumns[0].ColumnName + ")" +
" REFERENCES " + rel.ParentTable +
" (" + rel.ParentColumns[0].ColumnName +
")";
// Execute against database
Trace.WriteLine("CDatabase: Running SQL to create relation: " + sqlCreate);
SQL = new OleDbCommand(sqlCreate, dbconn);
SQL.ExecuteNonQuery();
SQL.Dispose();
}
}
// Create table DbInfo
CDatabase.CreateTable(new DatabaseDataset.DbInfoDataTable(), dbconn);
// Change shooter table to include "arrived" column
addColumnToTable("shooters", "Arrived", "bit null", dbconn);
addColumnToTable("shooters", "EmailResult", "bit null", dbconn);
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
DatabaseDataset ds = new DatabaseDataset();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
DatabaseDataset ds = new DatabaseDataset();
global::System.Xml.Schema.XmlSchemaAny any1 = new global::System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
global::System.Xml.Schema.XmlSchemaAny any2 = new global::System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
global::System.Xml.Schema.XmlSchemaAttribute attribute1 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
global::System.Xml.Schema.XmlSchemaAttribute attribute2 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "DbInfoDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
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());
}
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;
}
}
}
