288 lines
13 KiB
Python
288 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
##############################################################################
|
|
#
|
|
# OpenERP, Open Source Management Solution
|
|
# Copyright (C) 2004-2012 Tiny SPRL (<http://tiny.be>).
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
|
|
from osv import fields, osv
|
|
import xmlrpclib
|
|
import string
|
|
import time
|
|
import random
|
|
from random import sample
|
|
from tools.translate import _
|
|
|
|
class event_moodle(osv.osv):
|
|
_name = 'event.moodle.config.wiz'
|
|
_columns = {
|
|
'moodle_username' : fields.char('Moodle Username', 128, help="You can also connect with your username that you define when you create a token"),
|
|
'moodle_password' : fields.char('Moodle Password', 128),
|
|
'moodle_token' : fields.char('Moodle Token', 128, help="Put your token that you created in your moodle server"),
|
|
'server_moodle': fields.char('Moodle Server', 128, required=True,help="URL where you have your moodle server. For exemple: 'http://127.0.0.1' or 'http://localhost'"),
|
|
'url': fields.char('URL to Moodle Server', size=256, help="The url that will be used for the connection with moodle in xml-rpc"),
|
|
}
|
|
|
|
_order = 'create_date desc'
|
|
|
|
_defaults = {
|
|
'server_moodle': 'http://127.0.0.1',
|
|
}
|
|
|
|
def configure_moodle(self, cr, uid, ids, context=None):
|
|
url = self.make_url(cr, uid, ids, context=context)
|
|
self.write(cr, uid, ids, {'url': url})
|
|
return {'type': 'ir.actions.act_window_close'}
|
|
|
|
def find(self, cr, uid, context=None):
|
|
"""
|
|
Find the config wizard containing the configuration and raise and error if none is available.
|
|
"""
|
|
moodle_config_wiz_ids = self.search(cr, uid, [], context=context)
|
|
if not moodle_config_wiz_ids:
|
|
raise osv.except_osv(('Error!'),("First configure your moodle connection."))
|
|
return moodle_config_wiz_ids[0]
|
|
|
|
def make_url(self, cr, uid, ids, context=None):
|
|
"""
|
|
create the good url with the information of the configuration
|
|
@return url for moodle connexion
|
|
"""
|
|
def _encode_password(password):
|
|
for i in range(len(password)):
|
|
x = password[i]
|
|
if x not in string.ascii_letters + string.digits:
|
|
unicode_car = (hex(ord(x)))
|
|
hex_car = '%'+str(unicode_car[2:])
|
|
password = password.replace(x,hex_car)
|
|
return password
|
|
url=""
|
|
config_moodle = self.browse(cr, uid, ids[0], context=context)
|
|
if config_moodle.moodle_username and config_moodle.moodle_password:
|
|
#connexion with password and username
|
|
password = _encode_password(config_moodle.moodle_password)
|
|
url = config_moodle.server_moodle + '/moodle/webservice/xmlrpc/simpleserver.php?wsusername=' + config_moodle.moodle_username + '&wspassword=' + password
|
|
if config_moodle.moodle_token:
|
|
#connexion with token
|
|
url = config_moodle.server_moodle + '/moodle/webservice/xmlrpc/server.php?wstoken=' + config_moodle.moodle_token
|
|
return url
|
|
|
|
def create_moodle_user(self, cr, uid, id, dic_user, context=None):
|
|
"""
|
|
create a moodle user
|
|
@param dic_user : is a list of dictonnaries with the moodle information
|
|
@return a liste of dictonaries with the create user id
|
|
"""
|
|
#connect to moodle
|
|
url = self.browse(cr, uid, id, context=context).url
|
|
sock = xmlrpclib.ServerProxy(url)
|
|
#add user in moodle and return list of id and username
|
|
return sock.core_user_create_users(dic_user)
|
|
|
|
def create_moodle_courses(self, cr, uid, id, courses, context=None):
|
|
"""
|
|
create a mmodle course
|
|
@param courses : is a list of dictionaries with the moodle course information
|
|
@return a list of dictionaries with the create course id
|
|
"""
|
|
#connect to moodle
|
|
url = self.browse(cr, uid, id, context=context).url
|
|
sock = xmlrpclib.ServerProxy(url)
|
|
return sock.core_course_create_courses(courses)
|
|
|
|
def moodle_enrolled(self, cr, uid, id, enrolled, context=None):
|
|
"""
|
|
this method is used to match a course with users
|
|
@param enrolled : list of dictonaries with the course id and the user id
|
|
"""
|
|
#connect to moodle
|
|
url = self.browse(cr, uid, id, context=context).url
|
|
sock = xmlrpclib.ServerProxy(url)
|
|
#add enrolled in moodle
|
|
sock.enrol_manual_enrol_users(enrolled)
|
|
|
|
def create_password(self):
|
|
"""
|
|
create a random password
|
|
"""
|
|
rand = string.ascii_letters + string.digits
|
|
length = 8
|
|
passwd = ''.join(sample(rand, length))
|
|
passwd = passwd + '+'
|
|
return passwd
|
|
|
|
def check_email(self,email):
|
|
|
|
"""
|
|
check if email is correct
|
|
"""
|
|
if email:
|
|
if (email.count('@') != 1 and email.count('.') < 1):
|
|
raise osv.except_osv(_('Error!'),_("Your email '%s' is wrong.") % (email))
|
|
|
|
def make_username(self, username, response_courses):
|
|
"""
|
|
create a moodle username with a random number for the uniqueness
|
|
@return the moodle username
|
|
"""
|
|
if username:
|
|
#remove space in the name
|
|
username = username.replace(" ","_")
|
|
#give an user name
|
|
name_user = username + "%d" % (response_courses,) + "%d" % (random.randint(1,999999),)
|
|
else:
|
|
name_user = "moodle_" + "%d" % (response_courses,) + "%d" % (random.randint(1,999999),)
|
|
return name_user
|
|
|
|
event_moodle()
|
|
|
|
class event_event(osv.osv):
|
|
_inherit = "event.event"
|
|
|
|
_columns={
|
|
'moodle_id': fields.integer('Moodle ID', help='The identifier of this event in Moodle'),
|
|
}
|
|
|
|
def check_registration_limits(self, cr, uid, ids, context=None):
|
|
"""
|
|
create moodle courses ,users and match them when an event is confirmed
|
|
if the event_registration is not confirmed then it doesn t nothing
|
|
"""
|
|
res = super(event_event, self).check_registration_limits(cr, uid, ids, context=context)
|
|
moodle_pool = self.pool.get('event.moodle.config.wiz')
|
|
moodle_config_wiz_id = moodle_pool.find(cr, uid, context=context)
|
|
list_users=[]
|
|
userid = []
|
|
for event in self.browse(cr, uid, ids, context=context):
|
|
#moodle use time() to store the date
|
|
date = time.strptime(event.date_begin, '%Y-%m-%d %H:%M:%S')
|
|
date = int (time.mktime(date))
|
|
#create the dict of values to create the course in Moodle
|
|
dic_courses= [{
|
|
'fullname': event.name,
|
|
'shortname': '',
|
|
'startdate': date,
|
|
'summary': event.note,
|
|
'categoryid':1, #the category hardcoded is 'Miscellaneous'
|
|
}]
|
|
#create a course in moodle and keep the id
|
|
response_courses = moodle_pool.create_moodle_courses(cr, uid, moodle_config_wiz_id, dic_courses, context=context)
|
|
self.write(cr, uid, event.id, {'moodle_id': response_courses[0]['id']})
|
|
|
|
moodle_uids = []
|
|
for registration in event.registration_ids:
|
|
if registration.state == 'open':
|
|
#enroll the registration in Moodle as it is confirmed
|
|
if not registration.moodle_uid:
|
|
#create a dictionary for an user
|
|
name_user = moodle_pool.make_username(registration.name, response_courses[0]['id'])
|
|
moodle_pool.check_email(registration.email)
|
|
passwd = moodle_pool.create_password()
|
|
dic_users={
|
|
'username' : name_user,
|
|
'password' : passwd,
|
|
'city' : registration.city,
|
|
'firstname' : registration.name ,
|
|
'lastname': '',
|
|
'email': registration.email
|
|
}
|
|
#create the user in moodle
|
|
response_user = moodle_pool.create_moodle_user(cr, uid, moodle_config_wiz_id, [dic_users], context=context)
|
|
for user in response_user:
|
|
self.pool.get('event.registration').write(cr,uid,[registration.id],{'moodle_uid': user['id'], 'moodle_user_password': passwd, 'moodle_username': name_user})
|
|
moodle_uids.append(user['id'])
|
|
else:
|
|
moodle_uids.append(registration.moodle_uid)
|
|
|
|
#link the course with users
|
|
enrolled = []
|
|
for moodle_user in moodle_uids:
|
|
enrolled.append({
|
|
'roleid' :'5', #mark as 'Student'
|
|
'userid' : moodle_user,
|
|
'courseid' :response_courses[0]['id']
|
|
})
|
|
moodle_pool.moodle_enrolled(cr, uid, moodle_config_wiz_id, enrolled, context=context)
|
|
return res
|
|
|
|
event_event()
|
|
|
|
class event_registration(osv.osv):
|
|
|
|
_inherit = "event.registration"
|
|
|
|
_columns={
|
|
'moodle_user_password': fields.char('Password for Moodle User', 128),
|
|
'moodle_username': fields.char('Moodle Username', 128),
|
|
'moodle_uid': fields.integer('Moodle User ID'),
|
|
}
|
|
|
|
def confirm_registration(self, cr, uid, ids, context=None):
|
|
"""
|
|
create a user and match to a course if the event is already confirmed
|
|
"""
|
|
res = super(event_registration, self).confirm_registration(cr, uid, ids, context=context)
|
|
moodle_pool = self.pool.get('event.moodle.config.wiz')
|
|
moodle_config_wiz_id = moodle_pool.find(cr, uid, context=context)
|
|
for register in self.browse(cr, uid, ids, context=context):
|
|
if register.event_id.state == 'confirm' and register.event_id.moodle_id:
|
|
if not register.moodle_uid:
|
|
#create the user in moodle
|
|
name_user = moodle_pool.make_username(register.name, register.event_id.moodle_id)
|
|
moodle_pool.check_email(register.email)
|
|
passwd = moodle_pool.create_password()
|
|
dic_users = [{
|
|
'username': name_user,
|
|
'password': passwd,
|
|
'city': register.city,
|
|
'firstname': register.name,
|
|
'lastname': '', #we could make a split of the register.name on ' ' but it would be inaccurate, so it seems better to let it empty as it's not really useful
|
|
'email': register.email,
|
|
}]
|
|
response_user = moodle_pool.create_moodle_user(cr, uid, moodle_config_wiz_id, dic_users, context=context)
|
|
#write in database the password and the username
|
|
moodle_user_id = response_user[0]['id']
|
|
self.pool.get('event.registration').write(cr, uid, ids, {'moodle_uid': moodle_user_id, 'moodle_user_password': passwd, 'moodle_username': name_user})
|
|
else:
|
|
moodle_user_id = register.moodle_uid
|
|
enrolled=[{
|
|
'roleid': '5', #mark as student
|
|
'userid': moodle_user_id,
|
|
'courseid': register.event_id.moodle_id
|
|
}]
|
|
moodle_pool.moodle_enrolled(cr, uid, moodle_config_wiz_id, enrolled, context=context)
|
|
return res
|
|
|
|
def onchange_moodle_name(self, cr, uid, ids, moodle_username, context=None):
|
|
"""
|
|
This onchange receive as parameter a username moddle and will fill the moodle_uid and password fields if existing records with this username are found
|
|
@param moodle_username: the existing moodle username
|
|
"""
|
|
res = {}
|
|
reg_ids = self.search(cr, uid, [('moodle_username', '=', moodle_username)], order='create_date desc', context=context)
|
|
if reg_ids:
|
|
reg = self.browse(cr, uid, reg_ids[0], context=context)
|
|
res = {'value' :{
|
|
'moodle_uid': reg.moodle_uid,
|
|
'name': reg.name,
|
|
'email':reg.email,
|
|
'phone':reg.phone,
|
|
'city': reg.city,
|
|
'street': reg.street}}
|
|
return res
|
|
event_registration()
|