src/db/InstrumentsDbUtilities.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2007 - 2009 Grigor Iliev                                *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#include "InstrumentsDbUtilities.h"

#include "../common/File.h"
#include "../common/global_private.h"

#include <errno.h>

#include "../common/Exception.h"
#include "InstrumentsDb.h"

namespace LinuxSampler {

    void DbInstrument::Copy(const DbInstrument& Instr) {
        if (this == &Instr) return;

        InstrFile = Instr.InstrFile;
        InstrNr = Instr.InstrNr;
        FormatFamily = Instr.FormatFamily;
        FormatVersion = Instr.FormatVersion;
        Size = Instr.Size;
        Created = Instr.Created;
        Modified = Instr.Modified;
        Description = Instr.Description;
        IsDrum = Instr.IsDrum;
        Product = Instr.Product;
        Artists = Instr.Artists;
        Keywords = Instr.Keywords;
    }


    void DbDirectory::Copy(const DbDirectory& Dir) {
        if (this == &Dir) return;

        Created = Dir.Created;
        Modified = Dir.Modified;
        Description = Dir.Description;
    }

    SearchQuery::SearchQuery() {
        MinSize = -1;
        MaxSize = -1;
        InstrType = BOTH;
    }

    void SearchQuery::SetFormatFamilies(String s) {
        if (s.length() == 0) return;
        int i = 0;
        int j = s.find(',', 0);
        
        while (j != std::string::npos) {
            FormatFamilies.push_back(s.substr(i, j - i));
            i = j + 1;
            j = s.find(',', i);
        }
        
        if (i < s.length()) FormatFamilies.push_back(s.substr(i));
    }

    void SearchQuery::SetSize(String s) {
        String s2 = GetMin(s);
        if (s2.length() > 0) MinSize = atoll(s2.c_str());
        else MinSize = -1;
        
        s2 = GetMax(s);
        if (s2.length() > 0) MaxSize = atoll(s2.c_str());
        else MaxSize = -1;
    }

    void SearchQuery::SetCreated(String s) {
        CreatedAfter = GetMin(s);
        CreatedBefore = GetMax(s);
    }

    void SearchQuery::SetModified(String s) {
        ModifiedAfter = GetMin(s);
        ModifiedBefore = GetMax(s);
    }

    String SearchQuery::GetMin(String s) {
        if (s.length() < 3) return "";
        if (s.at(0) == '.' && s.at(1) == '.') return "";
        int i = s.find("..");
        if (i == std::string::npos) return "";
        return s.substr(0, i);
    }

    String SearchQuery::GetMax(String s) {
        if (s.length() < 3) return "";
        if (s.find("..", s.length() - 2) != std::string::npos) return "";
        int i = s.find("..");
        if (i == std::string::npos) return "";
        return s.substr(i + 2);
    }

    void ScanJob::Copy(const ScanJob& Job) {
        if (this == &Job) return;

        JobId = Job.JobId;
        FilesTotal = Job.FilesTotal;
        FilesScanned = Job.FilesScanned;
        Scanning = Job.Scanning;
        Status = Job.Status;
    }

    int JobList::AddJob(ScanJob Job) {
        if (Counter + 1 < Counter) Counter = 0;
        else Counter++;
        Job.JobId = Counter;
        Jobs.push_back(Job);
        if (Jobs.size() > 3) {
            std::vector<ScanJob>::iterator iter = Jobs.begin();
            Jobs.erase(iter);
        }
        return Job.JobId;
    }

    ScanJob& JobList::GetJobById(int JobId) {
        for (int i = 0; i < Jobs.size(); i++) {
            if (Jobs.at(i).JobId == JobId) return Jobs.at(i);
        }
        
        throw Exception("Invalid job ID: " + ToString(JobId));
    }
    
    bool AbstractFinder::IsRegex(String Pattern) {
        if(Pattern.find('?') != String::npos) return true;
        if(Pattern.find('*') != String::npos) return true;
        return false;
    }

    void AbstractFinder::AddSql(String Col, String Pattern, std::stringstream& Sql) {
        if (Pattern.length() == 0) return;

        if (IsRegex(Pattern)) {
#ifndef WIN32
            Sql << " AND " << Col << " regexp ?";
#else
            for (int i = 0; i < Pattern.length(); i++) {
                if (Pattern.at(i) == '?') Pattern.at(i) = '_';
                else if (Pattern.at(i) == '*') Pattern.at(i) = '%';
            }
            Sql << " AND " << Col << " LIKE ?";
#endif
            Params.push_back(Pattern);
            return;
        }

        String buf;
        std::vector<String> tokens;
        std::vector<String> tokens2;
        std::stringstream ss(Pattern);
        while (ss >> buf) tokens.push_back(buf);

        if (tokens.size() == 0) {
            Sql << " AND " << Col << " LIKE ?";
            Params.push_back("%" + Pattern + "%");
            return;
        }

        bool b = false;
        for (int i = 0; i < tokens.size(); i++) {
            Sql << (i == 0 ? " AND (" : "");

            for (int j = 0; j < tokens.at(i).length(); j++) {
                if (tokens.at(i).at(j) == '+') tokens.at(i).at(j) = ' ';
            }

            ss.clear();
            ss.str("");
            ss << tokens.at(i);

            tokens2.clear();
            while (ss >> buf) tokens2.push_back(buf);

            if (b && tokens2.size() > 0) Sql << " OR ";
            if (tokens2.size() > 1) Sql << "(";
            for (int j = 0; j < tokens2.size(); j++) {
                if (j != 0) Sql << " AND ";
                Sql << Col << " LIKE ?";
                Params.push_back("%" + tokens2.at(j) + "%");
                b = true;
            }
            if (tokens2.size() > 1) Sql << ")";
        }
        if (!b) Sql << "0)";
        else Sql << ")";
    }

    DirectoryFinder::DirectoryFinder(SearchQuery* pQuery) : pDirectories(new std::vector<String>) {
        pStmt = NULL;
        this->pQuery = pQuery;
        std::stringstream sql;
        sql << "SELECT dir_name from instr_dirs WHERE dir_id!=0 AND parent_dir_id=?";

        if (pQuery->CreatedAfter.length() != 0) {
            sql << " AND created > ?";
            Params.push_back(pQuery->CreatedAfter);
        }
        if (pQuery->CreatedBefore.length() != 0) {
            sql << " AND created < ?";
            Params.push_back(pQuery->CreatedBefore);
        }
        if (pQuery->ModifiedAfter.length() != 0) {
            sql << " AND modified > ?";
            Params.push_back(pQuery->ModifiedAfter);
        }
        if (pQuery->ModifiedBefore.length() != 0) {
            sql << " AND modified < ?";
            Params.push_back(pQuery->ModifiedBefore);
        }

        AddSql("dir_name", pQuery->Name, sql);
        AddSql("description", pQuery->Description, sql);
        SqlQuery = sql.str();

        InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();

        int res = sqlite3_prepare(idb->GetDb(), SqlQuery.c_str(), -1, &pStmt, NULL);
        if (res != SQLITE_OK) {
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }

        for(int i = 0; i < Params.size(); i++) {
            idb->BindTextParam(pStmt, i + 2, Params.at(i));
        }
    }
    
    DirectoryFinder::~DirectoryFinder() {
        if (pStmt != NULL) sqlite3_finalize(pStmt);
    }

    StringListPtr DirectoryFinder::GetDirectories() {
        return pDirectories;
    }
    
    void DirectoryFinder::ProcessDirectory(String Path, int DirId) {
        InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
        idb->BindIntParam(pStmt, 1, DirId);

        String s = Path;
        if(Path.compare("/") != 0) s += "/";
        int res = sqlite3_step(pStmt);
        while(res == SQLITE_ROW) {
            pDirectories->push_back(s + idb->toAbstractName(ToString(sqlite3_column_text(pStmt, 0))));
            res = sqlite3_step(pStmt);
        }
        
        if (res != SQLITE_DONE) {
            sqlite3_finalize(pStmt);
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }

        res = sqlite3_reset(pStmt);
        if (res != SQLITE_OK) {
            sqlite3_finalize(pStmt);
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }
    }

    InstrumentFinder::InstrumentFinder(SearchQuery* pQuery) : pInstruments(new std::vector<String>) {
        pStmt = NULL;
        this->pQuery = pQuery;
        std::stringstream sql;
        sql << "SELECT instr_name from instruments WHERE dir_id=?";

        if (pQuery->CreatedAfter.length() != 0) {
            sql << " AND created > ?";
            Params.push_back(pQuery->CreatedAfter);
        }
        if (pQuery->CreatedBefore.length() != 0) {
            sql << " AND created < ?";
            Params.push_back(pQuery->CreatedBefore);
        }
        if (pQuery->ModifiedAfter.length() != 0) {
            sql << " AND modified > ?";
            Params.push_back(pQuery->ModifiedAfter);
        }
        if (pQuery->ModifiedBefore.length() != 0) {
            sql << " AND modified < ?";
            Params.push_back(pQuery->ModifiedBefore);
        }
        if (pQuery->MinSize != -1) sql << " AND instr_size > " << pQuery->MinSize;
        if (pQuery->MaxSize != -1) sql << " AND instr_size < " << pQuery->MaxSize;

        if (pQuery->InstrType == SearchQuery::CHROMATIC) sql << " AND is_drum = 0";
        else if (pQuery->InstrType == SearchQuery::DRUM) sql << " AND is_drum != 0";

        if (pQuery->FormatFamilies.size() > 0) {
            sql << " AND (format_family=?";
            Params.push_back(pQuery->FormatFamilies.at(0));
            for (int i = 1; i < pQuery->FormatFamilies.size(); i++) {
                sql << "OR format_family=?";
                Params.push_back(pQuery->FormatFamilies.at(i));
            }
            sql << ")";
        }

        AddSql("instr_name", pQuery->Name, sql);
        AddSql("description", pQuery->Description, sql);
        AddSql("product", pQuery->Product, sql);
        AddSql("artists", pQuery->Artists, sql);
        AddSql("keywords", pQuery->Keywords, sql);
        SqlQuery = sql.str();

        InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();

        int res = sqlite3_prepare(idb->GetDb(), SqlQuery.c_str(), -1, &pStmt, NULL);
        if (res != SQLITE_OK) {
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }

        for(int i = 0; i < Params.size(); i++) {
            idb->BindTextParam(pStmt, i + 2, Params.at(i));
        }
    }
    
    InstrumentFinder::~InstrumentFinder() {
        if (pStmt != NULL) sqlite3_finalize(pStmt);
    }
    
    void InstrumentFinder::ProcessDirectory(String Path, int DirId) {
        InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
        idb->BindIntParam(pStmt, 1, DirId);

        String s = Path;
        if(Path.compare("/") != 0) s += "/";
        int res = sqlite3_step(pStmt);
        while(res == SQLITE_ROW) {
            pInstruments->push_back(s + idb->toAbstractName(ToString(sqlite3_column_text(pStmt, 0))));
            res = sqlite3_step(pStmt);
        }
        
        if (res != SQLITE_DONE) {
            sqlite3_finalize(pStmt);
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }

        res = sqlite3_reset(pStmt);
        if (res != SQLITE_OK) {
            sqlite3_finalize(pStmt);
            throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
        }
    }

    StringListPtr InstrumentFinder::GetInstruments() {
        return pInstruments;
    }

    void DirectoryCounter::ProcessDirectory(String Path, int DirId) {
        count += InstrumentsDb::GetInstrumentsDb()->GetDirectoryCount(DirId);
    }

    void InstrumentCounter::ProcessDirectory(String Path, int DirId) {
        count += InstrumentsDb::GetInstrumentsDb()->GetInstrumentCount(DirId);
    }

    DirectoryCopier::DirectoryCopier(String SrcParentDir, String DestDir) {
        this->SrcParentDir = SrcParentDir;
        this->DestDir = DestDir;

        if (DestDir.at(DestDir.length() - 1) != '/') {
            this->DestDir.append("/");
        }
        if (SrcParentDir.at(SrcParentDir.length() - 1) != '/') {
            this->SrcParentDir.append("/");
        }
    }

    void DirectoryCopier::ProcessDirectory(String Path, int DirId) {
        InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();

        String dir = DestDir;
        String subdir = Path;
        if(subdir.length() > SrcParentDir.length()) {
            subdir = subdir.substr(SrcParentDir.length());
            dir += subdir;
            db->AddDirectory(dir);
        }

        int dstDirId = db->GetDirectoryId(dir);
        if(dstDirId == -1) {
            throw Exception("Unkown DB directory: " + InstrumentsDb::toEscapedPath(dir));
        }
        IntListPtr ids = db->GetInstrumentIDs(DirId);
        for (int i = 0; i < ids->size(); i++) {
            String name = db->GetInstrumentName(ids->at(i));
            db->CopyInstrument(ids->at(i), name, dstDirId, dir);
        }
    }

    ScanProgress::ScanProgress() {
        TotalFileCount = ScannedFileCount = Status = 0;
        CurrentFile = "";
        GigFileProgress.custom = this;
        GigFileProgress.callback = GigFileProgressCallback;
    }

    void ScanProgress::StatusChanged() {
        InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
        db->Jobs.GetJobById(JobId).FilesTotal = GetTotalFileCount();
        db->Jobs.GetJobById(JobId).FilesScanned = GetScannedFileCount();
        db->Jobs.GetJobById(JobId).Scanning = CurrentFile;
        db->Jobs.GetJobById(JobId).Status = GetStatus();
        
        InstrumentsDb::GetInstrumentsDb()->FireJobStatusChanged(JobId);
    }

    int ScanProgress::GetTotalFileCount() {
        return TotalFileCount;
    }

    void ScanProgress::SetTotalFileCount(int Count) {
        if (TotalFileCount == Count) return;
        TotalFileCount = Count;
        StatusChanged();
    }

    int ScanProgress::GetScannedFileCount() {
        return ScannedFileCount;
    }

    void ScanProgress::SetScannedFileCount(int Count) {
        if (ScannedFileCount == Count) return;
        ScannedFileCount = Count;
        if (Count > TotalFileCount) TotalFileCount = Count;
        StatusChanged();
    }

    int ScanProgress::GetStatus() {
        return Status;
    }

    void ScanProgress::SetStatus(int Status) {
        if (this->Status == Status) return;
        if (Status < 0) this->Status = 0;
        else if (Status > 100) this->Status = 100;
        else this->Status = Status;
        StatusChanged();
    }

    void ScanProgress::SetErrorStatus(int Err) {
        if (Err > 0) Err *= -1;
        Status = Err;
        StatusChanged();
    }

    void ScanProgress::GigFileProgressCallback(gig::progress_t* pProgress) {
        if (pProgress == NULL) return;
        ScanProgress* sp = static_cast<ScanProgress*> (pProgress->custom);
        
        sp->SetStatus((int)(pProgress->factor * 100));
    }

    AddInstrumentsJob::AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir, bool insDir) {
        this->JobId = JobId;
        Progress.JobId = JobId;
        this->Mode = Mode;
        this->DbDir = DbDir;
        this->FsDir = FsDir;
                this->insDir = insDir;
    }

    void AddInstrumentsJob::Run() {
        try {
            InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();

            switch (Mode) {
                case NON_RECURSIVE:
                    Progress.SetTotalFileCount(GetFileCount());
                    db->AddInstrumentsNonrecursive(DbDir, FsDir, insDir, &Progress);
                    break;
                case RECURSIVE:
                    db->AddInstrumentsRecursive(DbDir, FsDir, false, insDir, &Progress);
                    break;
                case FLAT:
                    db->AddInstrumentsRecursive(DbDir, FsDir, true, insDir, &Progress);
                    break;
                default:
                    throw Exception("Unknown scan mode");
            }

            // Just to be sure that the frontends will be notified about the job completion
            if (Progress.GetTotalFileCount() != Progress.GetScannedFileCount()) {
                Progress.SetTotalFileCount(Progress.GetScannedFileCount());
            }
            if (Progress.GetStatus() != 100) Progress.SetStatus(100);
        } catch(Exception e) {
            Progress.SetErrorStatus(-1);
            throw e;
        }
    }

    int AddInstrumentsJob::GetFileCount() {
        int count = 0;

        try {
            FileListPtr fileList = File::GetFiles(FsDir);

            for (int i = 0; i < fileList->size(); i++) {
                String s = fileList->at(i);
                if (s.length() < 4) continue;
                if(!strcasecmp(".gig", s.substr(s.length() - 4).c_str())) count++;
            }
        } catch(Exception e) {
            e.PrintMessage();
            return 0;
        }
        
        return count;
    }

    AddInstrumentsFromFileJob::AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index, bool insDir) {
        this->JobId = JobId;
        Progress.JobId = JobId;
        Progress.SetTotalFileCount(1);

        this->DbDir = DbDir;
        this->FilePath = FilePath;
        this->Index = Index;
                this->insDir = insDir;
    }

    void AddInstrumentsFromFileJob::Run() {
        try {
            InstrumentsDb::GetInstrumentsDb()->AddInstruments(DbDir, insDir, FilePath, Index, &Progress);

            // Just to be sure that the frontends will be notified about the job completion
            if (Progress.GetTotalFileCount() != Progress.GetScannedFileCount()) {
                Progress.SetTotalFileCount(Progress.GetScannedFileCount());
            }
            if (Progress.GetStatus() != 100) Progress.SetStatus(100);
        } catch(Exception e) {
            Progress.SetErrorStatus(-1);
            throw e;
        }
    }


    void DirectoryScanner::Scan(String DbDir, String FsDir, bool Flat, bool insDir, ScanProgress* pProgress) {
        dmsg(2,("DirectoryScanner: Scan(DbDir=%s,FsDir=%s,Flat=%d,insDir=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat, insDir));
        if (DbDir.empty() || FsDir.empty()) throw Exception("Directory expected");
        
        this->DbDir = DbDir;
        this->FsDir = FsDir;
        this->insDir = insDir;
        if (DbDir.at(DbDir.length() - 1) != '/') {
            this->DbDir.append("/");
        }
        if (FsDir.at(FsDir.length() - 1) != File::DirSeparator) {
            this->FsDir.push_back(File::DirSeparator);
        }
        this->Flat = Flat;
        this->pProgress = pProgress;
        
        File::WalkDirectoryTree(FsDir, this);
    }

    void DirectoryScanner::DirectoryEntry(std::string Path) {
        dmsg(2,("DirectoryScanner: DirectoryEntry(Path=%s)\n", Path.c_str()));

        String dir = DbDir;
        if (!Flat) {
            String subdir = Path;
            if(subdir.length() > FsDir.length()) {
                subdir = subdir.substr(FsDir.length());
                dir += subdir;
            }
        }
        
        InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();

        if (HasInstrumentFiles(Path)) {
            if (!db->DirectoryExist(dir)) db->AddDirectory(dir);
            db->AddInstrumentsNonrecursive(dir, Path, insDir, pProgress);
        }
    };

    bool DirectoryScanner::HasInstrumentFiles(String Dir) {
        InstrumentFileCounter c;
        return c.Count(Dir) > 0;
    }

    int InstrumentFileCounter::Count(String FsDir) {
        dmsg(2,("InstrumentFileCounter: Count(FsDir=%s)\n", FsDir.c_str()));
        if (FsDir.empty()) throw Exception("Directory expected");
        FileCount = 0;

        File::WalkDirectoryTree(FsDir, this);
        return FileCount;
    }

    void InstrumentFileCounter::FileEntry(std::string Path) {
        dmsg(2,("InstrumentFileCounter: FileEntry(Path=%s)\n", Path.c_str()));
        if(Path.length() < 4) return;
        if(!strcasecmp(".gig", Path.substr(Path.length() - 4).c_str())) FileCount++;
    };

} // namespace LinuxSampler
1	iliev	1200	/***************************************************************************
2			* *
3	persson	1908	* Copyright (C) 2007 - 2009 Grigor Iliev *
4	iliev	1200	* *
5			* This program is free software; you can redistribute it and/or modify *
6			* it under the terms of the GNU General Public License as published by *
7			* the Free Software Foundation; either version 2 of the License, or *
8			* (at your option) any later version. *
9			* *
10			* This program is distributed in the hope that it will be useful, *
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13			* GNU General Public License for more details. *
14			* *
15			* You should have received a copy of the GNU General Public License *
16			* along with this program; if not, write to the Free Software *
17			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
18			* MA 02110-1301 USA *
19			***************************************************************************/
20
21			#include "InstrumentsDbUtilities.h"
22
23	iliev	1717	#include "../common/File.h"
24	schoenebeck	1424	#include "../common/global_private.h"
25	iliev	1200
26			#include <errno.h>
27
28			#include "../common/Exception.h"
29			#include "InstrumentsDb.h"
30
31			namespace LinuxSampler {
32
33			void DbInstrument::Copy(const DbInstrument& Instr) {
34			if (this == &Instr) return;
35
36			InstrFile = Instr.InstrFile;
37			InstrNr = Instr.InstrNr;
38			FormatFamily = Instr.FormatFamily;
39			FormatVersion = Instr.FormatVersion;
40			Size = Instr.Size;
41			Created = Instr.Created;
42			Modified = Instr.Modified;
43			Description = Instr.Description;
44			IsDrum = Instr.IsDrum;
45			Product = Instr.Product;
46			Artists = Instr.Artists;
47			Keywords = Instr.Keywords;
48			}
49
50
51			void DbDirectory::Copy(const DbDirectory& Dir) {
52			if (this == &Dir) return;
53
54			Created = Dir.Created;
55			Modified = Dir.Modified;
56			Description = Dir.Description;
57			}
58
59			SearchQuery::SearchQuery() {
60			MinSize = -1;
61			MaxSize = -1;
62			InstrType = BOTH;
63			}
64
65			void SearchQuery::SetFormatFamilies(String s) {
66			if (s.length() == 0) return;
67			int i = 0;
68			int j = s.find(',', 0);
69
70			while (j != std::string::npos) {
71			FormatFamilies.push_back(s.substr(i, j - i));
72			i = j + 1;
73			j = s.find(',', i);
74			}
75
76			if (i < s.length()) FormatFamilies.push_back(s.substr(i));
77			}
78
79			void SearchQuery::SetSize(String s) {
80			String s2 = GetMin(s);
81			if (s2.length() > 0) MinSize = atoll(s2.c_str());
82			else MinSize = -1;
83
84			s2 = GetMax(s);
85			if (s2.length() > 0) MaxSize = atoll(s2.c_str());
86			else MaxSize = -1;
87			}
88
89			void SearchQuery::SetCreated(String s) {
90			CreatedAfter = GetMin(s);
91			CreatedBefore = GetMax(s);
92			}
93
94			void SearchQuery::SetModified(String s) {
95			ModifiedAfter = GetMin(s);
96			ModifiedBefore = GetMax(s);
97			}
98
99			String SearchQuery::GetMin(String s) {
100			if (s.length() < 3) return "";
101			if (s.at(0) == '.' && s.at(1) == '.') return "";
102			int i = s.find("..");
103			if (i == std::string::npos) return "";
104			return s.substr(0, i);
105			}
106
107			String SearchQuery::GetMax(String s) {
108			if (s.length() < 3) return "";
109			if (s.find("..", s.length() - 2) != std::string::npos) return "";
110			int i = s.find("..");
111			if (i == std::string::npos) return "";
112			return s.substr(i + 2);
113			}
114
115			void ScanJob::Copy(const ScanJob& Job) {
116			if (this == &Job) return;
117
118			JobId = Job.JobId;
119			FilesTotal = Job.FilesTotal;
120			FilesScanned = Job.FilesScanned;
121			Scanning = Job.Scanning;
122			Status = Job.Status;
123			}
124
125			int JobList::AddJob(ScanJob Job) {
126			if (Counter + 1 < Counter) Counter = 0;
127			else Counter++;
128			Job.JobId = Counter;
129			Jobs.push_back(Job);
130			if (Jobs.size() > 3) {
131			std::vector<ScanJob>::iterator iter = Jobs.begin();
132			Jobs.erase(iter);
133			}
134			return Job.JobId;
135			}
136
137			ScanJob& JobList::GetJobById(int JobId) {
138			for (int i = 0; i < Jobs.size(); i++) {
139			if (Jobs.at(i).JobId == JobId) return Jobs.at(i);
140			}
141
142			throw Exception("Invalid job ID: " + ToString(JobId));
143			}
144
145			bool AbstractFinder::IsRegex(String Pattern) {
146			if(Pattern.find('?') != String::npos) return true;
147			if(Pattern.find('*') != String::npos) return true;
148			return false;
149			}
150
151			void AbstractFinder::AddSql(String Col, String Pattern, std::stringstream& Sql) {
152			if (Pattern.length() == 0) return;
153
154			if (IsRegex(Pattern)) {
155	persson	1908	#ifndef WIN32
156	iliev	1200	Sql << " AND " << Col << " regexp ?";
157	persson	1908	#else
158			for (int i = 0; i < Pattern.length(); i++) {
159			if (Pattern.at(i) == '?') Pattern.at(i) = '_';
160			else if (Pattern.at(i) == '*') Pattern.at(i) = '%';
161			}
162			Sql << " AND " << Col << " LIKE ?";
163			#endif
164	iliev	1200	Params.push_back(Pattern);
165			return;
166			}
167
168			String buf;
169			std::vector<String> tokens;
170			std::vector<String> tokens2;
171			std::stringstream ss(Pattern);
172			while (ss >> buf) tokens.push_back(buf);
173
174			if (tokens.size() == 0) {
175			Sql << " AND " << Col << " LIKE ?";
176			Params.push_back("%" + Pattern + "%");
177			return;
178			}
179
180			bool b = false;
181			for (int i = 0; i < tokens.size(); i++) {
182			Sql << (i == 0 ? " AND (" : "");
183
184			for (int j = 0; j < tokens.at(i).length(); j++) {
185			if (tokens.at(i).at(j) == '+') tokens.at(i).at(j) = ' ';
186			}
187
188			ss.clear();
189			ss.str("");
190			ss << tokens.at(i);
191
192			tokens2.clear();
193			while (ss >> buf) tokens2.push_back(buf);
194
195			if (b && tokens2.size() > 0) Sql << " OR ";
196			if (tokens2.size() > 1) Sql << "(";
197			for (int j = 0; j < tokens2.size(); j++) {
198			if (j != 0) Sql << " AND ";
199			Sql << Col << " LIKE ?";
200			Params.push_back("%" + tokens2.at(j) + "%");
201			b = true;
202			}
203			if (tokens2.size() > 1) Sql << ")";
204			}
205			if (!b) Sql << "0)";
206			else Sql << ")";
207			}
208
209			DirectoryFinder::DirectoryFinder(SearchQuery* pQuery) : pDirectories(new std::vector<String>) {
210			pStmt = NULL;
211			this->pQuery = pQuery;
212			std::stringstream sql;
213			sql << "SELECT dir_name from instr_dirs WHERE dir_id!=0 AND parent_dir_id=?";
214
215			if (pQuery->CreatedAfter.length() != 0) {
216			sql << " AND created > ?";
217			Params.push_back(pQuery->CreatedAfter);
218			}
219			if (pQuery->CreatedBefore.length() != 0) {
220			sql << " AND created < ?";
221			Params.push_back(pQuery->CreatedBefore);
222			}
223			if (pQuery->ModifiedAfter.length() != 0) {
224			sql << " AND modified > ?";
225			Params.push_back(pQuery->ModifiedAfter);
226			}
227			if (pQuery->ModifiedBefore.length() != 0) {
228			sql << " AND modified < ?";
229			Params.push_back(pQuery->ModifiedBefore);
230			}
231
232			AddSql("dir_name", pQuery->Name, sql);
233			AddSql("description", pQuery->Description, sql);
234			SqlQuery = sql.str();
235
236			InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
237
238			int res = sqlite3_prepare(idb->GetDb(), SqlQuery.c_str(), -1, &pStmt, NULL);
239			if (res != SQLITE_OK) {
240			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
241			}
242
243			for(int i = 0; i < Params.size(); i++) {
244			idb->BindTextParam(pStmt, i + 2, Params.at(i));
245			}
246			}
247
248			DirectoryFinder::~DirectoryFinder() {
249			if (pStmt != NULL) sqlite3_finalize(pStmt);
250			}
251
252			StringListPtr DirectoryFinder::GetDirectories() {
253			return pDirectories;
254			}
255
256			void DirectoryFinder::ProcessDirectory(String Path, int DirId) {
257			InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
258			idb->BindIntParam(pStmt, 1, DirId);
259
260			String s = Path;
261			if(Path.compare("/") != 0) s += "/";
262			int res = sqlite3_step(pStmt);
263			while(res == SQLITE_ROW) {
264	iliev	1345	pDirectories->push_back(s + idb->toAbstractName(ToString(sqlite3_column_text(pStmt, 0))));
265	iliev	1200	res = sqlite3_step(pStmt);
266			}
267
268			if (res != SQLITE_DONE) {
269			sqlite3_finalize(pStmt);
270			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
271			}
272
273			res = sqlite3_reset(pStmt);
274			if (res != SQLITE_OK) {
275			sqlite3_finalize(pStmt);
276			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
277			}
278			}
279
280			InstrumentFinder::InstrumentFinder(SearchQuery* pQuery) : pInstruments(new std::vector<String>) {
281			pStmt = NULL;
282			this->pQuery = pQuery;
283			std::stringstream sql;
284			sql << "SELECT instr_name from instruments WHERE dir_id=?";
285
286			if (pQuery->CreatedAfter.length() != 0) {
287			sql << " AND created > ?";
288			Params.push_back(pQuery->CreatedAfter);
289			}
290			if (pQuery->CreatedBefore.length() != 0) {
291			sql << " AND created < ?";
292			Params.push_back(pQuery->CreatedBefore);
293			}
294			if (pQuery->ModifiedAfter.length() != 0) {
295			sql << " AND modified > ?";
296			Params.push_back(pQuery->ModifiedAfter);
297			}
298			if (pQuery->ModifiedBefore.length() != 0) {
299			sql << " AND modified < ?";
300			Params.push_back(pQuery->ModifiedBefore);
301			}
302			if (pQuery->MinSize != -1) sql << " AND instr_size > " << pQuery->MinSize;
303			if (pQuery->MaxSize != -1) sql << " AND instr_size < " << pQuery->MaxSize;
304
305			if (pQuery->InstrType == SearchQuery::CHROMATIC) sql << " AND is_drum = 0";
306			else if (pQuery->InstrType == SearchQuery::DRUM) sql << " AND is_drum != 0";
307
308			if (pQuery->FormatFamilies.size() > 0) {
309			sql << " AND (format_family=?";
310			Params.push_back(pQuery->FormatFamilies.at(0));
311			for (int i = 1; i < pQuery->FormatFamilies.size(); i++) {
312			sql << "OR format_family=?";
313			Params.push_back(pQuery->FormatFamilies.at(i));
314			}
315			sql << ")";
316			}
317
318			AddSql("instr_name", pQuery->Name, sql);
319			AddSql("description", pQuery->Description, sql);
320			AddSql("product", pQuery->Product, sql);
321			AddSql("artists", pQuery->Artists, sql);
322			AddSql("keywords", pQuery->Keywords, sql);
323			SqlQuery = sql.str();
324
325			InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
326
327			int res = sqlite3_prepare(idb->GetDb(), SqlQuery.c_str(), -1, &pStmt, NULL);
328			if (res != SQLITE_OK) {
329			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
330			}
331
332			for(int i = 0; i < Params.size(); i++) {
333			idb->BindTextParam(pStmt, i + 2, Params.at(i));
334			}
335			}
336
337			InstrumentFinder::~InstrumentFinder() {
338			if (pStmt != NULL) sqlite3_finalize(pStmt);
339			}
340
341			void InstrumentFinder::ProcessDirectory(String Path, int DirId) {
342			InstrumentsDb* idb = InstrumentsDb::GetInstrumentsDb();
343			idb->BindIntParam(pStmt, 1, DirId);
344
345			String s = Path;
346			if(Path.compare("/") != 0) s += "/";
347			int res = sqlite3_step(pStmt);
348			while(res == SQLITE_ROW) {
349	iliev	1345	pInstruments->push_back(s + idb->toAbstractName(ToString(sqlite3_column_text(pStmt, 0))));
350	iliev	1200	res = sqlite3_step(pStmt);
351			}
352
353			if (res != SQLITE_DONE) {
354			sqlite3_finalize(pStmt);
355			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
356			}
357
358			res = sqlite3_reset(pStmt);
359			if (res != SQLITE_OK) {
360			sqlite3_finalize(pStmt);
361			throw Exception("DB error: " + ToString(sqlite3_errmsg(idb->GetDb())));
362			}
363			}
364
365			StringListPtr InstrumentFinder::GetInstruments() {
366			return pInstruments;
367			}
368
369			void DirectoryCounter::ProcessDirectory(String Path, int DirId) {
370			count += InstrumentsDb::GetInstrumentsDb()->GetDirectoryCount(DirId);
371			}
372
373			void InstrumentCounter::ProcessDirectory(String Path, int DirId) {
374			count += InstrumentsDb::GetInstrumentsDb()->GetInstrumentCount(DirId);
375			}
376
377			DirectoryCopier::DirectoryCopier(String SrcParentDir, String DestDir) {
378			this->SrcParentDir = SrcParentDir;
379			this->DestDir = DestDir;
380
381			if (DestDir.at(DestDir.length() - 1) != '/') {
382			this->DestDir.append("/");
383			}
384			if (SrcParentDir.at(SrcParentDir.length() - 1) != '/') {
385			this->SrcParentDir.append("/");
386			}
387			}
388
389			void DirectoryCopier::ProcessDirectory(String Path, int DirId) {
390			InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
391
392			String dir = DestDir;
393			String subdir = Path;
394			if(subdir.length() > SrcParentDir.length()) {
395			subdir = subdir.substr(SrcParentDir.length());
396			dir += subdir;
397			db->AddDirectory(dir);
398			}
399
400			int dstDirId = db->GetDirectoryId(dir);
401	iliev	1345	if(dstDirId == -1) {
402			throw Exception("Unkown DB directory: " + InstrumentsDb::toEscapedPath(dir));
403			}
404	iliev	1200	IntListPtr ids = db->GetInstrumentIDs(DirId);
405			for (int i = 0; i < ids->size(); i++) {
406			String name = db->GetInstrumentName(ids->at(i));
407			db->CopyInstrument(ids->at(i), name, dstDirId, dir);
408			}
409			}
410
411			ScanProgress::ScanProgress() {
412			TotalFileCount = ScannedFileCount = Status = 0;
413			CurrentFile = "";
414			GigFileProgress.custom = this;
415			GigFileProgress.callback = GigFileProgressCallback;
416			}
417
418			void ScanProgress::StatusChanged() {
419			InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
420			db->Jobs.GetJobById(JobId).FilesTotal = GetTotalFileCount();
421			db->Jobs.GetJobById(JobId).FilesScanned = GetScannedFileCount();
422			db->Jobs.GetJobById(JobId).Scanning = CurrentFile;
423			db->Jobs.GetJobById(JobId).Status = GetStatus();
424
425			InstrumentsDb::GetInstrumentsDb()->FireJobStatusChanged(JobId);
426			}
427
428			int ScanProgress::GetTotalFileCount() {
429			return TotalFileCount;
430			}
431
432			void ScanProgress::SetTotalFileCount(int Count) {
433			if (TotalFileCount == Count) return;
434			TotalFileCount = Count;
435			StatusChanged();
436			}
437
438			int ScanProgress::GetScannedFileCount() {
439			return ScannedFileCount;
440			}
441
442			void ScanProgress::SetScannedFileCount(int Count) {
443			if (ScannedFileCount == Count) return;
444			ScannedFileCount = Count;
445			if (Count > TotalFileCount) TotalFileCount = Count;
446			StatusChanged();
447			}
448
449			int ScanProgress::GetStatus() {
450			return Status;
451			}
452
453			void ScanProgress::SetStatus(int Status) {
454			if (this->Status == Status) return;
455			if (Status < 0) this->Status = 0;
456			else if (Status > 100) this->Status = 100;
457			else this->Status = Status;
458			StatusChanged();
459			}
460
461			void ScanProgress::SetErrorStatus(int Err) {
462			if (Err > 0) Err *= -1;
463			Status = Err;
464			StatusChanged();
465			}
466
467			void ScanProgress::GigFileProgressCallback(gig::progress_t* pProgress) {
468			if (pProgress == NULL) return;
469			ScanProgress* sp = static_cast<ScanProgress*> (pProgress->custom);
470
471			sp->SetStatus((int)(pProgress->factor * 100));
472			}
473
474	iliev	1781	AddInstrumentsJob::AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir, bool insDir) {
475	iliev	1200	this->JobId = JobId;
476			Progress.JobId = JobId;
477			this->Mode = Mode;
478			this->DbDir = DbDir;
479			this->FsDir = FsDir;
480	iliev	1781	this->insDir = insDir;
481	iliev	1200	}
482
483			void AddInstrumentsJob::Run() {
484			try {
485			InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
486
487			switch (Mode) {
488			case NON_RECURSIVE:
489			Progress.SetTotalFileCount(GetFileCount());
490	iliev	1781	db->AddInstrumentsNonrecursive(DbDir, FsDir, insDir, &Progress);
491	iliev	1200	break;
492			case RECURSIVE:
493	iliev	1781	db->AddInstrumentsRecursive(DbDir, FsDir, false, insDir, &Progress);
494	iliev	1200	break;
495			case FLAT:
496	iliev	1781	db->AddInstrumentsRecursive(DbDir, FsDir, true, insDir, &Progress);
497	iliev	1200	break;
498			default:
499			throw Exception("Unknown scan mode");
500			}
501	iliev	1208
502			// Just to be sure that the frontends will be notified about the job completion
503			if (Progress.GetTotalFileCount() != Progress.GetScannedFileCount()) {
504			Progress.SetTotalFileCount(Progress.GetScannedFileCount());
505			}
506			if (Progress.GetStatus() != 100) Progress.SetStatus(100);
507	iliev	1200	} catch(Exception e) {
508			Progress.SetErrorStatus(-1);
509			throw e;
510			}
511			}
512
513			int AddInstrumentsJob::GetFileCount() {
514			int count = 0;
515
516	iliev	1717	try {
517			FileListPtr fileList = File::GetFiles(FsDir);
518	iliev	1200
519	iliev	1717	for (int i = 0; i < fileList->size(); i++) {
520			String s = fileList->at(i);
521			if (s.length() < 4) continue;
522			if(!strcasecmp(".gig", s.substr(s.length() - 4).c_str())) count++;
523	iliev	1200	}
524	iliev	1717	} catch(Exception e) {
525			e.PrintMessage();
526			return 0;
527	iliev	1200	}
528
529			return count;
530			}
531
532	iliev	1781	AddInstrumentsFromFileJob::AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index, bool insDir) {
533	iliev	1200	this->JobId = JobId;
534			Progress.JobId = JobId;
535			Progress.SetTotalFileCount(1);
536
537			this->DbDir = DbDir;
538			this->FilePath = FilePath;
539			this->Index = Index;
540	iliev	1781	this->insDir = insDir;
541	iliev	1200	}
542
543			void AddInstrumentsFromFileJob::Run() {
544	iliev	1208	try {
545	iliev	1781	InstrumentsDb::GetInstrumentsDb()->AddInstruments(DbDir, insDir, FilePath, Index, &Progress);
546	iliev	1208
547			// Just to be sure that the frontends will be notified about the job completion
548			if (Progress.GetTotalFileCount() != Progress.GetScannedFileCount()) {
549			Progress.SetTotalFileCount(Progress.GetScannedFileCount());
550			}
551			if (Progress.GetStatus() != 100) Progress.SetStatus(100);
552			} catch(Exception e) {
553			Progress.SetErrorStatus(-1);
554			throw e;
555			}
556	iliev	1200	}
557
558
559	iliev	1781	void DirectoryScanner::Scan(String DbDir, String FsDir, bool Flat, bool insDir, ScanProgress* pProgress) {
560			dmsg(2,("DirectoryScanner: Scan(DbDir=%s,FsDir=%s,Flat=%d,insDir=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat, insDir));
561	iliev	1200	if (DbDir.empty() \|\| FsDir.empty()) throw Exception("Directory expected");
562
563	iliev	1717	this->DbDir = DbDir;
564			this->FsDir = FsDir;
565	iliev	1781	this->insDir = insDir;
566	iliev	1200	if (DbDir.at(DbDir.length() - 1) != '/') {
567	iliev	1717	this->DbDir.append("/");
568	iliev	1200	}
569	iliev	1717	if (FsDir.at(FsDir.length() - 1) != File::DirSeparator) {
570			this->FsDir.push_back(File::DirSeparator);
571	iliev	1200	}
572	iliev	1717	this->Flat = Flat;
573			this->pProgress = pProgress;
574	iliev	1200
575	iliev	1717	File::WalkDirectoryTree(FsDir, this);
576	iliev	1200	}
577
578	iliev	1717	void DirectoryScanner::DirectoryEntry(std::string Path) {
579			dmsg(2,("DirectoryScanner: DirectoryEntry(Path=%s)\n", Path.c_str()));
580	iliev	1200
581			String dir = DbDir;
582			if (!Flat) {
583	iliev	1717	String subdir = Path;
584	iliev	1200	if(subdir.length() > FsDir.length()) {
585			subdir = subdir.substr(FsDir.length());
586			dir += subdir;
587			}
588			}
589
590			InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
591
592	iliev	1717	if (HasInstrumentFiles(Path)) {
593	iliev	1208	if (!db->DirectoryExist(dir)) db->AddDirectory(dir);
594	iliev	1781	db->AddInstrumentsNonrecursive(dir, Path, insDir, pProgress);
595	iliev	1208	}
596	iliev	1200	};
597
598	iliev	1208	bool DirectoryScanner::HasInstrumentFiles(String Dir) {
599	iliev	1717	InstrumentFileCounter c;
600			return c.Count(Dir) > 0;
601	iliev	1208	}
602
603	iliev	1200	int InstrumentFileCounter::Count(String FsDir) {
604			dmsg(2,("InstrumentFileCounter: Count(FsDir=%s)\n", FsDir.c_str()));
605			if (FsDir.empty()) throw Exception("Directory expected");
606			FileCount = 0;
607
608	iliev	1717	File::WalkDirectoryTree(FsDir, this);
609	iliev	1200	return FileCount;
610			}
611
612	iliev	1717	void InstrumentFileCounter::FileEntry(std::string Path) {
613	iliev	1781	dmsg(2,("InstrumentFileCounter: FileEntry(Path=%s)\n", Path.c_str()));
614	iliev	1717	if(Path.length() < 4) return;
615			if(!strcasecmp(".gig", Path.substr(Path.length() - 4).c_str())) FileCount++;
616	iliev	1200	};
617
618			} // namespace LinuxSampler