1146

pending completion

Build # 1146

Build Type

Pull #242

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/OCA/website/commit/<a class=hub.com/OCA/website/commit/98d6ad689499956be016298803fd2cfaa536805e">98d6ad689<a href="https://github.com/OCA/website/commit/98d6ad689499956be016298803fd2cfaa536805e">&quot;&gt;Added disclaimer for Odoo backport in README.

Removed copyright info that should never have been there
(not present in the original commit </a><a class="double-link" href="https://github.com/OCA/website/commit/<a class="double-link" href="https://github.com/OCA/website/commit/5021f0dfc4850aabe42e4648b3ed86f3f45fcf59">5021f0dfc</a>">5021f0dfc</a><a href="https://github.com/OCA/website/commit/98d6ad689499956be016298803fd2cfaa536805e">)

Pull Request Pull Request #242: [ADD][9.0] website_version

Run Details

543 of 543 new or added lines in 8 files covered. (100.0%)

340 of 817 relevant lines covered (41.62%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.57

/website_version_ce/controllers/main.py

# -*- coding: utf-8 -*-#
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).

import datetime
from openerp import http
from openerp.http import request
from openerp.addons.website.controllers.main import Website
from openerp.tools.misc import DEFAULT_SERVER_DATETIME_FORMAT

GOOGLE_ANALYTICS_CONFIGURED = 2
GOOGLE_ANALYTICS_PARTIALLY_CONFIGURED = 1
GOOGLE_ANALYTICS_NOT_CONFIGURED = 0


class VersioningController(Website):

    @http.route('/website_version_ce/change_version', type='json', auth="user",
                website=True)
    def change_version(self, version_id):
        request.session['version_id'] = version_id
        return version_id

    @http.route('/website_version_ce/create_version', type='json', auth="user",
                website=True)
    def create_version(self, name, version_id=None):
        if not name:
            name = datetime.datetime.now().strftime(
                DEFAULT_SERVER_DATETIME_FORMAT)
        new_version = request.env['website_version_ce.version'].create(
            {'name': name, 'website_id': request.website.id}
        )
        if version_id:
            request.env['website_version_ce.version'].browse(
                version_id).copy_version(new_version.id)
        request.session['version_id'] = new_version.id
        return new_version.id

    @http.route('/website_version_ce/delete_version', type='json', auth="user",
                website=True)
    def delete_version(self, version_id):
        version = request.env['website_version_ce.version'].browse(version_id)
        name = version.name
        version.unlink()
        current_id = request.context.get('version_id')
        if version_id == current_id:
            request.session['version_id'] = 0
        return name

    @http.route('/website_version_ce/check_version', type='json', auth="user",
                website=True)
    def check_version(self, version_id):
        # To check if the version is in a running or paused experiment
        exp = request.env['website_version_ce.experiment']
        return bool(exp.search([
            '|',
            ('state', '=', 'running'),
            ('state', '=', 'paused'),
            ('experiment_version_ids.version_id', '=', version_id)
        ], limit=1))

    @http.route('/website_version_ce/all_versions', type='json', auth="public",
                website=True)
    def all_versions(self, view_id):
        # To get all versions in the menu
        view = request.env['ir.ui.view'].browse(view_id)
        version = request.env['website_version_ce.version']
        website_id = request.website.id
        versions = version.search([
            ('website_id', '=', website_id),
            '|',
            ('view_ids.key', '=', view.key),
            ('view_ids.key', '=', 'website.footer_default')
        ])
        current_version_id = request.context.get('version_id')
        check = False
        result = []
        for ver in versions:
            if ver.id == current_version_id:
                # To show in bold the current version in the menu
                result.append({'id': ver.id, 'name': ver.name, 'bold': 1})
                check = True
            else:
                result.append({'id': ver.id, 'name': ver.name, 'bold': 0})
        # To always show in the menu the current version
        if not check and current_version_id:
            result.append({'id': current_version_id, 'name': version.browse(
                current_version_id).name, 'bold': 1})
        return result

    @http.route('/website_version_ce/has_experiments', type='json',
                auth="user", website=True)
    def has_experiments(self, view_id):
        v = request.env['ir.ui.view'].browse(view_id)
        website_id = request.context.get('website_id')
        return bool(
            request.env["website_version_ce.experiment.version"].search([
                ('version_id.view_ids.key', '=', v.key),
                ('experiment_id.website_id.id', '=', website_id)
            ], limit=1))

    @http.route('/website_version_ce/publish_version', type='json',
                auth="user", website=True)
    def publish_version(self, version_id, save_master, copy_master_name):
        request.session['version_id'] = 0
        return request.env['website_version_ce.version'].browse(
            version_id).publish_version(save_master, copy_master_name)

    @http.route('/website_version_ce/diff_version', type='json', auth="user",
                website=True)
    def diff_version(self, version_id):
        mod_version = request.env['website_version_ce.version']
        version = mod_version.browse(version_id)
        name_list = []
        for view in version.view_ids:
            name_list.append({
                'name': view.name,
                'url': '/page/' + view.name.replace(' ', '').lower()
            })
        return name_list

    @http.route('/website_version_ce/google_access', type='json', auth="user")
    def google_authorize(self, **kw):
        # Check if client_id and client_secret are set for Google
        gs_obj = request.env['google.service']
        gm_obj = request.env['google.management']

        client_id = gs_obj.get_client_id(
            'management', context=kw.get('local_context'))
        client_secret = gs_obj.get_client_secret(
            'management', context=kw.get('local_context'))
        if not client_id or not client_secret:
            dummy, action = request.registry.get(
                'ir.model.data').get_object_reference(
                    request.cr,
                    request.uid,
                    'website_version_ce',
                    'action_config_settings_google_management'
                )
            return {
                "status": "need_config_from_admin",
                "url": '',
                "action": action
            }
        url = gm_obj.authorize_google_uri(from_url=kw.get('fromurl'),
                                          context=kw.get('local_context'))
        return {
            "status": "need_auth",
            "url": url
        }

    @http.route('/website_version_ce/set_google_access', type='json',
                auth="user", website=True)
    def set_google_access(self, ga_key, view_id, client_id, client_secret):
        # To set ga_key, view_id, client_id, client_secret
        website_id = request.context.get('website_id')
        web = request.env['website'].browse(website_id)
        web.write({
            'google_analytics_key': ga_key.strip(),
            'google_analytics_view_id': view_id.strip()
        })
        if client_id and client_secret:
            icp = request.env['ir.config_parameter']
            icp.set_param('google_management_client_id',
                          client_id.strip() or '',
                          groups=['base.group_system'])
            icp.set_param('google_management_client_secret',
                          client_secret.strip() or '',
                          groups=['base.group_system'])

    @http.route('/website_version_ce/all_versions_all_goals', type='json',
                auth="user", website=True)
    def all_versions_all_goals(self, view_id):
        # To get all versions and all goals to create an experiment
        view = request.env['ir.ui.view']
        version = request.env['website_version_ce.version']
        goal = request.env['website_version_ce.goals']
        icp = request.env['ir.config_parameter']
        v = view.browse(view_id)
        website_id = request.website.id
        tab_version = version.search_read([
            ('website_id', '=', website_id),
            '|',
            ('view_ids.key', '=', v.key),
            ('view_ids.key', '=', 'website.footer_default')
        ], ['id', 'name'])
        tab_goal = goal.search_read([], ['id', 'name'])
        # Check if all the parameters are set to communicate with Google
        if icp.get_param('google_management_token'):
            check_conf = GOOGLE_ANALYTICS_CONFIGURED
            if request.website.google_analytics_key \
                    and request.website.google_analytics_view_id:
                check_conf = GOOGLE_ANALYTICS_PARTIALLY_CONFIGURED
        else:
            check_conf = GOOGLE_ANALYTICS_NOT_CONFIGURED
        return {'tab_version': tab_version, 'tab_goal': tab_goal,
                'check_conf': check_conf}

    @http.route('/website_version_ce/launch_experiment', type='json',
                auth="user", website=True)
    def launch_experiment(self, name, version_ids, goal_id):
        exp_obj = request.env['website_version_ce.experiment']
        existing_experiment = exp_obj.check_no_overlap(version_ids)
        if not existing_experiment['existing']:
            vals = {
                'name': name,
                'google_id': False,
                'state': 'running',
                'website_id': request.context.get('website_id'),
                'experiment_version_ids': [[
                    0,
                    False,
                    {
                        'frequency': '50',
                        'version_id': int(version_ids[i]),
                        'google_index': i+1
                    }
                    ] for i in range(len(version_ids))],
                'goal_id': int(goal_id)
            }
            exp_obj.create(vals)
        return existing_experiment

1	# -- coding: utf-8 --#
2	# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
3
4	import datetime	2✔
5	from openerp import http	2✔
6	from openerp.http import request	2✔
7	from openerp.addons.website.controllers.main import Website	2✔
8	from openerp.tools.misc import DEFAULT_SERVER_DATETIME_FORMAT	2✔
9
10	GOOGLE_ANALYTICS_CONFIGURED = 2	2✔
11	GOOGLE_ANALYTICS_PARTIALLY_CONFIGURED = 1	2✔
12	GOOGLE_ANALYTICS_NOT_CONFIGURED = 0	2✔
13
14
15	class VersioningController(Website):	2✔
16
17	@http.route('/website_version_ce/change_version', type='json', auth="user",	2✔
18	website=True)
19	def change_version(self, version_id):
20	request.session['version_id'] = version_id	×
21	return version_id	×
22
23	@http.route('/website_version_ce/create_version', type='json', auth="user",	2✔
24	website=True)
25	def create_version(self, name, version_id=None):	2✔
26	if not name:	×
27	name = datetime.datetime.now().strftime(	×
28	DEFAULT_SERVER_DATETIME_FORMAT)
29	new_version = request.env['website_version_ce.version'].create(	×
30	{'name': name, 'website_id': request.website.id}
31	)
32	if version_id:	×
33	request.env['website_version_ce.version'].browse(	×
34	version_id).copy_version(new_version.id)
35	request.session['version_id'] = new_version.id	×
36	return new_version.id	×
37
38	@http.route('/website_version_ce/delete_version', type='json', auth="user",	2✔
39	website=True)
40	def delete_version(self, version_id):
41	version = request.env['website_version_ce.version'].browse(version_id)	×
42	name = version.name	×
43	version.unlink()	×
44	current_id = request.context.get('version_id')	×
45	if version_id == current_id:	×
46	request.session['version_id'] = 0	×
47	return name	×
48
49	@http.route('/website_version_ce/check_version', type='json', auth="user",	2✔
50	website=True)
51	def check_version(self, version_id):
52	# To check if the version is in a running or paused experiment
53	exp = request.env['website_version_ce.experiment']	×
54	return bool(exp.search([	×
55	'\|',
56	('state', '=', 'running'),
57	('state', '=', 'paused'),
58	('experiment_version_ids.version_id', '=', version_id)
59	], limit=1))
60
61	@http.route('/website_version_ce/all_versions', type='json', auth="public",	2✔
62	website=True)
63	def all_versions(self, view_id):
64	# To get all versions in the menu
65	view = request.env['ir.ui.view'].browse(view_id)	×
66	version = request.env['website_version_ce.version']	×
67	website_id = request.website.id	×
68	versions = version.search([	×
69	('website_id', '=', website_id),
70	'\|',
71	('view_ids.key', '=', view.key),
72	('view_ids.key', '=', 'website.footer_default')
73	])
74	current_version_id = request.context.get('version_id')	×
75	check = False	×
76	result = []	×
77	for ver in versions:	×
78	if ver.id == current_version_id:	×
79	# To show in bold the current version in the menu
80	result.append({'id': ver.id, 'name': ver.name, 'bold': 1})	×
81	check = True	×
82	else:
83	result.append({'id': ver.id, 'name': ver.name, 'bold': 0})	×
84	# To always show in the menu the current version
85	if not check and current_version_id:	×
86	result.append({'id': current_version_id, 'name': version.browse(	×
87	current_version_id).name, 'bold': 1})
88	return result	×
89
90	@http.route('/website_version_ce/has_experiments', type='json',	2✔
91	auth="user", website=True)
92	def has_experiments(self, view_id):
93	v = request.env['ir.ui.view'].browse(view_id)	×
94	website_id = request.context.get('website_id')	×
95	return bool(	×
96	request.env["website_version_ce.experiment.version"].search([
97	('version_id.view_ids.key', '=', v.key),
98	('experiment_id.website_id.id', '=', website_id)
99	], limit=1))
100
101	@http.route('/website_version_ce/publish_version', type='json',	2✔
102	auth="user", website=True)
103	def publish_version(self, version_id, save_master, copy_master_name):
104	request.session['version_id'] = 0	×
105	return request.env['website_version_ce.version'].browse(	×
106	version_id).publish_version(save_master, copy_master_name)
107
108	@http.route('/website_version_ce/diff_version', type='json', auth="user",	2✔
109	website=True)
110	def diff_version(self, version_id):
111	mod_version = request.env['website_version_ce.version']	×
112	version = mod_version.browse(version_id)	×
113	name_list = []	×
114	for view in version.view_ids:	×
115	name_list.append({	×
116	'name': view.name,
117	'url': '/page/' + view.name.replace(' ', '').lower()
118	})
119	return name_list	×
120
121	@http.route('/website_version_ce/google_access', type='json', auth="user")	2✔
122	def google_authorize(self, **kw):
123	# Check if client_id and client_secret are set for Google
124	gs_obj = request.env['google.service']	×
125	gm_obj = request.env['google.management']	×
126
127	client_id = gs_obj.get_client_id(	×
128	'management', context=kw.get('local_context'))
129	client_secret = gs_obj.get_client_secret(	×
130	'management', context=kw.get('local_context'))
131	if not client_id or not client_secret:	×
132	dummy, action = request.registry.get(	×
133	'ir.model.data').get_object_reference(
134	request.cr,
135	request.uid,
136	'website_version_ce',
137	'action_config_settings_google_management'
138	)
139	return {	×
140	"status": "need_config_from_admin",
141	"url": '',
142	"action": action
143	}
144	url = gm_obj.authorize_google_uri(from_url=kw.get('fromurl'),	×
145	context=kw.get('local_context'))
146	return {	×
147	"status": "need_auth",
148	"url": url
149	}
150
151	@http.route('/website_version_ce/set_google_access', type='json',	2✔
152	auth="user", website=True)
153	def set_google_access(self, ga_key, view_id, client_id, client_secret):
154	# To set ga_key, view_id, client_id, client_secret
155	website_id = request.context.get('website_id')	×
156	web = request.env['website'].browse(website_id)	×
157	web.write({	×
158	'google_analytics_key': ga_key.strip(),
159	'google_analytics_view_id': view_id.strip()
160	})
161	if client_id and client_secret:	×
162	icp = request.env['ir.config_parameter']	×
163	icp.set_param('google_management_client_id',	×
164	client_id.strip() or '',
165	groups=['base.group_system'])
166	icp.set_param('google_management_client_secret',	×
167	client_secret.strip() or '',
168	groups=['base.group_system'])
169
170	@http.route('/website_version_ce/all_versions_all_goals', type='json',	2✔
171	auth="user", website=True)
172	def all_versions_all_goals(self, view_id):
173	# To get all versions and all goals to create an experiment
174	view = request.env['ir.ui.view']	×
175	version = request.env['website_version_ce.version']	×
176	goal = request.env['website_version_ce.goals']	×
177	icp = request.env['ir.config_parameter']	×
178	v = view.browse(view_id)	×
179	website_id = request.website.id	×
180	tab_version = version.search_read([	×
181	('website_id', '=', website_id),
182	'\|',
183	('view_ids.key', '=', v.key),
184	('view_ids.key', '=', 'website.footer_default')
185	], ['id', 'name'])
186	tab_goal = goal.search_read([], ['id', 'name'])	×
187	# Check if all the parameters are set to communicate with Google
188	if icp.get_param('google_management_token'):	×
189	check_conf = GOOGLE_ANALYTICS_CONFIGURED	×
190	if request.website.google_analytics_key \	×
191	and request.website.google_analytics_view_id:
192	check_conf = GOOGLE_ANALYTICS_PARTIALLY_CONFIGURED	×
193	else:
194	check_conf = GOOGLE_ANALYTICS_NOT_CONFIGURED	×
195	return {'tab_version': tab_version, 'tab_goal': tab_goal,	×
196	'check_conf': check_conf}
197
198	@http.route('/website_version_ce/launch_experiment', type='json',	2✔
199	auth="user", website=True)
200	def launch_experiment(self, name, version_ids, goal_id):
201	exp_obj = request.env['website_version_ce.experiment']	×
202	existing_experiment = exp_obj.check_no_overlap(version_ids)	×
203	if not existing_experiment['existing']:	×
204	vals = {	×
205	'name': name,
206	'google_id': False,
207	'state': 'running',
208	'website_id': request.context.get('website_id'),
209	'experiment_version_ids': [[
210	0,
211	False,
212	{
213	'frequency': '50',
214	'version_id': int(version_ids[i]),
215	'google_index': i+1
216	}
217	] for i in range(len(version_ids))],
218	'goal_id': int(goal_id)
219	}
220	exp_obj.create(vals)	×
221	return existing_experiment	×

OCA / website / 1146

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous