427 lines
21 KiB
Python
427 lines
21 KiB
Python
# -*- coding: utf-8 -*-
|
|
import base64
|
|
import datetime
|
|
import logging
|
|
import time
|
|
import uuid
|
|
import random
|
|
|
|
import simplejson
|
|
|
|
import openerp
|
|
from openerp.http import request
|
|
from openerp.osv import osv, fields
|
|
from openerp.tools.misc import DEFAULT_SERVER_DATETIME_FORMAT
|
|
from openerp.addons.bus.bus import TIMEOUT
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
DISCONNECTION_TIMER = TIMEOUT + 5
|
|
AWAY_TIMER = 600 # 10 minutes
|
|
|
|
#----------------------------------------------------------
|
|
# Models
|
|
#----------------------------------------------------------
|
|
class im_chat_conversation_state(osv.Model):
|
|
""" Adds a state on the m2m between user and session. """
|
|
_name = 'im_chat.conversation_state'
|
|
_table = "im_chat_session_res_users_rel"
|
|
|
|
_columns = {
|
|
"state" : fields.selection([('open', 'Open'), ('folded', 'Folded'), ('closed', 'Closed')]),
|
|
"session_id" : fields.many2one('im_chat.session', 'Session', required=True, ondelete="cascade"),
|
|
"user_id" : fields.many2one('res.users', 'Users', required=True, ondelete="cascade"),
|
|
}
|
|
_defaults = {
|
|
"state" : 'open'
|
|
}
|
|
|
|
class im_chat_session(osv.Model):
|
|
""" Conversations."""
|
|
_order = 'id desc'
|
|
_name = 'im_chat.session'
|
|
_rec_name = 'uuid'
|
|
|
|
_columns = {
|
|
'uuid': fields.char('UUID', size=50, select=True),
|
|
'message_ids': fields.one2many('im_chat.message', 'to_id', 'Messages'),
|
|
'user_ids': fields.many2many('res.users', 'im_chat_session_res_users_rel', 'session_id', 'user_id', "Session Users"),
|
|
'session_res_users_rel': fields.one2many('im_chat.conversation_state', 'session_id', 'Relation Session Users'),
|
|
}
|
|
_defaults = {
|
|
'uuid': lambda *args: '%s' % uuid.uuid4(),
|
|
}
|
|
|
|
def is_in_session(self, cr, uid, uuid, user_id, context=None):
|
|
""" return if the given user_id is in the session """
|
|
sids = self.search(cr, uid, [('uuid', '=', uuid)], context=context, limit=1)
|
|
for session in self.browse(cr, uid, sids, context=context):
|
|
return user_id and user_id in [u.id for u in session.user_ids]
|
|
return False
|
|
|
|
def users_infos(self, cr, uid, ids, context=None):
|
|
""" get the user infos for all the user in the session """
|
|
for session in self.pool["im_chat.session"].browse(cr, uid, ids, context=context):
|
|
users_infos = self.pool["res.users"].read(cr, uid, [u.id for u in session.user_ids], ['id','name', 'im_status'], context=context)
|
|
return users_infos
|
|
|
|
def is_private(self, cr, uid, ids, context=None):
|
|
for session_id in ids:
|
|
""" return true if the session is private between users no external messages """
|
|
mess_ids = self.pool["im_chat.message"].search(cr, uid, [('to_id','=',session_id),('from_id','=',None)], context=context)
|
|
return len(mess_ids) == 0
|
|
|
|
def session_info(self, cr, uid, ids, context=None):
|
|
""" get the session info/header of a given session """
|
|
for session in self.browse(cr, uid, ids, context=context):
|
|
info = {
|
|
'uuid': session.uuid,
|
|
'users': session.users_infos(),
|
|
'state': 'open',
|
|
}
|
|
# add uid_state if available
|
|
if uid:
|
|
domain = [('user_id','=',uid), ('session_id','=',session.id)]
|
|
uid_state = self.pool['im_chat.conversation_state'].search_read(cr, uid, domain, ['state'], context=context)
|
|
if uid_state:
|
|
info['state'] = uid_state[0]['state']
|
|
return info
|
|
|
|
def session_get(self, cr, uid, user_to, context=None):
|
|
""" returns the canonical session between 2 users, create it if needed """
|
|
session_id = False
|
|
if user_to:
|
|
sids = self.search(cr, uid, [('user_ids','in', user_to),('user_ids', 'in', [uid])], context=context, limit=1)
|
|
for sess in self.browse(cr, uid, sids, context=context):
|
|
if len(sess.user_ids) == 2 and sess.is_private():
|
|
session_id = sess.id
|
|
break
|
|
else:
|
|
session_id = self.create(cr, uid, { 'user_ids': [(6,0, (user_to, uid))] }, context=context)
|
|
return self.session_info(cr, uid, [session_id], context=context)
|
|
|
|
def update_state(self, cr, uid, uuid, state=None, context=None):
|
|
""" modify the fold_state of the given session, and broadcast to himself (e.i. : to sync multiple tabs) """
|
|
domain = [('user_id','=',uid), ('session_id.uuid','=',uuid)]
|
|
ids = self.pool['im_chat.conversation_state'].search(cr, uid, domain, context=context)
|
|
for sr in self.pool['im_chat.conversation_state'].browse(cr, uid, ids, context=context):
|
|
if not state:
|
|
state = sr.state
|
|
if sr.state == 'open':
|
|
state = 'folded'
|
|
else:
|
|
state = 'open'
|
|
self.pool['im_chat.conversation_state'].write(cr, uid, ids, {'state': state}, context=context)
|
|
self.pool['bus.bus'].sendone(cr, uid, (cr.dbname, 'im_chat.session', uid), sr.session_id.session_info())
|
|
|
|
def add_user(self, cr, uid, uuid, user_id, context=None):
|
|
""" add the given user to the given session """
|
|
sids = self.search(cr, uid, [('uuid', '=', uuid)], context=context, limit=1)
|
|
for session in self.browse(cr, uid, sids, context=context):
|
|
if user_id not in [u.id for u in session.user_ids]:
|
|
self.write(cr, uid, [session.id], {'user_ids': [(4, user_id)]}, context=context)
|
|
# notify the all the channel users and anonymous channel
|
|
notifications = []
|
|
for channel_user_id in session.user_ids:
|
|
info = self.session_info(cr, channel_user_id.id, [session.id], context=context)
|
|
notifications.append([(cr.dbname, 'im_chat.session', channel_user_id.id), info])
|
|
# Anonymous are not notified when a new user is added : cannot exec session_info as uid = None
|
|
info = self.session_info(cr, openerp.SUPERUSER_ID, [session.id], context=context)
|
|
notifications.append([session.uuid, info])
|
|
self.pool['bus.bus'].sendmany(cr, uid, notifications)
|
|
# send a message to the conversation
|
|
user = self.pool['res.users'].read(cr, uid, user_id, ['name'], context=context)
|
|
self.pool["im_chat.message"].post(cr, uid, uid, session.uuid, "meta", user['name'] + " joined the conversation.", context=context)
|
|
|
|
def get_image(self, cr, uid, uuid, user_id, context=None):
|
|
""" get the avatar of a user in the given session """
|
|
#default image
|
|
image_b64 = 'R0lGODlhAQABAIABAP///wAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
|
|
# get the session
|
|
if user_id:
|
|
session_id = self.pool["im_chat.session"].search(cr, uid, [('uuid','=',uuid), ('user_ids','in', user_id)])
|
|
if session_id:
|
|
# get the image of the user
|
|
res = self.pool["res.users"].read(cr, uid, [user_id], ["image_small"])[0]
|
|
if res["image_small"]:
|
|
image_b64 = res["image_small"]
|
|
return image_b64
|
|
|
|
class im_chat_message(osv.Model):
|
|
""" Sessions messsages type can be 'message' or 'meta'.
|
|
For anonymous message, the from_id is False.
|
|
Messages are sent to a session not to users.
|
|
"""
|
|
_name = 'im_chat.message'
|
|
_order = "id desc"
|
|
_columns = {
|
|
'create_date': fields.datetime('Create Date', required=True, select=True),
|
|
'from_id': fields.many2one('res.users', 'Author'),
|
|
'to_id': fields.many2one('im_chat.session', 'Session To', required=True, select=True, ondelete='cascade'),
|
|
'type': fields.selection([('message','Message'), ('meta','Meta')], 'Type'),
|
|
'message': fields.char('Message'),
|
|
}
|
|
_defaults = {
|
|
'type' : 'message',
|
|
}
|
|
|
|
def init_messages(self, cr, uid, context=None):
|
|
""" get unread messages and old messages received less than AWAY_TIMER
|
|
ago and the session_info for open or folded window
|
|
"""
|
|
# get the message since the AWAY_TIMER
|
|
threshold = datetime.datetime.now() - datetime.timedelta(seconds=AWAY_TIMER)
|
|
threshold = threshold.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
|
|
domain = [('to_id.user_ids', 'in', [uid]), ('create_date','>',threshold)]
|
|
|
|
# get the message since the last poll of the user
|
|
presence_ids = self.pool['im_chat.presence'].search(cr, uid, [('user_id', '=', uid)], context=context)
|
|
if presence_ids:
|
|
presence = self.pool['im_chat.presence'].browse(cr, uid, presence_ids, context=context)[0]
|
|
threshold = presence.last_poll
|
|
domain.append(('create_date','>',threshold))
|
|
messages = self.search_read(cr, uid, domain, ['from_id','to_id','create_date','type','message'], order='id asc', context=context)
|
|
|
|
# get the session of the messages and the not-closed ones
|
|
session_ids = map(lambda m: m['to_id'][0], messages)
|
|
domain = [('user_id','=',uid), '|', ('state','!=','closed'), ('session_id', 'in', session_ids)]
|
|
session_rels_ids = self.pool['im_chat.conversation_state'].search(cr, uid, domain, context=context)
|
|
# re-open the session where a message have been recieve recently
|
|
session_rels = self.pool['im_chat.conversation_state'].browse(cr, uid, session_rels_ids, context=context)
|
|
|
|
reopening_session = []
|
|
notifications = []
|
|
for sr in session_rels:
|
|
si = sr.session_id.session_info()
|
|
si['state'] = sr.state
|
|
if sr.state == 'closed':
|
|
si['state'] = 'folded'
|
|
reopening_session.append(sr.id)
|
|
notifications.append([(cr.dbname,'im_chat.session', uid), si])
|
|
for m in messages:
|
|
notifications.append([(cr.dbname,'im_chat.session', uid), m])
|
|
self.pool['im_chat.conversation_state'].write(cr, uid, reopening_session, {'state': 'folded'}, context=context)
|
|
return notifications
|
|
|
|
def post(self, cr, uid, from_uid, uuid, message_type, message_content, context=None):
|
|
""" post and broadcast a message, return the message id """
|
|
message_id = False
|
|
Session = self.pool['im_chat.session']
|
|
session_ids = Session.search(cr, uid, [('uuid','=',uuid)], context=context)
|
|
notifications = []
|
|
for session in Session.browse(cr, uid, session_ids, context=context):
|
|
# build the new message
|
|
vals = {
|
|
"from_id": from_uid,
|
|
"to_id": session.id,
|
|
"type": message_type,
|
|
"message": message_content,
|
|
}
|
|
# save it
|
|
message_id = self.create(cr, uid, vals, context=context)
|
|
# broadcast it to channel (anonymous users) and users_ids
|
|
data = self.read(cr, uid, [message_id], ['from_id','to_id','create_date','type','message'], context=context)[0]
|
|
notifications.append([uuid, data])
|
|
for user in session.user_ids:
|
|
notifications.append([(cr.dbname, 'im_chat.session', user.id), data])
|
|
self.pool['bus.bus'].sendmany(cr, uid, notifications)
|
|
return message_id
|
|
|
|
def get_messages(self, cr, uid, uuid, last_id=False, limit=20, context=None):
|
|
""" get messages (id desc) from given last_id in the given session """
|
|
Session = self.pool['im_chat.session']
|
|
if Session.is_in_session(cr, uid, uuid, uid, context=context):
|
|
domain = [("to_id.uuid", "=", uuid)]
|
|
if last_id:
|
|
domain.append(("id", "<", last_id));
|
|
return self.search_read(cr, uid, domain, ['id', 'create_date','to_id','from_id', 'type', 'message'], limit=limit, context=context)
|
|
return False
|
|
|
|
|
|
class im_chat_presence(osv.Model):
|
|
""" im_chat_presence status can be: online, away or offline.
|
|
This model is a one2one, but is not attached to res_users to avoid database concurrence errors
|
|
"""
|
|
_name = 'im_chat.presence'
|
|
|
|
_columns = {
|
|
'user_id' : fields.many2one('res.users', 'Users', required=True, select=True, ondelete="cascade"),
|
|
'last_poll': fields.datetime('Last Poll'),
|
|
'last_presence': fields.datetime('Last Presence'),
|
|
'status' : fields.selection([('online','Online'), ('away','Away'), ('offline','Offline')], 'IM Status'),
|
|
}
|
|
_defaults = {
|
|
'last_poll' : fields.datetime.now,
|
|
'last_presence' : fields.datetime.now,
|
|
'status' : 'offline'
|
|
}
|
|
_sql_constraints = [('im_chat_user_status_unique','unique(user_id)', 'A user can only have one IM status.')]
|
|
|
|
def update(self, cr, uid, presence=True, context=None):
|
|
""" register the poll, and change its im status if necessary. It also notify the Bus if the status has changed. """
|
|
presence_ids = self.search(cr, uid, [('user_id', '=', uid)], context=context)
|
|
presences = self.browse(cr, uid, presence_ids, context=context)
|
|
# set the default values
|
|
send_notification = True
|
|
vals = {
|
|
'last_poll': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
|
|
'status' : presences and presences[0].status or 'offline'
|
|
}
|
|
# update the user or a create a new one
|
|
if not presences:
|
|
vals['status'] = 'online'
|
|
vals['user_id'] = uid
|
|
self.create(cr, uid, vals, context=context)
|
|
else:
|
|
if presence:
|
|
vals['last_presence'] = time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
|
|
vals['status'] = 'online'
|
|
else:
|
|
threshold = datetime.datetime.now() - datetime.timedelta(seconds=AWAY_TIMER)
|
|
if datetime.datetime.strptime(presences[0].last_presence, DEFAULT_SERVER_DATETIME_FORMAT) < threshold:
|
|
vals['status'] = 'away'
|
|
send_notification = presences[0].status != vals['status']
|
|
# write only if the last_poll is passed TIMEOUT, or if the status has changed
|
|
delta = datetime.datetime.now() - datetime.datetime.strptime(presences[0].last_poll, DEFAULT_SERVER_DATETIME_FORMAT)
|
|
if (delta > datetime.timedelta(seconds=TIMEOUT) or send_notification):
|
|
self.write(cr, uid, presence_ids, vals, context=context)
|
|
# avoid TransactionRollbackError
|
|
cr.commit()
|
|
# notify if the status has changed
|
|
if send_notification:
|
|
self.pool['bus.bus'].sendone(cr, uid, (cr.dbname,'im_chat.presence'), {'id': uid, 'im_status': vals['status']})
|
|
# gc : disconnect the users having a too old last_poll. 1 on 100 chance to do it.
|
|
if random.random() < 0.01:
|
|
self.check_users_disconnection(cr, uid, context=context)
|
|
return True
|
|
|
|
def check_users_disconnection(self, cr, uid, context=None):
|
|
""" disconnect the users having a too old last_poll """
|
|
dt = (datetime.datetime.now() - datetime.timedelta(0, DISCONNECTION_TIMER)).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
|
|
presence_ids = self.search(cr, uid, [('last_poll', '<', dt), ('status' , '!=', 'offline')], context=context)
|
|
self.write(cr, uid, presence_ids, {'status': 'offline'}, context=context)
|
|
presences = self.browse(cr, uid, presence_ids, context=context)
|
|
notifications = []
|
|
for presence in presences:
|
|
notifications.append([(cr.dbname,'im_chat.presence'), {'id': presence.user_id.id, 'im_status': presence.status}])
|
|
self.pool['bus.bus'].sendmany(cr, uid, notifications)
|
|
return True
|
|
|
|
class res_users(osv.Model):
|
|
_inherit = "res.users"
|
|
|
|
def _get_im_status(self, cr, uid, ids, fields, arg, context=None):
|
|
""" function computing the im_status field of the users """
|
|
r = dict((i, 'offline') for i in ids)
|
|
status_ids = self.pool['im_chat.presence'].search(cr, uid, [('user_id', 'in', ids)], context=context)
|
|
status = self.pool['im_chat.presence'].browse(cr, uid, status_ids, context=context)
|
|
for s in status:
|
|
r[s.user_id.id] = s.status
|
|
return r
|
|
|
|
_columns = {
|
|
'im_status' : fields.function(_get_im_status, type="char", string="IM Status"),
|
|
}
|
|
|
|
def im_search(self, cr, uid, name, limit=20, context=None):
|
|
""" search users with a name and return its id, name and im_status """
|
|
result = [];
|
|
# find the employee group
|
|
group_employee = self.pool['ir.model.data'].get_object_reference(cr, uid, 'base', 'group_user')[1]
|
|
|
|
where_clause_base = " U.active = 't' "
|
|
query_params = ()
|
|
if name:
|
|
where_clause_base += " AND P.name ILIKE %s "
|
|
query_params = query_params + ('%'+name+'%',)
|
|
|
|
# first query to find online employee
|
|
cr.execute('''SELECT U.id as id, P.name as name, COALESCE(S.status, 'offline') as im_status
|
|
FROM im_chat_presence S
|
|
JOIN res_users U ON S.user_id = U.id
|
|
JOIN res_partner P ON P.id = U.partner_id
|
|
WHERE '''+where_clause_base+'''
|
|
AND U.id != %s
|
|
AND EXISTS (SELECT 1 FROM res_groups_users_rel G WHERE G.gid = %s AND G.uid = U.id)
|
|
AND S.status = 'online'
|
|
ORDER BY P.name
|
|
LIMIT %s
|
|
''', query_params + (uid, group_employee, limit))
|
|
result = result + cr.dictfetchall()
|
|
|
|
# second query to find other online people
|
|
if(len(result) < limit):
|
|
cr.execute('''SELECT U.id as id, P.name as name, COALESCE(S.status, 'offline') as im_status
|
|
FROM im_chat_presence S
|
|
JOIN res_users U ON S.user_id = U.id
|
|
JOIN res_partner P ON P.id = U.partner_id
|
|
WHERE '''+where_clause_base+'''
|
|
AND U.id NOT IN %s
|
|
AND S.status = 'online'
|
|
ORDER BY P.name
|
|
LIMIT %s
|
|
''', query_params + (tuple([u["id"] for u in result]) + (uid,), limit-len(result)))
|
|
result = result + cr.dictfetchall()
|
|
|
|
# third query to find all other people
|
|
if(len(result) < limit):
|
|
cr.execute('''SELECT U.id as id, P.name as name, COALESCE(S.status, 'offline') as im_status
|
|
FROM res_users U
|
|
LEFT JOIN im_chat_presence S ON S.user_id = U.id
|
|
LEFT JOIN res_partner P ON P.id = U.partner_id
|
|
WHERE '''+where_clause_base+'''
|
|
AND U.id NOT IN %s
|
|
ORDER BY P.name
|
|
LIMIT %s
|
|
''', query_params + (tuple([u["id"] for u in result]) + (uid,), limit-len(result)))
|
|
result = result + cr.dictfetchall()
|
|
return result
|
|
|
|
#----------------------------------------------------------
|
|
# Controllers
|
|
#----------------------------------------------------------
|
|
class Controller(openerp.addons.bus.bus.Controller):
|
|
def _poll(self, dbname, channels, last, options):
|
|
if request.session.uid:
|
|
registry, cr, uid, context = request.registry, request.cr, request.session.uid, request.context
|
|
registry.get('im_chat.presence').update(cr, uid, options.get('im_presence', False), context=context)
|
|
## For performance issue, the real time status notification is disabled. This means a change of status are still braoadcasted
|
|
## but not received by anyone. Otherwise, all listening user restart their longpolling at the same time and cause a 'ConnectionPool Full Error'
|
|
## since there is not enought cursors for everyone. Now, when a user open his list of users, an RPC call is made to update his user status list.
|
|
##channels.append((request.db,'im_chat.presence'))
|
|
# channel to receive message
|
|
channels.append((request.db,'im_chat.session', request.uid))
|
|
return super(Controller, self)._poll(dbname, channels, last, options)
|
|
|
|
@openerp.http.route('/im_chat/init', type="json", auth="none")
|
|
def init(self):
|
|
registry, cr, uid, context = request.registry, request.cr, request.session.uid, request.context
|
|
notifications = registry['im_chat.message'].init_messages(cr, uid, context=context)
|
|
return notifications
|
|
|
|
@openerp.http.route('/im_chat/post', type="json", auth="none")
|
|
def post(self, uuid, message_type, message_content):
|
|
registry, cr, uid, context = request.registry, request.cr, request.session.uid, request.context
|
|
# execute the post method as SUPERUSER_ID
|
|
message_id = registry["im_chat.message"].post(cr, openerp.SUPERUSER_ID, uid, uuid, message_type, message_content, context=context)
|
|
return message_id
|
|
|
|
@openerp.http.route(['/im_chat/image/<string:uuid>/<string:user_id>'], type='http', auth="none")
|
|
def image(self, uuid, user_id):
|
|
registry, cr, context, uid = request.registry, request.cr, request.context, request.session.uid
|
|
# get the image
|
|
Session = registry.get("im_chat.session")
|
|
image_b64 = Session.get_image(cr, openerp.SUPERUSER_ID, uuid, simplejson.loads(user_id), context)
|
|
# built the response
|
|
image_data = base64.b64decode(image_b64)
|
|
headers = [('Content-Type', 'image/png')]
|
|
headers.append(('Content-Length', len(image_data)))
|
|
return request.make_response(image_data, headers)
|
|
|
|
@openerp.http.route(['/im_chat/history'], type="json", auth="none")
|
|
def history(self, uuid, last_id=False, limit=20):
|
|
registry, cr, uid, context = request.registry, request.cr, request.session.uid or openerp.SUPERUSER_ID, request.context
|
|
return registry["im_chat.message"].get_messages(cr, uid, uuid, last_id, limit, context=context)
|
|
|
|
# vim:et:
|