[chronojump/update-database-before-importing] chronojump-importer: better handling of the temporary file and calls Sqlite.Connect() to read from t

[Carles Pina i Estany <carlespina src gnome org>]

commit 1e9749a00aacb9a416590da5387c3eb1afac05b6
Author: Carles Pina i Estany <carles pina cat>
Date:   Fri Sep 30 12:54:06 2016 +0200

    chronojump-importer: better handling of the temporary file and calls Sqlite.Connect() to read from the 
new database.
    
    Now Chronojump always copies the source file to a temporary file and
    never reads the source file. Even if it doesn't need to be updated,
    easier to read the code.
    
    Also, important, calls Sqlite.Connect() so it connects to the new
    database file (!). Otherwise it was never updating it because Sqlite
    class was still connected to the old file.

 src/chronojumpImporter.cs |   45 ++++++++++++++++-----------------------------
 src/sqlite/main.cs        |   10 ++++++++--
 2 files changed, 24 insertions(+), 31 deletions(-)
---
diff --git a/src/chronojumpImporter.cs b/src/chronojumpImporter.cs
index af90334..bff9a54 100644
--- a/src/chronojumpImporter.cs
+++ b/src/chronojumpImporter.cs
@@ -38,10 +38,6 @@ class ChronojumpImporter
        // Session that will import
        private string session;
 
-       // When importing we might copy the sourceFile to update to the current database.
-       // The file is deleted afterwards
-       private string temporaryFile = "";
-
        // Result struct holds the output, error and success operations. It's used to pass
        // errors from different layers (e.g. executing Python scripts) to the UI layer
        public struct Result
@@ -74,8 +70,11 @@ class ChronojumpImporter
        // tries to import a newer chronojump version.
        public Result import()
        {
-               Result sourceDatabaseVersion = getSourceDatabaseVersion ();
-               Result destinationDatabaseVersion = getDestinationDatabaseVersion ();
+               string temporarySourceFile = Path.GetTempFileName ();
+               File.Copy (sourceFile, temporarySourceFile, true);
+
+               Result sourceDatabaseVersion = getDatabaseVersionFromFile (temporarySourceFile);
+               Result destinationDatabaseVersion = getDatabaseVersionFromFile (destinationFile);
 
                if (! sourceDatabaseVersion.success)
                        return sourceDatabaseVersion;
@@ -90,10 +89,12 @@ class ChronojumpImporter
                        return new Result (false, Catalog.GetString ("Trying to import a newer database 
version than this Chronojump\n" +
                                "Please, update the running Chronojump."));
                } else if (destinationDatabaseVersionNum > sourceDatabaseVersionNum) {
-                       updateSourceDatabase ();
+                       LogB.Debug ("chronojump-importer version before update: ", 
sourceDatabaseVersion.output);
+                       updateDatabase (temporarySourceFile);
+                       string versionAfterUpdate = getDatabaseVersionFromFile (temporarySourceFile).output;
+                       LogB.Debug ("chronojump-importer version after update: ", versionAfterUpdate);
                }
 
-
                List<string> parameters = new List<string> ();
                parameters.Add ("--source");
                parameters.Add (CommandLineEncoder.EncodeArgText (sourceFile));
@@ -104,41 +105,27 @@ class ChronojumpImporter
 
                Result result = executeChronojumpImporter (parameters);
 
-               if (temporaryFile != "") {
-                       File.Delete (temporaryFile);
-                       temporaryFile = "";
-               }
+               File.Delete (temporarySourceFile);
 
                return result;
        }
 
-       private bool updateSourceDatabase()
+       private static void updateDatabase(string databaseFile)
        {
                StaticClassState classOriginalState = new StaticClassState (typeof (Sqlite));
-               temporaryFile = Path.GetTempFileName ();
-
-               File.Copy (sourceFile, temporaryFile, true);
 
                classOriginalState.readAttributes ();
 
                classOriginalState.writeAttributes (Sqlite.InitialState);
-               Sqlite.setSqlFilePath (temporaryFile);
-               Sqlite.ConvertToLastChronojumpDBVersion ();
 
-               classOriginalState.writeAttributes (classOriginalState);
+               Sqlite.CurrentVersion = "0";
+               Sqlite.setSqlFilePath (databaseFile);
                Sqlite.Connect ();
 
-               return true;
-       }
-
-       private Result getSourceDatabaseVersion()
-       {
-               return getDatabaseVersionFromFile (sourceFile);
-       }
+               Sqlite.ConvertToLastChronojumpDBVersion ();
 
-       private Result getDestinationDatabaseVersion()
-       {
-               return getDatabaseVersionFromFile (destinationFile);
+               classOriginalState.writeAttributes (classOriginalState);
+               Sqlite.Connect ();
        }
 
        private Result getDatabaseVersionFromFile(string filePath)
diff --git a/src/sqlite/main.cs b/src/sqlite/main.cs
index 8c278f5..e32cba6 100644
--- a/src/sqlite/main.cs
+++ b/src/sqlite/main.cs
@@ -283,12 +283,18 @@ class Sqlite
 
        public static string DatabaseFilePath
        {
-               get
-               {
+               get {
                        return sqlFile;
                }
        }
 
+       public static string CurrentVersion
+       {
+               set {
+                       currentVersion = value;
+               }
+       }
+
        public static void setSqlFilePath(string filePath)
        {
                sqlFile = filePath;