##// END OF EJS Templates
shadow-repos: check if path to shadow repo existing before trying to call SCM object....
marcink -
r2797:169efce7 default
parent child Browse files
Show More
@@ -1,1304 +1,1306 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2011-2018 RhodeCode GmbH
3 # Copyright (C) 2011-2018 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 logging
21 import logging
22 import collections
22 import collections
23
23
24 import formencode
24 import formencode
25 import formencode.htmlfill
25 import formencode.htmlfill
26 import peppercorn
26 import peppercorn
27 from pyramid.httpexceptions import (
27 from pyramid.httpexceptions import (
28 HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest)
28 HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest)
29 from pyramid.view import view_config
29 from pyramid.view import view_config
30 from pyramid.renderers import render
30 from pyramid.renderers import render
31
31
32 from rhodecode import events
32 from rhodecode import events
33 from rhodecode.apps._base import RepoAppView, DataGridAppView
33 from rhodecode.apps._base import RepoAppView, DataGridAppView
34
34
35 from rhodecode.lib import helpers as h, diffs, codeblocks, channelstream
35 from rhodecode.lib import helpers as h, diffs, codeblocks, channelstream
36 from rhodecode.lib.base import vcs_operation_context
36 from rhodecode.lib.base import vcs_operation_context
37 from rhodecode.lib.diffs import load_cached_diff, cache_diff, diff_cache_exist
37 from rhodecode.lib.diffs import load_cached_diff, cache_diff, diff_cache_exist
38 from rhodecode.lib.ext_json import json
38 from rhodecode.lib.ext_json import json
39 from rhodecode.lib.auth import (
39 from rhodecode.lib.auth import (
40 LoginRequired, HasRepoPermissionAny, HasRepoPermissionAnyDecorator,
40 LoginRequired, HasRepoPermissionAny, HasRepoPermissionAnyDecorator,
41 NotAnonymous, CSRFRequired)
41 NotAnonymous, CSRFRequired)
42 from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode
42 from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode
43 from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
43 from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
44 from rhodecode.lib.vcs.exceptions import (CommitDoesNotExistError,
44 from rhodecode.lib.vcs.exceptions import (CommitDoesNotExistError,
45 RepositoryRequirementError, EmptyRepositoryError)
45 RepositoryRequirementError, EmptyRepositoryError)
46 from rhodecode.model.changeset_status import ChangesetStatusModel
46 from rhodecode.model.changeset_status import ChangesetStatusModel
47 from rhodecode.model.comment import CommentsModel
47 from rhodecode.model.comment import CommentsModel
48 from rhodecode.model.db import (func, or_, PullRequest, PullRequestVersion,
48 from rhodecode.model.db import (func, or_, PullRequest, PullRequestVersion,
49 ChangesetComment, ChangesetStatus, Repository)
49 ChangesetComment, ChangesetStatus, Repository)
50 from rhodecode.model.forms import PullRequestForm
50 from rhodecode.model.forms import PullRequestForm
51 from rhodecode.model.meta import Session
51 from rhodecode.model.meta import Session
52 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
52 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
53 from rhodecode.model.scm import ScmModel
53 from rhodecode.model.scm import ScmModel
54
54
55 log = logging.getLogger(__name__)
55 log = logging.getLogger(__name__)
56
56
57
57
58 class RepoPullRequestsView(RepoAppView, DataGridAppView):
58 class RepoPullRequestsView(RepoAppView, DataGridAppView):
59
59
60 def load_default_context(self):
60 def load_default_context(self):
61 c = self._get_local_tmpl_context(include_app_defaults=True)
61 c = self._get_local_tmpl_context(include_app_defaults=True)
62 c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
62 c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
63 c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
63 c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
64
64
65 return c
65 return c
66
66
67 def _get_pull_requests_list(
67 def _get_pull_requests_list(
68 self, repo_name, source, filter_type, opened_by, statuses):
68 self, repo_name, source, filter_type, opened_by, statuses):
69
69
70 draw, start, limit = self._extract_chunk(self.request)
70 draw, start, limit = self._extract_chunk(self.request)
71 search_q, order_by, order_dir = self._extract_ordering(self.request)
71 search_q, order_by, order_dir = self._extract_ordering(self.request)
72 _render = self.request.get_partial_renderer(
72 _render = self.request.get_partial_renderer(
73 'rhodecode:templates/data_table/_dt_elements.mako')
73 'rhodecode:templates/data_table/_dt_elements.mako')
74
74
75 # pagination
75 # pagination
76
76
77 if filter_type == 'awaiting_review':
77 if filter_type == 'awaiting_review':
78 pull_requests = PullRequestModel().get_awaiting_review(
78 pull_requests = PullRequestModel().get_awaiting_review(
79 repo_name, source=source, opened_by=opened_by,
79 repo_name, source=source, opened_by=opened_by,
80 statuses=statuses, offset=start, length=limit,
80 statuses=statuses, offset=start, length=limit,
81 order_by=order_by, order_dir=order_dir)
81 order_by=order_by, order_dir=order_dir)
82 pull_requests_total_count = PullRequestModel().count_awaiting_review(
82 pull_requests_total_count = PullRequestModel().count_awaiting_review(
83 repo_name, source=source, statuses=statuses,
83 repo_name, source=source, statuses=statuses,
84 opened_by=opened_by)
84 opened_by=opened_by)
85 elif filter_type == 'awaiting_my_review':
85 elif filter_type == 'awaiting_my_review':
86 pull_requests = PullRequestModel().get_awaiting_my_review(
86 pull_requests = PullRequestModel().get_awaiting_my_review(
87 repo_name, source=source, opened_by=opened_by,
87 repo_name, source=source, opened_by=opened_by,
88 user_id=self._rhodecode_user.user_id, statuses=statuses,
88 user_id=self._rhodecode_user.user_id, statuses=statuses,
89 offset=start, length=limit, order_by=order_by,
89 offset=start, length=limit, order_by=order_by,
90 order_dir=order_dir)
90 order_dir=order_dir)
91 pull_requests_total_count = PullRequestModel().count_awaiting_my_review(
91 pull_requests_total_count = PullRequestModel().count_awaiting_my_review(
92 repo_name, source=source, user_id=self._rhodecode_user.user_id,
92 repo_name, source=source, user_id=self._rhodecode_user.user_id,
93 statuses=statuses, opened_by=opened_by)
93 statuses=statuses, opened_by=opened_by)
94 else:
94 else:
95 pull_requests = PullRequestModel().get_all(
95 pull_requests = PullRequestModel().get_all(
96 repo_name, source=source, opened_by=opened_by,
96 repo_name, source=source, opened_by=opened_by,
97 statuses=statuses, offset=start, length=limit,
97 statuses=statuses, offset=start, length=limit,
98 order_by=order_by, order_dir=order_dir)
98 order_by=order_by, order_dir=order_dir)
99 pull_requests_total_count = PullRequestModel().count_all(
99 pull_requests_total_count = PullRequestModel().count_all(
100 repo_name, source=source, statuses=statuses,
100 repo_name, source=source, statuses=statuses,
101 opened_by=opened_by)
101 opened_by=opened_by)
102
102
103 data = []
103 data = []
104 comments_model = CommentsModel()
104 comments_model = CommentsModel()
105 for pr in pull_requests:
105 for pr in pull_requests:
106 comments = comments_model.get_all_comments(
106 comments = comments_model.get_all_comments(
107 self.db_repo.repo_id, pull_request=pr)
107 self.db_repo.repo_id, pull_request=pr)
108
108
109 data.append({
109 data.append({
110 'name': _render('pullrequest_name',
110 'name': _render('pullrequest_name',
111 pr.pull_request_id, pr.target_repo.repo_name),
111 pr.pull_request_id, pr.target_repo.repo_name),
112 'name_raw': pr.pull_request_id,
112 'name_raw': pr.pull_request_id,
113 'status': _render('pullrequest_status',
113 'status': _render('pullrequest_status',
114 pr.calculated_review_status()),
114 pr.calculated_review_status()),
115 'title': _render(
115 'title': _render(
116 'pullrequest_title', pr.title, pr.description),
116 'pullrequest_title', pr.title, pr.description),
117 'description': h.escape(pr.description),
117 'description': h.escape(pr.description),
118 'updated_on': _render('pullrequest_updated_on',
118 'updated_on': _render('pullrequest_updated_on',
119 h.datetime_to_time(pr.updated_on)),
119 h.datetime_to_time(pr.updated_on)),
120 'updated_on_raw': h.datetime_to_time(pr.updated_on),
120 'updated_on_raw': h.datetime_to_time(pr.updated_on),
121 'created_on': _render('pullrequest_updated_on',
121 'created_on': _render('pullrequest_updated_on',
122 h.datetime_to_time(pr.created_on)),
122 h.datetime_to_time(pr.created_on)),
123 'created_on_raw': h.datetime_to_time(pr.created_on),
123 'created_on_raw': h.datetime_to_time(pr.created_on),
124 'author': _render('pullrequest_author',
124 'author': _render('pullrequest_author',
125 pr.author.full_contact, ),
125 pr.author.full_contact, ),
126 'author_raw': pr.author.full_name,
126 'author_raw': pr.author.full_name,
127 'comments': _render('pullrequest_comments', len(comments)),
127 'comments': _render('pullrequest_comments', len(comments)),
128 'comments_raw': len(comments),
128 'comments_raw': len(comments),
129 'closed': pr.is_closed(),
129 'closed': pr.is_closed(),
130 })
130 })
131
131
132 data = ({
132 data = ({
133 'draw': draw,
133 'draw': draw,
134 'data': data,
134 'data': data,
135 'recordsTotal': pull_requests_total_count,
135 'recordsTotal': pull_requests_total_count,
136 'recordsFiltered': pull_requests_total_count,
136 'recordsFiltered': pull_requests_total_count,
137 })
137 })
138 return data
138 return data
139
139
140 @LoginRequired()
140 @LoginRequired()
141 @HasRepoPermissionAnyDecorator(
141 @HasRepoPermissionAnyDecorator(
142 'repository.read', 'repository.write', 'repository.admin')
142 'repository.read', 'repository.write', 'repository.admin')
143 @view_config(
143 @view_config(
144 route_name='pullrequest_show_all', request_method='GET',
144 route_name='pullrequest_show_all', request_method='GET',
145 renderer='rhodecode:templates/pullrequests/pullrequests.mako')
145 renderer='rhodecode:templates/pullrequests/pullrequests.mako')
146 def pull_request_list(self):
146 def pull_request_list(self):
147 c = self.load_default_context()
147 c = self.load_default_context()
148
148
149 req_get = self.request.GET
149 req_get = self.request.GET
150 c.source = str2bool(req_get.get('source'))
150 c.source = str2bool(req_get.get('source'))
151 c.closed = str2bool(req_get.get('closed'))
151 c.closed = str2bool(req_get.get('closed'))
152 c.my = str2bool(req_get.get('my'))
152 c.my = str2bool(req_get.get('my'))
153 c.awaiting_review = str2bool(req_get.get('awaiting_review'))
153 c.awaiting_review = str2bool(req_get.get('awaiting_review'))
154 c.awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
154 c.awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
155
155
156 c.active = 'open'
156 c.active = 'open'
157 if c.my:
157 if c.my:
158 c.active = 'my'
158 c.active = 'my'
159 if c.closed:
159 if c.closed:
160 c.active = 'closed'
160 c.active = 'closed'
161 if c.awaiting_review and not c.source:
161 if c.awaiting_review and not c.source:
162 c.active = 'awaiting'
162 c.active = 'awaiting'
163 if c.source and not c.awaiting_review:
163 if c.source and not c.awaiting_review:
164 c.active = 'source'
164 c.active = 'source'
165 if c.awaiting_my_review:
165 if c.awaiting_my_review:
166 c.active = 'awaiting_my'
166 c.active = 'awaiting_my'
167
167
168 return self._get_template_context(c)
168 return self._get_template_context(c)
169
169
170 @LoginRequired()
170 @LoginRequired()
171 @HasRepoPermissionAnyDecorator(
171 @HasRepoPermissionAnyDecorator(
172 'repository.read', 'repository.write', 'repository.admin')
172 'repository.read', 'repository.write', 'repository.admin')
173 @view_config(
173 @view_config(
174 route_name='pullrequest_show_all_data', request_method='GET',
174 route_name='pullrequest_show_all_data', request_method='GET',
175 renderer='json_ext', xhr=True)
175 renderer='json_ext', xhr=True)
176 def pull_request_list_data(self):
176 def pull_request_list_data(self):
177 self.load_default_context()
177 self.load_default_context()
178
178
179 # additional filters
179 # additional filters
180 req_get = self.request.GET
180 req_get = self.request.GET
181 source = str2bool(req_get.get('source'))
181 source = str2bool(req_get.get('source'))
182 closed = str2bool(req_get.get('closed'))
182 closed = str2bool(req_get.get('closed'))
183 my = str2bool(req_get.get('my'))
183 my = str2bool(req_get.get('my'))
184 awaiting_review = str2bool(req_get.get('awaiting_review'))
184 awaiting_review = str2bool(req_get.get('awaiting_review'))
185 awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
185 awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
186
186
187 filter_type = 'awaiting_review' if awaiting_review \
187 filter_type = 'awaiting_review' if awaiting_review \
188 else 'awaiting_my_review' if awaiting_my_review \
188 else 'awaiting_my_review' if awaiting_my_review \
189 else None
189 else None
190
190
191 opened_by = None
191 opened_by = None
192 if my:
192 if my:
193 opened_by = [self._rhodecode_user.user_id]
193 opened_by = [self._rhodecode_user.user_id]
194
194
195 statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
195 statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
196 if closed:
196 if closed:
197 statuses = [PullRequest.STATUS_CLOSED]
197 statuses = [PullRequest.STATUS_CLOSED]
198
198
199 data = self._get_pull_requests_list(
199 data = self._get_pull_requests_list(
200 repo_name=self.db_repo_name, source=source,
200 repo_name=self.db_repo_name, source=source,
201 filter_type=filter_type, opened_by=opened_by, statuses=statuses)
201 filter_type=filter_type, opened_by=opened_by, statuses=statuses)
202
202
203 return data
203 return data
204
204
205 def _is_diff_cache_enabled(self, target_repo):
205 def _is_diff_cache_enabled(self, target_repo):
206 caching_enabled = self._get_general_setting(
206 caching_enabled = self._get_general_setting(
207 target_repo, 'rhodecode_diff_cache')
207 target_repo, 'rhodecode_diff_cache')
208 log.debug('Diff caching enabled: %s', caching_enabled)
208 log.debug('Diff caching enabled: %s', caching_enabled)
209 return caching_enabled
209 return caching_enabled
210
210
211 def _get_diffset(self, source_repo_name, source_repo,
211 def _get_diffset(self, source_repo_name, source_repo,
212 source_ref_id, target_ref_id,
212 source_ref_id, target_ref_id,
213 target_commit, source_commit, diff_limit, file_limit,
213 target_commit, source_commit, diff_limit, file_limit,
214 fulldiff):
214 fulldiff):
215
215
216 vcs_diff = PullRequestModel().get_diff(
216 vcs_diff = PullRequestModel().get_diff(
217 source_repo, source_ref_id, target_ref_id)
217 source_repo, source_ref_id, target_ref_id)
218
218
219 diff_processor = diffs.DiffProcessor(
219 diff_processor = diffs.DiffProcessor(
220 vcs_diff, format='newdiff', diff_limit=diff_limit,
220 vcs_diff, format='newdiff', diff_limit=diff_limit,
221 file_limit=file_limit, show_full_diff=fulldiff)
221 file_limit=file_limit, show_full_diff=fulldiff)
222
222
223 _parsed = diff_processor.prepare()
223 _parsed = diff_processor.prepare()
224
224
225 diffset = codeblocks.DiffSet(
225 diffset = codeblocks.DiffSet(
226 repo_name=self.db_repo_name,
226 repo_name=self.db_repo_name,
227 source_repo_name=source_repo_name,
227 source_repo_name=source_repo_name,
228 source_node_getter=codeblocks.diffset_node_getter(target_commit),
228 source_node_getter=codeblocks.diffset_node_getter(target_commit),
229 target_node_getter=codeblocks.diffset_node_getter(source_commit),
229 target_node_getter=codeblocks.diffset_node_getter(source_commit),
230 )
230 )
231 diffset = self.path_filter.render_patchset_filtered(
231 diffset = self.path_filter.render_patchset_filtered(
232 diffset, _parsed, target_commit.raw_id, source_commit.raw_id)
232 diffset, _parsed, target_commit.raw_id, source_commit.raw_id)
233
233
234 return diffset
234 return diffset
235
235
236 @LoginRequired()
236 @LoginRequired()
237 @HasRepoPermissionAnyDecorator(
237 @HasRepoPermissionAnyDecorator(
238 'repository.read', 'repository.write', 'repository.admin')
238 'repository.read', 'repository.write', 'repository.admin')
239 @view_config(
239 @view_config(
240 route_name='pullrequest_show', request_method='GET',
240 route_name='pullrequest_show', request_method='GET',
241 renderer='rhodecode:templates/pullrequests/pullrequest_show.mako')
241 renderer='rhodecode:templates/pullrequests/pullrequest_show.mako')
242 def pull_request_show(self):
242 def pull_request_show(self):
243 pull_request_id = self.request.matchdict['pull_request_id']
243 pull_request_id = self.request.matchdict['pull_request_id']
244
244
245 c = self.load_default_context()
245 c = self.load_default_context()
246
246
247 version = self.request.GET.get('version')
247 version = self.request.GET.get('version')
248 from_version = self.request.GET.get('from_version') or version
248 from_version = self.request.GET.get('from_version') or version
249 merge_checks = self.request.GET.get('merge_checks')
249 merge_checks = self.request.GET.get('merge_checks')
250 c.fulldiff = str2bool(self.request.GET.get('fulldiff'))
250 c.fulldiff = str2bool(self.request.GET.get('fulldiff'))
251 force_refresh = str2bool(self.request.GET.get('force_refresh'))
251 force_refresh = str2bool(self.request.GET.get('force_refresh'))
252
252
253 (pull_request_latest,
253 (pull_request_latest,
254 pull_request_at_ver,
254 pull_request_at_ver,
255 pull_request_display_obj,
255 pull_request_display_obj,
256 at_version) = PullRequestModel().get_pr_version(
256 at_version) = PullRequestModel().get_pr_version(
257 pull_request_id, version=version)
257 pull_request_id, version=version)
258 pr_closed = pull_request_latest.is_closed()
258 pr_closed = pull_request_latest.is_closed()
259
259
260 if pr_closed and (version or from_version):
260 if pr_closed and (version or from_version):
261 # not allow to browse versions
261 # not allow to browse versions
262 raise HTTPFound(h.route_path(
262 raise HTTPFound(h.route_path(
263 'pullrequest_show', repo_name=self.db_repo_name,
263 'pullrequest_show', repo_name=self.db_repo_name,
264 pull_request_id=pull_request_id))
264 pull_request_id=pull_request_id))
265
265
266 versions = pull_request_display_obj.versions()
266 versions = pull_request_display_obj.versions()
267
267
268 c.at_version = at_version
268 c.at_version = at_version
269 c.at_version_num = (at_version
269 c.at_version_num = (at_version
270 if at_version and at_version != 'latest'
270 if at_version and at_version != 'latest'
271 else None)
271 else None)
272 c.at_version_pos = ChangesetComment.get_index_from_version(
272 c.at_version_pos = ChangesetComment.get_index_from_version(
273 c.at_version_num, versions)
273 c.at_version_num, versions)
274
274
275 (prev_pull_request_latest,
275 (prev_pull_request_latest,
276 prev_pull_request_at_ver,
276 prev_pull_request_at_ver,
277 prev_pull_request_display_obj,
277 prev_pull_request_display_obj,
278 prev_at_version) = PullRequestModel().get_pr_version(
278 prev_at_version) = PullRequestModel().get_pr_version(
279 pull_request_id, version=from_version)
279 pull_request_id, version=from_version)
280
280
281 c.from_version = prev_at_version
281 c.from_version = prev_at_version
282 c.from_version_num = (prev_at_version
282 c.from_version_num = (prev_at_version
283 if prev_at_version and prev_at_version != 'latest'
283 if prev_at_version and prev_at_version != 'latest'
284 else None)
284 else None)
285 c.from_version_pos = ChangesetComment.get_index_from_version(
285 c.from_version_pos = ChangesetComment.get_index_from_version(
286 c.from_version_num, versions)
286 c.from_version_num, versions)
287
287
288 # define if we're in COMPARE mode or VIEW at version mode
288 # define if we're in COMPARE mode or VIEW at version mode
289 compare = at_version != prev_at_version
289 compare = at_version != prev_at_version
290
290
291 # pull_requests repo_name we opened it against
291 # pull_requests repo_name we opened it against
292 # ie. target_repo must match
292 # ie. target_repo must match
293 if self.db_repo_name != pull_request_at_ver.target_repo.repo_name:
293 if self.db_repo_name != pull_request_at_ver.target_repo.repo_name:
294 raise HTTPNotFound()
294 raise HTTPNotFound()
295
295
296 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
296 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
297 pull_request_at_ver)
297 pull_request_at_ver)
298
298
299 c.pull_request = pull_request_display_obj
299 c.pull_request = pull_request_display_obj
300 c.pull_request_latest = pull_request_latest
300 c.pull_request_latest = pull_request_latest
301
301
302 if compare or (at_version and not at_version == 'latest'):
302 if compare or (at_version and not at_version == 'latest'):
303 c.allowed_to_change_status = False
303 c.allowed_to_change_status = False
304 c.allowed_to_update = False
304 c.allowed_to_update = False
305 c.allowed_to_merge = False
305 c.allowed_to_merge = False
306 c.allowed_to_delete = False
306 c.allowed_to_delete = False
307 c.allowed_to_comment = False
307 c.allowed_to_comment = False
308 c.allowed_to_close = False
308 c.allowed_to_close = False
309 else:
309 else:
310 can_change_status = PullRequestModel().check_user_change_status(
310 can_change_status = PullRequestModel().check_user_change_status(
311 pull_request_at_ver, self._rhodecode_user)
311 pull_request_at_ver, self._rhodecode_user)
312 c.allowed_to_change_status = can_change_status and not pr_closed
312 c.allowed_to_change_status = can_change_status and not pr_closed
313
313
314 c.allowed_to_update = PullRequestModel().check_user_update(
314 c.allowed_to_update = PullRequestModel().check_user_update(
315 pull_request_latest, self._rhodecode_user) and not pr_closed
315 pull_request_latest, self._rhodecode_user) and not pr_closed
316 c.allowed_to_merge = PullRequestModel().check_user_merge(
316 c.allowed_to_merge = PullRequestModel().check_user_merge(
317 pull_request_latest, self._rhodecode_user) and not pr_closed
317 pull_request_latest, self._rhodecode_user) and not pr_closed
318 c.allowed_to_delete = PullRequestModel().check_user_delete(
318 c.allowed_to_delete = PullRequestModel().check_user_delete(
319 pull_request_latest, self._rhodecode_user) and not pr_closed
319 pull_request_latest, self._rhodecode_user) and not pr_closed
320 c.allowed_to_comment = not pr_closed
320 c.allowed_to_comment = not pr_closed
321 c.allowed_to_close = c.allowed_to_merge and not pr_closed
321 c.allowed_to_close = c.allowed_to_merge and not pr_closed
322
322
323 c.forbid_adding_reviewers = False
323 c.forbid_adding_reviewers = False
324 c.forbid_author_to_review = False
324 c.forbid_author_to_review = False
325 c.forbid_commit_author_to_review = False
325 c.forbid_commit_author_to_review = False
326
326
327 if pull_request_latest.reviewer_data and \
327 if pull_request_latest.reviewer_data and \
328 'rules' in pull_request_latest.reviewer_data:
328 'rules' in pull_request_latest.reviewer_data:
329 rules = pull_request_latest.reviewer_data['rules'] or {}
329 rules = pull_request_latest.reviewer_data['rules'] or {}
330 try:
330 try:
331 c.forbid_adding_reviewers = rules.get(
331 c.forbid_adding_reviewers = rules.get(
332 'forbid_adding_reviewers')
332 'forbid_adding_reviewers')
333 c.forbid_author_to_review = rules.get(
333 c.forbid_author_to_review = rules.get(
334 'forbid_author_to_review')
334 'forbid_author_to_review')
335 c.forbid_commit_author_to_review = rules.get(
335 c.forbid_commit_author_to_review = rules.get(
336 'forbid_commit_author_to_review')
336 'forbid_commit_author_to_review')
337 except Exception:
337 except Exception:
338 pass
338 pass
339
339
340 # check merge capabilities
340 # check merge capabilities
341 _merge_check = MergeCheck.validate(
341 _merge_check = MergeCheck.validate(
342 pull_request_latest, user=self._rhodecode_user,
342 pull_request_latest, user=self._rhodecode_user,
343 translator=self.request.translate, force_shadow_repo_refresh=force_refresh)
343 translator=self.request.translate, force_shadow_repo_refresh=force_refresh)
344 c.pr_merge_errors = _merge_check.error_details
344 c.pr_merge_errors = _merge_check.error_details
345 c.pr_merge_possible = not _merge_check.failed
345 c.pr_merge_possible = not _merge_check.failed
346 c.pr_merge_message = _merge_check.merge_msg
346 c.pr_merge_message = _merge_check.merge_msg
347
347
348 c.pr_merge_info = MergeCheck.get_merge_conditions(
348 c.pr_merge_info = MergeCheck.get_merge_conditions(
349 pull_request_latest, translator=self.request.translate)
349 pull_request_latest, translator=self.request.translate)
350
350
351 c.pull_request_review_status = _merge_check.review_status
351 c.pull_request_review_status = _merge_check.review_status
352 if merge_checks:
352 if merge_checks:
353 self.request.override_renderer = \
353 self.request.override_renderer = \
354 'rhodecode:templates/pullrequests/pullrequest_merge_checks.mako'
354 'rhodecode:templates/pullrequests/pullrequest_merge_checks.mako'
355 return self._get_template_context(c)
355 return self._get_template_context(c)
356
356
357 comments_model = CommentsModel()
357 comments_model = CommentsModel()
358
358
359 # reviewers and statuses
359 # reviewers and statuses
360 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
360 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
361 allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
361 allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
362
362
363 # GENERAL COMMENTS with versions #
363 # GENERAL COMMENTS with versions #
364 q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
364 q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
365 q = q.order_by(ChangesetComment.comment_id.asc())
365 q = q.order_by(ChangesetComment.comment_id.asc())
366 general_comments = q
366 general_comments = q
367
367
368 # pick comments we want to render at current version
368 # pick comments we want to render at current version
369 c.comment_versions = comments_model.aggregate_comments(
369 c.comment_versions = comments_model.aggregate_comments(
370 general_comments, versions, c.at_version_num)
370 general_comments, versions, c.at_version_num)
371 c.comments = c.comment_versions[c.at_version_num]['until']
371 c.comments = c.comment_versions[c.at_version_num]['until']
372
372
373 # INLINE COMMENTS with versions #
373 # INLINE COMMENTS with versions #
374 q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
374 q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
375 q = q.order_by(ChangesetComment.comment_id.asc())
375 q = q.order_by(ChangesetComment.comment_id.asc())
376 inline_comments = q
376 inline_comments = q
377
377
378 c.inline_versions = comments_model.aggregate_comments(
378 c.inline_versions = comments_model.aggregate_comments(
379 inline_comments, versions, c.at_version_num, inline=True)
379 inline_comments, versions, c.at_version_num, inline=True)
380
380
381 # inject latest version
381 # inject latest version
382 latest_ver = PullRequest.get_pr_display_object(
382 latest_ver = PullRequest.get_pr_display_object(
383 pull_request_latest, pull_request_latest)
383 pull_request_latest, pull_request_latest)
384
384
385 c.versions = versions + [latest_ver]
385 c.versions = versions + [latest_ver]
386
386
387 # if we use version, then do not show later comments
387 # if we use version, then do not show later comments
388 # than current version
388 # than current version
389 display_inline_comments = collections.defaultdict(
389 display_inline_comments = collections.defaultdict(
390 lambda: collections.defaultdict(list))
390 lambda: collections.defaultdict(list))
391 for co in inline_comments:
391 for co in inline_comments:
392 if c.at_version_num:
392 if c.at_version_num:
393 # pick comments that are at least UPTO given version, so we
393 # pick comments that are at least UPTO given version, so we
394 # don't render comments for higher version
394 # don't render comments for higher version
395 should_render = co.pull_request_version_id and \
395 should_render = co.pull_request_version_id and \
396 co.pull_request_version_id <= c.at_version_num
396 co.pull_request_version_id <= c.at_version_num
397 else:
397 else:
398 # showing all, for 'latest'
398 # showing all, for 'latest'
399 should_render = True
399 should_render = True
400
400
401 if should_render:
401 if should_render:
402 display_inline_comments[co.f_path][co.line_no].append(co)
402 display_inline_comments[co.f_path][co.line_no].append(co)
403
403
404 # load diff data into template context, if we use compare mode then
404 # load diff data into template context, if we use compare mode then
405 # diff is calculated based on changes between versions of PR
405 # diff is calculated based on changes between versions of PR
406
406
407 source_repo = pull_request_at_ver.source_repo
407 source_repo = pull_request_at_ver.source_repo
408 source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
408 source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
409
409
410 target_repo = pull_request_at_ver.target_repo
410 target_repo = pull_request_at_ver.target_repo
411 target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
411 target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
412
412
413 if compare:
413 if compare:
414 # in compare switch the diff base to latest commit from prev version
414 # in compare switch the diff base to latest commit from prev version
415 target_ref_id = prev_pull_request_display_obj.revisions[0]
415 target_ref_id = prev_pull_request_display_obj.revisions[0]
416
416
417 # despite opening commits for bookmarks/branches/tags, we always
417 # despite opening commits for bookmarks/branches/tags, we always
418 # convert this to rev to prevent changes after bookmark or branch change
418 # convert this to rev to prevent changes after bookmark or branch change
419 c.source_ref_type = 'rev'
419 c.source_ref_type = 'rev'
420 c.source_ref = source_ref_id
420 c.source_ref = source_ref_id
421
421
422 c.target_ref_type = 'rev'
422 c.target_ref_type = 'rev'
423 c.target_ref = target_ref_id
423 c.target_ref = target_ref_id
424
424
425 c.source_repo = source_repo
425 c.source_repo = source_repo
426 c.target_repo = target_repo
426 c.target_repo = target_repo
427
427
428 c.commit_ranges = []
428 c.commit_ranges = []
429 source_commit = EmptyCommit()
429 source_commit = EmptyCommit()
430 target_commit = EmptyCommit()
430 target_commit = EmptyCommit()
431 c.missing_requirements = False
431 c.missing_requirements = False
432
432
433 source_scm = source_repo.scm_instance()
433 source_scm = source_repo.scm_instance()
434 target_scm = target_repo.scm_instance()
434 target_scm = target_repo.scm_instance()
435
435
436 # try first shadow repo, fallback to regular repo
436 shadow_scm = None
437 try:
437 try:
438 commits_source_repo = pull_request_latest.get_shadow_repo()
438 shadow_scm = pull_request_latest.get_shadow_repo()
439 except Exception:
439 except Exception:
440 log.debug('Failed to get shadow repo', exc_info=True)
440 log.debug('Failed to get shadow repo', exc_info=True)
441 commits_source_repo = source_scm
441 # try first the existing source_repo, and then shadow
442 # repo if we can obtain one
443 commits_source_repo = source_scm or shadow_scm
442
444
443 c.commits_source_repo = commits_source_repo
445 c.commits_source_repo = commits_source_repo
444 c.ancestor = None # set it to None, to hide it from PR view
446 c.ancestor = None # set it to None, to hide it from PR view
445
447
446 # empty version means latest, so we keep this to prevent
448 # empty version means latest, so we keep this to prevent
447 # double caching
449 # double caching
448 version_normalized = version or 'latest'
450 version_normalized = version or 'latest'
449 from_version_normalized = from_version or 'latest'
451 from_version_normalized = from_version or 'latest'
450
452
451 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
453 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
452 target_repo)
454 target_repo)
453 cache_file_path = diff_cache_exist(
455 cache_file_path = diff_cache_exist(
454 cache_path, 'pull_request', pull_request_id, version_normalized,
456 cache_path, 'pull_request', pull_request_id, version_normalized,
455 from_version_normalized, source_ref_id, target_ref_id, c.fulldiff)
457 from_version_normalized, source_ref_id, target_ref_id, c.fulldiff)
456
458
457 caching_enabled = self._is_diff_cache_enabled(c.target_repo)
459 caching_enabled = self._is_diff_cache_enabled(c.target_repo)
458 force_recache = str2bool(self.request.GET.get('force_recache'))
460 force_recache = str2bool(self.request.GET.get('force_recache'))
459
461
460 cached_diff = None
462 cached_diff = None
461 if caching_enabled:
463 if caching_enabled:
462 cached_diff = load_cached_diff(cache_file_path)
464 cached_diff = load_cached_diff(cache_file_path)
463
465
464 has_proper_commit_cache = (
466 has_proper_commit_cache = (
465 cached_diff and cached_diff.get('commits')
467 cached_diff and cached_diff.get('commits')
466 and len(cached_diff.get('commits', [])) == 5
468 and len(cached_diff.get('commits', [])) == 5
467 and cached_diff.get('commits')[0]
469 and cached_diff.get('commits')[0]
468 and cached_diff.get('commits')[3])
470 and cached_diff.get('commits')[3])
469 if not force_recache and has_proper_commit_cache:
471 if not force_recache and has_proper_commit_cache:
470 diff_commit_cache = \
472 diff_commit_cache = \
471 (ancestor_commit, commit_cache, missing_requirements,
473 (ancestor_commit, commit_cache, missing_requirements,
472 source_commit, target_commit) = cached_diff['commits']
474 source_commit, target_commit) = cached_diff['commits']
473 else:
475 else:
474 diff_commit_cache = \
476 diff_commit_cache = \
475 (ancestor_commit, commit_cache, missing_requirements,
477 (ancestor_commit, commit_cache, missing_requirements,
476 source_commit, target_commit) = self.get_commits(
478 source_commit, target_commit) = self.get_commits(
477 commits_source_repo,
479 commits_source_repo,
478 pull_request_at_ver,
480 pull_request_at_ver,
479 source_commit,
481 source_commit,
480 source_ref_id,
482 source_ref_id,
481 source_scm,
483 source_scm,
482 target_commit,
484 target_commit,
483 target_ref_id,
485 target_ref_id,
484 target_scm)
486 target_scm)
485
487
486 # register our commit range
488 # register our commit range
487 for comm in commit_cache.values():
489 for comm in commit_cache.values():
488 c.commit_ranges.append(comm)
490 c.commit_ranges.append(comm)
489
491
490 c.missing_requirements = missing_requirements
492 c.missing_requirements = missing_requirements
491 c.ancestor_commit = ancestor_commit
493 c.ancestor_commit = ancestor_commit
492 c.statuses = source_repo.statuses(
494 c.statuses = source_repo.statuses(
493 [x.raw_id for x in c.commit_ranges])
495 [x.raw_id for x in c.commit_ranges])
494
496
495 # auto collapse if we have more than limit
497 # auto collapse if we have more than limit
496 collapse_limit = diffs.DiffProcessor._collapse_commits_over
498 collapse_limit = diffs.DiffProcessor._collapse_commits_over
497 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
499 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
498 c.compare_mode = compare
500 c.compare_mode = compare
499
501
500 # diff_limit is the old behavior, will cut off the whole diff
502 # diff_limit is the old behavior, will cut off the whole diff
501 # if the limit is applied otherwise will just hide the
503 # if the limit is applied otherwise will just hide the
502 # big files from the front-end
504 # big files from the front-end
503 diff_limit = c.visual.cut_off_limit_diff
505 diff_limit = c.visual.cut_off_limit_diff
504 file_limit = c.visual.cut_off_limit_file
506 file_limit = c.visual.cut_off_limit_file
505
507
506 c.missing_commits = False
508 c.missing_commits = False
507 if (c.missing_requirements
509 if (c.missing_requirements
508 or isinstance(source_commit, EmptyCommit)
510 or isinstance(source_commit, EmptyCommit)
509 or source_commit == target_commit):
511 or source_commit == target_commit):
510
512
511 c.missing_commits = True
513 c.missing_commits = True
512 else:
514 else:
513 c.inline_comments = display_inline_comments
515 c.inline_comments = display_inline_comments
514
516
515 has_proper_diff_cache = cached_diff and cached_diff.get('commits')
517 has_proper_diff_cache = cached_diff and cached_diff.get('commits')
516 if not force_recache and has_proper_diff_cache:
518 if not force_recache and has_proper_diff_cache:
517 c.diffset = cached_diff['diff']
519 c.diffset = cached_diff['diff']
518 (ancestor_commit, commit_cache, missing_requirements,
520 (ancestor_commit, commit_cache, missing_requirements,
519 source_commit, target_commit) = cached_diff['commits']
521 source_commit, target_commit) = cached_diff['commits']
520 else:
522 else:
521 c.diffset = self._get_diffset(
523 c.diffset = self._get_diffset(
522 c.source_repo.repo_name, commits_source_repo,
524 c.source_repo.repo_name, commits_source_repo,
523 source_ref_id, target_ref_id,
525 source_ref_id, target_ref_id,
524 target_commit, source_commit,
526 target_commit, source_commit,
525 diff_limit, file_limit, c.fulldiff)
527 diff_limit, file_limit, c.fulldiff)
526
528
527 # save cached diff
529 # save cached diff
528 if caching_enabled:
530 if caching_enabled:
529 cache_diff(cache_file_path, c.diffset, diff_commit_cache)
531 cache_diff(cache_file_path, c.diffset, diff_commit_cache)
530
532
531 c.limited_diff = c.diffset.limited_diff
533 c.limited_diff = c.diffset.limited_diff
532
534
533 # calculate removed files that are bound to comments
535 # calculate removed files that are bound to comments
534 comment_deleted_files = [
536 comment_deleted_files = [
535 fname for fname in display_inline_comments
537 fname for fname in display_inline_comments
536 if fname not in c.diffset.file_stats]
538 if fname not in c.diffset.file_stats]
537
539
538 c.deleted_files_comments = collections.defaultdict(dict)
540 c.deleted_files_comments = collections.defaultdict(dict)
539 for fname, per_line_comments in display_inline_comments.items():
541 for fname, per_line_comments in display_inline_comments.items():
540 if fname in comment_deleted_files:
542 if fname in comment_deleted_files:
541 c.deleted_files_comments[fname]['stats'] = 0
543 c.deleted_files_comments[fname]['stats'] = 0
542 c.deleted_files_comments[fname]['comments'] = list()
544 c.deleted_files_comments[fname]['comments'] = list()
543 for lno, comments in per_line_comments.items():
545 for lno, comments in per_line_comments.items():
544 c.deleted_files_comments[fname]['comments'].extend(
546 c.deleted_files_comments[fname]['comments'].extend(
545 comments)
547 comments)
546
548
547 # this is a hack to properly display links, when creating PR, the
549 # this is a hack to properly display links, when creating PR, the
548 # compare view and others uses different notation, and
550 # compare view and others uses different notation, and
549 # compare_commits.mako renders links based on the target_repo.
551 # compare_commits.mako renders links based on the target_repo.
550 # We need to swap that here to generate it properly on the html side
552 # We need to swap that here to generate it properly on the html side
551 c.target_repo = c.source_repo
553 c.target_repo = c.source_repo
552
554
553 c.commit_statuses = ChangesetStatus.STATUSES
555 c.commit_statuses = ChangesetStatus.STATUSES
554
556
555 c.show_version_changes = not pr_closed
557 c.show_version_changes = not pr_closed
556 if c.show_version_changes:
558 if c.show_version_changes:
557 cur_obj = pull_request_at_ver
559 cur_obj = pull_request_at_ver
558 prev_obj = prev_pull_request_at_ver
560 prev_obj = prev_pull_request_at_ver
559
561
560 old_commit_ids = prev_obj.revisions
562 old_commit_ids = prev_obj.revisions
561 new_commit_ids = cur_obj.revisions
563 new_commit_ids = cur_obj.revisions
562 commit_changes = PullRequestModel()._calculate_commit_id_changes(
564 commit_changes = PullRequestModel()._calculate_commit_id_changes(
563 old_commit_ids, new_commit_ids)
565 old_commit_ids, new_commit_ids)
564 c.commit_changes_summary = commit_changes
566 c.commit_changes_summary = commit_changes
565
567
566 # calculate the diff for commits between versions
568 # calculate the diff for commits between versions
567 c.commit_changes = []
569 c.commit_changes = []
568 mark = lambda cs, fw: list(
570 mark = lambda cs, fw: list(
569 h.itertools.izip_longest([], cs, fillvalue=fw))
571 h.itertools.izip_longest([], cs, fillvalue=fw))
570 for c_type, raw_id in mark(commit_changes.added, 'a') \
572 for c_type, raw_id in mark(commit_changes.added, 'a') \
571 + mark(commit_changes.removed, 'r') \
573 + mark(commit_changes.removed, 'r') \
572 + mark(commit_changes.common, 'c'):
574 + mark(commit_changes.common, 'c'):
573
575
574 if raw_id in commit_cache:
576 if raw_id in commit_cache:
575 commit = commit_cache[raw_id]
577 commit = commit_cache[raw_id]
576 else:
578 else:
577 try:
579 try:
578 commit = commits_source_repo.get_commit(raw_id)
580 commit = commits_source_repo.get_commit(raw_id)
579 except CommitDoesNotExistError:
581 except CommitDoesNotExistError:
580 # in case we fail extracting still use "dummy" commit
582 # in case we fail extracting still use "dummy" commit
581 # for display in commit diff
583 # for display in commit diff
582 commit = h.AttributeDict(
584 commit = h.AttributeDict(
583 {'raw_id': raw_id,
585 {'raw_id': raw_id,
584 'message': 'EMPTY or MISSING COMMIT'})
586 'message': 'EMPTY or MISSING COMMIT'})
585 c.commit_changes.append([c_type, commit])
587 c.commit_changes.append([c_type, commit])
586
588
587 # current user review statuses for each version
589 # current user review statuses for each version
588 c.review_versions = {}
590 c.review_versions = {}
589 if self._rhodecode_user.user_id in allowed_reviewers:
591 if self._rhodecode_user.user_id in allowed_reviewers:
590 for co in general_comments:
592 for co in general_comments:
591 if co.author.user_id == self._rhodecode_user.user_id:
593 if co.author.user_id == self._rhodecode_user.user_id:
592 status = co.status_change
594 status = co.status_change
593 if status:
595 if status:
594 _ver_pr = status[0].comment.pull_request_version_id
596 _ver_pr = status[0].comment.pull_request_version_id
595 c.review_versions[_ver_pr] = status[0]
597 c.review_versions[_ver_pr] = status[0]
596
598
597 return self._get_template_context(c)
599 return self._get_template_context(c)
598
600
599 def get_commits(
601 def get_commits(
600 self, commits_source_repo, pull_request_at_ver, source_commit,
602 self, commits_source_repo, pull_request_at_ver, source_commit,
601 source_ref_id, source_scm, target_commit, target_ref_id, target_scm):
603 source_ref_id, source_scm, target_commit, target_ref_id, target_scm):
602 commit_cache = collections.OrderedDict()
604 commit_cache = collections.OrderedDict()
603 missing_requirements = False
605 missing_requirements = False
604 try:
606 try:
605 pre_load = ["author", "branch", "date", "message"]
607 pre_load = ["author", "branch", "date", "message"]
606 show_revs = pull_request_at_ver.revisions
608 show_revs = pull_request_at_ver.revisions
607 for rev in show_revs:
609 for rev in show_revs:
608 comm = commits_source_repo.get_commit(
610 comm = commits_source_repo.get_commit(
609 commit_id=rev, pre_load=pre_load)
611 commit_id=rev, pre_load=pre_load)
610 commit_cache[comm.raw_id] = comm
612 commit_cache[comm.raw_id] = comm
611
613
612 # Order here matters, we first need to get target, and then
614 # Order here matters, we first need to get target, and then
613 # the source
615 # the source
614 target_commit = commits_source_repo.get_commit(
616 target_commit = commits_source_repo.get_commit(
615 commit_id=safe_str(target_ref_id))
617 commit_id=safe_str(target_ref_id))
616
618
617 source_commit = commits_source_repo.get_commit(
619 source_commit = commits_source_repo.get_commit(
618 commit_id=safe_str(source_ref_id))
620 commit_id=safe_str(source_ref_id))
619 except CommitDoesNotExistError:
621 except CommitDoesNotExistError:
620 log.warning(
622 log.warning(
621 'Failed to get commit from `{}` repo'.format(
623 'Failed to get commit from `{}` repo'.format(
622 commits_source_repo), exc_info=True)
624 commits_source_repo), exc_info=True)
623 except RepositoryRequirementError:
625 except RepositoryRequirementError:
624 log.warning(
626 log.warning(
625 'Failed to get all required data from repo', exc_info=True)
627 'Failed to get all required data from repo', exc_info=True)
626 missing_requirements = True
628 missing_requirements = True
627 ancestor_commit = None
629 ancestor_commit = None
628 try:
630 try:
629 ancestor_id = source_scm.get_common_ancestor(
631 ancestor_id = source_scm.get_common_ancestor(
630 source_commit.raw_id, target_commit.raw_id, target_scm)
632 source_commit.raw_id, target_commit.raw_id, target_scm)
631 ancestor_commit = source_scm.get_commit(ancestor_id)
633 ancestor_commit = source_scm.get_commit(ancestor_id)
632 except Exception:
634 except Exception:
633 ancestor_commit = None
635 ancestor_commit = None
634 return ancestor_commit, commit_cache, missing_requirements, source_commit, target_commit
636 return ancestor_commit, commit_cache, missing_requirements, source_commit, target_commit
635
637
636 def assure_not_empty_repo(self):
638 def assure_not_empty_repo(self):
637 _ = self.request.translate
639 _ = self.request.translate
638
640
639 try:
641 try:
640 self.db_repo.scm_instance().get_commit()
642 self.db_repo.scm_instance().get_commit()
641 except EmptyRepositoryError:
643 except EmptyRepositoryError:
642 h.flash(h.literal(_('There are no commits yet')),
644 h.flash(h.literal(_('There are no commits yet')),
643 category='warning')
645 category='warning')
644 raise HTTPFound(
646 raise HTTPFound(
645 h.route_path('repo_summary', repo_name=self.db_repo.repo_name))
647 h.route_path('repo_summary', repo_name=self.db_repo.repo_name))
646
648
647 @LoginRequired()
649 @LoginRequired()
648 @NotAnonymous()
650 @NotAnonymous()
649 @HasRepoPermissionAnyDecorator(
651 @HasRepoPermissionAnyDecorator(
650 'repository.read', 'repository.write', 'repository.admin')
652 'repository.read', 'repository.write', 'repository.admin')
651 @view_config(
653 @view_config(
652 route_name='pullrequest_new', request_method='GET',
654 route_name='pullrequest_new', request_method='GET',
653 renderer='rhodecode:templates/pullrequests/pullrequest.mako')
655 renderer='rhodecode:templates/pullrequests/pullrequest.mako')
654 def pull_request_new(self):
656 def pull_request_new(self):
655 _ = self.request.translate
657 _ = self.request.translate
656 c = self.load_default_context()
658 c = self.load_default_context()
657
659
658 self.assure_not_empty_repo()
660 self.assure_not_empty_repo()
659 source_repo = self.db_repo
661 source_repo = self.db_repo
660
662
661 commit_id = self.request.GET.get('commit')
663 commit_id = self.request.GET.get('commit')
662 branch_ref = self.request.GET.get('branch')
664 branch_ref = self.request.GET.get('branch')
663 bookmark_ref = self.request.GET.get('bookmark')
665 bookmark_ref = self.request.GET.get('bookmark')
664
666
665 try:
667 try:
666 source_repo_data = PullRequestModel().generate_repo_data(
668 source_repo_data = PullRequestModel().generate_repo_data(
667 source_repo, commit_id=commit_id,
669 source_repo, commit_id=commit_id,
668 branch=branch_ref, bookmark=bookmark_ref,
670 branch=branch_ref, bookmark=bookmark_ref,
669 translator=self.request.translate)
671 translator=self.request.translate)
670 except CommitDoesNotExistError as e:
672 except CommitDoesNotExistError as e:
671 log.exception(e)
673 log.exception(e)
672 h.flash(_('Commit does not exist'), 'error')
674 h.flash(_('Commit does not exist'), 'error')
673 raise HTTPFound(
675 raise HTTPFound(
674 h.route_path('pullrequest_new', repo_name=source_repo.repo_name))
676 h.route_path('pullrequest_new', repo_name=source_repo.repo_name))
675
677
676 default_target_repo = source_repo
678 default_target_repo = source_repo
677
679
678 if source_repo.parent:
680 if source_repo.parent:
679 parent_vcs_obj = source_repo.parent.scm_instance()
681 parent_vcs_obj = source_repo.parent.scm_instance()
680 if parent_vcs_obj and not parent_vcs_obj.is_empty():
682 if parent_vcs_obj and not parent_vcs_obj.is_empty():
681 # change default if we have a parent repo
683 # change default if we have a parent repo
682 default_target_repo = source_repo.parent
684 default_target_repo = source_repo.parent
683
685
684 target_repo_data = PullRequestModel().generate_repo_data(
686 target_repo_data = PullRequestModel().generate_repo_data(
685 default_target_repo, translator=self.request.translate)
687 default_target_repo, translator=self.request.translate)
686
688
687 selected_source_ref = source_repo_data['refs']['selected_ref']
689 selected_source_ref = source_repo_data['refs']['selected_ref']
688 title_source_ref = ''
690 title_source_ref = ''
689 if selected_source_ref:
691 if selected_source_ref:
690 title_source_ref = selected_source_ref.split(':', 2)[1]
692 title_source_ref = selected_source_ref.split(':', 2)[1]
691 c.default_title = PullRequestModel().generate_pullrequest_title(
693 c.default_title = PullRequestModel().generate_pullrequest_title(
692 source=source_repo.repo_name,
694 source=source_repo.repo_name,
693 source_ref=title_source_ref,
695 source_ref=title_source_ref,
694 target=default_target_repo.repo_name
696 target=default_target_repo.repo_name
695 )
697 )
696
698
697 c.default_repo_data = {
699 c.default_repo_data = {
698 'source_repo_name': source_repo.repo_name,
700 'source_repo_name': source_repo.repo_name,
699 'source_refs_json': json.dumps(source_repo_data),
701 'source_refs_json': json.dumps(source_repo_data),
700 'target_repo_name': default_target_repo.repo_name,
702 'target_repo_name': default_target_repo.repo_name,
701 'target_refs_json': json.dumps(target_repo_data),
703 'target_refs_json': json.dumps(target_repo_data),
702 }
704 }
703 c.default_source_ref = selected_source_ref
705 c.default_source_ref = selected_source_ref
704
706
705 return self._get_template_context(c)
707 return self._get_template_context(c)
706
708
707 @LoginRequired()
709 @LoginRequired()
708 @NotAnonymous()
710 @NotAnonymous()
709 @HasRepoPermissionAnyDecorator(
711 @HasRepoPermissionAnyDecorator(
710 'repository.read', 'repository.write', 'repository.admin')
712 'repository.read', 'repository.write', 'repository.admin')
711 @view_config(
713 @view_config(
712 route_name='pullrequest_repo_refs', request_method='GET',
714 route_name='pullrequest_repo_refs', request_method='GET',
713 renderer='json_ext', xhr=True)
715 renderer='json_ext', xhr=True)
714 def pull_request_repo_refs(self):
716 def pull_request_repo_refs(self):
715 self.load_default_context()
717 self.load_default_context()
716 target_repo_name = self.request.matchdict['target_repo_name']
718 target_repo_name = self.request.matchdict['target_repo_name']
717 repo = Repository.get_by_repo_name(target_repo_name)
719 repo = Repository.get_by_repo_name(target_repo_name)
718 if not repo:
720 if not repo:
719 raise HTTPNotFound()
721 raise HTTPNotFound()
720
722
721 target_perm = HasRepoPermissionAny(
723 target_perm = HasRepoPermissionAny(
722 'repository.read', 'repository.write', 'repository.admin')(
724 'repository.read', 'repository.write', 'repository.admin')(
723 target_repo_name)
725 target_repo_name)
724 if not target_perm:
726 if not target_perm:
725 raise HTTPNotFound()
727 raise HTTPNotFound()
726
728
727 return PullRequestModel().generate_repo_data(
729 return PullRequestModel().generate_repo_data(
728 repo, translator=self.request.translate)
730 repo, translator=self.request.translate)
729
731
730 @LoginRequired()
732 @LoginRequired()
731 @NotAnonymous()
733 @NotAnonymous()
732 @HasRepoPermissionAnyDecorator(
734 @HasRepoPermissionAnyDecorator(
733 'repository.read', 'repository.write', 'repository.admin')
735 'repository.read', 'repository.write', 'repository.admin')
734 @view_config(
736 @view_config(
735 route_name='pullrequest_repo_destinations', request_method='GET',
737 route_name='pullrequest_repo_destinations', request_method='GET',
736 renderer='json_ext', xhr=True)
738 renderer='json_ext', xhr=True)
737 def pull_request_repo_destinations(self):
739 def pull_request_repo_destinations(self):
738 _ = self.request.translate
740 _ = self.request.translate
739 filter_query = self.request.GET.get('query')
741 filter_query = self.request.GET.get('query')
740
742
741 query = Repository.query() \
743 query = Repository.query() \
742 .order_by(func.length(Repository.repo_name)) \
744 .order_by(func.length(Repository.repo_name)) \
743 .filter(
745 .filter(
744 or_(Repository.repo_name == self.db_repo.repo_name,
746 or_(Repository.repo_name == self.db_repo.repo_name,
745 Repository.fork_id == self.db_repo.repo_id))
747 Repository.fork_id == self.db_repo.repo_id))
746
748
747 if filter_query:
749 if filter_query:
748 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
750 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
749 query = query.filter(
751 query = query.filter(
750 Repository.repo_name.ilike(ilike_expression))
752 Repository.repo_name.ilike(ilike_expression))
751
753
752 add_parent = False
754 add_parent = False
753 if self.db_repo.parent:
755 if self.db_repo.parent:
754 if filter_query in self.db_repo.parent.repo_name:
756 if filter_query in self.db_repo.parent.repo_name:
755 parent_vcs_obj = self.db_repo.parent.scm_instance()
757 parent_vcs_obj = self.db_repo.parent.scm_instance()
756 if parent_vcs_obj and not parent_vcs_obj.is_empty():
758 if parent_vcs_obj and not parent_vcs_obj.is_empty():
757 add_parent = True
759 add_parent = True
758
760
759 limit = 20 - 1 if add_parent else 20
761 limit = 20 - 1 if add_parent else 20
760 all_repos = query.limit(limit).all()
762 all_repos = query.limit(limit).all()
761 if add_parent:
763 if add_parent:
762 all_repos += [self.db_repo.parent]
764 all_repos += [self.db_repo.parent]
763
765
764 repos = []
766 repos = []
765 for obj in ScmModel().get_repos(all_repos):
767 for obj in ScmModel().get_repos(all_repos):
766 repos.append({
768 repos.append({
767 'id': obj['name'],
769 'id': obj['name'],
768 'text': obj['name'],
770 'text': obj['name'],
769 'type': 'repo',
771 'type': 'repo',
770 'repo_id': obj['dbrepo']['repo_id'],
772 'repo_id': obj['dbrepo']['repo_id'],
771 'repo_type': obj['dbrepo']['repo_type'],
773 'repo_type': obj['dbrepo']['repo_type'],
772 'private': obj['dbrepo']['private'],
774 'private': obj['dbrepo']['private'],
773
775
774 })
776 })
775
777
776 data = {
778 data = {
777 'more': False,
779 'more': False,
778 'results': [{
780 'results': [{
779 'text': _('Repositories'),
781 'text': _('Repositories'),
780 'children': repos
782 'children': repos
781 }] if repos else []
783 }] if repos else []
782 }
784 }
783 return data
785 return data
784
786
785 @LoginRequired()
787 @LoginRequired()
786 @NotAnonymous()
788 @NotAnonymous()
787 @HasRepoPermissionAnyDecorator(
789 @HasRepoPermissionAnyDecorator(
788 'repository.read', 'repository.write', 'repository.admin')
790 'repository.read', 'repository.write', 'repository.admin')
789 @CSRFRequired()
791 @CSRFRequired()
790 @view_config(
792 @view_config(
791 route_name='pullrequest_create', request_method='POST',
793 route_name='pullrequest_create', request_method='POST',
792 renderer=None)
794 renderer=None)
793 def pull_request_create(self):
795 def pull_request_create(self):
794 _ = self.request.translate
796 _ = self.request.translate
795 self.assure_not_empty_repo()
797 self.assure_not_empty_repo()
796 self.load_default_context()
798 self.load_default_context()
797
799
798 controls = peppercorn.parse(self.request.POST.items())
800 controls = peppercorn.parse(self.request.POST.items())
799
801
800 try:
802 try:
801 form = PullRequestForm(
803 form = PullRequestForm(
802 self.request.translate, self.db_repo.repo_id)()
804 self.request.translate, self.db_repo.repo_id)()
803 _form = form.to_python(controls)
805 _form = form.to_python(controls)
804 except formencode.Invalid as errors:
806 except formencode.Invalid as errors:
805 if errors.error_dict.get('revisions'):
807 if errors.error_dict.get('revisions'):
806 msg = 'Revisions: %s' % errors.error_dict['revisions']
808 msg = 'Revisions: %s' % errors.error_dict['revisions']
807 elif errors.error_dict.get('pullrequest_title'):
809 elif errors.error_dict.get('pullrequest_title'):
808 msg = errors.error_dict.get('pullrequest_title')
810 msg = errors.error_dict.get('pullrequest_title')
809 else:
811 else:
810 msg = _('Error creating pull request: {}').format(errors)
812 msg = _('Error creating pull request: {}').format(errors)
811 log.exception(msg)
813 log.exception(msg)
812 h.flash(msg, 'error')
814 h.flash(msg, 'error')
813
815
814 # would rather just go back to form ...
816 # would rather just go back to form ...
815 raise HTTPFound(
817 raise HTTPFound(
816 h.route_path('pullrequest_new', repo_name=self.db_repo_name))
818 h.route_path('pullrequest_new', repo_name=self.db_repo_name))
817
819
818 source_repo = _form['source_repo']
820 source_repo = _form['source_repo']
819 source_ref = _form['source_ref']
821 source_ref = _form['source_ref']
820 target_repo = _form['target_repo']
822 target_repo = _form['target_repo']
821 target_ref = _form['target_ref']
823 target_ref = _form['target_ref']
822 commit_ids = _form['revisions'][::-1]
824 commit_ids = _form['revisions'][::-1]
823
825
824 # find the ancestor for this pr
826 # find the ancestor for this pr
825 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
827 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
826 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
828 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
827
829
828 # re-check permissions again here
830 # re-check permissions again here
829 # source_repo we must have read permissions
831 # source_repo we must have read permissions
830
832
831 source_perm = HasRepoPermissionAny(
833 source_perm = HasRepoPermissionAny(
832 'repository.read',
834 'repository.read',
833 'repository.write', 'repository.admin')(source_db_repo.repo_name)
835 'repository.write', 'repository.admin')(source_db_repo.repo_name)
834 if not source_perm:
836 if not source_perm:
835 msg = _('Not Enough permissions to source repo `{}`.'.format(
837 msg = _('Not Enough permissions to source repo `{}`.'.format(
836 source_db_repo.repo_name))
838 source_db_repo.repo_name))
837 h.flash(msg, category='error')
839 h.flash(msg, category='error')
838 # copy the args back to redirect
840 # copy the args back to redirect
839 org_query = self.request.GET.mixed()
841 org_query = self.request.GET.mixed()
840 raise HTTPFound(
842 raise HTTPFound(
841 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
843 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
842 _query=org_query))
844 _query=org_query))
843
845
844 # target repo we must have read permissions, and also later on
846 # target repo we must have read permissions, and also later on
845 # we want to check branch permissions here
847 # we want to check branch permissions here
846 target_perm = HasRepoPermissionAny(
848 target_perm = HasRepoPermissionAny(
847 'repository.read',
849 'repository.read',
848 'repository.write', 'repository.admin')(target_db_repo.repo_name)
850 'repository.write', 'repository.admin')(target_db_repo.repo_name)
849 if not target_perm:
851 if not target_perm:
850 msg = _('Not Enough permissions to target repo `{}`.'.format(
852 msg = _('Not Enough permissions to target repo `{}`.'.format(
851 target_db_repo.repo_name))
853 target_db_repo.repo_name))
852 h.flash(msg, category='error')
854 h.flash(msg, category='error')
853 # copy the args back to redirect
855 # copy the args back to redirect
854 org_query = self.request.GET.mixed()
856 org_query = self.request.GET.mixed()
855 raise HTTPFound(
857 raise HTTPFound(
856 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
858 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
857 _query=org_query))
859 _query=org_query))
858
860
859 source_scm = source_db_repo.scm_instance()
861 source_scm = source_db_repo.scm_instance()
860 target_scm = target_db_repo.scm_instance()
862 target_scm = target_db_repo.scm_instance()
861
863
862 source_commit = source_scm.get_commit(source_ref.split(':')[-1])
864 source_commit = source_scm.get_commit(source_ref.split(':')[-1])
863 target_commit = target_scm.get_commit(target_ref.split(':')[-1])
865 target_commit = target_scm.get_commit(target_ref.split(':')[-1])
864
866
865 ancestor = source_scm.get_common_ancestor(
867 ancestor = source_scm.get_common_ancestor(
866 source_commit.raw_id, target_commit.raw_id, target_scm)
868 source_commit.raw_id, target_commit.raw_id, target_scm)
867
869
868 target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
870 target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
869 target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
871 target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
870
872
871 pullrequest_title = _form['pullrequest_title']
873 pullrequest_title = _form['pullrequest_title']
872 title_source_ref = source_ref.split(':', 2)[1]
874 title_source_ref = source_ref.split(':', 2)[1]
873 if not pullrequest_title:
875 if not pullrequest_title:
874 pullrequest_title = PullRequestModel().generate_pullrequest_title(
876 pullrequest_title = PullRequestModel().generate_pullrequest_title(
875 source=source_repo,
877 source=source_repo,
876 source_ref=title_source_ref,
878 source_ref=title_source_ref,
877 target=target_repo
879 target=target_repo
878 )
880 )
879
881
880 description = _form['pullrequest_desc']
882 description = _form['pullrequest_desc']
881
883
882 get_default_reviewers_data, validate_default_reviewers = \
884 get_default_reviewers_data, validate_default_reviewers = \
883 PullRequestModel().get_reviewer_functions()
885 PullRequestModel().get_reviewer_functions()
884
886
885 # recalculate reviewers logic, to make sure we can validate this
887 # recalculate reviewers logic, to make sure we can validate this
886 reviewer_rules = get_default_reviewers_data(
888 reviewer_rules = get_default_reviewers_data(
887 self._rhodecode_db_user, source_db_repo,
889 self._rhodecode_db_user, source_db_repo,
888 source_commit, target_db_repo, target_commit)
890 source_commit, target_db_repo, target_commit)
889
891
890 given_reviewers = _form['review_members']
892 given_reviewers = _form['review_members']
891 reviewers = validate_default_reviewers(given_reviewers, reviewer_rules)
893 reviewers = validate_default_reviewers(given_reviewers, reviewer_rules)
892
894
893 try:
895 try:
894 pull_request = PullRequestModel().create(
896 pull_request = PullRequestModel().create(
895 self._rhodecode_user.user_id, source_repo, source_ref,
897 self._rhodecode_user.user_id, source_repo, source_ref,
896 target_repo, target_ref, commit_ids, reviewers,
898 target_repo, target_ref, commit_ids, reviewers,
897 pullrequest_title, description, reviewer_rules,
899 pullrequest_title, description, reviewer_rules,
898 auth_user=self._rhodecode_user
900 auth_user=self._rhodecode_user
899 )
901 )
900 Session().commit()
902 Session().commit()
901
903
902 h.flash(_('Successfully opened new pull request'),
904 h.flash(_('Successfully opened new pull request'),
903 category='success')
905 category='success')
904 except Exception:
906 except Exception:
905 msg = _('Error occurred during creation of this pull request.')
907 msg = _('Error occurred during creation of this pull request.')
906 log.exception(msg)
908 log.exception(msg)
907 h.flash(msg, category='error')
909 h.flash(msg, category='error')
908
910
909 # copy the args back to redirect
911 # copy the args back to redirect
910 org_query = self.request.GET.mixed()
912 org_query = self.request.GET.mixed()
911 raise HTTPFound(
913 raise HTTPFound(
912 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
914 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
913 _query=org_query))
915 _query=org_query))
914
916
915 raise HTTPFound(
917 raise HTTPFound(
916 h.route_path('pullrequest_show', repo_name=target_repo,
918 h.route_path('pullrequest_show', repo_name=target_repo,
917 pull_request_id=pull_request.pull_request_id))
919 pull_request_id=pull_request.pull_request_id))
918
920
919 @LoginRequired()
921 @LoginRequired()
920 @NotAnonymous()
922 @NotAnonymous()
921 @HasRepoPermissionAnyDecorator(
923 @HasRepoPermissionAnyDecorator(
922 'repository.read', 'repository.write', 'repository.admin')
924 'repository.read', 'repository.write', 'repository.admin')
923 @CSRFRequired()
925 @CSRFRequired()
924 @view_config(
926 @view_config(
925 route_name='pullrequest_update', request_method='POST',
927 route_name='pullrequest_update', request_method='POST',
926 renderer='json_ext')
928 renderer='json_ext')
927 def pull_request_update(self):
929 def pull_request_update(self):
928 pull_request = PullRequest.get_or_404(
930 pull_request = PullRequest.get_or_404(
929 self.request.matchdict['pull_request_id'])
931 self.request.matchdict['pull_request_id'])
930 _ = self.request.translate
932 _ = self.request.translate
931
933
932 self.load_default_context()
934 self.load_default_context()
933
935
934 if pull_request.is_closed():
936 if pull_request.is_closed():
935 log.debug('update: forbidden because pull request is closed')
937 log.debug('update: forbidden because pull request is closed')
936 msg = _(u'Cannot update closed pull requests.')
938 msg = _(u'Cannot update closed pull requests.')
937 h.flash(msg, category='error')
939 h.flash(msg, category='error')
938 return True
940 return True
939
941
940 # only owner or admin can update it
942 # only owner or admin can update it
941 allowed_to_update = PullRequestModel().check_user_update(
943 allowed_to_update = PullRequestModel().check_user_update(
942 pull_request, self._rhodecode_user)
944 pull_request, self._rhodecode_user)
943 if allowed_to_update:
945 if allowed_to_update:
944 controls = peppercorn.parse(self.request.POST.items())
946 controls = peppercorn.parse(self.request.POST.items())
945
947
946 if 'review_members' in controls:
948 if 'review_members' in controls:
947 self._update_reviewers(
949 self._update_reviewers(
948 pull_request, controls['review_members'],
950 pull_request, controls['review_members'],
949 pull_request.reviewer_data)
951 pull_request.reviewer_data)
950 elif str2bool(self.request.POST.get('update_commits', 'false')):
952 elif str2bool(self.request.POST.get('update_commits', 'false')):
951 self._update_commits(pull_request)
953 self._update_commits(pull_request)
952 elif str2bool(self.request.POST.get('edit_pull_request', 'false')):
954 elif str2bool(self.request.POST.get('edit_pull_request', 'false')):
953 self._edit_pull_request(pull_request)
955 self._edit_pull_request(pull_request)
954 else:
956 else:
955 raise HTTPBadRequest()
957 raise HTTPBadRequest()
956 return True
958 return True
957 raise HTTPForbidden()
959 raise HTTPForbidden()
958
960
959 def _edit_pull_request(self, pull_request):
961 def _edit_pull_request(self, pull_request):
960 _ = self.request.translate
962 _ = self.request.translate
961 try:
963 try:
962 PullRequestModel().edit(
964 PullRequestModel().edit(
963 pull_request, self.request.POST.get('title'),
965 pull_request, self.request.POST.get('title'),
964 self.request.POST.get('description'), self._rhodecode_user)
966 self.request.POST.get('description'), self._rhodecode_user)
965 except ValueError:
967 except ValueError:
966 msg = _(u'Cannot update closed pull requests.')
968 msg = _(u'Cannot update closed pull requests.')
967 h.flash(msg, category='error')
969 h.flash(msg, category='error')
968 return
970 return
969 else:
971 else:
970 Session().commit()
972 Session().commit()
971
973
972 msg = _(u'Pull request title & description updated.')
974 msg = _(u'Pull request title & description updated.')
973 h.flash(msg, category='success')
975 h.flash(msg, category='success')
974 return
976 return
975
977
976 def _update_commits(self, pull_request):
978 def _update_commits(self, pull_request):
977 _ = self.request.translate
979 _ = self.request.translate
978 resp = PullRequestModel().update_commits(pull_request)
980 resp = PullRequestModel().update_commits(pull_request)
979
981
980 if resp.executed:
982 if resp.executed:
981
983
982 if resp.target_changed and resp.source_changed:
984 if resp.target_changed and resp.source_changed:
983 changed = 'target and source repositories'
985 changed = 'target and source repositories'
984 elif resp.target_changed and not resp.source_changed:
986 elif resp.target_changed and not resp.source_changed:
985 changed = 'target repository'
987 changed = 'target repository'
986 elif not resp.target_changed and resp.source_changed:
988 elif not resp.target_changed and resp.source_changed:
987 changed = 'source repository'
989 changed = 'source repository'
988 else:
990 else:
989 changed = 'nothing'
991 changed = 'nothing'
990
992
991 msg = _(
993 msg = _(
992 u'Pull request updated to "{source_commit_id}" with '
994 u'Pull request updated to "{source_commit_id}" with '
993 u'{count_added} added, {count_removed} removed commits. '
995 u'{count_added} added, {count_removed} removed commits. '
994 u'Source of changes: {change_source}')
996 u'Source of changes: {change_source}')
995 msg = msg.format(
997 msg = msg.format(
996 source_commit_id=pull_request.source_ref_parts.commit_id,
998 source_commit_id=pull_request.source_ref_parts.commit_id,
997 count_added=len(resp.changes.added),
999 count_added=len(resp.changes.added),
998 count_removed=len(resp.changes.removed),
1000 count_removed=len(resp.changes.removed),
999 change_source=changed)
1001 change_source=changed)
1000 h.flash(msg, category='success')
1002 h.flash(msg, category='success')
1001
1003
1002 channel = '/repo${}$/pr/{}'.format(
1004 channel = '/repo${}$/pr/{}'.format(
1003 pull_request.target_repo.repo_name,
1005 pull_request.target_repo.repo_name,
1004 pull_request.pull_request_id)
1006 pull_request.pull_request_id)
1005 message = msg + (
1007 message = msg + (
1006 ' - <a onclick="window.location.reload()">'
1008 ' - <a onclick="window.location.reload()">'
1007 '<strong>{}</strong></a>'.format(_('Reload page')))
1009 '<strong>{}</strong></a>'.format(_('Reload page')))
1008 channelstream.post_message(
1010 channelstream.post_message(
1009 channel, message, self._rhodecode_user.username,
1011 channel, message, self._rhodecode_user.username,
1010 registry=self.request.registry)
1012 registry=self.request.registry)
1011 else:
1013 else:
1012 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
1014 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
1013 warning_reasons = [
1015 warning_reasons = [
1014 UpdateFailureReason.NO_CHANGE,
1016 UpdateFailureReason.NO_CHANGE,
1015 UpdateFailureReason.WRONG_REF_TYPE,
1017 UpdateFailureReason.WRONG_REF_TYPE,
1016 ]
1018 ]
1017 category = 'warning' if resp.reason in warning_reasons else 'error'
1019 category = 'warning' if resp.reason in warning_reasons else 'error'
1018 h.flash(msg, category=category)
1020 h.flash(msg, category=category)
1019
1021
1020 @LoginRequired()
1022 @LoginRequired()
1021 @NotAnonymous()
1023 @NotAnonymous()
1022 @HasRepoPermissionAnyDecorator(
1024 @HasRepoPermissionAnyDecorator(
1023 'repository.read', 'repository.write', 'repository.admin')
1025 'repository.read', 'repository.write', 'repository.admin')
1024 @CSRFRequired()
1026 @CSRFRequired()
1025 @view_config(
1027 @view_config(
1026 route_name='pullrequest_merge', request_method='POST',
1028 route_name='pullrequest_merge', request_method='POST',
1027 renderer='json_ext')
1029 renderer='json_ext')
1028 def pull_request_merge(self):
1030 def pull_request_merge(self):
1029 """
1031 """
1030 Merge will perform a server-side merge of the specified
1032 Merge will perform a server-side merge of the specified
1031 pull request, if the pull request is approved and mergeable.
1033 pull request, if the pull request is approved and mergeable.
1032 After successful merging, the pull request is automatically
1034 After successful merging, the pull request is automatically
1033 closed, with a relevant comment.
1035 closed, with a relevant comment.
1034 """
1036 """
1035 pull_request = PullRequest.get_or_404(
1037 pull_request = PullRequest.get_or_404(
1036 self.request.matchdict['pull_request_id'])
1038 self.request.matchdict['pull_request_id'])
1037
1039
1038 self.load_default_context()
1040 self.load_default_context()
1039 check = MergeCheck.validate(pull_request, self._rhodecode_db_user,
1041 check = MergeCheck.validate(pull_request, self._rhodecode_db_user,
1040 translator=self.request.translate)
1042 translator=self.request.translate)
1041 merge_possible = not check.failed
1043 merge_possible = not check.failed
1042
1044
1043 for err_type, error_msg in check.errors:
1045 for err_type, error_msg in check.errors:
1044 h.flash(error_msg, category=err_type)
1046 h.flash(error_msg, category=err_type)
1045
1047
1046 if merge_possible:
1048 if merge_possible:
1047 log.debug("Pre-conditions checked, trying to merge.")
1049 log.debug("Pre-conditions checked, trying to merge.")
1048 extras = vcs_operation_context(
1050 extras = vcs_operation_context(
1049 self.request.environ, repo_name=pull_request.target_repo.repo_name,
1051 self.request.environ, repo_name=pull_request.target_repo.repo_name,
1050 username=self._rhodecode_db_user.username, action='push',
1052 username=self._rhodecode_db_user.username, action='push',
1051 scm=pull_request.target_repo.repo_type)
1053 scm=pull_request.target_repo.repo_type)
1052 self._merge_pull_request(
1054 self._merge_pull_request(
1053 pull_request, self._rhodecode_db_user, extras)
1055 pull_request, self._rhodecode_db_user, extras)
1054 else:
1056 else:
1055 log.debug("Pre-conditions failed, NOT merging.")
1057 log.debug("Pre-conditions failed, NOT merging.")
1056
1058
1057 raise HTTPFound(
1059 raise HTTPFound(
1058 h.route_path('pullrequest_show',
1060 h.route_path('pullrequest_show',
1059 repo_name=pull_request.target_repo.repo_name,
1061 repo_name=pull_request.target_repo.repo_name,
1060 pull_request_id=pull_request.pull_request_id))
1062 pull_request_id=pull_request.pull_request_id))
1061
1063
1062 def _merge_pull_request(self, pull_request, user, extras):
1064 def _merge_pull_request(self, pull_request, user, extras):
1063 _ = self.request.translate
1065 _ = self.request.translate
1064 merge_resp = PullRequestModel().merge(pull_request, user, extras=extras)
1066 merge_resp = PullRequestModel().merge(pull_request, user, extras=extras)
1065
1067
1066 if merge_resp.executed:
1068 if merge_resp.executed:
1067 log.debug("The merge was successful, closing the pull request.")
1069 log.debug("The merge was successful, closing the pull request.")
1068 PullRequestModel().close_pull_request(
1070 PullRequestModel().close_pull_request(
1069 pull_request.pull_request_id, user)
1071 pull_request.pull_request_id, user)
1070 Session().commit()
1072 Session().commit()
1071 msg = _('Pull request was successfully merged and closed.')
1073 msg = _('Pull request was successfully merged and closed.')
1072 h.flash(msg, category='success')
1074 h.flash(msg, category='success')
1073 else:
1075 else:
1074 log.debug(
1076 log.debug(
1075 "The merge was not successful. Merge response: %s",
1077 "The merge was not successful. Merge response: %s",
1076 merge_resp)
1078 merge_resp)
1077 msg = PullRequestModel().merge_status_message(
1079 msg = PullRequestModel().merge_status_message(
1078 merge_resp.failure_reason)
1080 merge_resp.failure_reason)
1079 h.flash(msg, category='error')
1081 h.flash(msg, category='error')
1080
1082
1081 def _update_reviewers(self, pull_request, review_members, reviewer_rules):
1083 def _update_reviewers(self, pull_request, review_members, reviewer_rules):
1082 _ = self.request.translate
1084 _ = self.request.translate
1083 get_default_reviewers_data, validate_default_reviewers = \
1085 get_default_reviewers_data, validate_default_reviewers = \
1084 PullRequestModel().get_reviewer_functions()
1086 PullRequestModel().get_reviewer_functions()
1085
1087
1086 try:
1088 try:
1087 reviewers = validate_default_reviewers(review_members, reviewer_rules)
1089 reviewers = validate_default_reviewers(review_members, reviewer_rules)
1088 except ValueError as e:
1090 except ValueError as e:
1089 log.error('Reviewers Validation: {}'.format(e))
1091 log.error('Reviewers Validation: {}'.format(e))
1090 h.flash(e, category='error')
1092 h.flash(e, category='error')
1091 return
1093 return
1092
1094
1093 PullRequestModel().update_reviewers(
1095 PullRequestModel().update_reviewers(
1094 pull_request, reviewers, self._rhodecode_user)
1096 pull_request, reviewers, self._rhodecode_user)
1095 h.flash(_('Pull request reviewers updated.'), category='success')
1097 h.flash(_('Pull request reviewers updated.'), category='success')
1096 Session().commit()
1098 Session().commit()
1097
1099
1098 @LoginRequired()
1100 @LoginRequired()
1099 @NotAnonymous()
1101 @NotAnonymous()
1100 @HasRepoPermissionAnyDecorator(
1102 @HasRepoPermissionAnyDecorator(
1101 'repository.read', 'repository.write', 'repository.admin')
1103 'repository.read', 'repository.write', 'repository.admin')
1102 @CSRFRequired()
1104 @CSRFRequired()
1103 @view_config(
1105 @view_config(
1104 route_name='pullrequest_delete', request_method='POST',
1106 route_name='pullrequest_delete', request_method='POST',
1105 renderer='json_ext')
1107 renderer='json_ext')
1106 def pull_request_delete(self):
1108 def pull_request_delete(self):
1107 _ = self.request.translate
1109 _ = self.request.translate
1108
1110
1109 pull_request = PullRequest.get_or_404(
1111 pull_request = PullRequest.get_or_404(
1110 self.request.matchdict['pull_request_id'])
1112 self.request.matchdict['pull_request_id'])
1111 self.load_default_context()
1113 self.load_default_context()
1112
1114
1113 pr_closed = pull_request.is_closed()
1115 pr_closed = pull_request.is_closed()
1114 allowed_to_delete = PullRequestModel().check_user_delete(
1116 allowed_to_delete = PullRequestModel().check_user_delete(
1115 pull_request, self._rhodecode_user) and not pr_closed
1117 pull_request, self._rhodecode_user) and not pr_closed
1116
1118
1117 # only owner can delete it !
1119 # only owner can delete it !
1118 if allowed_to_delete:
1120 if allowed_to_delete:
1119 PullRequestModel().delete(pull_request, self._rhodecode_user)
1121 PullRequestModel().delete(pull_request, self._rhodecode_user)
1120 Session().commit()
1122 Session().commit()
1121 h.flash(_('Successfully deleted pull request'),
1123 h.flash(_('Successfully deleted pull request'),
1122 category='success')
1124 category='success')
1123 raise HTTPFound(h.route_path('pullrequest_show_all',
1125 raise HTTPFound(h.route_path('pullrequest_show_all',
1124 repo_name=self.db_repo_name))
1126 repo_name=self.db_repo_name))
1125
1127
1126 log.warning('user %s tried to delete pull request without access',
1128 log.warning('user %s tried to delete pull request without access',
1127 self._rhodecode_user)
1129 self._rhodecode_user)
1128 raise HTTPNotFound()
1130 raise HTTPNotFound()
1129
1131
1130 @LoginRequired()
1132 @LoginRequired()
1131 @NotAnonymous()
1133 @NotAnonymous()
1132 @HasRepoPermissionAnyDecorator(
1134 @HasRepoPermissionAnyDecorator(
1133 'repository.read', 'repository.write', 'repository.admin')
1135 'repository.read', 'repository.write', 'repository.admin')
1134 @CSRFRequired()
1136 @CSRFRequired()
1135 @view_config(
1137 @view_config(
1136 route_name='pullrequest_comment_create', request_method='POST',
1138 route_name='pullrequest_comment_create', request_method='POST',
1137 renderer='json_ext')
1139 renderer='json_ext')
1138 def pull_request_comment_create(self):
1140 def pull_request_comment_create(self):
1139 _ = self.request.translate
1141 _ = self.request.translate
1140
1142
1141 pull_request = PullRequest.get_or_404(
1143 pull_request = PullRequest.get_or_404(
1142 self.request.matchdict['pull_request_id'])
1144 self.request.matchdict['pull_request_id'])
1143 pull_request_id = pull_request.pull_request_id
1145 pull_request_id = pull_request.pull_request_id
1144
1146
1145 if pull_request.is_closed():
1147 if pull_request.is_closed():
1146 log.debug('comment: forbidden because pull request is closed')
1148 log.debug('comment: forbidden because pull request is closed')
1147 raise HTTPForbidden()
1149 raise HTTPForbidden()
1148
1150
1149 allowed_to_comment = PullRequestModel().check_user_comment(
1151 allowed_to_comment = PullRequestModel().check_user_comment(
1150 pull_request, self._rhodecode_user)
1152 pull_request, self._rhodecode_user)
1151 if not allowed_to_comment:
1153 if not allowed_to_comment:
1152 log.debug(
1154 log.debug(
1153 'comment: forbidden because pull request is from forbidden repo')
1155 'comment: forbidden because pull request is from forbidden repo')
1154 raise HTTPForbidden()
1156 raise HTTPForbidden()
1155
1157
1156 c = self.load_default_context()
1158 c = self.load_default_context()
1157
1159
1158 status = self.request.POST.get('changeset_status', None)
1160 status = self.request.POST.get('changeset_status', None)
1159 text = self.request.POST.get('text')
1161 text = self.request.POST.get('text')
1160 comment_type = self.request.POST.get('comment_type')
1162 comment_type = self.request.POST.get('comment_type')
1161 resolves_comment_id = self.request.POST.get('resolves_comment_id', None)
1163 resolves_comment_id = self.request.POST.get('resolves_comment_id', None)
1162 close_pull_request = self.request.POST.get('close_pull_request')
1164 close_pull_request = self.request.POST.get('close_pull_request')
1163
1165
1164 # the logic here should work like following, if we submit close
1166 # the logic here should work like following, if we submit close
1165 # pr comment, use `close_pull_request_with_comment` function
1167 # pr comment, use `close_pull_request_with_comment` function
1166 # else handle regular comment logic
1168 # else handle regular comment logic
1167
1169
1168 if close_pull_request:
1170 if close_pull_request:
1169 # only owner or admin or person with write permissions
1171 # only owner or admin or person with write permissions
1170 allowed_to_close = PullRequestModel().check_user_update(
1172 allowed_to_close = PullRequestModel().check_user_update(
1171 pull_request, self._rhodecode_user)
1173 pull_request, self._rhodecode_user)
1172 if not allowed_to_close:
1174 if not allowed_to_close:
1173 log.debug('comment: forbidden because not allowed to close '
1175 log.debug('comment: forbidden because not allowed to close '
1174 'pull request %s', pull_request_id)
1176 'pull request %s', pull_request_id)
1175 raise HTTPForbidden()
1177 raise HTTPForbidden()
1176 comment, status = PullRequestModel().close_pull_request_with_comment(
1178 comment, status = PullRequestModel().close_pull_request_with_comment(
1177 pull_request, self._rhodecode_user, self.db_repo, message=text)
1179 pull_request, self._rhodecode_user, self.db_repo, message=text)
1178 Session().flush()
1180 Session().flush()
1179 events.trigger(
1181 events.trigger(
1180 events.PullRequestCommentEvent(pull_request, comment))
1182 events.PullRequestCommentEvent(pull_request, comment))
1181
1183
1182 else:
1184 else:
1183 # regular comment case, could be inline, or one with status.
1185 # regular comment case, could be inline, or one with status.
1184 # for that one we check also permissions
1186 # for that one we check also permissions
1185
1187
1186 allowed_to_change_status = PullRequestModel().check_user_change_status(
1188 allowed_to_change_status = PullRequestModel().check_user_change_status(
1187 pull_request, self._rhodecode_user)
1189 pull_request, self._rhodecode_user)
1188
1190
1189 if status and allowed_to_change_status:
1191 if status and allowed_to_change_status:
1190 message = (_('Status change %(transition_icon)s %(status)s')
1192 message = (_('Status change %(transition_icon)s %(status)s')
1191 % {'transition_icon': '>',
1193 % {'transition_icon': '>',
1192 'status': ChangesetStatus.get_status_lbl(status)})
1194 'status': ChangesetStatus.get_status_lbl(status)})
1193 text = text or message
1195 text = text or message
1194
1196
1195 comment = CommentsModel().create(
1197 comment = CommentsModel().create(
1196 text=text,
1198 text=text,
1197 repo=self.db_repo.repo_id,
1199 repo=self.db_repo.repo_id,
1198 user=self._rhodecode_user.user_id,
1200 user=self._rhodecode_user.user_id,
1199 pull_request=pull_request,
1201 pull_request=pull_request,
1200 f_path=self.request.POST.get('f_path'),
1202 f_path=self.request.POST.get('f_path'),
1201 line_no=self.request.POST.get('line'),
1203 line_no=self.request.POST.get('line'),
1202 status_change=(ChangesetStatus.get_status_lbl(status)
1204 status_change=(ChangesetStatus.get_status_lbl(status)
1203 if status and allowed_to_change_status else None),
1205 if status and allowed_to_change_status else None),
1204 status_change_type=(status
1206 status_change_type=(status
1205 if status and allowed_to_change_status else None),
1207 if status and allowed_to_change_status else None),
1206 comment_type=comment_type,
1208 comment_type=comment_type,
1207 resolves_comment_id=resolves_comment_id,
1209 resolves_comment_id=resolves_comment_id,
1208 auth_user=self._rhodecode_user
1210 auth_user=self._rhodecode_user
1209 )
1211 )
1210
1212
1211 if allowed_to_change_status:
1213 if allowed_to_change_status:
1212 # calculate old status before we change it
1214 # calculate old status before we change it
1213 old_calculated_status = pull_request.calculated_review_status()
1215 old_calculated_status = pull_request.calculated_review_status()
1214
1216
1215 # get status if set !
1217 # get status if set !
1216 if status:
1218 if status:
1217 ChangesetStatusModel().set_status(
1219 ChangesetStatusModel().set_status(
1218 self.db_repo.repo_id,
1220 self.db_repo.repo_id,
1219 status,
1221 status,
1220 self._rhodecode_user.user_id,
1222 self._rhodecode_user.user_id,
1221 comment,
1223 comment,
1222 pull_request=pull_request
1224 pull_request=pull_request
1223 )
1225 )
1224
1226
1225 Session().flush()
1227 Session().flush()
1226 # this is somehow required to get access to some relationship
1228 # this is somehow required to get access to some relationship
1227 # loaded on comment
1229 # loaded on comment
1228 Session().refresh(comment)
1230 Session().refresh(comment)
1229
1231
1230 events.trigger(
1232 events.trigger(
1231 events.PullRequestCommentEvent(pull_request, comment))
1233 events.PullRequestCommentEvent(pull_request, comment))
1232
1234
1233 # we now calculate the status of pull request, and based on that
1235 # we now calculate the status of pull request, and based on that
1234 # calculation we set the commits status
1236 # calculation we set the commits status
1235 calculated_status = pull_request.calculated_review_status()
1237 calculated_status = pull_request.calculated_review_status()
1236 if old_calculated_status != calculated_status:
1238 if old_calculated_status != calculated_status:
1237 PullRequestModel()._trigger_pull_request_hook(
1239 PullRequestModel()._trigger_pull_request_hook(
1238 pull_request, self._rhodecode_user, 'review_status_change')
1240 pull_request, self._rhodecode_user, 'review_status_change')
1239
1241
1240 Session().commit()
1242 Session().commit()
1241
1243
1242 data = {
1244 data = {
1243 'target_id': h.safeid(h.safe_unicode(
1245 'target_id': h.safeid(h.safe_unicode(
1244 self.request.POST.get('f_path'))),
1246 self.request.POST.get('f_path'))),
1245 }
1247 }
1246 if comment:
1248 if comment:
1247 c.co = comment
1249 c.co = comment
1248 rendered_comment = render(
1250 rendered_comment = render(
1249 'rhodecode:templates/changeset/changeset_comment_block.mako',
1251 'rhodecode:templates/changeset/changeset_comment_block.mako',
1250 self._get_template_context(c), self.request)
1252 self._get_template_context(c), self.request)
1251
1253
1252 data.update(comment.get_dict())
1254 data.update(comment.get_dict())
1253 data.update({'rendered_text': rendered_comment})
1255 data.update({'rendered_text': rendered_comment})
1254
1256
1255 return data
1257 return data
1256
1258
1257 @LoginRequired()
1259 @LoginRequired()
1258 @NotAnonymous()
1260 @NotAnonymous()
1259 @HasRepoPermissionAnyDecorator(
1261 @HasRepoPermissionAnyDecorator(
1260 'repository.read', 'repository.write', 'repository.admin')
1262 'repository.read', 'repository.write', 'repository.admin')
1261 @CSRFRequired()
1263 @CSRFRequired()
1262 @view_config(
1264 @view_config(
1263 route_name='pullrequest_comment_delete', request_method='POST',
1265 route_name='pullrequest_comment_delete', request_method='POST',
1264 renderer='json_ext')
1266 renderer='json_ext')
1265 def pull_request_comment_delete(self):
1267 def pull_request_comment_delete(self):
1266 pull_request = PullRequest.get_or_404(
1268 pull_request = PullRequest.get_or_404(
1267 self.request.matchdict['pull_request_id'])
1269 self.request.matchdict['pull_request_id'])
1268
1270
1269 comment = ChangesetComment.get_or_404(
1271 comment = ChangesetComment.get_or_404(
1270 self.request.matchdict['comment_id'])
1272 self.request.matchdict['comment_id'])
1271 comment_id = comment.comment_id
1273 comment_id = comment.comment_id
1272
1274
1273 if pull_request.is_closed():
1275 if pull_request.is_closed():
1274 log.debug('comment: forbidden because pull request is closed')
1276 log.debug('comment: forbidden because pull request is closed')
1275 raise HTTPForbidden()
1277 raise HTTPForbidden()
1276
1278
1277 if not comment:
1279 if not comment:
1278 log.debug('Comment with id:%s not found, skipping', comment_id)
1280 log.debug('Comment with id:%s not found, skipping', comment_id)
1279 # comment already deleted in another call probably
1281 # comment already deleted in another call probably
1280 return True
1282 return True
1281
1283
1282 if comment.pull_request.is_closed():
1284 if comment.pull_request.is_closed():
1283 # don't allow deleting comments on closed pull request
1285 # don't allow deleting comments on closed pull request
1284 raise HTTPForbidden()
1286 raise HTTPForbidden()
1285
1287
1286 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
1288 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
1287 super_admin = h.HasPermissionAny('hg.admin')()
1289 super_admin = h.HasPermissionAny('hg.admin')()
1288 comment_owner = comment.author.user_id == self._rhodecode_user.user_id
1290 comment_owner = comment.author.user_id == self._rhodecode_user.user_id
1289 is_repo_comment = comment.repo.repo_name == self.db_repo_name
1291 is_repo_comment = comment.repo.repo_name == self.db_repo_name
1290 comment_repo_admin = is_repo_admin and is_repo_comment
1292 comment_repo_admin = is_repo_admin and is_repo_comment
1291
1293
1292 if super_admin or comment_owner or comment_repo_admin:
1294 if super_admin or comment_owner or comment_repo_admin:
1293 old_calculated_status = comment.pull_request.calculated_review_status()
1295 old_calculated_status = comment.pull_request.calculated_review_status()
1294 CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user)
1296 CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user)
1295 Session().commit()
1297 Session().commit()
1296 calculated_status = comment.pull_request.calculated_review_status()
1298 calculated_status = comment.pull_request.calculated_review_status()
1297 if old_calculated_status != calculated_status:
1299 if old_calculated_status != calculated_status:
1298 PullRequestModel()._trigger_pull_request_hook(
1300 PullRequestModel()._trigger_pull_request_hook(
1299 comment.pull_request, self._rhodecode_user, 'review_status_change')
1301 comment.pull_request, self._rhodecode_user, 'review_status_change')
1300 return True
1302 return True
1301 else:
1303 else:
1302 log.warning('No permissions for user %s to delete comment_id: %s',
1304 log.warning('No permissions for user %s to delete comment_id: %s',
1303 self._rhodecode_db_user, comment_id)
1305 self._rhodecode_db_user, comment_id)
1304 raise HTTPNotFound()
1306 raise HTTPNotFound()
@@ -1,4523 +1,4524 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2018 RhodeCode GmbH
3 # Copyright (C) 2010-2018 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 """
21 """
22 Database Models for RhodeCode Enterprise
22 Database Models for RhodeCode Enterprise
23 """
23 """
24
24
25 import re
25 import re
26 import os
26 import os
27 import time
27 import time
28 import hashlib
28 import hashlib
29 import logging
29 import logging
30 import datetime
30 import datetime
31 import warnings
31 import warnings
32 import ipaddress
32 import ipaddress
33 import functools
33 import functools
34 import traceback
34 import traceback
35 import collections
35 import collections
36
36
37 from sqlalchemy import (
37 from sqlalchemy import (
38 or_, and_, not_, func, TypeDecorator, event,
38 or_, and_, not_, func, TypeDecorator, event,
39 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
39 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
40 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
40 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
41 Text, Float, PickleType)
41 Text, Float, PickleType)
42 from sqlalchemy.sql.expression import true, false
42 from sqlalchemy.sql.expression import true, false
43 from sqlalchemy.sql.functions import coalesce, count # noqa
43 from sqlalchemy.sql.functions import coalesce, count # noqa
44 from sqlalchemy.orm import (
44 from sqlalchemy.orm import (
45 relationship, joinedload, class_mapper, validates, aliased)
45 relationship, joinedload, class_mapper, validates, aliased)
46 from sqlalchemy.ext.declarative import declared_attr
46 from sqlalchemy.ext.declarative import declared_attr
47 from sqlalchemy.ext.hybrid import hybrid_property
47 from sqlalchemy.ext.hybrid import hybrid_property
48 from sqlalchemy.exc import IntegrityError # noqa
48 from sqlalchemy.exc import IntegrityError # noqa
49 from sqlalchemy.dialects.mysql import LONGTEXT
49 from sqlalchemy.dialects.mysql import LONGTEXT
50 from beaker.cache import cache_region
50 from beaker.cache import cache_region
51 from zope.cachedescriptors.property import Lazy as LazyProperty
51 from zope.cachedescriptors.property import Lazy as LazyProperty
52
52
53 from pyramid.threadlocal import get_current_request
53 from pyramid.threadlocal import get_current_request
54
54
55 from rhodecode.translation import _
55 from rhodecode.translation import _
56 from rhodecode.lib.vcs import get_vcs_instance
56 from rhodecode.lib.vcs import get_vcs_instance
57 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
57 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
58 from rhodecode.lib.utils2 import (
58 from rhodecode.lib.utils2 import (
59 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
59 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
60 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
60 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
61 glob2re, StrictAttributeDict, cleaned_uri)
61 glob2re, StrictAttributeDict, cleaned_uri)
62 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
62 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
63 JsonRaw
63 JsonRaw
64 from rhodecode.lib.ext_json import json
64 from rhodecode.lib.ext_json import json
65 from rhodecode.lib.caching_query import FromCache
65 from rhodecode.lib.caching_query import FromCache
66 from rhodecode.lib.encrypt import AESCipher
66 from rhodecode.lib.encrypt import AESCipher
67
67
68 from rhodecode.model.meta import Base, Session
68 from rhodecode.model.meta import Base, Session
69
69
70 URL_SEP = '/'
70 URL_SEP = '/'
71 log = logging.getLogger(__name__)
71 log = logging.getLogger(__name__)
72
72
73 # =============================================================================
73 # =============================================================================
74 # BASE CLASSES
74 # BASE CLASSES
75 # =============================================================================
75 # =============================================================================
76
76
77 # this is propagated from .ini file rhodecode.encrypted_values.secret or
77 # this is propagated from .ini file rhodecode.encrypted_values.secret or
78 # beaker.session.secret if first is not set.
78 # beaker.session.secret if first is not set.
79 # and initialized at environment.py
79 # and initialized at environment.py
80 ENCRYPTION_KEY = None
80 ENCRYPTION_KEY = None
81
81
82 # used to sort permissions by types, '#' used here is not allowed to be in
82 # used to sort permissions by types, '#' used here is not allowed to be in
83 # usernames, and it's very early in sorted string.printable table.
83 # usernames, and it's very early in sorted string.printable table.
84 PERMISSION_TYPE_SORT = {
84 PERMISSION_TYPE_SORT = {
85 'admin': '####',
85 'admin': '####',
86 'write': '###',
86 'write': '###',
87 'read': '##',
87 'read': '##',
88 'none': '#',
88 'none': '#',
89 }
89 }
90
90
91
91
92 def display_user_sort(obj):
92 def display_user_sort(obj):
93 """
93 """
94 Sort function used to sort permissions in .permissions() function of
94 Sort function used to sort permissions in .permissions() function of
95 Repository, RepoGroup, UserGroup. Also it put the default user in front
95 Repository, RepoGroup, UserGroup. Also it put the default user in front
96 of all other resources
96 of all other resources
97 """
97 """
98
98
99 if obj.username == User.DEFAULT_USER:
99 if obj.username == User.DEFAULT_USER:
100 return '#####'
100 return '#####'
101 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
101 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
102 return prefix + obj.username
102 return prefix + obj.username
103
103
104
104
105 def display_user_group_sort(obj):
105 def display_user_group_sort(obj):
106 """
106 """
107 Sort function used to sort permissions in .permissions() function of
107 Sort function used to sort permissions in .permissions() function of
108 Repository, RepoGroup, UserGroup. Also it put the default user in front
108 Repository, RepoGroup, UserGroup. Also it put the default user in front
109 of all other resources
109 of all other resources
110 """
110 """
111
111
112 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
112 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
113 return prefix + obj.users_group_name
113 return prefix + obj.users_group_name
114
114
115
115
116 def _hash_key(k):
116 def _hash_key(k):
117 return md5_safe(k)
117 return md5_safe(k)
118
118
119
119
120 def in_filter_generator(qry, items, limit=500):
120 def in_filter_generator(qry, items, limit=500):
121 """
121 """
122 Splits IN() into multiple with OR
122 Splits IN() into multiple with OR
123 e.g.::
123 e.g.::
124 cnt = Repository.query().filter(
124 cnt = Repository.query().filter(
125 or_(
125 or_(
126 *in_filter_generator(Repository.repo_id, range(100000))
126 *in_filter_generator(Repository.repo_id, range(100000))
127 )).count()
127 )).count()
128 """
128 """
129 if not items:
129 if not items:
130 # empty list will cause empty query which might cause security issues
130 # empty list will cause empty query which might cause security issues
131 # this can lead to hidden unpleasant results
131 # this can lead to hidden unpleasant results
132 items = [-1]
132 items = [-1]
133
133
134 parts = []
134 parts = []
135 for chunk in xrange(0, len(items), limit):
135 for chunk in xrange(0, len(items), limit):
136 parts.append(
136 parts.append(
137 qry.in_(items[chunk: chunk + limit])
137 qry.in_(items[chunk: chunk + limit])
138 )
138 )
139
139
140 return parts
140 return parts
141
141
142
142
143 class EncryptedTextValue(TypeDecorator):
143 class EncryptedTextValue(TypeDecorator):
144 """
144 """
145 Special column for encrypted long text data, use like::
145 Special column for encrypted long text data, use like::
146
146
147 value = Column("encrypted_value", EncryptedValue(), nullable=False)
147 value = Column("encrypted_value", EncryptedValue(), nullable=False)
148
148
149 This column is intelligent so if value is in unencrypted form it return
149 This column is intelligent so if value is in unencrypted form it return
150 unencrypted form, but on save it always encrypts
150 unencrypted form, but on save it always encrypts
151 """
151 """
152 impl = Text
152 impl = Text
153
153
154 def process_bind_param(self, value, dialect):
154 def process_bind_param(self, value, dialect):
155 if not value:
155 if not value:
156 return value
156 return value
157 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
157 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
158 # protect against double encrypting if someone manually starts
158 # protect against double encrypting if someone manually starts
159 # doing
159 # doing
160 raise ValueError('value needs to be in unencrypted format, ie. '
160 raise ValueError('value needs to be in unencrypted format, ie. '
161 'not starting with enc$aes')
161 'not starting with enc$aes')
162 return 'enc$aes_hmac$%s' % AESCipher(
162 return 'enc$aes_hmac$%s' % AESCipher(
163 ENCRYPTION_KEY, hmac=True).encrypt(value)
163 ENCRYPTION_KEY, hmac=True).encrypt(value)
164
164
165 def process_result_value(self, value, dialect):
165 def process_result_value(self, value, dialect):
166 import rhodecode
166 import rhodecode
167
167
168 if not value:
168 if not value:
169 return value
169 return value
170
170
171 parts = value.split('$', 3)
171 parts = value.split('$', 3)
172 if not len(parts) == 3:
172 if not len(parts) == 3:
173 # probably not encrypted values
173 # probably not encrypted values
174 return value
174 return value
175 else:
175 else:
176 if parts[0] != 'enc':
176 if parts[0] != 'enc':
177 # parts ok but without our header ?
177 # parts ok but without our header ?
178 return value
178 return value
179 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
179 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
180 'rhodecode.encrypted_values.strict') or True)
180 'rhodecode.encrypted_values.strict') or True)
181 # at that stage we know it's our encryption
181 # at that stage we know it's our encryption
182 if parts[1] == 'aes':
182 if parts[1] == 'aes':
183 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
183 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
184 elif parts[1] == 'aes_hmac':
184 elif parts[1] == 'aes_hmac':
185 decrypted_data = AESCipher(
185 decrypted_data = AESCipher(
186 ENCRYPTION_KEY, hmac=True,
186 ENCRYPTION_KEY, hmac=True,
187 strict_verification=enc_strict_mode).decrypt(parts[2])
187 strict_verification=enc_strict_mode).decrypt(parts[2])
188 else:
188 else:
189 raise ValueError(
189 raise ValueError(
190 'Encryption type part is wrong, must be `aes` '
190 'Encryption type part is wrong, must be `aes` '
191 'or `aes_hmac`, got `%s` instead' % (parts[1]))
191 'or `aes_hmac`, got `%s` instead' % (parts[1]))
192 return decrypted_data
192 return decrypted_data
193
193
194
194
195 class BaseModel(object):
195 class BaseModel(object):
196 """
196 """
197 Base Model for all classes
197 Base Model for all classes
198 """
198 """
199
199
200 @classmethod
200 @classmethod
201 def _get_keys(cls):
201 def _get_keys(cls):
202 """return column names for this model """
202 """return column names for this model """
203 return class_mapper(cls).c.keys()
203 return class_mapper(cls).c.keys()
204
204
205 def get_dict(self):
205 def get_dict(self):
206 """
206 """
207 return dict with keys and values corresponding
207 return dict with keys and values corresponding
208 to this model data """
208 to this model data """
209
209
210 d = {}
210 d = {}
211 for k in self._get_keys():
211 for k in self._get_keys():
212 d[k] = getattr(self, k)
212 d[k] = getattr(self, k)
213
213
214 # also use __json__() if present to get additional fields
214 # also use __json__() if present to get additional fields
215 _json_attr = getattr(self, '__json__', None)
215 _json_attr = getattr(self, '__json__', None)
216 if _json_attr:
216 if _json_attr:
217 # update with attributes from __json__
217 # update with attributes from __json__
218 if callable(_json_attr):
218 if callable(_json_attr):
219 _json_attr = _json_attr()
219 _json_attr = _json_attr()
220 for k, val in _json_attr.iteritems():
220 for k, val in _json_attr.iteritems():
221 d[k] = val
221 d[k] = val
222 return d
222 return d
223
223
224 def get_appstruct(self):
224 def get_appstruct(self):
225 """return list with keys and values tuples corresponding
225 """return list with keys and values tuples corresponding
226 to this model data """
226 to this model data """
227
227
228 lst = []
228 lst = []
229 for k in self._get_keys():
229 for k in self._get_keys():
230 lst.append((k, getattr(self, k),))
230 lst.append((k, getattr(self, k),))
231 return lst
231 return lst
232
232
233 def populate_obj(self, populate_dict):
233 def populate_obj(self, populate_dict):
234 """populate model with data from given populate_dict"""
234 """populate model with data from given populate_dict"""
235
235
236 for k in self._get_keys():
236 for k in self._get_keys():
237 if k in populate_dict:
237 if k in populate_dict:
238 setattr(self, k, populate_dict[k])
238 setattr(self, k, populate_dict[k])
239
239
240 @classmethod
240 @classmethod
241 def query(cls):
241 def query(cls):
242 return Session().query(cls)
242 return Session().query(cls)
243
243
244 @classmethod
244 @classmethod
245 def get(cls, id_):
245 def get(cls, id_):
246 if id_:
246 if id_:
247 return cls.query().get(id_)
247 return cls.query().get(id_)
248
248
249 @classmethod
249 @classmethod
250 def get_or_404(cls, id_):
250 def get_or_404(cls, id_):
251 from pyramid.httpexceptions import HTTPNotFound
251 from pyramid.httpexceptions import HTTPNotFound
252
252
253 try:
253 try:
254 id_ = int(id_)
254 id_ = int(id_)
255 except (TypeError, ValueError):
255 except (TypeError, ValueError):
256 raise HTTPNotFound()
256 raise HTTPNotFound()
257
257
258 res = cls.query().get(id_)
258 res = cls.query().get(id_)
259 if not res:
259 if not res:
260 raise HTTPNotFound()
260 raise HTTPNotFound()
261 return res
261 return res
262
262
263 @classmethod
263 @classmethod
264 def getAll(cls):
264 def getAll(cls):
265 # deprecated and left for backward compatibility
265 # deprecated and left for backward compatibility
266 return cls.get_all()
266 return cls.get_all()
267
267
268 @classmethod
268 @classmethod
269 def get_all(cls):
269 def get_all(cls):
270 return cls.query().all()
270 return cls.query().all()
271
271
272 @classmethod
272 @classmethod
273 def delete(cls, id_):
273 def delete(cls, id_):
274 obj = cls.query().get(id_)
274 obj = cls.query().get(id_)
275 Session().delete(obj)
275 Session().delete(obj)
276
276
277 @classmethod
277 @classmethod
278 def identity_cache(cls, session, attr_name, value):
278 def identity_cache(cls, session, attr_name, value):
279 exist_in_session = []
279 exist_in_session = []
280 for (item_cls, pkey), instance in session.identity_map.items():
280 for (item_cls, pkey), instance in session.identity_map.items():
281 if cls == item_cls and getattr(instance, attr_name) == value:
281 if cls == item_cls and getattr(instance, attr_name) == value:
282 exist_in_session.append(instance)
282 exist_in_session.append(instance)
283 if exist_in_session:
283 if exist_in_session:
284 if len(exist_in_session) == 1:
284 if len(exist_in_session) == 1:
285 return exist_in_session[0]
285 return exist_in_session[0]
286 log.exception(
286 log.exception(
287 'multiple objects with attr %s and '
287 'multiple objects with attr %s and '
288 'value %s found with same name: %r',
288 'value %s found with same name: %r',
289 attr_name, value, exist_in_session)
289 attr_name, value, exist_in_session)
290
290
291 def __repr__(self):
291 def __repr__(self):
292 if hasattr(self, '__unicode__'):
292 if hasattr(self, '__unicode__'):
293 # python repr needs to return str
293 # python repr needs to return str
294 try:
294 try:
295 return safe_str(self.__unicode__())
295 return safe_str(self.__unicode__())
296 except UnicodeDecodeError:
296 except UnicodeDecodeError:
297 pass
297 pass
298 return '<DB:%s>' % (self.__class__.__name__)
298 return '<DB:%s>' % (self.__class__.__name__)
299
299
300
300
301 class RhodeCodeSetting(Base, BaseModel):
301 class RhodeCodeSetting(Base, BaseModel):
302 __tablename__ = 'rhodecode_settings'
302 __tablename__ = 'rhodecode_settings'
303 __table_args__ = (
303 __table_args__ = (
304 UniqueConstraint('app_settings_name'),
304 UniqueConstraint('app_settings_name'),
305 {'extend_existing': True, 'mysql_engine': 'InnoDB',
305 {'extend_existing': True, 'mysql_engine': 'InnoDB',
306 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
306 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
307 )
307 )
308
308
309 SETTINGS_TYPES = {
309 SETTINGS_TYPES = {
310 'str': safe_str,
310 'str': safe_str,
311 'int': safe_int,
311 'int': safe_int,
312 'unicode': safe_unicode,
312 'unicode': safe_unicode,
313 'bool': str2bool,
313 'bool': str2bool,
314 'list': functools.partial(aslist, sep=',')
314 'list': functools.partial(aslist, sep=',')
315 }
315 }
316 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
316 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
317 GLOBAL_CONF_KEY = 'app_settings'
317 GLOBAL_CONF_KEY = 'app_settings'
318
318
319 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
319 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
320 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
320 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
321 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
321 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
322 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
322 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
323
323
324 def __init__(self, key='', val='', type='unicode'):
324 def __init__(self, key='', val='', type='unicode'):
325 self.app_settings_name = key
325 self.app_settings_name = key
326 self.app_settings_type = type
326 self.app_settings_type = type
327 self.app_settings_value = val
327 self.app_settings_value = val
328
328
329 @validates('_app_settings_value')
329 @validates('_app_settings_value')
330 def validate_settings_value(self, key, val):
330 def validate_settings_value(self, key, val):
331 assert type(val) == unicode
331 assert type(val) == unicode
332 return val
332 return val
333
333
334 @hybrid_property
334 @hybrid_property
335 def app_settings_value(self):
335 def app_settings_value(self):
336 v = self._app_settings_value
336 v = self._app_settings_value
337 _type = self.app_settings_type
337 _type = self.app_settings_type
338 if _type:
338 if _type:
339 _type = self.app_settings_type.split('.')[0]
339 _type = self.app_settings_type.split('.')[0]
340 # decode the encrypted value
340 # decode the encrypted value
341 if 'encrypted' in self.app_settings_type:
341 if 'encrypted' in self.app_settings_type:
342 cipher = EncryptedTextValue()
342 cipher = EncryptedTextValue()
343 v = safe_unicode(cipher.process_result_value(v, None))
343 v = safe_unicode(cipher.process_result_value(v, None))
344
344
345 converter = self.SETTINGS_TYPES.get(_type) or \
345 converter = self.SETTINGS_TYPES.get(_type) or \
346 self.SETTINGS_TYPES['unicode']
346 self.SETTINGS_TYPES['unicode']
347 return converter(v)
347 return converter(v)
348
348
349 @app_settings_value.setter
349 @app_settings_value.setter
350 def app_settings_value(self, val):
350 def app_settings_value(self, val):
351 """
351 """
352 Setter that will always make sure we use unicode in app_settings_value
352 Setter that will always make sure we use unicode in app_settings_value
353
353
354 :param val:
354 :param val:
355 """
355 """
356 val = safe_unicode(val)
356 val = safe_unicode(val)
357 # encode the encrypted value
357 # encode the encrypted value
358 if 'encrypted' in self.app_settings_type:
358 if 'encrypted' in self.app_settings_type:
359 cipher = EncryptedTextValue()
359 cipher = EncryptedTextValue()
360 val = safe_unicode(cipher.process_bind_param(val, None))
360 val = safe_unicode(cipher.process_bind_param(val, None))
361 self._app_settings_value = val
361 self._app_settings_value = val
362
362
363 @hybrid_property
363 @hybrid_property
364 def app_settings_type(self):
364 def app_settings_type(self):
365 return self._app_settings_type
365 return self._app_settings_type
366
366
367 @app_settings_type.setter
367 @app_settings_type.setter
368 def app_settings_type(self, val):
368 def app_settings_type(self, val):
369 if val.split('.')[0] not in self.SETTINGS_TYPES:
369 if val.split('.')[0] not in self.SETTINGS_TYPES:
370 raise Exception('type must be one of %s got %s'
370 raise Exception('type must be one of %s got %s'
371 % (self.SETTINGS_TYPES.keys(), val))
371 % (self.SETTINGS_TYPES.keys(), val))
372 self._app_settings_type = val
372 self._app_settings_type = val
373
373
374 def __unicode__(self):
374 def __unicode__(self):
375 return u"<%s('%s:%s[%s]')>" % (
375 return u"<%s('%s:%s[%s]')>" % (
376 self.__class__.__name__,
376 self.__class__.__name__,
377 self.app_settings_name, self.app_settings_value,
377 self.app_settings_name, self.app_settings_value,
378 self.app_settings_type
378 self.app_settings_type
379 )
379 )
380
380
381
381
382 class RhodeCodeUi(Base, BaseModel):
382 class RhodeCodeUi(Base, BaseModel):
383 __tablename__ = 'rhodecode_ui'
383 __tablename__ = 'rhodecode_ui'
384 __table_args__ = (
384 __table_args__ = (
385 UniqueConstraint('ui_key'),
385 UniqueConstraint('ui_key'),
386 {'extend_existing': True, 'mysql_engine': 'InnoDB',
386 {'extend_existing': True, 'mysql_engine': 'InnoDB',
387 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
387 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
388 )
388 )
389
389
390 HOOK_REPO_SIZE = 'changegroup.repo_size'
390 HOOK_REPO_SIZE = 'changegroup.repo_size'
391 # HG
391 # HG
392 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
392 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
393 HOOK_PULL = 'outgoing.pull_logger'
393 HOOK_PULL = 'outgoing.pull_logger'
394 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
394 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
395 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
395 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
396 HOOK_PUSH = 'changegroup.push_logger'
396 HOOK_PUSH = 'changegroup.push_logger'
397 HOOK_PUSH_KEY = 'pushkey.key_push'
397 HOOK_PUSH_KEY = 'pushkey.key_push'
398
398
399 # TODO: johbo: Unify way how hooks are configured for git and hg,
399 # TODO: johbo: Unify way how hooks are configured for git and hg,
400 # git part is currently hardcoded.
400 # git part is currently hardcoded.
401
401
402 # SVN PATTERNS
402 # SVN PATTERNS
403 SVN_BRANCH_ID = 'vcs_svn_branch'
403 SVN_BRANCH_ID = 'vcs_svn_branch'
404 SVN_TAG_ID = 'vcs_svn_tag'
404 SVN_TAG_ID = 'vcs_svn_tag'
405
405
406 ui_id = Column(
406 ui_id = Column(
407 "ui_id", Integer(), nullable=False, unique=True, default=None,
407 "ui_id", Integer(), nullable=False, unique=True, default=None,
408 primary_key=True)
408 primary_key=True)
409 ui_section = Column(
409 ui_section = Column(
410 "ui_section", String(255), nullable=True, unique=None, default=None)
410 "ui_section", String(255), nullable=True, unique=None, default=None)
411 ui_key = Column(
411 ui_key = Column(
412 "ui_key", String(255), nullable=True, unique=None, default=None)
412 "ui_key", String(255), nullable=True, unique=None, default=None)
413 ui_value = Column(
413 ui_value = Column(
414 "ui_value", String(255), nullable=True, unique=None, default=None)
414 "ui_value", String(255), nullable=True, unique=None, default=None)
415 ui_active = Column(
415 ui_active = Column(
416 "ui_active", Boolean(), nullable=True, unique=None, default=True)
416 "ui_active", Boolean(), nullable=True, unique=None, default=True)
417
417
418 def __repr__(self):
418 def __repr__(self):
419 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
419 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
420 self.ui_key, self.ui_value)
420 self.ui_key, self.ui_value)
421
421
422
422
423 class RepoRhodeCodeSetting(Base, BaseModel):
423 class RepoRhodeCodeSetting(Base, BaseModel):
424 __tablename__ = 'repo_rhodecode_settings'
424 __tablename__ = 'repo_rhodecode_settings'
425 __table_args__ = (
425 __table_args__ = (
426 UniqueConstraint(
426 UniqueConstraint(
427 'app_settings_name', 'repository_id',
427 'app_settings_name', 'repository_id',
428 name='uq_repo_rhodecode_setting_name_repo_id'),
428 name='uq_repo_rhodecode_setting_name_repo_id'),
429 {'extend_existing': True, 'mysql_engine': 'InnoDB',
429 {'extend_existing': True, 'mysql_engine': 'InnoDB',
430 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
430 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
431 )
431 )
432
432
433 repository_id = Column(
433 repository_id = Column(
434 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
434 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
435 nullable=False)
435 nullable=False)
436 app_settings_id = Column(
436 app_settings_id = Column(
437 "app_settings_id", Integer(), nullable=False, unique=True,
437 "app_settings_id", Integer(), nullable=False, unique=True,
438 default=None, primary_key=True)
438 default=None, primary_key=True)
439 app_settings_name = Column(
439 app_settings_name = Column(
440 "app_settings_name", String(255), nullable=True, unique=None,
440 "app_settings_name", String(255), nullable=True, unique=None,
441 default=None)
441 default=None)
442 _app_settings_value = Column(
442 _app_settings_value = Column(
443 "app_settings_value", String(4096), nullable=True, unique=None,
443 "app_settings_value", String(4096), nullable=True, unique=None,
444 default=None)
444 default=None)
445 _app_settings_type = Column(
445 _app_settings_type = Column(
446 "app_settings_type", String(255), nullable=True, unique=None,
446 "app_settings_type", String(255), nullable=True, unique=None,
447 default=None)
447 default=None)
448
448
449 repository = relationship('Repository')
449 repository = relationship('Repository')
450
450
451 def __init__(self, repository_id, key='', val='', type='unicode'):
451 def __init__(self, repository_id, key='', val='', type='unicode'):
452 self.repository_id = repository_id
452 self.repository_id = repository_id
453 self.app_settings_name = key
453 self.app_settings_name = key
454 self.app_settings_type = type
454 self.app_settings_type = type
455 self.app_settings_value = val
455 self.app_settings_value = val
456
456
457 @validates('_app_settings_value')
457 @validates('_app_settings_value')
458 def validate_settings_value(self, key, val):
458 def validate_settings_value(self, key, val):
459 assert type(val) == unicode
459 assert type(val) == unicode
460 return val
460 return val
461
461
462 @hybrid_property
462 @hybrid_property
463 def app_settings_value(self):
463 def app_settings_value(self):
464 v = self._app_settings_value
464 v = self._app_settings_value
465 type_ = self.app_settings_type
465 type_ = self.app_settings_type
466 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
466 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
467 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
467 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
468 return converter(v)
468 return converter(v)
469
469
470 @app_settings_value.setter
470 @app_settings_value.setter
471 def app_settings_value(self, val):
471 def app_settings_value(self, val):
472 """
472 """
473 Setter that will always make sure we use unicode in app_settings_value
473 Setter that will always make sure we use unicode in app_settings_value
474
474
475 :param val:
475 :param val:
476 """
476 """
477 self._app_settings_value = safe_unicode(val)
477 self._app_settings_value = safe_unicode(val)
478
478
479 @hybrid_property
479 @hybrid_property
480 def app_settings_type(self):
480 def app_settings_type(self):
481 return self._app_settings_type
481 return self._app_settings_type
482
482
483 @app_settings_type.setter
483 @app_settings_type.setter
484 def app_settings_type(self, val):
484 def app_settings_type(self, val):
485 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
485 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
486 if val not in SETTINGS_TYPES:
486 if val not in SETTINGS_TYPES:
487 raise Exception('type must be one of %s got %s'
487 raise Exception('type must be one of %s got %s'
488 % (SETTINGS_TYPES.keys(), val))
488 % (SETTINGS_TYPES.keys(), val))
489 self._app_settings_type = val
489 self._app_settings_type = val
490
490
491 def __unicode__(self):
491 def __unicode__(self):
492 return u"<%s('%s:%s:%s[%s]')>" % (
492 return u"<%s('%s:%s:%s[%s]')>" % (
493 self.__class__.__name__, self.repository.repo_name,
493 self.__class__.__name__, self.repository.repo_name,
494 self.app_settings_name, self.app_settings_value,
494 self.app_settings_name, self.app_settings_value,
495 self.app_settings_type
495 self.app_settings_type
496 )
496 )
497
497
498
498
499 class RepoRhodeCodeUi(Base, BaseModel):
499 class RepoRhodeCodeUi(Base, BaseModel):
500 __tablename__ = 'repo_rhodecode_ui'
500 __tablename__ = 'repo_rhodecode_ui'
501 __table_args__ = (
501 __table_args__ = (
502 UniqueConstraint(
502 UniqueConstraint(
503 'repository_id', 'ui_section', 'ui_key',
503 'repository_id', 'ui_section', 'ui_key',
504 name='uq_repo_rhodecode_ui_repository_id_section_key'),
504 name='uq_repo_rhodecode_ui_repository_id_section_key'),
505 {'extend_existing': True, 'mysql_engine': 'InnoDB',
505 {'extend_existing': True, 'mysql_engine': 'InnoDB',
506 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
506 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
507 )
507 )
508
508
509 repository_id = Column(
509 repository_id = Column(
510 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
510 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
511 nullable=False)
511 nullable=False)
512 ui_id = Column(
512 ui_id = Column(
513 "ui_id", Integer(), nullable=False, unique=True, default=None,
513 "ui_id", Integer(), nullable=False, unique=True, default=None,
514 primary_key=True)
514 primary_key=True)
515 ui_section = Column(
515 ui_section = Column(
516 "ui_section", String(255), nullable=True, unique=None, default=None)
516 "ui_section", String(255), nullable=True, unique=None, default=None)
517 ui_key = Column(
517 ui_key = Column(
518 "ui_key", String(255), nullable=True, unique=None, default=None)
518 "ui_key", String(255), nullable=True, unique=None, default=None)
519 ui_value = Column(
519 ui_value = Column(
520 "ui_value", String(255), nullable=True, unique=None, default=None)
520 "ui_value", String(255), nullable=True, unique=None, default=None)
521 ui_active = Column(
521 ui_active = Column(
522 "ui_active", Boolean(), nullable=True, unique=None, default=True)
522 "ui_active", Boolean(), nullable=True, unique=None, default=True)
523
523
524 repository = relationship('Repository')
524 repository = relationship('Repository')
525
525
526 def __repr__(self):
526 def __repr__(self):
527 return '<%s[%s:%s]%s=>%s]>' % (
527 return '<%s[%s:%s]%s=>%s]>' % (
528 self.__class__.__name__, self.repository.repo_name,
528 self.__class__.__name__, self.repository.repo_name,
529 self.ui_section, self.ui_key, self.ui_value)
529 self.ui_section, self.ui_key, self.ui_value)
530
530
531
531
532 class User(Base, BaseModel):
532 class User(Base, BaseModel):
533 __tablename__ = 'users'
533 __tablename__ = 'users'
534 __table_args__ = (
534 __table_args__ = (
535 UniqueConstraint('username'), UniqueConstraint('email'),
535 UniqueConstraint('username'), UniqueConstraint('email'),
536 Index('u_username_idx', 'username'),
536 Index('u_username_idx', 'username'),
537 Index('u_email_idx', 'email'),
537 Index('u_email_idx', 'email'),
538 {'extend_existing': True, 'mysql_engine': 'InnoDB',
538 {'extend_existing': True, 'mysql_engine': 'InnoDB',
539 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
539 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
540 )
540 )
541 DEFAULT_USER = 'default'
541 DEFAULT_USER = 'default'
542 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
542 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
543 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
543 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
544
544
545 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
545 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
546 username = Column("username", String(255), nullable=True, unique=None, default=None)
546 username = Column("username", String(255), nullable=True, unique=None, default=None)
547 password = Column("password", String(255), nullable=True, unique=None, default=None)
547 password = Column("password", String(255), nullable=True, unique=None, default=None)
548 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
548 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
549 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
549 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
550 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
550 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
551 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
551 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
552 _email = Column("email", String(255), nullable=True, unique=None, default=None)
552 _email = Column("email", String(255), nullable=True, unique=None, default=None)
553 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
553 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
554 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
554 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
555
555
556 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
556 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
557 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
557 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
558 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
558 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
559 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
559 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
560 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
560 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
561 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
561 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
562
562
563 user_log = relationship('UserLog')
563 user_log = relationship('UserLog')
564 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
564 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
565
565
566 repositories = relationship('Repository')
566 repositories = relationship('Repository')
567 repository_groups = relationship('RepoGroup')
567 repository_groups = relationship('RepoGroup')
568 user_groups = relationship('UserGroup')
568 user_groups = relationship('UserGroup')
569
569
570 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
570 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
571 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
571 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
572
572
573 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
573 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
574 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
574 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
575 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
575 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
576
576
577 group_member = relationship('UserGroupMember', cascade='all')
577 group_member = relationship('UserGroupMember', cascade='all')
578
578
579 notifications = relationship('UserNotification', cascade='all')
579 notifications = relationship('UserNotification', cascade='all')
580 # notifications assigned to this user
580 # notifications assigned to this user
581 user_created_notifications = relationship('Notification', cascade='all')
581 user_created_notifications = relationship('Notification', cascade='all')
582 # comments created by this user
582 # comments created by this user
583 user_comments = relationship('ChangesetComment', cascade='all')
583 user_comments = relationship('ChangesetComment', cascade='all')
584 # user profile extra info
584 # user profile extra info
585 user_emails = relationship('UserEmailMap', cascade='all')
585 user_emails = relationship('UserEmailMap', cascade='all')
586 user_ip_map = relationship('UserIpMap', cascade='all')
586 user_ip_map = relationship('UserIpMap', cascade='all')
587 user_auth_tokens = relationship('UserApiKeys', cascade='all')
587 user_auth_tokens = relationship('UserApiKeys', cascade='all')
588 user_ssh_keys = relationship('UserSshKeys', cascade='all')
588 user_ssh_keys = relationship('UserSshKeys', cascade='all')
589
589
590 # gists
590 # gists
591 user_gists = relationship('Gist', cascade='all')
591 user_gists = relationship('Gist', cascade='all')
592 # user pull requests
592 # user pull requests
593 user_pull_requests = relationship('PullRequest', cascade='all')
593 user_pull_requests = relationship('PullRequest', cascade='all')
594 # external identities
594 # external identities
595 extenal_identities = relationship(
595 extenal_identities = relationship(
596 'ExternalIdentity',
596 'ExternalIdentity',
597 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
597 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
598 cascade='all')
598 cascade='all')
599 # review rules
599 # review rules
600 user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
600 user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
601
601
602 def __unicode__(self):
602 def __unicode__(self):
603 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
603 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
604 self.user_id, self.username)
604 self.user_id, self.username)
605
605
606 @hybrid_property
606 @hybrid_property
607 def email(self):
607 def email(self):
608 return self._email
608 return self._email
609
609
610 @email.setter
610 @email.setter
611 def email(self, val):
611 def email(self, val):
612 self._email = val.lower() if val else None
612 self._email = val.lower() if val else None
613
613
614 @hybrid_property
614 @hybrid_property
615 def first_name(self):
615 def first_name(self):
616 from rhodecode.lib import helpers as h
616 from rhodecode.lib import helpers as h
617 if self.name:
617 if self.name:
618 return h.escape(self.name)
618 return h.escape(self.name)
619 return self.name
619 return self.name
620
620
621 @hybrid_property
621 @hybrid_property
622 def last_name(self):
622 def last_name(self):
623 from rhodecode.lib import helpers as h
623 from rhodecode.lib import helpers as h
624 if self.lastname:
624 if self.lastname:
625 return h.escape(self.lastname)
625 return h.escape(self.lastname)
626 return self.lastname
626 return self.lastname
627
627
628 @hybrid_property
628 @hybrid_property
629 def api_key(self):
629 def api_key(self):
630 """
630 """
631 Fetch if exist an auth-token with role ALL connected to this user
631 Fetch if exist an auth-token with role ALL connected to this user
632 """
632 """
633 user_auth_token = UserApiKeys.query()\
633 user_auth_token = UserApiKeys.query()\
634 .filter(UserApiKeys.user_id == self.user_id)\
634 .filter(UserApiKeys.user_id == self.user_id)\
635 .filter(or_(UserApiKeys.expires == -1,
635 .filter(or_(UserApiKeys.expires == -1,
636 UserApiKeys.expires >= time.time()))\
636 UserApiKeys.expires >= time.time()))\
637 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
637 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
638 if user_auth_token:
638 if user_auth_token:
639 user_auth_token = user_auth_token.api_key
639 user_auth_token = user_auth_token.api_key
640
640
641 return user_auth_token
641 return user_auth_token
642
642
643 @api_key.setter
643 @api_key.setter
644 def api_key(self, val):
644 def api_key(self, val):
645 # don't allow to set API key this is deprecated for now
645 # don't allow to set API key this is deprecated for now
646 self._api_key = None
646 self._api_key = None
647
647
648 @property
648 @property
649 def reviewer_pull_requests(self):
649 def reviewer_pull_requests(self):
650 return PullRequestReviewers.query() \
650 return PullRequestReviewers.query() \
651 .options(joinedload(PullRequestReviewers.pull_request)) \
651 .options(joinedload(PullRequestReviewers.pull_request)) \
652 .filter(PullRequestReviewers.user_id == self.user_id) \
652 .filter(PullRequestReviewers.user_id == self.user_id) \
653 .all()
653 .all()
654
654
655 @property
655 @property
656 def firstname(self):
656 def firstname(self):
657 # alias for future
657 # alias for future
658 return self.name
658 return self.name
659
659
660 @property
660 @property
661 def emails(self):
661 def emails(self):
662 other = UserEmailMap.query()\
662 other = UserEmailMap.query()\
663 .filter(UserEmailMap.user == self) \
663 .filter(UserEmailMap.user == self) \
664 .order_by(UserEmailMap.email_id.asc()) \
664 .order_by(UserEmailMap.email_id.asc()) \
665 .all()
665 .all()
666 return [self.email] + [x.email for x in other]
666 return [self.email] + [x.email for x in other]
667
667
668 @property
668 @property
669 def auth_tokens(self):
669 def auth_tokens(self):
670 auth_tokens = self.get_auth_tokens()
670 auth_tokens = self.get_auth_tokens()
671 return [x.api_key for x in auth_tokens]
671 return [x.api_key for x in auth_tokens]
672
672
673 def get_auth_tokens(self):
673 def get_auth_tokens(self):
674 return UserApiKeys.query()\
674 return UserApiKeys.query()\
675 .filter(UserApiKeys.user == self)\
675 .filter(UserApiKeys.user == self)\
676 .order_by(UserApiKeys.user_api_key_id.asc())\
676 .order_by(UserApiKeys.user_api_key_id.asc())\
677 .all()
677 .all()
678
678
679 @LazyProperty
679 @LazyProperty
680 def feed_token(self):
680 def feed_token(self):
681 return self.get_feed_token()
681 return self.get_feed_token()
682
682
683 def get_feed_token(self, cache=True):
683 def get_feed_token(self, cache=True):
684 feed_tokens = UserApiKeys.query()\
684 feed_tokens = UserApiKeys.query()\
685 .filter(UserApiKeys.user == self)\
685 .filter(UserApiKeys.user == self)\
686 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
686 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
687 if cache:
687 if cache:
688 feed_tokens = feed_tokens.options(
688 feed_tokens = feed_tokens.options(
689 FromCache("long_term", "get_user_feed_token_%s" % self.user_id))
689 FromCache("long_term", "get_user_feed_token_%s" % self.user_id))
690
690
691 feed_tokens = feed_tokens.all()
691 feed_tokens = feed_tokens.all()
692 if feed_tokens:
692 if feed_tokens:
693 return feed_tokens[0].api_key
693 return feed_tokens[0].api_key
694 return 'NO_FEED_TOKEN_AVAILABLE'
694 return 'NO_FEED_TOKEN_AVAILABLE'
695
695
696 @classmethod
696 @classmethod
697 def get(cls, user_id, cache=False):
697 def get(cls, user_id, cache=False):
698 if not user_id:
698 if not user_id:
699 return
699 return
700
700
701 user = cls.query()
701 user = cls.query()
702 if cache:
702 if cache:
703 user = user.options(
703 user = user.options(
704 FromCache("sql_cache_short", "get_users_%s" % user_id))
704 FromCache("sql_cache_short", "get_users_%s" % user_id))
705 return user.get(user_id)
705 return user.get(user_id)
706
706
707 @classmethod
707 @classmethod
708 def extra_valid_auth_tokens(cls, user, role=None):
708 def extra_valid_auth_tokens(cls, user, role=None):
709 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
709 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
710 .filter(or_(UserApiKeys.expires == -1,
710 .filter(or_(UserApiKeys.expires == -1,
711 UserApiKeys.expires >= time.time()))
711 UserApiKeys.expires >= time.time()))
712 if role:
712 if role:
713 tokens = tokens.filter(or_(UserApiKeys.role == role,
713 tokens = tokens.filter(or_(UserApiKeys.role == role,
714 UserApiKeys.role == UserApiKeys.ROLE_ALL))
714 UserApiKeys.role == UserApiKeys.ROLE_ALL))
715 return tokens.all()
715 return tokens.all()
716
716
717 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
717 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
718 from rhodecode.lib import auth
718 from rhodecode.lib import auth
719
719
720 log.debug('Trying to authenticate user: %s via auth-token, '
720 log.debug('Trying to authenticate user: %s via auth-token, '
721 'and roles: %s', self, roles)
721 'and roles: %s', self, roles)
722
722
723 if not auth_token:
723 if not auth_token:
724 return False
724 return False
725
725
726 crypto_backend = auth.crypto_backend()
726 crypto_backend = auth.crypto_backend()
727
727
728 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
728 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
729 tokens_q = UserApiKeys.query()\
729 tokens_q = UserApiKeys.query()\
730 .filter(UserApiKeys.user_id == self.user_id)\
730 .filter(UserApiKeys.user_id == self.user_id)\
731 .filter(or_(UserApiKeys.expires == -1,
731 .filter(or_(UserApiKeys.expires == -1,
732 UserApiKeys.expires >= time.time()))
732 UserApiKeys.expires >= time.time()))
733
733
734 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
734 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
735
735
736 plain_tokens = []
736 plain_tokens = []
737 hash_tokens = []
737 hash_tokens = []
738
738
739 for token in tokens_q.all():
739 for token in tokens_q.all():
740 # verify scope first
740 # verify scope first
741 if token.repo_id:
741 if token.repo_id:
742 # token has a scope, we need to verify it
742 # token has a scope, we need to verify it
743 if scope_repo_id != token.repo_id:
743 if scope_repo_id != token.repo_id:
744 log.debug(
744 log.debug(
745 'Scope mismatch: token has a set repo scope: %s, '
745 'Scope mismatch: token has a set repo scope: %s, '
746 'and calling scope is:%s, skipping further checks',
746 'and calling scope is:%s, skipping further checks',
747 token.repo, scope_repo_id)
747 token.repo, scope_repo_id)
748 # token has a scope, and it doesn't match, skip token
748 # token has a scope, and it doesn't match, skip token
749 continue
749 continue
750
750
751 if token.api_key.startswith(crypto_backend.ENC_PREF):
751 if token.api_key.startswith(crypto_backend.ENC_PREF):
752 hash_tokens.append(token.api_key)
752 hash_tokens.append(token.api_key)
753 else:
753 else:
754 plain_tokens.append(token.api_key)
754 plain_tokens.append(token.api_key)
755
755
756 is_plain_match = auth_token in plain_tokens
756 is_plain_match = auth_token in plain_tokens
757 if is_plain_match:
757 if is_plain_match:
758 return True
758 return True
759
759
760 for hashed in hash_tokens:
760 for hashed in hash_tokens:
761 # TODO(marcink): this is expensive to calculate, but most secure
761 # TODO(marcink): this is expensive to calculate, but most secure
762 match = crypto_backend.hash_check(auth_token, hashed)
762 match = crypto_backend.hash_check(auth_token, hashed)
763 if match:
763 if match:
764 return True
764 return True
765
765
766 return False
766 return False
767
767
768 @property
768 @property
769 def ip_addresses(self):
769 def ip_addresses(self):
770 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
770 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
771 return [x.ip_addr for x in ret]
771 return [x.ip_addr for x in ret]
772
772
773 @property
773 @property
774 def username_and_name(self):
774 def username_and_name(self):
775 return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
775 return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
776
776
777 @property
777 @property
778 def username_or_name_or_email(self):
778 def username_or_name_or_email(self):
779 full_name = self.full_name if self.full_name is not ' ' else None
779 full_name = self.full_name if self.full_name is not ' ' else None
780 return self.username or full_name or self.email
780 return self.username or full_name or self.email
781
781
782 @property
782 @property
783 def full_name(self):
783 def full_name(self):
784 return '%s %s' % (self.first_name, self.last_name)
784 return '%s %s' % (self.first_name, self.last_name)
785
785
786 @property
786 @property
787 def full_name_or_username(self):
787 def full_name_or_username(self):
788 return ('%s %s' % (self.first_name, self.last_name)
788 return ('%s %s' % (self.first_name, self.last_name)
789 if (self.first_name and self.last_name) else self.username)
789 if (self.first_name and self.last_name) else self.username)
790
790
791 @property
791 @property
792 def full_contact(self):
792 def full_contact(self):
793 return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
793 return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
794
794
795 @property
795 @property
796 def short_contact(self):
796 def short_contact(self):
797 return '%s %s' % (self.first_name, self.last_name)
797 return '%s %s' % (self.first_name, self.last_name)
798
798
799 @property
799 @property
800 def is_admin(self):
800 def is_admin(self):
801 return self.admin
801 return self.admin
802
802
803 def AuthUser(self, **kwargs):
803 def AuthUser(self, **kwargs):
804 """
804 """
805 Returns instance of AuthUser for this user
805 Returns instance of AuthUser for this user
806 """
806 """
807 from rhodecode.lib.auth import AuthUser
807 from rhodecode.lib.auth import AuthUser
808 return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
808 return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
809
809
810 @hybrid_property
810 @hybrid_property
811 def user_data(self):
811 def user_data(self):
812 if not self._user_data:
812 if not self._user_data:
813 return {}
813 return {}
814
814
815 try:
815 try:
816 return json.loads(self._user_data)
816 return json.loads(self._user_data)
817 except TypeError:
817 except TypeError:
818 return {}
818 return {}
819
819
820 @user_data.setter
820 @user_data.setter
821 def user_data(self, val):
821 def user_data(self, val):
822 if not isinstance(val, dict):
822 if not isinstance(val, dict):
823 raise Exception('user_data must be dict, got %s' % type(val))
823 raise Exception('user_data must be dict, got %s' % type(val))
824 try:
824 try:
825 self._user_data = json.dumps(val)
825 self._user_data = json.dumps(val)
826 except Exception:
826 except Exception:
827 log.error(traceback.format_exc())
827 log.error(traceback.format_exc())
828
828
829 @classmethod
829 @classmethod
830 def get_by_username(cls, username, case_insensitive=False,
830 def get_by_username(cls, username, case_insensitive=False,
831 cache=False, identity_cache=False):
831 cache=False, identity_cache=False):
832 session = Session()
832 session = Session()
833
833
834 if case_insensitive:
834 if case_insensitive:
835 q = cls.query().filter(
835 q = cls.query().filter(
836 func.lower(cls.username) == func.lower(username))
836 func.lower(cls.username) == func.lower(username))
837 else:
837 else:
838 q = cls.query().filter(cls.username == username)
838 q = cls.query().filter(cls.username == username)
839
839
840 if cache:
840 if cache:
841 if identity_cache:
841 if identity_cache:
842 val = cls.identity_cache(session, 'username', username)
842 val = cls.identity_cache(session, 'username', username)
843 if val:
843 if val:
844 return val
844 return val
845 else:
845 else:
846 cache_key = "get_user_by_name_%s" % _hash_key(username)
846 cache_key = "get_user_by_name_%s" % _hash_key(username)
847 q = q.options(
847 q = q.options(
848 FromCache("sql_cache_short", cache_key))
848 FromCache("sql_cache_short", cache_key))
849
849
850 return q.scalar()
850 return q.scalar()
851
851
852 @classmethod
852 @classmethod
853 def get_by_auth_token(cls, auth_token, cache=False):
853 def get_by_auth_token(cls, auth_token, cache=False):
854 q = UserApiKeys.query()\
854 q = UserApiKeys.query()\
855 .filter(UserApiKeys.api_key == auth_token)\
855 .filter(UserApiKeys.api_key == auth_token)\
856 .filter(or_(UserApiKeys.expires == -1,
856 .filter(or_(UserApiKeys.expires == -1,
857 UserApiKeys.expires >= time.time()))
857 UserApiKeys.expires >= time.time()))
858 if cache:
858 if cache:
859 q = q.options(
859 q = q.options(
860 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
860 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
861
861
862 match = q.first()
862 match = q.first()
863 if match:
863 if match:
864 return match.user
864 return match.user
865
865
866 @classmethod
866 @classmethod
867 def get_by_email(cls, email, case_insensitive=False, cache=False):
867 def get_by_email(cls, email, case_insensitive=False, cache=False):
868
868
869 if case_insensitive:
869 if case_insensitive:
870 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
870 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
871
871
872 else:
872 else:
873 q = cls.query().filter(cls.email == email)
873 q = cls.query().filter(cls.email == email)
874
874
875 email_key = _hash_key(email)
875 email_key = _hash_key(email)
876 if cache:
876 if cache:
877 q = q.options(
877 q = q.options(
878 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
878 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
879
879
880 ret = q.scalar()
880 ret = q.scalar()
881 if ret is None:
881 if ret is None:
882 q = UserEmailMap.query()
882 q = UserEmailMap.query()
883 # try fetching in alternate email map
883 # try fetching in alternate email map
884 if case_insensitive:
884 if case_insensitive:
885 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
885 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
886 else:
886 else:
887 q = q.filter(UserEmailMap.email == email)
887 q = q.filter(UserEmailMap.email == email)
888 q = q.options(joinedload(UserEmailMap.user))
888 q = q.options(joinedload(UserEmailMap.user))
889 if cache:
889 if cache:
890 q = q.options(
890 q = q.options(
891 FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
891 FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
892 ret = getattr(q.scalar(), 'user', None)
892 ret = getattr(q.scalar(), 'user', None)
893
893
894 return ret
894 return ret
895
895
896 @classmethod
896 @classmethod
897 def get_from_cs_author(cls, author):
897 def get_from_cs_author(cls, author):
898 """
898 """
899 Tries to get User objects out of commit author string
899 Tries to get User objects out of commit author string
900
900
901 :param author:
901 :param author:
902 """
902 """
903 from rhodecode.lib.helpers import email, author_name
903 from rhodecode.lib.helpers import email, author_name
904 # Valid email in the attribute passed, see if they're in the system
904 # Valid email in the attribute passed, see if they're in the system
905 _email = email(author)
905 _email = email(author)
906 if _email:
906 if _email:
907 user = cls.get_by_email(_email, case_insensitive=True)
907 user = cls.get_by_email(_email, case_insensitive=True)
908 if user:
908 if user:
909 return user
909 return user
910 # Maybe we can match by username?
910 # Maybe we can match by username?
911 _author = author_name(author)
911 _author = author_name(author)
912 user = cls.get_by_username(_author, case_insensitive=True)
912 user = cls.get_by_username(_author, case_insensitive=True)
913 if user:
913 if user:
914 return user
914 return user
915
915
916 def update_userdata(self, **kwargs):
916 def update_userdata(self, **kwargs):
917 usr = self
917 usr = self
918 old = usr.user_data
918 old = usr.user_data
919 old.update(**kwargs)
919 old.update(**kwargs)
920 usr.user_data = old
920 usr.user_data = old
921 Session().add(usr)
921 Session().add(usr)
922 log.debug('updated userdata with ', kwargs)
922 log.debug('updated userdata with ', kwargs)
923
923
924 def update_lastlogin(self):
924 def update_lastlogin(self):
925 """Update user lastlogin"""
925 """Update user lastlogin"""
926 self.last_login = datetime.datetime.now()
926 self.last_login = datetime.datetime.now()
927 Session().add(self)
927 Session().add(self)
928 log.debug('updated user %s lastlogin', self.username)
928 log.debug('updated user %s lastlogin', self.username)
929
929
930 def update_lastactivity(self):
930 def update_lastactivity(self):
931 """Update user lastactivity"""
931 """Update user lastactivity"""
932 self.last_activity = datetime.datetime.now()
932 self.last_activity = datetime.datetime.now()
933 Session().add(self)
933 Session().add(self)
934 log.debug('updated user `%s` last activity', self.username)
934 log.debug('updated user `%s` last activity', self.username)
935
935
936 def update_password(self, new_password):
936 def update_password(self, new_password):
937 from rhodecode.lib.auth import get_crypt_password
937 from rhodecode.lib.auth import get_crypt_password
938
938
939 self.password = get_crypt_password(new_password)
939 self.password = get_crypt_password(new_password)
940 Session().add(self)
940 Session().add(self)
941
941
942 @classmethod
942 @classmethod
943 def get_first_super_admin(cls):
943 def get_first_super_admin(cls):
944 user = User.query().filter(User.admin == true()).first()
944 user = User.query().filter(User.admin == true()).first()
945 if user is None:
945 if user is None:
946 raise Exception('FATAL: Missing administrative account!')
946 raise Exception('FATAL: Missing administrative account!')
947 return user
947 return user
948
948
949 @classmethod
949 @classmethod
950 def get_all_super_admins(cls):
950 def get_all_super_admins(cls):
951 """
951 """
952 Returns all admin accounts sorted by username
952 Returns all admin accounts sorted by username
953 """
953 """
954 return User.query().filter(User.admin == true())\
954 return User.query().filter(User.admin == true())\
955 .order_by(User.username.asc()).all()
955 .order_by(User.username.asc()).all()
956
956
957 @classmethod
957 @classmethod
958 def get_default_user(cls, cache=False, refresh=False):
958 def get_default_user(cls, cache=False, refresh=False):
959 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
959 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
960 if user is None:
960 if user is None:
961 raise Exception('FATAL: Missing default account!')
961 raise Exception('FATAL: Missing default account!')
962 if refresh:
962 if refresh:
963 # The default user might be based on outdated state which
963 # The default user might be based on outdated state which
964 # has been loaded from the cache.
964 # has been loaded from the cache.
965 # A call to refresh() ensures that the
965 # A call to refresh() ensures that the
966 # latest state from the database is used.
966 # latest state from the database is used.
967 Session().refresh(user)
967 Session().refresh(user)
968 return user
968 return user
969
969
970 def _get_default_perms(self, user, suffix=''):
970 def _get_default_perms(self, user, suffix=''):
971 from rhodecode.model.permission import PermissionModel
971 from rhodecode.model.permission import PermissionModel
972 return PermissionModel().get_default_perms(user.user_perms, suffix)
972 return PermissionModel().get_default_perms(user.user_perms, suffix)
973
973
974 def get_default_perms(self, suffix=''):
974 def get_default_perms(self, suffix=''):
975 return self._get_default_perms(self, suffix)
975 return self._get_default_perms(self, suffix)
976
976
977 def get_api_data(self, include_secrets=False, details='full'):
977 def get_api_data(self, include_secrets=False, details='full'):
978 """
978 """
979 Common function for generating user related data for API
979 Common function for generating user related data for API
980
980
981 :param include_secrets: By default secrets in the API data will be replaced
981 :param include_secrets: By default secrets in the API data will be replaced
982 by a placeholder value to prevent exposing this data by accident. In case
982 by a placeholder value to prevent exposing this data by accident. In case
983 this data shall be exposed, set this flag to ``True``.
983 this data shall be exposed, set this flag to ``True``.
984
984
985 :param details: details can be 'basic|full' basic gives only a subset of
985 :param details: details can be 'basic|full' basic gives only a subset of
986 the available user information that includes user_id, name and emails.
986 the available user information that includes user_id, name and emails.
987 """
987 """
988 user = self
988 user = self
989 user_data = self.user_data
989 user_data = self.user_data
990 data = {
990 data = {
991 'user_id': user.user_id,
991 'user_id': user.user_id,
992 'username': user.username,
992 'username': user.username,
993 'firstname': user.name,
993 'firstname': user.name,
994 'lastname': user.lastname,
994 'lastname': user.lastname,
995 'email': user.email,
995 'email': user.email,
996 'emails': user.emails,
996 'emails': user.emails,
997 }
997 }
998 if details == 'basic':
998 if details == 'basic':
999 return data
999 return data
1000
1000
1001 auth_token_length = 40
1001 auth_token_length = 40
1002 auth_token_replacement = '*' * auth_token_length
1002 auth_token_replacement = '*' * auth_token_length
1003
1003
1004 extras = {
1004 extras = {
1005 'auth_tokens': [auth_token_replacement],
1005 'auth_tokens': [auth_token_replacement],
1006 'active': user.active,
1006 'active': user.active,
1007 'admin': user.admin,
1007 'admin': user.admin,
1008 'extern_type': user.extern_type,
1008 'extern_type': user.extern_type,
1009 'extern_name': user.extern_name,
1009 'extern_name': user.extern_name,
1010 'last_login': user.last_login,
1010 'last_login': user.last_login,
1011 'last_activity': user.last_activity,
1011 'last_activity': user.last_activity,
1012 'ip_addresses': user.ip_addresses,
1012 'ip_addresses': user.ip_addresses,
1013 'language': user_data.get('language')
1013 'language': user_data.get('language')
1014 }
1014 }
1015 data.update(extras)
1015 data.update(extras)
1016
1016
1017 if include_secrets:
1017 if include_secrets:
1018 data['auth_tokens'] = user.auth_tokens
1018 data['auth_tokens'] = user.auth_tokens
1019 return data
1019 return data
1020
1020
1021 def __json__(self):
1021 def __json__(self):
1022 data = {
1022 data = {
1023 'full_name': self.full_name,
1023 'full_name': self.full_name,
1024 'full_name_or_username': self.full_name_or_username,
1024 'full_name_or_username': self.full_name_or_username,
1025 'short_contact': self.short_contact,
1025 'short_contact': self.short_contact,
1026 'full_contact': self.full_contact,
1026 'full_contact': self.full_contact,
1027 }
1027 }
1028 data.update(self.get_api_data())
1028 data.update(self.get_api_data())
1029 return data
1029 return data
1030
1030
1031
1031
1032 class UserApiKeys(Base, BaseModel):
1032 class UserApiKeys(Base, BaseModel):
1033 __tablename__ = 'user_api_keys'
1033 __tablename__ = 'user_api_keys'
1034 __table_args__ = (
1034 __table_args__ = (
1035 Index('uak_api_key_idx', 'api_key', unique=True),
1035 Index('uak_api_key_idx', 'api_key', unique=True),
1036 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
1036 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
1037 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1037 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1038 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1038 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1039 )
1039 )
1040 __mapper_args__ = {}
1040 __mapper_args__ = {}
1041
1041
1042 # ApiKey role
1042 # ApiKey role
1043 ROLE_ALL = 'token_role_all'
1043 ROLE_ALL = 'token_role_all'
1044 ROLE_HTTP = 'token_role_http'
1044 ROLE_HTTP = 'token_role_http'
1045 ROLE_VCS = 'token_role_vcs'
1045 ROLE_VCS = 'token_role_vcs'
1046 ROLE_API = 'token_role_api'
1046 ROLE_API = 'token_role_api'
1047 ROLE_FEED = 'token_role_feed'
1047 ROLE_FEED = 'token_role_feed'
1048 ROLE_PASSWORD_RESET = 'token_password_reset'
1048 ROLE_PASSWORD_RESET = 'token_password_reset'
1049
1049
1050 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
1050 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
1051
1051
1052 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1052 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1053 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1053 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1054 api_key = Column("api_key", String(255), nullable=False, unique=True)
1054 api_key = Column("api_key", String(255), nullable=False, unique=True)
1055 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1055 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1056 expires = Column('expires', Float(53), nullable=False)
1056 expires = Column('expires', Float(53), nullable=False)
1057 role = Column('role', String(255), nullable=True)
1057 role = Column('role', String(255), nullable=True)
1058 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1058 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1059
1059
1060 # scope columns
1060 # scope columns
1061 repo_id = Column(
1061 repo_id = Column(
1062 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
1062 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
1063 nullable=True, unique=None, default=None)
1063 nullable=True, unique=None, default=None)
1064 repo = relationship('Repository', lazy='joined')
1064 repo = relationship('Repository', lazy='joined')
1065
1065
1066 repo_group_id = Column(
1066 repo_group_id = Column(
1067 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
1067 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
1068 nullable=True, unique=None, default=None)
1068 nullable=True, unique=None, default=None)
1069 repo_group = relationship('RepoGroup', lazy='joined')
1069 repo_group = relationship('RepoGroup', lazy='joined')
1070
1070
1071 user = relationship('User', lazy='joined')
1071 user = relationship('User', lazy='joined')
1072
1072
1073 def __unicode__(self):
1073 def __unicode__(self):
1074 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
1074 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
1075
1075
1076 def __json__(self):
1076 def __json__(self):
1077 data = {
1077 data = {
1078 'auth_token': self.api_key,
1078 'auth_token': self.api_key,
1079 'role': self.role,
1079 'role': self.role,
1080 'scope': self.scope_humanized,
1080 'scope': self.scope_humanized,
1081 'expired': self.expired
1081 'expired': self.expired
1082 }
1082 }
1083 return data
1083 return data
1084
1084
1085 def get_api_data(self, include_secrets=False):
1085 def get_api_data(self, include_secrets=False):
1086 data = self.__json__()
1086 data = self.__json__()
1087 if include_secrets:
1087 if include_secrets:
1088 return data
1088 return data
1089 else:
1089 else:
1090 data['auth_token'] = self.token_obfuscated
1090 data['auth_token'] = self.token_obfuscated
1091 return data
1091 return data
1092
1092
1093 @hybrid_property
1093 @hybrid_property
1094 def description_safe(self):
1094 def description_safe(self):
1095 from rhodecode.lib import helpers as h
1095 from rhodecode.lib import helpers as h
1096 return h.escape(self.description)
1096 return h.escape(self.description)
1097
1097
1098 @property
1098 @property
1099 def expired(self):
1099 def expired(self):
1100 if self.expires == -1:
1100 if self.expires == -1:
1101 return False
1101 return False
1102 return time.time() > self.expires
1102 return time.time() > self.expires
1103
1103
1104 @classmethod
1104 @classmethod
1105 def _get_role_name(cls, role):
1105 def _get_role_name(cls, role):
1106 return {
1106 return {
1107 cls.ROLE_ALL: _('all'),
1107 cls.ROLE_ALL: _('all'),
1108 cls.ROLE_HTTP: _('http/web interface'),
1108 cls.ROLE_HTTP: _('http/web interface'),
1109 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1109 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1110 cls.ROLE_API: _('api calls'),
1110 cls.ROLE_API: _('api calls'),
1111 cls.ROLE_FEED: _('feed access'),
1111 cls.ROLE_FEED: _('feed access'),
1112 }.get(role, role)
1112 }.get(role, role)
1113
1113
1114 @property
1114 @property
1115 def role_humanized(self):
1115 def role_humanized(self):
1116 return self._get_role_name(self.role)
1116 return self._get_role_name(self.role)
1117
1117
1118 def _get_scope(self):
1118 def _get_scope(self):
1119 if self.repo:
1119 if self.repo:
1120 return repr(self.repo)
1120 return repr(self.repo)
1121 if self.repo_group:
1121 if self.repo_group:
1122 return repr(self.repo_group) + ' (recursive)'
1122 return repr(self.repo_group) + ' (recursive)'
1123 return 'global'
1123 return 'global'
1124
1124
1125 @property
1125 @property
1126 def scope_humanized(self):
1126 def scope_humanized(self):
1127 return self._get_scope()
1127 return self._get_scope()
1128
1128
1129 @property
1129 @property
1130 def token_obfuscated(self):
1130 def token_obfuscated(self):
1131 if self.api_key:
1131 if self.api_key:
1132 return self.api_key[:4] + "****"
1132 return self.api_key[:4] + "****"
1133
1133
1134
1134
1135 class UserEmailMap(Base, BaseModel):
1135 class UserEmailMap(Base, BaseModel):
1136 __tablename__ = 'user_email_map'
1136 __tablename__ = 'user_email_map'
1137 __table_args__ = (
1137 __table_args__ = (
1138 Index('uem_email_idx', 'email'),
1138 Index('uem_email_idx', 'email'),
1139 UniqueConstraint('email'),
1139 UniqueConstraint('email'),
1140 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1140 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1141 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1141 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1142 )
1142 )
1143 __mapper_args__ = {}
1143 __mapper_args__ = {}
1144
1144
1145 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1145 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1146 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1146 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1147 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1147 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1148 user = relationship('User', lazy='joined')
1148 user = relationship('User', lazy='joined')
1149
1149
1150 @validates('_email')
1150 @validates('_email')
1151 def validate_email(self, key, email):
1151 def validate_email(self, key, email):
1152 # check if this email is not main one
1152 # check if this email is not main one
1153 main_email = Session().query(User).filter(User.email == email).scalar()
1153 main_email = Session().query(User).filter(User.email == email).scalar()
1154 if main_email is not None:
1154 if main_email is not None:
1155 raise AttributeError('email %s is present is user table' % email)
1155 raise AttributeError('email %s is present is user table' % email)
1156 return email
1156 return email
1157
1157
1158 @hybrid_property
1158 @hybrid_property
1159 def email(self):
1159 def email(self):
1160 return self._email
1160 return self._email
1161
1161
1162 @email.setter
1162 @email.setter
1163 def email(self, val):
1163 def email(self, val):
1164 self._email = val.lower() if val else None
1164 self._email = val.lower() if val else None
1165
1165
1166
1166
1167 class UserIpMap(Base, BaseModel):
1167 class UserIpMap(Base, BaseModel):
1168 __tablename__ = 'user_ip_map'
1168 __tablename__ = 'user_ip_map'
1169 __table_args__ = (
1169 __table_args__ = (
1170 UniqueConstraint('user_id', 'ip_addr'),
1170 UniqueConstraint('user_id', 'ip_addr'),
1171 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1171 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1172 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1172 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1173 )
1173 )
1174 __mapper_args__ = {}
1174 __mapper_args__ = {}
1175
1175
1176 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1176 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1177 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1177 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1178 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1178 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1179 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1179 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1180 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1180 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1181 user = relationship('User', lazy='joined')
1181 user = relationship('User', lazy='joined')
1182
1182
1183 @hybrid_property
1183 @hybrid_property
1184 def description_safe(self):
1184 def description_safe(self):
1185 from rhodecode.lib import helpers as h
1185 from rhodecode.lib import helpers as h
1186 return h.escape(self.description)
1186 return h.escape(self.description)
1187
1187
1188 @classmethod
1188 @classmethod
1189 def _get_ip_range(cls, ip_addr):
1189 def _get_ip_range(cls, ip_addr):
1190 net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
1190 net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
1191 return [str(net.network_address), str(net.broadcast_address)]
1191 return [str(net.network_address), str(net.broadcast_address)]
1192
1192
1193 def __json__(self):
1193 def __json__(self):
1194 return {
1194 return {
1195 'ip_addr': self.ip_addr,
1195 'ip_addr': self.ip_addr,
1196 'ip_range': self._get_ip_range(self.ip_addr),
1196 'ip_range': self._get_ip_range(self.ip_addr),
1197 }
1197 }
1198
1198
1199 def __unicode__(self):
1199 def __unicode__(self):
1200 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1200 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1201 self.user_id, self.ip_addr)
1201 self.user_id, self.ip_addr)
1202
1202
1203
1203
1204 class UserSshKeys(Base, BaseModel):
1204 class UserSshKeys(Base, BaseModel):
1205 __tablename__ = 'user_ssh_keys'
1205 __tablename__ = 'user_ssh_keys'
1206 __table_args__ = (
1206 __table_args__ = (
1207 Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
1207 Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
1208
1208
1209 UniqueConstraint('ssh_key_fingerprint'),
1209 UniqueConstraint('ssh_key_fingerprint'),
1210
1210
1211 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1211 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1212 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1212 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1213 )
1213 )
1214 __mapper_args__ = {}
1214 __mapper_args__ = {}
1215
1215
1216 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
1216 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
1217 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
1217 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
1218 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
1218 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
1219
1219
1220 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1220 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1221
1221
1222 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1222 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1223 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
1223 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
1224 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1224 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1225
1225
1226 user = relationship('User', lazy='joined')
1226 user = relationship('User', lazy='joined')
1227
1227
1228 def __json__(self):
1228 def __json__(self):
1229 data = {
1229 data = {
1230 'ssh_fingerprint': self.ssh_key_fingerprint,
1230 'ssh_fingerprint': self.ssh_key_fingerprint,
1231 'description': self.description,
1231 'description': self.description,
1232 'created_on': self.created_on
1232 'created_on': self.created_on
1233 }
1233 }
1234 return data
1234 return data
1235
1235
1236 def get_api_data(self):
1236 def get_api_data(self):
1237 data = self.__json__()
1237 data = self.__json__()
1238 return data
1238 return data
1239
1239
1240
1240
1241 class UserLog(Base, BaseModel):
1241 class UserLog(Base, BaseModel):
1242 __tablename__ = 'user_logs'
1242 __tablename__ = 'user_logs'
1243 __table_args__ = (
1243 __table_args__ = (
1244 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1244 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1245 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1245 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1246 )
1246 )
1247 VERSION_1 = 'v1'
1247 VERSION_1 = 'v1'
1248 VERSION_2 = 'v2'
1248 VERSION_2 = 'v2'
1249 VERSIONS = [VERSION_1, VERSION_2]
1249 VERSIONS = [VERSION_1, VERSION_2]
1250
1250
1251 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1251 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1252 user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
1252 user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
1253 username = Column("username", String(255), nullable=True, unique=None, default=None)
1253 username = Column("username", String(255), nullable=True, unique=None, default=None)
1254 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
1254 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
1255 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1255 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1256 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1256 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1257 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1257 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1258 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1258 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1259
1259
1260 version = Column("version", String(255), nullable=True, default=VERSION_1)
1260 version = Column("version", String(255), nullable=True, default=VERSION_1)
1261 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1261 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1262 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1262 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1263
1263
1264 def __unicode__(self):
1264 def __unicode__(self):
1265 return u"<%s('id:%s:%s')>" % (
1265 return u"<%s('id:%s:%s')>" % (
1266 self.__class__.__name__, self.repository_name, self.action)
1266 self.__class__.__name__, self.repository_name, self.action)
1267
1267
1268 def __json__(self):
1268 def __json__(self):
1269 return {
1269 return {
1270 'user_id': self.user_id,
1270 'user_id': self.user_id,
1271 'username': self.username,
1271 'username': self.username,
1272 'repository_id': self.repository_id,
1272 'repository_id': self.repository_id,
1273 'repository_name': self.repository_name,
1273 'repository_name': self.repository_name,
1274 'user_ip': self.user_ip,
1274 'user_ip': self.user_ip,
1275 'action_date': self.action_date,
1275 'action_date': self.action_date,
1276 'action': self.action,
1276 'action': self.action,
1277 }
1277 }
1278
1278
1279 @hybrid_property
1279 @hybrid_property
1280 def entry_id(self):
1280 def entry_id(self):
1281 return self.user_log_id
1281 return self.user_log_id
1282
1282
1283 @property
1283 @property
1284 def action_as_day(self):
1284 def action_as_day(self):
1285 return datetime.date(*self.action_date.timetuple()[:3])
1285 return datetime.date(*self.action_date.timetuple()[:3])
1286
1286
1287 user = relationship('User')
1287 user = relationship('User')
1288 repository = relationship('Repository', cascade='')
1288 repository = relationship('Repository', cascade='')
1289
1289
1290
1290
1291 class UserGroup(Base, BaseModel):
1291 class UserGroup(Base, BaseModel):
1292 __tablename__ = 'users_groups'
1292 __tablename__ = 'users_groups'
1293 __table_args__ = (
1293 __table_args__ = (
1294 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1294 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1295 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1295 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1296 )
1296 )
1297
1297
1298 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1298 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1299 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1299 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1300 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1300 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1301 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1301 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1302 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1302 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1303 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1303 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1304 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1304 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1305 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1305 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1306
1306
1307 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1307 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1308 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1308 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1309 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1309 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1310 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1310 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1311 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1311 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1312 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1312 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1313
1313
1314 user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
1314 user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
1315 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
1315 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
1316
1316
1317 @classmethod
1317 @classmethod
1318 def _load_group_data(cls, column):
1318 def _load_group_data(cls, column):
1319 if not column:
1319 if not column:
1320 return {}
1320 return {}
1321
1321
1322 try:
1322 try:
1323 return json.loads(column) or {}
1323 return json.loads(column) or {}
1324 except TypeError:
1324 except TypeError:
1325 return {}
1325 return {}
1326
1326
1327 @hybrid_property
1327 @hybrid_property
1328 def description_safe(self):
1328 def description_safe(self):
1329 from rhodecode.lib import helpers as h
1329 from rhodecode.lib import helpers as h
1330 return h.escape(self.user_group_description)
1330 return h.escape(self.user_group_description)
1331
1331
1332 @hybrid_property
1332 @hybrid_property
1333 def group_data(self):
1333 def group_data(self):
1334 return self._load_group_data(self._group_data)
1334 return self._load_group_data(self._group_data)
1335
1335
1336 @group_data.expression
1336 @group_data.expression
1337 def group_data(self, **kwargs):
1337 def group_data(self, **kwargs):
1338 return self._group_data
1338 return self._group_data
1339
1339
1340 @group_data.setter
1340 @group_data.setter
1341 def group_data(self, val):
1341 def group_data(self, val):
1342 try:
1342 try:
1343 self._group_data = json.dumps(val)
1343 self._group_data = json.dumps(val)
1344 except Exception:
1344 except Exception:
1345 log.error(traceback.format_exc())
1345 log.error(traceback.format_exc())
1346
1346
1347 @classmethod
1347 @classmethod
1348 def _load_sync(cls, group_data):
1348 def _load_sync(cls, group_data):
1349 if group_data:
1349 if group_data:
1350 return group_data.get('extern_type')
1350 return group_data.get('extern_type')
1351
1351
1352 @property
1352 @property
1353 def sync(self):
1353 def sync(self):
1354 return self._load_sync(self.group_data)
1354 return self._load_sync(self.group_data)
1355
1355
1356 def __unicode__(self):
1356 def __unicode__(self):
1357 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1357 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1358 self.users_group_id,
1358 self.users_group_id,
1359 self.users_group_name)
1359 self.users_group_name)
1360
1360
1361 @classmethod
1361 @classmethod
1362 def get_by_group_name(cls, group_name, cache=False,
1362 def get_by_group_name(cls, group_name, cache=False,
1363 case_insensitive=False):
1363 case_insensitive=False):
1364 if case_insensitive:
1364 if case_insensitive:
1365 q = cls.query().filter(func.lower(cls.users_group_name) ==
1365 q = cls.query().filter(func.lower(cls.users_group_name) ==
1366 func.lower(group_name))
1366 func.lower(group_name))
1367
1367
1368 else:
1368 else:
1369 q = cls.query().filter(cls.users_group_name == group_name)
1369 q = cls.query().filter(cls.users_group_name == group_name)
1370 if cache:
1370 if cache:
1371 q = q.options(
1371 q = q.options(
1372 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
1372 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
1373 return q.scalar()
1373 return q.scalar()
1374
1374
1375 @classmethod
1375 @classmethod
1376 def get(cls, user_group_id, cache=False):
1376 def get(cls, user_group_id, cache=False):
1377 if not user_group_id:
1377 if not user_group_id:
1378 return
1378 return
1379
1379
1380 user_group = cls.query()
1380 user_group = cls.query()
1381 if cache:
1381 if cache:
1382 user_group = user_group.options(
1382 user_group = user_group.options(
1383 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
1383 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
1384 return user_group.get(user_group_id)
1384 return user_group.get(user_group_id)
1385
1385
1386 def permissions(self, with_admins=True, with_owner=True):
1386 def permissions(self, with_admins=True, with_owner=True):
1387 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1387 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1388 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1388 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1389 joinedload(UserUserGroupToPerm.user),
1389 joinedload(UserUserGroupToPerm.user),
1390 joinedload(UserUserGroupToPerm.permission),)
1390 joinedload(UserUserGroupToPerm.permission),)
1391
1391
1392 # get owners and admins and permissions. We do a trick of re-writing
1392 # get owners and admins and permissions. We do a trick of re-writing
1393 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1393 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1394 # has a global reference and changing one object propagates to all
1394 # has a global reference and changing one object propagates to all
1395 # others. This means if admin is also an owner admin_row that change
1395 # others. This means if admin is also an owner admin_row that change
1396 # would propagate to both objects
1396 # would propagate to both objects
1397 perm_rows = []
1397 perm_rows = []
1398 for _usr in q.all():
1398 for _usr in q.all():
1399 usr = AttributeDict(_usr.user.get_dict())
1399 usr = AttributeDict(_usr.user.get_dict())
1400 usr.permission = _usr.permission.permission_name
1400 usr.permission = _usr.permission.permission_name
1401 perm_rows.append(usr)
1401 perm_rows.append(usr)
1402
1402
1403 # filter the perm rows by 'default' first and then sort them by
1403 # filter the perm rows by 'default' first and then sort them by
1404 # admin,write,read,none permissions sorted again alphabetically in
1404 # admin,write,read,none permissions sorted again alphabetically in
1405 # each group
1405 # each group
1406 perm_rows = sorted(perm_rows, key=display_user_sort)
1406 perm_rows = sorted(perm_rows, key=display_user_sort)
1407
1407
1408 _admin_perm = 'usergroup.admin'
1408 _admin_perm = 'usergroup.admin'
1409 owner_row = []
1409 owner_row = []
1410 if with_owner:
1410 if with_owner:
1411 usr = AttributeDict(self.user.get_dict())
1411 usr = AttributeDict(self.user.get_dict())
1412 usr.owner_row = True
1412 usr.owner_row = True
1413 usr.permission = _admin_perm
1413 usr.permission = _admin_perm
1414 owner_row.append(usr)
1414 owner_row.append(usr)
1415
1415
1416 super_admin_rows = []
1416 super_admin_rows = []
1417 if with_admins:
1417 if with_admins:
1418 for usr in User.get_all_super_admins():
1418 for usr in User.get_all_super_admins():
1419 # if this admin is also owner, don't double the record
1419 # if this admin is also owner, don't double the record
1420 if usr.user_id == owner_row[0].user_id:
1420 if usr.user_id == owner_row[0].user_id:
1421 owner_row[0].admin_row = True
1421 owner_row[0].admin_row = True
1422 else:
1422 else:
1423 usr = AttributeDict(usr.get_dict())
1423 usr = AttributeDict(usr.get_dict())
1424 usr.admin_row = True
1424 usr.admin_row = True
1425 usr.permission = _admin_perm
1425 usr.permission = _admin_perm
1426 super_admin_rows.append(usr)
1426 super_admin_rows.append(usr)
1427
1427
1428 return super_admin_rows + owner_row + perm_rows
1428 return super_admin_rows + owner_row + perm_rows
1429
1429
1430 def permission_user_groups(self):
1430 def permission_user_groups(self):
1431 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1431 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1432 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1432 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1433 joinedload(UserGroupUserGroupToPerm.target_user_group),
1433 joinedload(UserGroupUserGroupToPerm.target_user_group),
1434 joinedload(UserGroupUserGroupToPerm.permission),)
1434 joinedload(UserGroupUserGroupToPerm.permission),)
1435
1435
1436 perm_rows = []
1436 perm_rows = []
1437 for _user_group in q.all():
1437 for _user_group in q.all():
1438 usr = AttributeDict(_user_group.user_group.get_dict())
1438 usr = AttributeDict(_user_group.user_group.get_dict())
1439 usr.permission = _user_group.permission.permission_name
1439 usr.permission = _user_group.permission.permission_name
1440 perm_rows.append(usr)
1440 perm_rows.append(usr)
1441
1441
1442 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1442 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1443 return perm_rows
1443 return perm_rows
1444
1444
1445 def _get_default_perms(self, user_group, suffix=''):
1445 def _get_default_perms(self, user_group, suffix=''):
1446 from rhodecode.model.permission import PermissionModel
1446 from rhodecode.model.permission import PermissionModel
1447 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1447 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1448
1448
1449 def get_default_perms(self, suffix=''):
1449 def get_default_perms(self, suffix=''):
1450 return self._get_default_perms(self, suffix)
1450 return self._get_default_perms(self, suffix)
1451
1451
1452 def get_api_data(self, with_group_members=True, include_secrets=False):
1452 def get_api_data(self, with_group_members=True, include_secrets=False):
1453 """
1453 """
1454 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1454 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1455 basically forwarded.
1455 basically forwarded.
1456
1456
1457 """
1457 """
1458 user_group = self
1458 user_group = self
1459 data = {
1459 data = {
1460 'users_group_id': user_group.users_group_id,
1460 'users_group_id': user_group.users_group_id,
1461 'group_name': user_group.users_group_name,
1461 'group_name': user_group.users_group_name,
1462 'group_description': user_group.user_group_description,
1462 'group_description': user_group.user_group_description,
1463 'active': user_group.users_group_active,
1463 'active': user_group.users_group_active,
1464 'owner': user_group.user.username,
1464 'owner': user_group.user.username,
1465 'sync': user_group.sync,
1465 'sync': user_group.sync,
1466 'owner_email': user_group.user.email,
1466 'owner_email': user_group.user.email,
1467 }
1467 }
1468
1468
1469 if with_group_members:
1469 if with_group_members:
1470 users = []
1470 users = []
1471 for user in user_group.members:
1471 for user in user_group.members:
1472 user = user.user
1472 user = user.user
1473 users.append(user.get_api_data(include_secrets=include_secrets))
1473 users.append(user.get_api_data(include_secrets=include_secrets))
1474 data['users'] = users
1474 data['users'] = users
1475
1475
1476 return data
1476 return data
1477
1477
1478
1478
1479 class UserGroupMember(Base, BaseModel):
1479 class UserGroupMember(Base, BaseModel):
1480 __tablename__ = 'users_groups_members'
1480 __tablename__ = 'users_groups_members'
1481 __table_args__ = (
1481 __table_args__ = (
1482 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1482 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1483 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1483 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1484 )
1484 )
1485
1485
1486 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1486 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1487 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1487 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1488 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1488 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1489
1489
1490 user = relationship('User', lazy='joined')
1490 user = relationship('User', lazy='joined')
1491 users_group = relationship('UserGroup')
1491 users_group = relationship('UserGroup')
1492
1492
1493 def __init__(self, gr_id='', u_id=''):
1493 def __init__(self, gr_id='', u_id=''):
1494 self.users_group_id = gr_id
1494 self.users_group_id = gr_id
1495 self.user_id = u_id
1495 self.user_id = u_id
1496
1496
1497
1497
1498 class RepositoryField(Base, BaseModel):
1498 class RepositoryField(Base, BaseModel):
1499 __tablename__ = 'repositories_fields'
1499 __tablename__ = 'repositories_fields'
1500 __table_args__ = (
1500 __table_args__ = (
1501 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1501 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1502 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1502 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1503 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1503 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1504 )
1504 )
1505 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1505 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1506
1506
1507 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1507 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1508 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1508 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1509 field_key = Column("field_key", String(250))
1509 field_key = Column("field_key", String(250))
1510 field_label = Column("field_label", String(1024), nullable=False)
1510 field_label = Column("field_label", String(1024), nullable=False)
1511 field_value = Column("field_value", String(10000), nullable=False)
1511 field_value = Column("field_value", String(10000), nullable=False)
1512 field_desc = Column("field_desc", String(1024), nullable=False)
1512 field_desc = Column("field_desc", String(1024), nullable=False)
1513 field_type = Column("field_type", String(255), nullable=False, unique=None)
1513 field_type = Column("field_type", String(255), nullable=False, unique=None)
1514 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1514 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1515
1515
1516 repository = relationship('Repository')
1516 repository = relationship('Repository')
1517
1517
1518 @property
1518 @property
1519 def field_key_prefixed(self):
1519 def field_key_prefixed(self):
1520 return 'ex_%s' % self.field_key
1520 return 'ex_%s' % self.field_key
1521
1521
1522 @classmethod
1522 @classmethod
1523 def un_prefix_key(cls, key):
1523 def un_prefix_key(cls, key):
1524 if key.startswith(cls.PREFIX):
1524 if key.startswith(cls.PREFIX):
1525 return key[len(cls.PREFIX):]
1525 return key[len(cls.PREFIX):]
1526 return key
1526 return key
1527
1527
1528 @classmethod
1528 @classmethod
1529 def get_by_key_name(cls, key, repo):
1529 def get_by_key_name(cls, key, repo):
1530 row = cls.query()\
1530 row = cls.query()\
1531 .filter(cls.repository == repo)\
1531 .filter(cls.repository == repo)\
1532 .filter(cls.field_key == key).scalar()
1532 .filter(cls.field_key == key).scalar()
1533 return row
1533 return row
1534
1534
1535
1535
1536 class Repository(Base, BaseModel):
1536 class Repository(Base, BaseModel):
1537 __tablename__ = 'repositories'
1537 __tablename__ = 'repositories'
1538 __table_args__ = (
1538 __table_args__ = (
1539 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1539 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1540 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1540 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1541 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1541 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1542 )
1542 )
1543 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1543 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1544 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1544 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1545 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
1545 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
1546
1546
1547 STATE_CREATED = 'repo_state_created'
1547 STATE_CREATED = 'repo_state_created'
1548 STATE_PENDING = 'repo_state_pending'
1548 STATE_PENDING = 'repo_state_pending'
1549 STATE_ERROR = 'repo_state_error'
1549 STATE_ERROR = 'repo_state_error'
1550
1550
1551 LOCK_AUTOMATIC = 'lock_auto'
1551 LOCK_AUTOMATIC = 'lock_auto'
1552 LOCK_API = 'lock_api'
1552 LOCK_API = 'lock_api'
1553 LOCK_WEB = 'lock_web'
1553 LOCK_WEB = 'lock_web'
1554 LOCK_PULL = 'lock_pull'
1554 LOCK_PULL = 'lock_pull'
1555
1555
1556 NAME_SEP = URL_SEP
1556 NAME_SEP = URL_SEP
1557
1557
1558 repo_id = Column(
1558 repo_id = Column(
1559 "repo_id", Integer(), nullable=False, unique=True, default=None,
1559 "repo_id", Integer(), nullable=False, unique=True, default=None,
1560 primary_key=True)
1560 primary_key=True)
1561 _repo_name = Column(
1561 _repo_name = Column(
1562 "repo_name", Text(), nullable=False, default=None)
1562 "repo_name", Text(), nullable=False, default=None)
1563 _repo_name_hash = Column(
1563 _repo_name_hash = Column(
1564 "repo_name_hash", String(255), nullable=False, unique=True)
1564 "repo_name_hash", String(255), nullable=False, unique=True)
1565 repo_state = Column("repo_state", String(255), nullable=True)
1565 repo_state = Column("repo_state", String(255), nullable=True)
1566
1566
1567 clone_uri = Column(
1567 clone_uri = Column(
1568 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1568 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1569 default=None)
1569 default=None)
1570 push_uri = Column(
1570 push_uri = Column(
1571 "push_uri", EncryptedTextValue(), nullable=True, unique=False,
1571 "push_uri", EncryptedTextValue(), nullable=True, unique=False,
1572 default=None)
1572 default=None)
1573 repo_type = Column(
1573 repo_type = Column(
1574 "repo_type", String(255), nullable=False, unique=False, default=None)
1574 "repo_type", String(255), nullable=False, unique=False, default=None)
1575 user_id = Column(
1575 user_id = Column(
1576 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1576 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1577 unique=False, default=None)
1577 unique=False, default=None)
1578 private = Column(
1578 private = Column(
1579 "private", Boolean(), nullable=True, unique=None, default=None)
1579 "private", Boolean(), nullable=True, unique=None, default=None)
1580 enable_statistics = Column(
1580 enable_statistics = Column(
1581 "statistics", Boolean(), nullable=True, unique=None, default=True)
1581 "statistics", Boolean(), nullable=True, unique=None, default=True)
1582 enable_downloads = Column(
1582 enable_downloads = Column(
1583 "downloads", Boolean(), nullable=True, unique=None, default=True)
1583 "downloads", Boolean(), nullable=True, unique=None, default=True)
1584 description = Column(
1584 description = Column(
1585 "description", String(10000), nullable=True, unique=None, default=None)
1585 "description", String(10000), nullable=True, unique=None, default=None)
1586 created_on = Column(
1586 created_on = Column(
1587 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1587 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1588 default=datetime.datetime.now)
1588 default=datetime.datetime.now)
1589 updated_on = Column(
1589 updated_on = Column(
1590 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1590 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1591 default=datetime.datetime.now)
1591 default=datetime.datetime.now)
1592 _landing_revision = Column(
1592 _landing_revision = Column(
1593 "landing_revision", String(255), nullable=False, unique=False,
1593 "landing_revision", String(255), nullable=False, unique=False,
1594 default=None)
1594 default=None)
1595 enable_locking = Column(
1595 enable_locking = Column(
1596 "enable_locking", Boolean(), nullable=False, unique=None,
1596 "enable_locking", Boolean(), nullable=False, unique=None,
1597 default=False)
1597 default=False)
1598 _locked = Column(
1598 _locked = Column(
1599 "locked", String(255), nullable=True, unique=False, default=None)
1599 "locked", String(255), nullable=True, unique=False, default=None)
1600 _changeset_cache = Column(
1600 _changeset_cache = Column(
1601 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1601 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1602
1602
1603 fork_id = Column(
1603 fork_id = Column(
1604 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1604 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1605 nullable=True, unique=False, default=None)
1605 nullable=True, unique=False, default=None)
1606 group_id = Column(
1606 group_id = Column(
1607 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1607 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1608 unique=False, default=None)
1608 unique=False, default=None)
1609
1609
1610 user = relationship('User', lazy='joined')
1610 user = relationship('User', lazy='joined')
1611 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1611 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1612 group = relationship('RepoGroup', lazy='joined')
1612 group = relationship('RepoGroup', lazy='joined')
1613 repo_to_perm = relationship(
1613 repo_to_perm = relationship(
1614 'UserRepoToPerm', cascade='all',
1614 'UserRepoToPerm', cascade='all',
1615 order_by='UserRepoToPerm.repo_to_perm_id')
1615 order_by='UserRepoToPerm.repo_to_perm_id')
1616 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1616 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1617 stats = relationship('Statistics', cascade='all', uselist=False)
1617 stats = relationship('Statistics', cascade='all', uselist=False)
1618
1618
1619 followers = relationship(
1619 followers = relationship(
1620 'UserFollowing',
1620 'UserFollowing',
1621 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1621 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1622 cascade='all')
1622 cascade='all')
1623 extra_fields = relationship(
1623 extra_fields = relationship(
1624 'RepositoryField', cascade="all, delete, delete-orphan")
1624 'RepositoryField', cascade="all, delete, delete-orphan")
1625 logs = relationship('UserLog')
1625 logs = relationship('UserLog')
1626 comments = relationship(
1626 comments = relationship(
1627 'ChangesetComment', cascade="all, delete, delete-orphan")
1627 'ChangesetComment', cascade="all, delete, delete-orphan")
1628 pull_requests_source = relationship(
1628 pull_requests_source = relationship(
1629 'PullRequest',
1629 'PullRequest',
1630 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1630 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1631 cascade="all, delete, delete-orphan")
1631 cascade="all, delete, delete-orphan")
1632 pull_requests_target = relationship(
1632 pull_requests_target = relationship(
1633 'PullRequest',
1633 'PullRequest',
1634 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1634 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1635 cascade="all, delete, delete-orphan")
1635 cascade="all, delete, delete-orphan")
1636 ui = relationship('RepoRhodeCodeUi', cascade="all")
1636 ui = relationship('RepoRhodeCodeUi', cascade="all")
1637 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1637 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1638 integrations = relationship('Integration',
1638 integrations = relationship('Integration',
1639 cascade="all, delete, delete-orphan")
1639 cascade="all, delete, delete-orphan")
1640
1640
1641 scoped_tokens = relationship('UserApiKeys', cascade="all")
1641 scoped_tokens = relationship('UserApiKeys', cascade="all")
1642
1642
1643 def __unicode__(self):
1643 def __unicode__(self):
1644 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1644 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1645 safe_unicode(self.repo_name))
1645 safe_unicode(self.repo_name))
1646
1646
1647 @hybrid_property
1647 @hybrid_property
1648 def description_safe(self):
1648 def description_safe(self):
1649 from rhodecode.lib import helpers as h
1649 from rhodecode.lib import helpers as h
1650 return h.escape(self.description)
1650 return h.escape(self.description)
1651
1651
1652 @hybrid_property
1652 @hybrid_property
1653 def landing_rev(self):
1653 def landing_rev(self):
1654 # always should return [rev_type, rev]
1654 # always should return [rev_type, rev]
1655 if self._landing_revision:
1655 if self._landing_revision:
1656 _rev_info = self._landing_revision.split(':')
1656 _rev_info = self._landing_revision.split(':')
1657 if len(_rev_info) < 2:
1657 if len(_rev_info) < 2:
1658 _rev_info.insert(0, 'rev')
1658 _rev_info.insert(0, 'rev')
1659 return [_rev_info[0], _rev_info[1]]
1659 return [_rev_info[0], _rev_info[1]]
1660 return [None, None]
1660 return [None, None]
1661
1661
1662 @landing_rev.setter
1662 @landing_rev.setter
1663 def landing_rev(self, val):
1663 def landing_rev(self, val):
1664 if ':' not in val:
1664 if ':' not in val:
1665 raise ValueError('value must be delimited with `:` and consist '
1665 raise ValueError('value must be delimited with `:` and consist '
1666 'of <rev_type>:<rev>, got %s instead' % val)
1666 'of <rev_type>:<rev>, got %s instead' % val)
1667 self._landing_revision = val
1667 self._landing_revision = val
1668
1668
1669 @hybrid_property
1669 @hybrid_property
1670 def locked(self):
1670 def locked(self):
1671 if self._locked:
1671 if self._locked:
1672 user_id, timelocked, reason = self._locked.split(':')
1672 user_id, timelocked, reason = self._locked.split(':')
1673 lock_values = int(user_id), timelocked, reason
1673 lock_values = int(user_id), timelocked, reason
1674 else:
1674 else:
1675 lock_values = [None, None, None]
1675 lock_values = [None, None, None]
1676 return lock_values
1676 return lock_values
1677
1677
1678 @locked.setter
1678 @locked.setter
1679 def locked(self, val):
1679 def locked(self, val):
1680 if val and isinstance(val, (list, tuple)):
1680 if val and isinstance(val, (list, tuple)):
1681 self._locked = ':'.join(map(str, val))
1681 self._locked = ':'.join(map(str, val))
1682 else:
1682 else:
1683 self._locked = None
1683 self._locked = None
1684
1684
1685 @hybrid_property
1685 @hybrid_property
1686 def changeset_cache(self):
1686 def changeset_cache(self):
1687 from rhodecode.lib.vcs.backends.base import EmptyCommit
1687 from rhodecode.lib.vcs.backends.base import EmptyCommit
1688 dummy = EmptyCommit().__json__()
1688 dummy = EmptyCommit().__json__()
1689 if not self._changeset_cache:
1689 if not self._changeset_cache:
1690 return dummy
1690 return dummy
1691 try:
1691 try:
1692 return json.loads(self._changeset_cache)
1692 return json.loads(self._changeset_cache)
1693 except TypeError:
1693 except TypeError:
1694 return dummy
1694 return dummy
1695 except Exception:
1695 except Exception:
1696 log.error(traceback.format_exc())
1696 log.error(traceback.format_exc())
1697 return dummy
1697 return dummy
1698
1698
1699 @changeset_cache.setter
1699 @changeset_cache.setter
1700 def changeset_cache(self, val):
1700 def changeset_cache(self, val):
1701 try:
1701 try:
1702 self._changeset_cache = json.dumps(val)
1702 self._changeset_cache = json.dumps(val)
1703 except Exception:
1703 except Exception:
1704 log.error(traceback.format_exc())
1704 log.error(traceback.format_exc())
1705
1705
1706 @hybrid_property
1706 @hybrid_property
1707 def repo_name(self):
1707 def repo_name(self):
1708 return self._repo_name
1708 return self._repo_name
1709
1709
1710 @repo_name.setter
1710 @repo_name.setter
1711 def repo_name(self, value):
1711 def repo_name(self, value):
1712 self._repo_name = value
1712 self._repo_name = value
1713 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1713 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1714
1714
1715 @classmethod
1715 @classmethod
1716 def normalize_repo_name(cls, repo_name):
1716 def normalize_repo_name(cls, repo_name):
1717 """
1717 """
1718 Normalizes os specific repo_name to the format internally stored inside
1718 Normalizes os specific repo_name to the format internally stored inside
1719 database using URL_SEP
1719 database using URL_SEP
1720
1720
1721 :param cls:
1721 :param cls:
1722 :param repo_name:
1722 :param repo_name:
1723 """
1723 """
1724 return cls.NAME_SEP.join(repo_name.split(os.sep))
1724 return cls.NAME_SEP.join(repo_name.split(os.sep))
1725
1725
1726 @classmethod
1726 @classmethod
1727 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1727 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1728 session = Session()
1728 session = Session()
1729 q = session.query(cls).filter(cls.repo_name == repo_name)
1729 q = session.query(cls).filter(cls.repo_name == repo_name)
1730
1730
1731 if cache:
1731 if cache:
1732 if identity_cache:
1732 if identity_cache:
1733 val = cls.identity_cache(session, 'repo_name', repo_name)
1733 val = cls.identity_cache(session, 'repo_name', repo_name)
1734 if val:
1734 if val:
1735 return val
1735 return val
1736 else:
1736 else:
1737 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
1737 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
1738 q = q.options(
1738 q = q.options(
1739 FromCache("sql_cache_short", cache_key))
1739 FromCache("sql_cache_short", cache_key))
1740
1740
1741 return q.scalar()
1741 return q.scalar()
1742
1742
1743 @classmethod
1743 @classmethod
1744 def get_by_id_or_repo_name(cls, repoid):
1744 def get_by_id_or_repo_name(cls, repoid):
1745 if isinstance(repoid, (int, long)):
1745 if isinstance(repoid, (int, long)):
1746 try:
1746 try:
1747 repo = cls.get(repoid)
1747 repo = cls.get(repoid)
1748 except ValueError:
1748 except ValueError:
1749 repo = None
1749 repo = None
1750 else:
1750 else:
1751 repo = cls.get_by_repo_name(repoid)
1751 repo = cls.get_by_repo_name(repoid)
1752 return repo
1752 return repo
1753
1753
1754 @classmethod
1754 @classmethod
1755 def get_by_full_path(cls, repo_full_path):
1755 def get_by_full_path(cls, repo_full_path):
1756 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1756 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1757 repo_name = cls.normalize_repo_name(repo_name)
1757 repo_name = cls.normalize_repo_name(repo_name)
1758 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1758 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1759
1759
1760 @classmethod
1760 @classmethod
1761 def get_repo_forks(cls, repo_id):
1761 def get_repo_forks(cls, repo_id):
1762 return cls.query().filter(Repository.fork_id == repo_id)
1762 return cls.query().filter(Repository.fork_id == repo_id)
1763
1763
1764 @classmethod
1764 @classmethod
1765 def base_path(cls):
1765 def base_path(cls):
1766 """
1766 """
1767 Returns base path when all repos are stored
1767 Returns base path when all repos are stored
1768
1768
1769 :param cls:
1769 :param cls:
1770 """
1770 """
1771 q = Session().query(RhodeCodeUi)\
1771 q = Session().query(RhodeCodeUi)\
1772 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1772 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1773 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1773 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1774 return q.one().ui_value
1774 return q.one().ui_value
1775
1775
1776 @classmethod
1776 @classmethod
1777 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1777 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1778 case_insensitive=True):
1778 case_insensitive=True):
1779 q = Repository.query()
1779 q = Repository.query()
1780
1780
1781 if not isinstance(user_id, Optional):
1781 if not isinstance(user_id, Optional):
1782 q = q.filter(Repository.user_id == user_id)
1782 q = q.filter(Repository.user_id == user_id)
1783
1783
1784 if not isinstance(group_id, Optional):
1784 if not isinstance(group_id, Optional):
1785 q = q.filter(Repository.group_id == group_id)
1785 q = q.filter(Repository.group_id == group_id)
1786
1786
1787 if case_insensitive:
1787 if case_insensitive:
1788 q = q.order_by(func.lower(Repository.repo_name))
1788 q = q.order_by(func.lower(Repository.repo_name))
1789 else:
1789 else:
1790 q = q.order_by(Repository.repo_name)
1790 q = q.order_by(Repository.repo_name)
1791 return q.all()
1791 return q.all()
1792
1792
1793 @property
1793 @property
1794 def forks(self):
1794 def forks(self):
1795 """
1795 """
1796 Return forks of this repo
1796 Return forks of this repo
1797 """
1797 """
1798 return Repository.get_repo_forks(self.repo_id)
1798 return Repository.get_repo_forks(self.repo_id)
1799
1799
1800 @property
1800 @property
1801 def parent(self):
1801 def parent(self):
1802 """
1802 """
1803 Returns fork parent
1803 Returns fork parent
1804 """
1804 """
1805 return self.fork
1805 return self.fork
1806
1806
1807 @property
1807 @property
1808 def just_name(self):
1808 def just_name(self):
1809 return self.repo_name.split(self.NAME_SEP)[-1]
1809 return self.repo_name.split(self.NAME_SEP)[-1]
1810
1810
1811 @property
1811 @property
1812 def groups_with_parents(self):
1812 def groups_with_parents(self):
1813 groups = []
1813 groups = []
1814 if self.group is None:
1814 if self.group is None:
1815 return groups
1815 return groups
1816
1816
1817 cur_gr = self.group
1817 cur_gr = self.group
1818 groups.insert(0, cur_gr)
1818 groups.insert(0, cur_gr)
1819 while 1:
1819 while 1:
1820 gr = getattr(cur_gr, 'parent_group', None)
1820 gr = getattr(cur_gr, 'parent_group', None)
1821 cur_gr = cur_gr.parent_group
1821 cur_gr = cur_gr.parent_group
1822 if gr is None:
1822 if gr is None:
1823 break
1823 break
1824 groups.insert(0, gr)
1824 groups.insert(0, gr)
1825
1825
1826 return groups
1826 return groups
1827
1827
1828 @property
1828 @property
1829 def groups_and_repo(self):
1829 def groups_and_repo(self):
1830 return self.groups_with_parents, self
1830 return self.groups_with_parents, self
1831
1831
1832 @LazyProperty
1832 @LazyProperty
1833 def repo_path(self):
1833 def repo_path(self):
1834 """
1834 """
1835 Returns base full path for that repository means where it actually
1835 Returns base full path for that repository means where it actually
1836 exists on a filesystem
1836 exists on a filesystem
1837 """
1837 """
1838 q = Session().query(RhodeCodeUi).filter(
1838 q = Session().query(RhodeCodeUi).filter(
1839 RhodeCodeUi.ui_key == self.NAME_SEP)
1839 RhodeCodeUi.ui_key == self.NAME_SEP)
1840 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1840 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1841 return q.one().ui_value
1841 return q.one().ui_value
1842
1842
1843 @property
1843 @property
1844 def repo_full_path(self):
1844 def repo_full_path(self):
1845 p = [self.repo_path]
1845 p = [self.repo_path]
1846 # we need to split the name by / since this is how we store the
1846 # we need to split the name by / since this is how we store the
1847 # names in the database, but that eventually needs to be converted
1847 # names in the database, but that eventually needs to be converted
1848 # into a valid system path
1848 # into a valid system path
1849 p += self.repo_name.split(self.NAME_SEP)
1849 p += self.repo_name.split(self.NAME_SEP)
1850 return os.path.join(*map(safe_unicode, p))
1850 return os.path.join(*map(safe_unicode, p))
1851
1851
1852 @property
1852 @property
1853 def cache_keys(self):
1853 def cache_keys(self):
1854 """
1854 """
1855 Returns associated cache keys for that repo
1855 Returns associated cache keys for that repo
1856 """
1856 """
1857 return CacheKey.query()\
1857 return CacheKey.query()\
1858 .filter(CacheKey.cache_args == self.repo_name)\
1858 .filter(CacheKey.cache_args == self.repo_name)\
1859 .order_by(CacheKey.cache_key)\
1859 .order_by(CacheKey.cache_key)\
1860 .all()
1860 .all()
1861
1861
1862 @property
1862 @property
1863 def cached_diffs_relative_dir(self):
1863 def cached_diffs_relative_dir(self):
1864 """
1864 """
1865 Return a relative to the repository store path of cached diffs
1865 Return a relative to the repository store path of cached diffs
1866 used for safe display for users, who shouldn't know the absolute store
1866 used for safe display for users, who shouldn't know the absolute store
1867 path
1867 path
1868 """
1868 """
1869 return os.path.join(
1869 return os.path.join(
1870 os.path.dirname(self.repo_name),
1870 os.path.dirname(self.repo_name),
1871 self.cached_diffs_dir.split(os.path.sep)[-1])
1871 self.cached_diffs_dir.split(os.path.sep)[-1])
1872
1872
1873 @property
1873 @property
1874 def cached_diffs_dir(self):
1874 def cached_diffs_dir(self):
1875 path = self.repo_full_path
1875 path = self.repo_full_path
1876 return os.path.join(
1876 return os.path.join(
1877 os.path.dirname(path),
1877 os.path.dirname(path),
1878 '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
1878 '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
1879
1879
1880 def cached_diffs(self):
1880 def cached_diffs(self):
1881 diff_cache_dir = self.cached_diffs_dir
1881 diff_cache_dir = self.cached_diffs_dir
1882 if os.path.isdir(diff_cache_dir):
1882 if os.path.isdir(diff_cache_dir):
1883 return os.listdir(diff_cache_dir)
1883 return os.listdir(diff_cache_dir)
1884 return []
1884 return []
1885
1885
1886 def get_new_name(self, repo_name):
1886 def get_new_name(self, repo_name):
1887 """
1887 """
1888 returns new full repository name based on assigned group and new new
1888 returns new full repository name based on assigned group and new new
1889
1889
1890 :param group_name:
1890 :param group_name:
1891 """
1891 """
1892 path_prefix = self.group.full_path_splitted if self.group else []
1892 path_prefix = self.group.full_path_splitted if self.group else []
1893 return self.NAME_SEP.join(path_prefix + [repo_name])
1893 return self.NAME_SEP.join(path_prefix + [repo_name])
1894
1894
1895 @property
1895 @property
1896 def _config(self):
1896 def _config(self):
1897 """
1897 """
1898 Returns db based config object.
1898 Returns db based config object.
1899 """
1899 """
1900 from rhodecode.lib.utils import make_db_config
1900 from rhodecode.lib.utils import make_db_config
1901 return make_db_config(clear_session=False, repo=self)
1901 return make_db_config(clear_session=False, repo=self)
1902
1902
1903 def permissions(self, with_admins=True, with_owner=True):
1903 def permissions(self, with_admins=True, with_owner=True):
1904 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1904 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1905 q = q.options(joinedload(UserRepoToPerm.repository),
1905 q = q.options(joinedload(UserRepoToPerm.repository),
1906 joinedload(UserRepoToPerm.user),
1906 joinedload(UserRepoToPerm.user),
1907 joinedload(UserRepoToPerm.permission),)
1907 joinedload(UserRepoToPerm.permission),)
1908
1908
1909 # get owners and admins and permissions. We do a trick of re-writing
1909 # get owners and admins and permissions. We do a trick of re-writing
1910 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1910 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1911 # has a global reference and changing one object propagates to all
1911 # has a global reference and changing one object propagates to all
1912 # others. This means if admin is also an owner admin_row that change
1912 # others. This means if admin is also an owner admin_row that change
1913 # would propagate to both objects
1913 # would propagate to both objects
1914 perm_rows = []
1914 perm_rows = []
1915 for _usr in q.all():
1915 for _usr in q.all():
1916 usr = AttributeDict(_usr.user.get_dict())
1916 usr = AttributeDict(_usr.user.get_dict())
1917 usr.permission = _usr.permission.permission_name
1917 usr.permission = _usr.permission.permission_name
1918 perm_rows.append(usr)
1918 perm_rows.append(usr)
1919
1919
1920 # filter the perm rows by 'default' first and then sort them by
1920 # filter the perm rows by 'default' first and then sort them by
1921 # admin,write,read,none permissions sorted again alphabetically in
1921 # admin,write,read,none permissions sorted again alphabetically in
1922 # each group
1922 # each group
1923 perm_rows = sorted(perm_rows, key=display_user_sort)
1923 perm_rows = sorted(perm_rows, key=display_user_sort)
1924
1924
1925 _admin_perm = 'repository.admin'
1925 _admin_perm = 'repository.admin'
1926 owner_row = []
1926 owner_row = []
1927 if with_owner:
1927 if with_owner:
1928 usr = AttributeDict(self.user.get_dict())
1928 usr = AttributeDict(self.user.get_dict())
1929 usr.owner_row = True
1929 usr.owner_row = True
1930 usr.permission = _admin_perm
1930 usr.permission = _admin_perm
1931 owner_row.append(usr)
1931 owner_row.append(usr)
1932
1932
1933 super_admin_rows = []
1933 super_admin_rows = []
1934 if with_admins:
1934 if with_admins:
1935 for usr in User.get_all_super_admins():
1935 for usr in User.get_all_super_admins():
1936 # if this admin is also owner, don't double the record
1936 # if this admin is also owner, don't double the record
1937 if usr.user_id == owner_row[0].user_id:
1937 if usr.user_id == owner_row[0].user_id:
1938 owner_row[0].admin_row = True
1938 owner_row[0].admin_row = True
1939 else:
1939 else:
1940 usr = AttributeDict(usr.get_dict())
1940 usr = AttributeDict(usr.get_dict())
1941 usr.admin_row = True
1941 usr.admin_row = True
1942 usr.permission = _admin_perm
1942 usr.permission = _admin_perm
1943 super_admin_rows.append(usr)
1943 super_admin_rows.append(usr)
1944
1944
1945 return super_admin_rows + owner_row + perm_rows
1945 return super_admin_rows + owner_row + perm_rows
1946
1946
1947 def permission_user_groups(self):
1947 def permission_user_groups(self):
1948 q = UserGroupRepoToPerm.query().filter(
1948 q = UserGroupRepoToPerm.query().filter(
1949 UserGroupRepoToPerm.repository == self)
1949 UserGroupRepoToPerm.repository == self)
1950 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1950 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1951 joinedload(UserGroupRepoToPerm.users_group),
1951 joinedload(UserGroupRepoToPerm.users_group),
1952 joinedload(UserGroupRepoToPerm.permission),)
1952 joinedload(UserGroupRepoToPerm.permission),)
1953
1953
1954 perm_rows = []
1954 perm_rows = []
1955 for _user_group in q.all():
1955 for _user_group in q.all():
1956 usr = AttributeDict(_user_group.users_group.get_dict())
1956 usr = AttributeDict(_user_group.users_group.get_dict())
1957 usr.permission = _user_group.permission.permission_name
1957 usr.permission = _user_group.permission.permission_name
1958 perm_rows.append(usr)
1958 perm_rows.append(usr)
1959
1959
1960 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1960 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1961 return perm_rows
1961 return perm_rows
1962
1962
1963 def get_api_data(self, include_secrets=False):
1963 def get_api_data(self, include_secrets=False):
1964 """
1964 """
1965 Common function for generating repo api data
1965 Common function for generating repo api data
1966
1966
1967 :param include_secrets: See :meth:`User.get_api_data`.
1967 :param include_secrets: See :meth:`User.get_api_data`.
1968
1968
1969 """
1969 """
1970 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1970 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1971 # move this methods on models level.
1971 # move this methods on models level.
1972 from rhodecode.model.settings import SettingsModel
1972 from rhodecode.model.settings import SettingsModel
1973 from rhodecode.model.repo import RepoModel
1973 from rhodecode.model.repo import RepoModel
1974
1974
1975 repo = self
1975 repo = self
1976 _user_id, _time, _reason = self.locked
1976 _user_id, _time, _reason = self.locked
1977
1977
1978 data = {
1978 data = {
1979 'repo_id': repo.repo_id,
1979 'repo_id': repo.repo_id,
1980 'repo_name': repo.repo_name,
1980 'repo_name': repo.repo_name,
1981 'repo_type': repo.repo_type,
1981 'repo_type': repo.repo_type,
1982 'clone_uri': repo.clone_uri or '',
1982 'clone_uri': repo.clone_uri or '',
1983 'push_uri': repo.push_uri or '',
1983 'push_uri': repo.push_uri or '',
1984 'url': RepoModel().get_url(self),
1984 'url': RepoModel().get_url(self),
1985 'private': repo.private,
1985 'private': repo.private,
1986 'created_on': repo.created_on,
1986 'created_on': repo.created_on,
1987 'description': repo.description_safe,
1987 'description': repo.description_safe,
1988 'landing_rev': repo.landing_rev,
1988 'landing_rev': repo.landing_rev,
1989 'owner': repo.user.username,
1989 'owner': repo.user.username,
1990 'fork_of': repo.fork.repo_name if repo.fork else None,
1990 'fork_of': repo.fork.repo_name if repo.fork else None,
1991 'fork_of_id': repo.fork.repo_id if repo.fork else None,
1991 'fork_of_id': repo.fork.repo_id if repo.fork else None,
1992 'enable_statistics': repo.enable_statistics,
1992 'enable_statistics': repo.enable_statistics,
1993 'enable_locking': repo.enable_locking,
1993 'enable_locking': repo.enable_locking,
1994 'enable_downloads': repo.enable_downloads,
1994 'enable_downloads': repo.enable_downloads,
1995 'last_changeset': repo.changeset_cache,
1995 'last_changeset': repo.changeset_cache,
1996 'locked_by': User.get(_user_id).get_api_data(
1996 'locked_by': User.get(_user_id).get_api_data(
1997 include_secrets=include_secrets) if _user_id else None,
1997 include_secrets=include_secrets) if _user_id else None,
1998 'locked_date': time_to_datetime(_time) if _time else None,
1998 'locked_date': time_to_datetime(_time) if _time else None,
1999 'lock_reason': _reason if _reason else None,
1999 'lock_reason': _reason if _reason else None,
2000 }
2000 }
2001
2001
2002 # TODO: mikhail: should be per-repo settings here
2002 # TODO: mikhail: should be per-repo settings here
2003 rc_config = SettingsModel().get_all_settings()
2003 rc_config = SettingsModel().get_all_settings()
2004 repository_fields = str2bool(
2004 repository_fields = str2bool(
2005 rc_config.get('rhodecode_repository_fields'))
2005 rc_config.get('rhodecode_repository_fields'))
2006 if repository_fields:
2006 if repository_fields:
2007 for f in self.extra_fields:
2007 for f in self.extra_fields:
2008 data[f.field_key_prefixed] = f.field_value
2008 data[f.field_key_prefixed] = f.field_value
2009
2009
2010 return data
2010 return data
2011
2011
2012 @classmethod
2012 @classmethod
2013 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
2013 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
2014 if not lock_time:
2014 if not lock_time:
2015 lock_time = time.time()
2015 lock_time = time.time()
2016 if not lock_reason:
2016 if not lock_reason:
2017 lock_reason = cls.LOCK_AUTOMATIC
2017 lock_reason = cls.LOCK_AUTOMATIC
2018 repo.locked = [user_id, lock_time, lock_reason]
2018 repo.locked = [user_id, lock_time, lock_reason]
2019 Session().add(repo)
2019 Session().add(repo)
2020 Session().commit()
2020 Session().commit()
2021
2021
2022 @classmethod
2022 @classmethod
2023 def unlock(cls, repo):
2023 def unlock(cls, repo):
2024 repo.locked = None
2024 repo.locked = None
2025 Session().add(repo)
2025 Session().add(repo)
2026 Session().commit()
2026 Session().commit()
2027
2027
2028 @classmethod
2028 @classmethod
2029 def getlock(cls, repo):
2029 def getlock(cls, repo):
2030 return repo.locked
2030 return repo.locked
2031
2031
2032 def is_user_lock(self, user_id):
2032 def is_user_lock(self, user_id):
2033 if self.lock[0]:
2033 if self.lock[0]:
2034 lock_user_id = safe_int(self.lock[0])
2034 lock_user_id = safe_int(self.lock[0])
2035 user_id = safe_int(user_id)
2035 user_id = safe_int(user_id)
2036 # both are ints, and they are equal
2036 # both are ints, and they are equal
2037 return all([lock_user_id, user_id]) and lock_user_id == user_id
2037 return all([lock_user_id, user_id]) and lock_user_id == user_id
2038
2038
2039 return False
2039 return False
2040
2040
2041 def get_locking_state(self, action, user_id, only_when_enabled=True):
2041 def get_locking_state(self, action, user_id, only_when_enabled=True):
2042 """
2042 """
2043 Checks locking on this repository, if locking is enabled and lock is
2043 Checks locking on this repository, if locking is enabled and lock is
2044 present returns a tuple of make_lock, locked, locked_by.
2044 present returns a tuple of make_lock, locked, locked_by.
2045 make_lock can have 3 states None (do nothing) True, make lock
2045 make_lock can have 3 states None (do nothing) True, make lock
2046 False release lock, This value is later propagated to hooks, which
2046 False release lock, This value is later propagated to hooks, which
2047 do the locking. Think about this as signals passed to hooks what to do.
2047 do the locking. Think about this as signals passed to hooks what to do.
2048
2048
2049 """
2049 """
2050 # TODO: johbo: This is part of the business logic and should be moved
2050 # TODO: johbo: This is part of the business logic and should be moved
2051 # into the RepositoryModel.
2051 # into the RepositoryModel.
2052
2052
2053 if action not in ('push', 'pull'):
2053 if action not in ('push', 'pull'):
2054 raise ValueError("Invalid action value: %s" % repr(action))
2054 raise ValueError("Invalid action value: %s" % repr(action))
2055
2055
2056 # defines if locked error should be thrown to user
2056 # defines if locked error should be thrown to user
2057 currently_locked = False
2057 currently_locked = False
2058 # defines if new lock should be made, tri-state
2058 # defines if new lock should be made, tri-state
2059 make_lock = None
2059 make_lock = None
2060 repo = self
2060 repo = self
2061 user = User.get(user_id)
2061 user = User.get(user_id)
2062
2062
2063 lock_info = repo.locked
2063 lock_info = repo.locked
2064
2064
2065 if repo and (repo.enable_locking or not only_when_enabled):
2065 if repo and (repo.enable_locking or not only_when_enabled):
2066 if action == 'push':
2066 if action == 'push':
2067 # check if it's already locked !, if it is compare users
2067 # check if it's already locked !, if it is compare users
2068 locked_by_user_id = lock_info[0]
2068 locked_by_user_id = lock_info[0]
2069 if user.user_id == locked_by_user_id:
2069 if user.user_id == locked_by_user_id:
2070 log.debug(
2070 log.debug(
2071 'Got `push` action from user %s, now unlocking', user)
2071 'Got `push` action from user %s, now unlocking', user)
2072 # unlock if we have push from user who locked
2072 # unlock if we have push from user who locked
2073 make_lock = False
2073 make_lock = False
2074 else:
2074 else:
2075 # we're not the same user who locked, ban with
2075 # we're not the same user who locked, ban with
2076 # code defined in settings (default is 423 HTTP Locked) !
2076 # code defined in settings (default is 423 HTTP Locked) !
2077 log.debug('Repo %s is currently locked by %s', repo, user)
2077 log.debug('Repo %s is currently locked by %s', repo, user)
2078 currently_locked = True
2078 currently_locked = True
2079 elif action == 'pull':
2079 elif action == 'pull':
2080 # [0] user [1] date
2080 # [0] user [1] date
2081 if lock_info[0] and lock_info[1]:
2081 if lock_info[0] and lock_info[1]:
2082 log.debug('Repo %s is currently locked by %s', repo, user)
2082 log.debug('Repo %s is currently locked by %s', repo, user)
2083 currently_locked = True
2083 currently_locked = True
2084 else:
2084 else:
2085 log.debug('Setting lock on repo %s by %s', repo, user)
2085 log.debug('Setting lock on repo %s by %s', repo, user)
2086 make_lock = True
2086 make_lock = True
2087
2087
2088 else:
2088 else:
2089 log.debug('Repository %s do not have locking enabled', repo)
2089 log.debug('Repository %s do not have locking enabled', repo)
2090
2090
2091 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
2091 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
2092 make_lock, currently_locked, lock_info)
2092 make_lock, currently_locked, lock_info)
2093
2093
2094 from rhodecode.lib.auth import HasRepoPermissionAny
2094 from rhodecode.lib.auth import HasRepoPermissionAny
2095 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
2095 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
2096 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
2096 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
2097 # if we don't have at least write permission we cannot make a lock
2097 # if we don't have at least write permission we cannot make a lock
2098 log.debug('lock state reset back to FALSE due to lack '
2098 log.debug('lock state reset back to FALSE due to lack '
2099 'of at least read permission')
2099 'of at least read permission')
2100 make_lock = False
2100 make_lock = False
2101
2101
2102 return make_lock, currently_locked, lock_info
2102 return make_lock, currently_locked, lock_info
2103
2103
2104 @property
2104 @property
2105 def last_db_change(self):
2105 def last_db_change(self):
2106 return self.updated_on
2106 return self.updated_on
2107
2107
2108 @property
2108 @property
2109 def clone_uri_hidden(self):
2109 def clone_uri_hidden(self):
2110 clone_uri = self.clone_uri
2110 clone_uri = self.clone_uri
2111 if clone_uri:
2111 if clone_uri:
2112 import urlobject
2112 import urlobject
2113 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
2113 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
2114 if url_obj.password:
2114 if url_obj.password:
2115 clone_uri = url_obj.with_password('*****')
2115 clone_uri = url_obj.with_password('*****')
2116 return clone_uri
2116 return clone_uri
2117
2117
2118 @property
2118 @property
2119 def push_uri_hidden(self):
2119 def push_uri_hidden(self):
2120 push_uri = self.push_uri
2120 push_uri = self.push_uri
2121 if push_uri:
2121 if push_uri:
2122 import urlobject
2122 import urlobject
2123 url_obj = urlobject.URLObject(cleaned_uri(push_uri))
2123 url_obj = urlobject.URLObject(cleaned_uri(push_uri))
2124 if url_obj.password:
2124 if url_obj.password:
2125 push_uri = url_obj.with_password('*****')
2125 push_uri = url_obj.with_password('*****')
2126 return push_uri
2126 return push_uri
2127
2127
2128 def clone_url(self, **override):
2128 def clone_url(self, **override):
2129 from rhodecode.model.settings import SettingsModel
2129 from rhodecode.model.settings import SettingsModel
2130
2130
2131 uri_tmpl = None
2131 uri_tmpl = None
2132 if 'with_id' in override:
2132 if 'with_id' in override:
2133 uri_tmpl = self.DEFAULT_CLONE_URI_ID
2133 uri_tmpl = self.DEFAULT_CLONE_URI_ID
2134 del override['with_id']
2134 del override['with_id']
2135
2135
2136 if 'uri_tmpl' in override:
2136 if 'uri_tmpl' in override:
2137 uri_tmpl = override['uri_tmpl']
2137 uri_tmpl = override['uri_tmpl']
2138 del override['uri_tmpl']
2138 del override['uri_tmpl']
2139
2139
2140 ssh = False
2140 ssh = False
2141 if 'ssh' in override:
2141 if 'ssh' in override:
2142 ssh = True
2142 ssh = True
2143 del override['ssh']
2143 del override['ssh']
2144
2144
2145 # we didn't override our tmpl from **overrides
2145 # we didn't override our tmpl from **overrides
2146 if not uri_tmpl:
2146 if not uri_tmpl:
2147 rc_config = SettingsModel().get_all_settings(cache=True)
2147 rc_config = SettingsModel().get_all_settings(cache=True)
2148 if ssh:
2148 if ssh:
2149 uri_tmpl = rc_config.get(
2149 uri_tmpl = rc_config.get(
2150 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
2150 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
2151 else:
2151 else:
2152 uri_tmpl = rc_config.get(
2152 uri_tmpl = rc_config.get(
2153 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
2153 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
2154
2154
2155 request = get_current_request()
2155 request = get_current_request()
2156 return get_clone_url(request=request,
2156 return get_clone_url(request=request,
2157 uri_tmpl=uri_tmpl,
2157 uri_tmpl=uri_tmpl,
2158 repo_name=self.repo_name,
2158 repo_name=self.repo_name,
2159 repo_id=self.repo_id, **override)
2159 repo_id=self.repo_id, **override)
2160
2160
2161 def set_state(self, state):
2161 def set_state(self, state):
2162 self.repo_state = state
2162 self.repo_state = state
2163 Session().add(self)
2163 Session().add(self)
2164 #==========================================================================
2164 #==========================================================================
2165 # SCM PROPERTIES
2165 # SCM PROPERTIES
2166 #==========================================================================
2166 #==========================================================================
2167
2167
2168 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
2168 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
2169 return get_commit_safe(
2169 return get_commit_safe(
2170 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
2170 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
2171
2171
2172 def get_changeset(self, rev=None, pre_load=None):
2172 def get_changeset(self, rev=None, pre_load=None):
2173 warnings.warn("Use get_commit", DeprecationWarning)
2173 warnings.warn("Use get_commit", DeprecationWarning)
2174 commit_id = None
2174 commit_id = None
2175 commit_idx = None
2175 commit_idx = None
2176 if isinstance(rev, basestring):
2176 if isinstance(rev, basestring):
2177 commit_id = rev
2177 commit_id = rev
2178 else:
2178 else:
2179 commit_idx = rev
2179 commit_idx = rev
2180 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
2180 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
2181 pre_load=pre_load)
2181 pre_load=pre_load)
2182
2182
2183 def get_landing_commit(self):
2183 def get_landing_commit(self):
2184 """
2184 """
2185 Returns landing commit, or if that doesn't exist returns the tip
2185 Returns landing commit, or if that doesn't exist returns the tip
2186 """
2186 """
2187 _rev_type, _rev = self.landing_rev
2187 _rev_type, _rev = self.landing_rev
2188 commit = self.get_commit(_rev)
2188 commit = self.get_commit(_rev)
2189 if isinstance(commit, EmptyCommit):
2189 if isinstance(commit, EmptyCommit):
2190 return self.get_commit()
2190 return self.get_commit()
2191 return commit
2191 return commit
2192
2192
2193 def update_commit_cache(self, cs_cache=None, config=None):
2193 def update_commit_cache(self, cs_cache=None, config=None):
2194 """
2194 """
2195 Update cache of last changeset for repository, keys should be::
2195 Update cache of last changeset for repository, keys should be::
2196
2196
2197 short_id
2197 short_id
2198 raw_id
2198 raw_id
2199 revision
2199 revision
2200 parents
2200 parents
2201 message
2201 message
2202 date
2202 date
2203 author
2203 author
2204
2204
2205 :param cs_cache:
2205 :param cs_cache:
2206 """
2206 """
2207 from rhodecode.lib.vcs.backends.base import BaseChangeset
2207 from rhodecode.lib.vcs.backends.base import BaseChangeset
2208 if cs_cache is None:
2208 if cs_cache is None:
2209 # use no-cache version here
2209 # use no-cache version here
2210 scm_repo = self.scm_instance(cache=False, config=config)
2210 scm_repo = self.scm_instance(cache=False, config=config)
2211 if scm_repo:
2211 if scm_repo:
2212 cs_cache = scm_repo.get_commit(
2212 cs_cache = scm_repo.get_commit(
2213 pre_load=["author", "date", "message", "parents"])
2213 pre_load=["author", "date", "message", "parents"])
2214 else:
2214 else:
2215 cs_cache = EmptyCommit()
2215 cs_cache = EmptyCommit()
2216
2216
2217 if isinstance(cs_cache, BaseChangeset):
2217 if isinstance(cs_cache, BaseChangeset):
2218 cs_cache = cs_cache.__json__()
2218 cs_cache = cs_cache.__json__()
2219
2219
2220 def is_outdated(new_cs_cache):
2220 def is_outdated(new_cs_cache):
2221 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
2221 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
2222 new_cs_cache['revision'] != self.changeset_cache['revision']):
2222 new_cs_cache['revision'] != self.changeset_cache['revision']):
2223 return True
2223 return True
2224 return False
2224 return False
2225
2225
2226 # check if we have maybe already latest cached revision
2226 # check if we have maybe already latest cached revision
2227 if is_outdated(cs_cache) or not self.changeset_cache:
2227 if is_outdated(cs_cache) or not self.changeset_cache:
2228 _default = datetime.datetime.fromtimestamp(0)
2228 _default = datetime.datetime.fromtimestamp(0)
2229 last_change = cs_cache.get('date') or _default
2229 last_change = cs_cache.get('date') or _default
2230 log.debug('updated repo %s with new cs cache %s',
2230 log.debug('updated repo %s with new cs cache %s',
2231 self.repo_name, cs_cache)
2231 self.repo_name, cs_cache)
2232 self.updated_on = last_change
2232 self.updated_on = last_change
2233 self.changeset_cache = cs_cache
2233 self.changeset_cache = cs_cache
2234 Session().add(self)
2234 Session().add(self)
2235 Session().commit()
2235 Session().commit()
2236 else:
2236 else:
2237 log.debug('Skipping update_commit_cache for repo:`%s` '
2237 log.debug('Skipping update_commit_cache for repo:`%s` '
2238 'commit already with latest changes', self.repo_name)
2238 'commit already with latest changes', self.repo_name)
2239
2239
2240 @property
2240 @property
2241 def tip(self):
2241 def tip(self):
2242 return self.get_commit('tip')
2242 return self.get_commit('tip')
2243
2243
2244 @property
2244 @property
2245 def author(self):
2245 def author(self):
2246 return self.tip.author
2246 return self.tip.author
2247
2247
2248 @property
2248 @property
2249 def last_change(self):
2249 def last_change(self):
2250 return self.scm_instance().last_change
2250 return self.scm_instance().last_change
2251
2251
2252 def get_comments(self, revisions=None):
2252 def get_comments(self, revisions=None):
2253 """
2253 """
2254 Returns comments for this repository grouped by revisions
2254 Returns comments for this repository grouped by revisions
2255
2255
2256 :param revisions: filter query by revisions only
2256 :param revisions: filter query by revisions only
2257 """
2257 """
2258 cmts = ChangesetComment.query()\
2258 cmts = ChangesetComment.query()\
2259 .filter(ChangesetComment.repo == self)
2259 .filter(ChangesetComment.repo == self)
2260 if revisions:
2260 if revisions:
2261 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2261 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2262 grouped = collections.defaultdict(list)
2262 grouped = collections.defaultdict(list)
2263 for cmt in cmts.all():
2263 for cmt in cmts.all():
2264 grouped[cmt.revision].append(cmt)
2264 grouped[cmt.revision].append(cmt)
2265 return grouped
2265 return grouped
2266
2266
2267 def statuses(self, revisions=None):
2267 def statuses(self, revisions=None):
2268 """
2268 """
2269 Returns statuses for this repository
2269 Returns statuses for this repository
2270
2270
2271 :param revisions: list of revisions to get statuses for
2271 :param revisions: list of revisions to get statuses for
2272 """
2272 """
2273 statuses = ChangesetStatus.query()\
2273 statuses = ChangesetStatus.query()\
2274 .filter(ChangesetStatus.repo == self)\
2274 .filter(ChangesetStatus.repo == self)\
2275 .filter(ChangesetStatus.version == 0)
2275 .filter(ChangesetStatus.version == 0)
2276
2276
2277 if revisions:
2277 if revisions:
2278 # Try doing the filtering in chunks to avoid hitting limits
2278 # Try doing the filtering in chunks to avoid hitting limits
2279 size = 500
2279 size = 500
2280 status_results = []
2280 status_results = []
2281 for chunk in xrange(0, len(revisions), size):
2281 for chunk in xrange(0, len(revisions), size):
2282 status_results += statuses.filter(
2282 status_results += statuses.filter(
2283 ChangesetStatus.revision.in_(
2283 ChangesetStatus.revision.in_(
2284 revisions[chunk: chunk+size])
2284 revisions[chunk: chunk+size])
2285 ).all()
2285 ).all()
2286 else:
2286 else:
2287 status_results = statuses.all()
2287 status_results = statuses.all()
2288
2288
2289 grouped = {}
2289 grouped = {}
2290
2290
2291 # maybe we have open new pullrequest without a status?
2291 # maybe we have open new pullrequest without a status?
2292 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2292 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2293 status_lbl = ChangesetStatus.get_status_lbl(stat)
2293 status_lbl = ChangesetStatus.get_status_lbl(stat)
2294 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2294 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2295 for rev in pr.revisions:
2295 for rev in pr.revisions:
2296 pr_id = pr.pull_request_id
2296 pr_id = pr.pull_request_id
2297 pr_repo = pr.target_repo.repo_name
2297 pr_repo = pr.target_repo.repo_name
2298 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2298 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2299
2299
2300 for stat in status_results:
2300 for stat in status_results:
2301 pr_id = pr_repo = None
2301 pr_id = pr_repo = None
2302 if stat.pull_request:
2302 if stat.pull_request:
2303 pr_id = stat.pull_request.pull_request_id
2303 pr_id = stat.pull_request.pull_request_id
2304 pr_repo = stat.pull_request.target_repo.repo_name
2304 pr_repo = stat.pull_request.target_repo.repo_name
2305 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2305 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2306 pr_id, pr_repo]
2306 pr_id, pr_repo]
2307 return grouped
2307 return grouped
2308
2308
2309 # ==========================================================================
2309 # ==========================================================================
2310 # SCM CACHE INSTANCE
2310 # SCM CACHE INSTANCE
2311 # ==========================================================================
2311 # ==========================================================================
2312
2312
2313 def scm_instance(self, **kwargs):
2313 def scm_instance(self, **kwargs):
2314 import rhodecode
2314 import rhodecode
2315
2315
2316 # Passing a config will not hit the cache currently only used
2316 # Passing a config will not hit the cache currently only used
2317 # for repo2dbmapper
2317 # for repo2dbmapper
2318 config = kwargs.pop('config', None)
2318 config = kwargs.pop('config', None)
2319 cache = kwargs.pop('cache', None)
2319 cache = kwargs.pop('cache', None)
2320 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2320 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2321 # if cache is NOT defined use default global, else we have a full
2321 # if cache is NOT defined use default global, else we have a full
2322 # control over cache behaviour
2322 # control over cache behaviour
2323 if cache is None and full_cache and not config:
2323 if cache is None and full_cache and not config:
2324 return self._get_instance_cached()
2324 return self._get_instance_cached()
2325 return self._get_instance(cache=bool(cache), config=config)
2325 return self._get_instance(cache=bool(cache), config=config)
2326
2326
2327 def _get_instance_cached(self):
2327 def _get_instance_cached(self):
2328 @cache_region('long_term')
2328 @cache_region('long_term')
2329 def _get_repo(cache_key):
2329 def _get_repo(cache_key):
2330 return self._get_instance()
2330 return self._get_instance()
2331
2331
2332 invalidator_context = CacheKey.repo_context_cache(
2332 invalidator_context = CacheKey.repo_context_cache(
2333 _get_repo, self.repo_name, None, thread_scoped=True)
2333 _get_repo, self.repo_name, None, thread_scoped=True)
2334
2334
2335 with invalidator_context as context:
2335 with invalidator_context as context:
2336 context.invalidate()
2336 context.invalidate()
2337 repo = context.compute()
2337 repo = context.compute()
2338
2338
2339 return repo
2339 return repo
2340
2340
2341 def _get_instance(self, cache=True, config=None):
2341 def _get_instance(self, cache=True, config=None):
2342 config = config or self._config
2342 config = config or self._config
2343 custom_wire = {
2343 custom_wire = {
2344 'cache': cache # controls the vcs.remote cache
2344 'cache': cache # controls the vcs.remote cache
2345 }
2345 }
2346 repo = get_vcs_instance(
2346 repo = get_vcs_instance(
2347 repo_path=safe_str(self.repo_full_path),
2347 repo_path=safe_str(self.repo_full_path),
2348 config=config,
2348 config=config,
2349 with_wire=custom_wire,
2349 with_wire=custom_wire,
2350 create=False,
2350 create=False,
2351 _vcs_alias=self.repo_type)
2351 _vcs_alias=self.repo_type)
2352
2352
2353 return repo
2353 return repo
2354
2354
2355 def __json__(self):
2355 def __json__(self):
2356 return {'landing_rev': self.landing_rev}
2356 return {'landing_rev': self.landing_rev}
2357
2357
2358 def get_dict(self):
2358 def get_dict(self):
2359
2359
2360 # Since we transformed `repo_name` to a hybrid property, we need to
2360 # Since we transformed `repo_name` to a hybrid property, we need to
2361 # keep compatibility with the code which uses `repo_name` field.
2361 # keep compatibility with the code which uses `repo_name` field.
2362
2362
2363 result = super(Repository, self).get_dict()
2363 result = super(Repository, self).get_dict()
2364 result['repo_name'] = result.pop('_repo_name', None)
2364 result['repo_name'] = result.pop('_repo_name', None)
2365 return result
2365 return result
2366
2366
2367
2367
2368 class RepoGroup(Base, BaseModel):
2368 class RepoGroup(Base, BaseModel):
2369 __tablename__ = 'groups'
2369 __tablename__ = 'groups'
2370 __table_args__ = (
2370 __table_args__ = (
2371 UniqueConstraint('group_name', 'group_parent_id'),
2371 UniqueConstraint('group_name', 'group_parent_id'),
2372 CheckConstraint('group_id != group_parent_id'),
2372 CheckConstraint('group_id != group_parent_id'),
2373 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2373 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2374 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2374 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2375 )
2375 )
2376 __mapper_args__ = {'order_by': 'group_name'}
2376 __mapper_args__ = {'order_by': 'group_name'}
2377
2377
2378 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2378 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2379
2379
2380 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2380 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2381 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2381 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2382 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2382 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2383 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2383 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2384 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2384 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2385 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2385 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2386 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2386 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2387 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2387 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2388 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2388 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2389
2389
2390 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2390 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2391 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2391 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2392 parent_group = relationship('RepoGroup', remote_side=group_id)
2392 parent_group = relationship('RepoGroup', remote_side=group_id)
2393 user = relationship('User')
2393 user = relationship('User')
2394 integrations = relationship('Integration',
2394 integrations = relationship('Integration',
2395 cascade="all, delete, delete-orphan")
2395 cascade="all, delete, delete-orphan")
2396
2396
2397 def __init__(self, group_name='', parent_group=None):
2397 def __init__(self, group_name='', parent_group=None):
2398 self.group_name = group_name
2398 self.group_name = group_name
2399 self.parent_group = parent_group
2399 self.parent_group = parent_group
2400
2400
2401 def __unicode__(self):
2401 def __unicode__(self):
2402 return u"<%s('id:%s:%s')>" % (
2402 return u"<%s('id:%s:%s')>" % (
2403 self.__class__.__name__, self.group_id, self.group_name)
2403 self.__class__.__name__, self.group_id, self.group_name)
2404
2404
2405 @hybrid_property
2405 @hybrid_property
2406 def description_safe(self):
2406 def description_safe(self):
2407 from rhodecode.lib import helpers as h
2407 from rhodecode.lib import helpers as h
2408 return h.escape(self.group_description)
2408 return h.escape(self.group_description)
2409
2409
2410 @classmethod
2410 @classmethod
2411 def _generate_choice(cls, repo_group):
2411 def _generate_choice(cls, repo_group):
2412 from webhelpers.html import literal as _literal
2412 from webhelpers.html import literal as _literal
2413 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2413 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2414 return repo_group.group_id, _name(repo_group.full_path_splitted)
2414 return repo_group.group_id, _name(repo_group.full_path_splitted)
2415
2415
2416 @classmethod
2416 @classmethod
2417 def groups_choices(cls, groups=None, show_empty_group=True):
2417 def groups_choices(cls, groups=None, show_empty_group=True):
2418 if not groups:
2418 if not groups:
2419 groups = cls.query().all()
2419 groups = cls.query().all()
2420
2420
2421 repo_groups = []
2421 repo_groups = []
2422 if show_empty_group:
2422 if show_empty_group:
2423 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2423 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2424
2424
2425 repo_groups.extend([cls._generate_choice(x) for x in groups])
2425 repo_groups.extend([cls._generate_choice(x) for x in groups])
2426
2426
2427 repo_groups = sorted(
2427 repo_groups = sorted(
2428 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2428 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2429 return repo_groups
2429 return repo_groups
2430
2430
2431 @classmethod
2431 @classmethod
2432 def url_sep(cls):
2432 def url_sep(cls):
2433 return URL_SEP
2433 return URL_SEP
2434
2434
2435 @classmethod
2435 @classmethod
2436 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2436 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2437 if case_insensitive:
2437 if case_insensitive:
2438 gr = cls.query().filter(func.lower(cls.group_name)
2438 gr = cls.query().filter(func.lower(cls.group_name)
2439 == func.lower(group_name))
2439 == func.lower(group_name))
2440 else:
2440 else:
2441 gr = cls.query().filter(cls.group_name == group_name)
2441 gr = cls.query().filter(cls.group_name == group_name)
2442 if cache:
2442 if cache:
2443 name_key = _hash_key(group_name)
2443 name_key = _hash_key(group_name)
2444 gr = gr.options(
2444 gr = gr.options(
2445 FromCache("sql_cache_short", "get_group_%s" % name_key))
2445 FromCache("sql_cache_short", "get_group_%s" % name_key))
2446 return gr.scalar()
2446 return gr.scalar()
2447
2447
2448 @classmethod
2448 @classmethod
2449 def get_user_personal_repo_group(cls, user_id):
2449 def get_user_personal_repo_group(cls, user_id):
2450 user = User.get(user_id)
2450 user = User.get(user_id)
2451 if user.username == User.DEFAULT_USER:
2451 if user.username == User.DEFAULT_USER:
2452 return None
2452 return None
2453
2453
2454 return cls.query()\
2454 return cls.query()\
2455 .filter(cls.personal == true()) \
2455 .filter(cls.personal == true()) \
2456 .filter(cls.user == user).scalar()
2456 .filter(cls.user == user).scalar()
2457
2457
2458 @classmethod
2458 @classmethod
2459 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2459 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2460 case_insensitive=True):
2460 case_insensitive=True):
2461 q = RepoGroup.query()
2461 q = RepoGroup.query()
2462
2462
2463 if not isinstance(user_id, Optional):
2463 if not isinstance(user_id, Optional):
2464 q = q.filter(RepoGroup.user_id == user_id)
2464 q = q.filter(RepoGroup.user_id == user_id)
2465
2465
2466 if not isinstance(group_id, Optional):
2466 if not isinstance(group_id, Optional):
2467 q = q.filter(RepoGroup.group_parent_id == group_id)
2467 q = q.filter(RepoGroup.group_parent_id == group_id)
2468
2468
2469 if case_insensitive:
2469 if case_insensitive:
2470 q = q.order_by(func.lower(RepoGroup.group_name))
2470 q = q.order_by(func.lower(RepoGroup.group_name))
2471 else:
2471 else:
2472 q = q.order_by(RepoGroup.group_name)
2472 q = q.order_by(RepoGroup.group_name)
2473 return q.all()
2473 return q.all()
2474
2474
2475 @property
2475 @property
2476 def parents(self):
2476 def parents(self):
2477 parents_recursion_limit = 10
2477 parents_recursion_limit = 10
2478 groups = []
2478 groups = []
2479 if self.parent_group is None:
2479 if self.parent_group is None:
2480 return groups
2480 return groups
2481 cur_gr = self.parent_group
2481 cur_gr = self.parent_group
2482 groups.insert(0, cur_gr)
2482 groups.insert(0, cur_gr)
2483 cnt = 0
2483 cnt = 0
2484 while 1:
2484 while 1:
2485 cnt += 1
2485 cnt += 1
2486 gr = getattr(cur_gr, 'parent_group', None)
2486 gr = getattr(cur_gr, 'parent_group', None)
2487 cur_gr = cur_gr.parent_group
2487 cur_gr = cur_gr.parent_group
2488 if gr is None:
2488 if gr is None:
2489 break
2489 break
2490 if cnt == parents_recursion_limit:
2490 if cnt == parents_recursion_limit:
2491 # this will prevent accidental infinit loops
2491 # this will prevent accidental infinit loops
2492 log.error(('more than %s parents found for group %s, stopping '
2492 log.error(('more than %s parents found for group %s, stopping '
2493 'recursive parent fetching' % (parents_recursion_limit, self)))
2493 'recursive parent fetching' % (parents_recursion_limit, self)))
2494 break
2494 break
2495
2495
2496 groups.insert(0, gr)
2496 groups.insert(0, gr)
2497 return groups
2497 return groups
2498
2498
2499 @property
2499 @property
2500 def last_db_change(self):
2500 def last_db_change(self):
2501 return self.updated_on
2501 return self.updated_on
2502
2502
2503 @property
2503 @property
2504 def children(self):
2504 def children(self):
2505 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2505 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2506
2506
2507 @property
2507 @property
2508 def name(self):
2508 def name(self):
2509 return self.group_name.split(RepoGroup.url_sep())[-1]
2509 return self.group_name.split(RepoGroup.url_sep())[-1]
2510
2510
2511 @property
2511 @property
2512 def full_path(self):
2512 def full_path(self):
2513 return self.group_name
2513 return self.group_name
2514
2514
2515 @property
2515 @property
2516 def full_path_splitted(self):
2516 def full_path_splitted(self):
2517 return self.group_name.split(RepoGroup.url_sep())
2517 return self.group_name.split(RepoGroup.url_sep())
2518
2518
2519 @property
2519 @property
2520 def repositories(self):
2520 def repositories(self):
2521 return Repository.query()\
2521 return Repository.query()\
2522 .filter(Repository.group == self)\
2522 .filter(Repository.group == self)\
2523 .order_by(Repository.repo_name)
2523 .order_by(Repository.repo_name)
2524
2524
2525 @property
2525 @property
2526 def repositories_recursive_count(self):
2526 def repositories_recursive_count(self):
2527 cnt = self.repositories.count()
2527 cnt = self.repositories.count()
2528
2528
2529 def children_count(group):
2529 def children_count(group):
2530 cnt = 0
2530 cnt = 0
2531 for child in group.children:
2531 for child in group.children:
2532 cnt += child.repositories.count()
2532 cnt += child.repositories.count()
2533 cnt += children_count(child)
2533 cnt += children_count(child)
2534 return cnt
2534 return cnt
2535
2535
2536 return cnt + children_count(self)
2536 return cnt + children_count(self)
2537
2537
2538 def _recursive_objects(self, include_repos=True):
2538 def _recursive_objects(self, include_repos=True):
2539 all_ = []
2539 all_ = []
2540
2540
2541 def _get_members(root_gr):
2541 def _get_members(root_gr):
2542 if include_repos:
2542 if include_repos:
2543 for r in root_gr.repositories:
2543 for r in root_gr.repositories:
2544 all_.append(r)
2544 all_.append(r)
2545 childs = root_gr.children.all()
2545 childs = root_gr.children.all()
2546 if childs:
2546 if childs:
2547 for gr in childs:
2547 for gr in childs:
2548 all_.append(gr)
2548 all_.append(gr)
2549 _get_members(gr)
2549 _get_members(gr)
2550
2550
2551 _get_members(self)
2551 _get_members(self)
2552 return [self] + all_
2552 return [self] + all_
2553
2553
2554 def recursive_groups_and_repos(self):
2554 def recursive_groups_and_repos(self):
2555 """
2555 """
2556 Recursive return all groups, with repositories in those groups
2556 Recursive return all groups, with repositories in those groups
2557 """
2557 """
2558 return self._recursive_objects()
2558 return self._recursive_objects()
2559
2559
2560 def recursive_groups(self):
2560 def recursive_groups(self):
2561 """
2561 """
2562 Returns all children groups for this group including children of children
2562 Returns all children groups for this group including children of children
2563 """
2563 """
2564 return self._recursive_objects(include_repos=False)
2564 return self._recursive_objects(include_repos=False)
2565
2565
2566 def get_new_name(self, group_name):
2566 def get_new_name(self, group_name):
2567 """
2567 """
2568 returns new full group name based on parent and new name
2568 returns new full group name based on parent and new name
2569
2569
2570 :param group_name:
2570 :param group_name:
2571 """
2571 """
2572 path_prefix = (self.parent_group.full_path_splitted if
2572 path_prefix = (self.parent_group.full_path_splitted if
2573 self.parent_group else [])
2573 self.parent_group else [])
2574 return RepoGroup.url_sep().join(path_prefix + [group_name])
2574 return RepoGroup.url_sep().join(path_prefix + [group_name])
2575
2575
2576 def permissions(self, with_admins=True, with_owner=True):
2576 def permissions(self, with_admins=True, with_owner=True):
2577 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2577 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2578 q = q.options(joinedload(UserRepoGroupToPerm.group),
2578 q = q.options(joinedload(UserRepoGroupToPerm.group),
2579 joinedload(UserRepoGroupToPerm.user),
2579 joinedload(UserRepoGroupToPerm.user),
2580 joinedload(UserRepoGroupToPerm.permission),)
2580 joinedload(UserRepoGroupToPerm.permission),)
2581
2581
2582 # get owners and admins and permissions. We do a trick of re-writing
2582 # get owners and admins and permissions. We do a trick of re-writing
2583 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2583 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2584 # has a global reference and changing one object propagates to all
2584 # has a global reference and changing one object propagates to all
2585 # others. This means if admin is also an owner admin_row that change
2585 # others. This means if admin is also an owner admin_row that change
2586 # would propagate to both objects
2586 # would propagate to both objects
2587 perm_rows = []
2587 perm_rows = []
2588 for _usr in q.all():
2588 for _usr in q.all():
2589 usr = AttributeDict(_usr.user.get_dict())
2589 usr = AttributeDict(_usr.user.get_dict())
2590 usr.permission = _usr.permission.permission_name
2590 usr.permission = _usr.permission.permission_name
2591 perm_rows.append(usr)
2591 perm_rows.append(usr)
2592
2592
2593 # filter the perm rows by 'default' first and then sort them by
2593 # filter the perm rows by 'default' first and then sort them by
2594 # admin,write,read,none permissions sorted again alphabetically in
2594 # admin,write,read,none permissions sorted again alphabetically in
2595 # each group
2595 # each group
2596 perm_rows = sorted(perm_rows, key=display_user_sort)
2596 perm_rows = sorted(perm_rows, key=display_user_sort)
2597
2597
2598 _admin_perm = 'group.admin'
2598 _admin_perm = 'group.admin'
2599 owner_row = []
2599 owner_row = []
2600 if with_owner:
2600 if with_owner:
2601 usr = AttributeDict(self.user.get_dict())
2601 usr = AttributeDict(self.user.get_dict())
2602 usr.owner_row = True
2602 usr.owner_row = True
2603 usr.permission = _admin_perm
2603 usr.permission = _admin_perm
2604 owner_row.append(usr)
2604 owner_row.append(usr)
2605
2605
2606 super_admin_rows = []
2606 super_admin_rows = []
2607 if with_admins:
2607 if with_admins:
2608 for usr in User.get_all_super_admins():
2608 for usr in User.get_all_super_admins():
2609 # if this admin is also owner, don't double the record
2609 # if this admin is also owner, don't double the record
2610 if usr.user_id == owner_row[0].user_id:
2610 if usr.user_id == owner_row[0].user_id:
2611 owner_row[0].admin_row = True
2611 owner_row[0].admin_row = True
2612 else:
2612 else:
2613 usr = AttributeDict(usr.get_dict())
2613 usr = AttributeDict(usr.get_dict())
2614 usr.admin_row = True
2614 usr.admin_row = True
2615 usr.permission = _admin_perm
2615 usr.permission = _admin_perm
2616 super_admin_rows.append(usr)
2616 super_admin_rows.append(usr)
2617
2617
2618 return super_admin_rows + owner_row + perm_rows
2618 return super_admin_rows + owner_row + perm_rows
2619
2619
2620 def permission_user_groups(self):
2620 def permission_user_groups(self):
2621 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2621 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2622 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2622 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2623 joinedload(UserGroupRepoGroupToPerm.users_group),
2623 joinedload(UserGroupRepoGroupToPerm.users_group),
2624 joinedload(UserGroupRepoGroupToPerm.permission),)
2624 joinedload(UserGroupRepoGroupToPerm.permission),)
2625
2625
2626 perm_rows = []
2626 perm_rows = []
2627 for _user_group in q.all():
2627 for _user_group in q.all():
2628 usr = AttributeDict(_user_group.users_group.get_dict())
2628 usr = AttributeDict(_user_group.users_group.get_dict())
2629 usr.permission = _user_group.permission.permission_name
2629 usr.permission = _user_group.permission.permission_name
2630 perm_rows.append(usr)
2630 perm_rows.append(usr)
2631
2631
2632 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2632 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2633 return perm_rows
2633 return perm_rows
2634
2634
2635 def get_api_data(self):
2635 def get_api_data(self):
2636 """
2636 """
2637 Common function for generating api data
2637 Common function for generating api data
2638
2638
2639 """
2639 """
2640 group = self
2640 group = self
2641 data = {
2641 data = {
2642 'group_id': group.group_id,
2642 'group_id': group.group_id,
2643 'group_name': group.group_name,
2643 'group_name': group.group_name,
2644 'group_description': group.description_safe,
2644 'group_description': group.description_safe,
2645 'parent_group': group.parent_group.group_name if group.parent_group else None,
2645 'parent_group': group.parent_group.group_name if group.parent_group else None,
2646 'repositories': [x.repo_name for x in group.repositories],
2646 'repositories': [x.repo_name for x in group.repositories],
2647 'owner': group.user.username,
2647 'owner': group.user.username,
2648 }
2648 }
2649 return data
2649 return data
2650
2650
2651
2651
2652 class Permission(Base, BaseModel):
2652 class Permission(Base, BaseModel):
2653 __tablename__ = 'permissions'
2653 __tablename__ = 'permissions'
2654 __table_args__ = (
2654 __table_args__ = (
2655 Index('p_perm_name_idx', 'permission_name'),
2655 Index('p_perm_name_idx', 'permission_name'),
2656 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2656 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2657 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2657 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2658 )
2658 )
2659 PERMS = [
2659 PERMS = [
2660 ('hg.admin', _('RhodeCode Super Administrator')),
2660 ('hg.admin', _('RhodeCode Super Administrator')),
2661
2661
2662 ('repository.none', _('Repository no access')),
2662 ('repository.none', _('Repository no access')),
2663 ('repository.read', _('Repository read access')),
2663 ('repository.read', _('Repository read access')),
2664 ('repository.write', _('Repository write access')),
2664 ('repository.write', _('Repository write access')),
2665 ('repository.admin', _('Repository admin access')),
2665 ('repository.admin', _('Repository admin access')),
2666
2666
2667 ('group.none', _('Repository group no access')),
2667 ('group.none', _('Repository group no access')),
2668 ('group.read', _('Repository group read access')),
2668 ('group.read', _('Repository group read access')),
2669 ('group.write', _('Repository group write access')),
2669 ('group.write', _('Repository group write access')),
2670 ('group.admin', _('Repository group admin access')),
2670 ('group.admin', _('Repository group admin access')),
2671
2671
2672 ('usergroup.none', _('User group no access')),
2672 ('usergroup.none', _('User group no access')),
2673 ('usergroup.read', _('User group read access')),
2673 ('usergroup.read', _('User group read access')),
2674 ('usergroup.write', _('User group write access')),
2674 ('usergroup.write', _('User group write access')),
2675 ('usergroup.admin', _('User group admin access')),
2675 ('usergroup.admin', _('User group admin access')),
2676
2676
2677 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2677 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2678 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2678 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2679
2679
2680 ('hg.usergroup.create.false', _('User Group creation disabled')),
2680 ('hg.usergroup.create.false', _('User Group creation disabled')),
2681 ('hg.usergroup.create.true', _('User Group creation enabled')),
2681 ('hg.usergroup.create.true', _('User Group creation enabled')),
2682
2682
2683 ('hg.create.none', _('Repository creation disabled')),
2683 ('hg.create.none', _('Repository creation disabled')),
2684 ('hg.create.repository', _('Repository creation enabled')),
2684 ('hg.create.repository', _('Repository creation enabled')),
2685 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2685 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2686 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2686 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2687
2687
2688 ('hg.fork.none', _('Repository forking disabled')),
2688 ('hg.fork.none', _('Repository forking disabled')),
2689 ('hg.fork.repository', _('Repository forking enabled')),
2689 ('hg.fork.repository', _('Repository forking enabled')),
2690
2690
2691 ('hg.register.none', _('Registration disabled')),
2691 ('hg.register.none', _('Registration disabled')),
2692 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2692 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2693 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2693 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2694
2694
2695 ('hg.password_reset.enabled', _('Password reset enabled')),
2695 ('hg.password_reset.enabled', _('Password reset enabled')),
2696 ('hg.password_reset.hidden', _('Password reset hidden')),
2696 ('hg.password_reset.hidden', _('Password reset hidden')),
2697 ('hg.password_reset.disabled', _('Password reset disabled')),
2697 ('hg.password_reset.disabled', _('Password reset disabled')),
2698
2698
2699 ('hg.extern_activate.manual', _('Manual activation of external account')),
2699 ('hg.extern_activate.manual', _('Manual activation of external account')),
2700 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2700 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2701
2701
2702 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2702 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2703 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2703 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2704 ]
2704 ]
2705
2705
2706 # definition of system default permissions for DEFAULT user
2706 # definition of system default permissions for DEFAULT user
2707 DEFAULT_USER_PERMISSIONS = [
2707 DEFAULT_USER_PERMISSIONS = [
2708 'repository.read',
2708 'repository.read',
2709 'group.read',
2709 'group.read',
2710 'usergroup.read',
2710 'usergroup.read',
2711 'hg.create.repository',
2711 'hg.create.repository',
2712 'hg.repogroup.create.false',
2712 'hg.repogroup.create.false',
2713 'hg.usergroup.create.false',
2713 'hg.usergroup.create.false',
2714 'hg.create.write_on_repogroup.true',
2714 'hg.create.write_on_repogroup.true',
2715 'hg.fork.repository',
2715 'hg.fork.repository',
2716 'hg.register.manual_activate',
2716 'hg.register.manual_activate',
2717 'hg.password_reset.enabled',
2717 'hg.password_reset.enabled',
2718 'hg.extern_activate.auto',
2718 'hg.extern_activate.auto',
2719 'hg.inherit_default_perms.true',
2719 'hg.inherit_default_perms.true',
2720 ]
2720 ]
2721
2721
2722 # defines which permissions are more important higher the more important
2722 # defines which permissions are more important higher the more important
2723 # Weight defines which permissions are more important.
2723 # Weight defines which permissions are more important.
2724 # The higher number the more important.
2724 # The higher number the more important.
2725 PERM_WEIGHTS = {
2725 PERM_WEIGHTS = {
2726 'repository.none': 0,
2726 'repository.none': 0,
2727 'repository.read': 1,
2727 'repository.read': 1,
2728 'repository.write': 3,
2728 'repository.write': 3,
2729 'repository.admin': 4,
2729 'repository.admin': 4,
2730
2730
2731 'group.none': 0,
2731 'group.none': 0,
2732 'group.read': 1,
2732 'group.read': 1,
2733 'group.write': 3,
2733 'group.write': 3,
2734 'group.admin': 4,
2734 'group.admin': 4,
2735
2735
2736 'usergroup.none': 0,
2736 'usergroup.none': 0,
2737 'usergroup.read': 1,
2737 'usergroup.read': 1,
2738 'usergroup.write': 3,
2738 'usergroup.write': 3,
2739 'usergroup.admin': 4,
2739 'usergroup.admin': 4,
2740
2740
2741 'hg.repogroup.create.false': 0,
2741 'hg.repogroup.create.false': 0,
2742 'hg.repogroup.create.true': 1,
2742 'hg.repogroup.create.true': 1,
2743
2743
2744 'hg.usergroup.create.false': 0,
2744 'hg.usergroup.create.false': 0,
2745 'hg.usergroup.create.true': 1,
2745 'hg.usergroup.create.true': 1,
2746
2746
2747 'hg.fork.none': 0,
2747 'hg.fork.none': 0,
2748 'hg.fork.repository': 1,
2748 'hg.fork.repository': 1,
2749 'hg.create.none': 0,
2749 'hg.create.none': 0,
2750 'hg.create.repository': 1
2750 'hg.create.repository': 1
2751 }
2751 }
2752
2752
2753 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2753 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2754 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2754 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2755 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2755 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2756
2756
2757 def __unicode__(self):
2757 def __unicode__(self):
2758 return u"<%s('%s:%s')>" % (
2758 return u"<%s('%s:%s')>" % (
2759 self.__class__.__name__, self.permission_id, self.permission_name
2759 self.__class__.__name__, self.permission_id, self.permission_name
2760 )
2760 )
2761
2761
2762 @classmethod
2762 @classmethod
2763 def get_by_key(cls, key):
2763 def get_by_key(cls, key):
2764 return cls.query().filter(cls.permission_name == key).scalar()
2764 return cls.query().filter(cls.permission_name == key).scalar()
2765
2765
2766 @classmethod
2766 @classmethod
2767 def get_default_repo_perms(cls, user_id, repo_id=None):
2767 def get_default_repo_perms(cls, user_id, repo_id=None):
2768 q = Session().query(UserRepoToPerm, Repository, Permission)\
2768 q = Session().query(UserRepoToPerm, Repository, Permission)\
2769 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2769 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2770 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2770 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2771 .filter(UserRepoToPerm.user_id == user_id)
2771 .filter(UserRepoToPerm.user_id == user_id)
2772 if repo_id:
2772 if repo_id:
2773 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2773 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2774 return q.all()
2774 return q.all()
2775
2775
2776 @classmethod
2776 @classmethod
2777 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2777 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2778 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2778 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2779 .join(
2779 .join(
2780 Permission,
2780 Permission,
2781 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2781 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2782 .join(
2782 .join(
2783 Repository,
2783 Repository,
2784 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2784 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2785 .join(
2785 .join(
2786 UserGroup,
2786 UserGroup,
2787 UserGroupRepoToPerm.users_group_id ==
2787 UserGroupRepoToPerm.users_group_id ==
2788 UserGroup.users_group_id)\
2788 UserGroup.users_group_id)\
2789 .join(
2789 .join(
2790 UserGroupMember,
2790 UserGroupMember,
2791 UserGroupRepoToPerm.users_group_id ==
2791 UserGroupRepoToPerm.users_group_id ==
2792 UserGroupMember.users_group_id)\
2792 UserGroupMember.users_group_id)\
2793 .filter(
2793 .filter(
2794 UserGroupMember.user_id == user_id,
2794 UserGroupMember.user_id == user_id,
2795 UserGroup.users_group_active == true())
2795 UserGroup.users_group_active == true())
2796 if repo_id:
2796 if repo_id:
2797 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2797 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2798 return q.all()
2798 return q.all()
2799
2799
2800 @classmethod
2800 @classmethod
2801 def get_default_group_perms(cls, user_id, repo_group_id=None):
2801 def get_default_group_perms(cls, user_id, repo_group_id=None):
2802 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2802 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2803 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2803 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2804 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2804 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2805 .filter(UserRepoGroupToPerm.user_id == user_id)
2805 .filter(UserRepoGroupToPerm.user_id == user_id)
2806 if repo_group_id:
2806 if repo_group_id:
2807 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2807 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2808 return q.all()
2808 return q.all()
2809
2809
2810 @classmethod
2810 @classmethod
2811 def get_default_group_perms_from_user_group(
2811 def get_default_group_perms_from_user_group(
2812 cls, user_id, repo_group_id=None):
2812 cls, user_id, repo_group_id=None):
2813 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2813 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2814 .join(
2814 .join(
2815 Permission,
2815 Permission,
2816 UserGroupRepoGroupToPerm.permission_id ==
2816 UserGroupRepoGroupToPerm.permission_id ==
2817 Permission.permission_id)\
2817 Permission.permission_id)\
2818 .join(
2818 .join(
2819 RepoGroup,
2819 RepoGroup,
2820 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2820 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2821 .join(
2821 .join(
2822 UserGroup,
2822 UserGroup,
2823 UserGroupRepoGroupToPerm.users_group_id ==
2823 UserGroupRepoGroupToPerm.users_group_id ==
2824 UserGroup.users_group_id)\
2824 UserGroup.users_group_id)\
2825 .join(
2825 .join(
2826 UserGroupMember,
2826 UserGroupMember,
2827 UserGroupRepoGroupToPerm.users_group_id ==
2827 UserGroupRepoGroupToPerm.users_group_id ==
2828 UserGroupMember.users_group_id)\
2828 UserGroupMember.users_group_id)\
2829 .filter(
2829 .filter(
2830 UserGroupMember.user_id == user_id,
2830 UserGroupMember.user_id == user_id,
2831 UserGroup.users_group_active == true())
2831 UserGroup.users_group_active == true())
2832 if repo_group_id:
2832 if repo_group_id:
2833 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2833 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2834 return q.all()
2834 return q.all()
2835
2835
2836 @classmethod
2836 @classmethod
2837 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2837 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2838 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2838 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2839 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2839 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2840 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2840 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2841 .filter(UserUserGroupToPerm.user_id == user_id)
2841 .filter(UserUserGroupToPerm.user_id == user_id)
2842 if user_group_id:
2842 if user_group_id:
2843 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2843 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2844 return q.all()
2844 return q.all()
2845
2845
2846 @classmethod
2846 @classmethod
2847 def get_default_user_group_perms_from_user_group(
2847 def get_default_user_group_perms_from_user_group(
2848 cls, user_id, user_group_id=None):
2848 cls, user_id, user_group_id=None):
2849 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2849 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2850 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2850 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2851 .join(
2851 .join(
2852 Permission,
2852 Permission,
2853 UserGroupUserGroupToPerm.permission_id ==
2853 UserGroupUserGroupToPerm.permission_id ==
2854 Permission.permission_id)\
2854 Permission.permission_id)\
2855 .join(
2855 .join(
2856 TargetUserGroup,
2856 TargetUserGroup,
2857 UserGroupUserGroupToPerm.target_user_group_id ==
2857 UserGroupUserGroupToPerm.target_user_group_id ==
2858 TargetUserGroup.users_group_id)\
2858 TargetUserGroup.users_group_id)\
2859 .join(
2859 .join(
2860 UserGroup,
2860 UserGroup,
2861 UserGroupUserGroupToPerm.user_group_id ==
2861 UserGroupUserGroupToPerm.user_group_id ==
2862 UserGroup.users_group_id)\
2862 UserGroup.users_group_id)\
2863 .join(
2863 .join(
2864 UserGroupMember,
2864 UserGroupMember,
2865 UserGroupUserGroupToPerm.user_group_id ==
2865 UserGroupUserGroupToPerm.user_group_id ==
2866 UserGroupMember.users_group_id)\
2866 UserGroupMember.users_group_id)\
2867 .filter(
2867 .filter(
2868 UserGroupMember.user_id == user_id,
2868 UserGroupMember.user_id == user_id,
2869 UserGroup.users_group_active == true())
2869 UserGroup.users_group_active == true())
2870 if user_group_id:
2870 if user_group_id:
2871 q = q.filter(
2871 q = q.filter(
2872 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2872 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2873
2873
2874 return q.all()
2874 return q.all()
2875
2875
2876
2876
2877 class UserRepoToPerm(Base, BaseModel):
2877 class UserRepoToPerm(Base, BaseModel):
2878 __tablename__ = 'repo_to_perm'
2878 __tablename__ = 'repo_to_perm'
2879 __table_args__ = (
2879 __table_args__ = (
2880 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2880 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2881 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2881 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2882 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2882 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2883 )
2883 )
2884 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2884 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2885 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2885 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2886 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2886 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2887 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2887 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2888
2888
2889 user = relationship('User')
2889 user = relationship('User')
2890 repository = relationship('Repository')
2890 repository = relationship('Repository')
2891 permission = relationship('Permission')
2891 permission = relationship('Permission')
2892
2892
2893 @classmethod
2893 @classmethod
2894 def create(cls, user, repository, permission):
2894 def create(cls, user, repository, permission):
2895 n = cls()
2895 n = cls()
2896 n.user = user
2896 n.user = user
2897 n.repository = repository
2897 n.repository = repository
2898 n.permission = permission
2898 n.permission = permission
2899 Session().add(n)
2899 Session().add(n)
2900 return n
2900 return n
2901
2901
2902 def __unicode__(self):
2902 def __unicode__(self):
2903 return u'<%s => %s >' % (self.user, self.repository)
2903 return u'<%s => %s >' % (self.user, self.repository)
2904
2904
2905
2905
2906 class UserUserGroupToPerm(Base, BaseModel):
2906 class UserUserGroupToPerm(Base, BaseModel):
2907 __tablename__ = 'user_user_group_to_perm'
2907 __tablename__ = 'user_user_group_to_perm'
2908 __table_args__ = (
2908 __table_args__ = (
2909 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2909 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2910 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2910 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2911 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2911 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2912 )
2912 )
2913 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2913 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2914 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2914 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2915 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2915 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2916 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2916 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2917
2917
2918 user = relationship('User')
2918 user = relationship('User')
2919 user_group = relationship('UserGroup')
2919 user_group = relationship('UserGroup')
2920 permission = relationship('Permission')
2920 permission = relationship('Permission')
2921
2921
2922 @classmethod
2922 @classmethod
2923 def create(cls, user, user_group, permission):
2923 def create(cls, user, user_group, permission):
2924 n = cls()
2924 n = cls()
2925 n.user = user
2925 n.user = user
2926 n.user_group = user_group
2926 n.user_group = user_group
2927 n.permission = permission
2927 n.permission = permission
2928 Session().add(n)
2928 Session().add(n)
2929 return n
2929 return n
2930
2930
2931 def __unicode__(self):
2931 def __unicode__(self):
2932 return u'<%s => %s >' % (self.user, self.user_group)
2932 return u'<%s => %s >' % (self.user, self.user_group)
2933
2933
2934
2934
2935 class UserToPerm(Base, BaseModel):
2935 class UserToPerm(Base, BaseModel):
2936 __tablename__ = 'user_to_perm'
2936 __tablename__ = 'user_to_perm'
2937 __table_args__ = (
2937 __table_args__ = (
2938 UniqueConstraint('user_id', 'permission_id'),
2938 UniqueConstraint('user_id', 'permission_id'),
2939 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2939 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2940 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2940 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2941 )
2941 )
2942 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2942 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2943 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2943 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2944 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2944 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2945
2945
2946 user = relationship('User')
2946 user = relationship('User')
2947 permission = relationship('Permission', lazy='joined')
2947 permission = relationship('Permission', lazy='joined')
2948
2948
2949 def __unicode__(self):
2949 def __unicode__(self):
2950 return u'<%s => %s >' % (self.user, self.permission)
2950 return u'<%s => %s >' % (self.user, self.permission)
2951
2951
2952
2952
2953 class UserGroupRepoToPerm(Base, BaseModel):
2953 class UserGroupRepoToPerm(Base, BaseModel):
2954 __tablename__ = 'users_group_repo_to_perm'
2954 __tablename__ = 'users_group_repo_to_perm'
2955 __table_args__ = (
2955 __table_args__ = (
2956 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2956 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2957 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2957 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2958 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2958 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2959 )
2959 )
2960 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2960 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2961 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2961 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2962 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2962 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2963 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2963 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2964
2964
2965 users_group = relationship('UserGroup')
2965 users_group = relationship('UserGroup')
2966 permission = relationship('Permission')
2966 permission = relationship('Permission')
2967 repository = relationship('Repository')
2967 repository = relationship('Repository')
2968
2968
2969 @classmethod
2969 @classmethod
2970 def create(cls, users_group, repository, permission):
2970 def create(cls, users_group, repository, permission):
2971 n = cls()
2971 n = cls()
2972 n.users_group = users_group
2972 n.users_group = users_group
2973 n.repository = repository
2973 n.repository = repository
2974 n.permission = permission
2974 n.permission = permission
2975 Session().add(n)
2975 Session().add(n)
2976 return n
2976 return n
2977
2977
2978 def __unicode__(self):
2978 def __unicode__(self):
2979 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2979 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2980
2980
2981
2981
2982 class UserGroupUserGroupToPerm(Base, BaseModel):
2982 class UserGroupUserGroupToPerm(Base, BaseModel):
2983 __tablename__ = 'user_group_user_group_to_perm'
2983 __tablename__ = 'user_group_user_group_to_perm'
2984 __table_args__ = (
2984 __table_args__ = (
2985 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2985 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2986 CheckConstraint('target_user_group_id != user_group_id'),
2986 CheckConstraint('target_user_group_id != user_group_id'),
2987 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2987 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2988 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2988 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2989 )
2989 )
2990 user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2990 user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2991 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2991 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2992 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2992 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2993 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2993 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2994
2994
2995 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2995 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2996 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2996 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2997 permission = relationship('Permission')
2997 permission = relationship('Permission')
2998
2998
2999 @classmethod
2999 @classmethod
3000 def create(cls, target_user_group, user_group, permission):
3000 def create(cls, target_user_group, user_group, permission):
3001 n = cls()
3001 n = cls()
3002 n.target_user_group = target_user_group
3002 n.target_user_group = target_user_group
3003 n.user_group = user_group
3003 n.user_group = user_group
3004 n.permission = permission
3004 n.permission = permission
3005 Session().add(n)
3005 Session().add(n)
3006 return n
3006 return n
3007
3007
3008 def __unicode__(self):
3008 def __unicode__(self):
3009 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
3009 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
3010
3010
3011
3011
3012 class UserGroupToPerm(Base, BaseModel):
3012 class UserGroupToPerm(Base, BaseModel):
3013 __tablename__ = 'users_group_to_perm'
3013 __tablename__ = 'users_group_to_perm'
3014 __table_args__ = (
3014 __table_args__ = (
3015 UniqueConstraint('users_group_id', 'permission_id',),
3015 UniqueConstraint('users_group_id', 'permission_id',),
3016 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3016 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3017 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3017 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3018 )
3018 )
3019 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3019 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3020 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3020 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3021 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3021 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3022
3022
3023 users_group = relationship('UserGroup')
3023 users_group = relationship('UserGroup')
3024 permission = relationship('Permission')
3024 permission = relationship('Permission')
3025
3025
3026
3026
3027 class UserRepoGroupToPerm(Base, BaseModel):
3027 class UserRepoGroupToPerm(Base, BaseModel):
3028 __tablename__ = 'user_repo_group_to_perm'
3028 __tablename__ = 'user_repo_group_to_perm'
3029 __table_args__ = (
3029 __table_args__ = (
3030 UniqueConstraint('user_id', 'group_id', 'permission_id'),
3030 UniqueConstraint('user_id', 'group_id', 'permission_id'),
3031 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3031 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3032 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3032 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3033 )
3033 )
3034
3034
3035 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3035 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3036 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3036 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3037 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3037 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3038 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3038 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3039
3039
3040 user = relationship('User')
3040 user = relationship('User')
3041 group = relationship('RepoGroup')
3041 group = relationship('RepoGroup')
3042 permission = relationship('Permission')
3042 permission = relationship('Permission')
3043
3043
3044 @classmethod
3044 @classmethod
3045 def create(cls, user, repository_group, permission):
3045 def create(cls, user, repository_group, permission):
3046 n = cls()
3046 n = cls()
3047 n.user = user
3047 n.user = user
3048 n.group = repository_group
3048 n.group = repository_group
3049 n.permission = permission
3049 n.permission = permission
3050 Session().add(n)
3050 Session().add(n)
3051 return n
3051 return n
3052
3052
3053
3053
3054 class UserGroupRepoGroupToPerm(Base, BaseModel):
3054 class UserGroupRepoGroupToPerm(Base, BaseModel):
3055 __tablename__ = 'users_group_repo_group_to_perm'
3055 __tablename__ = 'users_group_repo_group_to_perm'
3056 __table_args__ = (
3056 __table_args__ = (
3057 UniqueConstraint('users_group_id', 'group_id'),
3057 UniqueConstraint('users_group_id', 'group_id'),
3058 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3058 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3059 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3059 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3060 )
3060 )
3061
3061
3062 users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3062 users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3063 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3063 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3064 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3064 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3065 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3065 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3066
3066
3067 users_group = relationship('UserGroup')
3067 users_group = relationship('UserGroup')
3068 permission = relationship('Permission')
3068 permission = relationship('Permission')
3069 group = relationship('RepoGroup')
3069 group = relationship('RepoGroup')
3070
3070
3071 @classmethod
3071 @classmethod
3072 def create(cls, user_group, repository_group, permission):
3072 def create(cls, user_group, repository_group, permission):
3073 n = cls()
3073 n = cls()
3074 n.users_group = user_group
3074 n.users_group = user_group
3075 n.group = repository_group
3075 n.group = repository_group
3076 n.permission = permission
3076 n.permission = permission
3077 Session().add(n)
3077 Session().add(n)
3078 return n
3078 return n
3079
3079
3080 def __unicode__(self):
3080 def __unicode__(self):
3081 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
3081 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
3082
3082
3083
3083
3084 class Statistics(Base, BaseModel):
3084 class Statistics(Base, BaseModel):
3085 __tablename__ = 'statistics'
3085 __tablename__ = 'statistics'
3086 __table_args__ = (
3086 __table_args__ = (
3087 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3087 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3088 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3088 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3089 )
3089 )
3090 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3090 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3091 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
3091 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
3092 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
3092 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
3093 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
3093 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
3094 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
3094 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
3095 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
3095 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
3096
3096
3097 repository = relationship('Repository', single_parent=True)
3097 repository = relationship('Repository', single_parent=True)
3098
3098
3099
3099
3100 class UserFollowing(Base, BaseModel):
3100 class UserFollowing(Base, BaseModel):
3101 __tablename__ = 'user_followings'
3101 __tablename__ = 'user_followings'
3102 __table_args__ = (
3102 __table_args__ = (
3103 UniqueConstraint('user_id', 'follows_repository_id'),
3103 UniqueConstraint('user_id', 'follows_repository_id'),
3104 UniqueConstraint('user_id', 'follows_user_id'),
3104 UniqueConstraint('user_id', 'follows_user_id'),
3105 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3105 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3106 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3106 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3107 )
3107 )
3108
3108
3109 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3109 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3110 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3110 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3111 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
3111 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
3112 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
3112 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
3113 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
3113 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
3114
3114
3115 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
3115 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
3116
3116
3117 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
3117 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
3118 follows_repository = relationship('Repository', order_by='Repository.repo_name')
3118 follows_repository = relationship('Repository', order_by='Repository.repo_name')
3119
3119
3120 @classmethod
3120 @classmethod
3121 def get_repo_followers(cls, repo_id):
3121 def get_repo_followers(cls, repo_id):
3122 return cls.query().filter(cls.follows_repo_id == repo_id)
3122 return cls.query().filter(cls.follows_repo_id == repo_id)
3123
3123
3124
3124
3125 class CacheKey(Base, BaseModel):
3125 class CacheKey(Base, BaseModel):
3126 __tablename__ = 'cache_invalidation'
3126 __tablename__ = 'cache_invalidation'
3127 __table_args__ = (
3127 __table_args__ = (
3128 UniqueConstraint('cache_key'),
3128 UniqueConstraint('cache_key'),
3129 Index('key_idx', 'cache_key'),
3129 Index('key_idx', 'cache_key'),
3130 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3130 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3131 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3131 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3132 )
3132 )
3133 CACHE_TYPE_ATOM = 'ATOM'
3133 CACHE_TYPE_ATOM = 'ATOM'
3134 CACHE_TYPE_RSS = 'RSS'
3134 CACHE_TYPE_RSS = 'RSS'
3135 CACHE_TYPE_README = 'README'
3135 CACHE_TYPE_README = 'README'
3136
3136
3137 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3137 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3138 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
3138 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
3139 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
3139 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
3140 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
3140 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
3141
3141
3142 def __init__(self, cache_key, cache_args=''):
3142 def __init__(self, cache_key, cache_args=''):
3143 self.cache_key = cache_key
3143 self.cache_key = cache_key
3144 self.cache_args = cache_args
3144 self.cache_args = cache_args
3145 self.cache_active = False
3145 self.cache_active = False
3146
3146
3147 def __unicode__(self):
3147 def __unicode__(self):
3148 return u"<%s('%s:%s[%s]')>" % (
3148 return u"<%s('%s:%s[%s]')>" % (
3149 self.__class__.__name__,
3149 self.__class__.__name__,
3150 self.cache_id, self.cache_key, self.cache_active)
3150 self.cache_id, self.cache_key, self.cache_active)
3151
3151
3152 def _cache_key_partition(self):
3152 def _cache_key_partition(self):
3153 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
3153 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
3154 return prefix, repo_name, suffix
3154 return prefix, repo_name, suffix
3155
3155
3156 def get_prefix(self):
3156 def get_prefix(self):
3157 """
3157 """
3158 Try to extract prefix from existing cache key. The key could consist
3158 Try to extract prefix from existing cache key. The key could consist
3159 of prefix, repo_name, suffix
3159 of prefix, repo_name, suffix
3160 """
3160 """
3161 # this returns prefix, repo_name, suffix
3161 # this returns prefix, repo_name, suffix
3162 return self._cache_key_partition()[0]
3162 return self._cache_key_partition()[0]
3163
3163
3164 def get_suffix(self):
3164 def get_suffix(self):
3165 """
3165 """
3166 get suffix that might have been used in _get_cache_key to
3166 get suffix that might have been used in _get_cache_key to
3167 generate self.cache_key. Only used for informational purposes
3167 generate self.cache_key. Only used for informational purposes
3168 in repo_edit.mako.
3168 in repo_edit.mako.
3169 """
3169 """
3170 # prefix, repo_name, suffix
3170 # prefix, repo_name, suffix
3171 return self._cache_key_partition()[2]
3171 return self._cache_key_partition()[2]
3172
3172
3173 @classmethod
3173 @classmethod
3174 def delete_all_cache(cls):
3174 def delete_all_cache(cls):
3175 """
3175 """
3176 Delete all cache keys from database.
3176 Delete all cache keys from database.
3177 Should only be run when all instances are down and all entries
3177 Should only be run when all instances are down and all entries
3178 thus stale.
3178 thus stale.
3179 """
3179 """
3180 cls.query().delete()
3180 cls.query().delete()
3181 Session().commit()
3181 Session().commit()
3182
3182
3183 @classmethod
3183 @classmethod
3184 def get_cache_key(cls, repo_name, cache_type):
3184 def get_cache_key(cls, repo_name, cache_type):
3185 """
3185 """
3186
3186
3187 Generate a cache key for this process of RhodeCode instance.
3187 Generate a cache key for this process of RhodeCode instance.
3188 Prefix most likely will be process id or maybe explicitly set
3188 Prefix most likely will be process id or maybe explicitly set
3189 instance_id from .ini file.
3189 instance_id from .ini file.
3190 """
3190 """
3191 import rhodecode
3191 import rhodecode
3192 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
3192 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
3193
3193
3194 repo_as_unicode = safe_unicode(repo_name)
3194 repo_as_unicode = safe_unicode(repo_name)
3195 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
3195 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
3196 if cache_type else repo_as_unicode
3196 if cache_type else repo_as_unicode
3197
3197
3198 return u'{}{}'.format(prefix, key)
3198 return u'{}{}'.format(prefix, key)
3199
3199
3200 @classmethod
3200 @classmethod
3201 def set_invalidate(cls, repo_name, delete=False):
3201 def set_invalidate(cls, repo_name, delete=False):
3202 """
3202 """
3203 Mark all caches of a repo as invalid in the database.
3203 Mark all caches of a repo as invalid in the database.
3204 """
3204 """
3205
3205
3206 try:
3206 try:
3207 qry = Session().query(cls).filter(cls.cache_args == repo_name)
3207 qry = Session().query(cls).filter(cls.cache_args == repo_name)
3208 if delete:
3208 if delete:
3209 log.debug('cache objects deleted for repo %s',
3209 log.debug('cache objects deleted for repo %s',
3210 safe_str(repo_name))
3210 safe_str(repo_name))
3211 qry.delete()
3211 qry.delete()
3212 else:
3212 else:
3213 log.debug('cache objects marked as invalid for repo %s',
3213 log.debug('cache objects marked as invalid for repo %s',
3214 safe_str(repo_name))
3214 safe_str(repo_name))
3215 qry.update({"cache_active": False})
3215 qry.update({"cache_active": False})
3216
3216
3217 Session().commit()
3217 Session().commit()
3218 except Exception:
3218 except Exception:
3219 log.exception(
3219 log.exception(
3220 'Cache key invalidation failed for repository %s',
3220 'Cache key invalidation failed for repository %s',
3221 safe_str(repo_name))
3221 safe_str(repo_name))
3222 Session().rollback()
3222 Session().rollback()
3223
3223
3224 @classmethod
3224 @classmethod
3225 def get_active_cache(cls, cache_key):
3225 def get_active_cache(cls, cache_key):
3226 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
3226 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
3227 if inv_obj:
3227 if inv_obj:
3228 return inv_obj
3228 return inv_obj
3229 return None
3229 return None
3230
3230
3231 @classmethod
3231 @classmethod
3232 def repo_context_cache(cls, compute_func, repo_name, cache_type,
3232 def repo_context_cache(cls, compute_func, repo_name, cache_type,
3233 thread_scoped=False):
3233 thread_scoped=False):
3234 """
3234 """
3235 @cache_region('long_term')
3235 @cache_region('long_term')
3236 def _heavy_calculation(cache_key):
3236 def _heavy_calculation(cache_key):
3237 return 'result'
3237 return 'result'
3238
3238
3239 cache_context = CacheKey.repo_context_cache(
3239 cache_context = CacheKey.repo_context_cache(
3240 _heavy_calculation, repo_name, cache_type)
3240 _heavy_calculation, repo_name, cache_type)
3241
3241
3242 with cache_context as context:
3242 with cache_context as context:
3243 context.invalidate()
3243 context.invalidate()
3244 computed = context.compute()
3244 computed = context.compute()
3245
3245
3246 assert computed == 'result'
3246 assert computed == 'result'
3247 """
3247 """
3248 from rhodecode.lib import caches
3248 from rhodecode.lib import caches
3249 return caches.InvalidationContext(
3249 return caches.InvalidationContext(
3250 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
3250 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
3251
3251
3252
3252
3253 class ChangesetComment(Base, BaseModel):
3253 class ChangesetComment(Base, BaseModel):
3254 __tablename__ = 'changeset_comments'
3254 __tablename__ = 'changeset_comments'
3255 __table_args__ = (
3255 __table_args__ = (
3256 Index('cc_revision_idx', 'revision'),
3256 Index('cc_revision_idx', 'revision'),
3257 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3257 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3258 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3258 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3259 )
3259 )
3260
3260
3261 COMMENT_OUTDATED = u'comment_outdated'
3261 COMMENT_OUTDATED = u'comment_outdated'
3262 COMMENT_TYPE_NOTE = u'note'
3262 COMMENT_TYPE_NOTE = u'note'
3263 COMMENT_TYPE_TODO = u'todo'
3263 COMMENT_TYPE_TODO = u'todo'
3264 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3264 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3265
3265
3266 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3266 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3267 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3267 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3268 revision = Column('revision', String(40), nullable=True)
3268 revision = Column('revision', String(40), nullable=True)
3269 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3269 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3270 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3270 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3271 line_no = Column('line_no', Unicode(10), nullable=True)
3271 line_no = Column('line_no', Unicode(10), nullable=True)
3272 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3272 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3273 f_path = Column('f_path', Unicode(1000), nullable=True)
3273 f_path = Column('f_path', Unicode(1000), nullable=True)
3274 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3274 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3275 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3275 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3276 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3276 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3277 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3277 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3278 renderer = Column('renderer', Unicode(64), nullable=True)
3278 renderer = Column('renderer', Unicode(64), nullable=True)
3279 display_state = Column('display_state', Unicode(128), nullable=True)
3279 display_state = Column('display_state', Unicode(128), nullable=True)
3280
3280
3281 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3281 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3282 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3282 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3283 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')
3283 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')
3284 author = relationship('User', lazy='joined')
3284 author = relationship('User', lazy='joined')
3285 repo = relationship('Repository')
3285 repo = relationship('Repository')
3286 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
3286 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
3287 pull_request = relationship('PullRequest', lazy='joined')
3287 pull_request = relationship('PullRequest', lazy='joined')
3288 pull_request_version = relationship('PullRequestVersion')
3288 pull_request_version = relationship('PullRequestVersion')
3289
3289
3290 @classmethod
3290 @classmethod
3291 def get_users(cls, revision=None, pull_request_id=None):
3291 def get_users(cls, revision=None, pull_request_id=None):
3292 """
3292 """
3293 Returns user associated with this ChangesetComment. ie those
3293 Returns user associated with this ChangesetComment. ie those
3294 who actually commented
3294 who actually commented
3295
3295
3296 :param cls:
3296 :param cls:
3297 :param revision:
3297 :param revision:
3298 """
3298 """
3299 q = Session().query(User)\
3299 q = Session().query(User)\
3300 .join(ChangesetComment.author)
3300 .join(ChangesetComment.author)
3301 if revision:
3301 if revision:
3302 q = q.filter(cls.revision == revision)
3302 q = q.filter(cls.revision == revision)
3303 elif pull_request_id:
3303 elif pull_request_id:
3304 q = q.filter(cls.pull_request_id == pull_request_id)
3304 q = q.filter(cls.pull_request_id == pull_request_id)
3305 return q.all()
3305 return q.all()
3306
3306
3307 @classmethod
3307 @classmethod
3308 def get_index_from_version(cls, pr_version, versions):
3308 def get_index_from_version(cls, pr_version, versions):
3309 num_versions = [x.pull_request_version_id for x in versions]
3309 num_versions = [x.pull_request_version_id for x in versions]
3310 try:
3310 try:
3311 return num_versions.index(pr_version) +1
3311 return num_versions.index(pr_version) +1
3312 except (IndexError, ValueError):
3312 except (IndexError, ValueError):
3313 return
3313 return
3314
3314
3315 @property
3315 @property
3316 def outdated(self):
3316 def outdated(self):
3317 return self.display_state == self.COMMENT_OUTDATED
3317 return self.display_state == self.COMMENT_OUTDATED
3318
3318
3319 def outdated_at_version(self, version):
3319 def outdated_at_version(self, version):
3320 """
3320 """
3321 Checks if comment is outdated for given pull request version
3321 Checks if comment is outdated for given pull request version
3322 """
3322 """
3323 return self.outdated and self.pull_request_version_id != version
3323 return self.outdated and self.pull_request_version_id != version
3324
3324
3325 def older_than_version(self, version):
3325 def older_than_version(self, version):
3326 """
3326 """
3327 Checks if comment is made from previous version than given
3327 Checks if comment is made from previous version than given
3328 """
3328 """
3329 if version is None:
3329 if version is None:
3330 return self.pull_request_version_id is not None
3330 return self.pull_request_version_id is not None
3331
3331
3332 return self.pull_request_version_id < version
3332 return self.pull_request_version_id < version
3333
3333
3334 @property
3334 @property
3335 def resolved(self):
3335 def resolved(self):
3336 return self.resolved_by[0] if self.resolved_by else None
3336 return self.resolved_by[0] if self.resolved_by else None
3337
3337
3338 @property
3338 @property
3339 def is_todo(self):
3339 def is_todo(self):
3340 return self.comment_type == self.COMMENT_TYPE_TODO
3340 return self.comment_type == self.COMMENT_TYPE_TODO
3341
3341
3342 @property
3342 @property
3343 def is_inline(self):
3343 def is_inline(self):
3344 return self.line_no and self.f_path
3344 return self.line_no and self.f_path
3345
3345
3346 def get_index_version(self, versions):
3346 def get_index_version(self, versions):
3347 return self.get_index_from_version(
3347 return self.get_index_from_version(
3348 self.pull_request_version_id, versions)
3348 self.pull_request_version_id, versions)
3349
3349
3350 def __repr__(self):
3350 def __repr__(self):
3351 if self.comment_id:
3351 if self.comment_id:
3352 return '<DB:Comment #%s>' % self.comment_id
3352 return '<DB:Comment #%s>' % self.comment_id
3353 else:
3353 else:
3354 return '<DB:Comment at %#x>' % id(self)
3354 return '<DB:Comment at %#x>' % id(self)
3355
3355
3356 def get_api_data(self):
3356 def get_api_data(self):
3357 comment = self
3357 comment = self
3358 data = {
3358 data = {
3359 'comment_id': comment.comment_id,
3359 'comment_id': comment.comment_id,
3360 'comment_type': comment.comment_type,
3360 'comment_type': comment.comment_type,
3361 'comment_text': comment.text,
3361 'comment_text': comment.text,
3362 'comment_status': comment.status_change,
3362 'comment_status': comment.status_change,
3363 'comment_f_path': comment.f_path,
3363 'comment_f_path': comment.f_path,
3364 'comment_lineno': comment.line_no,
3364 'comment_lineno': comment.line_no,
3365 'comment_author': comment.author,
3365 'comment_author': comment.author,
3366 'comment_created_on': comment.created_on
3366 'comment_created_on': comment.created_on
3367 }
3367 }
3368 return data
3368 return data
3369
3369
3370 def __json__(self):
3370 def __json__(self):
3371 data = dict()
3371 data = dict()
3372 data.update(self.get_api_data())
3372 data.update(self.get_api_data())
3373 return data
3373 return data
3374
3374
3375
3375
3376 class ChangesetStatus(Base, BaseModel):
3376 class ChangesetStatus(Base, BaseModel):
3377 __tablename__ = 'changeset_statuses'
3377 __tablename__ = 'changeset_statuses'
3378 __table_args__ = (
3378 __table_args__ = (
3379 Index('cs_revision_idx', 'revision'),
3379 Index('cs_revision_idx', 'revision'),
3380 Index('cs_version_idx', 'version'),
3380 Index('cs_version_idx', 'version'),
3381 UniqueConstraint('repo_id', 'revision', 'version'),
3381 UniqueConstraint('repo_id', 'revision', 'version'),
3382 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3382 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3383 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3383 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3384 )
3384 )
3385 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3385 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3386 STATUS_APPROVED = 'approved'
3386 STATUS_APPROVED = 'approved'
3387 STATUS_REJECTED = 'rejected'
3387 STATUS_REJECTED = 'rejected'
3388 STATUS_UNDER_REVIEW = 'under_review'
3388 STATUS_UNDER_REVIEW = 'under_review'
3389
3389
3390 STATUSES = [
3390 STATUSES = [
3391 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3391 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3392 (STATUS_APPROVED, _("Approved")),
3392 (STATUS_APPROVED, _("Approved")),
3393 (STATUS_REJECTED, _("Rejected")),
3393 (STATUS_REJECTED, _("Rejected")),
3394 (STATUS_UNDER_REVIEW, _("Under Review")),
3394 (STATUS_UNDER_REVIEW, _("Under Review")),
3395 ]
3395 ]
3396
3396
3397 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3397 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3398 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3398 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3399 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3399 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3400 revision = Column('revision', String(40), nullable=False)
3400 revision = Column('revision', String(40), nullable=False)
3401 status = Column('status', String(128), nullable=False, default=DEFAULT)
3401 status = Column('status', String(128), nullable=False, default=DEFAULT)
3402 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3402 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3403 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3403 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3404 version = Column('version', Integer(), nullable=False, default=0)
3404 version = Column('version', Integer(), nullable=False, default=0)
3405 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3405 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3406
3406
3407 author = relationship('User', lazy='joined')
3407 author = relationship('User', lazy='joined')
3408 repo = relationship('Repository')
3408 repo = relationship('Repository')
3409 comment = relationship('ChangesetComment', lazy='joined')
3409 comment = relationship('ChangesetComment', lazy='joined')
3410 pull_request = relationship('PullRequest', lazy='joined')
3410 pull_request = relationship('PullRequest', lazy='joined')
3411
3411
3412 def __unicode__(self):
3412 def __unicode__(self):
3413 return u"<%s('%s[v%s]:%s')>" % (
3413 return u"<%s('%s[v%s]:%s')>" % (
3414 self.__class__.__name__,
3414 self.__class__.__name__,
3415 self.status, self.version, self.author
3415 self.status, self.version, self.author
3416 )
3416 )
3417
3417
3418 @classmethod
3418 @classmethod
3419 def get_status_lbl(cls, value):
3419 def get_status_lbl(cls, value):
3420 return dict(cls.STATUSES).get(value)
3420 return dict(cls.STATUSES).get(value)
3421
3421
3422 @property
3422 @property
3423 def status_lbl(self):
3423 def status_lbl(self):
3424 return ChangesetStatus.get_status_lbl(self.status)
3424 return ChangesetStatus.get_status_lbl(self.status)
3425
3425
3426 def get_api_data(self):
3426 def get_api_data(self):
3427 status = self
3427 status = self
3428 data = {
3428 data = {
3429 'status_id': status.changeset_status_id,
3429 'status_id': status.changeset_status_id,
3430 'status': status.status,
3430 'status': status.status,
3431 }
3431 }
3432 return data
3432 return data
3433
3433
3434 def __json__(self):
3434 def __json__(self):
3435 data = dict()
3435 data = dict()
3436 data.update(self.get_api_data())
3436 data.update(self.get_api_data())
3437 return data
3437 return data
3438
3438
3439
3439
3440 class _PullRequestBase(BaseModel):
3440 class _PullRequestBase(BaseModel):
3441 """
3441 """
3442 Common attributes of pull request and version entries.
3442 Common attributes of pull request and version entries.
3443 """
3443 """
3444
3444
3445 # .status values
3445 # .status values
3446 STATUS_NEW = u'new'
3446 STATUS_NEW = u'new'
3447 STATUS_OPEN = u'open'
3447 STATUS_OPEN = u'open'
3448 STATUS_CLOSED = u'closed'
3448 STATUS_CLOSED = u'closed'
3449
3449
3450 title = Column('title', Unicode(255), nullable=True)
3450 title = Column('title', Unicode(255), nullable=True)
3451 description = Column(
3451 description = Column(
3452 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
3452 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
3453 nullable=True)
3453 nullable=True)
3454 # new/open/closed status of pull request (not approve/reject/etc)
3454 # new/open/closed status of pull request (not approve/reject/etc)
3455 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3455 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3456 created_on = Column(
3456 created_on = Column(
3457 'created_on', DateTime(timezone=False), nullable=False,
3457 'created_on', DateTime(timezone=False), nullable=False,
3458 default=datetime.datetime.now)
3458 default=datetime.datetime.now)
3459 updated_on = Column(
3459 updated_on = Column(
3460 'updated_on', DateTime(timezone=False), nullable=False,
3460 'updated_on', DateTime(timezone=False), nullable=False,
3461 default=datetime.datetime.now)
3461 default=datetime.datetime.now)
3462
3462
3463 @declared_attr
3463 @declared_attr
3464 def user_id(cls):
3464 def user_id(cls):
3465 return Column(
3465 return Column(
3466 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3466 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3467 unique=None)
3467 unique=None)
3468
3468
3469 # 500 revisions max
3469 # 500 revisions max
3470 _revisions = Column(
3470 _revisions = Column(
3471 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3471 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3472
3472
3473 @declared_attr
3473 @declared_attr
3474 def source_repo_id(cls):
3474 def source_repo_id(cls):
3475 # TODO: dan: rename column to source_repo_id
3475 # TODO: dan: rename column to source_repo_id
3476 return Column(
3476 return Column(
3477 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3477 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3478 nullable=False)
3478 nullable=False)
3479
3479
3480 source_ref = Column('org_ref', Unicode(255), nullable=False)
3480 source_ref = Column('org_ref', Unicode(255), nullable=False)
3481
3481
3482 @declared_attr
3482 @declared_attr
3483 def target_repo_id(cls):
3483 def target_repo_id(cls):
3484 # TODO: dan: rename column to target_repo_id
3484 # TODO: dan: rename column to target_repo_id
3485 return Column(
3485 return Column(
3486 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3486 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3487 nullable=False)
3487 nullable=False)
3488
3488
3489 target_ref = Column('other_ref', Unicode(255), nullable=False)
3489 target_ref = Column('other_ref', Unicode(255), nullable=False)
3490 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3490 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3491
3491
3492 # TODO: dan: rename column to last_merge_source_rev
3492 # TODO: dan: rename column to last_merge_source_rev
3493 _last_merge_source_rev = Column(
3493 _last_merge_source_rev = Column(
3494 'last_merge_org_rev', String(40), nullable=True)
3494 'last_merge_org_rev', String(40), nullable=True)
3495 # TODO: dan: rename column to last_merge_target_rev
3495 # TODO: dan: rename column to last_merge_target_rev
3496 _last_merge_target_rev = Column(
3496 _last_merge_target_rev = Column(
3497 'last_merge_other_rev', String(40), nullable=True)
3497 'last_merge_other_rev', String(40), nullable=True)
3498 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3498 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3499 merge_rev = Column('merge_rev', String(40), nullable=True)
3499 merge_rev = Column('merge_rev', String(40), nullable=True)
3500
3500
3501 reviewer_data = Column(
3501 reviewer_data = Column(
3502 'reviewer_data_json', MutationObj.as_mutable(
3502 'reviewer_data_json', MutationObj.as_mutable(
3503 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3503 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3504
3504
3505 @property
3505 @property
3506 def reviewer_data_json(self):
3506 def reviewer_data_json(self):
3507 return json.dumps(self.reviewer_data)
3507 return json.dumps(self.reviewer_data)
3508
3508
3509 @hybrid_property
3509 @hybrid_property
3510 def description_safe(self):
3510 def description_safe(self):
3511 from rhodecode.lib import helpers as h
3511 from rhodecode.lib import helpers as h
3512 return h.escape(self.description)
3512 return h.escape(self.description)
3513
3513
3514 @hybrid_property
3514 @hybrid_property
3515 def revisions(self):
3515 def revisions(self):
3516 return self._revisions.split(':') if self._revisions else []
3516 return self._revisions.split(':') if self._revisions else []
3517
3517
3518 @revisions.setter
3518 @revisions.setter
3519 def revisions(self, val):
3519 def revisions(self, val):
3520 self._revisions = ':'.join(val)
3520 self._revisions = ':'.join(val)
3521
3521
3522 @hybrid_property
3522 @hybrid_property
3523 def last_merge_status(self):
3523 def last_merge_status(self):
3524 return safe_int(self._last_merge_status)
3524 return safe_int(self._last_merge_status)
3525
3525
3526 @last_merge_status.setter
3526 @last_merge_status.setter
3527 def last_merge_status(self, val):
3527 def last_merge_status(self, val):
3528 self._last_merge_status = val
3528 self._last_merge_status = val
3529
3529
3530 @declared_attr
3530 @declared_attr
3531 def author(cls):
3531 def author(cls):
3532 return relationship('User', lazy='joined')
3532 return relationship('User', lazy='joined')
3533
3533
3534 @declared_attr
3534 @declared_attr
3535 def source_repo(cls):
3535 def source_repo(cls):
3536 return relationship(
3536 return relationship(
3537 'Repository',
3537 'Repository',
3538 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3538 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3539
3539
3540 @property
3540 @property
3541 def source_ref_parts(self):
3541 def source_ref_parts(self):
3542 return self.unicode_to_reference(self.source_ref)
3542 return self.unicode_to_reference(self.source_ref)
3543
3543
3544 @declared_attr
3544 @declared_attr
3545 def target_repo(cls):
3545 def target_repo(cls):
3546 return relationship(
3546 return relationship(
3547 'Repository',
3547 'Repository',
3548 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3548 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3549
3549
3550 @property
3550 @property
3551 def target_ref_parts(self):
3551 def target_ref_parts(self):
3552 return self.unicode_to_reference(self.target_ref)
3552 return self.unicode_to_reference(self.target_ref)
3553
3553
3554 @property
3554 @property
3555 def shadow_merge_ref(self):
3555 def shadow_merge_ref(self):
3556 return self.unicode_to_reference(self._shadow_merge_ref)
3556 return self.unicode_to_reference(self._shadow_merge_ref)
3557
3557
3558 @shadow_merge_ref.setter
3558 @shadow_merge_ref.setter
3559 def shadow_merge_ref(self, ref):
3559 def shadow_merge_ref(self, ref):
3560 self._shadow_merge_ref = self.reference_to_unicode(ref)
3560 self._shadow_merge_ref = self.reference_to_unicode(ref)
3561
3561
3562 def unicode_to_reference(self, raw):
3562 def unicode_to_reference(self, raw):
3563 """
3563 """
3564 Convert a unicode (or string) to a reference object.
3564 Convert a unicode (or string) to a reference object.
3565 If unicode evaluates to False it returns None.
3565 If unicode evaluates to False it returns None.
3566 """
3566 """
3567 if raw:
3567 if raw:
3568 refs = raw.split(':')
3568 refs = raw.split(':')
3569 return Reference(*refs)
3569 return Reference(*refs)
3570 else:
3570 else:
3571 return None
3571 return None
3572
3572
3573 def reference_to_unicode(self, ref):
3573 def reference_to_unicode(self, ref):
3574 """
3574 """
3575 Convert a reference object to unicode.
3575 Convert a reference object to unicode.
3576 If reference is None it returns None.
3576 If reference is None it returns None.
3577 """
3577 """
3578 if ref:
3578 if ref:
3579 return u':'.join(ref)
3579 return u':'.join(ref)
3580 else:
3580 else:
3581 return None
3581 return None
3582
3582
3583 def get_api_data(self, with_merge_state=True):
3583 def get_api_data(self, with_merge_state=True):
3584 from rhodecode.model.pull_request import PullRequestModel
3584 from rhodecode.model.pull_request import PullRequestModel
3585
3585
3586 pull_request = self
3586 pull_request = self
3587 if with_merge_state:
3587 if with_merge_state:
3588 merge_status = PullRequestModel().merge_status(pull_request)
3588 merge_status = PullRequestModel().merge_status(pull_request)
3589 merge_state = {
3589 merge_state = {
3590 'status': merge_status[0],
3590 'status': merge_status[0],
3591 'message': safe_unicode(merge_status[1]),
3591 'message': safe_unicode(merge_status[1]),
3592 }
3592 }
3593 else:
3593 else:
3594 merge_state = {'status': 'not_available',
3594 merge_state = {'status': 'not_available',
3595 'message': 'not_available'}
3595 'message': 'not_available'}
3596
3596
3597 merge_data = {
3597 merge_data = {
3598 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
3598 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
3599 'reference': (
3599 'reference': (
3600 pull_request.shadow_merge_ref._asdict()
3600 pull_request.shadow_merge_ref._asdict()
3601 if pull_request.shadow_merge_ref else None),
3601 if pull_request.shadow_merge_ref else None),
3602 }
3602 }
3603
3603
3604 data = {
3604 data = {
3605 'pull_request_id': pull_request.pull_request_id,
3605 'pull_request_id': pull_request.pull_request_id,
3606 'url': PullRequestModel().get_url(pull_request),
3606 'url': PullRequestModel().get_url(pull_request),
3607 'title': pull_request.title,
3607 'title': pull_request.title,
3608 'description': pull_request.description,
3608 'description': pull_request.description,
3609 'status': pull_request.status,
3609 'status': pull_request.status,
3610 'created_on': pull_request.created_on,
3610 'created_on': pull_request.created_on,
3611 'updated_on': pull_request.updated_on,
3611 'updated_on': pull_request.updated_on,
3612 'commit_ids': pull_request.revisions,
3612 'commit_ids': pull_request.revisions,
3613 'review_status': pull_request.calculated_review_status(),
3613 'review_status': pull_request.calculated_review_status(),
3614 'mergeable': merge_state,
3614 'mergeable': merge_state,
3615 'source': {
3615 'source': {
3616 'clone_url': pull_request.source_repo.clone_url(),
3616 'clone_url': pull_request.source_repo.clone_url(),
3617 'repository': pull_request.source_repo.repo_name,
3617 'repository': pull_request.source_repo.repo_name,
3618 'reference': {
3618 'reference': {
3619 'name': pull_request.source_ref_parts.name,
3619 'name': pull_request.source_ref_parts.name,
3620 'type': pull_request.source_ref_parts.type,
3620 'type': pull_request.source_ref_parts.type,
3621 'commit_id': pull_request.source_ref_parts.commit_id,
3621 'commit_id': pull_request.source_ref_parts.commit_id,
3622 },
3622 },
3623 },
3623 },
3624 'target': {
3624 'target': {
3625 'clone_url': pull_request.target_repo.clone_url(),
3625 'clone_url': pull_request.target_repo.clone_url(),
3626 'repository': pull_request.target_repo.repo_name,
3626 'repository': pull_request.target_repo.repo_name,
3627 'reference': {
3627 'reference': {
3628 'name': pull_request.target_ref_parts.name,
3628 'name': pull_request.target_ref_parts.name,
3629 'type': pull_request.target_ref_parts.type,
3629 'type': pull_request.target_ref_parts.type,
3630 'commit_id': pull_request.target_ref_parts.commit_id,
3630 'commit_id': pull_request.target_ref_parts.commit_id,
3631 },
3631 },
3632 },
3632 },
3633 'merge': merge_data,
3633 'merge': merge_data,
3634 'author': pull_request.author.get_api_data(include_secrets=False,
3634 'author': pull_request.author.get_api_data(include_secrets=False,
3635 details='basic'),
3635 details='basic'),
3636 'reviewers': [
3636 'reviewers': [
3637 {
3637 {
3638 'user': reviewer.get_api_data(include_secrets=False,
3638 'user': reviewer.get_api_data(include_secrets=False,
3639 details='basic'),
3639 details='basic'),
3640 'reasons': reasons,
3640 'reasons': reasons,
3641 'review_status': st[0][1].status if st else 'not_reviewed',
3641 'review_status': st[0][1].status if st else 'not_reviewed',
3642 }
3642 }
3643 for obj, reviewer, reasons, mandatory, st in
3643 for obj, reviewer, reasons, mandatory, st in
3644 pull_request.reviewers_statuses()
3644 pull_request.reviewers_statuses()
3645 ]
3645 ]
3646 }
3646 }
3647
3647
3648 return data
3648 return data
3649
3649
3650
3650
3651 class PullRequest(Base, _PullRequestBase):
3651 class PullRequest(Base, _PullRequestBase):
3652 __tablename__ = 'pull_requests'
3652 __tablename__ = 'pull_requests'
3653 __table_args__ = (
3653 __table_args__ = (
3654 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3654 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3655 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3655 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3656 )
3656 )
3657
3657
3658 pull_request_id = Column(
3658 pull_request_id = Column(
3659 'pull_request_id', Integer(), nullable=False, primary_key=True)
3659 'pull_request_id', Integer(), nullable=False, primary_key=True)
3660
3660
3661 def __repr__(self):
3661 def __repr__(self):
3662 if self.pull_request_id:
3662 if self.pull_request_id:
3663 return '<DB:PullRequest #%s>' % self.pull_request_id
3663 return '<DB:PullRequest #%s>' % self.pull_request_id
3664 else:
3664 else:
3665 return '<DB:PullRequest at %#x>' % id(self)
3665 return '<DB:PullRequest at %#x>' % id(self)
3666
3666
3667 reviewers = relationship('PullRequestReviewers',
3667 reviewers = relationship('PullRequestReviewers',
3668 cascade="all, delete, delete-orphan")
3668 cascade="all, delete, delete-orphan")
3669 statuses = relationship('ChangesetStatus',
3669 statuses = relationship('ChangesetStatus',
3670 cascade="all, delete, delete-orphan")
3670 cascade="all, delete, delete-orphan")
3671 comments = relationship('ChangesetComment',
3671 comments = relationship('ChangesetComment',
3672 cascade="all, delete, delete-orphan")
3672 cascade="all, delete, delete-orphan")
3673 versions = relationship('PullRequestVersion',
3673 versions = relationship('PullRequestVersion',
3674 cascade="all, delete, delete-orphan",
3674 cascade="all, delete, delete-orphan",
3675 lazy='dynamic')
3675 lazy='dynamic')
3676
3676
3677 @classmethod
3677 @classmethod
3678 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
3678 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
3679 internal_methods=None):
3679 internal_methods=None):
3680
3680
3681 class PullRequestDisplay(object):
3681 class PullRequestDisplay(object):
3682 """
3682 """
3683 Special object wrapper for showing PullRequest data via Versions
3683 Special object wrapper for showing PullRequest data via Versions
3684 It mimics PR object as close as possible. This is read only object
3684 It mimics PR object as close as possible. This is read only object
3685 just for display
3685 just for display
3686 """
3686 """
3687
3687
3688 def __init__(self, attrs, internal=None):
3688 def __init__(self, attrs, internal=None):
3689 self.attrs = attrs
3689 self.attrs = attrs
3690 # internal have priority over the given ones via attrs
3690 # internal have priority over the given ones via attrs
3691 self.internal = internal or ['versions']
3691 self.internal = internal or ['versions']
3692
3692
3693 def __getattr__(self, item):
3693 def __getattr__(self, item):
3694 if item in self.internal:
3694 if item in self.internal:
3695 return getattr(self, item)
3695 return getattr(self, item)
3696 try:
3696 try:
3697 return self.attrs[item]
3697 return self.attrs[item]
3698 except KeyError:
3698 except KeyError:
3699 raise AttributeError(
3699 raise AttributeError(
3700 '%s object has no attribute %s' % (self, item))
3700 '%s object has no attribute %s' % (self, item))
3701
3701
3702 def __repr__(self):
3702 def __repr__(self):
3703 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
3703 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
3704
3704
3705 def versions(self):
3705 def versions(self):
3706 return pull_request_obj.versions.order_by(
3706 return pull_request_obj.versions.order_by(
3707 PullRequestVersion.pull_request_version_id).all()
3707 PullRequestVersion.pull_request_version_id).all()
3708
3708
3709 def is_closed(self):
3709 def is_closed(self):
3710 return pull_request_obj.is_closed()
3710 return pull_request_obj.is_closed()
3711
3711
3712 @property
3712 @property
3713 def pull_request_version_id(self):
3713 def pull_request_version_id(self):
3714 return getattr(pull_request_obj, 'pull_request_version_id', None)
3714 return getattr(pull_request_obj, 'pull_request_version_id', None)
3715
3715
3716 attrs = StrictAttributeDict(pull_request_obj.get_api_data())
3716 attrs = StrictAttributeDict(pull_request_obj.get_api_data())
3717
3717
3718 attrs.author = StrictAttributeDict(
3718 attrs.author = StrictAttributeDict(
3719 pull_request_obj.author.get_api_data())
3719 pull_request_obj.author.get_api_data())
3720 if pull_request_obj.target_repo:
3720 if pull_request_obj.target_repo:
3721 attrs.target_repo = StrictAttributeDict(
3721 attrs.target_repo = StrictAttributeDict(
3722 pull_request_obj.target_repo.get_api_data())
3722 pull_request_obj.target_repo.get_api_data())
3723 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
3723 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
3724
3724
3725 if pull_request_obj.source_repo:
3725 if pull_request_obj.source_repo:
3726 attrs.source_repo = StrictAttributeDict(
3726 attrs.source_repo = StrictAttributeDict(
3727 pull_request_obj.source_repo.get_api_data())
3727 pull_request_obj.source_repo.get_api_data())
3728 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
3728 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
3729
3729
3730 attrs.source_ref_parts = pull_request_obj.source_ref_parts
3730 attrs.source_ref_parts = pull_request_obj.source_ref_parts
3731 attrs.target_ref_parts = pull_request_obj.target_ref_parts
3731 attrs.target_ref_parts = pull_request_obj.target_ref_parts
3732 attrs.revisions = pull_request_obj.revisions
3732 attrs.revisions = pull_request_obj.revisions
3733
3733
3734 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
3734 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
3735 attrs.reviewer_data = org_pull_request_obj.reviewer_data
3735 attrs.reviewer_data = org_pull_request_obj.reviewer_data
3736 attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
3736 attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
3737
3737
3738 return PullRequestDisplay(attrs, internal=internal_methods)
3738 return PullRequestDisplay(attrs, internal=internal_methods)
3739
3739
3740 def is_closed(self):
3740 def is_closed(self):
3741 return self.status == self.STATUS_CLOSED
3741 return self.status == self.STATUS_CLOSED
3742
3742
3743 def __json__(self):
3743 def __json__(self):
3744 return {
3744 return {
3745 'revisions': self.revisions,
3745 'revisions': self.revisions,
3746 }
3746 }
3747
3747
3748 def calculated_review_status(self):
3748 def calculated_review_status(self):
3749 from rhodecode.model.changeset_status import ChangesetStatusModel
3749 from rhodecode.model.changeset_status import ChangesetStatusModel
3750 return ChangesetStatusModel().calculated_review_status(self)
3750 return ChangesetStatusModel().calculated_review_status(self)
3751
3751
3752 def reviewers_statuses(self):
3752 def reviewers_statuses(self):
3753 from rhodecode.model.changeset_status import ChangesetStatusModel
3753 from rhodecode.model.changeset_status import ChangesetStatusModel
3754 return ChangesetStatusModel().reviewers_statuses(self)
3754 return ChangesetStatusModel().reviewers_statuses(self)
3755
3755
3756 @property
3756 @property
3757 def workspace_id(self):
3757 def workspace_id(self):
3758 from rhodecode.model.pull_request import PullRequestModel
3758 from rhodecode.model.pull_request import PullRequestModel
3759 return PullRequestModel()._workspace_id(self)
3759 return PullRequestModel()._workspace_id(self)
3760
3760
3761 def get_shadow_repo(self):
3761 def get_shadow_repo(self):
3762 workspace_id = self.workspace_id
3762 workspace_id = self.workspace_id
3763 vcs_obj = self.target_repo.scm_instance()
3763 vcs_obj = self.target_repo.scm_instance()
3764 shadow_repository_path = vcs_obj._get_shadow_repository_path(
3764 shadow_repository_path = vcs_obj._get_shadow_repository_path(
3765 workspace_id)
3765 workspace_id)
3766 if os.path.isdir(shadow_repository_path):
3766 return vcs_obj._get_shadow_instance(shadow_repository_path)
3767 return vcs_obj._get_shadow_instance(shadow_repository_path)
3767
3768
3768
3769
3769 class PullRequestVersion(Base, _PullRequestBase):
3770 class PullRequestVersion(Base, _PullRequestBase):
3770 __tablename__ = 'pull_request_versions'
3771 __tablename__ = 'pull_request_versions'
3771 __table_args__ = (
3772 __table_args__ = (
3772 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3773 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3773 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3774 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3774 )
3775 )
3775
3776
3776 pull_request_version_id = Column(
3777 pull_request_version_id = Column(
3777 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3778 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3778 pull_request_id = Column(
3779 pull_request_id = Column(
3779 'pull_request_id', Integer(),
3780 'pull_request_id', Integer(),
3780 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3781 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3781 pull_request = relationship('PullRequest')
3782 pull_request = relationship('PullRequest')
3782
3783
3783 def __repr__(self):
3784 def __repr__(self):
3784 if self.pull_request_version_id:
3785 if self.pull_request_version_id:
3785 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3786 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3786 else:
3787 else:
3787 return '<DB:PullRequestVersion at %#x>' % id(self)
3788 return '<DB:PullRequestVersion at %#x>' % id(self)
3788
3789
3789 @property
3790 @property
3790 def reviewers(self):
3791 def reviewers(self):
3791 return self.pull_request.reviewers
3792 return self.pull_request.reviewers
3792
3793
3793 @property
3794 @property
3794 def versions(self):
3795 def versions(self):
3795 return self.pull_request.versions
3796 return self.pull_request.versions
3796
3797
3797 def is_closed(self):
3798 def is_closed(self):
3798 # calculate from original
3799 # calculate from original
3799 return self.pull_request.status == self.STATUS_CLOSED
3800 return self.pull_request.status == self.STATUS_CLOSED
3800
3801
3801 def calculated_review_status(self):
3802 def calculated_review_status(self):
3802 return self.pull_request.calculated_review_status()
3803 return self.pull_request.calculated_review_status()
3803
3804
3804 def reviewers_statuses(self):
3805 def reviewers_statuses(self):
3805 return self.pull_request.reviewers_statuses()
3806 return self.pull_request.reviewers_statuses()
3806
3807
3807
3808
3808 class PullRequestReviewers(Base, BaseModel):
3809 class PullRequestReviewers(Base, BaseModel):
3809 __tablename__ = 'pull_request_reviewers'
3810 __tablename__ = 'pull_request_reviewers'
3810 __table_args__ = (
3811 __table_args__ = (
3811 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3812 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3812 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3813 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3813 )
3814 )
3814
3815
3815 @hybrid_property
3816 @hybrid_property
3816 def reasons(self):
3817 def reasons(self):
3817 if not self._reasons:
3818 if not self._reasons:
3818 return []
3819 return []
3819 return self._reasons
3820 return self._reasons
3820
3821
3821 @reasons.setter
3822 @reasons.setter
3822 def reasons(self, val):
3823 def reasons(self, val):
3823 val = val or []
3824 val = val or []
3824 if any(not isinstance(x, basestring) for x in val):
3825 if any(not isinstance(x, basestring) for x in val):
3825 raise Exception('invalid reasons type, must be list of strings')
3826 raise Exception('invalid reasons type, must be list of strings')
3826 self._reasons = val
3827 self._reasons = val
3827
3828
3828 pull_requests_reviewers_id = Column(
3829 pull_requests_reviewers_id = Column(
3829 'pull_requests_reviewers_id', Integer(), nullable=False,
3830 'pull_requests_reviewers_id', Integer(), nullable=False,
3830 primary_key=True)
3831 primary_key=True)
3831 pull_request_id = Column(
3832 pull_request_id = Column(
3832 "pull_request_id", Integer(),
3833 "pull_request_id", Integer(),
3833 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3834 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3834 user_id = Column(
3835 user_id = Column(
3835 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3836 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3836 _reasons = Column(
3837 _reasons = Column(
3837 'reason', MutationList.as_mutable(
3838 'reason', MutationList.as_mutable(
3838 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3839 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3839
3840
3840 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
3841 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
3841 user = relationship('User')
3842 user = relationship('User')
3842 pull_request = relationship('PullRequest')
3843 pull_request = relationship('PullRequest')
3843
3844
3844 rule_data = Column(
3845 rule_data = Column(
3845 'rule_data_json',
3846 'rule_data_json',
3846 JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
3847 JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
3847
3848
3848 def rule_user_group_data(self):
3849 def rule_user_group_data(self):
3849 """
3850 """
3850 Returns the voting user group rule data for this reviewer
3851 Returns the voting user group rule data for this reviewer
3851 """
3852 """
3852
3853
3853 if self.rule_data and 'vote_rule' in self.rule_data:
3854 if self.rule_data and 'vote_rule' in self.rule_data:
3854 user_group_data = {}
3855 user_group_data = {}
3855 if 'rule_user_group_entry_id' in self.rule_data:
3856 if 'rule_user_group_entry_id' in self.rule_data:
3856 # means a group with voting rules !
3857 # means a group with voting rules !
3857 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
3858 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
3858 user_group_data['name'] = self.rule_data['rule_name']
3859 user_group_data['name'] = self.rule_data['rule_name']
3859 user_group_data['vote_rule'] = self.rule_data['vote_rule']
3860 user_group_data['vote_rule'] = self.rule_data['vote_rule']
3860
3861
3861 return user_group_data
3862 return user_group_data
3862
3863
3863 def __unicode__(self):
3864 def __unicode__(self):
3864 return u"<%s('id:%s')>" % (self.__class__.__name__,
3865 return u"<%s('id:%s')>" % (self.__class__.__name__,
3865 self.pull_requests_reviewers_id)
3866 self.pull_requests_reviewers_id)
3866
3867
3867
3868
3868 class Notification(Base, BaseModel):
3869 class Notification(Base, BaseModel):
3869 __tablename__ = 'notifications'
3870 __tablename__ = 'notifications'
3870 __table_args__ = (
3871 __table_args__ = (
3871 Index('notification_type_idx', 'type'),
3872 Index('notification_type_idx', 'type'),
3872 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3873 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3873 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3874 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3874 )
3875 )
3875
3876
3876 TYPE_CHANGESET_COMMENT = u'cs_comment'
3877 TYPE_CHANGESET_COMMENT = u'cs_comment'
3877 TYPE_MESSAGE = u'message'
3878 TYPE_MESSAGE = u'message'
3878 TYPE_MENTION = u'mention'
3879 TYPE_MENTION = u'mention'
3879 TYPE_REGISTRATION = u'registration'
3880 TYPE_REGISTRATION = u'registration'
3880 TYPE_PULL_REQUEST = u'pull_request'
3881 TYPE_PULL_REQUEST = u'pull_request'
3881 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3882 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3882
3883
3883 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3884 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3884 subject = Column('subject', Unicode(512), nullable=True)
3885 subject = Column('subject', Unicode(512), nullable=True)
3885 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3886 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3886 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3887 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3887 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3888 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3888 type_ = Column('type', Unicode(255))
3889 type_ = Column('type', Unicode(255))
3889
3890
3890 created_by_user = relationship('User')
3891 created_by_user = relationship('User')
3891 notifications_to_users = relationship('UserNotification', lazy='joined',
3892 notifications_to_users = relationship('UserNotification', lazy='joined',
3892 cascade="all, delete, delete-orphan")
3893 cascade="all, delete, delete-orphan")
3893
3894
3894 @property
3895 @property
3895 def recipients(self):
3896 def recipients(self):
3896 return [x.user for x in UserNotification.query()\
3897 return [x.user for x in UserNotification.query()\
3897 .filter(UserNotification.notification == self)\
3898 .filter(UserNotification.notification == self)\
3898 .order_by(UserNotification.user_id.asc()).all()]
3899 .order_by(UserNotification.user_id.asc()).all()]
3899
3900
3900 @classmethod
3901 @classmethod
3901 def create(cls, created_by, subject, body, recipients, type_=None):
3902 def create(cls, created_by, subject, body, recipients, type_=None):
3902 if type_ is None:
3903 if type_ is None:
3903 type_ = Notification.TYPE_MESSAGE
3904 type_ = Notification.TYPE_MESSAGE
3904
3905
3905 notification = cls()
3906 notification = cls()
3906 notification.created_by_user = created_by
3907 notification.created_by_user = created_by
3907 notification.subject = subject
3908 notification.subject = subject
3908 notification.body = body
3909 notification.body = body
3909 notification.type_ = type_
3910 notification.type_ = type_
3910 notification.created_on = datetime.datetime.now()
3911 notification.created_on = datetime.datetime.now()
3911
3912
3912 for u in recipients:
3913 for u in recipients:
3913 assoc = UserNotification()
3914 assoc = UserNotification()
3914 assoc.notification = notification
3915 assoc.notification = notification
3915
3916
3916 # if created_by is inside recipients mark his notification
3917 # if created_by is inside recipients mark his notification
3917 # as read
3918 # as read
3918 if u.user_id == created_by.user_id:
3919 if u.user_id == created_by.user_id:
3919 assoc.read = True
3920 assoc.read = True
3920
3921
3921 u.notifications.append(assoc)
3922 u.notifications.append(assoc)
3922 Session().add(notification)
3923 Session().add(notification)
3923
3924
3924 return notification
3925 return notification
3925
3926
3926
3927
3927 class UserNotification(Base, BaseModel):
3928 class UserNotification(Base, BaseModel):
3928 __tablename__ = 'user_to_notification'
3929 __tablename__ = 'user_to_notification'
3929 __table_args__ = (
3930 __table_args__ = (
3930 UniqueConstraint('user_id', 'notification_id'),
3931 UniqueConstraint('user_id', 'notification_id'),
3931 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3932 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3932 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3933 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3933 )
3934 )
3934 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3935 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3935 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3936 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3936 read = Column('read', Boolean, default=False)
3937 read = Column('read', Boolean, default=False)
3937 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3938 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3938
3939
3939 user = relationship('User', lazy="joined")
3940 user = relationship('User', lazy="joined")
3940 notification = relationship('Notification', lazy="joined",
3941 notification = relationship('Notification', lazy="joined",
3941 order_by=lambda: Notification.created_on.desc(),)
3942 order_by=lambda: Notification.created_on.desc(),)
3942
3943
3943 def mark_as_read(self):
3944 def mark_as_read(self):
3944 self.read = True
3945 self.read = True
3945 Session().add(self)
3946 Session().add(self)
3946
3947
3947
3948
3948 class Gist(Base, BaseModel):
3949 class Gist(Base, BaseModel):
3949 __tablename__ = 'gists'
3950 __tablename__ = 'gists'
3950 __table_args__ = (
3951 __table_args__ = (
3951 Index('g_gist_access_id_idx', 'gist_access_id'),
3952 Index('g_gist_access_id_idx', 'gist_access_id'),
3952 Index('g_created_on_idx', 'created_on'),
3953 Index('g_created_on_idx', 'created_on'),
3953 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3954 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3954 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3955 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3955 )
3956 )
3956 GIST_PUBLIC = u'public'
3957 GIST_PUBLIC = u'public'
3957 GIST_PRIVATE = u'private'
3958 GIST_PRIVATE = u'private'
3958 DEFAULT_FILENAME = u'gistfile1.txt'
3959 DEFAULT_FILENAME = u'gistfile1.txt'
3959
3960
3960 ACL_LEVEL_PUBLIC = u'acl_public'
3961 ACL_LEVEL_PUBLIC = u'acl_public'
3961 ACL_LEVEL_PRIVATE = u'acl_private'
3962 ACL_LEVEL_PRIVATE = u'acl_private'
3962
3963
3963 gist_id = Column('gist_id', Integer(), primary_key=True)
3964 gist_id = Column('gist_id', Integer(), primary_key=True)
3964 gist_access_id = Column('gist_access_id', Unicode(250))
3965 gist_access_id = Column('gist_access_id', Unicode(250))
3965 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3966 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3966 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3967 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3967 gist_expires = Column('gist_expires', Float(53), nullable=False)
3968 gist_expires = Column('gist_expires', Float(53), nullable=False)
3968 gist_type = Column('gist_type', Unicode(128), nullable=False)
3969 gist_type = Column('gist_type', Unicode(128), nullable=False)
3969 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3970 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3970 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3971 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3971 acl_level = Column('acl_level', Unicode(128), nullable=True)
3972 acl_level = Column('acl_level', Unicode(128), nullable=True)
3972
3973
3973 owner = relationship('User')
3974 owner = relationship('User')
3974
3975
3975 def __repr__(self):
3976 def __repr__(self):
3976 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3977 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3977
3978
3978 @hybrid_property
3979 @hybrid_property
3979 def description_safe(self):
3980 def description_safe(self):
3980 from rhodecode.lib import helpers as h
3981 from rhodecode.lib import helpers as h
3981 return h.escape(self.gist_description)
3982 return h.escape(self.gist_description)
3982
3983
3983 @classmethod
3984 @classmethod
3984 def get_or_404(cls, id_):
3985 def get_or_404(cls, id_):
3985 from pyramid.httpexceptions import HTTPNotFound
3986 from pyramid.httpexceptions import HTTPNotFound
3986
3987
3987 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3988 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3988 if not res:
3989 if not res:
3989 raise HTTPNotFound()
3990 raise HTTPNotFound()
3990 return res
3991 return res
3991
3992
3992 @classmethod
3993 @classmethod
3993 def get_by_access_id(cls, gist_access_id):
3994 def get_by_access_id(cls, gist_access_id):
3994 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3995 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3995
3996
3996 def gist_url(self):
3997 def gist_url(self):
3997 from rhodecode.model.gist import GistModel
3998 from rhodecode.model.gist import GistModel
3998 return GistModel().get_url(self)
3999 return GistModel().get_url(self)
3999
4000
4000 @classmethod
4001 @classmethod
4001 def base_path(cls):
4002 def base_path(cls):
4002 """
4003 """
4003 Returns base path when all gists are stored
4004 Returns base path when all gists are stored
4004
4005
4005 :param cls:
4006 :param cls:
4006 """
4007 """
4007 from rhodecode.model.gist import GIST_STORE_LOC
4008 from rhodecode.model.gist import GIST_STORE_LOC
4008 q = Session().query(RhodeCodeUi)\
4009 q = Session().query(RhodeCodeUi)\
4009 .filter(RhodeCodeUi.ui_key == URL_SEP)
4010 .filter(RhodeCodeUi.ui_key == URL_SEP)
4010 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
4011 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
4011 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
4012 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
4012
4013
4013 def get_api_data(self):
4014 def get_api_data(self):
4014 """
4015 """
4015 Common function for generating gist related data for API
4016 Common function for generating gist related data for API
4016 """
4017 """
4017 gist = self
4018 gist = self
4018 data = {
4019 data = {
4019 'gist_id': gist.gist_id,
4020 'gist_id': gist.gist_id,
4020 'type': gist.gist_type,
4021 'type': gist.gist_type,
4021 'access_id': gist.gist_access_id,
4022 'access_id': gist.gist_access_id,
4022 'description': gist.gist_description,
4023 'description': gist.gist_description,
4023 'url': gist.gist_url(),
4024 'url': gist.gist_url(),
4024 'expires': gist.gist_expires,
4025 'expires': gist.gist_expires,
4025 'created_on': gist.created_on,
4026 'created_on': gist.created_on,
4026 'modified_at': gist.modified_at,
4027 'modified_at': gist.modified_at,
4027 'content': None,
4028 'content': None,
4028 'acl_level': gist.acl_level,
4029 'acl_level': gist.acl_level,
4029 }
4030 }
4030 return data
4031 return data
4031
4032
4032 def __json__(self):
4033 def __json__(self):
4033 data = dict(
4034 data = dict(
4034 )
4035 )
4035 data.update(self.get_api_data())
4036 data.update(self.get_api_data())
4036 return data
4037 return data
4037 # SCM functions
4038 # SCM functions
4038
4039
4039 def scm_instance(self, **kwargs):
4040 def scm_instance(self, **kwargs):
4040 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
4041 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
4041 return get_vcs_instance(
4042 return get_vcs_instance(
4042 repo_path=safe_str(full_repo_path), create=False)
4043 repo_path=safe_str(full_repo_path), create=False)
4043
4044
4044
4045
4045 class ExternalIdentity(Base, BaseModel):
4046 class ExternalIdentity(Base, BaseModel):
4046 __tablename__ = 'external_identities'
4047 __tablename__ = 'external_identities'
4047 __table_args__ = (
4048 __table_args__ = (
4048 Index('local_user_id_idx', 'local_user_id'),
4049 Index('local_user_id_idx', 'local_user_id'),
4049 Index('external_id_idx', 'external_id'),
4050 Index('external_id_idx', 'external_id'),
4050 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4051 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4051 'mysql_charset': 'utf8'})
4052 'mysql_charset': 'utf8'})
4052
4053
4053 external_id = Column('external_id', Unicode(255), default=u'',
4054 external_id = Column('external_id', Unicode(255), default=u'',
4054 primary_key=True)
4055 primary_key=True)
4055 external_username = Column('external_username', Unicode(1024), default=u'')
4056 external_username = Column('external_username', Unicode(1024), default=u'')
4056 local_user_id = Column('local_user_id', Integer(),
4057 local_user_id = Column('local_user_id', Integer(),
4057 ForeignKey('users.user_id'), primary_key=True)
4058 ForeignKey('users.user_id'), primary_key=True)
4058 provider_name = Column('provider_name', Unicode(255), default=u'',
4059 provider_name = Column('provider_name', Unicode(255), default=u'',
4059 primary_key=True)
4060 primary_key=True)
4060 access_token = Column('access_token', String(1024), default=u'')
4061 access_token = Column('access_token', String(1024), default=u'')
4061 alt_token = Column('alt_token', String(1024), default=u'')
4062 alt_token = Column('alt_token', String(1024), default=u'')
4062 token_secret = Column('token_secret', String(1024), default=u'')
4063 token_secret = Column('token_secret', String(1024), default=u'')
4063
4064
4064 @classmethod
4065 @classmethod
4065 def by_external_id_and_provider(cls, external_id, provider_name,
4066 def by_external_id_and_provider(cls, external_id, provider_name,
4066 local_user_id=None):
4067 local_user_id=None):
4067 """
4068 """
4068 Returns ExternalIdentity instance based on search params
4069 Returns ExternalIdentity instance based on search params
4069
4070
4070 :param external_id:
4071 :param external_id:
4071 :param provider_name:
4072 :param provider_name:
4072 :return: ExternalIdentity
4073 :return: ExternalIdentity
4073 """
4074 """
4074 query = cls.query()
4075 query = cls.query()
4075 query = query.filter(cls.external_id == external_id)
4076 query = query.filter(cls.external_id == external_id)
4076 query = query.filter(cls.provider_name == provider_name)
4077 query = query.filter(cls.provider_name == provider_name)
4077 if local_user_id:
4078 if local_user_id:
4078 query = query.filter(cls.local_user_id == local_user_id)
4079 query = query.filter(cls.local_user_id == local_user_id)
4079 return query.first()
4080 return query.first()
4080
4081
4081 @classmethod
4082 @classmethod
4082 def user_by_external_id_and_provider(cls, external_id, provider_name):
4083 def user_by_external_id_and_provider(cls, external_id, provider_name):
4083 """
4084 """
4084 Returns User instance based on search params
4085 Returns User instance based on search params
4085
4086
4086 :param external_id:
4087 :param external_id:
4087 :param provider_name:
4088 :param provider_name:
4088 :return: User
4089 :return: User
4089 """
4090 """
4090 query = User.query()
4091 query = User.query()
4091 query = query.filter(cls.external_id == external_id)
4092 query = query.filter(cls.external_id == external_id)
4092 query = query.filter(cls.provider_name == provider_name)
4093 query = query.filter(cls.provider_name == provider_name)
4093 query = query.filter(User.user_id == cls.local_user_id)
4094 query = query.filter(User.user_id == cls.local_user_id)
4094 return query.first()
4095 return query.first()
4095
4096
4096 @classmethod
4097 @classmethod
4097 def by_local_user_id(cls, local_user_id):
4098 def by_local_user_id(cls, local_user_id):
4098 """
4099 """
4099 Returns all tokens for user
4100 Returns all tokens for user
4100
4101
4101 :param local_user_id:
4102 :param local_user_id:
4102 :return: ExternalIdentity
4103 :return: ExternalIdentity
4103 """
4104 """
4104 query = cls.query()
4105 query = cls.query()
4105 query = query.filter(cls.local_user_id == local_user_id)
4106 query = query.filter(cls.local_user_id == local_user_id)
4106 return query
4107 return query
4107
4108
4108
4109
4109 class Integration(Base, BaseModel):
4110 class Integration(Base, BaseModel):
4110 __tablename__ = 'integrations'
4111 __tablename__ = 'integrations'
4111 __table_args__ = (
4112 __table_args__ = (
4112 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4113 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4113 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
4114 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
4114 )
4115 )
4115
4116
4116 integration_id = Column('integration_id', Integer(), primary_key=True)
4117 integration_id = Column('integration_id', Integer(), primary_key=True)
4117 integration_type = Column('integration_type', String(255))
4118 integration_type = Column('integration_type', String(255))
4118 enabled = Column('enabled', Boolean(), nullable=False)
4119 enabled = Column('enabled', Boolean(), nullable=False)
4119 name = Column('name', String(255), nullable=False)
4120 name = Column('name', String(255), nullable=False)
4120 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
4121 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
4121 default=False)
4122 default=False)
4122
4123
4123 settings = Column(
4124 settings = Column(
4124 'settings_json', MutationObj.as_mutable(
4125 'settings_json', MutationObj.as_mutable(
4125 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4126 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4126 repo_id = Column(
4127 repo_id = Column(
4127 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
4128 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
4128 nullable=True, unique=None, default=None)
4129 nullable=True, unique=None, default=None)
4129 repo = relationship('Repository', lazy='joined')
4130 repo = relationship('Repository', lazy='joined')
4130
4131
4131 repo_group_id = Column(
4132 repo_group_id = Column(
4132 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
4133 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
4133 nullable=True, unique=None, default=None)
4134 nullable=True, unique=None, default=None)
4134 repo_group = relationship('RepoGroup', lazy='joined')
4135 repo_group = relationship('RepoGroup', lazy='joined')
4135
4136
4136 @property
4137 @property
4137 def scope(self):
4138 def scope(self):
4138 if self.repo:
4139 if self.repo:
4139 return repr(self.repo)
4140 return repr(self.repo)
4140 if self.repo_group:
4141 if self.repo_group:
4141 if self.child_repos_only:
4142 if self.child_repos_only:
4142 return repr(self.repo_group) + ' (child repos only)'
4143 return repr(self.repo_group) + ' (child repos only)'
4143 else:
4144 else:
4144 return repr(self.repo_group) + ' (recursive)'
4145 return repr(self.repo_group) + ' (recursive)'
4145 if self.child_repos_only:
4146 if self.child_repos_only:
4146 return 'root_repos'
4147 return 'root_repos'
4147 return 'global'
4148 return 'global'
4148
4149
4149 def __repr__(self):
4150 def __repr__(self):
4150 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
4151 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
4151
4152
4152
4153
4153 class RepoReviewRuleUser(Base, BaseModel):
4154 class RepoReviewRuleUser(Base, BaseModel):
4154 __tablename__ = 'repo_review_rules_users'
4155 __tablename__ = 'repo_review_rules_users'
4155 __table_args__ = (
4156 __table_args__ = (
4156 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4157 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4157 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4158 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4158 )
4159 )
4159
4160
4160 repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
4161 repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
4161 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4162 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4162 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
4163 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
4163 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4164 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4164 user = relationship('User')
4165 user = relationship('User')
4165
4166
4166 def rule_data(self):
4167 def rule_data(self):
4167 return {
4168 return {
4168 'mandatory': self.mandatory
4169 'mandatory': self.mandatory
4169 }
4170 }
4170
4171
4171
4172
4172 class RepoReviewRuleUserGroup(Base, BaseModel):
4173 class RepoReviewRuleUserGroup(Base, BaseModel):
4173 __tablename__ = 'repo_review_rules_users_groups'
4174 __tablename__ = 'repo_review_rules_users_groups'
4174 __table_args__ = (
4175 __table_args__ = (
4175 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4176 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4176 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4177 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4177 )
4178 )
4178 VOTE_RULE_ALL = -1
4179 VOTE_RULE_ALL = -1
4179
4180
4180 repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
4181 repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
4181 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4182 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4182 users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
4183 users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
4183 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4184 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4184 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
4185 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
4185 users_group = relationship('UserGroup')
4186 users_group = relationship('UserGroup')
4186
4187
4187 def rule_data(self):
4188 def rule_data(self):
4188 return {
4189 return {
4189 'mandatory': self.mandatory,
4190 'mandatory': self.mandatory,
4190 'vote_rule': self.vote_rule
4191 'vote_rule': self.vote_rule
4191 }
4192 }
4192
4193
4193 @property
4194 @property
4194 def vote_rule_label(self):
4195 def vote_rule_label(self):
4195 if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
4196 if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
4196 return 'all must vote'
4197 return 'all must vote'
4197 else:
4198 else:
4198 return 'min. vote {}'.format(self.vote_rule)
4199 return 'min. vote {}'.format(self.vote_rule)
4199
4200
4200
4201
4201 class RepoReviewRule(Base, BaseModel):
4202 class RepoReviewRule(Base, BaseModel):
4202 __tablename__ = 'repo_review_rules'
4203 __tablename__ = 'repo_review_rules'
4203 __table_args__ = (
4204 __table_args__ = (
4204 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4205 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4205 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4206 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4206 )
4207 )
4207
4208
4208 repo_review_rule_id = Column(
4209 repo_review_rule_id = Column(
4209 'repo_review_rule_id', Integer(), primary_key=True)
4210 'repo_review_rule_id', Integer(), primary_key=True)
4210 repo_id = Column(
4211 repo_id = Column(
4211 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
4212 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
4212 repo = relationship('Repository', backref='review_rules')
4213 repo = relationship('Repository', backref='review_rules')
4213
4214
4214 review_rule_name = Column('review_rule_name', String(255))
4215 review_rule_name = Column('review_rule_name', String(255))
4215 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4216 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4216 _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4217 _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4217 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4218 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4218
4219
4219 use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
4220 use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
4220 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
4221 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
4221 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
4222 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
4222 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
4223 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
4223
4224
4224 rule_users = relationship('RepoReviewRuleUser')
4225 rule_users = relationship('RepoReviewRuleUser')
4225 rule_user_groups = relationship('RepoReviewRuleUserGroup')
4226 rule_user_groups = relationship('RepoReviewRuleUserGroup')
4226
4227
4227 def _validate_glob(self, value):
4228 def _validate_glob(self, value):
4228 re.compile('^' + glob2re(value) + '$')
4229 re.compile('^' + glob2re(value) + '$')
4229
4230
4230 @hybrid_property
4231 @hybrid_property
4231 def source_branch_pattern(self):
4232 def source_branch_pattern(self):
4232 return self._branch_pattern or '*'
4233 return self._branch_pattern or '*'
4233
4234
4234 @source_branch_pattern.setter
4235 @source_branch_pattern.setter
4235 def source_branch_pattern(self, value):
4236 def source_branch_pattern(self, value):
4236 self._validate_glob(value)
4237 self._validate_glob(value)
4237 self._branch_pattern = value or '*'
4238 self._branch_pattern = value or '*'
4238
4239
4239 @hybrid_property
4240 @hybrid_property
4240 def target_branch_pattern(self):
4241 def target_branch_pattern(self):
4241 return self._target_branch_pattern or '*'
4242 return self._target_branch_pattern or '*'
4242
4243
4243 @target_branch_pattern.setter
4244 @target_branch_pattern.setter
4244 def target_branch_pattern(self, value):
4245 def target_branch_pattern(self, value):
4245 self._validate_glob(value)
4246 self._validate_glob(value)
4246 self._target_branch_pattern = value or '*'
4247 self._target_branch_pattern = value or '*'
4247
4248
4248 @hybrid_property
4249 @hybrid_property
4249 def file_pattern(self):
4250 def file_pattern(self):
4250 return self._file_pattern or '*'
4251 return self._file_pattern or '*'
4251
4252
4252 @file_pattern.setter
4253 @file_pattern.setter
4253 def file_pattern(self, value):
4254 def file_pattern(self, value):
4254 self._validate_glob(value)
4255 self._validate_glob(value)
4255 self._file_pattern = value or '*'
4256 self._file_pattern = value or '*'
4256
4257
4257 def matches(self, source_branch, target_branch, files_changed):
4258 def matches(self, source_branch, target_branch, files_changed):
4258 """
4259 """
4259 Check if this review rule matches a branch/files in a pull request
4260 Check if this review rule matches a branch/files in a pull request
4260
4261
4261 :param source_branch: source branch name for the commit
4262 :param source_branch: source branch name for the commit
4262 :param target_branch: target branch name for the commit
4263 :param target_branch: target branch name for the commit
4263 :param files_changed: list of file paths changed in the pull request
4264 :param files_changed: list of file paths changed in the pull request
4264 """
4265 """
4265
4266
4266 source_branch = source_branch or ''
4267 source_branch = source_branch or ''
4267 target_branch = target_branch or ''
4268 target_branch = target_branch or ''
4268 files_changed = files_changed or []
4269 files_changed = files_changed or []
4269
4270
4270 branch_matches = True
4271 branch_matches = True
4271 if source_branch or target_branch:
4272 if source_branch or target_branch:
4272 if self.source_branch_pattern == '*':
4273 if self.source_branch_pattern == '*':
4273 source_branch_match = True
4274 source_branch_match = True
4274 else:
4275 else:
4275 source_branch_regex = re.compile(
4276 source_branch_regex = re.compile(
4276 '^' + glob2re(self.source_branch_pattern) + '$')
4277 '^' + glob2re(self.source_branch_pattern) + '$')
4277 source_branch_match = bool(source_branch_regex.search(source_branch))
4278 source_branch_match = bool(source_branch_regex.search(source_branch))
4278 if self.target_branch_pattern == '*':
4279 if self.target_branch_pattern == '*':
4279 target_branch_match = True
4280 target_branch_match = True
4280 else:
4281 else:
4281 target_branch_regex = re.compile(
4282 target_branch_regex = re.compile(
4282 '^' + glob2re(self.target_branch_pattern) + '$')
4283 '^' + glob2re(self.target_branch_pattern) + '$')
4283 target_branch_match = bool(target_branch_regex.search(target_branch))
4284 target_branch_match = bool(target_branch_regex.search(target_branch))
4284
4285
4285 branch_matches = source_branch_match and target_branch_match
4286 branch_matches = source_branch_match and target_branch_match
4286
4287
4287 files_matches = True
4288 files_matches = True
4288 if self.file_pattern != '*':
4289 if self.file_pattern != '*':
4289 files_matches = False
4290 files_matches = False
4290 file_regex = re.compile(glob2re(self.file_pattern))
4291 file_regex = re.compile(glob2re(self.file_pattern))
4291 for filename in files_changed:
4292 for filename in files_changed:
4292 if file_regex.search(filename):
4293 if file_regex.search(filename):
4293 files_matches = True
4294 files_matches = True
4294 break
4295 break
4295
4296
4296 return branch_matches and files_matches
4297 return branch_matches and files_matches
4297
4298
4298 @property
4299 @property
4299 def review_users(self):
4300 def review_users(self):
4300 """ Returns the users which this rule applies to """
4301 """ Returns the users which this rule applies to """
4301
4302
4302 users = collections.OrderedDict()
4303 users = collections.OrderedDict()
4303
4304
4304 for rule_user in self.rule_users:
4305 for rule_user in self.rule_users:
4305 if rule_user.user.active:
4306 if rule_user.user.active:
4306 if rule_user.user not in users:
4307 if rule_user.user not in users:
4307 users[rule_user.user.username] = {
4308 users[rule_user.user.username] = {
4308 'user': rule_user.user,
4309 'user': rule_user.user,
4309 'source': 'user',
4310 'source': 'user',
4310 'source_data': {},
4311 'source_data': {},
4311 'data': rule_user.rule_data()
4312 'data': rule_user.rule_data()
4312 }
4313 }
4313
4314
4314 for rule_user_group in self.rule_user_groups:
4315 for rule_user_group in self.rule_user_groups:
4315 source_data = {
4316 source_data = {
4316 'user_group_id': rule_user_group.users_group.users_group_id,
4317 'user_group_id': rule_user_group.users_group.users_group_id,
4317 'name': rule_user_group.users_group.users_group_name,
4318 'name': rule_user_group.users_group.users_group_name,
4318 'members': len(rule_user_group.users_group.members)
4319 'members': len(rule_user_group.users_group.members)
4319 }
4320 }
4320 for member in rule_user_group.users_group.members:
4321 for member in rule_user_group.users_group.members:
4321 if member.user.active:
4322 if member.user.active:
4322 key = member.user.username
4323 key = member.user.username
4323 if key in users:
4324 if key in users:
4324 # skip this member as we have him already
4325 # skip this member as we have him already
4325 # this prevents from override the "first" matched
4326 # this prevents from override the "first" matched
4326 # users with duplicates in multiple groups
4327 # users with duplicates in multiple groups
4327 continue
4328 continue
4328
4329
4329 users[key] = {
4330 users[key] = {
4330 'user': member.user,
4331 'user': member.user,
4331 'source': 'user_group',
4332 'source': 'user_group',
4332 'source_data': source_data,
4333 'source_data': source_data,
4333 'data': rule_user_group.rule_data()
4334 'data': rule_user_group.rule_data()
4334 }
4335 }
4335
4336
4336 return users
4337 return users
4337
4338
4338 def user_group_vote_rule(self):
4339 def user_group_vote_rule(self):
4339 rules = []
4340 rules = []
4340 if self.rule_user_groups:
4341 if self.rule_user_groups:
4341 for user_group in self.rule_user_groups:
4342 for user_group in self.rule_user_groups:
4342 rules.append(user_group)
4343 rules.append(user_group)
4343 return rules
4344 return rules
4344
4345
4345 def __repr__(self):
4346 def __repr__(self):
4346 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
4347 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
4347 self.repo_review_rule_id, self.repo)
4348 self.repo_review_rule_id, self.repo)
4348
4349
4349
4350
4350 class ScheduleEntry(Base, BaseModel):
4351 class ScheduleEntry(Base, BaseModel):
4351 __tablename__ = 'schedule_entries'
4352 __tablename__ = 'schedule_entries'
4352 __table_args__ = (
4353 __table_args__ = (
4353 UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
4354 UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
4354 UniqueConstraint('task_uid', name='s_task_uid_idx'),
4355 UniqueConstraint('task_uid', name='s_task_uid_idx'),
4355 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4356 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4356 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4357 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4357 )
4358 )
4358 schedule_types = ['crontab', 'timedelta', 'integer']
4359 schedule_types = ['crontab', 'timedelta', 'integer']
4359 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
4360 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
4360
4361
4361 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
4362 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
4362 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
4363 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
4363 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
4364 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
4364
4365
4365 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
4366 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
4366 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
4367 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
4367
4368
4368 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
4369 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
4369 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
4370 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
4370
4371
4371 # task
4372 # task
4372 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
4373 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
4373 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
4374 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
4374 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
4375 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
4375 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
4376 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
4376
4377
4377 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4378 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4378 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
4379 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
4379
4380
4380 @hybrid_property
4381 @hybrid_property
4381 def schedule_type(self):
4382 def schedule_type(self):
4382 return self._schedule_type
4383 return self._schedule_type
4383
4384
4384 @schedule_type.setter
4385 @schedule_type.setter
4385 def schedule_type(self, val):
4386 def schedule_type(self, val):
4386 if val not in self.schedule_types:
4387 if val not in self.schedule_types:
4387 raise ValueError('Value must be on of `{}` and got `{}`'.format(
4388 raise ValueError('Value must be on of `{}` and got `{}`'.format(
4388 val, self.schedule_type))
4389 val, self.schedule_type))
4389
4390
4390 self._schedule_type = val
4391 self._schedule_type = val
4391
4392
4392 @classmethod
4393 @classmethod
4393 def get_uid(cls, obj):
4394 def get_uid(cls, obj):
4394 args = obj.task_args
4395 args = obj.task_args
4395 kwargs = obj.task_kwargs
4396 kwargs = obj.task_kwargs
4396 if isinstance(args, JsonRaw):
4397 if isinstance(args, JsonRaw):
4397 try:
4398 try:
4398 args = json.loads(args)
4399 args = json.loads(args)
4399 except ValueError:
4400 except ValueError:
4400 args = tuple()
4401 args = tuple()
4401
4402
4402 if isinstance(kwargs, JsonRaw):
4403 if isinstance(kwargs, JsonRaw):
4403 try:
4404 try:
4404 kwargs = json.loads(kwargs)
4405 kwargs = json.loads(kwargs)
4405 except ValueError:
4406 except ValueError:
4406 kwargs = dict()
4407 kwargs = dict()
4407
4408
4408 dot_notation = obj.task_dot_notation
4409 dot_notation = obj.task_dot_notation
4409 val = '.'.join(map(safe_str, [
4410 val = '.'.join(map(safe_str, [
4410 sorted(dot_notation), args, sorted(kwargs.items())]))
4411 sorted(dot_notation), args, sorted(kwargs.items())]))
4411 return hashlib.sha1(val).hexdigest()
4412 return hashlib.sha1(val).hexdigest()
4412
4413
4413 @classmethod
4414 @classmethod
4414 def get_by_schedule_name(cls, schedule_name):
4415 def get_by_schedule_name(cls, schedule_name):
4415 return cls.query().filter(cls.schedule_name == schedule_name).scalar()
4416 return cls.query().filter(cls.schedule_name == schedule_name).scalar()
4416
4417
4417 @classmethod
4418 @classmethod
4418 def get_by_schedule_id(cls, schedule_id):
4419 def get_by_schedule_id(cls, schedule_id):
4419 return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
4420 return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
4420
4421
4421 @property
4422 @property
4422 def task(self):
4423 def task(self):
4423 return self.task_dot_notation
4424 return self.task_dot_notation
4424
4425
4425 @property
4426 @property
4426 def schedule(self):
4427 def schedule(self):
4427 from rhodecode.lib.celerylib.utils import raw_2_schedule
4428 from rhodecode.lib.celerylib.utils import raw_2_schedule
4428 schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
4429 schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
4429 return schedule
4430 return schedule
4430
4431
4431 @property
4432 @property
4432 def args(self):
4433 def args(self):
4433 try:
4434 try:
4434 return list(self.task_args or [])
4435 return list(self.task_args or [])
4435 except ValueError:
4436 except ValueError:
4436 return list()
4437 return list()
4437
4438
4438 @property
4439 @property
4439 def kwargs(self):
4440 def kwargs(self):
4440 try:
4441 try:
4441 return dict(self.task_kwargs or {})
4442 return dict(self.task_kwargs or {})
4442 except ValueError:
4443 except ValueError:
4443 return dict()
4444 return dict()
4444
4445
4445 def _as_raw(self, val):
4446 def _as_raw(self, val):
4446 if hasattr(val, 'de_coerce'):
4447 if hasattr(val, 'de_coerce'):
4447 val = val.de_coerce()
4448 val = val.de_coerce()
4448 if val:
4449 if val:
4449 val = json.dumps(val)
4450 val = json.dumps(val)
4450
4451
4451 return val
4452 return val
4452
4453
4453 @property
4454 @property
4454 def schedule_definition_raw(self):
4455 def schedule_definition_raw(self):
4455 return self._as_raw(self.schedule_definition)
4456 return self._as_raw(self.schedule_definition)
4456
4457
4457 @property
4458 @property
4458 def args_raw(self):
4459 def args_raw(self):
4459 return self._as_raw(self.task_args)
4460 return self._as_raw(self.task_args)
4460
4461
4461 @property
4462 @property
4462 def kwargs_raw(self):
4463 def kwargs_raw(self):
4463 return self._as_raw(self.task_kwargs)
4464 return self._as_raw(self.task_kwargs)
4464
4465
4465 def __repr__(self):
4466 def __repr__(self):
4466 return '<DB:ScheduleEntry({}:{})>'.format(
4467 return '<DB:ScheduleEntry({}:{})>'.format(
4467 self.schedule_entry_id, self.schedule_name)
4468 self.schedule_entry_id, self.schedule_name)
4468
4469
4469
4470
4470 @event.listens_for(ScheduleEntry, 'before_update')
4471 @event.listens_for(ScheduleEntry, 'before_update')
4471 def update_task_uid(mapper, connection, target):
4472 def update_task_uid(mapper, connection, target):
4472 target.task_uid = ScheduleEntry.get_uid(target)
4473 target.task_uid = ScheduleEntry.get_uid(target)
4473
4474
4474
4475
4475 @event.listens_for(ScheduleEntry, 'before_insert')
4476 @event.listens_for(ScheduleEntry, 'before_insert')
4476 def set_task_uid(mapper, connection, target):
4477 def set_task_uid(mapper, connection, target):
4477 target.task_uid = ScheduleEntry.get_uid(target)
4478 target.task_uid = ScheduleEntry.get_uid(target)
4478
4479
4479
4480
4480 class DbMigrateVersion(Base, BaseModel):
4481 class DbMigrateVersion(Base, BaseModel):
4481 __tablename__ = 'db_migrate_version'
4482 __tablename__ = 'db_migrate_version'
4482 __table_args__ = (
4483 __table_args__ = (
4483 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4484 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4484 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4485 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4485 )
4486 )
4486 repository_id = Column('repository_id', String(250), primary_key=True)
4487 repository_id = Column('repository_id', String(250), primary_key=True)
4487 repository_path = Column('repository_path', Text)
4488 repository_path = Column('repository_path', Text)
4488 version = Column('version', Integer)
4489 version = Column('version', Integer)
4489
4490
4490
4491
4491 class DbSession(Base, BaseModel):
4492 class DbSession(Base, BaseModel):
4492 __tablename__ = 'db_session'
4493 __tablename__ = 'db_session'
4493 __table_args__ = (
4494 __table_args__ = (
4494 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4495 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4495 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4496 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4496 )
4497 )
4497
4498
4498 def __repr__(self):
4499 def __repr__(self):
4499 return '<DB:DbSession({})>'.format(self.id)
4500 return '<DB:DbSession({})>'.format(self.id)
4500
4501
4501 id = Column('id', Integer())
4502 id = Column('id', Integer())
4502 namespace = Column('namespace', String(255), primary_key=True)
4503 namespace = Column('namespace', String(255), primary_key=True)
4503 accessed = Column('accessed', DateTime, nullable=False)
4504 accessed = Column('accessed', DateTime, nullable=False)
4504 created = Column('created', DateTime, nullable=False)
4505 created = Column('created', DateTime, nullable=False)
4505 data = Column('data', PickleType, nullable=False)
4506 data = Column('data', PickleType, nullable=False)
4506
4507
4507
4508
4508
4509
4509 class BeakerCache(Base, BaseModel):
4510 class BeakerCache(Base, BaseModel):
4510 __tablename__ = 'beaker_cache'
4511 __tablename__ = 'beaker_cache'
4511 __table_args__ = (
4512 __table_args__ = (
4512 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4513 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4513 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4514 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
4514 )
4515 )
4515
4516
4516 def __repr__(self):
4517 def __repr__(self):
4517 return '<DB:DbSession({})>'.format(self.id)
4518 return '<DB:DbSession({})>'.format(self.id)
4518
4519
4519 id = Column('id', Integer())
4520 id = Column('id', Integer())
4520 namespace = Column('namespace', String(255), primary_key=True)
4521 namespace = Column('namespace', String(255), primary_key=True)
4521 accessed = Column('accessed', DateTime, nullable=False)
4522 accessed = Column('accessed', DateTime, nullable=False)
4522 created = Column('created', DateTime, nullable=False)
4523 created = Column('created', DateTime, nullable=False)
4523 data = Column('data', PickleType, nullable=False)
4524 data = Column('data', PickleType, nullable=False)
General Comments 0
You need to be logged in to leave comments. Login now