class SideBarCrossSellingBox(Folder):

    class_id = 'vertical-item-sidebar-cross-selling-box'
    class_version = '20090122'
    class_title = MSG(u'Vertical item cross selling')
    class_views = ['edit', 'configure']
    order_path = 'order-products'
    order_class = CrossSellingTable
    __fixed_handlers__ = [order_path]

    edit_schema = {}
    edit_widgets = []

    item_widgets = []

    edit = AutomaticEditView()
    view = SideBarCrossSellingBox_View()
    configure = GoToSpecificDocument(title=MSG(u'Configurer'),
                                     specific_document=order_path)

    @staticmethod
    def _make_resource(cls, folder, name, **kw):
        Folder._make_resource(cls, folder, name, **kw)
        order_class = cls.order_class
        order_class._make_resource(order_class, folder,
                                   '%s/%s' % (name, cls.order_path))

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(),
                           CrossSellingTable.get_metadata_schema())
Exemplo n.º 2
0
class Supplier(Folder):

    class_id = 'supplier'
    class_title = MSG(u'Supplier')
    class_views = ['edit']

    edit = AutomaticEditView()
    add_image = CurrentFolder_AddImage()

    # Edit views
    edit_schema = {
        'address': Unicode(mandatory=True),
        'phone': String,
        'fax': String,
        'email': Email,
        'description': Unicode(multilingual=True)
    }

    edit_widgets = [
        MultilineWidget('address', title=MSG(u'Address')),
        TextWidget('phone', title=MSG(u'Phone')),
        TextWidget('fax', title=MSG(u'Fax')),
        TextWidget('email', title=MSG(u'Email')),
        MultilineWidget('description', title=MSG(u'Description'))
    ]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(), cls.edit_schema)
Exemplo n.º 3
0
class Manufacturer(Folder):

    class_id = 'manufacturer'
    class_title = MSG(u'Manufacturer')
    class_views = ['view', 'edit']

    view = Manufacturer_View()
    edit = AutomaticEditView()
    add_image = CurrentFolder_AddImage()

    # Edit configuration
    edit_show_meta = True
    edit_schema = {
        'data': XHTMLBody(mandatory=True, multilingual=True),
        'photo': PathDataType(mandatory=True)
    }

    edit_widgets = [
        ImageSelectorWidget('photo', title=MSG(u'Photo')),
        RTEWidget('data', title=MSG(u'Data'))
    ]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(),
                           data=XHTMLBody(multilingual=True),
                           photo=PathDataType)
Exemplo n.º 4
0
class ShopModule_Advertising_Ad(ShopFolder):

    class_id = 'shop_module_advertising_ad'
    class_title = MSG(u'Advertising, an Ad')
    class_views = ['edit']

    edit = AutomaticEditView()

    edit_schema = {'code': XHTMLBody(sanitize_html=False)}
    edit_widgets = [MultilineWidget('code', title=MSG(u'Code'))]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(ShopFolder.get_metadata_schema(), cls.edit_schema)
Exemplo n.º 5
0
class CrossSelling_Section(Folder):
    """
    XXX That should be a section_view on 0.62
    """

    class_id = 'section-cross-selling'
    class_title = MSG(u'Cross Selling Section')
    class_views = ['view', 'edit']

    view = CrossSelling_Section_View()
    edit = AutomaticEditView()

    # Edit views
    edit_schema = {'product_model': ProductModelsEnumerate}

    edit_widgets = [
        SelectWidget('product_model', title=MSG(u'Product model')),
    ]
Exemplo n.º 6
0
class ShopForm(OrderedTable):

    class_id = 'shop-form'
    class_title = MSG(u'Shop form')
    class_version = '20090609'
    class_handler = ShopFormTable
    class_views = ['display', 'edit', 'view', 'add_record']

    display = ShopForm_Display()
    view = OrderedTable_View(search_template=None, access='is_admin')
    edit = AutomaticEditView()

    add_product = AddProduct_View()

    form = [
        TextWidget('name', title=MSG(u'Name')),
        TextWidget('title', title=MSG(u'Title')),
        BooleanCheckBox('mandatory', title=MSG(u'Mandatory')),
        BooleanCheckBox('multiple', title=MSG(u'Multiple')),
        SelectWidget('datatype', title=MSG(u'Data Type')),
        SelectWidget('widget', title=MSG(u'Widget')),
    ]

    edit_widgets = [
        TextWidget('submit_value', title=MSG(u'Submit value')),
        TextWidget('to_addr', title=MSG(u'To addr')),
        RTEWidget('introduction', title=MSG(u'Introduction')),
        RTEWidget('final_message', title=MSG(u'Final message')),
        BooleanRadio('must_be_authentificated',
                     title=MSG(u'Must be authentificated to see form'))
    ]

    edit_schema = {
        'submit_value': Unicode(multilingual=True, mandatory=True),
        'to_addr': Email(mandatory=True),
        'introduction': XHTMLBody(multilingual=True),
        'final_message': XHTMLBody(multilingual=True),
        'must_be_authentificated': Boolean
    }

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(OrderedTable.get_metadata_schema(), cls.edit_schema)
Exemplo n.º 7
0
class Filter_Criterium_Categorie(Folder):

    class_id = 'sidebar-item-filter-box-criterium-categorie'
    class_title = MSG(u'Catégorie criterium')
    class_views = ['edit']

    edit = AutomaticEditView(access='is_admin')
    edit_show_meta = False
    edit_schema = {'base_abspath': CategoriesEnumerate(mandatory=True)}
    edit_widgets = [SelectWidget('base_abspath', title=MSG(u'Base Abspath'))]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(),
                           base_abspath=CategoriesEnumerate)

    def get_items(self, context):
        options = []
        root = get_context().root
        base_abspath = self.get_property('base_abspath')
        base_resource = root.get_resource(base_abspath)
        search = root.search(format='category', parent_paths=base_abspath)
        items_list = [base_resource]
        for brain in search.get_documents(sort_by='abspath'):
            items_list.append(root.get_resource(brain.abspath))
        for resource in items_list:
            abspath = str(resource.get_abspath())
            selected = context.resource.get_abspath() == abspath
            uri = get_reference(context.get_link(resource))
            uri.query = context.uri.query
            title = resource.get_title()
            if abspath == base_abspath:
                title = MSG(u'All')
            options.append({
                'name': abspath,
                'criterium': 'category',
                'query': PhraseQuery('parent_paths', abspath),
                'selected': selected,
                'uri': uri,
                'css': 'selected' if selected else None,
                'title': title
            })
        return options
Exemplo n.º 8
0
class Filter_Criterium(Folder):

    class_id = 'sidebar-item-filter-box-criterium'
    class_title = MSG(u'Criterium')
    class_views = ['edit']

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(),
                           criterium=Filter_DFT_Enumerate)

    edit = AutomaticEditView(access='is_admin')
    edit_show_meta = False
    edit_schema = {'criterium': Filter_DFT_Enumerate(mandatory=True)}
    edit_widgets = [SelectWidget('criterium', title=MSG(u'Criterium'))]

    def get_items(self, context):
        options = []
        uri = deepcopy(context.uri)
        criterium = self.get_property('criterium')
        criterium_name = 'DFT-%s' % criterium
        enum = EnumerateTable_to_Enumerate(enumerate_name=criterium)
        options = []
        for option in [{
                'name': None,
                'value': MSG(u'All')
        }] + enum.get_options():
            selected = context.query.get(criterium_name) == option['name']
            option['criterium'] = criterium
            kw = {criterium_name: option['name'], 'batch_start': 0}
            option['uri'] = uri.replace(**kw)
            option['query'] = None
            if option['name']:
                option['query'] = PhraseQuery(criterium_name, option['name'])
            option['selected'] = selected
            option['title'] = option['value']
            option['css'] = 'selected' if selected else None
            options.append(option)
        return options
Exemplo n.º 9
0
class ShopUser_Group(ShopFolder):

    class_id = 'user-group'
    class_views = ['edit', 'goto_categories', 'register', 'schema', 'welcome']
    class_version = '20100719'
    class_title = MSG(u'User group')

    edit = AutomaticEditView()
    schema = GoToSpecificDocument(specific_document='schema',
                                  title=MSG(u'Schema'))
    welcome = GoToSpecificDocument(specific_document='welcome',
                                  title=MSG(u'Edit welcome page'))
    goto_categories = GoToSpecificDocument(
            specific_document='../../../categories',
            title=MSG(u'Revenir aux catégories'))
    register = Group_Register()

    edit_schema = {'register_title': Unicode(multilingual=True),
                   'register_body': XHTMLBody(multilingual=True),
                   'register_mail_subject': Unicode(multilingual=True),
                   'register_mail_body': Unicode(multilingual=True),
                   'validation_mail_subject': Unicode(multilingual=True),
                   'validation_mail_body': Unicode(multilingual=True),
                   'invalidation_mail_subject': Unicode(multilingual=True),
                   'invalidation_mail_body': Unicode(multilingual=True),
                   'hide_address_on_registration': Boolean,
                   'user_is_enabled_when_register': Boolean,
                   'use_default_price': Boolean,
                   'show_ht_price': Boolean,
                   'phone_is_mandatory_on_registration': Boolean,
                   'lastname_is_mandatory_on_registration': Boolean}

    edit_widgets = [TextWidget('register_title', title=MSG(u'Register view title ?')),
                    RTEWidget('register_body', title=MSG(u'Register body')),
                    TextWidget('register_mail_subject', title=MSG(u'Register mail subject')),
                    MultilineWidget('register_mail_body', title=MSG(u'Register mail body')),
                    TextWidget('validation_mail_subject', title=MSG(u'Validation mail subject')),
                    MultilineWidget('validation_mail_body', title=MSG(u'Validation mail body')),
                    TextWidget('invalidation_mail_subject', title=MSG(u'Invalidation mail subject')),
                    MultilineWidget('invalidation_mail_body', title=MSG(u'Invalidation mail body')),
                    BooleanRadio('hide_address_on_registration', title=MSG(u'Hide address on registration')),
                    BooleanRadio('user_is_enabled_when_register', title=MSG(u'User is enabled ?')),
                    BooleanRadio('use_default_price', title=MSG(u'Use default price ?')),
                    BooleanRadio('show_ht_price', title=MSG(u'Show HT price ?')),
                    BooleanRadio('lastname_is_mandatory_on_registration', title=MSG(u'Lastname is mandatory on registration ?')),
                    BooleanRadio('phone_is_mandatory_on_registration', title=MSG(u'Phone is mandatory on registration ?'))]



    __fixed_handlers__ = ShopFolder.__fixed_handlers__ + ['welcome']


    @staticmethod
    def _make_resource(cls, folder, name, *args, **kw):
        # Create group
        ShopFolder._make_resource(cls, folder, name, *args, **kw)
        # Group schema
        cls = CustomerSchema
        cls._make_resource(cls, folder, '%s/schema' % name)
        # Welcome Page
        cls = WebPage
        cls._make_resource(cls, folder, '%s/welcome' % name,
                                title={'en': u'Welcome'},
                                state='public')

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(ShopFolder.get_metadata_schema(),
                           cls.edit_schema)


    def get_dynamic_schema(self):
        schema = self.get_resource('schema')
        return schema.get_model_schema()


    def get_dynamic_widgets(self):
        schema = self.get_resource('schema')
        return schema.get_model_widgets()


    def get_register_mail_subject(self):
        subject = self.get_property('register_mail_subject')
        if subject:
            return subject
        return MSG(u"Inscription confirmation.").gettext()


    def get_register_mail_body(self):
        body = self.get_property('register_mail_body')
        if body:
            return body
        return MSG(u"Your inscription has been validated").gettext()


    def get_prefix(self):
        # Price prefix
        # XXX for future we should add group property to price
        if self.name == 'default':
            return ''
        return '%s-' % self.name
Exemplo n.º 10
0
class ShopModule_AReview(WorkflowAware, Folder):

    class_id = 'shop_module_a_review'
    class_title = MSG(u'A review')
    class_views = ['view']

    view = ShopModule_AReview_View()
    viewbox = Review_Viewbox()
    add_report = ShopModule_AReport_NewInstance()

    # Edition
    edit = AutomaticEditView(access='is_admin')
    edit_show_meta = False
    display_title = False
    edit_schema = {
        'title': Unicode,
        'note': NoteEnumerate,
        'advantages': Unicode,
        'disadvantages': Unicode,
        'description': Unicode,
        'recommended': RecommandationEnumerate
    }

    edit_widgets = [
        TextWidget('title', title=MSG(u'Title')),
        NoteWidget('note', title=MSG(u'Note'), has_empty_option=False),
        TextWidget('advantages', title=MSG(u'Advantages')),
        TextWidget('disadvantages', title=MSG(u'Disadvantages')),
        MultilineWidget('description', title=MSG(u'Your review')),
        SelectRadio('recommended',
                    title=MSG(u'Recommendation'),
                    has_empty_option=False,
                    is_inline=True)
    ]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Folder.get_metadata_schema(),
                           WorkflowAware.get_metadata_schema(),
                           ctime=DateTime,
                           note=Integer(default=0),
                           remote_ip=String,
                           author=String,
                           advantages=Unicode,
                           disadvantages=Unicode,
                           images=String,
                           recommended=RecommandationEnumerate)

    def _get_catalog_values(self):
        values = Folder._get_catalog_values(self)
        values['ctime'] = self.get_property('ctime')
        values['shop_module_review_author'] = self.get_property('author')
        values['shop_module_review_note'] = self.get_property('note')
        # XXX description is multilingual in the DB (xml:lang=xx)
        values['shop_module_review_description'] = self.get_property(
            'description')
        return values

    def get_namespace(self, context):
        # Build namespace
        namespace = {
            'author': self.get_namespace_author(context),
            'href': context.get_link(self),
            'images': self.get_images(context)
        }
        for key in ['title', 'note', 'advantages', 'disadvantages']:
            namespace[key] = self.get_property(key)
        # Add informations about product
        product = self.parent.parent
        namespace['product'] = {
            'link': context.get_link(product),
            'title': product.get_title()
        }
        # Context
        here = context.resource
        namespace['is_on_user_view'] = here.class_id == 'user'
        namespace['is_on_product_view'] = here.class_id == 'product'
        # Description
        description = self.get_property('description').encode('utf-8')
        description = XMLContent.encode(description)
        namespace['description'] = XMLParser(description.replace(
            '\n', '<br/>'))
        # ctime
        ctime = self.get_property('ctime')
        accept = context.accept_language
        namespace['ctime'] = format_datetime(ctime, accept)
        # Recommendation
        recommended = self.get_property('recommended') or 0
        namespace['recommendation'] = bool(int(recommended))

        return namespace

    def get_namespace_author(self, context):
        if self.get_property('author') is None:
            return None
        from shop.utils import ResourceDynamicProperty
        author = self.get_property('author')
        author_resource = context.root.get_resource('/users/%s' % author)
        dynamic_user_value = ResourceDynamicProperty()
        dynamic_user_value.resource = author_resource
        return {
            'title': author_resource.get_title(),
            'public_title': author_resource.get_public_title(),
            'dynamic_user_value': dynamic_user_value,
            'href': context.get_link(author_resource)
        }

    def get_images(self, context, nb_images=None):
        path = self.get_property('images')
        if not path:
            return []
        image = self.get_resource(path, soft=True)
        if image is None:
            return []
        images = []
        images.append({'src': context.get_link(image)})
        return images
Exemplo n.º 11
0
 def set_value(self, resource, context, name, form):
     if name == 'update_now':
         resource.update_rss()
         return
     return AutomaticEditView.set_value(self, resource, context, name, form)
Exemplo n.º 12
0
 def get_value(self, resource, context, name, datatype):
     if name == 'update_now':
         return False
     return AutomaticEditView.get_value(self, resource, context, name,
                                        datatype)
Exemplo n.º 13
0
class Category(ShopFolder):

    class_id = 'category'
    class_title = MSG(u'Category')

    # Edit configuration
    edit_show_meta = True
    edit_schema = {
        'data': XHTMLBody(multilingual=True),
        'breadcrumb_title': Unicode(multilingual=True),
        'image_category': ImagePathDataType(multilingual=True),
        'default_product_cover': ImagePathDataType(multilingual=True)
    }

    edit_widgets = [
        TextWidget('breadcrumb_title', title=MSG(u'Breadcrumb title')),
        ImageSelectorWidget('image_category', title=MSG(u'Category image')),
        ImageSelectorWidget('default_product_cover',
                            title=MSG(u'Default cover for products')),
        RTEWidget('data', title=MSG(u"Description"))
    ]

    # Views
    view = Category_View()
    browse_content = Products_View()
    view_categories = Category_BackofficeView()
    edit = AutomaticEditView()
    batch_edition = Category_BatchEdition()
    new_product = Product_NewProduct()
    new_category = NewCategory_Form()
    comparator = Category_Comparator()

    @property
    def class_views(self):
        context = get_context()
        # Back-Office
        hostname = context.uri.authority
        if hostname[:6] == 'admin.':
            return [
                'browse_content', 'new_product', 'view_categories',
                'new_category', 'edit'
            ]
        return ['view', 'edit']

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(
            ShopFolder.get_metadata_schema(),
            data=XHTMLBody(multilingual=True),
            breadcrumb_title=Unicode(multilingual=True),
            image_category=ImagePathDataType(multilingual=True),
            default_product_cover=ImagePathDataType(multilingual=True))

    def _get_catalog_values(self):
        # Get the languages
        site_root = self.get_site_root()
        languages = site_root.get_property('website_languages')
        # Titles
        m_title = {}
        m_breadcrumb_title = {}
        for language in languages:
            value = self.get_property('title', language=language)
            if value:
                m_title[language] = value
            value = self.get_property('breadcrumb_title', language=language)
            if value:
                m_breadcrumb_title[language] = value
        # Data
        data = self.get_property('data')
        if data is not None:
            data = xml_to_text(data)
        return merge_dicts(
            super(Category, self)._get_catalog_values(),
            data=data,
            # XXX Hack to be on sitemap
            workflow_state='public',
            m_title=m_title,
            m_breadcrumb_title=m_breadcrumb_title)

    def get_document_types(self):
        return [Product, Category]

    ####################################
    # Computed fields
    ####################################
    computed_schema = {
        'nb_products': Integer(title=MSG(u'Nb products')),
        'nb_categories': Integer(title=MSG(u'Nb sub categories'))
    }

    def get_nb_products(self, only_public=False):
        root = self.get_root()
        shop = get_shop(self)
        abspath = self.get_canonical_path()
        query = [
            PhraseQuery('parent_paths', str(abspath)),
            PhraseQuery('format', shop.product_class.class_id)
        ]
        if shop.get_property('hide_not_buyable_products') is True:
            context = get_context()
            group_name = get_group_name(shop, context)
            query.append(
                NotQuery(PhraseQuery('not_buyable_by_groups', group_name)))
        if only_public is True:
            query.append(PhraseQuery('workflow_state', 'public'))
        return len(root.search(AndQuery(*query)))

    def get_nb_categories(self):
        root = self.get_root()
        abspath = self.get_canonical_path()
        query = AndQuery(PhraseQuery('parent_paths', str(abspath)),
                         PhraseQuery('format', 'category'))
        return len(root.search(query))

    @property
    def nb_products(self):
        return self.get_nb_products()

    @property
    def nb_categories(self):
        return self.get_nb_categories()

    #############################
    # Export
    #############################
    export = Export(export_resource=Product,
                    access='is_allowed_to_edit',
                    file_columns=[
                        'reference', 'state', 'frontoffice_uri', 'cover_uri',
                        'manufacturer', 'price_with_tax', 'description'
                    ])
Exemplo n.º 14
0
class FilterRange_Table(Table):

    class_id = 'table-filter-by-price'
    # XXX We can change name
    class_title = MSG(u'Filter by range')
    class_handler = FilterRange_BaseTable

    form = [
        TextWidget('min', title=MSG(u'Min')),
        TextWidget('max', title=MSG(u'Max'))
    ]

    edit = AutomaticEditView(access='is_admin')
    edit_show_meta = False
    edit_schema = {
        'unit': Unicode,
        'criterium': FilterRange_Enumerate(mandatory=True)
    }
    edit_widgets = [
        SelectWidget('criterium', title=MSG(u'Criterirum')),
        TextWidget('unit', title=MSG(u'Unit'))
    ]

    @classmethod
    def get_metadata_schema(cls):
        return merge_dicts(Table.get_metadata_schema(),
                           criterium=FilterRange_Enumerate,
                           unit=Unicode)

    def get_items(self, context):
        unit = self.get_property('unit')
        criterium = self.get_property('criterium')
        uri = context.uri
        options = []
        get_record_value = self.handler.get_record_value
        # Get values
        values = [(None, None)]
        for record in self.handler.get_records():
            min_value = get_record_value(record, 'min')
            max_value = get_record_value(record, 'max')
            values.append((min_value, max_value))
        for value in values:
            min_value, max_value = value
            min_value_q = int(min_value * 100) if min_value else None
            max_value_q = int(max_value * 100) if max_value else None
            value = (min_value_q, max_value_q)
            name = IntegerRange.encode(value)
            if min_value is None and max_value:
                title = MSG(u'Less than {max_value} {unit}')
            elif min_value and max_value:
                title = MSG(u'From {min_value} to {max_value} {unit}')
            elif max_value is None and min_value:
                title = MSG(u'More than {min_value} {unit}')
            else:
                title = MSG(u'All')
                name = None
                value = None
            selected = context.query.get(criterium) == value
            kw = {criterium: name, 'batch_start': 0}
            uri = uri.replace(**kw)
            title = title.gettext(min_value=min_value,
                                  max_value=max_value,
                                  unit=unit)
            options.append({
                'name':
                name,
                'criterium':
                criterium,
                'query':
                RangeQuery(criterium, min_value_q, max_value_q),
                'selected':
                selected,
                'uri':
                uri,
                'css':
                'selected' if selected else None,
                'title':
                title
            })
        return options
Exemplo n.º 15
0
 def action(self, resource, context, form):
     AutomaticEditView.action(self, resource, context, form)
     if not context.edit_conflict and form['force_update']:
         resource._update_data()