| public static SelectCurrentSessionPersons ( int sessionID, bool returnPersonAndPSlist ) : ArrayList | ||
| sessionID | int | |
| returnPersonAndPSlist | bool | |
| return | ArrayList | |
protected override void getData()
{
ArrayList dataPre = SqlitePersonSession.SelectCurrentSessionPersons(currentSession.UniqueID,
false); //means: do not returnPersonAndPSlist
data = new ArrayList();
nonSensitiveRows = new ArrayList();
int j = 0; //list of added persons
foreach (Person p in dataPre)
{
ArrayList eSQLarray = SqliteEncoder.Select(
false, -1, p.UniqueID, currentSession.UniqueID, encoderGI,
exerciseID, "curve", EncoderSQL.Eccons.ALL,
false, true);
int allCurves = eSQLarray.Count;
string [] s = { p.UniqueID.ToString(), "", p.Name,
//activeCurves.ToString(),
allCurves.ToString() };
data.Add(s);
if (allCurves == 0)
{
nonSensitiveRows.Add(j);
}
j++;
}
}
protected override void getData()
{
//create directory fileName_files/
string directoryName = Util.GetReportDirectoryName(fileName);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
else
{
//if it exists before, delete all pngs
string [] pngs = Directory.GetFiles(directoryName, "*.png");
foreach (string myFile in pngs)
{
File.Delete(myFile);
}
}
if (ShowCurrentSessionJumpers)
{
myPersonsAndPS = SqlitePersonSession.SelectCurrentSessionPersons(sessionID, true);
}
//Leave SQL opened in all this process
Sqlite.Open(); // ------------------------------
if (ShowSimpleJumps)
{
myJumps = SqliteJump.SelectJumps(true, sessionID, -1, "", "",
Sqlite.Orders_by.DEFAULT, -1);
}
if (ShowReactiveJumps)
{
myJumpsRj = SqliteJumpRj.SelectJumps(true, sessionID, -1, "", "");
}
if (ShowSimpleRuns)
{
myRuns = SqliteRun.SelectRuns(true, sessionID, -1, "",
Sqlite.Orders_by.DEFAULT, -1);
}
if (ShowIntervalRuns)
{
myRunsInterval = SqliteRunInterval.SelectRuns(true, sessionID, -1, "");
}
if (ShowReactionTimes)
{
myReactionTimes = SqliteReactionTime.SelectReactionTimes(true, sessionID, -1, "",
Sqlite.Orders_by.DEFAULT, -1);
}
if (ShowPulses)
{
myPulses = SqlitePulse.SelectPulses(true, sessionID, -1);
}
Sqlite.Close(); // ------------------------------
}
protected override void createGenericWindow()
{
/*
* Disabled because combo exercise is selected before (not on genericWinESR)
*
* add exercises to the combo (only the exercises done, and only unique)
* ArrayList encoderExercisesNames = new ArrayList();
* foreach(EncoderSQL es in data) {
* encoderExercisesNames = Util.AddToArrayListIfNotExist(encoderExercisesNames, Catalog.GetString(es.exerciseName));
* }
*/
genericWinESR = GenericWindow.Show(false, //don't show now
string.Format(Catalog.GetString("Saved repetitions of athlete {0} on this session."),
currentPerson.Name) + "\n" +
Catalog.GetString("Activate the repetitions you want to use clicking on first column.") + "\n" +
Catalog.GetString("If you want to edit or delete a row, right click on it.") + "\n",
bigArray);
genericWinESR.SetTreeview(columnsString, true, dataPrint, new ArrayList(), Constants.ContextMenu.EDITDELETE, false);
genericWinESR.ResetComboCheckBoxesOptions();
//genericWinESR.AddOptionsToComboCheckBoxesOptions(encoderExercisesNames);
genericWinESR.CreateComboCheckBoxes();
genericWinESR.MarkActiveCurves(checkboxes);
//find all persons in current session
ArrayList personsPre = SqlitePersonSession.SelectCurrentSessionPersons(
currentSession.UniqueID,
false); //means: do not returnPersonAndPSlist
string [] persons = new String[personsPre.Count];
int count = 0;
foreach (Person p in personsPre)
{
persons[count++] = p.UniqueID.ToString() + ":" + p.Name;
}
genericWinESR.SetComboValues(persons, currentPerson.UniqueID + ":" + currentPerson.Name);
genericWinESR.SetComboLabel(Catalog.GetString("Change the owner of selected repetition") +
" (" + Catalog.GetString("code") + ":" + Catalog.GetString("name") + ")");
genericWinESR.ShowEditRow(false);
genericWinESR.CommentColumn = 10;
genericWinESR.ShowButtonCancel(false);
genericWinESR.SetButtonAcceptSensitive(true);
genericWinESR.SetButtonCancelLabel(Catalog.GetString("Close"));
//used when we don't need to read data,
//and we want to ensure next window will be created at needed size
//genericWinESR.DestroyOnAccept=true;
//here is comented because we are going to read the checkboxes
genericWinESR.Type = GenericWindow.Types.ENCODER_SEL_REPS_IND_CURRENT_SESS;
}
private void on_button_next_clicked(object o, EventArgs args)
{
if (notebook_main.CurrentPage == 0)
{
if (radio_load.Active)
{
loadDo(); //this also defines the 'mode' variable
}
else
{
mode = ExecuteAuto.ModeTypes.BY_PERSONS;
if (radio_by_tests.Active)
{
mode = ExecuteAuto.ModeTypes.BY_TESTS;
}
else if (radio_by_sets.Active)
{
mode = ExecuteAuto.ModeTypes.BY_SETS;
}
//next button will be sensitive when first test is added
button_next.Sensitive = false;
}
showSeriesStuff(mode == ExecuteAuto.ModeTypes.BY_SETS);
notebook_main.NextPage();
}
else if (notebook_main.CurrentPage == 1)
{
ArrayList persons = SqlitePersonSession.SelectCurrentSessionPersons(
sessionID,
false); //means: do not returnPersonAndPSlist
orderedData = ExecuteAuto.CreateOrder(mode, persons,
treeviewSerie1Array, treeviewSerie2Array, treeviewSerie3Array);
createTreeviewResult(mode == ExecuteAuto.ModeTypes.BY_SETS);
fillTreeviewResult();
button_next.Label = Catalog.GetString("Accept");
if (orderedData.Count == 0)
{
button_next.Sensitive = false;
}
notebook_main.NextPage();
}
else // notebook_main.CurrentPage == 2
{
FakeButtonAccept.Click(); //signal to read orderedData
}
}
protected virtual void getData()
{
myPersonsAndPS = SqlitePersonSession.SelectCurrentSessionPersons(mySession.UniqueID, true);
//Leave SQL opened in all this process
Sqlite.Open(); // ------------------------------
myJumps = SqliteJump.SelectJumps(true, mySession.UniqueID, -1, "", "",
Sqlite.Orders_by.DEFAULT, -1);
myJumpsRj = SqliteJumpRj.SelectJumps(true, mySession.UniqueID, -1, "", "");
myRuns = SqliteRun.SelectRuns(true, mySession.UniqueID, -1, "",
Sqlite.Orders_by.DEFAULT, -1);
myRunsInterval = SqliteRunInterval.SelectRuns(true, mySession.UniqueID, -1, "");
myReactionTimes = SqliteReactionTime.SelectReactionTimes(true, mySession.UniqueID, -1, "",
Sqlite.Orders_by.DEFAULT, -1);
myPulses = SqlitePulse.SelectPulses(true, mySession.UniqueID, -1);
myMCs = SqliteMultiChronopic.SelectTests(true, mySession.UniqueID, -1);
Sqlite.Close(); // ------------------------------
}
protected void fillDialog(Event myEvent)
{
fillWindowTitleAndLabelHeader();
string id = myEvent.UniqueID.ToString();
if (myEvent.Simulated == Constants.Simulated)
{
label_simulated.Show();
}
label_event_id_value.Text = id;
label_event_id_value.UseMarkup = true;
if (showTv)
{
fillTv(myEvent);
}
else
{
label_tv_title.Hide();
entry_tv_value.Hide();
label_tv_units.Hide();
}
if (showTc)
{
fillTc(myEvent);
}
else
{
label_tc_title.Hide();
entry_tc_value.Hide();
label_tc_units.Hide();
}
if (showFall)
{
fillFall(myEvent);
}
else
{
label_fall_title.Hide();
entry_fall_value.Hide();
label_fall_units.Hide();
}
if (showDistance)
{
fillDistance(myEvent);
}
else
{
label_distance_title.Hide();
entry_distance_value.Hide();
label_distance_units.Hide();
}
if (showTime)
{
fillTime(myEvent);
}
else
{
label_time_title.Hide();
entry_time_value.Hide();
label_time_units.Hide();
}
if (showSpeed)
{
fillSpeed(myEvent);
}
else
{
label_speed_title.Hide();
label_speed_value.Hide();
label_speed_units.Hide();
}
if (showWeight)
{
fillWeight(myEvent);
}
else
{
label_weight_title.Hide();
entry_weight_value.Hide();
label_weight_units.Hide();
}
if (showLimited)
{
fillLimited(myEvent);
}
else
{
label_limited_title.Hide();
label_limited_value.Hide();
}
if (showAngle)
{
fillAngle(myEvent);
}
else
{
label_angle_title.Hide();
entry_angle_value.Hide();
label_angle_units.Hide();
}
if (!showMistakes)
{
label_mistakes.Hide();
spin_mistakes.Hide();
}
//also remove new line for old descriptions that used a textview
string temp = Util.RemoveTildeAndColonAndDot(myEvent.Description);
entry_description.Text = Util.RemoveNewLine(temp, true);
createComboEventType(myEvent);
if (!showType)
{
label_type_title.Hide();
combo_eventType.Hide();
}
if (showRunStart)
{
fillRunStart(myEvent);
}
else
{
label_run_start_title.Hide();
label_run_start_value.Hide();
}
ArrayList persons = SqlitePersonSession.SelectCurrentSessionPersons(
myEvent.SessionID,
false); //means: do not returnPersonAndPSlist
string [] personsStrings = new String[persons.Count];
int i = 0;
foreach (Person person in persons)
{
personsStrings[i++] = person.IDAndName(":");
}
combo_persons = ComboBox.NewText();
UtilGtk.ComboUpdate(combo_persons, personsStrings, "");
combo_persons.Active = UtilGtk.ComboMakeActive(personsStrings, myEvent.PersonID + ":" + myEvent.PersonName);
oldPersonID = myEvent.PersonID;
hbox_combo_person.PackStart(combo_persons, true, true, 0);
hbox_combo_person.ShowAll();
//show video if available
videoFileName = Util.GetVideoFileName(myEvent.SessionID, typeOfTest, myEvent.UniqueID);
if (File.Exists(videoFileName))
{
label_video_yes.Visible = true;
label_video_no.Visible = false;
button_video_watch.Sensitive = true;
button_video_url.Sensitive = true;
}
else
{
label_video_yes.Visible = false;
label_video_no.Visible = true;
button_video_watch.Sensitive = false;
button_video_url.Sensitive = false;
}
}
private static void on_server_upload_session_started()
{
int evalSID = Convert.ToInt32(SqlitePreferences.Select("evaluatorServerID"));
try {
ChronojumpServer myServer = new ChronojumpServer();
LogB.Information(myServer.ConnectDatabase());
int state = (int)Constants.ServerSessionStates.UPLOADINGSESSION;
//create ServerSession based on Session currentSession
ServerSession serverSession = new ServerSession(currentSession, evalSID, progName + " " + progVersion,
UtilAll.GetOS(), DateTime.Now, state);
//if uploading session for first time
if (currentSession.ServerUniqueID == Constants.ServerUndefinedID)
{
//upload ServerSession
int idAtServer = myServer.UploadSession(serverSession);
//update session currentSession (serverUniqueID) on client database
currentSession.ServerUniqueID = idAtServer;
SqliteSession.UpdateServerUniqueID(currentSession.UniqueID, currentSession.ServerUniqueID);
}
state = (int)Constants.ServerSessionStates.UPLOADINGDATA;
myServer.UpdateSession(currentSession.ServerUniqueID, state);
sessionUploadPersonData.testTypes = "";
string testTypesSeparator = "";
sessionUploadPersonData.sports = "";
string sportsSeparator = "";
//upload persons (updating also person.serverUniqueID locally)
ArrayList persons = SqlitePersonSession.SelectCurrentSessionPersons(
serverSession.UniqueID,
false); //means: do not returnPersonAndPSlist
Constants.UploadCodes uCode;
ArrayList notToUpload = SqlitePersonSessionNotUpload.SelectAll(currentSession.UniqueID);
//store in variable for updating progressBar from other thread
progressBarPersonsNum = persons.Count - notToUpload.Count;
foreach (Person p in persons)
{
Person person = p;
//do not continue with this person if has been banned to upload
if (Util.FoundInArrayList(notToUpload, person.UniqueID.ToString()))
{
continue;
}
PersonSession ps = SqlitePersonSession.Select(person.UniqueID, currentSession.UniqueID);
//check person if exists
if (person.ServerUniqueID != Constants.ServerUndefinedID)
{
uCode = Constants.UploadCodes.EXISTS;
}
else
{
uCode = Constants.UploadCodes.OK;
person = serverUploadPerson(myServer, person, serverSession.UniqueID);
}
//if sport is user defined, upload it
//and when upload the person, do it with new sportID
Sport sport = SqliteSport.Select(false, ps.SportID);
//but record old sport ID because locally will be a change in serverUniqueID
//(with slite update)
//but local sport has not to be changed
int sportUserDefinedLocal = -1;
if (sport.UserDefined)
{
sportUserDefinedLocal = sport.UniqueID;
//this will be uploaded
int newSport = myServer.UploadSport(sport);
if (newSport != -1)
{
ps.SportID = newSport;
sessionUploadPersonData.sports += sportsSeparator + sport.Name;
sportsSeparator = ", ";
}
}
//a person can be in the database for one session,
//but maybe now we add jumps from another session and we should add an entry at personsession
serverUploadPersonSessionIfNeeded(myServer, person.ServerUniqueID,
currentSession.ServerUniqueID, ps, sportUserDefinedLocal);
//other thread updates the gui:
sessionUploadPersonData.person = person;
sessionUploadPersonData.personCode = uCode;
//upload jumps
int countU = 0;
int countE = 0;
int countS = 0;
string [] jumps = SqliteJump.SelectJumps(false, currentSession.UniqueID, person.UniqueID, "", "",
Sqlite.Orders_by.DEFAULT, -1);
Sqlite.Open();
foreach (string myJump in jumps)
{
string [] js = myJump.Split(new char[] { ':' });
//select jump
Jump test = SqliteJump.SelectJumpData(Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
//if test is not simulated and has not been uploaded,
//see if it's type is not predefined and is not in the database
//then upload it first
if (test.Simulated == 0)
{
//upload jumpType if is user defined and doesn't exists in server database
//JumpType type = new JumpType(test.Type);
JumpType type = SqliteJumpType.SelectAndReturnJumpType(test.Type, true);
if (!type.IsPredefined)
{
//Console.WriteLine("USER DEFINED TEST: " + test.Type);
//
//this uploads the new type, as it's user created, it will be like this
//eg: for user defined jumpType: "supra" of evaluatorServerID: 9
//at server will be "supra-9"
//then two problems get solved:
//1.- every evaluator that uploads a type will have a different name
//than other evaluator uploading a type that is named the same but could be different
//(one can think that "supra" is another thing
//2- when the same evaluator upload some supra's, only a new type is created
//test.Type = myServer.UploadJumpType(type, evalSID);
//int testType = (int) Constants.TestTypes.JUMP;
//string insertedType = myServer.UploadTestType(Constants.TestTypes.JUMP, type, evalSID);
//string insertedType = myServer.UploadTestType(testType, type, evalSID);
string insertedType = myServer.UploadJumpType(type, evalSID);
if (insertedType != "-1")
{
//record type in test (with the "-7" if it's done by evaluator 7)
test.Type = insertedType;
//show user uploaded type (without the "-7")
sessionUploadPersonData.testTypes += testTypesSeparator + type.Name;
testTypesSeparator = ", ";
}
//test.Type in the server will have the correct name "supra-9"
}
}
//upload... (if not because of simulated or uploaded before, report also the user)
uCode = serverUploadTest(myServer, Constants.TestTypes.JUMP, Constants.JumpTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.jumpsU = countU;
sessionUploadPersonData.jumpsE = countE;
sessionUploadPersonData.jumpsS = countS;
//upload jumpsRj
countU = 0;
countE = 0;
countS = 0;
string [] jumpsRj = SqliteJumpRj.SelectJumps(false, currentSession.UniqueID, person.UniqueID, "", "");
Sqlite.Open();
foreach (string myJump in jumpsRj)
{
string [] js = myJump.Split(new char[] { ':' });
//select jump
JumpRj test = SqliteJumpRj.SelectJumpData(Constants.JumpRjTable, Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
if (test.Simulated == 0)
{
JumpType type = SqliteJumpType.SelectAndReturnJumpRjType(test.Type, true);
if (!type.IsPredefined)
{
string insertedType = myServer.UploadJumpRjType(type, evalSID);
if (insertedType != "-1")
{
test.Type = insertedType;
sessionUploadPersonData.testTypes += testTypesSeparator + type.Name;
testTypesSeparator = ", ";
}
}
}
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.JUMP_RJ, Constants.JumpRjTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.jumpsRjU = countU;
sessionUploadPersonData.jumpsRjE = countE;
sessionUploadPersonData.jumpsRjS = countS;
//upload runs
countU = 0;
countE = 0;
countS = 0;
string [] runs = SqliteRun.SelectRuns(false, currentSession.UniqueID, person.UniqueID, "",
Sqlite.Orders_by.DEFAULT, -1);
Sqlite.Open();
foreach (string myRun in runs)
{
string [] js = myRun.Split(new char[] { ':' });
//select run
Run test = SqliteRun.SelectRunData(Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
if (test.Simulated == 0)
{
RunType type = SqliteRunType.SelectAndReturnRunType(test.Type, true);
if (!type.IsPredefined)
{
string insertedType = myServer.UploadRunType(type, evalSID);
if (insertedType != "-1")
{
test.Type = insertedType;
sessionUploadPersonData.testTypes += testTypesSeparator + type.Name;
testTypesSeparator = ", ";
}
}
}
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.RUN, Constants.RunTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.runsU = countU;
sessionUploadPersonData.runsE = countE;
sessionUploadPersonData.runsS = countS;
//upload runs intervallic
countU = 0;
countE = 0;
countS = 0;
string [] runsI = SqliteRunInterval.SelectRuns(false, currentSession.UniqueID, person.UniqueID, "");
Sqlite.Open();
foreach (string myRun in runsI)
{
string [] js = myRun.Split(new char[] { ':' });
//select run
RunInterval test = SqliteRunInterval.SelectRunData(Constants.RunIntervalTable, Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
if (test.Simulated == 0)
{
RunType type = SqliteRunIntervalType.SelectAndReturnRunIntervalType(test.Type, true);
if (!type.IsPredefined)
{
string insertedType = myServer.UploadRunIntervalType(type, evalSID);
if (insertedType != "-1")
{
test.Type = insertedType;
sessionUploadPersonData.testTypes += testTypesSeparator + type.Name;
testTypesSeparator = ", ";
}
}
}
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.RUN_I, Constants.RunIntervalTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.runsIU = countU;
sessionUploadPersonData.runsIE = countE;
sessionUploadPersonData.runsIS = countS;
//upload reaction times
countU = 0;
countE = 0;
countS = 0;
string [] rts = SqliteReactionTime.SelectReactionTimes(false, currentSession.UniqueID, person.UniqueID,
Sqlite.Orders_by.DEFAULT, -1);
Sqlite.Open();
foreach (string myRt in rts)
{
string [] js = myRt.Split(new char[] { ':' });
//select rt
ReactionTime test = SqliteReactionTime.SelectReactionTimeData(Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.RT, Constants.ReactionTimeTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.rtsU = countU;
sessionUploadPersonData.rtsE = countE;
sessionUploadPersonData.rtsS = countS;
//upload pulses
countU = 0;
countE = 0;
countS = 0;
string [] pulses = SqlitePulse.SelectPulses(false, currentSession.UniqueID, person.UniqueID);
Sqlite.Open();
foreach (string myPulse in pulses)
{
string [] js = myPulse.Split(new char[] { ':' });
//select pulse
Pulse test = SqlitePulse.SelectPulseData(Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.PULSE, Constants.PulseTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.pulsesU = countU;
sessionUploadPersonData.pulsesE = countE;
sessionUploadPersonData.pulsesS = countS;
//upload multiChronopic
countU = 0;
countE = 0;
countS = 0;
string [] mcs = SqliteMultiChronopic.SelectTests(false, currentSession.UniqueID, person.UniqueID);
Sqlite.Open();
foreach (string mc in mcs)
{
string [] js = mc.Split(new char[] { ':' });
//select mc
MultiChronopic test = SqliteMultiChronopic.SelectMultiChronopicData(Convert.ToInt32(js[1]), true); //uniqueID
//fix it to server person, session keys
test.PersonID = person.ServerUniqueID;
test.SessionID = currentSession.ServerUniqueID;
//upload...
uCode = serverUploadTest(myServer, Constants.TestTypes.MULTICHRONOPIC, Constants.MultiChronopicTable, test);
if (uCode == Constants.UploadCodes.OK)
{
countU++;
}
else if (uCode == Constants.UploadCodes.EXISTS)
{
countE++;
}
else //SIMULATED
{
countS++;
}
}
Sqlite.Close();
//other thread updates the gui:
sessionUploadPersonData.mcsU = countU;
sessionUploadPersonData.mcsE = countE;
sessionUploadPersonData.mcsS = countS;
needUpdateServerSession = true;
while (needUpdateServerSession)
{
//wait until data is printed on the other thread
}
}
state = (int)Constants.ServerSessionStates.DONE;
//myServer.UpdateSession(currentSession.ServerUniqueID, (ServerSessionStates) Constants.ServerSessionStates.DONE);
myServer.UpdateSession(currentSession.ServerUniqueID, state);
LogB.Information(myServer.DisConnectDatabase());
} catch {
//other thread updates the gui:
serverSessionError = true;
}
}