from system import System
import Globals, OFS, webdav
import string, re, os, types, time, urllib


class ZSystem(OFS.Folder.Folder):
    id        = 'system'
    name      = 'ZSystem'
    icon      = 'misc_/ZSystem/Icon'
    meta_type = 'ZSystem'
    color     = '#666666'
    utf8      = 0

    _properties = (
        {'id' : 'title', 'type' : 'string', 'mode' : 'w'},
        {'id' : 'name', 'type' : 'string', 'mode' : 'w'},
        {'id' : 'database', 'type' : 'string', 'mode' : 'w'},
        {'id' : 'location', 'type' : 'string', 'mode' : 'w'},
        {'id' : 'color', 'type' : 'string', 'mode' : 'w'},
        {'id' : 'utf8', 'type' : 'boolean', 'mode' : 'w'},
    )

    manage_options = (
        OFS.Folder.Folder.manage_options[0],
        OFS.Folder.Folder.manage_options[1],
        {
            'label'  : 'System',
            'icon'   : '',
            'action' : 'manage_system',
            'target' : '_self',
        },
        {
            'label'  : 'Basic',
            'icon'   : '',
            'action' : 'manage_basic',
            'target' : '_self',
        },
        {
            'label'  : 'Init',
            'icon'   : '',
            'action' : 'manage_init',
            'target' : '_self',
        },
        OFS.Folder.Folder.manage_options[2],
        OFS.Folder.Folder.manage_options[3],
        {
            'label'  : 'Color',
            'icon'   : '',
            'action' : 'manage_color',
            'target' : '_self',
        },
        OFS.Folder.Folder.manage_options[-1],
    )

    manage_system   = Globals.DTMLFile('manage/system', globals())
    manage_basic    = Globals.DTMLFile('manage/basic', globals())
    manage_init     = Globals.DTMLFile('manage/init', globals())
    manage_color    = Globals.DTMLFile('manage/color', globals())

    manage_system_dtml   = Globals.DTMLFile('manage/code/system', globals())
    manage_table_dtml    = Globals.DTMLFile('manage/code/table', globals())
    manage_user_dtml     = Globals.DTMLFile('manage/code/user', globals())
    manage_function_dtml = Globals.DTMLFile('manage/code/function', globals())
    manage_language_dtml = Globals.DTMLFile('manage/code/language', globals())
    manage_basic_dtml    = Globals.DTMLFile('manage/code/basic', globals())
    manage_init_dtml     = Globals.DTMLFile('manage/code/init', globals())
    manage_color_dtml    = Globals.DTMLFile('manage/code/color', globals())
    manage_title_dtml    = Globals.DTMLFile('manage/code/title', globals())

    system_login         = Globals.DTMLFile('manage/login', globals())
    system_function      = Globals.DTMLFile('manage/function', globals())

    edit                 = OFS.Folder.Folder('edit')

    background = Globals.ImageFile('images/background.gif', globals())
    empty      = Globals.ImageFile('images/empty.gif', globals())
    edit_icon  = Globals.ImageFile('images/edit.gif', globals())
    new_icon   = Globals.ImageFile('images/new.gif', globals())
    dot_icon   = Globals.ImageFile('images/dot.gif', globals())
    dot_a_icon = Globals.ImageFile('images/dot_a.gif', globals())


    def __init__(self, name, database, location):
        self._v_system = System(name, database, location)
        self._setObject('edit', ZEdit(self))
        return


    def init(self):
        self._v_system = System(self.name, self.database, self.location)
        return


    def open(self):
        if not hasattr(self, '_v_system'):
            self.init()
        return self._v_system.open()


    def close(self):
        return self._v_system.close()


    def state(self):
        return self._v_system.state()


    def commit(self, request=None):
        if request and request.retry_count:
            return
        return self._v_system.commit()


    def rollback(self, request=None):
        if request and request.retry_count:
            return
        return self._v_system.rollback()


    def conflict(self, request):
        return request.retry_count


    def getdata(self, table, id):
        return self._v_system.getdata(table, id)


    def newdata(self, table, id=None):
        return self._v_system.newdata(table, id)


    def setdata(self, table, id, data):
        return self._v_system.setdata(table, id, data)


    def deldata(self, table, id):
        return self._v_system.deldata(table, id)


    def listdata(self, table, where='', order='id', constraint=''):
        return self._v_system.listdata(table, where, order, constraint)


    def finddata(self, table, where='', order='id', constraint=''):
        return self._v_system.finddata(table, where, order, constraint)


    def authenticate(self, name, password):
        return self._v_system.authenticate(name, password)


    def login(self, name, password, session=None):
        if session:
            instance = session.get(self.name, {})
            user = self.getuser(name)
            if self.authenticate(name, password):
                instance['user'] = name
                instance['role'] = ''
                instance['roles'] = string.split(user.roles)
                if instance['roles']:
                    instance['role'] = instance['roles'][0]
                instance['preferences'] = {}
                for preference in re.split('\s*;\s*', user.preferences):
                    item = string.split(preference, '=')
                    if len(item) == 2:
                        instance['preferences'][item[0]] = item[1]
                instance['history'] = []
                session[self.name] = instance
                return 1
        return 0


    def logout(self, name, session=None):
        if session:
            instance = session.get(self.name, {})
            instance['user'] = ''
            instance['role'] = ''
            instance['roles'] = []
            instance['preferences'] = {}
            instance['history'] = []
            session[self.name] = instance
            return 1
        return 0


    def setrole(self, name, role, session=None):
        if session:
            instance = session.get(self.name, {})
            if instance.has_key('roles'):
                if role in instance['roles']:
                    instance['role'] = role
                    session[self.name] = instance
                    return 1
        return 0


    def addtohistory(self, table, id, session=None):
        if session:
            instance = session.get(self.name, {})
            if instance.has_key('history'):
                for item in instance['history']:
                    if item['table'] == table and item['id'] == id:
                        return 1
                instance['history'].append({
                    'date'  : time.time(),
                    'table' : table,
                    'id'    : id
                })
                session[self.name] = instance
                return 1
        return 0


    def environment(self, request=None):
        if request == None:
            return
        session = request.SESSION
        request.set('test_', str(request.AUTHENTICATED_USER) == 'zope')
        request.set('server_', request.SERVER_URL)
        request.set('system_', request.PARENTS[-2])
        request.set('base_', request.PARENTS[-2].id)
        request.set('root_', '')
        request.set('print_', 0)
        script = ''
        path = []
        for name in string.split(request.PATH_INFO, '/')[2:]:
            if name:
                path.append(name)
        if path and path[-1] == 'edit':
            request.set('login_', {'':''})
            path = path[:-1]
        if path and path[-1] == 'print':
            request.set('print_', 1)
            path = path[:-1]
        if path and re.match('^(index[._]html)|(.*\.css)|(.*\.js)$', path[-1]):
            path = path[:-1]
        if path and re.match('.*\.html$', path[-1]):
            script = path[-1]
            path = path[:-1]
        language = self._v_system.listnames('^language::id$', '.*', '^(0|1)$')[-1]
        if path and path[0] in self._v_system.listnames('^language$', '^.+'):
            language = path[0]
            path = path[1:]
        while path and path.count(''):
            path.remove('')
        request.set('script_', script)
        request.set('path_', path)
        request.set('language_', language)
        page = string.join(path, '/')
        request.set('page_', page)
        if page and language:
            request.set('page_', '%s/%s' % (language, page))
        elif language:
            request.set('page_', language)
        else:
            request.set('page_', page)
        request.set('ticket_', str(time.time()))
        query = request.get('QUERY_STRING', '')
        if not query:
            form = request.form
            if form:
                query = []
                for key,value in form.items():
                    if not key or key[0] == '-':
                        continue
                    try:
                        query.append('%s=%s' % (key, self.urlquote(value)))
                    except:
                        pass
                query = string.join(query, '&')
        request.set('query_string_', query)
        request.set('user_', '')
        request.set('role_', '')
        request.set('roles_', [])
        request.set('preferences_', {})
        request.set('history_', [])
        try:
            instance = session.get(self.name, {})
            if instance.has_key('user'):
                request.set('user_', instance['user'])
                request.set('role_', instance['role'])
                request.set('roles_', instance['roles'])
                request.set('preferences_', instance['preferences'])
                request.set('history_', instance['history'])
        except:
            pass
        request.set('edit_', not request.print_ and request.user_ != '')
        request.set('edit__', request.edit_ and request.role_ in ('administrator','manager',))
        request.set('edit___', request.edit_ and request.role_ in ('administrator',))
        if not request.has_key('owner_'):
            request.set('owner_', request.user_)

        request.set('identifier_', '%s_%s' % (request.base_, request.owner_))

        return


    def setticket(self, session, ticket, action):
        if not session:
            return
        instance = session.get('ticket', {})
        instance['%s.%s' % (ticket, action)] = time.time()
        session.set('ticket', instance)
        return


    def getticket(self, session, ticket, action):
        if not session:
            return None
        instance = session.get('ticket', {})
        return instance.get('%s.%s' % (ticket, action), None)


    class Type(OFS.SimpleItem.SimpleItem):
        (type, id) = ('', '')

        def __init__(self, type):
            self.type = type
            self.id   = type.split('::')[-1]
            return


    def listtypes(self, type):
        list = []
        if type:
            for type in self._v_system.listtypes('^%s::[^:]+$' % (type)):
                list.append(self.Type(type))
        else:
            for type in self._v_system.listtypes('^[^:]+$'):
                list.append(self.Type(type))
        return list


    def listnames(self, type):
        list = []
        for name in self._v_system.listnames('^%s$' % (type)):
            list.append(name)
        return list


    class Table(OFS.SimpleItem.SimpleItem):
        (table, id, name) = ('', 0, '')

        def __init__(self, table):
            self.table       = table['']
            if table['id']:
                self.id      = int(table['id'])
            self.name        = table['name']
            return


    def listtables(self):
        list = []
        for table in self._v_system.listtables():
            list.append(self.Table(table))
        return list


    class Field(OFS.SimpleItem.SimpleItem):
        (table, field, id, name, type, default, index) = ('', '', 0, '', '', '', '')

        def __init__(self, table, field):
            self.table       = table
            self.field       = field['']
            if field['id']:
                self.id      = int(field['id'])
            self.name        = field['name']
            self.type        = field['type']
            self.default     = field['default']
            self.index       = field['index']
            return


    def listfields(self, table):
        list = []
        for field in self._v_system.listfields(table):
            list.append(self.Field(table, field))
        return list


    class User(OFS.SimpleItem.SimpleItem):
        (user, id, name, password, roles, preferences) = ('', 0, '', '', '', '')

        def __init__(self, user):
            self.user        = user['']
            if user['id']:
                self.id      = int(user['id'])
            self.name        = user['name']
            self.password    = user['password']
            self.roles       = user['roles']
            self.preferences = user['preferences']
            return


    def getuser(self, name):
        return self.User(self._v_system.getuser(name))


    def listusers(self):
        list = []
        for user in self._v_system.listusers():
            list.append(self.User(user))
        return list


    class Function(OFS.SimpleItem.SimpleItem):
        (function, id, name, roles, title, attributes) = ('', 0, '', '', '', '')

        def __init__(self, function):
            self.function    = function['']
            if function['id']:
                self.id      = int(function['id'])
            self.name        = function['name']
            self.roles       = function['roles']
            self.title       = function['title']
            self.attributes  = function['attributes']
            return


    def getfunction(self, name):
        return self.Function(self._v_system.getfunction(name))


    def listfunctions(self):
        list = []
        for function in self._v_system.listfunctions():
            list.append(self.Function(function))
        return list


    class Language(OFS.SimpleItem.SimpleItem):
        (language, id, name, title) = ('', 0, '', '')

        def __init__(self, language):
            self.language    = language['']
            if language['id']:
                self.id      = int(language['id'])
            self.name        = language['name']
            self.title       = language['title']
            return


    def getlanguage(self, name):
        return self.Language(self._v_system.getlanguage(name))


    def listlanguages(self):
        list = []
        for language in self._v_system.listlanguages():
            list.append(self.Language(language))
        return list


    def getobjectbypath(self, root, path):
        if path:
            try:
                root = root[path[0]]
            except:
                pass
            return self.getobjectbypath(root, path[1:])
        return root


    class Record(OFS.SimpleItem.SimpleItem):
        (id_, id) = (0, 0)

        def __init__(self, table, data=None, sort='id'):
            self.type_ = table
            self.id_   = 0
            self.keys_ = ['id']
            if data:
                self.id_   = data['id']
                for key in data.keys():
                    if key != 'id':
                        self.keys_.append(key)
                    setattr(self, key, data[key])
                self.sort = data[sort]
            self.keys_.sort()
            return

        def get(self, attr, start=0, end=0, default=''):
            value = getattr(self, attr, default)
            if not value:
                value = default
            if start and end:
                value = value[start:end]
            elif start:
                value = value[start:]
            elif end:
                value = value[:end]
            return value

        def keys(self):
            return self.keys_

        def __dict__(self):
            data = {}
            for key in self.keys_:
                data[key] = getattr(self, key)
            return data

        def __getitem__(self, key):
            return getattr(self, key)

        def __setitem__(self, key, value):
            if not key in self.keys_:
                self.keys_.append(key)
                self.keys_.sort()
            setattr(self, key, value)
            return self

        def __str__(self):
            text = []
            for key in self.keys_:
                text.append('%s: %s' % (key, getattr(self, key)))
            return(string.join(text, '\n'))

        def __len__(self):
            return len(self.keys_)


    def getrecord(self, table, id):
        data = self._v_system.getdata(table, id)
        if not data:
            data = self._v_system.getdata(table, 0)
        return self.Record(table, data)


    def setrecord(self, table, id, record):
        self._v_system.setdata(table, id, record)
        return


    def newrecord(self, table, id=None, record=None):
        id = self._v_system.newdata(table, id)
        if record:
            self._v_system.setdata(table, id, record)
        return id


    def delrecord(self, table, id):
        self._v_system.deldata(table, id)
        return


    def listrecords(self, table, where='id>0', order='id', constraint=''):
        list = []
        for record in self._v_system.select('*', table, where, order, constraint):
            list.append(self.Record(table, record))
        return list


    def listrecordids(self, table, where='id>0', order='id', constraint=''):
        return self._v_system.listids(table, where, order, constraint)


    def record(self, table, data):
        if type(data) in (types.InstanceType, types.DictionaryType,):
            return self.Record(table, data)
        return data


    def records(self, table, list):
        for i in range(len(list)):
            if type(list[i]) in (types.InstanceType, types.DictionaryType,):
                list[i] = self.Record(table, list[i])
        return list


    def navigate(self, table, id=0, action='next'):
        return self._v_system.navigate(table, id, action)


    def minid(self, table):
        return self._v_system.minid(table)


    def maxid(self, table):
        return self._v_system.maxid(table)


    def listids(self, table, where='', order='id', constraint=''):
        return self._v_system.listids(table, where, order, constraint)


    def select(self, field, table, where='', order='id', constraint=''):
        return self._v_system.select(field, table, where, order, constraint)


    def sql(self, query):
        return self._v_system.sql(query)


    def identifier(self, text):
        return self._v_system.identifier(text)


    def text2date(self, text):
        return self._v_system.text2date(text)


    def date2text(self, date):
        return self._v_system.date2text(date)


    def float2text(self, float):
        return self._v_system.float2text(float)


    def float2price(self, float):
        return self._v_system.float2price(float)


    def price2float(self, price):
        return self._v_system.price2float(price)


    def date2sort(self, text, reverse=0):
        return self._v_system.date2sort(text, reverse)


    def evaluate(self, text, request=None):
        dtml = OFS.DTMLMethod.DTMLMethod(request)
        dtml.raw = str(text)
        return dtml


    def quote(self, value, javascript=None):
        return self._v_system.quote(value, javascript)


    def pglist(self, value):
        return self._v_system.pglist(value)


    def pgdatetime(self, value):
        return self._v_system.pgdatetime(value)


    def urlquote(self, value):
        return urllib.quote_plus(value)


    def is_valid_email(self, email):
        return self._v_system.is_valid_email(email)


    def dir(self, object):
        return dir(object)


    def object(self, root, list):
        if list:
            return self.object(root[list[0]], list[1:])
        return root


    def getfile(self, path, name, type='text/html', response=None):
        content = self._v_system.readfile(path, name)
        if response:
            response.setHeader('Content-Type', type)
            response.setHeader('Content-Length', len(content))
            response.setHeader('Accept-Ranges', 'bytes')
            response.setHeader('Content-Name', os.path.basename(name))
            response.setHeader('Content-Disposition', 'inline; filename=%s' % (os.path.basename(name)))
            response.setHeader('text', os.path.basename(name))
            response.write(content)
            response.setStatus('OK')
        else:
            return content
        return


    def sorthtml(self, left, right):
        return self._v_system.sorthtml(left, right)


    def writelog(self, name, data):
        return self._v_system.writelog(name, data)


    def readlog(self, name):
        list = []
        id = 0
        for line in self._v_system.readlog(name):
            id = id + 1
            record = {}
            record['id'] = id
            record['time'] = line[0]
            record['data'] = line[1:]
            list.append(self.Record('log', record))
        return list


    def datetime(self, datetime, format='%d.%m.%Y %H:%M:%S'):
        if type(datetime) in (types.StringType,):
            scan = re.match('^(\d\d\d\d)-(\d\d)-(\d\d)\s(\d\d):(\d\d):(\d\d)', str(datetime))
            if scan:
                year   = int(scan.group(1))
                month  = int(scan.group(2))
                day    = int(scan.group(3))
                hour   = int(scan.group(4))
                minute = int(scan.group(5))
                second = int(scan.group(6))
                datetime = (year, month, day, hour, minute, second, 0, 0, 0,)
                return time.strftime(format, datetime)
            return ''
        else:
            try:
                return datetime.strftime(format)
            except:
                return ''
        return str(datetime)


    def tmpstore(self, dirname, filename, text):
        return self._v_system.tmpstore(self.location, dirname, filename, text)


    def tmpload(self, dirname, filename):
        return self._v_system.tmpload(self.location, dirname, filename)


    def tmpclean(self, dirname):
        return self._v_system.tmpclean(self.location, dirname)


class ZEdit(OFS.Folder.Folder):
    id        = 'edit'
    name      = 'ZEdit'
    icon      = 'misc_/zsystem/icon.gif'
    meta_type = 'ZEdit'

    manage_options = (
        OFS.Folder.Folder.manage_options[0],
        OFS.Folder.Folder.manage_options[3],
    )


    def __init__(self, system):
        self._v_system = system.this()
        return


    def edit(self):
        """edit"""
        object = {}
        object['name'] = self._v_system.name
        try:
            object['table'] = self.REQUEST.form['table']
            object['field'] = self.REQUEST.form['field']
            object['id']    = int(self.REQUEST.form['id'])
            try:
                element = self.REQUEST.form['element']
            except:
                element = None
        except:
            return
        id = "%(name)s.%(table)s.%(field)s.%(id)d" % (object)
        self = self.this()
        try:
            self._setObject(id, ZEditObject(self, object, element))
        except:
            self._delObject(id)
            self._setObject(id, ZEditObject(self, object, element))
        self.REQUEST['RESPONSE'].redirect('%s/externalEdit_/%s' % (self.absolute_url(), id))
        return


    def refresh(self):
        """refresh"""
        try:
            id = self.REQUEST.form['id']
        except:
            return
        try:
            self.REQUEST['RESPONSE'].redirect('%s/%s/refresh' % (self.absolute_url(), self[id].id))
        except:
            self.REQUEST['RESPONSE'].write('<html><head><title>%s</title></head><body bgcolor="white"></body></html>' % (id))
        return


class ZEditObject(OFS.SimpleItem.SimpleItem):
    name      = 'ZEditObject'
    icon      = 'misc_/zsystem/icon.gif'
    meta_type = 'ZEditObject'

    manage_options = (
        {
            'label'  : 'Content',
            'icon'   : '',
            'action' : 'manage_content',
            'target' : '_self',
        },
    )

    manage_content  = Globals.DTMLFile('manage/content', globals())

    __implements__ = (webdav.WriteLockInterface.WriteLockInterface,)


    def __init__(self, container, object, element=None):
        self.id = "%(name)s.%(table)s.%(field)s.%(id)d" % (object)
        self.container = container
        self.object    = object
        self.element   = element
        self.raw       = ''
        return


    def read(self):
        self.container.system.system.open()
        self.raw = self.container.system.system.getdata(self.object['table'], self.object['id'])[self.object['field']]
        self.container.system.system.close()
        return str(self.raw)


    def refresh(self):
        """refresh"""
        value = self.raw
        value = value.replace('\\', '\\\\')
        value = value.replace('\'', '\\\'')
        value = value.replace('\<', '&lt;')
        value = value.replace('\>', '&gt;')
        value = value.replace('\&', '&amp;')
        value = value.replace('\"', '&quot;')
        value = value.replace('\r', '')
        value = value.replace('\n', '\\n')
        return """
        <html><head><title>%s</title></head><body bgcolor="white" onload="opener.document.form['%s'].value='%s'"></body></html>
        """ % (self.element.split(':')[0], self.element, value)


    def GET(self):
        """get"""
        return self.read()


    def PUT(self, REQUEST, RESPONSE):
        """put"""
        self.raw = REQUEST.get('BODY', '')
        if not self.element:
            self.container.system.system.open()
            self.container.system.system.setdata(self.object['table'], self.object['id'], {self.object['field']:str(self.raw)})
            self.container.system.system.commit()
            self.container.system.system.close()
        return


    def LOCK(self, REQUEST, RESPONSE):
        """lock"""
        OFS.SimpleItem.SimpleItem.LOCK(self, REQUEST, RESPONSE)
        return


    def UNLOCK(self, REQUEST, RESPONSE):
        """unlock"""
        OFS.SimpleItem.SimpleItem.UNLOCK(self, REQUEST, RESPONSE)
        self.container._delObject(self.id)
        return


manage_addZSystem = Globals.DTMLFile('manage/add', globals())

def manage_add(self, id, title, REQUEST=None):
    """Add a new ZSystem instance"""
    handle          = ZSystem(REQUEST.name, REQUEST.database, REQUEST.location)
    handle.id       = id
    handle.title    = title
    handle.name     = REQUEST.name
    handle.database = REQUEST.database
    handle.location = REQUEST.location

    self = self.this()
    self._setObject(id, handle)

    if REQUEST is not None:
        REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
    return