creaImageIOSynchron.cpp

Go to the documentation of this file.

/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image 
#                        pour la Santé)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  This software is governed by the CeCILL-B license under French law and 
#  abiding by the rules of distribution of free software. You can  use, 
#  modify and/ or redistribute the software under the terms of the CeCILL-B 
#  license as circulated by CEA, CNRS and INRIA at the following URL 
#  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
#  or in the file LICENSE.txt.
#
#  As a counterpart to the access to the source code and  rights to copy,
#  modify and redistribute granted by the license, users are provided only
#  with a limited warranty  and the software's author,  the holder of the
#  economic rights,  and the successive licensors  have only  limited
#  liability. 
#
#  The fact that you are presently reading this means that you have had
#  knowledge of the CeCILL-B license and that you accept its terms.
# ------------------------------------------------------------------------
*/

#include <creaImageIOSynchron.h>
#include <creaImageIOSystem.h>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>


//namespace fs = boost::filesystem;

//=====================================================================
 

namespace creaImageIO
{

    //=====================================================================
    #define QUERYSYNCDB(QUER,RES)                                       \
    try                                                                 \
    {                                                                   \
        RES = mDB->execQuery(QUER.c_str());                             \
    }                                                                   \
    catch (CppSQLite3Exception& e)                                      \
    {                                                                   \
      GimmickError("SQLite query '"<<QUER<<"' Error : "                 \
                   << e.errorCode() << ":"                              \
                   << e.errorMessage() );                               \
    }                                                                                                                                      
   //=====================================================================
    #define UPDATESYNCDB(UP)                                            \
    try                                                                 \
    {                                                                   \
      mDB->execDML(UP.c_str());                                         \
    }                                                                   \
    catch (CppSQLite3Exception& e)                                      \
    {                                                                   \
      GimmickError("SQLite update '"<<UP<<"' Error : "                  \
                   << e.errorCode() << ":"                              \
                   << e.errorMessage() );                               \
    }                           
   //=====================================================================

    Synchronizer::Synchronizer(const std::string& path)
    {
                pathDB = path + "maintenance_database.db3";
                mDB = new CppSQLite3DB;
                Initialize();
    }

   //=====================================================================
    Synchronizer::~Synchronizer()
    {
       delete mDB;
    }

        //=====================================================================
        void Synchronizer::Initialize()
        {    
                if (!boost::filesystem::exists(pathDB)) 
                {
                        CreateDB();
                }
    
                // OPENING
                else
                {
                try
                {
                mDB->open(pathDB.c_str());
                }
                catch (CppSQLite3Exception& e)
                {
                GimmickError("Opening '"<<pathDB<<"' : "
                     << e.errorCode() << ":" 
                     << e.errorMessage());
                }
                }
                // get the ADD operations List 
                //UpdateAddList(pathDB);
        }

   //=====================================================================
    void Synchronizer::CreateDB()
    {
                mDB->open(pathDB.c_str());
        // CREATING TABLES
        std::string command;
        command = "CREATE TABLE ";
        command += "ADD_OPS";
        command += "\n(\nADD_KEY INTEGER PRIMARY KEY";
        command += ",\nPATH text";
        command += ",\nRECURSIVE boolean";
        command += ",\nFILES_ADDED int";
        command += ",\nREFERENCEDDB text";
        command += "\n)";
        UPDATESYNCDB(command);

        command = "CREATE TABLE ";
        command += "IGNORED_FILES";
        command += "\n(\nID INTEGER PRIMARY KEY";
        command += ",\nADD_KEY integer";
        command += ",\nPATH text";
        command += ",\nREMOVE boolean";
        command += ",\nTIME datetext";
        command += "\n)";
        UPDATESYNCDB(command);
    }

        //=====================================================================
        void Synchronizer::CleanName(std::string& str) const
        {
                size_t pos;
                do
                {
                        pos = str.find('\\');
                        if (pos!=-1)  
                        {
                                str.replace(pos, 1, "/");
                        }
                }
                while (pos!=-1);
        }

        //=====================================================================
    void Synchronizer::GetFileList(std::vector<AddList> & list, const std::string& refdb)
    {
       CleanList(refdb);
       list=mAddList;
    }

        //=====================================================================
   void Synchronizer::GetIgnoredFiles(const std::string& key, std::vector<std::string> &ignoreList)
   {
        ignoreList=GetIgnoreList(key);
   }

//=====================================================================
    void Synchronizer::UpdateAddList(const std::string& refdb)
    {
        std::string query = "SELECT * FROM ADD_OPS WHERE REFERENCEDDB = '"+refdb+"';";
        CppSQLite3Query res;
        QUERYSYNCDB(query, res);
        while (!res.eof())
        {
            AddList temp = AddList(res);
            mAddList.push_back(temp);
            res.nextRow();
        }
    }

    // remove an entry of the DB
    //@param i_table : table where to do the remove
    // @param i_key : the add_key reference (one entry to remove for ADD_OP table, many for IGNORED_FILES table
    //@result : -
    void Synchronizer::RemoveEntry(const std::string i_table, const std::string i_key)
    {
        std::string query = "DELETE  FROM " + i_table + " WHERE ADD_KEY = '" + i_key +"'";
        UPDATESYNCDB(query);
    }

    // remove several entries of the DB
    // @param i_table : table where to do the remove
    // @param i_attribute: attribute to match
    // @param i_operand : operand to use
    // @param i_val : the reference
    //@result : -
    void Synchronizer::RemoveEntries(const std::string i_table, 
                const std::string i_attribute, 
                const std::string i_operand, 
                const std::string i_val)
    {
        std::stringstream query;
        query<<"DELETE  FROM "<<i_table<<" WHERE "<<i_attribute<<" "<<i_operand<<" '"<<i_val<<"'";
        UPDATESYNCDB(query.str());
        }

    // clean DataBase if an operation has no child anymore
        // @param refdb: the database segement to clean
    // @result : -
    void Synchronizer::CleanList(const std::string& refdb)
    {
        mAddList.clear();
        UpdateAddList(refdb);
        std::vector<AddList>::iterator it_add = mAddList.begin();
        for(;it_add <mAddList.end(); ++it_add)
        {
                if(it_add->nbFiles == "0")
                {
                        RemoveEntry("ADD_OPS", it_add->key);
                        RemoveEntry("IGNORED_FILES", it_add->key);

                }
        }
                mAddList.clear();
                UpdateAddList(refdb);
    }

    // Inserts a new add operation in the database
    // @param path: the path of the directory that was added
    // @param recursive: shows if the action was called recursively or not
    // @param nChildren: the number of files affected by the operation
    // @param refdb: the referenced database
    // @result : The operation has been added
        void Synchronizer::InsertAddOp(const std::string& path, const std::string& recursive, const std::string& nChildren, const std::string& refdb)
        {
                std::string insert;
                std::string pat=path.c_str();
                CleanName(pat);
                insert="INSERT INTO ADD_OPS (PATH,RECURSIVE,FILES_ADDED,REFERENCEDDB) VALUES('";
                insert+=convert(pat)+"','";
                insert+=recursive+"',";
                insert+=nChildren+",'";
                insert+=refdb+"');";
                UPDATESYNCDB(insert);
        }

    // Inserts a new ignored file in the database
        // @param add_key: the key of the add_op to which it corresponds
    // @param path: the path of the directory that was added
        // @param remove: shows if the file was removed or not
        // @param time: the time in which the file was removed
    // @result : The file has been inserted

        void Synchronizer::InsertIgnoreFile(const std::string& addKey, const std::string& path, const std::string& remove, const std::string& time, const std::string& refdb )
        {
                std::string pat=path.c_str();
                CleanName(pat);
                std::string id=GetAttribute("ID","IGNORED_FILES","PATH",pat,refdb);
                if(id.compare("")==0)
                {
                        std::string insert;
                        insert="INSERT INTO IGNORED_FILES (ADD_KEY,PATH,REMOVE,TIME) VALUES('";
                        insert+=addKey+"','";
                        insert+=convert(pat)+"','";
                        insert+=remove+"',";
                        insert+=time+");";
                        UPDATESYNCDB(insert);
                }
                else
                {
                        //Gets the add key
                        std::string ak=GetAttribute("ADD_KEY","IGNORED_FILES","ID",id,refdb);
                        //gets the parent database to check if the file has been added to the current database
                        std::string parentDB=GetAttribute("*","ADD_OPS","ADD_KEY",ak,refdb);
                        //If there is no such entry, add it
                        if(parentDB.compare("")==0)
                        {
                                std::string insert;
                                insert="INSERT INTO IGNORED_FILES (ADD_KEY,PATH,REMOVE,TIME) VALUES('";
                                insert+=addKey+"','";
                                insert+=convert(pat)+"','";
                                insert+=remove+"',";
                                insert+=time+");";
                                UPDATESYNCDB(insert);
                        }
                        else
                        {
                                //Sets the new add key attribute for the file
                                SetAttribute("ADD_KEY","IGNORED_FILES",addKey,"ID", id,refdb);
                                //Sets the new remove attribute for the file
                                SetAttribute("REMOVE","IGNORED_FILES",remove,"ID", id,refdb);
                                //Sets the new time attribute for the file
                                SetAttribute("TIME","IGNORED_FILES",time,"ID", id,refdb);
                        }
                }
        }

    // get the files name to ignore for a add operation synchronization
    // @param : the add key
    //@result : list (path) of ignore files
    std::vector<std::string> Synchronizer::GetIgnoreList(const std::string &i_key)
    {
        mIgnoreList.clear();
        std::vector<std::string> i_names;
        std::string query = "SELECT * FROM IGNORED_FILES WHERE ADD_KEY = ";
        query+=i_key;
        CppSQLite3Query res;
        QUERYSYNCDB(query, res);
        while (!res.eof())
        {
                RemoveList temp = RemoveList(res);
                if(temp.remove.compare("0")==0)
                {
                   mIgnoreList.push_back(temp);
                }
                res.nextRow();
        }
        std::vector<RemoveList>::iterator it;

        for(it = mIgnoreList.begin();it != mIgnoreList.end(); ++it)
        {
            i_names.push_back((*it).path);
        }
        return i_names;
    }

    // Gets the required attribute in the required table
    // @param attribute: the attribute to look for
    // @param table: the table to look in
    // @param searchParam: the search parameter
    // @param searchValue: the search value
    // @result : required attribute
    std::string Synchronizer::GetAttribute(const std::string& attribute, 
                                        const std::string& table, 
                                        const std::string& searchParam,
                                        const std::string& searchValue, 
                                        const std::string& refdb)
    {
        std::stringstream query;
        std::string result;
        std::string sVal=convert(searchValue.c_str());
        CleanName(sVal);
        query<<"SELECT "<<attribute<<" FROM "<<table<<" WHERE "<<searchParam<<" = '"<<sVal;
        if(table.compare("ADD_OPS")==0)
        {
                query<<"' AND REFERENCEDDB = '"<<refdb<<"';";
        }
        else
        {
                query<<"';";
        }
        CppSQLite3Query res;
        QUERYSYNCDB(query.str(), res);
        while (!res.eof())
        {
                result=res.getStringField(0);
                res.nextRow();
        }
        return result;
    }

    // Sets the attribute value in the required table and column
    // @param attribute: the attribute to look for
    // @param table: the table to look in
    // @param value: the value to set
    // @param searchParam: the search parameter
    // @param searchValue: the search value
    // @result : attribute value changed
    void Synchronizer::SetAttribute(const std::string& attribute, 
                                const std::string& table, 
                                const std::string& value,
                                const std::string& searchParam,
                                const std::string& searchValue,
                                const std::string& refdb)
    {
        std::string val=value.c_str();
        std::string sVal=convert(searchValue.c_str());
        CleanName(val);
        CleanName(sVal);
        std::string sql = "UPDATE ";
        sql+=table;
        sql+=" SET ";
        sql += attribute;
        sql += " = '";
        sql += val;
        sql += "' WHERE ";
        sql += searchParam;
        sql += " = '";
        sql += sVal;
        if(table.compare("ADD_OPS")==0)
        {
                sql += "' AND REFERENCEDDB = '";
                sql += refdb;
        }
        sql += "';";
        UPDATESYNCDB(sql);
    }



    // get the files name to ignore for a add operation synchronization
    // @param : the add key
    //@result : list (path) of ignore files
        void Synchronizer::GetList(const std::string i_db)
    {
                mList.clear();
        std::vector<std::string> i_names;
                std::vector<std::string> keys;
                CppSQLite3Query res;
                std::string query ="SELECT ADD_KEY, REFERENCEDDB FROM  ADD_OPS";
                QUERYSYNCDB(query, res);
                keys.clear();
                while (!res.eof())
        {
                        std::string key(res.getStringField(0));
                        std::string db(res.getStringField(1));
                        if (db == i_db)
                        {
                                keys.push_back(key);
                        }
                        res.nextRow();
                }
                query = "SELECT PATH, REMOVE FROM IGNORED_FILES WHERE";
                if(keys.size() > 0)
                {
                        for (int i=0; i < keys.size(); i++)
                        {
                                query += " ADD_KEY = " + keys[i];
                                query += " AND";
                        }
                        query = query.substr(0,query.size() - 4);
                }
                else 
                {
                        query += " ADD_KEY = -1";
                }
        QUERYSYNCDB(query, res);
                while (!res.eof())
        {
                std::string file(res.getStringField(0));
                std::string ignore(res.getStringField(1));
                mList[file] = ignore == "0"? true : false;
                res.nextRow();
        }
    }

        bool Synchronizer::isIndexed(const std::string filename)
        {
                bool valid = true;
                std::string name(filename);
                boost::algorithm::replace_all( name,"\\" , "/");
                std::map <std::string, bool>::iterator it_list = mList.begin();
                for(;it_list != mList.end(); it_list++)
                {
                        if(it_list->first == name)
                        {
                                valid = false;
                                break;
                        }
                }
                return valid;
        }
          const std::string Synchronizer::convert(const std::string &i_word)
          {
                  std::string temp = i_word;
                  boost::algorithm::replace_all(temp,"'","''");

          return temp.c_str();
  }
}