notepad_filestore.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_filestore.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * notepad is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include "config.h"
#include <sys/time.h>
#include <cstring>
#include <gtk/gtk.h>
#include <glib.h>
#include <glib/gstdio.h> // for rename and test
#include <libermetadb/ermetadb.h>

#include "log.h"
#include "notepad_ipc.h"
#include "notepad_utils.h"
#include "notepad_filestore.h"

#define NOTE_AUTHOR    "Notepad"
#define NOTE_DIR       "Notes"
#define NOTE_TAG       "note"
#define NOTE_EXTENSION ".note"

namespace notepad
{

    static const char*  SCRIBBLE_LAST_READ_LOCATION  = "scribble_last_read_location";

    CFileStore::CFileStore()
        :
            m_db(0),
            m_dbfilename(0)
    {
        LOGPRINTF("entry");
        LOGPRINTF("exit");
    }

    CFileStore::~CFileStore()
    {
        LOGPRINTF("entry");
        closeDatabase();
        LOGPRINTF("exit");
    }

    np_result CFileStore::openDatabase(const gchar* dir, const gchar* filename)
    {
        LOGPRINTF("entry");
        g_assert(m_db == 0 );
        g_return_val_if_fail((dir !=0) && (dir[0] != '\0'), NP_NO_FILENAME);
        g_return_val_if_fail((filename !=0) && (filename[0] != '\0'), NP_NO_FILENAME);

        erMetadb db = ermetadb_local_open_custom(dir, filename);
        if (db == 0)
        {
            LOGPRINTF("opening file failed");
            return NP_CREATE_FAILED;
        }
        m_db = db;

        LOGPRINTF("exit");
        return NP_OK;
    }

    void CFileStore::closeDatabase(void)
    {
        LOGPRINTF("entry");

        if (m_dbfilename) g_free(m_dbfilename);
        m_dbfilename = 0;

        if (m_db) 
        {
            ermetadb_close(m_db);
            m_db = 0;
        }

        LOGPRINTF("exit"); 
    }

    np_result CFileStore::createDatabase(const gchar* dir, const gchar* file, const char* title)
    {
        LOGPRINTF("entry");

        // precondition: there is no db file
        g_assert(m_db == 0);
        // input check
        g_return_val_if_fail((dir != 0) && (dir[0] != '\0'), NP_NO_FILENAME);
        g_return_val_if_fail((file != 0) && (file[0] != '\0'), NP_NO_FILENAME);
        g_return_val_if_fail((title != 0) && (title[0] != '\0'), NP_NO_FILENAME);

        if ( ! g_file_test(dir, G_FILE_TEST_EXISTS) )
        {
            LOGPRINTF("dir %s did not exist, created", dir);
            // try to create directory
            if (g_mkdir(dir, 0775) != 0)
            {
                WARNPRINTF("failed to create Notes directory.");
                return NP_IS_NOT_DIR;
            }
        }

        if ( ! g_file_test(dir, G_FILE_TEST_IS_DIR))
        {
            LOGPRINTF("%s is no directory", dir);
            return NP_IS_NOT_DIR;
        }

        // precondition: directory Notes should exist
        // create database
        int ret = ermetadb_local_create_database(dir, file);
        if (ret != ER_OK) {
            WARNPRINTF("ermetadb_new failed");
            return NP_CREATE_FAILED;
        }

        // add new file to global
        const char* mountpoint = ipc_get_mountpoint();
        erMetadb global_db = ermetadb_global_open(mountpoint, FALSE);
        if (global_db == 0) {
            WARNPRINTF("failed to open globaldb.");
            return NP_OPEN_FAILED;
        }

        // date and size attributes
        struct stat statbuf;
        gchar* fname = g_strdup_printf("%s/%s", dir, file); 
        stat(fname, &statbuf);
        gint64 size = statbuf.st_size;
        gint64 mtime = statbuf.st_mtime;
        LOGPRINTF("%s size %lld, mtime %lld", fname, size, mtime);
        g_free(fname);
 
        ret = ermetadb_global_add_file(global_db, dir, file, size, mtime, title, NOTE_AUTHOR, NOTE_TAG);
        if (ret != ER_OK) {
            WARNPRINTF("ermetadb_add_file failed");
        }

        ermetadb_close(global_db);

        LOGPRINTF("exit");
        return openDatabase(dir, file);
    }

    np_result    CFileStore::renameDatabase(const gchar* dir, const gchar* srcfile, const gchar* destfile)
    {
        LOGPRINTF("entry");
        
        g_assert(m_db != 0);
        // input check
        g_return_val_if_fail((dir != 0) && (dir[0] != '\0'), NP_NO_FILENAME);
        g_return_val_if_fail((srcfile != 0) && (srcfile[0] != '\0'), NP_NO_FILENAME);
        g_return_val_if_fail((destfile != 0) && (destfile[0] != '\0'), NP_NO_FILENAME);

        LOGPRINTF("dir %s srcfile %s destfile %s", dir, srcfile, destfile);

        if (0 == g_strcmp0(srcfile, destfile))
        {
            LOGPRINTF("same name, do nothing");
            return NP_OK;
        }

        // rename on filesystem
        gchar *dst = g_strdup_printf("%s/%s", dir, destfile);
        gchar *src = g_strdup_printf("%s/%s", dir, srcfile);
        int err = g_rename(src, dst);
        g_free(src);
        g_free(dst);
        if (err) {
            WARNPRINTF("rename failed.");
            return NP_RENAME_FAILED;
        }

        // rename in global database
        const char* mountpoint = ipc_get_mountpoint();
        erMetadb global_db = ermetadb_global_open(mountpoint, FALSE);
        if (global_db == 0) {
            WARNPRINTF("rename failed.");
            return NP_OPEN_FAILED;
        }
        gchar* title = noExt(destfile); 
        int ret = ermetadb_global_rename_file(global_db, dir, srcfile, destfile, title);
        //TODO call global_change_file to update date and size attributes
        g_free(title);
        ermetadb_close(global_db);
        if (ret != ER_OK) {
            WARNPRINTF("rename failed.");
            return NP_RENAME_FAILED;
        }

        LOGPRINTF("exit success");
        return NP_OK;
    }

    np_result    CFileStore::createFile(const gchar* filename)
    {
        LOGPRINTF("filename='%s'", filename ? filename : "NULL");

        g_assert(m_dbfilename == 0);
        g_assert(m_db == 0);

        // determine dir + filename
        gchar* dir = 0;
        gchar* file = 0;
        if (  (filename != 0) && (filename[0] != '\0'))
        {
            dir = g_path_get_dirname(filename);
            file = g_path_get_basename(filename);
        }
        else 
        {
            dir = g_strdup_printf("%s/%s", ipc_get_mountpoint(), NOTE_DIR); 
            file = generateNewFilename();
        }

        gchar* title = 0;
        gchar* iter = g_strrstr(file, NOTE_EXTENSION);
        if ( iter == 0 ) // no needle found in the haystack
        {
            title =  g_strdup(file);
        }
        else
        {
            title =  g_strndup(file, (iter - file));
        }

        np_result result = createDatabase(dir, file, title);
        if (result == NP_OK)
        {
            m_dbfilename = g_strdup_printf("%s/%s", dir, file); 
        }
        else
        {
            WARNPRINTF("failed to create");
        }

        g_free(dir);
        g_free(file);
        g_free(title);

        LOGPRINTF("exit");
        return result;
    }

    np_result    CFileStore::openFile(const gchar* filename)
    {
        LOGPRINTF("entry");

        g_assert( m_dbfilename == 0);
        g_assert( m_db == 0);

        // input check
        g_return_val_if_fail((filename != 0) && (filename[0] != '\0'), NP_NO_FILENAME);

        gchar* directory = g_path_get_dirname(filename);
        gchar* file = g_path_get_basename(filename);
        np_result result = openDatabase(directory, file);

        if ( result == NP_OK)
        {
            m_dbfilename = g_strdup(filename);
        }
        else
        {
            WARNPRINTF("failed to open");
        }

        g_free(directory);
        g_free(file);

        LOGPRINTF("exit");
        return result;
    }

    void    CFileStore::closeFile()
    {
        return closeDatabase();
    }

    np_result    CFileStore::renameFile(const gchar* newshortfilename)
    {
        LOGPRINTF("entry");
        np_result result = NP_OK;

        g_assert( m_dbfilename != 0);
        g_assert( m_db != 0);

        // input check
        g_return_val_if_fail((newshortfilename != 0) && (newshortfilename[0] != '\0'), NP_NO_FILENAME);

        // assemble filenames 
        gchar* dir = getFileNameDirPart();
        gchar* newfilename = 0;
        int len = strlen(newshortfilename) - strlen(NOTE_EXTENSION);
        if (0 == g_strcmp0(newshortfilename + len, NOTE_EXTENSION))
        {
            g_assert(len > 0);
            newfilename = g_strdup_printf("%s/%s", dir, newshortfilename); 
        }
        else
        {
            newfilename = g_strdup_printf("%s/%s%s", dir, newshortfilename, NOTE_EXTENSION); 
        }
        LOGPRINTF("oldfilename %s, newfilename %s", m_dbfilename, newfilename);

        // test if new == old;
        if (0 == g_strcmp0(m_dbfilename, newfilename))
        {
            LOGPRINTF("save as same filename");
            result = NP_OK;
        }
        else
        {
            // test if file already exists
            if (g_file_test(newfilename, G_FILE_TEST_EXISTS))
                result = NP_FILE_EXISTS;

            if (result != NP_FILE_EXISTS)
            {
                gchar* srcfile  = getFileNameFilePart();
                gchar* destfile = g_path_get_basename(newfilename);

                // create local db with filename
                result = renameDatabase(dir, srcfile, destfile); 
                if (result == NP_OK)
                {
                    // rename succeeded, store filename
                    g_free(m_dbfilename);
                    m_dbfilename = g_strdup(newfilename);
                }
                g_free(srcfile);
                g_free(destfile);
            }
        }

        g_free(dir);
        g_free(newfilename);

        LOGPRINTF("FUNCTION EXIT");
        return result; 
    }

    gchar* CFileStore::getFilename(void)
    {
        // CRASHES if run after constructor!!
        return m_dbfilename;
    }

    erMetadb CFileStore::getFile()
    {
        return m_db;
    }

    // caller takes ownership of gchar object
    gchar* CFileStore::generateNewFilename(void)
    {  
        // format: Note_2010-02-19__10-07-05.note 
        time_t rawtime;
        time(&rawtime);
        struct tm * tms;
        tms = localtime(&rawtime);

        gchar* fname = g_strdup_printf("Note_%d-%02d-%02d__%02d-%02d-%02d%s", 
                                       1900+tms->tm_year, 
                                       1+tms->tm_mon, 
                                       tms->tm_mday, 
                                       tms->tm_hour, 
                                       tms->tm_min, 
                                       tms->tm_sec, 
                                       NOTE_EXTENSION);
        return fname;
    }

    gchar* CFileStore::noExt(const gchar* filename)
    {
        g_assert(filename != 0);
        // filename has shape: '/path/...morepathelements.../basename.extension'
        gchar* basename = g_path_get_basename(filename);
        gchar* iter = g_strrstr(basename, NOTE_EXTENSION);
        if (iter == 0) // no needle found in the haystack
        {
            return basename ;
        }
        gchar* basename_noext = g_strndup(basename, (iter - basename));
        g_free(basename);
        return basename_noext;
    }

    // caller takes ownership -> so caller must g_free() when not needed anymore
    gchar* CFileStore::getFileNameDirPart(void)
    {
        g_assert( m_dbfilename != 0);
        return g_path_get_dirname(m_dbfilename);
    }

    // caller takes ownership -> so caller must g_free() when not needed anymore
    gchar* CFileStore::getFileNameFilePart(void)
    {
        g_assert( m_dbfilename != 0);
        return g_path_get_basename(m_dbfilename);
    }

    // caller takes ownership -> so caller must g_free() when not needed anymore
    gchar* CFileStore::getFileNameFilePartNoExt(void)
    {
        g_assert( m_dbfilename != 0);
        return noExt(m_dbfilename);
    }

    // ----- Added metadata table mangling to store and load the last read page in a scribble document

    /// Save key and value pair into application data table.
    gboolean CFileStore::save_string(const char *key, const gchar* value)
    {
        // Create table.
        metadata_table *value_table = metadata_table_new();
        if (value_table == 0)
        {
            return false;
        }

        // Set key.
        metadata_table_add_column(value_table, key);

        // Assign value.
        int ret = -1;
        int index = metadata_table_find_column(value_table, key);
        if (index >= 0)
        {
            ret = metadata_table_set_text(value_table, index, value);
            if (ret != ER_OK)
            {
                ERRORPRINTF("Cannot write value %s to table.", value);
            }
        }

        // TODO: we use "." for filename -- for we do not want to record the filemane into the db format.
        // If we did, then we would have to update the filename when the db is renamed.
        ret = ermetadb_local_set_application_data(m_db, ".", value_table);
        metadata_table_free(value_table);
        return static_cast<gboolean>(ret == ER_OK);
    }


    /// Load application data according to the key.
    gboolean CFileStore::load_string(const char *key, gchar** value)
    {
        LOGPRINTF("entry, key %s", key);
        // Create table.
        metadata_table *name_table = metadata_table_new();
        if (name_table == NULL)
        {
            return FALSE;
        }

        // Add column.
        metadata_table_add_column(name_table, key);

        // Query.
        metadata_table *results_table = NULL;
        int ret = ermetadb_local_get_application_data(m_db, ".", name_table, &results_table);

        // free the name table
        metadata_table_free(name_table);

        if (results_table == NULL)
        {
            LOGPRINTF("No result.");
            return FALSE;
        }
        if (ret != ER_OK)
        {
            ERRORPRINTF("Could not get application data.");
        }

        const metadata_cell *cell = NULL;
        int index = metadata_table_find_column(results_table, key);

        if (index >= 0)
        {   
            cell = metadata_table_get_cell(results_table, index);
            if (cell != 0) 
            {
                if (cell->type == METADATA_TEXT)
                {
                    *value = g_strdup(cell->value.v_text->str);
                }
                else
                {
                    ERRORPRINTF("wrong cell type"); // Note: Pair of metadata where value is text. Not in lib. 
                    ret = ER_NOT_FOUND;
                }
            }
            else
            {
                ERRORPRINTF("Cannot find cell");
                ret = ER_NOT_FOUND;
            }
        }
        else
        {
            ERRORPRINTF("Cannot find column");
            ret = ER_NOT_FOUND;
        }

        // free the results table
        metadata_table_free(results_table);
        return static_cast<gboolean>(ret == ER_OK);
    }

    /// Load last read location from meta database.
    gint CFileStore::get_last_read_location(void)
    {
        gchar* location = 0;
        gboolean result = load_string (SCRIBBLE_LAST_READ_LOCATION, &location);
        gint last_read = 0;
        if ( ! result )
        {
            last_read = -1;
        }
        else if (sscanf( location, "%d", &last_read ) < 0)
        {
            last_read = -1;
        }
        g_free(location);
        LOGPRINTF( "get_last_read_location -- last_read = %d", last_read);
        return last_read;
    }

    gboolean CFileStore::set_last_read_location(gint location)
    {
        LOGPRINTF( "set_last_read_location -- last_read = %d", location);
        gboolean result = FALSE;
        gchar* my_location = g_strdup_printf("%d", location);
        result = save_string( SCRIBBLE_LAST_READ_LOCATION, my_location);
        g_free(my_location);
        return result; 
    }

}