views.py

# -*- coding: UTF-8 -*-
# Copyright (C) 2010 Henry Obein <henry@itaapy.com>
#
# 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 3 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, see <http://www.gnu.org/licenses/>.

# Import from standard Library
from datetime import datetime

# Import from itools
from itools.core import freeze, merge_dicts
from itools.datatypes import Boolean, DateTime, Integer, String, Unicode
from itools.fs import FileName
from itools.gettext import MSG
from itools.handlers import checkid
from itools.html import stream_to_str_as_xhtml
from itools.rss import RSSFile
from itools.uri import get_reference, Path
from itools.web import get_context, BaseView, ERROR, FormError, STLView
from itools.xapian import AndQuery, RangeQuery, NotQuery, PhraseQuery, OrQuery

# Import from ikaaro
from ikaaro import messages
from ikaaro.buttons import Button
from ikaaro.buttons import RemoveButton, RenameButton, PublishButton
from ikaaro.buttons import RetireButton, CopyButton, CutButton, PasteButton
from ikaaro.file_views import File_NewInstance as BaseFile_NewInstance
from ikaaro.folder_views import Folder_BrowseContent, Folder_Rename
from ikaaro.folder_views import GoToSpecificDocument
from ikaaro.forms import AutoForm, TextWidget, HTMLBody, SelectRadio
from ikaaro.forms import FileWidget, description_widget, subject_widget
from ikaaro.forms import title_widget, timestamp_widget, rte_widget
from ikaaro.future.menu import Menu_View
from ikaaro.future.order import ResourcesOrderedTable_Ordered
from ikaaro.future.order import ResourcesOrderedTable_Unordered
from ikaaro.future.order import ResourcesOrderedTable_View
from ikaaro.registry import get_resource_class, get_document_types
from ikaaro.resource_ import DBResource
from ikaaro.resource_views import DBResource_AddImage, DBResource_AddMedia
from ikaaro.resource_views import DBResource_Edit, DBResource_AddLink
from ikaaro.text import CSS
from ikaaro.text_views import Text_Edit
from ikaaro.user import User
from ikaaro.utils import get_base_path_query
from ikaaro.views import CompositeForm
from ikaaro.views_new import NewInstance
from ikaaro.webpage import WebPage, HTMLEditView
from ikaaro.workflow import WorkflowAware

# Import from itws
from datatypes import StateEnumerate, StaticStateEnumerate, OrderBoxEnumerate
from utils import set_prefix_with_hostname, state_widget
from utils import get_warn_referenced_message



############################################################
# NewInstance
############################################################

class EasyNewInstance(NewInstance):
    """ ikaaro.views_new.NewInstance without field name.
    """
    template = '/ui/common/improve_auto_form.xml'
    actions = [Button(access='is_allowed_to_edit',
                      name='default', title=MSG(u'Add'))]

    query_schema = freeze({'type': String, 'title': Unicode})
    widgets = freeze([
        TextWidget('title', title=MSG(u'Title', mandatory=True))])

    goto_method = None

    def get_new_resource_name(self, form):
        # As we have no name, always return the title
        title = form['title'].strip()
        return title


    def get_actions(self, resource, context):
        return self.actions


    def _get_action_namespace(self, resource, context):
        # (1) Actions (submit buttons)
        actions = []
        for button in self.get_actions(resource, context):
            #if button.show(resource, context, []) is False:
            #    continue
            if button.confirm:
                confirm = button.confirm.gettext().encode('utf_8')
                onclick = 'return confirm("%s");' % confirm
            else:
                onclick = None
            actions.append(
                {'value': button.name,
                 'title': button.title,
                 'class': button.css,
                 'onclick': onclick})

        return actions


    def get_namespace(self, resource, context):
        namespace = NewInstance.get_namespace(self, resource, context)
        # actions namespace
        namespace['actions'] = self._get_action_namespace(resource, context)

        return namespace


    def _get_goto_method(self, resource, context, form):
        return self.goto_method


    def _get_goto(self, resource, context, form):
        name = form['name']
        goto_method = self._get_goto_method(resource, context, form)
        if goto_method:
            return './%s/;%s' % (name, goto_method)
        return './%s/' % name


    def action_default(self, resource, context, form):
        name = form['name']
        title = form['title']

        # Create the resource
        class_id = context.query['type']
        cls = get_resource_class(class_id)
        child = cls.make_resource(cls, resource, name)
        # The metadata
        metadata = child.metadata
        language = resource.get_content_language(context)
        metadata.set_property('title', title, language=language)

        goto = self._get_goto(resource, context, form)
        return context.come_back(messages.MSG_NEW_RESOURCE, goto=goto)



class ProxyContainerNewInstance(EasyNewInstance):

    query_schema = freeze({'title': Unicode})

    def _get_resource_cls(self, resource, context):
        raise NotImplementedError


    def _get_container(self, resource, context):
        raise NotImplementedError


    def _get_goto(self, resource, context, form):
        name = form['name']
        container = self._get_container(resource, context)
        goto_method = self._get_goto_method(resource, context, form)
        container_path = context.get_link(container)
        if goto_method:
            return '%s/%s/;%s' % (container_path, name, goto_method)
        return '%s/%s/' % (container_path, name)


    def _get_form(self, resource, context):
        form = AutoForm._get_form(self, resource, context)
        name = self.get_new_resource_name(form)

        # Check the name
        if not name:
            raise FormError, messages.MSG_NAME_MISSING

        try:
            name = checkid(name)
        except UnicodeEncodeError:
            name = None

        if name is None:
            raise FormError, messages.MSG_BAD_NAME

        # Check the name is free
        container = self._get_container(resource, context)
        if container.get_resource(name, soft=True) is not None:
            raise FormError, messages.MSG_NAME_CLASH

        # Ok
        form['name'] = name
        return form


    def get_title(self, context):
        cls = self._get_resource_cls(context.resource, context)
        class_title = cls.class_title.gettext()
        title = MSG(u'Add {class_title}')
        return title.gettext(class_title=class_title)


    def icon(self, resource, **kw):
        context = get_context()
        cls = self._get_resource_cls(context.resource, context)
        return cls.get_class_icon()


    def action_default(self, resource, context, form):
        name = form['name']
        title = form['title']

        # Create the resource
        cls = self._get_resource_cls(resource, context)
        container = self._get_container(resource, context)
        child = cls.make_resource(cls, container, name)
        # The metadata
        metadata = child.metadata
        language = resource.get_content_language(context)
        metadata.set_property('title', title, language=language)

        goto = self._get_goto(resource, context, form)
        return context.come_back(messages.MSG_NEW_RESOURCE, goto=goto)



class ProxyContainerProxyEasyNewInstance(EasyNewInstance):

    template = '/ui/common/proxy_improve_auto_form.xml'
    query_schema = freeze({'title': Unicode})
    schema = {
        'name': String,
        'title': Unicode,
        'class_id': String}

    def _get_resource_class_id(self, context):
        # Use in action method
        raise NotImplementedError


    def _get_resource_cls(self, resource, context):
        raise NotImplementedError


    def _get_container(self, resource, context):
        raise NotImplementedError


    def _get_goto(self, resource, context, form):
        name = form['name']
        container = self._get_container(resource, context)
        goto_method = self._get_goto_method(resource, context, form)
        container_path = context.get_link(container)
        if goto_method:
            return '%s/%s/;%s' % (container_path, name, goto_method)
        return '%s/%s/' % (container_path, name)


    def _get_form(self, resource, context):
        form = AutoForm._get_form(self, resource, context)
        name = self.get_new_resource_name(form)

        # Check the name
        if not name:
            raise FormError, messages.MSG_NAME_MISSING

        try:
            name = checkid(name)
        except UnicodeEncodeError:
            name = None

        if name is None:
            raise FormError, messages.MSG_BAD_NAME

        # Check the name is free
        container = self._get_container(resource, context)
        if container.get_resource(name, soft=True) is not None:
            raise FormError, messages.MSG_NAME_CLASH

        # Ok
        form['name'] = name
        return form


    def get_namespace(self, resource, context):
        namespace = NewInstance.get_namespace(self, resource, context)
        # actions namespace
        namespace['actions'] = self._get_action_namespace(resource, context)
        # proxy items
        type = self._get_resource_class_id(context)
        cls = get_resource_class(type)

        document_types = get_document_types(type)
        items = []
        if document_types:
            # Multiple types
            if len(document_types) == 1:
                items = None
            else:
                selected = context.get_form_value('class_id')
                items = [
                    {'title': cls.class_title,
                     'class_id': cls.class_id,
                     'selected': cls.class_id == selected,
                     'icon': '/ui/' + cls.class_icon16}
                    for cls in document_types ]
                if selected is None:
                    items[0]['selected'] = True
        namespace['items'] = items
        # class title
        namespace['class_title'] = cls.class_title

        return namespace


    def get_title(self, context):
        cls = self._get_resource_cls(context.resource, context)
        class_title = cls.class_title.gettext()
        title = MSG(u'Add {class_title}')
        return title.gettext(class_title=class_title)


    def icon(self, resource, **kw):
        context = get_context()
        cls = self._get_resource_cls(context.resource, context)
        return cls.get_class_icon()


    def action_default(self, resource, context, form):
        name = form['name']
        title = form['title']

        # Create the resource
        class_id = form['class_id']
        if class_id is None:
            class_id = self._get_resource_class_id(context)
        cls = get_resource_class(class_id)
        container = self._get_container(resource, context)
        child = cls.make_resource(cls, container, name)
        # The metadata
        metadata = child.metadata
        language = resource.get_content_language(context)
        metadata.set_property('title', title, language=language)

        goto = self._get_goto(resource, context, form)
        return context.come_back(messages.MSG_NEW_RESOURCE, goto=goto)



class BoxAwareNewInstance(ProxyContainerProxyEasyNewInstance):

    context_menus = []
    schema = merge_dicts(ProxyContainerProxyEasyNewInstance.schema,
                         class_id=String(mandatory=True))

    # configuration
    is_content = None
    is_side = None

    def get_title(self, context):
        return self.title


    def _get_resource_cls(self, resource, context):
        from repository import Box
        return Box


    def _get_container(self, resource, context):
        site_root = resource.get_site_root()
        repository = site_root.get_repository()
        return repository


    def get_namespace(self, resource, context):
        namespace = EasyNewInstance.get_namespace(self, resource, context)
        # actions namespace
        namespace['actions'] = self._get_action_namespace(resource, context)
        # proxy items
        site_root = resource.get_site_root()
        repository = site_root.get_repository()
        document_types = repository._get_document_types(
                is_content=self.is_content, is_side=self.is_side,
                allow_instanciation=True)
        selected = context.get_form_value('class_id')
        items = [
            {'title': cls.class_title,
             'description': cls.class_description,
             'class_id': cls.class_id,
             'selected': cls.class_id == selected,
             'icon': '/ui/' + cls.class_icon16}
            for cls in document_types ]
        if selected is None:
            items[0]['selected'] = True
        namespace['items'] = items
        # class title
        cls = self._get_resource_cls(resource, context)
        namespace['class_title'] = cls.class_title

        return namespace


    def action_default(self, resource, context, form):
        name = form['name']
        title = form['title']

        # Create the resource
        class_id = form['class_id']
        cls = get_resource_class(class_id)
        container = self._get_container(resource, context)
        child = cls.make_resource(cls, container, name)
        # The metadata
        metadata = child.metadata
        language = resource.get_content_language(context)
        metadata.set_property('title', title, language=language)

        goto = self._get_goto(resource, context, form)
        return context.come_back(messages.MSG_NEW_RESOURCE, goto=goto)



class BarAwareBoxAwareNewInstance(BoxAwareNewInstance):

    schema = merge_dicts(BoxAwareNewInstance.schema,
                         order=OrderBoxEnumerate(default='order-bottom'),
                         state=StaticStateEnumerate(default='public'))

    widgets = freeze(BoxAwareNewInstance.widgets
                     + [state_widget,
                        SelectRadio('order', title=MSG(u'Order box'),
                                    has_empty_option=False)])


    def _get_goto(self, resource, context, form):
        return context.get_link(resource)


    def action_default(self, resource, context, form):
        name = form['name']
        title = form['title']
        order = form['order']

        # Create the resource
        class_id = form['class_id']
        cls = get_resource_class(class_id)
        container = self._get_container(resource, context)
        child = cls.make_resource(cls, container, name)
        if order != 'do-not-order':
            if self.is_side:
                order_table = resource.get_resource(resource.sidebar_name)
            else:
                order_table = resource.get_resource(resource.contentbar_name)

            # Order child
            record = order_table.add_new_record({'name': name})
            if order == 'order-top':
                order_table.handler.order_top([record.id])
            else:
                order_table.handler.order_bottom([record.id])

        # The metadata
        metadata = child.metadata
        language = resource.get_content_language(context)
        metadata.set_property('title', title, language=language)
        if isinstance(child, WorkflowAware):
            child.set_property('state', form['state'])

        goto = self._get_goto(resource, context, form)
        return context.come_back(messages.MSG_NEW_RESOURCE, goto=goto)



class File_NewInstance(BaseFile_NewInstance):

    def get_schema(self, resource, context):
        schema = merge_dicts(BaseFile_NewInstance.schema,
                             state=StaticStateEnumerate(default='public'))
        del schema['name']
        return schema


    def get_widgets(self, resource, context):
        return [ title_widget,
                 FileWidget('file', title=MSG(u'File'), size=35),
                 state_widget ]


    def get_new_resource_name(self, form):
        # As we have no name, always return the title or get it from the file
        title = form['title'].strip()
        if not title:
            filename, mimetype, body = form['file']
            name, type, language = FileName.decode(filename)
        return title or name


    def action(self, resource, context, form):
        goto = BaseFile_NewInstance.action(self, resource, context, form)

        # Get the resource
        name = form['name']
        child = resource.get_resource(name)
        if isinstance(child, WorkflowAware):
            child.set_property('state', form['state'])

        # Ok
        return goto



############################################################
# Links
############################################################

class DBResource_Links(Folder_BrowseContent):
    """Links are the list of resources used by this resource."""

    access = 'is_allowed_to_edit'
    title = MSG(u"Links")
    icon = 'rename.png'

    query_schema = merge_dicts(Folder_BrowseContent.query_schema,
                               batch_size=Integer(default=0))

    search_template = None
    search_schema = {}


    def get_items(self, resource, context):
        links = resource.get_links()
        links = list(set(links))
        query = OrQuery(*[ PhraseQuery('abspath', link)
                           for link in links ])
        return context.root.search(query)


    def action_links_publish(self, resource, context, form):
        Folder_BrowseContent.action_publish(self, resource, context, form)


    def action_links_retire(self, resource, context, form):
        Folder_BrowseContent.action_retire(self, resource, context, form)


    table_actions = [PublishButton(name='links_publish'),
                     RetireButton(name='links_retire')]



class DBResource_Backlinks(DBResource_Links):
    """Backlinks are the list of resources pointing to this resource. This
    view answers the question "where is this resource used?" You'll see all
    WebPages (for example) referencing it. If the list is empty, you can
    consider it is "orphan".
    """

    title = MSG(u"Backlinks")
    query_schema = {}


    def get_table_columns(self, resource, context):
        cols = DBResource_Links.get_table_columns(self, resource, context)
        return [ col for col in cols if col[0] != 'checkbox' ]


    def get_items(self, resource, context):
        query = PhraseQuery('links', str(resource.get_canonical_path()))
        return context.root.search(query)


    table_actions = []



class DBResource_CompositeLinks(CompositeForm):

    title = MSG(u'Links/Backlinks')
    access = 'is_allowed_to_edit'
    template = '/ui/common/cascade.xml'
    subviews = [ DBResource_Links(), DBResource_Backlinks() ]


    def get_namespace(self, resource, context):
        views = []
        for view in self.subviews:
            views.append({'title': view.title,
                          'view': view.GET(resource, context)})
        return {'views': views}



def improve_addlink_action_upload(self, resource, context, form):
    filename, mimetype, body = form['file']
    name, type, language = FileName.decode(filename)

    # Check the filename is good
    title = form['title']
    name = checkid(title) if title else checkid(name)
    if name is None:
        context.message = messages.MSG_BAD_NAME
        return

    # Get the container
    container = context.root.get_resource(form['target_path'])

    # Check the name is free
    if container.get_resource(name, soft=True) is not None:
        context.message = messages.MSG_NAME_CLASH
        return

    # Check it is of the expected type
    cls = get_resource_class(mimetype)
    if not self.can_upload(cls):
        error = u'The given file is not of the expected type.'
        context.message = ERROR(error)
        return

    # Add the image to the resource
    cls.make_resource(cls, container, name, body, format=mimetype,
                      filename=filename, extension=type)
    # Get resource path
    child = container.get_resource(name)
    # Set title and state
    if title:
        language = container.get_content_language(context)
        child.set_property('title', title, language=language)
    child.set_property('state', form['state'])

    path = resource.get_pathto(child)
    # Add an action to the resource
    action = self.get_resource_action(context)
    if action:
        path = '%s%s' % (path, action)
    # Return javascript
    scripts = self.get_scripts(context)
    context.add_script(*scripts)
    return self.get_javascript_return(context, path)



class ImproveDBResource_AddLink(DBResource_AddLink):

    template = '/ui/common/addlink.xml'
    action_upload_schema = merge_dicts(DBResource_AddLink.action_upload_schema,
                                       title=Unicode, state=StaticStateEnumerate)
    action_add_resource_schema = merge_dicts(
            DBResource_AddLink.action_add_resource_schema,
            state=StaticStateEnumerate)

    def get_namespace(self, resource, context):
        namespace = DBResource_AddLink.get_namespace(self, resource, context)
        # add state widget
        widget = state_widget.to_html(StaticStateEnumerate, 'public')
        namespace['state_widget'] = list(widget)

        return namespace


    def action_upload(self, resource, context, form):
        return improve_addlink_action_upload(self, resource, context, form)


    def action_add_resource(self, resource, context, form):
        mode = form['mode']
        title = form['title']
        name = checkid(title)
        # Check name validity
        if name is None:
            context.message = MSG(u"Invalid title.")
            return
        # Get the container
        root = context.root
        container = root.get_resource(context.get_form_value('target_path'))
        # Check the name is free
        if container.get_resource(name, soft=True) is not None:
            context.message = messages.MSG_NAME_CLASH
            return
        # Get the type of resource to add
        cls = self.get_page_type(mode)
        # Create the resource
        child = cls.make_resource(cls, container, name)
        # Set state and title
        language = container.get_content_language(context)
        if title:
            child.set_property('title', title, language=language)
        child.set_property('state', form['state'])

        path = context.resource.get_pathto(child)
        scripts = self.get_scripts(context)
        context.add_script(*scripts)
        return self.get_javascript_return(context, path)



class ImproveDBResource_AddImage(DBResource_AddImage):

    template = '/ui/common/addimage.xml'
    action_upload_schema = merge_dicts(DBResource_AddLink.action_upload_schema,
                                       title=Unicode, state=StaticStateEnumerate)

    def get_namespace(self, resource, context):
        namespace = DBResource_AddImage.get_namespace(self, resource, context)
        # add state widget
        widget = state_widget.to_html(StaticStateEnumerate, 'public')
        namespace['state_widget'] = list(widget)

        return namespace


    def action_upload(self, resource, context, form):
        return improve_addlink_action_upload(self, resource, context, form)



class ImproveDBResource_AddMedia(DBResource_AddMedia):

    template = '/ui/common/addmedia.xml'
    action_upload_schema = merge_dicts(DBResource_AddMedia.action_upload_schema,
                                       title=Unicode, state=StaticStateEnumerate)

    def get_namespace(self, resource, context):
        namespace = DBResource_AddImage.get_namespace(self, resource, context)
        # add state widget
        widget = state_widget.to_html(StaticStateEnumerate, 'public')
        namespace['state_widget'] = list(widget)

        return namespace


    def action_upload(self, resource, context, form):
        return improve_addlink_action_upload(self, resource, context, form)



# Override DBResource backlinks view
DBResource.backlinks = DBResource_CompositeLinks()
DBResource.add_link = ImproveDBResource_AddLink()
DBResource.add_image = ImproveDBResource_AddImage()
DBResource.add_media = ImproveDBResource_AddMedia()

# Override User is_allowed_to_view
User.is_allowed_to_view = User.is_allowed_to_edit


############################################################
# CSS
############################################################

class CSS_Edit(Text_Edit):

    def get_widgets(self, resource, context):
        widgets = Text_Edit.get_widgets(self, resource, context)
        new_widgets = []
        for widget in widgets:
            if widget.name in ('timestamp', 'data'):
                new_widgets.append(widget)
        return new_widgets


    def action(self, resource, context, form):
        # Check edit conflict
        self.check_edit_conflict(resource, context, form)
        if context.edit_conflict:
            return

        if form['file'] is None:
            data = form['data']
            resource.handler.load_state_from_string(data)



CSS.edit = CSS_Edit()


############################################################
# Table
############################################################

class SmartOrderedTable_Ordered(ResourcesOrderedTable_Ordered):

    def get_table_columns(self, resource, context):
        func = ResourcesOrderedTable_Ordered.get_table_columns
        columns = func(self, resource, context)
        # Fix order_preview title
        new_columns = []
        for column in columns:
            if column[0] != 'order_preview':
                new_columns.append(column)
                continue
            if len(column) == 3:
                new_columns.append((column[0], MSG(u"Info"), column[2]))
            else:
                new_columns.append((column[0], MSG(u"Info")))
        return new_columns


    def get_title(self):
        context = get_context()
        resource = context.resource
        return getattr(resource, 'ordered_view_title', None)

    title = property(get_title)

    def get_title_description(self):
        context = get_context()
        resource = context.resource
        return getattr(resource, 'ordered_view_title_description', None)

    title = property(get_title)
    title_description = property(get_title_description)



class SmartOrderedTable_Unordered(ResourcesOrderedTable_Unordered):

    def get_table_columns(self, resource, context):
        func = ResourcesOrderedTable_Unordered.get_table_columns
        columns = func(self, resource, context)
        # Fix order_preview title
        new_columns = []
        for column in columns:
            if column[0] != 'order_preview':
                new_columns.append(column)
                continue
            if len(column) == 3:
                new_columns.append((column[0], MSG(u"Info"), column[2]))
            else:
                new_columns.append((column[0], MSG(u"Info")))
        return new_columns


    def get_title(self):
        context = get_context()
        resource = context.resource
        return getattr(resource, 'unordered_view_title', None)


    def get_title_description(self):
        context = get_context()
        resource = context.resource
        return getattr(resource, 'unordered_view_title_description', None)

    title = property(get_title)
    title_description = property(get_title_description)



class SmartOrderedTable_View(ResourcesOrderedTable_View):

    template = '/ui/common/order_view.xml'

    subviews = [ SmartOrderedTable_Ordered(),
                 SmartOrderedTable_Unordered() ]

    def get_namespace(self, resource, context):
        views = []
        for view in self.subviews:
            views.append({'title': view.title,
                          'description': view.title_description,
                          'view': view.GET(resource, context)})
        return {'views': views}



############################################################
# GoToSpecificItem
############################################################

class AdvanceGoToSpecificDocument(GoToSpecificDocument):

    title = MSG(u'View')
    keep_query = False
    keep_message = False

    def GET(self, resource, context):
        specific_document = self.get_specific_document(resource, context)
        specific_view = self.get_specific_view(resource, context)
        goto = '%s/%s' % (context.get_link(resource), specific_document)
        if specific_view:
            goto = '%s/;%s' % (goto, specific_view)
        goto = get_reference(goto)

        # Keep the query
        if self.keep_query and context.uri.query:
            goto.query = context.uri.query.copy()

        # Keep the message
        if self.keep_message:
            message = context.get_form_value('message')
            if message:
                goto = goto.replace(message=message)

        return goto



############################################################
# Footer
############################################################

class FooterMenu_View(Menu_View):

    access = 'is_allowed_to_edit'

    def get_item_value(self, resource, context, item, column):
        if column == 'html_content':
            value = resource.handler.get_record_value(item, column)
            return HTMLBody.decode(Unicode.encode(value))
        return Menu_View.get_item_value(self, resource, context, item, column)



############################################################
# Manage link view
############################################################

class BaseManageLink(STLView):

    template = '/ui/neutral/manage_link.xml'
    title = MSG(u'Manage view')

    def get_items(self, resource, context):
        items_list = [[]]

        return items_list


    def get_namespace(self, resource, context):
        items_list = self.get_items(resource, context)

        # Post process link
        # FIXME Does not work for absolute links
        here_link = Path(context.get_link(resource))
        for list in items_list:
            for item in list['items']:
                new_path = here_link.resolve2(item['path'])
                item['path'] = new_path
                disable = item.get('disable', False)
                item['disable'] = disable
                if disable:
                    item['class'] = '%s disable' % item['class']

        return {'lists': items_list, 'title': self.title}



class BaseManageContent(Folder_BrowseContent):

    access = 'is_allowed_to_edit'

    search_template = None

    table_actions = [
        RemoveButton, RenameButton, CopyButton, CutButton, PasteButton,
        PublishButton, RetireButton]

    table_columns = [
        ('checkbox', None),
        ('icon', None),
        ('name', MSG(u'Name')),
        ('title', MSG(u'Title')),
        ('format', MSG(u'Format')),
        ('mtime', MSG(u'Last Modified')),
        ('workflow_state', MSG(u'State')),
        ]

    def get_query_schema(self):
        return merge_dicts(Folder_BrowseContent.get_query_schema(self),
                           sort_by=String(default='mtime'),
                           reverse=Boolean(default=True))


    def get_items(self, resource, context, *args):
        return Folder_BrowseContent.get_items(self, resource, context, *args)


    def get_item_value(self, resource, context, item, column):
        brain, item_resource = item
        if column == 'name':
            return brain.name, context.get_link(item_resource)
        return Folder_BrowseContent.get_item_value(self, resource,
                  context, item, column)



class BaseManage_Rename(Folder_Rename):

    def action(self, resource, context, form):
        ret = Folder_Rename.action(self, resource, context, form)
        # Tweak goto
        ret.path = Path(';manage_view')
        return ret



############################################################
# Numeric batch
############################################################

class BrowseFormBatchNumeric(Folder_BrowseContent):

    batch_template = '/ui/common/browse_batch.xml'
    max_middle_pages = None

    def get_batch_namespace(self, resource, context, items):
        namespace = {}
        batch_start = context.query['batch_start']
        size = context.query['batch_size']
        uri = context.uri

        # Calcul nb_pages and current_page
        total = len(items)
        end = min(batch_start + size, total)
        nb_pages = total / size
        if total % size > 0:
            nb_pages += 1
        current_page = (batch_start / size) + 1

        namespace['control'] = nb_pages > 1

        # Message (singular or plural)
        total = len(items)
        if total == 1:
            namespace['msg'] = self.batch_msg1.gettext()
        else:
            namespace['msg'] = self.batch_msg2.gettext(n=total)

        # Add start & end value in namespace
        namespace['start'] = batch_start + 1
        namespace['end'] = end

        # See previous button ?
        if current_page != 1:
            previous = max(batch_start - size, 0)
            namespace['previous'] = uri.replace(batch_start=previous)
        else:
            namespace['previous'] = None

        # See next button ?
        if current_page < nb_pages:
            namespace['next'] = uri.replace(batch_start=batch_start+size)
        else:
            namespace['next'] = None

        # Add middle pages
        middle_pages = range(max(current_page - 3, 2),
                             min(current_page + 3, nb_pages-1) + 1)

        # Truncate middle pages if nedded
        if self.max_middle_pages:
            middle_pages_len = len(middle_pages)
            if middle_pages_len > self.max_middle_pages:
                delta = middle_pages_len - self.max_middle_pages
                delta_start = delta_end = delta / 2
                if delta % 2 == 1:
                    delta_end = delta_end +1
                middle_pages = middle_pages[delta_start:-delta_end]

        pages = [1] + middle_pages
        if nb_pages > 1:
            pages.append(nb_pages)

        namespace['pages'] = []
        for i in pages:
            namespace['pages'].append(
                {'number': i,
                 'css': 'current' if i == current_page else None,
                 'uri': uri.replace(batch_start=((i-1) * size))})

        # Add ellipsis if needed
        if nb_pages > 5:
            ellipsis = {'number': u'…',
                        'css': 'ellipsis',
                        'uri': None}
            if 2 not in middle_pages:
                namespace['pages'].insert(1, ellipsis)
            if (nb_pages - 1) not in middle_pages:
                namespace['pages'].insert(len(namespace['pages']) - 1,
                                          ellipsis)

        return namespace



############################################################
# RSS
############################################################

class BaseRSS(BaseView):

    access = True
    allowed_formats = freeze([])
    excluded_formats = freeze([])
    excluded_paths = freeze([])
    excluded_container_paths = freeze([])
    max_items_number = 20


    def get_base_query(self, resource, context):
        # Filter by website
        abspath = resource.get_site_root().get_canonical_path()
        query = [ get_base_path_query(str(abspath)) ]
        # Filter by pub_datetime
        today = datetime.now()
        min_date = datetime(1900, 1, 1)
        query.append(RangeQuery('pub_datetime', min_date, today))
        # Do not show image
        query.append(PhraseQuery('is_image', False))
        return query


    def get_allowed_formats(self, resource, context):
        return self.allowed_formats


    def get_excluded_formats(self, resource, context):
        return self.excluded_formats


    def get_excluded_paths(self, resource, context):
        return self.excluded_paths


    def get_excluded_container_paths(self, resource, context):
        return self.excluded_container_paths


    def get_max_items_number(self, resource, context):
        return self.max_items_number


    def get_if_modified_since_query(self, resource, context,
                                    if_modified_since):
        if not if_modified_since:
            return []
        return AndQuery(RangeQuery('pub_datetime', if_modified_since, None),
                        NotQuery(PhraseQuery('pub_datetime',
                                             if_modified_since)))


    def get_items(self, resource, context, if_modified_since=None):
        # Base query (workflow aware, image, state ...)
        query = self.get_base_query(resource, context)

        # Allowed formats
        formats = self.get_allowed_formats(resource, context)
        if formats:
            if len(formats) > 1:
                query2 = OrQuery(*[ PhraseQuery('format', format)
                                    for format in formats ])
            else:
                query2 = PhraseQuery('format', formats[0])
            query.append(query2)

        # Excluded formats
        excluded_formats = self.get_excluded_formats(resource, context)
        if excluded_formats:
            if len(excluded_formats) > 1:
                query2 = OrQuery(*[ PhraseQuery('format', format)
                                    for format in excluded_formats ])
            else:
                query2 = PhraseQuery('format', excluded_formats[0])
            query.append(NotQuery(query2))

        # Excluded paths
        excluded_paths = self.get_excluded_paths(resource, context)
        if excluded_paths:
            if len(excluded_paths) > 1:
                query2 = OrQuery(*[ PhraseQuery('abspath', str(path))
                                    for path in excluded_paths ])
            else:
                query2 = PhraseQuery('abspath', str(excluded_paths[0]))
            query.append(NotQuery(query2))

        # Excluded container paths
        excluded_cpaths = self.get_excluded_container_paths(resource, context)
        if excluded_cpaths:
            if len(excluded_cpaths) > 1:
                query2 = OrQuery(*[ get_base_path_query(str(path))
                                    for path in excluded_cpaths ])
            else:
                query2 = get_base_path_query(str(excluded_cpaths[0]))
            query.append(NotQuery(query2))

        # An If-Modified-Since ?
        query2 = self.get_if_modified_since_query(resource, context,
                                                  if_modified_since)
        if query2:
            query.append(query2)

        query = AndQuery(*query)
        return resource.get_root().search(query)


    def _sort_and_batch(self, resource, context, results):
        size = self.get_max_items_number(resource, context)
        items = results.get_documents(sort_by='pub_datetime',
                                      reverse=True, size=size)
        return items


    def sort_and_batch(self, resource, context, results):
        items = self._sort_and_batch(resource, context, results)

        # Access Control (FIXME this should be done before batch)
        user = context.user
        root = context.root
        allowed_items = []
        for item in items:
            abspath = item.abspath
            resource = root.get_resource(abspath)
            ac = resource.get_access_control()
            if ac.is_allowed_to_view(user, resource):
                allowed_items.append((item, resource))

        return allowed_items


    def get_mtime(self, resource):
        context = get_context()
        items = self.get_items(resource, context)
        items = self.sort_and_batch(resource, context, items)
        # FIXME If there is no modifications ?
        if not items:
            return
        last_brain = items[0][0]
        dow = last_brain.pub_datetime
        # date -> datetime
        return datetime(dow.year, dow.month, dow.day)


    def get_item_value(self, resource, context, item, column, site_root):
        brain, item_resource = item
        if column in ('link', 'guid'):
            value = context.uri.resolve(context.get_link(item_resource))
            return str(value)
        elif column == 'pubDate':
            return brain.pub_datetime
        elif column == 'title':
            return item_resource.get_title()
        elif column == 'description':
            if isinstance(item_resource, WebPage):
                data = item_resource.get_html_data()
                if data is None:
                    # Skip empty content
                    return ''
                # Set the prefix
                prefix = site_root.get_pathto(item_resource)
                data = set_prefix_with_hostname(data, '%s/' % prefix,
                                                uri=context.uri)
                data = stream_to_str_as_xhtml(data)
                return data.decode('utf-8')
            else:
                return item_resource.get_property('description')


    def GET(self, resource, context):
        language = context.get_query_value('language')
        if language is None:
            language = resource.get_content_language(context)
        if_modified_since = context.get_header('if-modified-since')
        items = self.get_items(resource, context, if_modified_since)
        items = self.sort_and_batch(resource, context, items)

        # Construction of the RSS flux
        feed = RSSFile()

        site_root = resource.get_site_root()
        host = context.uri.authority
        # The channel
        channel = feed.channel
        channel['title'] = site_root.get_property('title')
        channel['link'] = 'http://%s/?language=%s' % (host, language)
        channel['description'] = MSG(u'Last News').gettext()
        channel['language'] = language

        # The new items
        feed_items = feed.items
        for item in items:
            ns = {}
            for key in ('link', 'guid', 'title', 'pubDate', 'description'):
                ns[key] = self.get_item_value(resource, context, item, key,
                                              site_root)
            feed_items.append(ns)

        # Filename and Content-Type
        context.set_content_disposition('inline', "last_news.rss")
        context.set_content_type('application/rss+xml')
        return feed.to_str()



############################################################
# 404
############################################################

class NotFoundPage_Edit(HTMLEditView):

    schema = {
        'data': HTMLBody,
        'title': Unicode,
        'timestamp': DateTime(readonly=True)}

    widgets = [ timestamp_widget,
                title_widget,
                rte_widget ]

    def action(self, resource, context, form):
        # Check edit conflict
        self.check_edit_conflict(resource, context, form)
        if context.edit_conflict:
            return

        # Save changes
        title = form['title']
        language = resource.get_content_language(context)
        resource.set_property('title', title, language=language)
        new_body = form['data']
        handler = resource.get_handler(language=language)
        handler.set_body(new_body)
        # Ok
        context.message = messages.MSG_CHANGES_SAVED
        # Publish referenced resources which are not public/pending
        message2 = get_warn_referenced_message(resource, context, 'public')
        if message2:
            # Add custom message
            context.message = [ context.message, message2 ]



class AutomaticEditView(DBResource_Edit):

    base_schema = {'title': Unicode(multilingual=True),
                   'timestamp': DateTime(readonly=True, ignore=True)}

    # Add timestamp_widget in get_widgets method
    base_widgets = [title_widget]


    def get_schema(self, resource, context):
        schema = {}
        if isinstance(resource, WorkflowAware):
            schema['state'] = StateEnumerate
        if getattr(resource, 'edit_show_meta', False) is True:
            schema['description'] = Unicode(multilingual=True)
            schema['subject'] = Unicode(multilingual=True)
        return merge_dicts(self.base_schema, schema, resource.edit_schema)


    def get_widgets(self, resource, context):
        widgets = []
        if getattr(resource, 'edit_show_meta', False) is True:
            widgets.extend([description_widget, subject_widget])
        widgets = self.base_widgets + widgets + resource.edit_widgets
        # Add state widget in bottom
        if isinstance(resource, WorkflowAware):
            widgets.append(state_widget)
        # Add timestamp_widget
        widgets.append(timestamp_widget)
        return widgets


    def get_value(self, resource, context, name, datatype):
        if name == 'state':
            return resource.get_workflow_state()
        return DBResource_Edit.get_value(self, resource, context, name,
                                         datatype)


    def action(self, resource, context, form):
        self.check_edit_conflict(resource, context, form)
        # Check edit conflict
        if context.edit_conflict:
            return
        # Save changes
        language = resource.get_content_language(context)
        for key, datatype in self.get_schema(resource, context).items():
            if getattr(datatype, 'ignore', False) is True:
                continue
            elif getattr(datatype, 'multilingual', False) is True:
                resource.set_property(key, form[key], language=language)
            else:
                resource.set_property(key, form[key])
        # Ok
        context.message = messages.MSG_CHANGES_SAVED
        # Publish referenced resources which are not public/pending
        state = form.get('state', 'public')
        message2 = get_warn_referenced_message(resource, context, state)
        if message2:
            # Add custom message
            context.message = [ context.message, message2 ]