# -*- coding: utf-8 -*-
-import base64, glob, os, re
+
+import base64
+import csv
+import glob
+import operator
+import os
+import re
+import simplejson
+import textwrap
+import xmlrpclib
from xml.etree import ElementTree
from cStringIO import StringIO
-import simplejson
+import cherrypy
import openerpweb
import openerpweb.ast
import openerpweb.nonliterals
-import cherrypy
+from babel.messages.pofile import read_po
# Should move to openerpweb.Xml2Json
class Xml2Json:
files_concat = "".join(files_content)
return files_concat
+home_template = textwrap.dedent("""<!DOCTYPE html>
+<html style="height: 100%%">
+ <head>
+ <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+ <title>OpenERP</title>
+ %(javascript)s
+ <script type="text/javascript">
+ $(function() {
+ QWeb = new QWeb2.Engine();
+ openerp.init().base.webclient("oe");
+ });
+ </script>
+ <link rel="shortcut icon" href="/base/static/src/img/favicon.ico" type="image/x-icon"/>
+ %(css)s
+ <!--[if lte IE 7]>
+ <link rel="stylesheet" href="/base/static/src/css/base-ie7.css" type="text/css"/>
+ <![endif]-->
+ </head>
+ <body id="oe" class="openerp"></body>
+</html>
+""")
class WebClient(openerpweb.Controller):
_cp_path = "/base/webclient"
return concat
@openerpweb.httprequest
- def home(self, req):
- template ="""<!DOCTYPE html>
- <html style="height: 100%%">
- <head>
- <meta http-equiv="content-type" content="text/html; charset=utf-8" />
- <title>OpenERP</title>
- %s
- <script type="text/javascript">
- $(function() {
- QWeb = new QWeb2.Engine();
- openerp.init().base.webclient("oe");
- });
- </script>
- <link rel="shortcut icon" href="/base/static/src/img/favicon.ico" type="image/x-icon"/>
- %s
- <!--[if lte IE 7]>
- <link rel="stylesheet" href="/base/static/src/css/base-ie7.css" type="text/css"/>
- <![endif]-->
- </head>
- <body id="oe" class="openerp"></body>
- </html>
- """.replace('\n'+' '*8,'\n')
-
+ def home(self, req, s_action=None):
# script tags
jslist = ['/base/webclient/js']
if 1: # debug == 1
jslist = manifest_glob(['base'], 'js')
- js = "\n ".join(['<script type="text/javascript" src="%s"></script>'%i for i in jslist])
+ js = "\n ".join(['<script type="text/javascript" src="%s"></script>'%i for i in jslist])
# css tags
csslist = ['/base/webclient/css']
if 1: # debug == 1
csslist = manifest_glob(['base'], 'css')
- css = "\n ".join(['<link rel="stylesheet" href="%s">'%i for i in csslist])
- r = template % (js, css)
+ css = "\n ".join(['<link rel="stylesheet" href="%s">'%i for i in csslist])
+ r = home_template % {
+ 'javascript': js,
+ 'css': css
+ }
return r
+
+ @openerpweb.jsonrequest
+ def translations(self, req, mods, lang):
+ transs = {}
+ for addon_name in mods:
+ transl = {"messages":[]}
+ transs[addon_name] = transl
+ f_name = os.path.join(openerpweb.path_addons, addon_name, "po", lang + ".po")
+ if not os.path.exists(f_name):
+ continue
+ try:
+ with open(f_name) as t_file:
+ po = read_po(t_file)
+ except:
+ continue
+ for x in po:
+ if x.id:
+ transl["messages"].append({'id': x.id, 'string': x.string})
+ return {"modules": transs}
+
class Database(openerpweb.Controller):
_cp_path = "/base/database"
@openerpweb.jsonrequest
- def get_databases_list(self, req):
+ def get_list(self, req):
proxy = req.session.proxy("db")
dbs = proxy.list()
h = req.httprequest.headers['Host'].split(':')[0]
d = h.split('.')[0]
- r = cherrypy.config['openerp.dbfilter'].replace('%h',h).replace('%d',d)
- print "h,d",h,d,r
- dbs = [i for i in dbs if re.match(r,i)]
+ r = cherrypy.config['openerp.dbfilter'].replace('%h', h).replace('%d', d)
+ dbs = [i for i in dbs if re.match(r, i)]
return {"db_list": dbs}
+ @openerpweb.jsonrequest
+ def progress(self, req, password, id):
+ return req.session.proxy('db').get_progress(password, id)
+
+ @openerpweb.jsonrequest
+ def create(self, req, fields):
+
+ params = dict(map(operator.itemgetter('name', 'value'), fields))
+ create_attrs = (
+ params['super_admin_pwd'],
+ params['db_name'],
+ bool(params.get('demo_data')),
+ params['db_lang'],
+ params['create_admin_pwd']
+ )
+
+ try:
+ return req.session.proxy("db").create(*create_attrs)
+ except xmlrpclib.Fault, e:
+ if e.faultCode and e.faultCode.split(':')[0] == 'AccessDenied':
+ return {'error': e.faultCode, 'title': 'Create Database'}
+ return {'error': 'Could not create database !', 'title': 'Create Database'}
+
+ @openerpweb.jsonrequest
+ def drop(self, req, fields):
+ password, db = operator.itemgetter(
+ 'drop_pwd', 'drop_db')(
+ dict(map(operator.itemgetter('name', 'value'), fields)))
+
+ try:
+ return req.session.proxy("db").drop(password, db)
+ except xmlrpclib.Fault, e:
+ if e.faultCode and e.faultCode.split(':')[0] == 'AccessDenied':
+ return {'error': e.faultCode, 'title': 'Drop Database'}
+ return {'error': 'Could not drop database !', 'title': 'Drop Database'}
+
+ @openerpweb.httprequest
+ def backup(self, req, backup_db, backup_pwd, token):
+ try:
+ db_dump = base64.decodestring(
+ req.session.proxy("db").dump(backup_pwd, backup_db))
+ cherrypy.response.headers['Content-Type'] = "application/octet-stream; charset=binary"
+ cherrypy.response.headers['Content-Disposition'] = 'attachment; filename="' + backup_db + '.dump"'
+ cherrypy.response.cookie['fileToken'] = token
+ cherrypy.response.cookie['fileToken']['path'] = '/'
+ return db_dump
+ except xmlrpclib.Fault, e:
+ if e.faultCode and e.faultCode.split(':')[0] == 'AccessDenied':
+ return 'Backup Database|' + e.faultCode
+ return 'Backup Database|Could not generate database backup'
+
+ @openerpweb.httprequest
+ def restore(self, req, db_file, restore_pwd, new_db):
+ try:
+ data = base64.encodestring(db_file.file.read())
+ req.session.proxy("db").restore(restore_pwd, new_db, data)
+ return ''
+ except xmlrpclib.Fault, e:
+ if e.faultCode and e.faultCode.split(':')[0] == 'AccessDenied':
+ raise cherrypy.HTTPError(403)
+
+ raise cherrypy.HTTPError()
+
+ @openerpweb.jsonrequest
+ def change_password(self, req, fields):
+ old_password, new_password = operator.itemgetter(
+ 'old_pwd', 'new_pwd')(
+ dict(map(operator.itemgetter('name', 'value'), fields)))
+ try:
+ return req.session.proxy("db").change_admin_password(old_password, new_password)
+ except xmlrpclib.Fault, e:
+ if e.faultCode and e.faultCode.split(':')[0] == 'AccessDenied':
+ return {'error': e.faultCode, 'title': 'Change Password'}
+ return {'error': 'Error, password not changed !', 'title': 'Change Password'}
+
class Session(openerpweb.Controller):
_cp_path = "/base/session"
@openerpweb.jsonrequest
def login(self, req, db, login, password):
req.session.login(db, login, password)
+ ctx = req.session.get_context()
return {
"session_id": req.session_id,
"uid": req.session._uid,
+ "context": ctx
}
@openerpweb.jsonrequest
req.session.eval_context(req.context))
@openerpweb.jsonrequest
+ def get_lang_list(self, req):
+ try:
+ return {
+ 'lang_list': (req.session.proxy("db").list_lang() or []),
+ 'error': ""
+ }
+ except Exception, e:
+ return {"error": e, "title": "Languages"}
+
+ @openerpweb.jsonrequest
def modules(self, req):
# TODO query server for installed web modules
mods = []
context, domain = eval_context_and_domain(req.session,
openerpweb.nonliterals.CompoundContext(*(contexts or [])),
openerpweb.nonliterals.CompoundDomain(*(domains or [])))
-
+
group_by_sequence = []
for candidate in (group_by_seq or []):
ctx = req.session.eval_context(candidate, context)
group_by_sequence.append(group_by)
else:
group_by_sequence.extend(group_by)
-
+
return {
'context': context,
'domain': domain,
This method store an action object in the session object and returns an integer
identifying that action. The method get_session_action() can be used to get
back the action.
-
+
:param the_action: The action to save in the session.
:type the_action: anything
:return: A key identifying the saved action.
"""
Gets back a previously saved action. This method can return None if the action
was saved since too much time (this case should be handled in a smart way).
-
+
:param key: The key given by save_session_action()
:type key: integer
:return: The saved action or None.
return None
return saved_actions["actions"].get(key)
+ @openerpweb.jsonrequest
+ def check(self, req):
+ req.session.assert_valid()
+ return None
+
def eval_context_and_domain(session, context, domain=None):
e_context = session.eval_context(context)
# should we give the evaluated context as an evaluation context to the domain?
Values = req.session.model('ir.values')
actions = Values.get(key, key2, models, meta, context)
- return [(id, name, clean_action(action, req.session))
+ return [(id, name, clean_action(action, req.session, context=context))
for id, name, action in actions]
-def clean_action(action, session):
+def clean_action(action, session, context=None):
+ action.setdefault('flags', {})
if action['type'] != 'ir.actions.act_window':
return action
# values come from the server, we can just eval them
- if isinstance(action.get('context', None), basestring):
+ if isinstance(action.get('context'), basestring):
action['context'] = eval(
action['context'],
- session.evaluation_context()) or {}
+ session.evaluation_context(context=context)) or {}
- if isinstance(action.get('domain', None), basestring):
+ if isinstance(action.get('domain'), basestring):
action['domain'] = eval(
action['domain'],
session.evaluation_context(
action.get('context', {}))) or []
- if 'flags' not in action:
- # Set empty flags dictionary for web client.
- action['flags'] = dict()
+
return fix_view_modes(action)
def generate_views(action):
menu_items = Menus.read(menu_ids, ['name', 'sequence', 'parent_id'], context)
menu_root = {'id': False, 'name': 'root', 'parent_id': [-1, '']}
menu_items.append(menu_root)
-
+
# make a tree using parent_id
menu_items_map = dict((menu_item["id"], menu_item) for menu_item in menu_items)
for menu_item in menu_items:
:rtype: list
"""
Model = request.session.model(model)
+
context, domain = eval_context_and_domain(
request.session, request.context, domain)
@openerpweb.jsonrequest
+ def read(self, request, model, ids, fields=False):
+ return self.do_search_read(request, model, ids, fields)
+
+ @openerpweb.jsonrequest
def get(self, request, model, ids, fields=False):
return self.do_get(request, model, ids, fields)
+
def do_get(self, request, model, ids, fields=False):
""" Fetches and returns the records of the model ``model`` whose ids
are in ``ids``.
record_map = dict((record['id'], record) for record in records)
return [record_map[id] for id in ids if record_map.get(id)]
-
+
@openerpweb.jsonrequest
def load(self, req, model, id, fields):
m = req.session.model(model)
Model = req.session.model(model)
return Model.default_get(fields, req.session.eval_context(req.context))
+ @openerpweb.jsonrequest
+ def name_search(self, req, model, search_str, domain=[], context={}):
+ m = req.session.model(model)
+ r = m.name_search(search_str+'%', domain, '=ilike', context)
+ return {'result': r}
+
class DataGroup(openerpweb.Controller):
_cp_path = "/base/group"
@openerpweb.jsonrequest
""" Parses an arbitrary string containing a domain, transforms it
to either a literal domain or a :class:`openerpweb.nonliterals.Domain`
- :param domain: the domain to parse, if the domain is not a string it is assumed to
- be a literal domain and is returned as-is
+ :param domain: the domain to parse, if the domain is not a string it
+ is assumed to be a literal domain and is returned as-is
:param session: Current OpenERP session
:type session: openerpweb.openerpweb.OpenERPSession
"""
except ValueError:
# not a literal
return openerpweb.nonliterals.Domain(session, domain)
-
+
def parse_context(self, context, session):
""" Parses an arbitrary string containing a context, transforms it
to either a literal context or a :class:`openerpweb.nonliterals.Context`
- :param context: the context to parse, if the context is not a string it is assumed to
- be a literal domain and is returned as-is
+ :param context: the context to parse, if the context is not a string it
+ is assumed to be a literal domain and is returned as-is
:param session: Current OpenERP session
:type session: openerpweb.openerpweb.OpenERPSession
"""
return clean_action(req.session.model('ir.actions.server').run(
[action_id], req.session.eval_context(req.context)), req.session)
-#
+class TreeView(View):
+ _cp_path = "/base/treeview"
+
+ @openerpweb.jsonrequest
+ def load(self, req, model, view_id, toolbar=False):
+ return self.fields_view_get(req, model, view_id, 'tree', toolbar=toolbar)
+
+ @openerpweb.jsonrequest
+ def action(self, req, model, id):
+ return load_actions_from_ir_values(
+ req,'action', 'tree_but_open',[(model, id)],
+ False, req.session.eval_context(req.context))
+
+def export_csv(fields, result):
+ fp = StringIO()
+ writer = csv.writer(fp, quoting=csv.QUOTE_ALL)
+
+ writer.writerow(fields)
+
+ for data in result:
+ row = []
+ for d in data:
+ if isinstance(d, basestring):
+ d = d.replace('\n',' ').replace('\t',' ')
+ try:
+ d = d.encode('utf-8')
+ except:
+ pass
+ if d is False: d = None
+ row.append(d)
+ writer.writerow(row)
+
+ fp.seek(0)
+ data = fp.read()
+ fp.close()
+ return data
+
+def export_xls(fieldnames, table):
+ try:
+ import xlwt
+ except ImportError:
+ common.error(_('Import Error.'), _('Please install xlwt library to export to MS Excel.'))
+
+ workbook = xlwt.Workbook()
+ worksheet = workbook.add_sheet('Sheet 1')
+
+ for i, fieldname in enumerate(fieldnames):
+ worksheet.write(0, i, str(fieldname))
+ worksheet.col(i).width = 8000 # around 220 pixels
+
+ style = xlwt.easyxf('align: wrap yes')
+
+ for row_index, row in enumerate(table):
+ for cell_index, cell_value in enumerate(row):
+ cell_value = str(cell_value)
+ cell_value = re.sub("\r", " ", cell_value)
+ worksheet.write(row_index + 1, cell_index, cell_value, style)
+
+
+ fp = StringIO()
+ workbook.save(fp)
+ fp.seek(0)
+ data = fp.read()
+ fp.close()
+ #return data.decode('ISO-8859-1')
+ return unicode(data, 'utf-8', 'replace')
+
+class Export(View):
+ _cp_path = "/base/export"
+
+ def fields_get(self, req, model):
+ Model = req.session.model(model)
+ fields = Model.fields_get(False, req.session.eval_context(req.context))
+ return fields
+
+ @openerpweb.jsonrequest
+ def get_fields(self, req, model, prefix='', name= '', field_parent=None, params={}):
+ import_compat = params.get("import_compat", False)
+
+ fields = self.fields_get(req, model)
+ field_parent_type = params.get("parent_field_type",False)
+
+ if import_compat and field_parent_type and field_parent_type == "many2one":
+ fields = {}
+
+ fields.update({'id': {'string': 'ID'}, '.id': {'string': 'Database ID'}})
+ records = []
+ fields_order = fields.keys()
+ fields_order.sort(lambda x,y: -cmp(fields[x].get('string', ''), fields[y].get('string', '')))
+
+ for index, field in enumerate(fields_order):
+ value = fields[field]
+ record = {}
+ if import_compat and value.get('readonly', False):
+ ok = False
+ for sl in value.get('states', {}).values():
+ for s in sl:
+ ok = ok or (s==['readonly',False])
+ if not ok: continue
+
+ id = prefix + (prefix and '/'or '') + field
+ nm = name + (name and '/' or '') + value['string']
+ record.update(id=id, string= nm, action='javascript: void(0)',
+ target=None, icon=None, children=[], field_type=value.get('type',False), required=value.get('required', False))
+ records.append(record)
+
+ if len(nm.split('/')) < 3 and value.get('relation', False):
+ if import_compat:
+ ref = value.pop('relation')
+ cfields = self.fields_get(req, ref)
+ if (value['type'] == 'many2many'):
+ record['children'] = []
+ record['params'] = {'model': ref, 'prefix': id, 'name': nm}
+
+ elif value['type'] == 'many2one':
+ record['children'] = [id + '/id', id + '/.id']
+ record['params'] = {'model': ref, 'prefix': id, 'name': nm}
+
+ else:
+ cfields_order = cfields.keys()
+ cfields_order.sort(lambda x,y: -cmp(cfields[x].get('string', ''), cfields[y].get('string', '')))
+ children = []
+ for j, fld in enumerate(cfields_order):
+ cid = id + '/' + fld
+ cid = cid.replace(' ', '_')
+ children.append(cid)
+ record['children'] = children or []
+ record['params'] = {'model': ref, 'prefix': id, 'name': nm}
+ else:
+ ref = value.pop('relation')
+ cfields = self.fields_get(req, ref)
+ cfields_order = cfields.keys()
+ cfields_order.sort(lambda x,y: -cmp(cfields[x].get('string', ''), cfields[y].get('string', '')))
+ children = []
+ for j, fld in enumerate(cfields_order):
+ cid = id + '/' + fld
+ cid = cid.replace(' ', '_')
+ children.append(cid)
+ record['children'] = children or []
+ record['params'] = {'model': ref, 'prefix': id, 'name': nm}
+
+ records.reverse()
+ return records
+
+ @openerpweb.jsonrequest
+ def save_export_lists(self, req, name, model, field_list):
+ result = {'resource':model, 'name':name, 'export_fields': []}
+ for field in field_list:
+ result['export_fields'].append((0, 0, {'name': field}))
+ return req.session.model("ir.exports").create(result, req.session.eval_context(req.context))
+
+ @openerpweb.jsonrequest
+ def exist_export_lists(self, req, model):
+ export_model = req.session.model("ir.exports")
+ return export_model.read(export_model.search([('resource', '=', model)]), ['name'])
+
+ @openerpweb.jsonrequest
+ def delete_export(self, req, export_id):
+ req.session.model("ir.exports").unlink(export_id, req.session.eval_context(req.context))
+ return True
+
+ @openerpweb.jsonrequest
+ def namelist(self,req, model, export_id):
+
+ result = self.get_data(req, model, req.session.eval_context(req.context))
+ ir_export_obj = req.session.model("ir.exports")
+ ir_export_line_obj = req.session.model("ir.exports.line")
+
+ field = ir_export_obj.read(export_id)
+ fields = ir_export_line_obj.read(field['export_fields'])
+
+ name_list = {}
+ [name_list.update({field['name']: result.get(field['name'])}) for field in fields]
+ return name_list
+
+ def get_data(self, req, model, context=None):
+ ids = []
+ context = context or {}
+ fields_data = {}
+ proxy = req.session.model(model)
+ fields = self.fields_get(req, model)
+ if not ids:
+ f1 = proxy.fields_view_get(False, 'tree', context)['fields']
+ f2 = proxy.fields_view_get(False, 'form', context)['fields']
+
+ fields = dict(f1)
+ fields.update(f2)
+ fields.update({'id': {'string': 'ID'}, '.id': {'string': 'Database ID'}})
+
+ def rec(fields):
+ _fields = {'id': 'ID' , '.id': 'Database ID' }
+ def model_populate(fields, prefix_node='', prefix=None, prefix_value='', level=2):
+ fields_order = fields.keys()
+ fields_order.sort(lambda x,y: -cmp(fields[x].get('string', ''), fields[y].get('string', '')))
+
+ for field in fields_order:
+ fields_data[prefix_node+field] = fields[field]
+ if prefix_node:
+ fields_data[prefix_node + field]['string'] = '%s%s' % (prefix_value, fields_data[prefix_node + field]['string'])
+ st_name = fields[field]['string'] or field
+ _fields[prefix_node+field] = st_name
+ if fields[field].get('relation', False) and level>0:
+ fields2 = self.fields_get(req, fields[field]['relation'])
+ fields2.update({'id': {'string': 'ID'}, '.id': {'string': 'Database ID'}})
+ model_populate(fields2, prefix_node+field+'/', None, st_name+'/', level-1)
+ model_populate(fields)
+ return _fields
+ return rec(fields)
+
+ @openerpweb.jsonrequest
+ def export_data(self, req, model, fields, ids, domain, import_compat=False, export_format="csv", context=None):
+ context = req.session.eval_context(req.context)
+ modle_obj = req.session.model(model)
+ ids = ids or modle_obj.search(domain, context=context)
+
+ field = fields.keys()
+ result = modle_obj.export_data(ids, field , context).get('datas',[])
+
+ if not import_compat:
+ field = [val.strip() for val in fields.values()]
+
+ if export_format == 'xls':
+ return export_xls(field, result)
+ else:
+ return export_csv(field, result)
projects / odoo / odoo.git / blobdiff