[MIG] website_mail: code migration to new api

No functional changes, only rewrite the code with
the api.v8 which more pythonic and smooth.

1 files changed, 53 insertions, 76 deletions

diff --git a/addons/website_mail/controllers/main.py b/addons/website_mail/controllers/main.py
index 64f11412aa1..ca7678a458e 100644
--- a/addons/website_mail/controllers/main.py
+++ b/addons/website_mail/controllers/main.py
@@ -4,9 +4,8 @@ from hashlib import sha1
 from time import time
 from werkzeug.exceptions import NotFound
 
-from openerp import SUPERUSER_ID
-from openerp.addons.web import http
-from openerp.addons.web.http import request
+from odoo import http
+from odoo.http import request
 
 
 def object_shasign(record=False, res_model='', res_id=None, **kw):
@@ -47,127 +46,105 @@ def _message_post_helper(res_model='', res_id=None, message='', token='', token_
 
         The rest of the kwargs are passed on to message_post()
     """
-    res = request.env[res_model].browse(res_id)
-    author_id = request.env.user.partner_id.id
-    if token and res and token == getattr(res.sudo(), token_field, None):
-        res = res.sudo()
-        if request.env.user == request.env['ir.model.data'].xmlid_to_object('base.public_user'):
-            author_id = (res.partner_id and res.partner_id.id) if hasattr(res, 'partner_id') else author_id
+    record = request.env[res_model].browse(res_id)
+    author_id = request.env.user.partner_id.id if request.env.user.partner_id else False
+    if token and record and token == getattr(record.sudo(), token_field, None):
+        record = record.sudo()
+        if request.env.user == request.env.ref('base.public_user'):
+            author_id = record.partner_id.id if hasattr(record, 'partner_id') else author_id
         else:
-            author_id = request.env.user.partner_id and request.env.user.partner_id.id
             if not author_id:
                 raise NotFound()
     elif sha_in:
         timestamp = int(sha_time)
-        secret = request.env['ir.config_parameter'].sudo().get_param('database.secret')
-        shasign = sha1('%s%s%s%s' % (res_model, res_id, secret, timestamp))
+        secret_sudo = request.env['ir.config_parameter'].sudo().get_param('database.secret')
+        shasign = sha1('%s%s%s%s' % (res_model, res_id, secret_sudo, timestamp))
         if sha_in == shasign.hexdigest() and int(time()) < timestamp + 3600 * 24:
-            res = res.sudo()
+            record = record.sudo()
         else:
             raise NotFound()
-    return res.with_context({'mail_create_nosubscribe': nosubscribe}).message_post(body=message,
-                                                                                   message_type=kw.pop('message_type', False) or "comment",
-                                                                                   subtype=kw.pop('subtype', False) or "mt_comment",
+    return record.with_context(mail_create_nosubscribe=nosubscribe).message_post(body=message,
+                                                                                   message_type=kw.pop('message_type', "comment"),
+                                                                                   subtype=kw.pop('subtype', "mt_comment"),
                                                                                    author_id=author_id,
                                                                                    **kw)
 
+
 class WebsiteMail(http.Controller):
 
     @http.route(['/website_mail/follow'], type='json', auth="public", website=True)
     def website_message_subscribe(self, id=0, object=None, message_is_follower="on", email=False, **post):
         # TDE FIXME: check this method with new followers
-        cr, uid, context = request.cr, request.uid, request.context
-
-        partner_obj = request.registry['res.partner']
-        user_obj = request.registry['res.users']
-
-        _id = int(id)
-        _message_is_follower = message_is_follower == 'on'
-        _object = request.registry[object]
+        res_id = int(id)
+        is_follower = message_is_follower == 'on'
+        record = request.env[object].browse(res_id)
 
         # search partner_id
-        public_id = request.website.user_id.id
-        if uid != public_id:
-            partner_ids = [user_obj.browse(cr, uid, uid, context).partner_id.id]
+        if request.env.user != request.website.user_id:
+            partner_ids = request.env.user.partner_id.ids
         else:
             # mail_thread method
-            partner_ids = _object._find_partner_from_emails(
-                cr, SUPERUSER_ID, [_id], [email], context=context, check_followers=True)
+            partner_ids = record.sudo()._find_partner_from_emails([email], check_followers=True)
             if not partner_ids or not partner_ids[0]:
                 name = email.split('@')[0]
-                partner_ids = [partner_obj.create(cr, SUPERUSER_ID, {'name': name, 'email': email}, context=context)]
-
+                partner_ids = request.env['res.partner'].sudo().create({'name': name, 'email': email}).ids
         # add or remove follower
-        if _message_is_follower:
-            _object.check_access_rule(cr, uid, [_id], 'read', context)
-            _object.message_unsubscribe(cr, SUPERUSER_ID, [_id], partner_ids, context=context)
+        if is_follower:
+            record.check_access_rule('read')
+            record.sudo().message_unsubscribe(partner_ids)
             return False
         else:
-            _object.check_access_rule(cr, uid, [_id], 'read', context)
+            record.check_access_rule('read')
             # add partner to session
             request.session['partner_id'] = partner_ids[0]
-            _object.message_subscribe(cr, SUPERUSER_ID, [_id], partner_ids, context=context)
+            record.sudo().message_subscribe(partner_ids)
             return True
 
     @http.route(['/website_mail/is_follower'], type='json', auth="public", website=True)
-    def call(self, model, id, **post):
-        id = int(id)
-        cr, uid, context = request.cr, request.uid, request.context
-
-        partner_obj = request.registry.get('res.partner')
-        users_obj = request.registry.get('res.users')
-        obj = request.registry.get(model)
-
-        partner_id = None
-        public_id = request.website.user_id.id
-        if uid != public_id:
-            partner_id = users_obj.browse(cr, SUPERUSER_ID, uid, context).partner_id
+    def is_follower(self, model, res_id, **post):
+        user = request.env.user
+        partner = None
+        public_user = request.website.user_id
+        if user != public_user:
+            partner = request.env.user.partner_id
         elif request.session.get('partner_id'):
-            partner_id = partner_obj.browse(cr, SUPERUSER_ID, request.session.get('partner_id'), context)
-        email = partner_id and partner_id.email or ""
+            partner = request.env['res.partner'].sudo().browse(request.session.get('partner_id'))
 
         values = {
-            'is_user': uid != public_id,
-            'email': email,
+            'is_user': user != public_user,
+            'email': partner.email if partner else "",
             'is_follower': False,
             'alias_name': False,
         }
 
-        if not obj:
-            return values
-        obj_ids = obj.exists(cr, SUPERUSER_ID, [id], context=context)
-        if obj_ids:
-            if partner_id:
-                values['is_follower'] = len(
-                    request.registry['mail.followers'].search(
-                        cr, SUPERUSER_ID, [
-                            ('res_model', '=', model),
-                            ('res_id', '=', obj_ids[0]),
-                            ('partner_id', '=', partner_id.id)
-                        ], context=context)) == 1
+        record = request.env[model].sudo().browse(int(res_id))
+        if record and partner:
+            values['is_follower'] = bool(request.env['mail.followers'].search_count([
+                ('res_model', '=', model),
+                ('res_id', '=', record.id),
+                ('partner_id', '=', partner.id)
+            ]))
         return values
 
     @http.route(['/website_mail/post/json'], type='json', auth='public', website=True)
     def chatter_json(self, res_model='', res_id=None, message='', **kw):
-        res_id = int(res_id)
         try:
-            msg = _message_post_helper(res_model, res_id, message, **kw)
-            data = {
-                'id': msg.id,
-                'body': msg.body,
-                'date': msg.date,
-                'author': msg.author_id.name,
-                'image_url': '/mail/%s/%s/avatar/%s' % (msg.model, msg.res_id, msg.author_id.id)
-            }
-            return data
+            msg = _message_post_helper(res_model, int(res_id), message, **kw)
         except Exception:
             return False
+        data = {
+            'id': msg.id,
+            'body': msg.body,
+            'date': msg.date,
+            'author': msg.author_id.name,
+            'image_url': '/mail/%s/%s/avatar/%s' % (msg.model, msg.res_id, msg.author_id.id)
+        }
+        return data
 
     @http.route(['/website_mail/post/post'], type='http', methods=['POST'], auth='public', website=True)
     def chatter_post(self, res_model='', res_id=None, message='', redirect=None, **kw):
-        res_id = int(res_id)
         url = request.httprequest.referrer
         if message:
-            message = _message_post_helper(res_model, res_id, message, **kw)
+            message = _message_post_helper(res_model, int(res_id), message, **kw)
             url = url + "#message-%s" % (message.id,)
         return request.redirect(url)