removed unused modules

diff --git a/database/db.py b/database/db.py
deleted file mode 100755 (executable)
index fc808dc..0000000
--- a/database/db.py
+++ /dev/null
@@ -1,225 +0,0 @@
-#!/usr/bin/python -tt
-# -*- coding: utf-8 -*-
-# vim: sw=4 ts=4 expandtab ai
-
-"""Module for work with database"""
-
-import os
-import sqlite3
-import pygtk
-pygtk.require('2.0')
-import gtk
-
-class DbSqlite:
-
-    """class for work with database"""
-
-    def __init__(self):
-        self.conn = self.connect()
-
-    def connect(self):
-
-        """connect to database"""
-        dbname = "meabookdb_oblgas"
-        if os.access(dbname, os.F_OK|os.R_OK|os.W_OK):
-            conn = sqlite3.connect(dbname)
-        else:
-            print "access to database file error"
-            conn = None
-        return conn
-
-    def get_record(self,  id):
-        
-        """return record field"""
-        cur = self.conn.cursor()
-        cur.execute("select field.name, data.value "
-                    "from data left join field "
-                    "on data.id_field=field.id "
-                    "where data.id=?", (id,))
-        self.data = {} 
-        for row in cur:
-            print "key = %s value = %s" % (row[0], row[1])
-            self.data[row[0]] = row[1]
-        return self.data
-
-    def get_allrecords(self, field, struct):
-        
-        """return records"""
-        cur = self.conn.cursor()
-        cur.execute("select data.id, data.value "
-                    "from data left join field "
-                    "on data.id_field=field.id "
-                    "left join relation on data.id=relation.id_data "
-                    "where field.name=? and relation.id_struct=? ", (field, struct))
-        self.data = {}
-        for row in cur:
-            #print row
-            self.data[row[0]] = row[1]
-        return self.data
-
-    def get_allrecords1(self, field, struct):
-        
-        """return records"""
-        cur = self.conn.cursor()
-        cur.execute("select distinct data.id "
-                    "from data left join relation on data.id=relation.id_data "
-                    "where relation.id_struct=?", (struct,))
-        self.data = {}
-        cur1 = self.conn.cursor();
-        for row in cur:
-            #print row
-            cur1.execute("select data.value from data "
-                        "left join field on data.id_field=field.id "
-                        "where data.id=? and field.type=1 "
-                        "order by field.sort", (row[0],));
-            str = "";
-            for row1 in cur1:
-                str += row1[0]
-                str += " "
-            self.data[row[0]] = str;    
-        return self.data
-        
-    def get_id(self, table, value):
-        
-        """get id for value into table"""
-        if self.conn is None:
-            return None
-        cur = self.conn.cursor()
-        query = "select id from %s where name='%s'" % (table, value)
-        cur.execute(query)
-        res = cur.fetchone()
-        id = 0
-        if res is None:
-            query = "insert into %s (name) values ('%s')" % (table, value)
-            cur.execute(query)
-            id = cur.lastrowid
-        else:
-            id = res[0]
-        return id
-    
-    def get_parent(self, id):
-        
-        if self.conn is None:
-            return None
-        cur = self.conn.cursor()
-        cur.execute("select parent from struct where id=?", (id,))
-        res = cur.fetchone()
-        id = 0
-        if res != None:
-            id = res[0]
-        return id
-    
-    def get_name_struct(self, id):
-        
-        if self.conn is None:
-            return None
-        cur = self.conn.cursor()
-        cur.execute("select name from struct where id=?", (id,))
-        res = cur.fetchone()
-        name = "All"
-        if res != None:
-            name = res[0]
-        return name
-
-    def get_id_struct(self, value, parent):
-        
-        """get id for value into struct"""
-        if self.conn is None:
-            return None
-        cur = self.conn.cursor()
-        cur.execute("select id from struct where name=? and parent=?", (value, parent))
-        res = cur.fetchone()
-        id = 0
-        if res is None:
-            cur.execute("insert into struct (name, parent) values (?, ?)", (value, parent))
-            id = cur.lastrowid
-        else:
-            id = res[0]
-        return id
-
-    def ins_record(self, rec):
-
-        """insert record into database"""
-        #get id new record
-        #conn = self.connect()
-        if self.conn is None:
-            print "database connect error"
-            return None
-        cur = self.conn.cursor()
-        cur.execute("select max(id) from data")
-        id_record = cur.fetchone()[0]
-        if id_record is None:
-            id_record = 1
-        else:
-            id_record = id_record + 1
-        print "id_record=%s" % (id_record,)
-        
-        struct = ["", ""]
-        for key, val in rec.items():
-            if val == None:
-                continue
-            id_field = self.get_id("field", key)
-            if key == 'company':
-                struct[0] = val
-            if key == 'department':
-                struct[1] = val
-            #for i in val:
-            cur.execute("insert into data (id, id_field, value) values (?, ?, ?)", 
-                (id_record, id_field, val))
-        #insert comppane into table struct
-        id0 = self.get_id("struct", struct[0])
-        cur.execute("update struct set parent=0 where id=?", (id0,))
-        
-        id1 = self.get_id_struct(struct[1], id0)
-        #cur.execute("update struct set parent=? where id=?", (id0, id1))
-        cur.execute("insert into relation (id_data, id_struct) values (?, ?)", (id_record, id1))
-        self.conn.commit()
-        #conn.close()
-
-    def clear_data(self):
-
-        """clear all record from table data"""
-        conn = self.connect()
-        if conn is None:
-            print "database connect error"
-            return None
-        cur = conn.cursor()
-        cur.execute("delete from data")
-        cur.execute("delete from field")
-        cur.execute("delete from struct")
-        cur.execute("delete from relation")
-        conn.commit()
-        conn.close()
-
-    def make_tree(self):
-
-        """create TreeStore from database table Struct"""
-        ts = gtk.TreeStore(int, str)
-        
-        conn = self.connect()
-        if conn is None:
-            return None
-        cur = conn.cursor()
-        cur.execute("select id, name, parent from struct")
-        item = {}
-        for row in cur:
-            if (row[2] == 0):
-                item[row[0]] = ts.append(None, [row[0], row[1]]) 
-            else :
-                ts.append(item[row[2]], [row[0], row[1]])
-        return ts
-
-    def get_list(self, parent):
-        
-        """return list of struct with same parent"""
-        conn = self.connect()
-        if conn is None:
-            return None
-        cur = conn.cursor()
-        cur.execute("select id, name from struct where parent=?", (parent,))
-        data = {}
-        for row in cur:
-            data[row[0]] = row[1]
-        
-        return data    
-

diff --git a/parser.py b/parser.py
deleted file mode 100755 (executable)
index d954456..0000000
--- a/parser.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/python -tt
-# vim: sw=4 ts=4 expandtab ai
-
-import os
-import re
-import sys
-import base64
-
-from database import db
-
-
-class LDIFParser:
-    def __init__(self, fname):
-        self.fname = fname
-        #self.database = db.DbSqlite()
-        #self.database.clear_data()
-
-    def parse(self):
-        """Parse LDIF file."""
-
-        try:
-            fobj = open(self.fname)
-        except IOError:
-            return None
-
-        item = {}
-        for line in fobj:
-            if line == '\n' and item:
-                #self.database.insert_record(item)
-                print item
-                item = {}
-            else:
-                parts = line.split(':')
-                if len(parts) == 2:
-                    item[parts[0]] = parts[1].strip()
-                else:
-                    item[parts[0]] = base64.b64decode(parts[2])
-
-if __name__ == "__main__":
-    p = LDIFParser('/tmp/test.ldif')
-    p.parse()
-
-
-def read_file(file_name):
-    try:
-        file = open(file_name)
-    except IOError:
-        return None
-    result = {}
-    dbo = db.DbSqlite()
-    dbo.clear_data()
-    flag_last_string = True
-
-    for line in file:
-        # Check end of person 
-        if line == "\n":
-            dbo.ins_record(result)
-            # unset result
-            result = {}
-            continue
-        # Check uuencode long string
-        if flag_last_string == False:
-            if re.search("^ .*=$", line):
-                value = value + line
-                continue
-            else:
-                value = base64.b64decode(value)
-                key, value = key.strip(), value.strip()
-                try:
-                    result[key].append(value)
-                except KeyError:
-                    result[key]  = [value]
-                flag_last_string = True
-                       
-        key, value = line.split(':', 1)
-        #Look up uuecode string
-        if (re.search("^: ", value)):
-            flag_last_string = False
-            continue
-
-        key, value = key.strip(), value.strip()
-        try:
-            result[key].append(value)
-        except KeyError:
-            result[key]  = [value]
-    return result
-
-def main(argv):
-    """ Main """
-
-    result=read_file("test/test.ldiff")
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))