##// END OF EJS Templates
goto-switcher: reduce query data to only required attributes for speedups.
marcink -
r4152:beb1dad7 default
parent child Browse files
Show More
@@ -1,822 +1,830 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2016-2019 RhodeCode GmbH
3 # Copyright (C) 2016-2019 RhodeCode GmbH
4 #
4 #
5 # This program is free software: you can redistribute it and/or modify
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
7 # (only), as published by the Free Software Foundation.
8 #
8 #
9 # This program is distributed in the hope that it will be useful,
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
12 # GNU General Public License for more details.
13 #
13 #
14 # You should have received a copy of the GNU Affero General Public License
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
16 #
17 # This program is dual-licensed. If you wish to learn more about the
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
20
21 import re
21 import re
22 import logging
22 import logging
23 import collections
23 import collections
24
24
25 from pyramid.httpexceptions import HTTPNotFound
25 from pyramid.httpexceptions import HTTPNotFound
26 from pyramid.view import view_config
26 from pyramid.view import view_config
27
27
28 from rhodecode.apps._base import BaseAppView, DataGridAppView
28 from rhodecode.apps._base import BaseAppView, DataGridAppView
29 from rhodecode.lib import helpers as h
29 from rhodecode.lib import helpers as h
30 from rhodecode.lib.auth import (
30 from rhodecode.lib.auth import (
31 LoginRequired, NotAnonymous, HasRepoGroupPermissionAnyDecorator, CSRFRequired,
31 LoginRequired, NotAnonymous, HasRepoGroupPermissionAnyDecorator, CSRFRequired,
32 HasRepoGroupPermissionAny, AuthUser)
32 HasRepoGroupPermissionAny, AuthUser)
33 from rhodecode.lib.codeblocks import filenode_as_lines_tokens
33 from rhodecode.lib.codeblocks import filenode_as_lines_tokens
34 from rhodecode.lib.index import searcher_from_config
34 from rhodecode.lib.index import searcher_from_config
35 from rhodecode.lib.utils2 import safe_unicode, str2bool, safe_int
35 from rhodecode.lib.utils2 import safe_unicode, str2bool, safe_int
36 from rhodecode.lib.vcs.nodes import FileNode
36 from rhodecode.lib.vcs.nodes import FileNode
37 from rhodecode.model.db import (
37 from rhodecode.model.db import (
38 func, true, or_, case, in_filter_generator, Session,
38 func, true, or_, case, in_filter_generator, Session,
39 Repository, RepoGroup, User, UserGroup)
39 Repository, RepoGroup, User, UserGroup)
40 from rhodecode.model.repo import RepoModel
40 from rhodecode.model.repo import RepoModel
41 from rhodecode.model.repo_group import RepoGroupModel
41 from rhodecode.model.repo_group import RepoGroupModel
42 from rhodecode.model.user import UserModel
42 from rhodecode.model.user import UserModel
43 from rhodecode.model.user_group import UserGroupModel
43 from rhodecode.model.user_group import UserGroupModel
44
44
45 log = logging.getLogger(__name__)
45 log = logging.getLogger(__name__)
46
46
47
47
48 class HomeView(BaseAppView, DataGridAppView):
48 class HomeView(BaseAppView, DataGridAppView):
49
49
50 def load_default_context(self):
50 def load_default_context(self):
51 c = self._get_local_tmpl_context()
51 c = self._get_local_tmpl_context()
52 c.user = c.auth_user.get_instance()
52 c.user = c.auth_user.get_instance()
53
53
54 return c
54 return c
55
55
56 @LoginRequired()
56 @LoginRequired()
57 @view_config(
57 @view_config(
58 route_name='user_autocomplete_data', request_method='GET',
58 route_name='user_autocomplete_data', request_method='GET',
59 renderer='json_ext', xhr=True)
59 renderer='json_ext', xhr=True)
60 def user_autocomplete_data(self):
60 def user_autocomplete_data(self):
61 self.load_default_context()
61 self.load_default_context()
62 query = self.request.GET.get('query')
62 query = self.request.GET.get('query')
63 active = str2bool(self.request.GET.get('active') or True)
63 active = str2bool(self.request.GET.get('active') or True)
64 include_groups = str2bool(self.request.GET.get('user_groups'))
64 include_groups = str2bool(self.request.GET.get('user_groups'))
65 expand_groups = str2bool(self.request.GET.get('user_groups_expand'))
65 expand_groups = str2bool(self.request.GET.get('user_groups_expand'))
66 skip_default_user = str2bool(self.request.GET.get('skip_default_user'))
66 skip_default_user = str2bool(self.request.GET.get('skip_default_user'))
67
67
68 log.debug('generating user list, query:%s, active:%s, with_groups:%s',
68 log.debug('generating user list, query:%s, active:%s, with_groups:%s',
69 query, active, include_groups)
69 query, active, include_groups)
70
70
71 _users = UserModel().get_users(
71 _users = UserModel().get_users(
72 name_contains=query, only_active=active)
72 name_contains=query, only_active=active)
73
73
74 def maybe_skip_default_user(usr):
74 def maybe_skip_default_user(usr):
75 if skip_default_user and usr['username'] == UserModel.cls.DEFAULT_USER:
75 if skip_default_user and usr['username'] == UserModel.cls.DEFAULT_USER:
76 return False
76 return False
77 return True
77 return True
78 _users = filter(maybe_skip_default_user, _users)
78 _users = filter(maybe_skip_default_user, _users)
79
79
80 if include_groups:
80 if include_groups:
81 # extend with user groups
81 # extend with user groups
82 _user_groups = UserGroupModel().get_user_groups(
82 _user_groups = UserGroupModel().get_user_groups(
83 name_contains=query, only_active=active,
83 name_contains=query, only_active=active,
84 expand_groups=expand_groups)
84 expand_groups=expand_groups)
85 _users = _users + _user_groups
85 _users = _users + _user_groups
86
86
87 return {'suggestions': _users}
87 return {'suggestions': _users}
88
88
89 @LoginRequired()
89 @LoginRequired()
90 @NotAnonymous()
90 @NotAnonymous()
91 @view_config(
91 @view_config(
92 route_name='user_group_autocomplete_data', request_method='GET',
92 route_name='user_group_autocomplete_data', request_method='GET',
93 renderer='json_ext', xhr=True)
93 renderer='json_ext', xhr=True)
94 def user_group_autocomplete_data(self):
94 def user_group_autocomplete_data(self):
95 self.load_default_context()
95 self.load_default_context()
96 query = self.request.GET.get('query')
96 query = self.request.GET.get('query')
97 active = str2bool(self.request.GET.get('active') or True)
97 active = str2bool(self.request.GET.get('active') or True)
98 expand_groups = str2bool(self.request.GET.get('user_groups_expand'))
98 expand_groups = str2bool(self.request.GET.get('user_groups_expand'))
99
99
100 log.debug('generating user group list, query:%s, active:%s',
100 log.debug('generating user group list, query:%s, active:%s',
101 query, active)
101 query, active)
102
102
103 _user_groups = UserGroupModel().get_user_groups(
103 _user_groups = UserGroupModel().get_user_groups(
104 name_contains=query, only_active=active,
104 name_contains=query, only_active=active,
105 expand_groups=expand_groups)
105 expand_groups=expand_groups)
106 _user_groups = _user_groups
106 _user_groups = _user_groups
107
107
108 return {'suggestions': _user_groups}
108 return {'suggestions': _user_groups}
109
109
110 def _get_repo_list(self, name_contains=None, repo_type=None, repo_group_name='', limit=20):
110 def _get_repo_list(self, name_contains=None, repo_type=None, repo_group_name='', limit=20):
111 org_query = name_contains
111 org_query = name_contains
112 allowed_ids = self._rhodecode_user.repo_acl_ids(
112 allowed_ids = self._rhodecode_user.repo_acl_ids(
113 ['repository.read', 'repository.write', 'repository.admin'],
113 ['repository.read', 'repository.write', 'repository.admin'],
114 cache=False, name_filter=name_contains) or [-1]
114 cache=False, name_filter=name_contains) or [-1]
115
115
116 query = Repository.query()\
116 query = Session().query(
117 Repository.repo_name,
118 Repository.repo_id,
119 Repository.repo_type,
120 Repository.private,
121 )\
117 .filter(Repository.archived.isnot(true()))\
122 .filter(Repository.archived.isnot(true()))\
118 .filter(or_(
123 .filter(or_(
119 # generate multiple IN to fix limitation problems
124 # generate multiple IN to fix limitation problems
120 *in_filter_generator(Repository.repo_id, allowed_ids)
125 *in_filter_generator(Repository.repo_id, allowed_ids)
121 ))
126 ))
122
127
123 query = query.order_by(case(
128 query = query.order_by(case(
124 [
129 [
125 (Repository.repo_name.startswith(repo_group_name), repo_group_name+'/'),
130 (Repository.repo_name.startswith(repo_group_name), repo_group_name+'/'),
126 ],
131 ],
127 ))
132 ))
128 query = query.order_by(func.length(Repository.repo_name))
133 query = query.order_by(func.length(Repository.repo_name))
129 query = query.order_by(Repository.repo_name)
134 query = query.order_by(Repository.repo_name)
130
135
131 if repo_type:
136 if repo_type:
132 query = query.filter(Repository.repo_type == repo_type)
137 query = query.filter(Repository.repo_type == repo_type)
133
138
134 if name_contains:
139 if name_contains:
135 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
140 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
136 query = query.filter(
141 query = query.filter(
137 Repository.repo_name.ilike(ilike_expression))
142 Repository.repo_name.ilike(ilike_expression))
138 query = query.limit(limit)
143 query = query.limit(limit)
139
144
140 acl_iter = query
145 acl_iter = query
141
146
142 return [
147 return [
143 {
148 {
144 'id': obj.repo_name,
149 'id': obj.repo_name,
145 'value': org_query,
150 'value': org_query,
146 'value_display': obj.repo_name,
151 'value_display': obj.repo_name,
147 'text': obj.repo_name,
152 'text': obj.repo_name,
148 'type': 'repo',
153 'type': 'repo',
149 'repo_id': obj.repo_id,
154 'repo_id': obj.repo_id,
150 'repo_type': obj.repo_type,
155 'repo_type': obj.repo_type,
151 'private': obj.private,
156 'private': obj.private,
152 'url': h.route_path('repo_summary', repo_name=obj.repo_name)
157 'url': h.route_path('repo_summary', repo_name=obj.repo_name)
153 }
158 }
154 for obj in acl_iter]
159 for obj in acl_iter]
155
160
156 def _get_repo_group_list(self, name_contains=None, repo_group_name='', limit=20):
161 def _get_repo_group_list(self, name_contains=None, repo_group_name='', limit=20):
157 org_query = name_contains
162 org_query = name_contains
158 allowed_ids = self._rhodecode_user.repo_group_acl_ids(
163 allowed_ids = self._rhodecode_user.repo_group_acl_ids(
159 ['group.read', 'group.write', 'group.admin'],
164 ['group.read', 'group.write', 'group.admin'],
160 cache=False, name_filter=name_contains) or [-1]
165 cache=False, name_filter=name_contains) or [-1]
161
166
162 query = RepoGroup.query()\
167 query = Session().query(
168 RepoGroup.group_id,
169 RepoGroup.group_name,
170 )\
163 .filter(or_(
171 .filter(or_(
164 # generate multiple IN to fix limitation problems
172 # generate multiple IN to fix limitation problems
165 *in_filter_generator(RepoGroup.group_id, allowed_ids)
173 *in_filter_generator(RepoGroup.group_id, allowed_ids)
166 ))
174 ))
167
175
168 query = query.order_by(case(
176 query = query.order_by(case(
169 [
177 [
170 (RepoGroup.group_name.startswith(repo_group_name), repo_group_name+'/'),
178 (RepoGroup.group_name.startswith(repo_group_name), repo_group_name+'/'),
171 ],
179 ],
172 ))
180 ))
173 query = query.order_by(func.length(RepoGroup.group_name))
181 query = query.order_by(func.length(RepoGroup.group_name))
174 query = query.order_by(RepoGroup.group_name)
182 query = query.order_by(RepoGroup.group_name)
175
183
176 if name_contains:
184 if name_contains:
177 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
185 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
178 query = query.filter(
186 query = query.filter(
179 RepoGroup.group_name.ilike(ilike_expression))
187 RepoGroup.group_name.ilike(ilike_expression))
180 query = query.limit(limit)
188 query = query.limit(limit)
181
189
182 acl_iter = query
190 acl_iter = query
183
191
184 return [
192 return [
185 {
193 {
186 'id': obj.group_name,
194 'id': obj.group_name,
187 'value': org_query,
195 'value': org_query,
188 'value_display': obj.group_name,
196 'value_display': obj.group_name,
189 'text': obj.group_name,
197 'text': obj.group_name,
190 'type': 'repo_group',
198 'type': 'repo_group',
191 'repo_group_id': obj.group_id,
199 'repo_group_id': obj.group_id,
192 'url': h.route_path(
200 'url': h.route_path(
193 'repo_group_home', repo_group_name=obj.group_name)
201 'repo_group_home', repo_group_name=obj.group_name)
194 }
202 }
195 for obj in acl_iter]
203 for obj in acl_iter]
196
204
197 def _get_user_list(self, name_contains=None, limit=20):
205 def _get_user_list(self, name_contains=None, limit=20):
198 org_query = name_contains
206 org_query = name_contains
199 if not name_contains:
207 if not name_contains:
200 return [], False
208 return [], False
201
209
202 # TODO(marcink): should all logged in users be allowed to search others?
210 # TODO(marcink): should all logged in users be allowed to search others?
203 allowed_user_search = self._rhodecode_user.username != User.DEFAULT_USER
211 allowed_user_search = self._rhodecode_user.username != User.DEFAULT_USER
204 if not allowed_user_search:
212 if not allowed_user_search:
205 return [], False
213 return [], False
206
214
207 name_contains = re.compile('(?:user:[ ]?)(.+)').findall(name_contains)
215 name_contains = re.compile('(?:user:[ ]?)(.+)').findall(name_contains)
208 if len(name_contains) != 1:
216 if len(name_contains) != 1:
209 return [], False
217 return [], False
210
218
211 name_contains = name_contains[0]
219 name_contains = name_contains[0]
212
220
213 query = User.query()\
221 query = User.query()\
214 .order_by(func.length(User.username))\
222 .order_by(func.length(User.username))\
215 .order_by(User.username) \
223 .order_by(User.username) \
216 .filter(User.username != User.DEFAULT_USER)
224 .filter(User.username != User.DEFAULT_USER)
217
225
218 if name_contains:
226 if name_contains:
219 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
227 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
220 query = query.filter(
228 query = query.filter(
221 User.username.ilike(ilike_expression))
229 User.username.ilike(ilike_expression))
222 query = query.limit(limit)
230 query = query.limit(limit)
223
231
224 acl_iter = query
232 acl_iter = query
225
233
226 return [
234 return [
227 {
235 {
228 'id': obj.user_id,
236 'id': obj.user_id,
229 'value': org_query,
237 'value': org_query,
230 'value_display': 'user: `{}`'.format(obj.username),
238 'value_display': 'user: `{}`'.format(obj.username),
231 'type': 'user',
239 'type': 'user',
232 'icon_link': h.gravatar_url(obj.email, 30),
240 'icon_link': h.gravatar_url(obj.email, 30),
233 'url': h.route_path(
241 'url': h.route_path(
234 'user_profile', username=obj.username)
242 'user_profile', username=obj.username)
235 }
243 }
236 for obj in acl_iter], True
244 for obj in acl_iter], True
237
245
238 def _get_user_groups_list(self, name_contains=None, limit=20):
246 def _get_user_groups_list(self, name_contains=None, limit=20):
239 org_query = name_contains
247 org_query = name_contains
240 if not name_contains:
248 if not name_contains:
241 return [], False
249 return [], False
242
250
243 # TODO(marcink): should all logged in users be allowed to search others?
251 # TODO(marcink): should all logged in users be allowed to search others?
244 allowed_user_search = self._rhodecode_user.username != User.DEFAULT_USER
252 allowed_user_search = self._rhodecode_user.username != User.DEFAULT_USER
245 if not allowed_user_search:
253 if not allowed_user_search:
246 return [], False
254 return [], False
247
255
248 name_contains = re.compile('(?:user_group:[ ]?)(.+)').findall(name_contains)
256 name_contains = re.compile('(?:user_group:[ ]?)(.+)').findall(name_contains)
249 if len(name_contains) != 1:
257 if len(name_contains) != 1:
250 return [], False
258 return [], False
251
259
252 name_contains = name_contains[0]
260 name_contains = name_contains[0]
253
261
254 query = UserGroup.query()\
262 query = UserGroup.query()\
255 .order_by(func.length(UserGroup.users_group_name))\
263 .order_by(func.length(UserGroup.users_group_name))\
256 .order_by(UserGroup.users_group_name)
264 .order_by(UserGroup.users_group_name)
257
265
258 if name_contains:
266 if name_contains:
259 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
267 ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
260 query = query.filter(
268 query = query.filter(
261 UserGroup.users_group_name.ilike(ilike_expression))
269 UserGroup.users_group_name.ilike(ilike_expression))
262 query = query.limit(limit)
270 query = query.limit(limit)
263
271
264 acl_iter = query
272 acl_iter = query
265
273
266 return [
274 return [
267 {
275 {
268 'id': obj.users_group_id,
276 'id': obj.users_group_id,
269 'value': org_query,
277 'value': org_query,
270 'value_display': 'user_group: `{}`'.format(obj.users_group_name),
278 'value_display': 'user_group: `{}`'.format(obj.users_group_name),
271 'type': 'user_group',
279 'type': 'user_group',
272 'url': h.route_path(
280 'url': h.route_path(
273 'user_group_profile', user_group_name=obj.users_group_name)
281 'user_group_profile', user_group_name=obj.users_group_name)
274 }
282 }
275 for obj in acl_iter], True
283 for obj in acl_iter], True
276
284
277 def _get_hash_commit_list(self, auth_user, searcher, query, repo=None, repo_group=None):
285 def _get_hash_commit_list(self, auth_user, searcher, query, repo=None, repo_group=None):
278 repo_name = repo_group_name = None
286 repo_name = repo_group_name = None
279 if repo:
287 if repo:
280 repo_name = repo.repo_name
288 repo_name = repo.repo_name
281 if repo_group:
289 if repo_group:
282 repo_group_name = repo_group.group_name
290 repo_group_name = repo_group.group_name
283
291
284 org_query = query
292 org_query = query
285 if not query or len(query) < 3 or not searcher:
293 if not query or len(query) < 3 or not searcher:
286 return [], False
294 return [], False
287
295
288 commit_hashes = re.compile('(?:commit:[ ]?)([0-9a-f]{2,40})').findall(query)
296 commit_hashes = re.compile('(?:commit:[ ]?)([0-9a-f]{2,40})').findall(query)
289
297
290 if len(commit_hashes) != 1:
298 if len(commit_hashes) != 1:
291 return [], False
299 return [], False
292
300
293 commit_hash = commit_hashes[0]
301 commit_hash = commit_hashes[0]
294
302
295 result = searcher.search(
303 result = searcher.search(
296 'commit_id:{}*'.format(commit_hash), 'commit', auth_user,
304 'commit_id:{}*'.format(commit_hash), 'commit', auth_user,
297 repo_name, repo_group_name, raise_on_exc=False)
305 repo_name, repo_group_name, raise_on_exc=False)
298
306
299 commits = []
307 commits = []
300 for entry in result['results']:
308 for entry in result['results']:
301 repo_data = {
309 repo_data = {
302 'repository_id': entry.get('repository_id'),
310 'repository_id': entry.get('repository_id'),
303 'repository_type': entry.get('repo_type'),
311 'repository_type': entry.get('repo_type'),
304 'repository_name': entry.get('repository'),
312 'repository_name': entry.get('repository'),
305 }
313 }
306
314
307 commit_entry = {
315 commit_entry = {
308 'id': entry['commit_id'],
316 'id': entry['commit_id'],
309 'value': org_query,
317 'value': org_query,
310 'value_display': '`{}` commit: {}'.format(
318 'value_display': '`{}` commit: {}'.format(
311 entry['repository'], entry['commit_id']),
319 entry['repository'], entry['commit_id']),
312 'type': 'commit',
320 'type': 'commit',
313 'repo': entry['repository'],
321 'repo': entry['repository'],
314 'repo_data': repo_data,
322 'repo_data': repo_data,
315
323
316 'url': h.route_path(
324 'url': h.route_path(
317 'repo_commit',
325 'repo_commit',
318 repo_name=entry['repository'], commit_id=entry['commit_id'])
326 repo_name=entry['repository'], commit_id=entry['commit_id'])
319 }
327 }
320
328
321 commits.append(commit_entry)
329 commits.append(commit_entry)
322 return commits, True
330 return commits, True
323
331
324 def _get_path_list(self, auth_user, searcher, query, repo=None, repo_group=None):
332 def _get_path_list(self, auth_user, searcher, query, repo=None, repo_group=None):
325 repo_name = repo_group_name = None
333 repo_name = repo_group_name = None
326 if repo:
334 if repo:
327 repo_name = repo.repo_name
335 repo_name = repo.repo_name
328 if repo_group:
336 if repo_group:
329 repo_group_name = repo_group.group_name
337 repo_group_name = repo_group.group_name
330
338
331 org_query = query
339 org_query = query
332 if not query or len(query) < 3 or not searcher:
340 if not query or len(query) < 3 or not searcher:
333 return [], False
341 return [], False
334
342
335 paths_re = re.compile('(?:file:[ ]?)(.+)').findall(query)
343 paths_re = re.compile('(?:file:[ ]?)(.+)').findall(query)
336 if len(paths_re) != 1:
344 if len(paths_re) != 1:
337 return [], False
345 return [], False
338
346
339 file_path = paths_re[0]
347 file_path = paths_re[0]
340
348
341 search_path = searcher.escape_specials(file_path)
349 search_path = searcher.escape_specials(file_path)
342 result = searcher.search(
350 result = searcher.search(
343 'file.raw:*{}*'.format(search_path), 'path', auth_user,
351 'file.raw:*{}*'.format(search_path), 'path', auth_user,
344 repo_name, repo_group_name, raise_on_exc=False)
352 repo_name, repo_group_name, raise_on_exc=False)
345
353
346 files = []
354 files = []
347 for entry in result['results']:
355 for entry in result['results']:
348 repo_data = {
356 repo_data = {
349 'repository_id': entry.get('repository_id'),
357 'repository_id': entry.get('repository_id'),
350 'repository_type': entry.get('repo_type'),
358 'repository_type': entry.get('repo_type'),
351 'repository_name': entry.get('repository'),
359 'repository_name': entry.get('repository'),
352 }
360 }
353
361
354 file_entry = {
362 file_entry = {
355 'id': entry['commit_id'],
363 'id': entry['commit_id'],
356 'value': org_query,
364 'value': org_query,
357 'value_display': '`{}` file: {}'.format(
365 'value_display': '`{}` file: {}'.format(
358 entry['repository'], entry['file']),
366 entry['repository'], entry['file']),
359 'type': 'file',
367 'type': 'file',
360 'repo': entry['repository'],
368 'repo': entry['repository'],
361 'repo_data': repo_data,
369 'repo_data': repo_data,
362
370
363 'url': h.route_path(
371 'url': h.route_path(
364 'repo_files',
372 'repo_files',
365 repo_name=entry['repository'], commit_id=entry['commit_id'],
373 repo_name=entry['repository'], commit_id=entry['commit_id'],
366 f_path=entry['file'])
374 f_path=entry['file'])
367 }
375 }
368
376
369 files.append(file_entry)
377 files.append(file_entry)
370 return files, True
378 return files, True
371
379
372 @LoginRequired()
380 @LoginRequired()
373 @view_config(
381 @view_config(
374 route_name='repo_list_data', request_method='GET',
382 route_name='repo_list_data', request_method='GET',
375 renderer='json_ext', xhr=True)
383 renderer='json_ext', xhr=True)
376 def repo_list_data(self):
384 def repo_list_data(self):
377 _ = self.request.translate
385 _ = self.request.translate
378 self.load_default_context()
386 self.load_default_context()
379
387
380 query = self.request.GET.get('query')
388 query = self.request.GET.get('query')
381 repo_type = self.request.GET.get('repo_type')
389 repo_type = self.request.GET.get('repo_type')
382 log.debug('generating repo list, query:%s, repo_type:%s',
390 log.debug('generating repo list, query:%s, repo_type:%s',
383 query, repo_type)
391 query, repo_type)
384
392
385 res = []
393 res = []
386 repos = self._get_repo_list(query, repo_type=repo_type)
394 repos = self._get_repo_list(query, repo_type=repo_type)
387 if repos:
395 if repos:
388 res.append({
396 res.append({
389 'text': _('Repositories'),
397 'text': _('Repositories'),
390 'children': repos
398 'children': repos
391 })
399 })
392
400
393 data = {
401 data = {
394 'more': False,
402 'more': False,
395 'results': res
403 'results': res
396 }
404 }
397 return data
405 return data
398
406
399 @LoginRequired()
407 @LoginRequired()
400 @view_config(
408 @view_config(
401 route_name='repo_group_list_data', request_method='GET',
409 route_name='repo_group_list_data', request_method='GET',
402 renderer='json_ext', xhr=True)
410 renderer='json_ext', xhr=True)
403 def repo_group_list_data(self):
411 def repo_group_list_data(self):
404 _ = self.request.translate
412 _ = self.request.translate
405 self.load_default_context()
413 self.load_default_context()
406
414
407 query = self.request.GET.get('query')
415 query = self.request.GET.get('query')
408
416
409 log.debug('generating repo group list, query:%s',
417 log.debug('generating repo group list, query:%s',
410 query)
418 query)
411
419
412 res = []
420 res = []
413 repo_groups = self._get_repo_group_list(query)
421 repo_groups = self._get_repo_group_list(query)
414 if repo_groups:
422 if repo_groups:
415 res.append({
423 res.append({
416 'text': _('Repository Groups'),
424 'text': _('Repository Groups'),
417 'children': repo_groups
425 'children': repo_groups
418 })
426 })
419
427
420 data = {
428 data = {
421 'more': False,
429 'more': False,
422 'results': res
430 'results': res
423 }
431 }
424 return data
432 return data
425
433
426 def _get_default_search_queries(self, search_context, searcher, query):
434 def _get_default_search_queries(self, search_context, searcher, query):
427 if not searcher:
435 if not searcher:
428 return []
436 return []
429
437
430 is_es_6 = searcher.is_es_6
438 is_es_6 = searcher.is_es_6
431
439
432 queries = []
440 queries = []
433 repo_group_name, repo_name, repo_context = None, None, None
441 repo_group_name, repo_name, repo_context = None, None, None
434
442
435 # repo group context
443 # repo group context
436 if search_context.get('search_context[repo_group_name]'):
444 if search_context.get('search_context[repo_group_name]'):
437 repo_group_name = search_context.get('search_context[repo_group_name]')
445 repo_group_name = search_context.get('search_context[repo_group_name]')
438 if search_context.get('search_context[repo_name]'):
446 if search_context.get('search_context[repo_name]'):
439 repo_name = search_context.get('search_context[repo_name]')
447 repo_name = search_context.get('search_context[repo_name]')
440 repo_context = search_context.get('search_context[repo_view_type]')
448 repo_context = search_context.get('search_context[repo_view_type]')
441
449
442 if is_es_6 and repo_name:
450 if is_es_6 and repo_name:
443 # files
451 # files
444 def query_modifier():
452 def query_modifier():
445 qry = query
453 qry = query
446 return {'q': qry, 'type': 'content'}
454 return {'q': qry, 'type': 'content'}
447
455
448 label = u'File search for `{}`'.format(h.escape(query))
456 label = u'File search for `{}`'.format(h.escape(query))
449 file_qry = {
457 file_qry = {
450 'id': -10,
458 'id': -10,
451 'value': query,
459 'value': query,
452 'value_display': label,
460 'value_display': label,
453 'value_icon': '<i class="icon-code"></i>',
461 'value_icon': '<i class="icon-code"></i>',
454 'type': 'search',
462 'type': 'search',
455 'subtype': 'repo',
463 'subtype': 'repo',
456 'url': h.route_path('search_repo',
464 'url': h.route_path('search_repo',
457 repo_name=repo_name,
465 repo_name=repo_name,
458 _query=query_modifier())
466 _query=query_modifier())
459 }
467 }
460
468
461 # commits
469 # commits
462 def query_modifier():
470 def query_modifier():
463 qry = query
471 qry = query
464 return {'q': qry, 'type': 'commit'}
472 return {'q': qry, 'type': 'commit'}
465
473
466 label = u'Commit search for `{}`'.format(h.escape(query))
474 label = u'Commit search for `{}`'.format(h.escape(query))
467 commit_qry = {
475 commit_qry = {
468 'id': -20,
476 'id': -20,
469 'value': query,
477 'value': query,
470 'value_display': label,
478 'value_display': label,
471 'value_icon': '<i class="icon-history"></i>',
479 'value_icon': '<i class="icon-history"></i>',
472 'type': 'search',
480 'type': 'search',
473 'subtype': 'repo',
481 'subtype': 'repo',
474 'url': h.route_path('search_repo',
482 'url': h.route_path('search_repo',
475 repo_name=repo_name,
483 repo_name=repo_name,
476 _query=query_modifier())
484 _query=query_modifier())
477 }
485 }
478
486
479 if repo_context in ['commit', 'commits']:
487 if repo_context in ['commit', 'commits']:
480 queries.extend([commit_qry, file_qry])
488 queries.extend([commit_qry, file_qry])
481 elif repo_context in ['files', 'summary']:
489 elif repo_context in ['files', 'summary']:
482 queries.extend([file_qry, commit_qry])
490 queries.extend([file_qry, commit_qry])
483 else:
491 else:
484 queries.extend([commit_qry, file_qry])
492 queries.extend([commit_qry, file_qry])
485
493
486 elif is_es_6 and repo_group_name:
494 elif is_es_6 and repo_group_name:
487 # files
495 # files
488 def query_modifier():
496 def query_modifier():
489 qry = query
497 qry = query
490 return {'q': qry, 'type': 'content'}
498 return {'q': qry, 'type': 'content'}
491
499
492 label = u'File search for `{}`'.format(query)
500 label = u'File search for `{}`'.format(query)
493 file_qry = {
501 file_qry = {
494 'id': -30,
502 'id': -30,
495 'value': query,
503 'value': query,
496 'value_display': label,
504 'value_display': label,
497 'value_icon': '<i class="icon-code"></i>',
505 'value_icon': '<i class="icon-code"></i>',
498 'type': 'search',
506 'type': 'search',
499 'subtype': 'repo_group',
507 'subtype': 'repo_group',
500 'url': h.route_path('search_repo_group',
508 'url': h.route_path('search_repo_group',
501 repo_group_name=repo_group_name,
509 repo_group_name=repo_group_name,
502 _query=query_modifier())
510 _query=query_modifier())
503 }
511 }
504
512
505 # commits
513 # commits
506 def query_modifier():
514 def query_modifier():
507 qry = query
515 qry = query
508 return {'q': qry, 'type': 'commit'}
516 return {'q': qry, 'type': 'commit'}
509
517
510 label = u'Commit search for `{}`'.format(query)
518 label = u'Commit search for `{}`'.format(query)
511 commit_qry = {
519 commit_qry = {
512 'id': -40,
520 'id': -40,
513 'value': query,
521 'value': query,
514 'value_display': label,
522 'value_display': label,
515 'value_icon': '<i class="icon-history"></i>',
523 'value_icon': '<i class="icon-history"></i>',
516 'type': 'search',
524 'type': 'search',
517 'subtype': 'repo_group',
525 'subtype': 'repo_group',
518 'url': h.route_path('search_repo_group',
526 'url': h.route_path('search_repo_group',
519 repo_group_name=repo_group_name,
527 repo_group_name=repo_group_name,
520 _query=query_modifier())
528 _query=query_modifier())
521 }
529 }
522
530
523 if repo_context in ['commit', 'commits']:
531 if repo_context in ['commit', 'commits']:
524 queries.extend([commit_qry, file_qry])
532 queries.extend([commit_qry, file_qry])
525 elif repo_context in ['files', 'summary']:
533 elif repo_context in ['files', 'summary']:
526 queries.extend([file_qry, commit_qry])
534 queries.extend([file_qry, commit_qry])
527 else:
535 else:
528 queries.extend([commit_qry, file_qry])
536 queries.extend([commit_qry, file_qry])
529
537
530 # Global, not scoped
538 # Global, not scoped
531 if not queries:
539 if not queries:
532 queries.append(
540 queries.append(
533 {
541 {
534 'id': -1,
542 'id': -1,
535 'value': query,
543 'value': query,
536 'value_display': u'File search for: `{}`'.format(query),
544 'value_display': u'File search for: `{}`'.format(query),
537 'value_icon': '<i class="icon-code"></i>',
545 'value_icon': '<i class="icon-code"></i>',
538 'type': 'search',
546 'type': 'search',
539 'subtype': 'global',
547 'subtype': 'global',
540 'url': h.route_path('search',
548 'url': h.route_path('search',
541 _query={'q': query, 'type': 'content'})
549 _query={'q': query, 'type': 'content'})
542 })
550 })
543 queries.append(
551 queries.append(
544 {
552 {
545 'id': -2,
553 'id': -2,
546 'value': query,
554 'value': query,
547 'value_display': u'Commit search for: `{}`'.format(query),
555 'value_display': u'Commit search for: `{}`'.format(query),
548 'value_icon': '<i class="icon-history"></i>',
556 'value_icon': '<i class="icon-history"></i>',
549 'type': 'search',
557 'type': 'search',
550 'subtype': 'global',
558 'subtype': 'global',
551 'url': h.route_path('search',
559 'url': h.route_path('search',
552 _query={'q': query, 'type': 'commit'})
560 _query={'q': query, 'type': 'commit'})
553 })
561 })
554
562
555 return queries
563 return queries
556
564
557 @LoginRequired()
565 @LoginRequired()
558 @view_config(
566 @view_config(
559 route_name='goto_switcher_data', request_method='GET',
567 route_name='goto_switcher_data', request_method='GET',
560 renderer='json_ext', xhr=True)
568 renderer='json_ext', xhr=True)
561 def goto_switcher_data(self):
569 def goto_switcher_data(self):
562 c = self.load_default_context()
570 c = self.load_default_context()
563
571
564 _ = self.request.translate
572 _ = self.request.translate
565
573
566 query = self.request.GET.get('query')
574 query = self.request.GET.get('query')
567 log.debug('generating main filter data, query %s', query)
575 log.debug('generating main filter data, query %s', query)
568
576
569 res = []
577 res = []
570 if not query:
578 if not query:
571 return {'suggestions': res}
579 return {'suggestions': res}
572
580
573 def no_match(name):
581 def no_match(name):
574 return {
582 return {
575 'id': -1,
583 'id': -1,
576 'value': "",
584 'value': "",
577 'value_display': name,
585 'value_display': name,
578 'type': 'text',
586 'type': 'text',
579 'url': ""
587 'url': ""
580 }
588 }
581 searcher = searcher_from_config(self.request.registry.settings)
589 searcher = searcher_from_config(self.request.registry.settings)
582 has_specialized_search = False
590 has_specialized_search = False
583
591
584 # set repo context
592 # set repo context
585 repo = None
593 repo = None
586 repo_id = safe_int(self.request.GET.get('search_context[repo_id]'))
594 repo_id = safe_int(self.request.GET.get('search_context[repo_id]'))
587 if repo_id:
595 if repo_id:
588 repo = Repository.get(repo_id)
596 repo = Repository.get(repo_id)
589
597
590 # set group context
598 # set group context
591 repo_group = None
599 repo_group = None
592 repo_group_id = safe_int(self.request.GET.get('search_context[repo_group_id]'))
600 repo_group_id = safe_int(self.request.GET.get('search_context[repo_group_id]'))
593 if repo_group_id:
601 if repo_group_id:
594 repo_group = RepoGroup.get(repo_group_id)
602 repo_group = RepoGroup.get(repo_group_id)
595 prefix_match = False
603 prefix_match = False
596
604
597 # user: type search
605 # user: type search
598 if not prefix_match:
606 if not prefix_match:
599 users, prefix_match = self._get_user_list(query)
607 users, prefix_match = self._get_user_list(query)
600 if users:
608 if users:
601 has_specialized_search = True
609 has_specialized_search = True
602 for serialized_user in users:
610 for serialized_user in users:
603 res.append(serialized_user)
611 res.append(serialized_user)
604 elif prefix_match:
612 elif prefix_match:
605 has_specialized_search = True
613 has_specialized_search = True
606 res.append(no_match('No matching users found'))
614 res.append(no_match('No matching users found'))
607
615
608 # user_group: type search
616 # user_group: type search
609 if not prefix_match:
617 if not prefix_match:
610 user_groups, prefix_match = self._get_user_groups_list(query)
618 user_groups, prefix_match = self._get_user_groups_list(query)
611 if user_groups:
619 if user_groups:
612 has_specialized_search = True
620 has_specialized_search = True
613 for serialized_user_group in user_groups:
621 for serialized_user_group in user_groups:
614 res.append(serialized_user_group)
622 res.append(serialized_user_group)
615 elif prefix_match:
623 elif prefix_match:
616 has_specialized_search = True
624 has_specialized_search = True
617 res.append(no_match('No matching user groups found'))
625 res.append(no_match('No matching user groups found'))
618
626
619 # FTS commit: type search
627 # FTS commit: type search
620 if not prefix_match:
628 if not prefix_match:
621 commits, prefix_match = self._get_hash_commit_list(
629 commits, prefix_match = self._get_hash_commit_list(
622 c.auth_user, searcher, query, repo, repo_group)
630 c.auth_user, searcher, query, repo, repo_group)
623 if commits:
631 if commits:
624 has_specialized_search = True
632 has_specialized_search = True
625 unique_repos = collections.OrderedDict()
633 unique_repos = collections.OrderedDict()
626 for commit in commits:
634 for commit in commits:
627 repo_name = commit['repo']
635 repo_name = commit['repo']
628 unique_repos.setdefault(repo_name, []).append(commit)
636 unique_repos.setdefault(repo_name, []).append(commit)
629
637
630 for _repo, commits in unique_repos.items():
638 for _repo, commits in unique_repos.items():
631 for commit in commits:
639 for commit in commits:
632 res.append(commit)
640 res.append(commit)
633 elif prefix_match:
641 elif prefix_match:
634 has_specialized_search = True
642 has_specialized_search = True
635 res.append(no_match('No matching commits found'))
643 res.append(no_match('No matching commits found'))
636
644
637 # FTS file: type search
645 # FTS file: type search
638 if not prefix_match:
646 if not prefix_match:
639 paths, prefix_match = self._get_path_list(
647 paths, prefix_match = self._get_path_list(
640 c.auth_user, searcher, query, repo, repo_group)
648 c.auth_user, searcher, query, repo, repo_group)
641 if paths:
649 if paths:
642 has_specialized_search = True
650 has_specialized_search = True
643 unique_repos = collections.OrderedDict()
651 unique_repos = collections.OrderedDict()
644 for path in paths:
652 for path in paths:
645 repo_name = path['repo']
653 repo_name = path['repo']
646 unique_repos.setdefault(repo_name, []).append(path)
654 unique_repos.setdefault(repo_name, []).append(path)
647
655
648 for repo, paths in unique_repos.items():
656 for repo, paths in unique_repos.items():
649 for path in paths:
657 for path in paths:
650 res.append(path)
658 res.append(path)
651 elif prefix_match:
659 elif prefix_match:
652 has_specialized_search = True
660 has_specialized_search = True
653 res.append(no_match('No matching files found'))
661 res.append(no_match('No matching files found'))
654
662
655 # main suggestions
663 # main suggestions
656 if not has_specialized_search:
664 if not has_specialized_search:
657 repo_group_name = ''
665 repo_group_name = ''
658 if repo_group:
666 if repo_group:
659 repo_group_name = repo_group.group_name
667 repo_group_name = repo_group.group_name
660
668
661 for _q in self._get_default_search_queries(self.request.GET, searcher, query):
669 for _q in self._get_default_search_queries(self.request.GET, searcher, query):
662 res.append(_q)
670 res.append(_q)
663
671
664 repo_groups = self._get_repo_group_list(query, repo_group_name=repo_group_name)
672 repo_groups = self._get_repo_group_list(query, repo_group_name=repo_group_name)
665 for serialized_repo_group in repo_groups:
673 for serialized_repo_group in repo_groups:
666 res.append(serialized_repo_group)
674 res.append(serialized_repo_group)
667
675
668 repos = self._get_repo_list(query, repo_group_name=repo_group_name)
676 repos = self._get_repo_list(query, repo_group_name=repo_group_name)
669 for serialized_repo in repos:
677 for serialized_repo in repos:
670 res.append(serialized_repo)
678 res.append(serialized_repo)
671
679
672 if not repos and not repo_groups:
680 if not repos and not repo_groups:
673 res.append(no_match('No matches found'))
681 res.append(no_match('No matches found'))
674
682
675 return {'suggestions': res}
683 return {'suggestions': res}
676
684
677 @LoginRequired()
685 @LoginRequired()
678 @view_config(
686 @view_config(
679 route_name='home', request_method='GET',
687 route_name='home', request_method='GET',
680 renderer='rhodecode:templates/index.mako')
688 renderer='rhodecode:templates/index.mako')
681 def main_page(self):
689 def main_page(self):
682 c = self.load_default_context()
690 c = self.load_default_context()
683 c.repo_group = None
691 c.repo_group = None
684 return self._get_template_context(c)
692 return self._get_template_context(c)
685
693
686 def _main_page_repo_groups_data(self, repo_group_id):
694 def _main_page_repo_groups_data(self, repo_group_id):
687 column_map = {
695 column_map = {
688 'name': 'group_name_hash',
696 'name': 'group_name_hash',
689 'desc': 'group_description',
697 'desc': 'group_description',
690 'last_change': 'updated_on',
698 'last_change': 'updated_on',
691 'owner': 'user_username',
699 'owner': 'user_username',
692 }
700 }
693 draw, start, limit = self._extract_chunk(self.request)
701 draw, start, limit = self._extract_chunk(self.request)
694 search_q, order_by, order_dir = self._extract_ordering(
702 search_q, order_by, order_dir = self._extract_ordering(
695 self.request, column_map=column_map)
703 self.request, column_map=column_map)
696 return RepoGroupModel().get_repo_groups_data_table(
704 return RepoGroupModel().get_repo_groups_data_table(
697 draw, start, limit,
705 draw, start, limit,
698 search_q, order_by, order_dir,
706 search_q, order_by, order_dir,
699 self._rhodecode_user, repo_group_id)
707 self._rhodecode_user, repo_group_id)
700
708
701 def _main_page_repos_data(self, repo_group_id):
709 def _main_page_repos_data(self, repo_group_id):
702 column_map = {
710 column_map = {
703 'name': 'repo_name',
711 'name': 'repo_name',
704 'desc': 'description',
712 'desc': 'description',
705 'last_change': 'updated_on',
713 'last_change': 'updated_on',
706 'owner': 'user_username',
714 'owner': 'user_username',
707 }
715 }
708 draw, start, limit = self._extract_chunk(self.request)
716 draw, start, limit = self._extract_chunk(self.request)
709 search_q, order_by, order_dir = self._extract_ordering(
717 search_q, order_by, order_dir = self._extract_ordering(
710 self.request, column_map=column_map)
718 self.request, column_map=column_map)
711 return RepoModel().get_repos_data_table(
719 return RepoModel().get_repos_data_table(
712 draw, start, limit,
720 draw, start, limit,
713 search_q, order_by, order_dir,
721 search_q, order_by, order_dir,
714 self._rhodecode_user, repo_group_id)
722 self._rhodecode_user, repo_group_id)
715
723
716 @LoginRequired()
724 @LoginRequired()
717 @view_config(
725 @view_config(
718 route_name='main_page_repo_groups_data',
726 route_name='main_page_repo_groups_data',
719 request_method='GET', renderer='json_ext', xhr=True)
727 request_method='GET', renderer='json_ext', xhr=True)
720 def main_page_repo_groups_data(self):
728 def main_page_repo_groups_data(self):
721 self.load_default_context()
729 self.load_default_context()
722 repo_group_id = safe_int(self.request.GET.get('repo_group_id'))
730 repo_group_id = safe_int(self.request.GET.get('repo_group_id'))
723
731
724 if repo_group_id:
732 if repo_group_id:
725 group = RepoGroup.get_or_404(repo_group_id)
733 group = RepoGroup.get_or_404(repo_group_id)
726 _perms = AuthUser.repo_group_read_perms
734 _perms = AuthUser.repo_group_read_perms
727 if not HasRepoGroupPermissionAny(*_perms)(
735 if not HasRepoGroupPermissionAny(*_perms)(
728 group.group_name, 'user is allowed to list repo group children'):
736 group.group_name, 'user is allowed to list repo group children'):
729 raise HTTPNotFound()
737 raise HTTPNotFound()
730
738
731 return self._main_page_repo_groups_data(repo_group_id)
739 return self._main_page_repo_groups_data(repo_group_id)
732
740
733 @LoginRequired()
741 @LoginRequired()
734 @view_config(
742 @view_config(
735 route_name='main_page_repos_data',
743 route_name='main_page_repos_data',
736 request_method='GET', renderer='json_ext', xhr=True)
744 request_method='GET', renderer='json_ext', xhr=True)
737 def main_page_repos_data(self):
745 def main_page_repos_data(self):
738 self.load_default_context()
746 self.load_default_context()
739 repo_group_id = safe_int(self.request.GET.get('repo_group_id'))
747 repo_group_id = safe_int(self.request.GET.get('repo_group_id'))
740
748
741 if repo_group_id:
749 if repo_group_id:
742 group = RepoGroup.get_or_404(repo_group_id)
750 group = RepoGroup.get_or_404(repo_group_id)
743 _perms = AuthUser.repo_group_read_perms
751 _perms = AuthUser.repo_group_read_perms
744 if not HasRepoGroupPermissionAny(*_perms)(
752 if not HasRepoGroupPermissionAny(*_perms)(
745 group.group_name, 'user is allowed to list repo group children'):
753 group.group_name, 'user is allowed to list repo group children'):
746 raise HTTPNotFound()
754 raise HTTPNotFound()
747
755
748 return self._main_page_repos_data(repo_group_id)
756 return self._main_page_repos_data(repo_group_id)
749
757
750 @LoginRequired()
758 @LoginRequired()
751 @HasRepoGroupPermissionAnyDecorator(*AuthUser.repo_group_read_perms)
759 @HasRepoGroupPermissionAnyDecorator(*AuthUser.repo_group_read_perms)
752 @view_config(
760 @view_config(
753 route_name='repo_group_home', request_method='GET',
761 route_name='repo_group_home', request_method='GET',
754 renderer='rhodecode:templates/index_repo_group.mako')
762 renderer='rhodecode:templates/index_repo_group.mako')
755 @view_config(
763 @view_config(
756 route_name='repo_group_home_slash', request_method='GET',
764 route_name='repo_group_home_slash', request_method='GET',
757 renderer='rhodecode:templates/index_repo_group.mako')
765 renderer='rhodecode:templates/index_repo_group.mako')
758 def repo_group_main_page(self):
766 def repo_group_main_page(self):
759 c = self.load_default_context()
767 c = self.load_default_context()
760 c.repo_group = self.request.db_repo_group
768 c.repo_group = self.request.db_repo_group
761 return self._get_template_context(c)
769 return self._get_template_context(c)
762
770
763 @LoginRequired()
771 @LoginRequired()
764 @CSRFRequired()
772 @CSRFRequired()
765 @view_config(
773 @view_config(
766 route_name='markup_preview', request_method='POST',
774 route_name='markup_preview', request_method='POST',
767 renderer='string', xhr=True)
775 renderer='string', xhr=True)
768 def markup_preview(self):
776 def markup_preview(self):
769 # Technically a CSRF token is not needed as no state changes with this
777 # Technically a CSRF token is not needed as no state changes with this
770 # call. However, as this is a POST is better to have it, so automated
778 # call. However, as this is a POST is better to have it, so automated
771 # tools don't flag it as potential CSRF.
779 # tools don't flag it as potential CSRF.
772 # Post is required because the payload could be bigger than the maximum
780 # Post is required because the payload could be bigger than the maximum
773 # allowed by GET.
781 # allowed by GET.
774
782
775 text = self.request.POST.get('text')
783 text = self.request.POST.get('text')
776 renderer = self.request.POST.get('renderer') or 'rst'
784 renderer = self.request.POST.get('renderer') or 'rst'
777 if text:
785 if text:
778 return h.render(text, renderer=renderer, mentions=True)
786 return h.render(text, renderer=renderer, mentions=True)
779 return ''
787 return ''
780
788
781 @LoginRequired()
789 @LoginRequired()
782 @CSRFRequired()
790 @CSRFRequired()
783 @view_config(
791 @view_config(
784 route_name='file_preview', request_method='POST',
792 route_name='file_preview', request_method='POST',
785 renderer='string', xhr=True)
793 renderer='string', xhr=True)
786 def file_preview(self):
794 def file_preview(self):
787 # Technically a CSRF token is not needed as no state changes with this
795 # Technically a CSRF token is not needed as no state changes with this
788 # call. However, as this is a POST is better to have it, so automated
796 # call. However, as this is a POST is better to have it, so automated
789 # tools don't flag it as potential CSRF.
797 # tools don't flag it as potential CSRF.
790 # Post is required because the payload could be bigger than the maximum
798 # Post is required because the payload could be bigger than the maximum
791 # allowed by GET.
799 # allowed by GET.
792
800
793 text = self.request.POST.get('text')
801 text = self.request.POST.get('text')
794 file_path = self.request.POST.get('file_path')
802 file_path = self.request.POST.get('file_path')
795
803
796 renderer = h.renderer_from_filename(file_path)
804 renderer = h.renderer_from_filename(file_path)
797
805
798 if renderer:
806 if renderer:
799 return h.render(text, renderer=renderer, mentions=True)
807 return h.render(text, renderer=renderer, mentions=True)
800 else:
808 else:
801 self.load_default_context()
809 self.load_default_context()
802 _render = self.request.get_partial_renderer(
810 _render = self.request.get_partial_renderer(
803 'rhodecode:templates/files/file_content.mako')
811 'rhodecode:templates/files/file_content.mako')
804
812
805 lines = filenode_as_lines_tokens(FileNode(file_path, text))
813 lines = filenode_as_lines_tokens(FileNode(file_path, text))
806
814
807 return _render('render_lines', lines)
815 return _render('render_lines', lines)
808
816
809 @LoginRequired()
817 @LoginRequired()
810 @CSRFRequired()
818 @CSRFRequired()
811 @view_config(
819 @view_config(
812 route_name='store_user_session_value', request_method='POST',
820 route_name='store_user_session_value', request_method='POST',
813 renderer='string', xhr=True)
821 renderer='string', xhr=True)
814 def store_user_session_attr(self):
822 def store_user_session_attr(self):
815 key = self.request.POST.get('key')
823 key = self.request.POST.get('key')
816 val = self.request.POST.get('val')
824 val = self.request.POST.get('val')
817
825
818 existing_value = self.request.session.get(key)
826 existing_value = self.request.session.get(key)
819 if existing_value != val:
827 if existing_value != val:
820 self.request.session[key] = val
828 self.request.session[key] = val
821
829
822 return 'stored:{}:{}'.format(key, val)
830 return 'stored:{}:{}'.format(key, val)
General Comments 0
You need to be logged in to leave comments. Login now