from zsystem import ZSystem
from site import Site
import Globals, OFS
import string, re, time, types


class ZSite(ZSystem):
    id        = 'site'
    name      = 'ZSite'
    icon      = 'misc_/ZSite/Icon'
    meta_type = 'ZSite'
    color     = '#003366'
    utf8      = 0
    editor    = 1

    _properties = ZSystem._properties + (
        {'id' : 'editor', 'type' : 'boolean', 'mode' : 'w'},
    )

    manage_options = (
        ZSystem.manage_options[0],
        ZSystem.manage_options[1],
        {
            'label'  : 'Data',
            'icon'   : '',
            'action' : 'manage_data',
            'target' : '_self',
        },
        {
            'label'  : 'Site',
            'icon'   : '',
            'action' : 'manage_site',
            'target' : '_self',
        },
        ZSystem.manage_options[2],
        ZSystem.manage_options[3],
        ZSystem.manage_options[4],
        ZSystem.manage_options[5],
        ZSystem.manage_options[6],
        ZSystem.manage_options[7],
        ZSystem.manage_options[8],
    )

    manage_data          = Globals.DTMLFile('manage/data', globals())
    manage_site          = Globals.DTMLFile('manage/site', globals())

    manage_data_dtml     = Globals.DTMLFile('manage/code/data', globals())
    manage_config_dtml   = Globals.DTMLFile('manage/code/config', globals())
    manage_markup_dtml   = Globals.DTMLFile('manage/code/markup', globals())
    manage_object_dtml   = Globals.DTMLFile('manage/code/object', globals())

    manage_site_dtml     = Globals.DTMLFile('manage/code/site', globals())
    manage_document_dtml = Globals.DTMLFile('manage/code/document', globals())
    manage_text_dtml     = Globals.DTMLFile('manage/code/text', globals())
    manage_content_dtml  = Globals.DTMLFile('manage/code/content', globals())

    edit_text            = Globals.DTMLFile('edit/text', globals())
    edit_content         = Globals.DTMLFile('edit/content', globals())
    edit_image           = Globals.DTMLFile('edit/image', globals())
    edit_file            = Globals.DTMLFile('edit/file', globals())

    edit_access          = Globals.DTMLFile('edit/access', globals())

    edit_login           = Globals.DTMLFile('edit/login', globals())
    edit_state           = Globals.DTMLFile('edit/state', globals())
    edit_history         = Globals.DTMLFile('edit/history', globals())
    edit_admin           = Globals.DTMLFile('edit/admin', globals())

    file_icon  = Globals.ImageFile('images/file.gif', globals())


    def __init__(self, name, database, location):
        self._v_system = Site(name, database, location)
        return


    def init(self):
        self._v_system = Site(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 environment(self, request=None):
        if request == None:
            return
        ZSystem.environment(self, request)

        request.set('site_', request.system_)

        request.set('id_', self.getdocumentid(request.path_))
        if request.path_ and request.id_ == 0:
            request.set('id_', self.getdocumentid(request.path_[:-1]))
        request.set('document_', self.getdocument(request.id_))
        request.set('parents_', self.listparents(request.id_))
        request.set('menu_', self.listmenu(0))
        request.set('scope_', '')

        if request.owner_:
            request.set('state_', self.getstateofdocument(request.id_, request.language_, request.owner_))
            request.set('history_', self.gethistoryofdocument(request.id_, request.language_))
        request.set('identifier_', '%s_%s' % (request.base_, request.owner_))

        objects = {}
        for object in self.listobjects():
            objects[object.name] = self.listobjectvalues(object.name)
        request.set('objects_', objects)

        markups = {}
        for markup in self._v_system.listmarkups():
            if markup['code1']:
                markups['<xml-%s>' % (markup[''])] = markup['code1']
            if markup['code2']:
                markups['</xml-%s>' % (markup[''])] = markup['code2']
        request.set('markups_', markups)

        if not request.edit_ and request.document_.link:
            request.RESPONSE.redirect(request.document_.link)
        return


    def getvalue(self, name, type=''):
        if type:
            return self._v_system.getvalue(name, 'site::%s' % (type))
        else:
            return self._v_system.getvalue(name, 'site')


    class Object(OFS.SimpleItem.SimpleItem):
        (object, id, name, size) = ('', 0, '', '')

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


    def listobjects(self):
        list = []
        for object in self._v_system.listobjects():
            list.append(self.Object(object))
        return list


    class ObjectValue(OFS.SimpleItem.SimpleItem):
        (object, value) = ('', '')
        (id, name, type, size, default) = (0, '', 'text', '1', '')

        def __init__(self, object, value):
            self.object    = object
            self.value     = value['']
            if value['id']:
                self.id    = int(value['id'])
            self.name      = value['name']
            self.type      = value['type']
            self.size      = value['size']
            self.default   = value['default']
            return


    def listobjectvalues(self, object):
        list = []
        for value in self._v_system.listobjectvalues(object):
            list.append(self.ObjectValue(object, value))
        return list


    class Markup(OFS.SimpleItem.SimpleItem):
        (markup, id, name, code1, code2) = ('', 0, '', '', '')

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


    def listmarkups(self):
        list = []
        for markup in self._v_system.listmarkups():
            list.append(self.Markup(markup))
        return list


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


    class Document(OFS.SimpleItem.SimpleItem):
        (id_, id, time) = (0, 0, '00010101')
        (parent, type, name, title) = (0, '', '', '')
        (template, link) = ('', '')
        (parameter, menu, sort) = ('', 0, '')

        def __init__(self, document):
            if document:
                self.id_       = document['id']
                self.id        = document['id']
                self.time      = document['time']
                self.parent    = document['parent']
                self.type      = document['type']
                self.name      = document['name']
                self.title     = document['title']
                self.template  = document['template']
                self.link      = document['link']
                self.parameter = document['parameter']
                self.menu      = document['menu']
                self.sort      = document['sort']
            self.keys_ = ['id','time','parent','type','name','title','template','link','parameter','menu','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 getdocument(self, id):
        return self.Document(self._v_system.getdocument(id))


    def setdocument(self, id, document):
        return self._v_system.setdocument(id, document)


    def listdocuments(self, parent=0, expression=''):
        list = []
        for document in self._v_system.listdocuments(parent, expression):
            list.append(self.Document(document))
        return list


    def getdocumentid(self, list):
        return self._v_system.getdocumentid(0, list)


    def listdocumentids(self, parent=0, expression=''):
        return self._v_system.listdocumentids(parent, expression)


    def geturl(self, id):
        if id == 0:
            return ''
        document = self.getdocument(id)
        if document.parent == 0:
            return document.name
        return '%s/%s' % (self.geturl(document.parent), document.name)


    def getfolderobject(self, root, id):
        folder = root
        for id in self._v_system.listparents(id):
            name = self._v_system.getdata('document', id)['name']
            folder = folder[name]
        return folder


    def listparents(self, id):
        return self._v_system.listparents(id)


    def listmenu(self, id):
        return map(self.getdocument, self._v_system.listmenu(id))


    class State(OFS.SimpleItem.SimpleItem):
        (id_, id, time) = (0, 0, '00010101')
        (document, language, owner) = (0, '', '')
        (state, date, remark, sort) = ('', '00010101', '', '')

        def __init__(self, state):
            if state:
                self.id_       = state['id']
                self.id        = state['id']
                self.time      = state['time']
                self.document  = state['document']
                self.language  = state['language']
                self.owner     = state['owner']
                self.state     = state['state']
                self.date      = state['date']
                self.remark    = state['remark']
                self.sort      = state['document']
            return


    def getstate(self, id):
        return self.State(self._v_system.getstate(id))


    def setstate(self, id, state):
        return self._v_system.setstate(id, state)


    def liststates(self, document, language, states=['']):
        list = []
        for state in self._v_system.liststates(document, language, states):
            list.append(self.State(state))
        return list


    def getstateofdocument(self, document, language, owner):
        return self.State(self._v_system.getstateofdocument(document, language, owner))


    def setstateofdocument(self, document, language, owner, state):
        return self._v_system.setstateofdocument(document, language, owner, state)


    class History(OFS.SimpleItem.SimpleItem):
        (id_, id, time) = (0, 0, '00010101')
        (document, language, owner) = (0, '', '')
        (remark, sort) = ('', '')

        def __init__(self, history):
            if history:
                self.id_       = history['id']
                self.id        = history['id']
                self.time      = history['time']
                self.document  = history['document']
                self.language  = history['language']
                self.owner     = history['owner']
                self.remark    = history['remark']
                self.sort      = history['document']
            return


    def gethistory(self, id):
        return self.History(self._v_system.gethistory(id))


    def sethistory(self, id, history):
        return self._v_system.sethistory(id, history)


    def listhistories(self, document, language):
        list = []
        for history in self._v_system.listhistories(document, language):
            list.append(self.History(history))
        return list


    def gethistoryofdocument(self, document, language):
        return self.History(self._v_system.gethistoryofdocument(document, language))


    def sethistoryofdocument(self, document, language, history):
        return self._v_system.sethistoryofdocument(document, language, history)


    def recoverdocument(self, document, language, owner):
        return self._v_system.recoverdocument(document, language, owner)


    def publishdocument(self, document, language, owner, remark=''):
        return self._v_system.publishdocument(document, language, owner, remark)


    class Text(OFS.SimpleItem.SimpleItem):
        (id_, id, time) = (0, 0, '00010101')
        (document, language, owner) = (0, '', '')
        (type, name, date, text, sort) = ('', '', '00010101', '', '')

        def __init__(self, text):
            if text:
                self.id_       = text['id']
                self.id        = text['id']
                self.time      = text['time']
                self.document  = text['document']
                self.language  = text['language']
                self.owner     = text['owner']
                self.type      = text['type']
                self.name      = text['name']
                self.date      = text['date']
                self.text      = text['text']
                self.sort      = text['sort']
            return


        def sort_plus_id(self):
            return '%s %09d' % (self.sort, self.id)


        def edit(self, edit=1, base='', init={}):
            if edit:
                parameter = ['id_:int=%d' % (self.id)]
                for key in init.keys():
                    parameter.append('init_.%s:record%s=%s' % (key, ['',':int'][type(init[key])==types.IntType], init[key]))
                return '<a href="" onclick="win=window.open(\'%sedit_text?%s\',\'text_%d\',\'width=640,height=480,scrollbars,menubar\'); win.focus(); return false"><img src="%s_icon" width="10" height="10" border="0" alt="[edit]"></a>&nbsp;' % (base, string.join(parameter, '&'), self.id, ['edit','new'][init != {}])
            return ''


        def show(self, edit=0, html=0, base=''):
            text = string.strip(self.text)
            if html:
                text = string.replace(text, '\r\n\r\n', '</p><p>')
                text = string.replace(text, '\r\n', '<br />')
                text = string.replace(text, '<br /><', '<')
                text = '<p>%s</p>' % (text)
            if edit:
                return '%s%s' % (self.edit(edit, base), text)
            return text


    def gettext(self, id, init={}):
        text = self._v_system.gettext(id)
        if not text:
            text = {
                'id'       : id,
                'time'     : 'now',
                'document' : -1,
                'language' : '',
                'owner'    : '',
                'type'     : '',
                'name'     : '',
                'date'     : '00010101',
                'text'     : '',
                'sort'     : ''
            }
            for key in init.keys():
                text[key] = init[key]
        return self.Text(text)


    def settext(self, id, text):
        return self._v_system.settext(id, text)


    def listtexts(self, document, language, owner, type='', expression=''):
        list = []
        for text in self._v_system.listtexts(document, language, owner, expression):
            if type:
                if type == text['type']:
                    list.append(self.Text(text))
            else:
                list.append(self.Text(text))
        return list


    def gettextbyname(self, document, language, owner, name):
        return self.gettext(self._v_system.gettextidbyname(document, language, owner, name))


    def listtextbytype(self, document, language, owner, type, expression=''):
        list = []
        for id in self._v_system.listtextidsbytype(document, language, owner, type, expression):
            list.append(self.gettext(id))
        return list


    class Content(OFS.SimpleItem.SimpleItem):
        (id_, id, time) = (0, 0, '00010101')
        (document, language, owner, parent) = (0, '', '', -1)
        (type, name, date, text, sort) = ('', '', '00010101', [], '')
        (size) = ('480')

        def __init__(self, content, size='480'):
            if content:
                self.id_       = content['id']
                self.id        = content['id']
                self.time      = content['time']
                self.document  = content['document']
                self.language  = content['language']
                self.owner     = content['owner']
                self.parent    = content['parent']
                self.type      = content['type']
                self.name      = content['name']
                self.date      = content['date']
                self.text      = content['text'].split('\t')
                self.sort      = content['sort']
            self.size = size
            return


        def sort_plus_id(self):
            return '%s %09d' % (self.sort, self.id)


        def sort_by_date(self):
            sort = (self.text[0]).split(' ')[-1]
            return '%s %09d' % (sort, self.id)


        def edit(self, edit=1, data='data', init={}):
            if edit:
                parameter = ['id_:int=%d' % (self.id), 'data_=%s' % (data)]
                for key in init.keys():
                    parameter.append('init_.%s:record%s=%s' % (key, ['',':int'][type(init[key])==types.IntType], init[key]))
                return '<a href="" onclick="win=window.open(\'edit_content?%s\',\'content_%d\',\'width=720,height=%s,scrollbars,menubar\'); win.focus(); return false"><img src="%s_icon" width="10" height="10" border="0" alt="[edit]"></a>&nbsp;' % (string.join(parameter, '&'), self.id, self.size, ['edit','new'][init != {}])
            return ''


        def show(self, edit=0):
            if edit:
                return '%s%s' % (self.edit(edit), self.text)
            return self.text


    def getcontent(self, id, init={}):
        content = self._v_system.getcontent(id)
        if not content:
            content = {
                'id'       : id,
                'time'     : 'now',
                'document' : -1,
                'language' : '',
                'owner'    : '',
                'parent'   : -1,
                'type'     : '',
                'name'     : '',
                'date'     : '00010101',
                'text'     : '',
                'sort'     : ''
            }
            for key in init.keys():
                content[key] = init[key]
        return self.Content(content, self._v_system.getvalue(content['type'], 'object::size'))


    def setcontent(self, id, content):
        return self._v_system.setcontent(id, content)


    def listcontents(self, document, language, owner, type='', expression=''):
        list = []
        for content in self._v_system.listcontents(document, language, owner, expression):
            if type:
                if type == content['type']:
                    list.append(self.Content(content, self._v_system.getvalue(content['type'], 'object::size')))
            else:
                list.append(self.Content(content, self._v_system.getvalue(content['type'], 'object::size')))
        return list


    def getcontentbyname(self, document, language, owner, type, name):
        return self.getcontent(self._v_system.getcontentidbyname(document, language, owner, type, name))


    def listcontentbytype(self, document, language, owner, type, expression=''):
        list = []
        for id in self._v_system.listcontentidsbytype(document, language, owner, type, expression):
            list.append(self.getcontent(id))
        return list


    def getparameter(self, parameter):
        return self._v_system.getparameter(parameter)


    def log(self, document, language, owner, action, data):
        name = '%s/log/%d' % (self.location, document)
        return self.writelog(name, [language, owner, action, str(data)])


    def text2dict(self, text, objecttype, objectvalues=None):
        dict = {}
        (index, max) = (0, len(text))
        if not objectvalues:
            objectvalues = self.listobjectvalues(objecttype)
        for objectvalue in objectvalues:
            if index < max:
                if objectvalue.type == 'date':
                    size = int(objectvalue.size)
                    list = re.split('\r*\n', '%s%s' % (text[index], size*'\n'))[:size]
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', list[i])
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(string.join(temp[:-2], ' ').strip())
                        dict[objectvalue.value].append(temp[-2])
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'image':
                    size = int(objectvalue.size)
                    list = re.split('\r*\n', '%s%s' % (text[index], size*'\n'))[:size]
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', list[i])
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(temp[1])
                        dict[objectvalue.value].append(string.join(temp[2:], ' ').strip())
                elif objectvalue.type == 'file':
                    size = int(objectvalue.size)
                    list = re.split('\r*\n', '%s%s' % (text[index], size*'\n'))[:size]
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', list[i])
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(string.join(temp[1:-1], ' ').strip())
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'link':
                    size = int(objectvalue.size)
                    list = re.split('\r*\n', '%s%s' % (text[index], size*'\n'))[:size]
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', list[i])
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(string.join(temp[1:-1], ' ').strip())
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'table':
                    list = re.split('\r*\n', text[index])
                    dict[objectvalue.value] = []
                    for line in list:
                        dict[objectvalue.value].append(re.split('\s+\|\s+', line))
                else:
                    dict[objectvalue.value] = text[index]
            else:
                if objectvalue.type == 'date':
                    size = int(objectvalue.size)
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', objectvalue.default)
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(string.join(temp[:-2], ' ').strip())
                        dict[objectvalue.value].append(temp[-2])
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'image':
                    size = int(objectvalue.size)
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', objectvalue.default)
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(temp[1])
                        dict[objectvalue.value].append(string.join(temp[2:], ' ').strip())
                elif objectvalue.type == 'file':
                    size = int(objectvalue.size)
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', objectvalue.default)
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(string.join(temp[1:-1], ' ').strip())
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'link':
                    size = int(objectvalue.size)
                    dict[objectvalue.value] = []
                    for i in range(size):
                        temp = re.split(' ', objectvalue.default)
                        while len(temp) < 3:
                            temp.append('')
                        dict[objectvalue.value].append(temp[0])
                        dict[objectvalue.value].append(string.join(temp[1:-1], ' ').strip())
                        dict[objectvalue.value].append(temp[-1])
                elif objectvalue.type == 'table':
                    list = re.split('\r*\n', objectvalue.default)
                    dict[objectvalue.value] = []
                    for line in list:
                        dict[objectvalue.value].append(re.split('\s+\|\s+', line))
                else:
                    dict[objectvalue.value] = objectvalue.default
            index += 1
        return dict


    def dict2text(self, dict, objecttype, objectvalues=None):
        text = []
        if not objectvalues:
            objectvalues = self.listobjectvalues(objecttype)
        for objectvalue in objectvalues:
            if objectvalue.type == 'date':
                size = int(objectvalue.size)
                list = []
                for i in range(size):
                    if type(dict[objectvalue.value][3*i]) == types.ListType:
                        force = dict[objectvalue.value][(3*i)+1][0] == '1'
                        sort = self.date2sort(dict[objectvalue.value][(3*i)][0])
                        if force:
                            sort = dict[objectvalue.value][(3*i)+2][0]
                        list.append('%s %d %s' % (dict[objectvalue.value][3*i][0], force, sort))
                    else:
                        force = dict[objectvalue.value][(3*i)+1] == '1'
                        sort = self.date2sort(dict[objectvalue.value][(3*i)])
                        if force:
                            sort = dict[objectvalue.value][(3*i)+2]
                        list.append('%s %d %s' % (dict[objectvalue.value][3*i], force, sort))
                text.append(string.join(list, '\n'))
            elif objectvalue.type == 'image':
                size = int(objectvalue.size)
                list = []
                for i in range(size):
                    if type(dict[objectvalue.value][3*i]) == types.ListType:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i][0], dict[objectvalue.value][(3*i)+1][0], dict[objectvalue.value][(3*i)+2][0]))
                    else:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i], dict[objectvalue.value][(3*i)+1], dict[objectvalue.value][(3*i)+2]))
                text.append(string.join(list, '\n'))
            elif objectvalue.type == 'file':
                size = int(objectvalue.size)
                list = []
                for i in range(size):
                    if type(dict[objectvalue.value][3*i]) == types.ListType:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i][0], dict[objectvalue.value][(3*i)+1][0], dict[objectvalue.value][(3*i)+2][0]))
                    else:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i], dict[objectvalue.value][(3*i)+1], dict[objectvalue.value][(3*i)+2]))
                text.append(string.join(list, '\n'))
            elif objectvalue.type == 'link':
                size = int(objectvalue.size)
                list = []
                for i in range(size):
                    if type(dict[objectvalue.value][3*i]) == types.ListType:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i][0], dict[objectvalue.value][(3*i)+1][0], dict[objectvalue.value][(3*i)+2][0]))
                    else:
                        list.append('%s %s %s' % (dict[objectvalue.value][3*i], dict[objectvalue.value][(3*i)+1], dict[objectvalue.value][(3*i)+2]))
                text.append(string.join(list, '\n'))
            elif objectvalue.type == 'table':
                if type(dict[objectvalue.value]) == types.ListType:
                    list = []
                    for line in dict[objectvalue.value]:
                        list.append(string.join(line, ' | '))
                    text.append(string.join(list, '\n'))
                else:
                    text.append(string.strip(dict[objectvalue.value]))
            else:
                text.append(string.strip(str(dict[objectvalue.value])))
        for i in range(len(text)):
            text[i] = string.replace(text[i], '\t', ' ')
        return string.join(text, '\t')


    def find(self, language, owner, words, type_list=[], all_words=0, case_sensitive=0, whole_words=0):
        list = []
        operator = '~*'
        if case_sensitive:
            operator = '~'
        for word in re.split('\s+', words.strip()):
            expr = '(document > -1) AND ('
            delimiter = ['', '']
            if whole_words:
                delimiter = ['([^a-zA-Z0-9]|^)', '([^a-zA-Z0-9]|$)']
            expr += 'text%s\'%s%s%s\' OR ' % (operator, delimiter[0], self.quote(word), delimiter[1])
            expr += 'FALSE)'
            list.append(expr)
        operator = ' OR '
        if all_words:
            operator = ' AND '
        if type_list:
            expression = 'type IN (\'%s\') AND (%s)' % (string.join(type_list, '\',\''), string.join(list, operator))
        else:
            expression = '%s' % (string.join(list, operator))
        where = "language='%s' AND owner='%s' AND %s" % (language, owner, expression)
        list = []
        try:
            for id in self._v_system.listids('text', where):
                list.append(self.gettext(id))
            for id in self._v_system.listids('content', where):
                list.append(self.getcontent(id))
        except Exception:
            self.rollback()
        return list


    def selectdocuments(self, list):
        list.sort(self._sortbydocument)
        c = 0
        if list:
            list[0] = self.getdocument(list[0].document)
            for i in range(1, len(list)):
                if list[c].id != list[i].document:
                    c = c+1
                    list[c] = self.getdocument(list[i].document)
            c = c+1
        return list[:c]


    def _sortbydocument(self, left, right):
        if left.document < right.document:
            return -1
        if left.document > right.document:
            return 1
        return 0


    def checkname(self, name):
        return self._v_system.getuser(name)['id']


    def name2id(self, name):
        return re.sub('[^\S\w\-]+', '_', name.strip()).lower()


    def list2dict(self, list, name='value'):
        dict = {}
        for item in list:
            dict[item['id']] = item[name]
        return dict


    def text2html(self, text):
        text = string.replace(text, '\r\n\r\n', '<p></p>')
        text = re.sub('\n[ \t\r]*<(/?)(ul|ol)([^>]*)>', '<\\1\\2\\3>', text)
        text = re.sub('\n[ \t\r]*<(/?)(ul|ol)([^>]*)>', '<\\1\\2\\3>', text)
        text = re.sub('<(/?)(ul|ol)([^>]*)>[ \t\r]*\n', '<\\1\\2\\3>', text)
        text = re.sub('<(/?)(ul|ol)([^>]*)>[ \t\r]*\n', '<\\1\\2\\3>', text)
        text = re.sub('\n[ \t\r]*<(/?)(li|p|table|tr|td|th|map)([^>]*)>', '<\\1\\2\\3>', text)
        text = re.sub('<(/?)(li|p|table|tr|td|th|map)([^>]*)>[ \t\r]*\n', '<\\1\\2\\3>', text)
        text = re.sub('\n[ \t\r]*<(br|hr|img|area)([^>]*)>', '<\\1\\2>', text)
        text = re.sub('<(br|hr|img|area)([^>]*)>[ \t\r]*\n', '<\\1\\2>', text)
        text = string.replace(text, '\r\n', '<br>')
        return text


    def plugin(self, extension):
        dict = {
            'adobe_reader': ('pdf',
                             'Adobe Reader',
                             'http://www.adobe.com/de/products/acrobat/'),
            'flash_player': ('swf',
                             'Adobe Flash Player',
                             'http://www.adobe.com/go/getflashplayer_de'),
            'java'        : ('jar class',
                             'Sun Java SE Runtime Environment (JRE)',
                             'http://java.com/de/download'),
            'shock_wave'  : ('sbl lob',
                             'Adobe Shockwave',
                             'http://www.adobe.com/shockwave/download/'),
            'real_audio'  : ('ram mpv awb r1m',
                             'Real Player',
                             'http://germany.real.com/player/'),
            'media_player': ('avi wmz rmi midi ivf ogm',
                             'Windows Media Player',
                             'http://update.microsoft.com/microsoftupdate/'),
            'quick_time'  : ('mov qt qtc qti qti qtif qtm qts',
                             'Apple Quicktime',
                             'http://www.apple.com/de/quicktime/download/'),
        }
        for key, value in dict.items():
            if extension in value[0].split():
                return (value[1], value[2])
        return None


    def test(self):
        return self.markup


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


def manage_add(self, id, title, REQUEST=None):
    """Add a new ZSite instance"""
    handle          = ZSite(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')