+
+
+
+
+
+
+
diff --git a/addons/web_mobile/static/src/css/web_mobile.css b/addons/web_mobile/static/src/css/web_mobile.css
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/addons/web_mobile/static/src/js/web_mobile.js b/addons/web_mobile/static/src/js/web_mobile.js
new file mode 100644
index 00000000000..08d9e81f4be
--- /dev/null
+++ b/addons/web_mobile/static/src/js/web_mobile.js
@@ -0,0 +1,260 @@
+
+openerp.web_mobile = function(openerp) {
+
+openerp.web_mobile = {};
+
+openerp.web_mobile.MobileWebClient = openerp.base.Controller.extend({
+ init: function(element_id) {
+ var self = this;
+ this._super(null, element_id);
+ QWeb.add_template("xml/web_mobile.xml");
+ var params = {};
+
+ this.$element.html(QWeb.render("WebClient", {}));
+ this.session = new openerp.base.Session("oe_errors");
+ this.crashmanager = new openerp.base.CrashManager(this.session);
+ this.login = new openerp.web_mobile.Login(this.session, "oe_app");
+
+ this.session.on_session_invalid.add(this.login.do_ask_login);
+
+ },
+ start: function() {
+ this.session.start();
+ this.login.start();
+ }
+});
+
+openerp.web_mobile.mobilewebclient = function(element_id) {
+ // TODO Helper to start mobile webclient rename it openerp.base.webclient
+ var client = new openerp.web_mobile.MobileWebClient(element_id);
+ client.start();
+ return client;
+};
+
+openerp.web_mobile.Header = openerp.base.Controller.extend({
+ init: function(session, element_id) {
+ this._super(session, element_id);
+ },
+ start: function() {
+ this.$element.html(QWeb.render("Header", this));
+ this.$element.find("a").click(this.on_clicked);
+ },
+ on_clicked: function(ev) {
+ $opt = $(ev.currentTarget);
+ current_id = $opt.attr('id');
+ if (current_id == 'home') {
+ this.homepage = new openerp.web_mobile.Login(this.session, "oe_app");
+ this.homepage.on_login_valid();
+ }
+ }
+
+});
+
+openerp.web_mobile.Shortcuts = openerp.base.Controller.extend({
+ init: function(session, element_id) {
+ this._super(session, element_id);
+ },
+ start: function() {
+ var self = this;
+ this.rpc('/base/session/sc_list',{} ,function(res){
+ self.$element.html(QWeb.render("Shortcuts", {'sc' : res}))
+ self.$element.find("a").click(self.on_clicked);
+ })
+ },
+ on_clicked: function(ev) {
+ $shortcut = $(ev.currentTarget);
+ id = $shortcut.data('menu');
+ res_id = $shortcut.data('res');
+ jQuery("#oe_header").find("h1").html($shortcut.data('name'));
+ this.listview = new openerp.web_mobile.ListView(this.session, "oe_app", res_id);
+ this.listview.start();
+ }
+});
+
+openerp.web_mobile.ListView = openerp.base.Controller.extend({
+ init: function(session, element_id, list_id) {
+ this._super(session, element_id);
+ this.list_id = list_id;
+ },
+ start: function() {
+ this.rpc('/base/menu/action', {'menu_id': this.list_id},
+ this.on_menu_action_loaded);
+ },
+ on_menu_action_loaded: function(data) {
+ var self = this;
+ if (data.action.length) {
+ var action = data.action[0][2];
+ self.on_action(action);
+ }
+ },
+ on_action: function(action) {
+ var self = this;
+ var view_id = action.views[0][0];
+ var model = action.res_model;
+
+ self.rpc('/base/dataset/search_read', {
+ model: model
+ },function(result){
+ this.listview = new openerp.web_mobile.ListView(this.session, "oe_app");
+ self.$element.html(QWeb.render("ListView", {'records' : result}));
+ });
+ }
+ });
+
+openerp.web_mobile.Secondary = openerp.base.Controller.extend({
+ init: function(session, element_id, secondary_menu_id) {
+ this._super(session, element_id);
+ this.data = secondary_menu_id;
+ },
+ start: function(ev, id) {
+ var v = { menu : this.data };
+ this.$element.html(QWeb.render("Menu.secondary", v));
+ this.$element.add(this.$secondary_menu).find("a").click(this.on_menu_click);
+ },
+ on_menu_click: function(ev, id) {
+ $menu = $(ev.currentTarget);
+ id = $menu.data('menu');
+ for (var i = 0; i < this.data.children.length; i++) {
+ if (this.data.children[i].id == id) {
+ this.children = this.data.children[i];
+ }
+ }
+ jQuery("#oe_header").find("h1").html($menu.data('name'));
+
+ var child_len = this.children.children.length;
+ if (child_len > 0) {
+ this.$element
+ .removeClass("secondary_menu")
+ .addClass("content_menu");
+ //.hide();
+ this.secondary = new openerp.web_mobile.Secondary(this.session, "oe_app", this.children);
+ this.secondary.start();
+ }
+ else {
+ if (id) {
+ this.listview = new openerp.web_mobile.ListView(this.session, "oe_app", id);
+ this.listview.start();
+ }
+ }
+ }
+});
+
+openerp.web_mobile.Menu = openerp.base.Controller.extend({
+ init: function(session, element_id, secondary_menu_id) {
+ this._super(session, element_id);
+ this.secondary_menu_id = secondary_menu_id;
+ this.$secondary_menu = $("#" + secondary_menu_id);
+ this.menu = false;
+ },
+ start: function() {
+ this.rpc("/base/menu/load", {}, this.on_loaded);
+ },
+ on_loaded: function(data) {
+ this.data = data;
+ this.$element.html(QWeb.render("Menu", this.data));
+ this.$element.add(this.$secondary_menu).find("a").click(this.on_menu_click);
+ },
+ on_menu_click: function(ev, id) {
+ $menu = $(ev.currentTarget);
+ id = $menu.data('menu');
+ for (var i = 0; i < this.data.data.children.length; i++) {
+ if (this.data.data.children[i].id == id) {
+ this.children = this.data.data.children[i];
+ }
+ }
+ jQuery("#oe_header").find("h1").html($menu.data('name'));
+ this.$element
+ .removeClass("login_valid")
+ .addClass("secondary_menu");
+ //.hide();
+ this.secondary = new openerp.web_mobile.Secondary(this.session, "oe_app", this.children);
+ this.secondary.start();
+ }
+});
+
+openerp.web_mobile.Options = openerp.base.Controller.extend({
+ init: function(session, element_id) {
+ this._super(session, element_id);
+ },
+ start: function() {
+ var self = this;
+ this.$element.html(QWeb.render("Options", this));
+ self.$element.find("#logout").click(self.on_logout);
+ },
+ on_logout: function(ev) {
+ this.session.logout();
+ this.login = new openerp.web_mobile.Login(this.session, "oe_app");
+ this.login.start();
+ }
+});
+openerp.web_mobile.Login = openerp.base.Controller.extend({
+ init: function(session, element_id) {
+ this._super(session, element_id);
+ },
+ start: function() {
+ var self = this;
+
+ jQuery("#oe_header").children().remove();
+ this.rpc("/base/session/get_databases_list", {}, function(result) {
+ self.db_list = result.db_list;
+ self.$element.html(QWeb.render("Login", self));
+ self.$element.find('#database').click(self.on_db_select);
+ self.$element.find("#login").click(self.on_login);
+ $.mobile.initializePage();
+ })
+ },
+ on_db_select: function(ev) {
+ var db = this.$element.find("#database option:selected").val();
+ jQuery("#db_text").html(db);
+ },
+ on_login: function(ev) {
+ ev.preventDefault();
+ var self = this;
+ var $e = this.$element;
+ var db = $e.find("div select[name=database]").val();
+ var login = $e.find("div input[name=login]").val();
+ var password = $e.find("div input[name=password]").val();
+ //$e.hide();
+ // Should hide then call callback
+ this.session.session_login(db, login, password, function() {
+ if(self.session.session_is_valid()) {
+ self.on_login_valid();
+ } else {
+ self.on_login_invalid();
+ }
+ });
+ },
+ on_login_invalid: function() {
+ this.$element
+ .removeClass("login_valid")
+ .addClass("login_invalid")
+ .show();
+ },
+ on_login_valid: function() {
+ this.$element
+ .removeClass("login_invalid")
+ .addClass("login_valid");
+ //.hide();
+ this.$element.html(QWeb.render("HomePage", {}));
+ this.header = new openerp.web_mobile.Header(this.session, "oe_header");
+ this.shortcuts = new openerp.web_mobile.Shortcuts(this.session, "oe_shortcuts");
+ this.menu = new openerp.web_mobile.Menu(this.session, "oe_menu", "oe_secondary_menu");
+ this.options = new openerp.web_mobile.Options(this.session, "oe_options");
+ this.header.start();
+ this.shortcuts.start();
+ this.menu.start();
+ this.options.start();
+ jQuery("#oe_header").find("h1").html('Home');
+
+ },
+ do_ask_login: function(continuation) {
+ this.on_login_invalid();
+ this.on_login_valid.add({
+ position: "last",
+ unique: true,
+ callback: continuation
+ });
+ }
+});
+
+};
diff --git a/addons/web_mobile/static/src/web_mobile.html b/addons/web_mobile/static/src/web_mobile.html
new file mode 100755
index 00000000000..bc95e40eb43
--- /dev/null
+++ b/addons/web_mobile/static/src/web_mobile.html
@@ -0,0 +1,40 @@
+
+
+
+
+
Login Page OpenERP mobile
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/addons/web_mobile/static/src/xml/web_mobile.xml b/addons/web_mobile/static/src/xml/web_mobile.xml
new file mode 100644
index 00000000000..2f8a464ab72
--- /dev/null
+++ b/addons/web_mobile/static/src/xml/web_mobile.xml
@@ -0,0 +1,166 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+ Options
+
+ -
+
+
+ -
+
+
+
+
+
+
diff --git a/openerpweb/nonliterals.py b/openerpweb/nonliterals.py
index 1584628f777..643ee8a393b 100644
--- a/openerpweb/nonliterals.py
+++ b/openerpweb/nonliterals.py
@@ -6,7 +6,6 @@ can't be sent there themselves).
"""
import binascii
import hashlib
-import simplejson.decoder
import simplejson.encoder
__all__ = ['Domain', 'Context', 'NonLiteralEncoder, non_literal_decoder']
@@ -17,6 +16,8 @@ SHORT_HASH_BYTES_SIZE = 6
class NonLiteralEncoder(simplejson.encoder.JSONEncoder):
def default(self, object):
+ if not isinstance(object, (BaseDomain, BaseContext)):
+ return super(NonLiteralEncoder, self).default(object)
if isinstance(object, Domain):
return {
'__ref': 'domain',
@@ -27,7 +28,17 @@ class NonLiteralEncoder(simplejson.encoder.JSONEncoder):
'__ref': 'context',
'__id': object.key
}
- return super(NonLiteralEncoder, self).default(object)
+ elif isinstance(object, CompoundDomain):
+ return {
+ '__ref': 'compound_domain',
+ '__domains': object.domains
+ }
+ elif isinstance(object, CompoundContext):
+ return {
+ '__ref': 'compound_context',
+ '__contexts': object.contexts
+ }
+ raise TypeError('Could not encode unknown non-literal %s' % object)
def non_literal_decoder(dct):
""" Decodes JSON dicts into :class:`Domain` and :class:`Context` based on
@@ -47,9 +58,28 @@ def non_literal_decoder(dct):
if 'own_values' in dct:
context.own = dct['own_values']
return context
+ elif dct["__ref"] == "compound_domain":
+ cdomain = CompoundDomain()
+ for el in dct["__domains"]:
+ cdomain.domains.append(non_literal_decoder(el))
+ return cdomain
+ elif dct["__ref"] == "compound_context":
+ ccontext = CompoundContext()
+ for el in dct["__contexts"]:
+ ccontext.contexts.append(non_literal_decoder(el))
+ return ccontext
return dct
-class Domain(object):
+# TODO: use abstract base classes if 2.6+?
+class BaseDomain(object):
+ def evaluate(self, context=None):
+ raise NotImplementedError('Non literals must implement evaluate()')
+
+class BaseContext(object):
+ def evaluate(self, context=None):
+ raise NotImplementedError('Non literals must implement evaluate()')
+
+class Domain(BaseDomain):
def __init__(self, session, domain_string=None, key=None):
""" Uses session information to store the domain string and map it to a
domain key, which can be safely round-tripped to the client.
@@ -93,7 +123,7 @@ class Domain(object):
ctx.update(self.own)
return eval(self.get_domain_string(), ctx)
-class Context(object):
+class Context(BaseContext):
def __init__(self, session, context_string=None, key=None):
""" Uses session information to store the context string and map it to
a key (stored in a secret location under a secret mountain), which can
@@ -138,3 +168,63 @@ class Context(object):
ctx.update(self.own)
return eval(self.get_context_string(),
ctx)
+
+class CompoundDomain(BaseDomain):
+ def __init__(self, *domains):
+ self.domains = []
+ self.session = None
+ for domain in domains:
+ self.add(domain)
+
+ def evaluate(self, context=None):
+ final_domain = []
+ for domain in self.domains:
+ if not isinstance(domain, (list, BaseDomain)):
+ raise TypeError("Domain %r is not a list or a nonliteral Domain",
+ domain)
+
+ if isinstance(domain, list):
+ final_domain.extend(domain)
+ continue
+
+ ctx = dict(context or {})
+ ctx['context'] = ctx
+
+ domain.session = self.session
+ final_domain.extend(domain.evaluate(ctx))
+ return final_domain
+
+ def add(self, domain):
+ self.domains.append(domain)
+ return self
+
+class CompoundContext(BaseContext):
+ def __init__(self, *contexts):
+ self.contexts = []
+ self.session = None
+ for context in contexts:
+ self.add(context)
+
+ def evaluate(self, context=None):
+ ctx = dict(context or {})
+ final_context = {}
+ for context_to_eval in self.contexts:
+ if not isinstance(context_to_eval, (dict, BaseContext)):
+ raise TypeError("Context %r is not a dict or a nonliteral Context",
+ context_to_eval)
+
+ if isinstance(context_to_eval, dict):
+ final_context.update(context_to_eval)
+ continue
+
+ ctx.update(final_context)
+ ctx["context"] = ctx
+
+ context_to_eval.session = self.session
+ final_context.update(context_to_eval.evaluate(ctx))
+ return final_context
+
+ def add(self, context):
+ self.contexts.append(context)
+ return self
+
diff --git a/openerpweb/openerpweb.py b/openerpweb/openerpweb.py
index 030e5367732..9da14d5ace0 100644
--- a/openerpweb/openerpweb.py
+++ b/openerpweb/openerpweb.py
@@ -138,6 +138,9 @@ class OpenERPSession(object):
"""
assert self._uid, "The user needs to be logged-in to initialize his context"
self.context = self.model('res.users').context_get(self.context)
+ # set bin_size to True all the time
+ self.context = self.context or {}
+ self.context["bin_size"] = True
self.client_timezone = self.context.get("tz", False)
# invalid code, anyway we decided the server will be in UTC
@@ -182,7 +185,7 @@ class OpenERPSession(object):
def eval_context(self, context_to_eval, context=None):
""" Evaluates the provided context_to_eval in the context (haha) of
- the context.
+ the context. Also merges the evaluated context with the session's context.
:param context_to_eval: a context to evaluate. Must be a dict or a
non-literal context. If it's a dict, will be
@@ -194,46 +197,15 @@ class OpenERPSession(object):
:raises: ``TypeError`` if ``context_to_eval`` is neither a dict nor
a Context
"""
- if not isinstance(context_to_eval, (dict, nonliterals.Domain)):
- raise TypeError("Context %r is not a dict or a nonliteral Context",
- context_to_eval)
-
- if isinstance(context_to_eval, dict):
- return context_to_eval
-
- ctx = dict(context or {})
- ctx['context'] = ctx
-
- # if the domain was unpacked from JSON, it needs the current
- # OpenERPSession for its data retrieval
- context_to_eval.session = self
- return context_to_eval.evaluate(ctx)
-
- def eval_contexts(self, contexts, context=None):
- """ Evaluates a sequence of contexts to build a single final result
-
- :param list contexts: a list of Context or dict contexts
- :param dict context: a base context, if needed
- :returns: the final combination of all provided contexts
- :rtype: dict
- """
- # This is the context we use to evaluate stuff
- current_context = dict(
+ ctx = dict(
self.base_eval_context,
**(context or {}))
- # this is our result, it should not contain the values
- # of the base context above
- final_context = {}
- for ctx in contexts:
- # evaluate the current context in the sequence, merge it into
- # the result
- final_context.update(
- self.eval_context(
- ctx, current_context))
- # update the current evaluation context so that future
- # evaluations can use the results we just gathered
- current_context.update(final_context)
- return final_context
+ ctx['context'] = ctx
+
+ # adding the context of the session to send to the openerp server
+ ccontext = nonliterals.CompoundContext(self.context, context_to_eval)
+ ccontext.session = self
+ return ccontext.evaluate(ctx)
def eval_domain(self, domain, context=None):
""" Evaluates the provided domain using the provided context
@@ -250,39 +222,15 @@ class OpenERPSession(object):
:raises: ``TypeError`` if ``domain`` is neither a list nor a Domain
"""
- if not isinstance(domain, (list, nonliterals.Domain)):
- raise TypeError("Domain %r is not a list or a nonliteral Domain",
- domain)
-
if isinstance(domain, list):
return domain
ctx = dict(context or {})
ctx['context'] = ctx
- # if the domain was unpacked from JSON, it needs the current
- # OpenERPSession for its data retrieval
- domain.session = self
- return domain.evaluate(ctx)
-
- def eval_domains(self, domains, context=None):
- """ Evaluates and concatenates the provided domains using the
- provided context for all of them.
-
- Returns the final, concatenated result.
-
- :param list domains: a list of Domain or list domains
- :param dict context: the context in which the domains
- should be evaluated (if evaluations need
- to happen)
- :returns: the final combination of all domains in the sequence
- :rtype: list
- """
- final_domain = []
- for domain in domains:
- final_domain.extend(
- self.eval_domain(domain, context))
- return final_domain
+ cdomain = nonliterals.CompoundDomain(domain)
+ cdomain.session = self
+ return cdomain.evaluate(ctx)
#----------------------------------------------------------
# OpenERP Web RequestHandler
@@ -498,6 +446,9 @@ class Root(object):
print "Calling", ps, c, meth, m
return m(**kw)
raise cherrypy.NotFound('/' + '/'.join(l))
+ elif l and l[0] == 'mobile':
+ #for the mobile web client we are supposed to use a different url to just add '/mobile'
+ raise cherrypy.HTTPRedirect('/web_mobile/static/src/web_mobile.html', 301)
else:
raise cherrypy.HTTPRedirect('/base/static/src/base.html', 301)
default.exposed = True
diff --git a/openerpweb/tests/test_session.py b/openerpweb/tests/test_session.py
index e7e0381cec5..991a1d061ec 100644
--- a/openerpweb/tests/test_session.py
+++ b/openerpweb/tests/test_session.py
@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*-
import unittest2
-from openerpweb.nonliterals import Domain
+from openerpweb.nonliterals import Domain, Context, CompoundDomain, CompoundContext
import openerpweb.openerpweb
class TestOpenERPSession(unittest2.TestCase):
@@ -77,7 +77,7 @@ class TestOpenERPSession(unittest2.TestCase):
def test_eval_empty_domains(self):
self.assertEqual(
- self.session.eval_domains([]),
+ self.session.eval_domain(CompoundDomain()),
[])
def test_eval_literal_domains(self):
@@ -89,7 +89,7 @@ class TestOpenERPSession(unittest2.TestCase):
('c', 'in', ['a', 'b', 'c'])]
]
self.assertEqual(
- self.session.eval_domains(domains),
+ self.session.eval_domain(CompoundDomain(*domains)),
[
('a', 'is', 3),
('b', 'ilike', 'foo'),
@@ -104,7 +104,7 @@ class TestOpenERPSession(unittest2.TestCase):
"['|', ('date', '<', current_date),"
" ('date', '>', current_date)]")]
self.assertEqual(
- self.session.eval_domains(domains),
+ self.session.eval_domain(CompoundDomain(*domains)),
[('uid', '=', -1),
'|', ('date', '<', '1945-08-05'), ('date', '>', '1945-08-05')]
)