| public static Select ( string myName ) : string | ||
| myName | string | |
| return | string | |
private void show_send_log(string sendLogMessage, string logLanguage)
{
label_send_log.Text = sendLogMessage;
emailStored = SqlitePreferences.Select("email");
if (emailStored != null && emailStored != "" && emailStored != "0")
{
entry_send_log.Text = emailStored;
}
//set language radiobuttons
if (logLanguage == "Catalan")
{
radio_log_catalan.Active = true;
}
else if (logLanguage == "Spanish")
{
radio_log_spanish.Active = true;
}
else if (logLanguage == "Portuguese")
{
radio_log_portuguese.Active = true;
}
else
{
radio_log_english.Active = true;
}
hbox_send_log.Show();
}
public void Show_send_log()
{
emailStored = SqlitePreferences.Select("email");
if (emailStored != null && emailStored != "" && emailStored != "0")
{
entry_send_log.Text = emailStored;
}
hbox_send_log.Show();
//button_send_log.Label = "Disabled";
//button_send_log.Sensitive = false;
}
//called when menuitem mode changes
public bool SelectTresholdForThisMode(Constants.Menuitem_modes m)
{
//declare it with default value to solve potential SQL problems
string newThreshold = "5";
//check current mode. Power modes doesn't use threshold
newThreshold = SqlitePreferences.Select(nameAtSQL(m), false);
if (Util.IsNumber(newThreshold, false))
{
t = Convert.ToInt32(newThreshold);
t_previous_on_this_mode = t;
return(true);
}
return(false);
}
public static void ServerUploadEvaluator()
{
try {
ChronojumpServer myServer = new ChronojumpServer();
LogB.Information(myServer.ConnectDatabase());
ServerEvaluator myEval = SqliteServer.SelectEvaluator(1);
bool success = false;
int evalSID = Convert.ToInt32(SqlitePreferences.Select("evaluatorServerID"));
if (evalSID == Constants.ServerUndefinedID)
{
string idCode = myServer.UploadEvaluator(myEval);
myEval.Code = Util.FetchName(idCode);
myEval.Update(false);
evalSID = Util.FetchID(idCode);
SqlitePreferences.Update("evaluatorServerID", evalSID.ToString(), false);
success = true;
}
else
{
success = myServer.EditEvaluator(myEval, evalSID);
}
if (success)
{
new DialogMessage(Constants.MessageTypes.INFO,
string.Format(Catalog.GetString("Successfully Uploaded evaluator with ID: {0}"), evalSID));
}
else
{
new DialogMessage(Constants.MessageTypes.WARNING,
string.Format(Catalog.GetString("Evaluator {0} has not been correctly uploaded. Maybe codes doesn't match."), evalSID));
}
LogB.Information(myServer.DisConnectDatabase());
} catch {
new DialogMessage(Constants.MessageTypes.WARNING, Constants.ServerOffline);
}
}
/*
* EncoderConfiguration
*/
//called on startup to load last encoderConfiguration
public static EncoderConfiguration LoadEncoderConfiguration()
{
string ecStr = SqlitePreferences.Select("encoderConfiguration", false);
//1.5.1 and previous don't store encoderConfiguration on SqlitePreferences
if (ecStr == null || ecStr.Length == 0 || ecStr == "0" || ecStr == "")
{
return(new EncoderConfiguration());
}
string [] ecStrFull = ecStr.Split(new char[] { ':' });
//create object
EncoderConfiguration ec = new EncoderConfiguration(
(Constants.EncoderConfigurationNames)
Enum.Parse(typeof(Constants.EncoderConfigurationNames), ecStrFull[0]));
//assign the rest of params
ec.ReadParamsFromSQL(ecStrFull);
return(ec);
}
private void sql_stress_test(int times)
{
Stopwatch sw = new Stopwatch();
sw.Start();
//trying if new way of Sqlite.Close disposing dbcmd fixes problems when multiple open / close connection
for (int i = 0; i < times; i++)
{
LogB.Debug(" i=" + i.ToString());
LogB.Debug(SqlitePreferences.Select("databaseVersion"));
}
sw.Stop();
string message = "Success!" +
" Done " + times + " times." +
" Elapsed " + sw.ElapsedMilliseconds + " ms";
LogB.Information(message);
label_advanced_feedback.Text = message;
}
/*
* private static string getIP() {
* string strHostName = "";
* strHostName = System.Net.Dns.GetHostName();
* IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(strHostName);
* IPAddress[] addr = ipEntry.AddressList;
* return addr[addr.Length-1].ToString();
* }
*/
public static string Ping(bool doInsertion, string progName, string progVersion)
{
try {
ChronojumpServer myServer = new ChronojumpServer();
LogB.Information(myServer.ConnectDatabase());
int evalSID = Convert.ToInt32(SqlitePreferences.Select("evaluatorServerID"));
string machineID = SqlitePreferences.Select("machineID");
ServerPing myPing = new ServerPing(evalSID, progName + " " + progVersion, UtilAll.GetOS(),
//getIP(), DateTime.Now); //evaluator IP, date
machineID, DateTime.Now); //evaluator machineID, date
//if !doIsertion nothing will be uploaded,
//is ok for uploadPerson to know if server is online
string versionAvailable = myServer.UploadPing(myPing, doInsertion);
LogB.Information(myServer.DisConnectDatabase());
return(versionAvailable);
} catch (Exception e) {
LogB.Information("Server Connection", e.Message);
return(Constants.ServerOffline);
}
}
public static void Main(string [] args)
{ /*
* bool timeLogPassedOk = Log.Start(args);
* Log.WriteLine(string.Format("Time log passed: {0}", timeLogPassedOk.ToString()));
* Log.WriteLine(string.Format("Client database option 1 in ... " + Util.GetDatabaseDir()));
* Log.WriteLine(string.Format("Client database option 2 in ... " + Util.GetDatabaseTempDir()));
*/
LogSync.Initialize();
//1.4.10
Log.Start();
LogB.Debugging = true; //now LogB.Debug will be shown. Also there will be thread info on Warning, Error, Information
if (args.Length > 0 && args[0] == "printAll")
{
LogB.PrintAllThreads = true;
}
var envPath = Environment.GetEnvironmentVariable("PATH");
var rBinPath = "";
baseDirectory = Util.GetPrefixDir();
/*
* location of gtkrc file
* DISABLED tight now because on windows there are inestabilities on jumps results
* and on Mode menu
*/
//Rc.AddDefaultFile (Util.GetThemeFile());
//LogB.Information("gtk theme:" + Util.GetThemeFile());
if (UtilAll.IsWindows())
{
//Environment.SetEnvironmentVariable ("R_HOME", RelativeToPrefix ("library"));
//rBinPath = RelativeToPrefix ("lib");
//rBinPath = RelativeToPrefix ("library");
//var rPath = System.Environment.Is64BitProcess ? @"C:\Program Files\R\R-3.0.2\bin\x64" : @"C:\Program Files\R\R-3.0.2\bin\i386";
string x64 = "bin" + System.IO.Path.DirectorySeparatorChar + "x64";
string i386 = "bin" + System.IO.Path.DirectorySeparatorChar + "i386";
var rPath = System.Environment.Is64BitProcess ?
System.IO.Path.Combine(baseDirectory, x64) : System.IO.Path.Combine(baseDirectory, i386);
if (Directory.Exists(rPath) == false)
{
LogB.Error("Could not found the specified path to the directory containing R.dll: ", rPath);
throw new DirectoryNotFoundException(string.Format("Could not found the specified path to the directory containing R.dll: {0}", rPath));
}
var newPath = string.Format("{0}{1}{2}", rPath, System.IO.Path.PathSeparator, envPath);
LogB.Information("newPath:", newPath);
System.Environment.SetEnvironmentVariable("PATH", newPath);
LogB.Information("path:", System.Environment.GetEnvironmentVariable("PATH"));
//use this because we don't want to look at the registry
//we don't want to force user to install R
Environment.SetEnvironmentVariable("R_HOME", baseDirectory);
LogB.Information("R_HOME:", baseDirectory);
}
else
{
switch (UtilAll.GetOSEnum())
{
case UtilAll.OperatingSystems.MACOSX:
LogB.Information(Environment.GetEnvironmentVariable("R_HOME"));
rBinPath = "/Library/Frameworks/R.Framework/Libraries";
Environment.SetEnvironmentVariable("R_HOME", "/Library/Frameworks/R.Framework/Resources");
Environment.SetEnvironmentVariable("PATH", rBinPath + Path.PathSeparator + envPath);
LogB.Information("environments");
LogB.Information(Environment.GetEnvironmentVariable("R_HOME"));
LogB.Information(Environment.GetEnvironmentVariable("PATH"));
//Gstreamer stuff
string prefix = "/Applications/Chronojump.app/Contents/Home/";
Environment.SetEnvironmentVariable("GST_PLUGIN_PATH", prefix + "lib/gstreamer-0.10");
Environment.SetEnvironmentVariable("GST_PLUGIN_SYSTEM_PATH", prefix + "lib/gstreamer-0.10");
Environment.SetEnvironmentVariable("GST_PLUGIN_SCANNER_PATH", prefix + "lib/gstreamer-0.10/gst-plugin-scanner");
break;
case UtilAll.OperatingSystems.LINUX:
rBinPath = @"/usr/lib/R/lib";
Environment.SetEnvironmentVariable("R_HOME", @"/usr/lib/R");
Environment.SetEnvironmentVariable("PATH", envPath + Path.PathSeparator + rBinPath);
break;
}
}
LogB.Information("Platform:" + Environment.OSVersion.Platform);
LogB.Information("baseDir0:", System.AppDomain.CurrentDomain.BaseDirectory);
LogB.Information("baseDir1:", baseDirectory);
LogB.Information("envPath+rBinPath:", envPath + Path.PathSeparator + rBinPath);
//UtilCSV.ReadValues("/tmp/chronojump-encoder-graph-input-multi.csv");
if (UtilAll.IsWindows())
{
Environment.SetEnvironmentVariable("GST_PLUGIN_PATH", RelativeToPrefix("lib\\gstreamer-0.10"));
}
//this call has to be done to chronojump.prg
//chronojump.prg createBlankDB
//this creates a blank database and exists.
//Then new user will have an updated database without the need of creating in
if (args.Length > 0 && args[0] == "createBlankDB")
{
createBlankDB();
Environment.Exit(1);
}
if (args.Length > 0 && args[0] == "createBlankDBServer")
{
createBlankDBServer();
Environment.Exit(1);
}
string language = "";
if (File.Exists(System.IO.Path.Combine(Util.GetDatabaseDir(), "chronojump.db")))
{
try {
Sqlite.Connect();
/*
* chronojump 1.5.2 converts DB 1.24 to 1.25 changing language to ""
* but this operation is done later (on sqliteThings)
* We need here! to define the language from the beginning
* so we use language = "" if version is prior to 1.25
*/
string currentDBVersion = SqlitePreferences.Select("databaseVersion", false);
double currentDBVersionDouble = Convert.ToDouble(Util.ChangeDecimalSeparator(currentDBVersion));
if (currentDBVersionDouble < Convert.ToDouble(Util.ChangeDecimalSeparator("1.25")))
{
language = "";
}
else
{
language = SqlitePreferences.Select("language", false);
}
Sqlite.DisConnect();
if (language != "")
{
//convert pt-BR to pt_BR
if (language.Contains("-"))
{
language = language.Replace("-", "_");
}
Environment.SetEnvironmentVariable("LANGUAGE", language); //works
#if OSTYPE_WINDOWS
g_setenv("LANGUAGE", language, true);
#endif
}
}
catch {
LogB.Warning("Problem reading language on start");
}
}
Catalog.Init("chronojump", System.IO.Path.Combine(Util.GetPrefixDir(), "share/locale"));
new ChronoJump(args);
}
protected void sqliteThings()
{
configChronojump = new Config();
configChronojump.Read();
bool badExit = checkIfChronojumpExitAbnormally();
if (badExit)
{
if (chronojumpIsExecutingNTimes())
{
messageToShowOnBoot += Catalog.GetString("Chronojump is already running") + "\n\n" +
Catalog.GetString("Chronojump will exit now.");
chronojumpHasToExit = true;
quitNowCjTwoTimes = true;
LogB.Error("Chronojump is already running.");
return;
}
else
{
chronojumpCrashedBefore();
}
}
//print version of chronojump
progVersion = BuildInfo.chronojumpVersion;
LogB.Information("Chronojump version: {0}", progVersion);
//to store user videos and photos
Util.CreateMultimediaDirsIfNeeded();
//to store (encoder, force sensor, run encoder) data and graphs
UtilEncoder.CreateEncoderDirIfNeeded();
Util.CreateForceSensorDirIfNeeded();
Util.CreateRaceAnalyzerDirIfNeeded();
//TODO: when a session is deleted, encoder data has to be deleted, also multimedia videos, I suppose. Show message to user warning about it
//TODO: encoder weight auto written depending on person loaded, and changes if it changes person or weight
//move database to new location if chronojump version is before 0.7
moveDatabaseToNewLocationIfNeeded();
LogB.Information("move? ended");
splashMessageChange(1); //checking database
/*
* splashMessage = "pre-connect";
* needUpdateSplashMessage = true;
* Console.ReadLine();
*/
Sqlite.CreateDir();
bool defaultDBLocation = Sqlite.Connect();
LogB.SQL("sqlite connected");
/*
* splashMessage = "post-connect" + defaultDBLocation.ToString();
* needUpdateSplashMessage = true;
* Console.ReadLine();
*/
//Chech if the DB file exists
if (!Sqlite.CheckTables(defaultDBLocation))
{
LogB.SQL(Catalog.GetString("no tables, creating ..."));
creatingDB = true;
splashMessageChange(2); //creating database
/*
* splashMessage = "pre-create";
* needUpdateSplashMessage = true;
* Console.ReadLine();
*/
Sqlite.CreateDir();
Sqlite.CreateFile();
//Sqlite.CreateFile(defaultDBLocation);
/*
* splashMessage = "post-create";
* needUpdateSplashMessage = true;
* Console.ReadLine();
*/
createRunningFileName(runningFileName);
Sqlite.CreateTables(false); //not server
creatingDB = false;
}
else
{
LogB.SQL("doing backup");
//backup the database
Util.BackupDirCreateIfNeeded();
splashMessageChange(3); //making db backup
Util.BackupDatabase();
LogB.SQL("made a database backup"); //not compressed yet, it seems System.IO.Compression.DeflateStream and
//System.IO.Compression.GZipStream are not in mono
if (!Sqlite.IsSqlite3())
{
bool ok = Sqlite.ConvertFromSqlite2To3();
if (!ok)
{
LogB.Error("problem with sqlite");
//check (spanish)
//http://mail.gnome.org/archives/chronojump-devel-list/2008-March/msg00011.html
string errorMessage = Catalog.GetString("Failed database conversion, ensure you have libsqlite3-0 installed. \nIf problems persist ask in chronojump-list");
errorMessage += "\n\n" + string.Format(Catalog.GetString("If you have no data on your database (you just installed Chronojump), you can fix this problem deleting this file: {0}"),
Util.GetDatabaseDir() + Path.DirectorySeparatorChar + "chronojump.db") +
"\n" + Catalog.GetString("And starting Chronojump again.");
LogB.Error(errorMessage);
messageToShowOnBoot += errorMessage;
chronojumpHasToExit = true;
return;
}
Sqlite.Connect();
}
splashMessageChange(4); //updating DB
updatingDB = true;
if (Sqlite.ChangeDjToDJna())
{
messageToShowOnBoot += Catalog.GetString("All DJ jumps have been renamed as 'DJna' (Drop Jumps with No Arms).") + "\n\n" +
Catalog.GetString("If your Drop Jumps were executed using the arms, please rename them manually as 'DJa'.") + "\n";
}
bool softwareIsNew = Sqlite.ConvertToLastChronojumpDBVersion();
updatingDB = false;
if (!softwareIsNew)
{
//Console.Clear();
string errorMessage = string.Format(Catalog.GetString("Sorry, this Chronojump version ({0}) is too old for your database."), progVersion) + "\n" +
Catalog.GetString("Please update Chronojump") + ":\n";
errorMessage += "http://chronojump.org";
//errorMessage += "\n\n" + Catalog.GetString("Press any key");
LogB.Error(errorMessage);
messageToShowOnBoot += errorMessage;
chronojumpHasToExit = true;
}
LogB.Information(Catalog.GetString("tables already created"));
//check for bad Rjs (activate if program crashes and you use it in the same db before v.0.41)
//SqliteJump.FindBadRjs();
createRunningFileName(runningFileName);
}
//splashMessageChange(5); //check for new version
splashMessageChange(5); //connecting to server
messageToShowOnBoot += recuperateBrokenEvents();
//connect to server to Ping
versionAvailable = "";
versionAvailable = Constants.ServerOffline;
//doing ping using json methods
/*
* temporarily disabled on start
* string machineID = SqlitePreferences.Select("machineID", false);
* Json js = new Json();
* bool success = js.Ping(UtilAll.GetOS(), progVersion, machineID);
* if(success)
* LogB.Information(js.ResultMessage);
* else
* LogB.Error(js.ResultMessage);
*/
allSQLCallsDoneOnSqliteThingsThread = false;
//wait until pinging ends (or it's cancelled)
//while(! pingEnd) {
//}
Sqlite.Open();
//TODO: fix this to the new code
string versionAvailableKnown = SqlitePreferences.Select("versionAvailable", true);
if (versionAvailable != Constants.ServerOffline && new Version(versionAvailable) > new Version(progVersion))
{
//check if available version is higher than known available version
Version versionAvailableAsV = new Version(versionAvailable);
Version versionAvailableKnownAsV;
bool updateKnownVersion = false;
if (versionAvailableKnown == "")
{
updateKnownVersion = true;
}
else
{
versionAvailableKnownAsV = new Version(versionAvailableKnown);
if (versionAvailableAsV > versionAvailableKnownAsV)
{
updateKnownVersion = true;
}
}
if (updateKnownVersion)
{
//is the first time we know about this new version
//just write on db and show message to user
SqlitePreferences.Update(Constants.PrefVersionAvailable, versionAvailable, true);
versionAvailableKnown = versionAvailable;
messageToShowOnBoot += string.Format(Catalog.GetString(
"\nNew Chronojump version available on website.\nYour Chronojump version is: {1}"),
versionAvailable, progVersion) + "\n\n" +
Catalog.GetString("Please, update to new version.") + "\n";
}
}
//if chronojump chrashed before
if (badExit)
{
if (versionAvailableKnown.Length > 0 && new Version(versionAvailableKnown) > new Version(progVersion))
{
messageToShowOnBoot += "\n" + Catalog.GetString("Chronojump crashed before.") + "\n" +
Catalog.GetString("Please, update to new version: ") + versionAvailableKnown + "\n";
}
else
{
messageToShowOnBoot += messageCrashedBefore;
//SqlitePreferences.Update("videoOn", "False", true);
}
}
splashMessageChange(6); //preparing main window
//start as "simulated"
SqlitePreferences.Update("simulated", "True", true); //dbcon opened
Sqlite.Close();
// Chronojump sqlite is in an initialized state, let's keep the Sqlite state here
// to be re-used
Sqlite.saveClassState();
allSQLCallsDoneOnSqliteThingsThread = true;
LogB.SQL("all SQL calls done on sqliteThings thread");
UtilAll.IsWindows(); //only as additional info here
//Application.Init();
needEndSplashWin = true;
}
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;
}
}
public string UploadPing(ServerPing myPing, bool doInsertion)
{
//problemes getting user ip:
//when it works it should be assigned to myPing.IP
//string a = Request.UserHostName;
//Console.WriteLine(System.Web.HttpRequest.UserHostAdress);
Console.WriteLine("ping string: " + myPing.ToString());
string strHostName = "";
strHostName = System.Net.Dns.GetHostName();
IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(strHostName);
IPAddress[] addr = ipEntry.AddressList;
string ip = addr[addr.Length - 1].ToString();
Console.WriteLine("ip: " + ip);
//!doInsertion is a way to know if server is connected
//but without inserting nothing
//is ok before uploading a session
//Console.WriteLine("IP: " + System.Web.HttpRequest.UserHostAddress.ToString());
//Console.WriteLine("IP: " + System.Net.HttpRequest.UserHostAddress.ToString());
//Console.WriteLine("IP: " + System.Net.Request.UserHostAddress.ToString());
//Console.WriteLine("IP: " + HttpContext.Current.Request.UserHostAddress);
//Console.WriteLine("IP context : " + this.Context.Request.UserHostAddress);
//Console.WriteLine("IP : " + this.Request.UserHostAddress);
//Console.WriteLine("IP : " + System.Net.HttpListenerRequest.UserHostAddress.ToString());
//System.Net.HttpListenerRequest req = new System.Net.HttpListenerRequest();
//Console.WriteLine("IP : " + req.UserHostAddress.ToString());
// System.Net.HttpListenerRequest req;
//string a = System.Net.HttpListenerRequest.UserHostAddress;
// string a = req.UserHostAddress;
//string a = this.System.Net.HttpListenerRequest.UserHostAddress;
// System.Net.HttpListenerRequest request = new HttpListenerRequest (String.Empty, "http://localhost/", String.Empty);
// string a = request.UserHostAddress;
//http://lists.ximian.com/pipermail/mono-list/2007-January/033998.html
/*
* HttpListener listener = new HttpListener();
*
* listener.AuthenticationSchemeSelectorDelegate += delegate{
* Console.WriteLine("Asking for authentication scheme");
* return AuthenticationSchemes.Basic;
* };
*
*
*
* listener.Start();
* HttpListenerContext context = listener.GetContext();
* HttpListenerRequest request = context.Request;
* Console.WriteLine("IP req: " + request.UserHostAddress);
*/
if (doInsertion)
{
myPing.InsertAtDB(false);
}
return(SqlitePreferences.Select("versionAvailable"));
}
