odoo_source/addons/website_mail_channel/controllers/main.py

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.

from datetime import datetime
from dateutil import relativedelta

from odoo import http, fields
from odoo.http import request
from odoo.addons.website.models.website import slug


class MailGroup(http.Controller):
    _thread_per_page = 20
    _replies_per_page = 10

    def _get_archives(self, group_id):
        MailMessage = request.env['mail.message']
        groups = MailMessage._read_group_raw(
            [('model', '=', 'mail.channel'), ('res_id', '=', group_id)], ['subject', 'date'],
            groupby=["date"], orderby="date desc")
        for group in groups:
            (r, label) = group['date']
            start, end = r.split('/')
            group['date'] = label
            group['date_begin'] = self._to_date(start)
            group['date_end'] = self._to_date(end)
        return groups

    def _to_date(self, dt):
        """ date is (of course) a datetime so start and end are datetime
        strings, but we just want date strings
        """
        return (datetime.datetime
            .strptime(dt, tools.DEFAULT_SERVER_DATETIME_FORMAT)
            .date() # may be unnecessary?
            .strftime(tools.DEFAULT_SERVER_DATE_FORMAT))

    @http.route("/groups", type='http', auth="public", website=True)
    def view(self, **post):
        groups = request.env['mail.channel'].search([('alias_id.alias_name', '!=', False)])

        # compute statistics
        month_date = datetime.today() - relativedelta.relativedelta(months=1)
        messages = request.env['mail.message'].read_group(
            [('model', '=', 'mail.channel'), ('date', '>=', fields.Datetime.to_string(month_date))],
            [], ['res_id'])
        message_data = dict((message['res_id'], message['res_id_count']) for message in messages)

        group_data = dict((group.id, {'monthly_message_nbr': message_data.get(group.id, 0)}) for group in groups)
        return request.website.render('website_mail_channel.mail_channels', {'groups': groups, 'group_data': group_data})

    @http.route(["/groups/is_member"], type='json', auth="public", website=True)
    def is_member(self, channel_id=0, **kw):
        """ Determine if the current user is member of the given channel_id
            :param channel_id : the channel_id to check
        """
        current_user = request.env.user
        session_partner_id = request.session.get('partner_id')
        public_user = request.website.user_id
        partner = None
        # find the current partner
        if current_user != public_user:
            partner = current_user.partner_id
        elif session_partner_id:
            partner = request.env['res.partner'].sudo().browse(session_partner_id)

        values = {
            'is_user': current_user != public_user,
            'email': partner.email if partner else "",
            'is_member': False,
            'alias_name': False,
        }
        # check if the current partner is member or not
        channel = request.env['mail.channel'].browse(int(channel_id))
        if channel.exists() and partner is not None:
            values['is_member'] = bool(partner in channel.sudo().channel_partner_ids)
        return values

    @http.route(["/groups/subscription"], type='json', auth="public", website=True)
    def subscription(self, channel_id=0, subscription="on", email='', **kw):
        """ Subscribe to a mailing list : this will create a partner with its email address (if public user not
            registered yet) and add it as channel member
            :param channel_id : the channel id to join/quit
            :param subscription : 'on' to unsubscribe the user, 'off' to subscribe
        """
        subscribe = subscription == 'on'
        channel = request.env['mail.channel'].browse(int(channel_id))
        partner_ids = []

        # search partner_id
        if request.env.user != request.website.user_id:
            partner_ids = request.env.user.partner_id.ids
        else:  # mail_thread method
            partner_ids = channel.sudo()._find_partner_from_emails([email], check_followers=True)
            if not partner_ids or not partner_ids[0]:
                name = email.split('@')[0]
                partner_ids = request.env['res.partner'].sudo().create({'name': name, 'email': email}).ids

        # add or remove channel members
        if subscribe:
            channel.check_access_rule('read')
            channel.sudo().write({'channel_partner_ids': [(3, partner_id) for partner_id in partner_ids]})
            return False
        else:  # add partner to the channel
            request.session['partner_id'] = partner_ids[0]
            channel.check_access_rule('read')
            channel.sudo().write({'channel_partner_ids': [(4, partner_id) for partner_id in partner_ids]})
        return True

    @http.route([
        "/groups/<model('mail.channel'):group>",
        "/groups/<model('mail.channel'):group>/page/<int:page>"
    ], type='http', auth="public", website=True)
    def thread_headers(self, group, page=1, mode='thread', date_begin=None, date_end=None, **post):
        Message = request.env['mail.message']

        domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id), ('message_type', '!=', 'notification')]
        if mode == 'thread':
            domain += [('parent_id', '=', False)]
        if date_begin and date_end:
            domain += [('date', '>=', date_begin), ('date', '<=', date_end)]

        pager = request.website.pager(
            url='/groups/%s' % slug(group),
            total=Message.search_count(domain),
            page=page,
            step=self._thread_per_page,
            url_args={'mode': mode, 'date_begin': date_begin or '', 'date_end': date_end or ''},
        )
        messages = Message.search(domain, limit=self._thread_per_page, offset=pager['offset'])
        values = {
            'messages': messages,
            'group': group,
            'pager': pager,
            'mode': mode,
            'archives': self._get_archives(group.id),
            'date_begin': date_begin,
            'date_end': date_end,
            'replies_per_page': self._replies_per_page,
        }
        return request.website.render('website_mail_channel.group_messages', values)

    @http.route([
        '''/groups/<model('mail.channel'):group>/<model('mail.message', "[('model','=','mail.channel'), ('res_id','=',group[0])]"):message>''',
    ], type='http', auth="public", website=True)
    def thread_discussion(self, group, message, mode='thread', date_begin=None, date_end=None, **post):
        Message = request.env['mail.message']
        if mode == 'thread':
            base_domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id), ('parent_id', '=', message.parent_id and message.parent_id.id or False)]
        else:
            base_domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id)]
        next_message = Message.search(base_domain + [('date', '<', message.date)], order="date DESC", limit=1) or None
        prev_message = Message.search(base_domain + [('date', '>', message.date)], order="date", limit=1) or None
        values = {
            'message': message,
            'group': group,
            'mode': mode,
            'archives': self._get_archives(group.id),
            'date_begin': date_begin,
            'date_end': date_end,
            'replies_per_page': self._replies_per_page,
            'next_message': next_message,
            'prev_message': prev_message,
        }
        return request.website.render('website_mail_channel.group_message', values)

    @http.route(
        '''/groups/<model('mail.channel'):group>/<model('mail.message', "[('model','=','mail.channel'), ('res_id','=',group[0])]"):message>/get_replies''',
        type='json', auth="public", methods=['POST'], website=True)
    def render_messages(self, group, message, **post):
        last_displayed_id = post.get('last_displayed_id')
        if not last_displayed_id:
            return False

        replies_domain = [('id', '<', int(last_displayed_id)), ('parent_id', '=', message.id)]
        messages = request.env['mail.message'].search(replies_domain, limit=self._replies_per_page)
        message_count = request.env['mail.message'].search_count(replies_domain)
        values = {
            'group': group,
            'thread_header': message,
            'messages': messages,
            'msg_more_count': message_count - self._replies_per_page,
            'replies_per_page': self._replies_per_page,
        }
        return request.env.ref('website_mail_channel.messages_short').render(values, engine='ir.qweb')

    @http.route("/groups/<model('mail.channel'):group>/get_alias_info", type='json', auth='public', website=True)
    def get_alias_info(self, group, **post):
        return {
            'alias_name': group.alias_id and group.alias_id.alias_name and group.alias_id.alias_domain and '%s@%s' % (group.alias_id.alias_name, group.alias_id.alias_domain) or False
        }