Show More
@@ -1,231 +1,240 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2016-2019 RhodeCode GmbH |
|
3 | # Copyright (C) 2016-2019 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | import os |
|
21 | import os | |
22 | import time |
|
22 | import time | |
23 | import shutil |
|
23 | import shutil | |
24 | import hashlib |
|
24 | import hashlib | |
25 |
|
25 | |||
26 | from rhodecode.lib.ext_json import json |
|
26 | from rhodecode.lib.ext_json import json | |
27 | from rhodecode.apps.file_store import utils |
|
27 | from rhodecode.apps.file_store import utils | |
28 | from rhodecode.apps.file_store.extensions import resolve_extensions |
|
28 | from rhodecode.apps.file_store.extensions import resolve_extensions | |
29 |
from rhodecode.apps.file_store.exceptions import |
|
29 | from rhodecode.apps.file_store.exceptions import ( | |
|
30 | FileNotAllowedException, FileOverSizeException) | |||
30 |
|
31 | |||
31 | METADATA_VER = 'v1' |
|
32 | METADATA_VER = 'v1' | |
32 |
|
33 | |||
33 |
|
34 | |||
34 | class LocalFileStorage(object): |
|
35 | class LocalFileStorage(object): | |
35 |
|
36 | |||
36 | @classmethod |
|
37 | @classmethod | |
37 | def resolve_name(cls, name, directory): |
|
38 | def resolve_name(cls, name, directory): | |
38 | """ |
|
39 | """ | |
39 | Resolves a unique name and the correct path. If a filename |
|
40 | Resolves a unique name and the correct path. If a filename | |
40 | for that path already exists then a numeric prefix with values > 0 will be |
|
41 | for that path already exists then a numeric prefix with values > 0 will be | |
41 | added, for example test.jpg -> 1-test.jpg etc. initially file would have 0 prefix. |
|
42 | added, for example test.jpg -> 1-test.jpg etc. initially file would have 0 prefix. | |
42 |
|
43 | |||
43 | :param name: base name of file |
|
44 | :param name: base name of file | |
44 | :param directory: absolute directory path |
|
45 | :param directory: absolute directory path | |
45 | """ |
|
46 | """ | |
46 |
|
47 | |||
47 | counter = 0 |
|
48 | counter = 0 | |
48 | while True: |
|
49 | while True: | |
49 | name = '%d-%s' % (counter, name) |
|
50 | name = '%d-%s' % (counter, name) | |
50 |
|
51 | |||
51 | # sub_store prefix to optimize disk usage, e.g some_path/ab/final_file |
|
52 | # sub_store prefix to optimize disk usage, e.g some_path/ab/final_file | |
52 | sub_store = cls._sub_store_from_filename(name) |
|
53 | sub_store = cls._sub_store_from_filename(name) | |
53 | sub_store_path = os.path.join(directory, sub_store) |
|
54 | sub_store_path = os.path.join(directory, sub_store) | |
54 | if not os.path.exists(sub_store_path): |
|
55 | if not os.path.exists(sub_store_path): | |
55 | os.makedirs(sub_store_path) |
|
56 | os.makedirs(sub_store_path) | |
56 |
|
57 | |||
57 | path = os.path.join(sub_store_path, name) |
|
58 | path = os.path.join(sub_store_path, name) | |
58 | if not os.path.exists(path): |
|
59 | if not os.path.exists(path): | |
59 | return name, path |
|
60 | return name, path | |
60 | counter += 1 |
|
61 | counter += 1 | |
61 |
|
62 | |||
62 | @classmethod |
|
63 | @classmethod | |
63 | def _sub_store_from_filename(cls, filename): |
|
64 | def _sub_store_from_filename(cls, filename): | |
64 | return filename[:2] |
|
65 | return filename[:2] | |
65 |
|
66 | |||
66 | @classmethod |
|
67 | @classmethod | |
67 | def calculate_path_hash(cls, file_path): |
|
68 | def calculate_path_hash(cls, file_path): | |
68 | """ |
|
69 | """ | |
69 | Efficient calculation of file_path sha256 sum |
|
70 | Efficient calculation of file_path sha256 sum | |
70 |
|
71 | |||
71 | :param file_path: |
|
72 | :param file_path: | |
72 | :return: sha256sum |
|
73 | :return: sha256sum | |
73 | """ |
|
74 | """ | |
74 | digest = hashlib.sha256() |
|
75 | digest = hashlib.sha256() | |
75 | with open(file_path, 'rb') as f: |
|
76 | with open(file_path, 'rb') as f: | |
76 | for chunk in iter(lambda: f.read(1024 * 100), b""): |
|
77 | for chunk in iter(lambda: f.read(1024 * 100), b""): | |
77 | digest.update(chunk) |
|
78 | digest.update(chunk) | |
78 |
|
79 | |||
79 | return digest.hexdigest() |
|
80 | return digest.hexdigest() | |
80 |
|
81 | |||
81 | def __init__(self, base_path, extension_groups=None): |
|
82 | def __init__(self, base_path, extension_groups=None): | |
82 |
|
83 | |||
83 | """ |
|
84 | """ | |
84 | Local file storage |
|
85 | Local file storage | |
85 |
|
86 | |||
86 | :param base_path: the absolute base path where uploads are stored |
|
87 | :param base_path: the absolute base path where uploads are stored | |
87 | :param extension_groups: extensions string |
|
88 | :param extension_groups: extensions string | |
88 | """ |
|
89 | """ | |
89 |
|
90 | |||
90 | extension_groups = extension_groups or ['any'] |
|
91 | extension_groups = extension_groups or ['any'] | |
91 | self.base_path = base_path |
|
92 | self.base_path = base_path | |
92 | self.extensions = resolve_extensions([], groups=extension_groups) |
|
93 | self.extensions = resolve_extensions([], groups=extension_groups) | |
93 |
|
94 | |||
94 | def __repr__(self): |
|
95 | def __repr__(self): | |
95 | return '{}@{}'.format(self.__class__, self.base_path) |
|
96 | return '{}@{}'.format(self.__class__, self.base_path) | |
96 |
|
97 | |||
97 | def store_path(self, filename): |
|
98 | def store_path(self, filename): | |
98 | """ |
|
99 | """ | |
99 | Returns absolute file path of the filename, joined to the |
|
100 | Returns absolute file path of the filename, joined to the | |
100 | base_path. |
|
101 | base_path. | |
101 |
|
102 | |||
102 | :param filename: base name of file |
|
103 | :param filename: base name of file | |
103 | """ |
|
104 | """ | |
104 | sub_store = self._sub_store_from_filename(filename) |
|
105 | sub_store = self._sub_store_from_filename(filename) | |
105 | return os.path.join(self.base_path, sub_store, filename) |
|
106 | return os.path.join(self.base_path, sub_store, filename) | |
106 |
|
107 | |||
107 | def delete(self, filename): |
|
108 | def delete(self, filename): | |
108 | """ |
|
109 | """ | |
109 | Deletes the filename. Filename is resolved with the |
|
110 | Deletes the filename. Filename is resolved with the | |
110 | absolute path based on base_path. If file does not exist, |
|
111 | absolute path based on base_path. If file does not exist, | |
111 | returns **False**, otherwise **True** |
|
112 | returns **False**, otherwise **True** | |
112 |
|
113 | |||
113 | :param filename: base name of file |
|
114 | :param filename: base name of file | |
114 | """ |
|
115 | """ | |
115 | if self.exists(filename): |
|
116 | if self.exists(filename): | |
116 | os.remove(self.store_path(filename)) |
|
117 | os.remove(self.store_path(filename)) | |
117 | return True |
|
118 | return True | |
118 | return False |
|
119 | return False | |
119 |
|
120 | |||
120 | def exists(self, filename): |
|
121 | def exists(self, filename): | |
121 | """ |
|
122 | """ | |
122 | Checks if file exists. Resolves filename's absolute |
|
123 | Checks if file exists. Resolves filename's absolute | |
123 | path based on base_path. |
|
124 | path based on base_path. | |
124 |
|
125 | |||
125 | :param filename: base name of file |
|
126 | :param filename: base name of file | |
126 | """ |
|
127 | """ | |
127 | return os.path.exists(self.store_path(filename)) |
|
128 | return os.path.exists(self.store_path(filename)) | |
128 |
|
129 | |||
129 | def filename_allowed(self, filename, extensions=None): |
|
130 | def filename_allowed(self, filename, extensions=None): | |
130 | """Checks if a filename has an allowed extension |
|
131 | """Checks if a filename has an allowed extension | |
131 |
|
132 | |||
132 | :param filename: base name of file |
|
133 | :param filename: base name of file | |
133 | :param extensions: iterable of extensions (or self.extensions) |
|
134 | :param extensions: iterable of extensions (or self.extensions) | |
134 | """ |
|
135 | """ | |
135 | _, ext = os.path.splitext(filename) |
|
136 | _, ext = os.path.splitext(filename) | |
136 | return self.extension_allowed(ext, extensions) |
|
137 | return self.extension_allowed(ext, extensions) | |
137 |
|
138 | |||
138 | def extension_allowed(self, ext, extensions=None): |
|
139 | def extension_allowed(self, ext, extensions=None): | |
139 | """ |
|
140 | """ | |
140 | Checks if an extension is permitted. Both e.g. ".jpg" and |
|
141 | Checks if an extension is permitted. Both e.g. ".jpg" and | |
141 | "jpg" can be passed in. Extension lookup is case-insensitive. |
|
142 | "jpg" can be passed in. Extension lookup is case-insensitive. | |
142 |
|
143 | |||
143 | :param ext: extension to check |
|
144 | :param ext: extension to check | |
144 | :param extensions: iterable of extensions to validate against (or self.extensions) |
|
145 | :param extensions: iterable of extensions to validate against (or self.extensions) | |
145 | """ |
|
146 | """ | |
146 | def normalize_ext(_ext): |
|
147 | def normalize_ext(_ext): | |
147 | if _ext.startswith('.'): |
|
148 | if _ext.startswith('.'): | |
148 | _ext = _ext[1:] |
|
149 | _ext = _ext[1:] | |
149 | return _ext.lower() |
|
150 | return _ext.lower() | |
150 |
|
151 | |||
151 | extensions = extensions or self.extensions |
|
152 | extensions = extensions or self.extensions | |
152 | if not extensions: |
|
153 | if not extensions: | |
153 | return True |
|
154 | return True | |
154 |
|
155 | |||
155 | ext = normalize_ext(ext) |
|
156 | ext = normalize_ext(ext) | |
156 |
|
157 | |||
157 | return ext in [normalize_ext(x) for x in extensions] |
|
158 | return ext in [normalize_ext(x) for x in extensions] | |
158 |
|
159 | |||
159 | def save_file(self, file_obj, filename, directory=None, extensions=None, |
|
160 | def save_file(self, file_obj, filename, directory=None, extensions=None, | |
160 | extra_metadata=None, **kwargs): |
|
161 | extra_metadata=None, max_filesize=None, **kwargs): | |
161 | """ |
|
162 | """ | |
162 | Saves a file object to the uploads location. |
|
163 | Saves a file object to the uploads location. | |
163 | Returns the resolved filename, i.e. the directory + |
|
164 | Returns the resolved filename, i.e. the directory + | |
164 | the (randomized/incremented) base name. |
|
165 | the (randomized/incremented) base name. | |
165 |
|
166 | |||
166 | :param file_obj: **cgi.FieldStorage** object (or similar) |
|
167 | :param file_obj: **cgi.FieldStorage** object (or similar) | |
167 | :param filename: original filename |
|
168 | :param filename: original filename | |
168 | :param directory: relative path of sub-directory |
|
169 | :param directory: relative path of sub-directory | |
169 | :param extensions: iterable of allowed extensions, if not default |
|
170 | :param extensions: iterable of allowed extensions, if not default | |
|
171 | :param max_filesize: maximum size of file that should be allowed | |||
170 | :param extra_metadata: extra JSON metadata to store next to the file with .meta suffix |
|
172 | :param extra_metadata: extra JSON metadata to store next to the file with .meta suffix | |
|
173 | ||||
171 | """ |
|
174 | """ | |
172 |
|
175 | |||
173 | extensions = extensions or self.extensions |
|
176 | extensions = extensions or self.extensions | |
174 |
|
177 | |||
175 | if not self.filename_allowed(filename, extensions): |
|
178 | if not self.filename_allowed(filename, extensions): | |
176 | raise FileNotAllowedException() |
|
179 | raise FileNotAllowedException() | |
177 |
|
180 | |||
178 | if directory: |
|
181 | if directory: | |
179 | dest_directory = os.path.join(self.base_path, directory) |
|
182 | dest_directory = os.path.join(self.base_path, directory) | |
180 | else: |
|
183 | else: | |
181 | dest_directory = self.base_path |
|
184 | dest_directory = self.base_path | |
182 |
|
185 | |||
183 | if not os.path.exists(dest_directory): |
|
186 | if not os.path.exists(dest_directory): | |
184 | os.makedirs(dest_directory) |
|
187 | os.makedirs(dest_directory) | |
185 |
|
188 | |||
186 | filename = utils.uid_filename(filename) |
|
189 | filename = utils.uid_filename(filename) | |
187 |
|
190 | |||
188 | # resolve also produces special sub-dir for file optimized store |
|
191 | # resolve also produces special sub-dir for file optimized store | |
189 | filename, path = self.resolve_name(filename, dest_directory) |
|
192 | filename, path = self.resolve_name(filename, dest_directory) | |
190 | stored_file_dir = os.path.dirname(path) |
|
193 | stored_file_dir = os.path.dirname(path) | |
191 |
|
194 | |||
192 | file_obj.seek(0) |
|
195 | file_obj.seek(0) | |
193 |
|
196 | |||
194 | with open(path, "wb") as dest: |
|
197 | with open(path, "wb") as dest: | |
195 | shutil.copyfileobj(file_obj, dest) |
|
198 | shutil.copyfileobj(file_obj, dest) | |
196 |
|
199 | |||
197 | metadata = {} |
|
200 | metadata = {} | |
198 | if extra_metadata: |
|
201 | if extra_metadata: | |
199 | metadata = extra_metadata |
|
202 | metadata = extra_metadata | |
200 |
|
203 | |||
201 | size = os.stat(path).st_size |
|
204 | size = os.stat(path).st_size | |
|
205 | ||||
|
206 | if max_filesize and size > max_filesize: | |||
|
207 | # free up the copied file, and raise exc | |||
|
208 | os.remove(path) | |||
|
209 | raise FileOverSizeException() | |||
|
210 | ||||
202 | file_hash = self.calculate_path_hash(path) |
|
211 | file_hash = self.calculate_path_hash(path) | |
203 |
|
212 | |||
204 | metadata.update( |
|
213 | metadata.update( | |
205 | {"filename": filename, |
|
214 | {"filename": filename, | |
206 | "size": size, |
|
215 | "size": size, | |
207 | "time": time.time(), |
|
216 | "time": time.time(), | |
208 | "sha256": file_hash, |
|
217 | "sha256": file_hash, | |
209 | "meta_ver": METADATA_VER}) |
|
218 | "meta_ver": METADATA_VER}) | |
210 |
|
219 | |||
211 | filename_meta = filename + '.meta' |
|
220 | filename_meta = filename + '.meta' | |
212 | with open(os.path.join(stored_file_dir, filename_meta), "wb") as dest_meta: |
|
221 | with open(os.path.join(stored_file_dir, filename_meta), "wb") as dest_meta: | |
213 | dest_meta.write(json.dumps(metadata)) |
|
222 | dest_meta.write(json.dumps(metadata)) | |
214 |
|
223 | |||
215 | if directory: |
|
224 | if directory: | |
216 | filename = os.path.join(directory, filename) |
|
225 | filename = os.path.join(directory, filename) | |
217 |
|
226 | |||
218 | return filename, metadata |
|
227 | return filename, metadata | |
219 |
|
228 | |||
220 | def get_metadata(self, filename): |
|
229 | def get_metadata(self, filename): | |
221 | """ |
|
230 | """ | |
222 | Reads JSON stored metadata for a file |
|
231 | Reads JSON stored metadata for a file | |
223 |
|
232 | |||
224 | :param filename: |
|
233 | :param filename: | |
225 | :return: |
|
234 | :return: | |
226 | """ |
|
235 | """ | |
227 | filename = self.store_path(filename) |
|
236 | filename = self.store_path(filename) | |
228 | filename_meta = filename + '.meta' |
|
237 | filename_meta = filename + '.meta' | |
229 |
|
238 | |||
230 | with open(filename_meta, "rb") as source_meta: |
|
239 | with open(filename_meta, "rb") as source_meta: | |
231 | return json.loads(source_meta.read()) |
|
240 | return json.loads(source_meta.read()) |
@@ -1,512 +1,516 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2016-2019 RhodeCode GmbH |
|
3 | # Copyright (C) 2016-2019 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 | from rhodecode.apps._base import add_route_with_slash |
|
20 | from rhodecode.apps._base import add_route_with_slash | |
21 |
|
21 | |||
22 |
|
22 | |||
23 | def includeme(config): |
|
23 | def includeme(config): | |
24 |
|
24 | |||
25 | # repo creating checks, special cases that aren't repo routes |
|
25 | # repo creating checks, special cases that aren't repo routes | |
26 | config.add_route( |
|
26 | config.add_route( | |
27 | name='repo_creating', |
|
27 | name='repo_creating', | |
28 | pattern='/{repo_name:.*?[^/]}/repo_creating') |
|
28 | pattern='/{repo_name:.*?[^/]}/repo_creating') | |
29 |
|
29 | |||
30 | config.add_route( |
|
30 | config.add_route( | |
31 | name='repo_creating_check', |
|
31 | name='repo_creating_check', | |
32 | pattern='/{repo_name:.*?[^/]}/repo_creating_check') |
|
32 | pattern='/{repo_name:.*?[^/]}/repo_creating_check') | |
33 |
|
33 | |||
34 | # Summary |
|
34 | # Summary | |
35 | # NOTE(marcink): one additional route is defined in very bottom, catch |
|
35 | # NOTE(marcink): one additional route is defined in very bottom, catch | |
36 | # all pattern |
|
36 | # all pattern | |
37 | config.add_route( |
|
37 | config.add_route( | |
38 | name='repo_summary_explicit', |
|
38 | name='repo_summary_explicit', | |
39 | pattern='/{repo_name:.*?[^/]}/summary', repo_route=True) |
|
39 | pattern='/{repo_name:.*?[^/]}/summary', repo_route=True) | |
40 | config.add_route( |
|
40 | config.add_route( | |
41 | name='repo_summary_commits', |
|
41 | name='repo_summary_commits', | |
42 | pattern='/{repo_name:.*?[^/]}/summary-commits', repo_route=True) |
|
42 | pattern='/{repo_name:.*?[^/]}/summary-commits', repo_route=True) | |
43 |
|
43 | |||
44 | # Commits |
|
44 | # Commits | |
45 | config.add_route( |
|
45 | config.add_route( | |
46 | name='repo_commit', |
|
46 | name='repo_commit', | |
47 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}', repo_route=True) |
|
47 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}', repo_route=True) | |
48 |
|
48 | |||
49 | config.add_route( |
|
49 | config.add_route( | |
50 | name='repo_commit_children', |
|
50 | name='repo_commit_children', | |
51 | pattern='/{repo_name:.*?[^/]}/changeset_children/{commit_id}', repo_route=True) |
|
51 | pattern='/{repo_name:.*?[^/]}/changeset_children/{commit_id}', repo_route=True) | |
52 |
|
52 | |||
53 | config.add_route( |
|
53 | config.add_route( | |
54 | name='repo_commit_parents', |
|
54 | name='repo_commit_parents', | |
55 | pattern='/{repo_name:.*?[^/]}/changeset_parents/{commit_id}', repo_route=True) |
|
55 | pattern='/{repo_name:.*?[^/]}/changeset_parents/{commit_id}', repo_route=True) | |
56 |
|
56 | |||
57 | config.add_route( |
|
57 | config.add_route( | |
58 | name='repo_commit_raw', |
|
58 | name='repo_commit_raw', | |
59 | pattern='/{repo_name:.*?[^/]}/changeset-diff/{commit_id}', repo_route=True) |
|
59 | pattern='/{repo_name:.*?[^/]}/changeset-diff/{commit_id}', repo_route=True) | |
60 |
|
60 | |||
61 | config.add_route( |
|
61 | config.add_route( | |
62 | name='repo_commit_patch', |
|
62 | name='repo_commit_patch', | |
63 | pattern='/{repo_name:.*?[^/]}/changeset-patch/{commit_id}', repo_route=True) |
|
63 | pattern='/{repo_name:.*?[^/]}/changeset-patch/{commit_id}', repo_route=True) | |
64 |
|
64 | |||
65 | config.add_route( |
|
65 | config.add_route( | |
66 | name='repo_commit_download', |
|
66 | name='repo_commit_download', | |
67 | pattern='/{repo_name:.*?[^/]}/changeset-download/{commit_id}', repo_route=True) |
|
67 | pattern='/{repo_name:.*?[^/]}/changeset-download/{commit_id}', repo_route=True) | |
68 |
|
68 | |||
69 | config.add_route( |
|
69 | config.add_route( | |
70 | name='repo_commit_data', |
|
70 | name='repo_commit_data', | |
71 | pattern='/{repo_name:.*?[^/]}/changeset-data/{commit_id}', repo_route=True) |
|
71 | pattern='/{repo_name:.*?[^/]}/changeset-data/{commit_id}', repo_route=True) | |
72 |
|
72 | |||
73 | config.add_route( |
|
73 | config.add_route( | |
74 | name='repo_commit_comment_create', |
|
74 | name='repo_commit_comment_create', | |
75 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/create', repo_route=True) |
|
75 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/create', repo_route=True) | |
76 |
|
76 | |||
77 | config.add_route( |
|
77 | config.add_route( | |
78 | name='repo_commit_comment_preview', |
|
78 | name='repo_commit_comment_preview', | |
79 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/preview', repo_route=True) |
|
79 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/preview', repo_route=True) | |
80 |
|
80 | |||
81 | config.add_route( |
|
81 | config.add_route( | |
|
82 | name='repo_commit_comment_attachment_upload', | |||
|
83 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/attachment_upload', repo_route=True) | |||
|
84 | ||||
|
85 | config.add_route( | |||
82 | name='repo_commit_comment_delete', |
|
86 | name='repo_commit_comment_delete', | |
83 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/{comment_id}/delete', repo_route=True) |
|
87 | pattern='/{repo_name:.*?[^/]}/changeset/{commit_id}/comment/{comment_id}/delete', repo_route=True) | |
84 |
|
88 | |||
85 | # still working url for backward compat. |
|
89 | # still working url for backward compat. | |
86 | config.add_route( |
|
90 | config.add_route( | |
87 | name='repo_commit_raw_deprecated', |
|
91 | name='repo_commit_raw_deprecated', | |
88 | pattern='/{repo_name:.*?[^/]}/raw-changeset/{commit_id}', repo_route=True) |
|
92 | pattern='/{repo_name:.*?[^/]}/raw-changeset/{commit_id}', repo_route=True) | |
89 |
|
93 | |||
90 | # Files |
|
94 | # Files | |
91 | config.add_route( |
|
95 | config.add_route( | |
92 | name='repo_archivefile', |
|
96 | name='repo_archivefile', | |
93 | pattern='/{repo_name:.*?[^/]}/archive/{fname:.*}', repo_route=True) |
|
97 | pattern='/{repo_name:.*?[^/]}/archive/{fname:.*}', repo_route=True) | |
94 |
|
98 | |||
95 | config.add_route( |
|
99 | config.add_route( | |
96 | name='repo_files_diff', |
|
100 | name='repo_files_diff', | |
97 | pattern='/{repo_name:.*?[^/]}/diff/{f_path:.*}', repo_route=True) |
|
101 | pattern='/{repo_name:.*?[^/]}/diff/{f_path:.*}', repo_route=True) | |
98 | config.add_route( # legacy route to make old links work |
|
102 | config.add_route( # legacy route to make old links work | |
99 | name='repo_files_diff_2way_redirect', |
|
103 | name='repo_files_diff_2way_redirect', | |
100 | pattern='/{repo_name:.*?[^/]}/diff-2way/{f_path:.*}', repo_route=True) |
|
104 | pattern='/{repo_name:.*?[^/]}/diff-2way/{f_path:.*}', repo_route=True) | |
101 |
|
105 | |||
102 | config.add_route( |
|
106 | config.add_route( | |
103 | name='repo_files', |
|
107 | name='repo_files', | |
104 | pattern='/{repo_name:.*?[^/]}/files/{commit_id}/{f_path:.*}', repo_route=True) |
|
108 | pattern='/{repo_name:.*?[^/]}/files/{commit_id}/{f_path:.*}', repo_route=True) | |
105 | config.add_route( |
|
109 | config.add_route( | |
106 | name='repo_files:default_path', |
|
110 | name='repo_files:default_path', | |
107 | pattern='/{repo_name:.*?[^/]}/files/{commit_id}/', repo_route=True) |
|
111 | pattern='/{repo_name:.*?[^/]}/files/{commit_id}/', repo_route=True) | |
108 | config.add_route( |
|
112 | config.add_route( | |
109 | name='repo_files:default_commit', |
|
113 | name='repo_files:default_commit', | |
110 | pattern='/{repo_name:.*?[^/]}/files', repo_route=True) |
|
114 | pattern='/{repo_name:.*?[^/]}/files', repo_route=True) | |
111 |
|
115 | |||
112 | config.add_route( |
|
116 | config.add_route( | |
113 | name='repo_files:rendered', |
|
117 | name='repo_files:rendered', | |
114 | pattern='/{repo_name:.*?[^/]}/render/{commit_id}/{f_path:.*}', repo_route=True) |
|
118 | pattern='/{repo_name:.*?[^/]}/render/{commit_id}/{f_path:.*}', repo_route=True) | |
115 |
|
119 | |||
116 | config.add_route( |
|
120 | config.add_route( | |
117 | name='repo_files:annotated', |
|
121 | name='repo_files:annotated', | |
118 | pattern='/{repo_name:.*?[^/]}/annotate/{commit_id}/{f_path:.*}', repo_route=True) |
|
122 | pattern='/{repo_name:.*?[^/]}/annotate/{commit_id}/{f_path:.*}', repo_route=True) | |
119 | config.add_route( |
|
123 | config.add_route( | |
120 | name='repo_files:annotated_previous', |
|
124 | name='repo_files:annotated_previous', | |
121 | pattern='/{repo_name:.*?[^/]}/annotate-previous/{commit_id}/{f_path:.*}', repo_route=True) |
|
125 | pattern='/{repo_name:.*?[^/]}/annotate-previous/{commit_id}/{f_path:.*}', repo_route=True) | |
122 |
|
126 | |||
123 | config.add_route( |
|
127 | config.add_route( | |
124 | name='repo_nodetree_full', |
|
128 | name='repo_nodetree_full', | |
125 | pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/{f_path:.*}', repo_route=True) |
|
129 | pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/{f_path:.*}', repo_route=True) | |
126 | config.add_route( |
|
130 | config.add_route( | |
127 | name='repo_nodetree_full:default_path', |
|
131 | name='repo_nodetree_full:default_path', | |
128 | pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/', repo_route=True) |
|
132 | pattern='/{repo_name:.*?[^/]}/nodetree_full/{commit_id}/', repo_route=True) | |
129 |
|
133 | |||
130 | config.add_route( |
|
134 | config.add_route( | |
131 | name='repo_files_nodelist', |
|
135 | name='repo_files_nodelist', | |
132 | pattern='/{repo_name:.*?[^/]}/nodelist/{commit_id}/{f_path:.*}', repo_route=True) |
|
136 | pattern='/{repo_name:.*?[^/]}/nodelist/{commit_id}/{f_path:.*}', repo_route=True) | |
133 |
|
137 | |||
134 | config.add_route( |
|
138 | config.add_route( | |
135 | name='repo_file_raw', |
|
139 | name='repo_file_raw', | |
136 | pattern='/{repo_name:.*?[^/]}/raw/{commit_id}/{f_path:.*}', repo_route=True) |
|
140 | pattern='/{repo_name:.*?[^/]}/raw/{commit_id}/{f_path:.*}', repo_route=True) | |
137 |
|
141 | |||
138 | config.add_route( |
|
142 | config.add_route( | |
139 | name='repo_file_download', |
|
143 | name='repo_file_download', | |
140 | pattern='/{repo_name:.*?[^/]}/download/{commit_id}/{f_path:.*}', repo_route=True) |
|
144 | pattern='/{repo_name:.*?[^/]}/download/{commit_id}/{f_path:.*}', repo_route=True) | |
141 | config.add_route( # backward compat to keep old links working |
|
145 | config.add_route( # backward compat to keep old links working | |
142 | name='repo_file_download:legacy', |
|
146 | name='repo_file_download:legacy', | |
143 | pattern='/{repo_name:.*?[^/]}/rawfile/{commit_id}/{f_path:.*}', |
|
147 | pattern='/{repo_name:.*?[^/]}/rawfile/{commit_id}/{f_path:.*}', | |
144 | repo_route=True) |
|
148 | repo_route=True) | |
145 |
|
149 | |||
146 | config.add_route( |
|
150 | config.add_route( | |
147 | name='repo_file_history', |
|
151 | name='repo_file_history', | |
148 | pattern='/{repo_name:.*?[^/]}/history/{commit_id}/{f_path:.*}', repo_route=True) |
|
152 | pattern='/{repo_name:.*?[^/]}/history/{commit_id}/{f_path:.*}', repo_route=True) | |
149 |
|
153 | |||
150 | config.add_route( |
|
154 | config.add_route( | |
151 | name='repo_file_authors', |
|
155 | name='repo_file_authors', | |
152 | pattern='/{repo_name:.*?[^/]}/authors/{commit_id}/{f_path:.*}', repo_route=True) |
|
156 | pattern='/{repo_name:.*?[^/]}/authors/{commit_id}/{f_path:.*}', repo_route=True) | |
153 |
|
157 | |||
154 | config.add_route( |
|
158 | config.add_route( | |
155 | name='repo_files_remove_file', |
|
159 | name='repo_files_remove_file', | |
156 | pattern='/{repo_name:.*?[^/]}/remove_file/{commit_id}/{f_path:.*}', |
|
160 | pattern='/{repo_name:.*?[^/]}/remove_file/{commit_id}/{f_path:.*}', | |
157 | repo_route=True) |
|
161 | repo_route=True) | |
158 | config.add_route( |
|
162 | config.add_route( | |
159 | name='repo_files_delete_file', |
|
163 | name='repo_files_delete_file', | |
160 | pattern='/{repo_name:.*?[^/]}/delete_file/{commit_id}/{f_path:.*}', |
|
164 | pattern='/{repo_name:.*?[^/]}/delete_file/{commit_id}/{f_path:.*}', | |
161 | repo_route=True) |
|
165 | repo_route=True) | |
162 | config.add_route( |
|
166 | config.add_route( | |
163 | name='repo_files_edit_file', |
|
167 | name='repo_files_edit_file', | |
164 | pattern='/{repo_name:.*?[^/]}/edit_file/{commit_id}/{f_path:.*}', |
|
168 | pattern='/{repo_name:.*?[^/]}/edit_file/{commit_id}/{f_path:.*}', | |
165 | repo_route=True) |
|
169 | repo_route=True) | |
166 | config.add_route( |
|
170 | config.add_route( | |
167 | name='repo_files_update_file', |
|
171 | name='repo_files_update_file', | |
168 | pattern='/{repo_name:.*?[^/]}/update_file/{commit_id}/{f_path:.*}', |
|
172 | pattern='/{repo_name:.*?[^/]}/update_file/{commit_id}/{f_path:.*}', | |
169 | repo_route=True) |
|
173 | repo_route=True) | |
170 | config.add_route( |
|
174 | config.add_route( | |
171 | name='repo_files_add_file', |
|
175 | name='repo_files_add_file', | |
172 | pattern='/{repo_name:.*?[^/]}/add_file/{commit_id}/{f_path:.*}', |
|
176 | pattern='/{repo_name:.*?[^/]}/add_file/{commit_id}/{f_path:.*}', | |
173 | repo_route=True) |
|
177 | repo_route=True) | |
174 | config.add_route( |
|
178 | config.add_route( | |
175 | name='repo_files_upload_file', |
|
179 | name='repo_files_upload_file', | |
176 | pattern='/{repo_name:.*?[^/]}/upload_file/{commit_id}/{f_path:.*}', |
|
180 | pattern='/{repo_name:.*?[^/]}/upload_file/{commit_id}/{f_path:.*}', | |
177 | repo_route=True) |
|
181 | repo_route=True) | |
178 | config.add_route( |
|
182 | config.add_route( | |
179 | name='repo_files_create_file', |
|
183 | name='repo_files_create_file', | |
180 | pattern='/{repo_name:.*?[^/]}/create_file/{commit_id}/{f_path:.*}', |
|
184 | pattern='/{repo_name:.*?[^/]}/create_file/{commit_id}/{f_path:.*}', | |
181 | repo_route=True) |
|
185 | repo_route=True) | |
182 |
|
186 | |||
183 | # Refs data |
|
187 | # Refs data | |
184 | config.add_route( |
|
188 | config.add_route( | |
185 | name='repo_refs_data', |
|
189 | name='repo_refs_data', | |
186 | pattern='/{repo_name:.*?[^/]}/refs-data', repo_route=True) |
|
190 | pattern='/{repo_name:.*?[^/]}/refs-data', repo_route=True) | |
187 |
|
191 | |||
188 | config.add_route( |
|
192 | config.add_route( | |
189 | name='repo_refs_changelog_data', |
|
193 | name='repo_refs_changelog_data', | |
190 | pattern='/{repo_name:.*?[^/]}/refs-data-changelog', repo_route=True) |
|
194 | pattern='/{repo_name:.*?[^/]}/refs-data-changelog', repo_route=True) | |
191 |
|
195 | |||
192 | config.add_route( |
|
196 | config.add_route( | |
193 | name='repo_stats', |
|
197 | name='repo_stats', | |
194 | pattern='/{repo_name:.*?[^/]}/repo_stats/{commit_id}', repo_route=True) |
|
198 | pattern='/{repo_name:.*?[^/]}/repo_stats/{commit_id}', repo_route=True) | |
195 |
|
199 | |||
196 | # Commits |
|
200 | # Commits | |
197 | config.add_route( |
|
201 | config.add_route( | |
198 | name='repo_commits', |
|
202 | name='repo_commits', | |
199 | pattern='/{repo_name:.*?[^/]}/commits', repo_route=True) |
|
203 | pattern='/{repo_name:.*?[^/]}/commits', repo_route=True) | |
200 | config.add_route( |
|
204 | config.add_route( | |
201 | name='repo_commits_file', |
|
205 | name='repo_commits_file', | |
202 | pattern='/{repo_name:.*?[^/]}/commits/{commit_id}/{f_path:.*}', repo_route=True) |
|
206 | pattern='/{repo_name:.*?[^/]}/commits/{commit_id}/{f_path:.*}', repo_route=True) | |
203 | config.add_route( |
|
207 | config.add_route( | |
204 | name='repo_commits_elements', |
|
208 | name='repo_commits_elements', | |
205 | pattern='/{repo_name:.*?[^/]}/commits_elements', repo_route=True) |
|
209 | pattern='/{repo_name:.*?[^/]}/commits_elements', repo_route=True) | |
206 | config.add_route( |
|
210 | config.add_route( | |
207 | name='repo_commits_elements_file', |
|
211 | name='repo_commits_elements_file', | |
208 | pattern='/{repo_name:.*?[^/]}/commits_elements/{commit_id}/{f_path:.*}', repo_route=True) |
|
212 | pattern='/{repo_name:.*?[^/]}/commits_elements/{commit_id}/{f_path:.*}', repo_route=True) | |
209 |
|
213 | |||
210 | # Changelog (old deprecated name for commits page) |
|
214 | # Changelog (old deprecated name for commits page) | |
211 | config.add_route( |
|
215 | config.add_route( | |
212 | name='repo_changelog', |
|
216 | name='repo_changelog', | |
213 | pattern='/{repo_name:.*?[^/]}/changelog', repo_route=True) |
|
217 | pattern='/{repo_name:.*?[^/]}/changelog', repo_route=True) | |
214 | config.add_route( |
|
218 | config.add_route( | |
215 | name='repo_changelog_file', |
|
219 | name='repo_changelog_file', | |
216 | pattern='/{repo_name:.*?[^/]}/changelog/{commit_id}/{f_path:.*}', repo_route=True) |
|
220 | pattern='/{repo_name:.*?[^/]}/changelog/{commit_id}/{f_path:.*}', repo_route=True) | |
217 |
|
221 | |||
218 | # Compare |
|
222 | # Compare | |
219 | config.add_route( |
|
223 | config.add_route( | |
220 | name='repo_compare_select', |
|
224 | name='repo_compare_select', | |
221 | pattern='/{repo_name:.*?[^/]}/compare', repo_route=True) |
|
225 | pattern='/{repo_name:.*?[^/]}/compare', repo_route=True) | |
222 |
|
226 | |||
223 | config.add_route( |
|
227 | config.add_route( | |
224 | name='repo_compare', |
|
228 | name='repo_compare', | |
225 | pattern='/{repo_name:.*?[^/]}/compare/{source_ref_type}@{source_ref:.*?}...{target_ref_type}@{target_ref:.*?}', repo_route=True) |
|
229 | pattern='/{repo_name:.*?[^/]}/compare/{source_ref_type}@{source_ref:.*?}...{target_ref_type}@{target_ref:.*?}', repo_route=True) | |
226 |
|
230 | |||
227 | # Tags |
|
231 | # Tags | |
228 | config.add_route( |
|
232 | config.add_route( | |
229 | name='tags_home', |
|
233 | name='tags_home', | |
230 | pattern='/{repo_name:.*?[^/]}/tags', repo_route=True) |
|
234 | pattern='/{repo_name:.*?[^/]}/tags', repo_route=True) | |
231 |
|
235 | |||
232 | # Branches |
|
236 | # Branches | |
233 | config.add_route( |
|
237 | config.add_route( | |
234 | name='branches_home', |
|
238 | name='branches_home', | |
235 | pattern='/{repo_name:.*?[^/]}/branches', repo_route=True) |
|
239 | pattern='/{repo_name:.*?[^/]}/branches', repo_route=True) | |
236 |
|
240 | |||
237 | # Bookmarks |
|
241 | # Bookmarks | |
238 | config.add_route( |
|
242 | config.add_route( | |
239 | name='bookmarks_home', |
|
243 | name='bookmarks_home', | |
240 | pattern='/{repo_name:.*?[^/]}/bookmarks', repo_route=True) |
|
244 | pattern='/{repo_name:.*?[^/]}/bookmarks', repo_route=True) | |
241 |
|
245 | |||
242 | # Forks |
|
246 | # Forks | |
243 | config.add_route( |
|
247 | config.add_route( | |
244 | name='repo_fork_new', |
|
248 | name='repo_fork_new', | |
245 | pattern='/{repo_name:.*?[^/]}/fork', repo_route=True, |
|
249 | pattern='/{repo_name:.*?[^/]}/fork', repo_route=True, | |
246 | repo_forbid_when_archived=True, |
|
250 | repo_forbid_when_archived=True, | |
247 | repo_accepted_types=['hg', 'git']) |
|
251 | repo_accepted_types=['hg', 'git']) | |
248 |
|
252 | |||
249 | config.add_route( |
|
253 | config.add_route( | |
250 | name='repo_fork_create', |
|
254 | name='repo_fork_create', | |
251 | pattern='/{repo_name:.*?[^/]}/fork/create', repo_route=True, |
|
255 | pattern='/{repo_name:.*?[^/]}/fork/create', repo_route=True, | |
252 | repo_forbid_when_archived=True, |
|
256 | repo_forbid_when_archived=True, | |
253 | repo_accepted_types=['hg', 'git']) |
|
257 | repo_accepted_types=['hg', 'git']) | |
254 |
|
258 | |||
255 | config.add_route( |
|
259 | config.add_route( | |
256 | name='repo_forks_show_all', |
|
260 | name='repo_forks_show_all', | |
257 | pattern='/{repo_name:.*?[^/]}/forks', repo_route=True, |
|
261 | pattern='/{repo_name:.*?[^/]}/forks', repo_route=True, | |
258 | repo_accepted_types=['hg', 'git']) |
|
262 | repo_accepted_types=['hg', 'git']) | |
259 | config.add_route( |
|
263 | config.add_route( | |
260 | name='repo_forks_data', |
|
264 | name='repo_forks_data', | |
261 | pattern='/{repo_name:.*?[^/]}/forks/data', repo_route=True, |
|
265 | pattern='/{repo_name:.*?[^/]}/forks/data', repo_route=True, | |
262 | repo_accepted_types=['hg', 'git']) |
|
266 | repo_accepted_types=['hg', 'git']) | |
263 |
|
267 | |||
264 | # Pull Requests |
|
268 | # Pull Requests | |
265 | config.add_route( |
|
269 | config.add_route( | |
266 | name='pullrequest_show', |
|
270 | name='pullrequest_show', | |
267 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}', |
|
271 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}', | |
268 | repo_route=True) |
|
272 | repo_route=True) | |
269 |
|
273 | |||
270 | config.add_route( |
|
274 | config.add_route( | |
271 | name='pullrequest_show_all', |
|
275 | name='pullrequest_show_all', | |
272 | pattern='/{repo_name:.*?[^/]}/pull-request', |
|
276 | pattern='/{repo_name:.*?[^/]}/pull-request', | |
273 | repo_route=True, repo_accepted_types=['hg', 'git']) |
|
277 | repo_route=True, repo_accepted_types=['hg', 'git']) | |
274 |
|
278 | |||
275 | config.add_route( |
|
279 | config.add_route( | |
276 | name='pullrequest_show_all_data', |
|
280 | name='pullrequest_show_all_data', | |
277 | pattern='/{repo_name:.*?[^/]}/pull-request-data', |
|
281 | pattern='/{repo_name:.*?[^/]}/pull-request-data', | |
278 | repo_route=True, repo_accepted_types=['hg', 'git']) |
|
282 | repo_route=True, repo_accepted_types=['hg', 'git']) | |
279 |
|
283 | |||
280 | config.add_route( |
|
284 | config.add_route( | |
281 | name='pullrequest_repo_refs', |
|
285 | name='pullrequest_repo_refs', | |
282 | pattern='/{repo_name:.*?[^/]}/pull-request/refs/{target_repo_name:.*?[^/]}', |
|
286 | pattern='/{repo_name:.*?[^/]}/pull-request/refs/{target_repo_name:.*?[^/]}', | |
283 | repo_route=True) |
|
287 | repo_route=True) | |
284 |
|
288 | |||
285 | config.add_route( |
|
289 | config.add_route( | |
286 | name='pullrequest_repo_targets', |
|
290 | name='pullrequest_repo_targets', | |
287 | pattern='/{repo_name:.*?[^/]}/pull-request/repo-targets', |
|
291 | pattern='/{repo_name:.*?[^/]}/pull-request/repo-targets', | |
288 | repo_route=True) |
|
292 | repo_route=True) | |
289 |
|
293 | |||
290 | config.add_route( |
|
294 | config.add_route( | |
291 | name='pullrequest_new', |
|
295 | name='pullrequest_new', | |
292 | pattern='/{repo_name:.*?[^/]}/pull-request/new', |
|
296 | pattern='/{repo_name:.*?[^/]}/pull-request/new', | |
293 | repo_route=True, repo_accepted_types=['hg', 'git'], |
|
297 | repo_route=True, repo_accepted_types=['hg', 'git'], | |
294 | repo_forbid_when_archived=True) |
|
298 | repo_forbid_when_archived=True) | |
295 |
|
299 | |||
296 | config.add_route( |
|
300 | config.add_route( | |
297 | name='pullrequest_create', |
|
301 | name='pullrequest_create', | |
298 | pattern='/{repo_name:.*?[^/]}/pull-request/create', |
|
302 | pattern='/{repo_name:.*?[^/]}/pull-request/create', | |
299 | repo_route=True, repo_accepted_types=['hg', 'git'], |
|
303 | repo_route=True, repo_accepted_types=['hg', 'git'], | |
300 | repo_forbid_when_archived=True) |
|
304 | repo_forbid_when_archived=True) | |
301 |
|
305 | |||
302 | config.add_route( |
|
306 | config.add_route( | |
303 | name='pullrequest_update', |
|
307 | name='pullrequest_update', | |
304 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/update', |
|
308 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/update', | |
305 | repo_route=True, repo_forbid_when_archived=True) |
|
309 | repo_route=True, repo_forbid_when_archived=True) | |
306 |
|
310 | |||
307 | config.add_route( |
|
311 | config.add_route( | |
308 | name='pullrequest_merge', |
|
312 | name='pullrequest_merge', | |
309 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/merge', |
|
313 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/merge', | |
310 | repo_route=True, repo_forbid_when_archived=True) |
|
314 | repo_route=True, repo_forbid_when_archived=True) | |
311 |
|
315 | |||
312 | config.add_route( |
|
316 | config.add_route( | |
313 | name='pullrequest_delete', |
|
317 | name='pullrequest_delete', | |
314 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/delete', |
|
318 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/delete', | |
315 | repo_route=True, repo_forbid_when_archived=True) |
|
319 | repo_route=True, repo_forbid_when_archived=True) | |
316 |
|
320 | |||
317 | config.add_route( |
|
321 | config.add_route( | |
318 | name='pullrequest_comment_create', |
|
322 | name='pullrequest_comment_create', | |
319 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment', |
|
323 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment', | |
320 | repo_route=True) |
|
324 | repo_route=True) | |
321 |
|
325 | |||
322 | config.add_route( |
|
326 | config.add_route( | |
323 | name='pullrequest_comment_delete', |
|
327 | name='pullrequest_comment_delete', | |
324 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment/{comment_id}/delete', |
|
328 | pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment/{comment_id}/delete', | |
325 | repo_route=True, repo_accepted_types=['hg', 'git']) |
|
329 | repo_route=True, repo_accepted_types=['hg', 'git']) | |
326 |
|
330 | |||
327 | # Artifacts, (EE feature) |
|
331 | # Artifacts, (EE feature) | |
328 | config.add_route( |
|
332 | config.add_route( | |
329 | name='repo_artifacts_list', |
|
333 | name='repo_artifacts_list', | |
330 | pattern='/{repo_name:.*?[^/]}/artifacts', repo_route=True) |
|
334 | pattern='/{repo_name:.*?[^/]}/artifacts', repo_route=True) | |
331 |
|
335 | |||
332 | # Settings |
|
336 | # Settings | |
333 | config.add_route( |
|
337 | config.add_route( | |
334 | name='edit_repo', |
|
338 | name='edit_repo', | |
335 | pattern='/{repo_name:.*?[^/]}/settings', repo_route=True) |
|
339 | pattern='/{repo_name:.*?[^/]}/settings', repo_route=True) | |
336 | # update is POST on edit_repo |
|
340 | # update is POST on edit_repo | |
337 |
|
341 | |||
338 | # Settings advanced |
|
342 | # Settings advanced | |
339 | config.add_route( |
|
343 | config.add_route( | |
340 | name='edit_repo_advanced', |
|
344 | name='edit_repo_advanced', | |
341 | pattern='/{repo_name:.*?[^/]}/settings/advanced', repo_route=True) |
|
345 | pattern='/{repo_name:.*?[^/]}/settings/advanced', repo_route=True) | |
342 | config.add_route( |
|
346 | config.add_route( | |
343 | name='edit_repo_advanced_archive', |
|
347 | name='edit_repo_advanced_archive', | |
344 | pattern='/{repo_name:.*?[^/]}/settings/advanced/archive', repo_route=True) |
|
348 | pattern='/{repo_name:.*?[^/]}/settings/advanced/archive', repo_route=True) | |
345 | config.add_route( |
|
349 | config.add_route( | |
346 | name='edit_repo_advanced_delete', |
|
350 | name='edit_repo_advanced_delete', | |
347 | pattern='/{repo_name:.*?[^/]}/settings/advanced/delete', repo_route=True) |
|
351 | pattern='/{repo_name:.*?[^/]}/settings/advanced/delete', repo_route=True) | |
348 | config.add_route( |
|
352 | config.add_route( | |
349 | name='edit_repo_advanced_locking', |
|
353 | name='edit_repo_advanced_locking', | |
350 | pattern='/{repo_name:.*?[^/]}/settings/advanced/locking', repo_route=True) |
|
354 | pattern='/{repo_name:.*?[^/]}/settings/advanced/locking', repo_route=True) | |
351 | config.add_route( |
|
355 | config.add_route( | |
352 | name='edit_repo_advanced_journal', |
|
356 | name='edit_repo_advanced_journal', | |
353 | pattern='/{repo_name:.*?[^/]}/settings/advanced/journal', repo_route=True) |
|
357 | pattern='/{repo_name:.*?[^/]}/settings/advanced/journal', repo_route=True) | |
354 | config.add_route( |
|
358 | config.add_route( | |
355 | name='edit_repo_advanced_fork', |
|
359 | name='edit_repo_advanced_fork', | |
356 | pattern='/{repo_name:.*?[^/]}/settings/advanced/fork', repo_route=True) |
|
360 | pattern='/{repo_name:.*?[^/]}/settings/advanced/fork', repo_route=True) | |
357 |
|
361 | |||
358 | config.add_route( |
|
362 | config.add_route( | |
359 | name='edit_repo_advanced_hooks', |
|
363 | name='edit_repo_advanced_hooks', | |
360 | pattern='/{repo_name:.*?[^/]}/settings/advanced/hooks', repo_route=True) |
|
364 | pattern='/{repo_name:.*?[^/]}/settings/advanced/hooks', repo_route=True) | |
361 |
|
365 | |||
362 | # Caches |
|
366 | # Caches | |
363 | config.add_route( |
|
367 | config.add_route( | |
364 | name='edit_repo_caches', |
|
368 | name='edit_repo_caches', | |
365 | pattern='/{repo_name:.*?[^/]}/settings/caches', repo_route=True) |
|
369 | pattern='/{repo_name:.*?[^/]}/settings/caches', repo_route=True) | |
366 |
|
370 | |||
367 | # Permissions |
|
371 | # Permissions | |
368 | config.add_route( |
|
372 | config.add_route( | |
369 | name='edit_repo_perms', |
|
373 | name='edit_repo_perms', | |
370 | pattern='/{repo_name:.*?[^/]}/settings/permissions', repo_route=True) |
|
374 | pattern='/{repo_name:.*?[^/]}/settings/permissions', repo_route=True) | |
371 |
|
375 | |||
372 | config.add_route( |
|
376 | config.add_route( | |
373 | name='edit_repo_perms_set_private', |
|
377 | name='edit_repo_perms_set_private', | |
374 | pattern='/{repo_name:.*?[^/]}/settings/permissions/set_private', repo_route=True) |
|
378 | pattern='/{repo_name:.*?[^/]}/settings/permissions/set_private', repo_route=True) | |
375 |
|
379 | |||
376 | # Permissions Branch (EE feature) |
|
380 | # Permissions Branch (EE feature) | |
377 | config.add_route( |
|
381 | config.add_route( | |
378 | name='edit_repo_perms_branch', |
|
382 | name='edit_repo_perms_branch', | |
379 | pattern='/{repo_name:.*?[^/]}/settings/branch_permissions', repo_route=True) |
|
383 | pattern='/{repo_name:.*?[^/]}/settings/branch_permissions', repo_route=True) | |
380 | config.add_route( |
|
384 | config.add_route( | |
381 | name='edit_repo_perms_branch_delete', |
|
385 | name='edit_repo_perms_branch_delete', | |
382 | pattern='/{repo_name:.*?[^/]}/settings/branch_permissions/{rule_id}/delete', |
|
386 | pattern='/{repo_name:.*?[^/]}/settings/branch_permissions/{rule_id}/delete', | |
383 | repo_route=True) |
|
387 | repo_route=True) | |
384 |
|
388 | |||
385 | # Maintenance |
|
389 | # Maintenance | |
386 | config.add_route( |
|
390 | config.add_route( | |
387 | name='edit_repo_maintenance', |
|
391 | name='edit_repo_maintenance', | |
388 | pattern='/{repo_name:.*?[^/]}/settings/maintenance', repo_route=True) |
|
392 | pattern='/{repo_name:.*?[^/]}/settings/maintenance', repo_route=True) | |
389 |
|
393 | |||
390 | config.add_route( |
|
394 | config.add_route( | |
391 | name='edit_repo_maintenance_execute', |
|
395 | name='edit_repo_maintenance_execute', | |
392 | pattern='/{repo_name:.*?[^/]}/settings/maintenance/execute', repo_route=True) |
|
396 | pattern='/{repo_name:.*?[^/]}/settings/maintenance/execute', repo_route=True) | |
393 |
|
397 | |||
394 | # Fields |
|
398 | # Fields | |
395 | config.add_route( |
|
399 | config.add_route( | |
396 | name='edit_repo_fields', |
|
400 | name='edit_repo_fields', | |
397 | pattern='/{repo_name:.*?[^/]}/settings/fields', repo_route=True) |
|
401 | pattern='/{repo_name:.*?[^/]}/settings/fields', repo_route=True) | |
398 | config.add_route( |
|
402 | config.add_route( | |
399 | name='edit_repo_fields_create', |
|
403 | name='edit_repo_fields_create', | |
400 | pattern='/{repo_name:.*?[^/]}/settings/fields/create', repo_route=True) |
|
404 | pattern='/{repo_name:.*?[^/]}/settings/fields/create', repo_route=True) | |
401 | config.add_route( |
|
405 | config.add_route( | |
402 | name='edit_repo_fields_delete', |
|
406 | name='edit_repo_fields_delete', | |
403 | pattern='/{repo_name:.*?[^/]}/settings/fields/{field_id}/delete', repo_route=True) |
|
407 | pattern='/{repo_name:.*?[^/]}/settings/fields/{field_id}/delete', repo_route=True) | |
404 |
|
408 | |||
405 | # Locking |
|
409 | # Locking | |
406 | config.add_route( |
|
410 | config.add_route( | |
407 | name='repo_edit_toggle_locking', |
|
411 | name='repo_edit_toggle_locking', | |
408 | pattern='/{repo_name:.*?[^/]}/settings/toggle_locking', repo_route=True) |
|
412 | pattern='/{repo_name:.*?[^/]}/settings/toggle_locking', repo_route=True) | |
409 |
|
413 | |||
410 | # Remote |
|
414 | # Remote | |
411 | config.add_route( |
|
415 | config.add_route( | |
412 | name='edit_repo_remote', |
|
416 | name='edit_repo_remote', | |
413 | pattern='/{repo_name:.*?[^/]}/settings/remote', repo_route=True) |
|
417 | pattern='/{repo_name:.*?[^/]}/settings/remote', repo_route=True) | |
414 | config.add_route( |
|
418 | config.add_route( | |
415 | name='edit_repo_remote_pull', |
|
419 | name='edit_repo_remote_pull', | |
416 | pattern='/{repo_name:.*?[^/]}/settings/remote/pull', repo_route=True) |
|
420 | pattern='/{repo_name:.*?[^/]}/settings/remote/pull', repo_route=True) | |
417 | config.add_route( |
|
421 | config.add_route( | |
418 | name='edit_repo_remote_push', |
|
422 | name='edit_repo_remote_push', | |
419 | pattern='/{repo_name:.*?[^/]}/settings/remote/push', repo_route=True) |
|
423 | pattern='/{repo_name:.*?[^/]}/settings/remote/push', repo_route=True) | |
420 |
|
424 | |||
421 | # Statistics |
|
425 | # Statistics | |
422 | config.add_route( |
|
426 | config.add_route( | |
423 | name='edit_repo_statistics', |
|
427 | name='edit_repo_statistics', | |
424 | pattern='/{repo_name:.*?[^/]}/settings/statistics', repo_route=True) |
|
428 | pattern='/{repo_name:.*?[^/]}/settings/statistics', repo_route=True) | |
425 | config.add_route( |
|
429 | config.add_route( | |
426 | name='edit_repo_statistics_reset', |
|
430 | name='edit_repo_statistics_reset', | |
427 | pattern='/{repo_name:.*?[^/]}/settings/statistics/update', repo_route=True) |
|
431 | pattern='/{repo_name:.*?[^/]}/settings/statistics/update', repo_route=True) | |
428 |
|
432 | |||
429 | # Issue trackers |
|
433 | # Issue trackers | |
430 | config.add_route( |
|
434 | config.add_route( | |
431 | name='edit_repo_issuetracker', |
|
435 | name='edit_repo_issuetracker', | |
432 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers', repo_route=True) |
|
436 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers', repo_route=True) | |
433 | config.add_route( |
|
437 | config.add_route( | |
434 | name='edit_repo_issuetracker_test', |
|
438 | name='edit_repo_issuetracker_test', | |
435 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/test', repo_route=True) |
|
439 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/test', repo_route=True) | |
436 | config.add_route( |
|
440 | config.add_route( | |
437 | name='edit_repo_issuetracker_delete', |
|
441 | name='edit_repo_issuetracker_delete', | |
438 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/delete', repo_route=True) |
|
442 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/delete', repo_route=True) | |
439 | config.add_route( |
|
443 | config.add_route( | |
440 | name='edit_repo_issuetracker_update', |
|
444 | name='edit_repo_issuetracker_update', | |
441 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/update', repo_route=True) |
|
445 | pattern='/{repo_name:.*?[^/]}/settings/issue_trackers/update', repo_route=True) | |
442 |
|
446 | |||
443 | # VCS Settings |
|
447 | # VCS Settings | |
444 | config.add_route( |
|
448 | config.add_route( | |
445 | name='edit_repo_vcs', |
|
449 | name='edit_repo_vcs', | |
446 | pattern='/{repo_name:.*?[^/]}/settings/vcs', repo_route=True) |
|
450 | pattern='/{repo_name:.*?[^/]}/settings/vcs', repo_route=True) | |
447 | config.add_route( |
|
451 | config.add_route( | |
448 | name='edit_repo_vcs_update', |
|
452 | name='edit_repo_vcs_update', | |
449 | pattern='/{repo_name:.*?[^/]}/settings/vcs/update', repo_route=True) |
|
453 | pattern='/{repo_name:.*?[^/]}/settings/vcs/update', repo_route=True) | |
450 |
|
454 | |||
451 | # svn pattern |
|
455 | # svn pattern | |
452 | config.add_route( |
|
456 | config.add_route( | |
453 | name='edit_repo_vcs_svn_pattern_delete', |
|
457 | name='edit_repo_vcs_svn_pattern_delete', | |
454 | pattern='/{repo_name:.*?[^/]}/settings/vcs/svn_pattern/delete', repo_route=True) |
|
458 | pattern='/{repo_name:.*?[^/]}/settings/vcs/svn_pattern/delete', repo_route=True) | |
455 |
|
459 | |||
456 | # Repo Review Rules (EE feature) |
|
460 | # Repo Review Rules (EE feature) | |
457 | config.add_route( |
|
461 | config.add_route( | |
458 | name='repo_reviewers', |
|
462 | name='repo_reviewers', | |
459 | pattern='/{repo_name:.*?[^/]}/settings/review/rules', repo_route=True) |
|
463 | pattern='/{repo_name:.*?[^/]}/settings/review/rules', repo_route=True) | |
460 |
|
464 | |||
461 | config.add_route( |
|
465 | config.add_route( | |
462 | name='repo_default_reviewers_data', |
|
466 | name='repo_default_reviewers_data', | |
463 | pattern='/{repo_name:.*?[^/]}/settings/review/default-reviewers', repo_route=True) |
|
467 | pattern='/{repo_name:.*?[^/]}/settings/review/default-reviewers', repo_route=True) | |
464 |
|
468 | |||
465 | # Repo Automation (EE feature) |
|
469 | # Repo Automation (EE feature) | |
466 | config.add_route( |
|
470 | config.add_route( | |
467 | name='repo_automation', |
|
471 | name='repo_automation', | |
468 | pattern='/{repo_name:.*?[^/]}/settings/automation', repo_route=True) |
|
472 | pattern='/{repo_name:.*?[^/]}/settings/automation', repo_route=True) | |
469 |
|
473 | |||
470 | # Strip |
|
474 | # Strip | |
471 | config.add_route( |
|
475 | config.add_route( | |
472 | name='edit_repo_strip', |
|
476 | name='edit_repo_strip', | |
473 | pattern='/{repo_name:.*?[^/]}/settings/strip', repo_route=True) |
|
477 | pattern='/{repo_name:.*?[^/]}/settings/strip', repo_route=True) | |
474 |
|
478 | |||
475 | config.add_route( |
|
479 | config.add_route( | |
476 | name='strip_check', |
|
480 | name='strip_check', | |
477 | pattern='/{repo_name:.*?[^/]}/settings/strip_check', repo_route=True) |
|
481 | pattern='/{repo_name:.*?[^/]}/settings/strip_check', repo_route=True) | |
478 |
|
482 | |||
479 | config.add_route( |
|
483 | config.add_route( | |
480 | name='strip_execute', |
|
484 | name='strip_execute', | |
481 | pattern='/{repo_name:.*?[^/]}/settings/strip_execute', repo_route=True) |
|
485 | pattern='/{repo_name:.*?[^/]}/settings/strip_execute', repo_route=True) | |
482 |
|
486 | |||
483 | # Audit logs |
|
487 | # Audit logs | |
484 | config.add_route( |
|
488 | config.add_route( | |
485 | name='edit_repo_audit_logs', |
|
489 | name='edit_repo_audit_logs', | |
486 | pattern='/{repo_name:.*?[^/]}/settings/audit_logs', repo_route=True) |
|
490 | pattern='/{repo_name:.*?[^/]}/settings/audit_logs', repo_route=True) | |
487 |
|
491 | |||
488 | # ATOM/RSS Feed, shouldn't contain slashes for outlook compatibility |
|
492 | # ATOM/RSS Feed, shouldn't contain slashes for outlook compatibility | |
489 | config.add_route( |
|
493 | config.add_route( | |
490 | name='rss_feed_home', |
|
494 | name='rss_feed_home', | |
491 | pattern='/{repo_name:.*?[^/]}/feed-rss', repo_route=True) |
|
495 | pattern='/{repo_name:.*?[^/]}/feed-rss', repo_route=True) | |
492 |
|
496 | |||
493 | config.add_route( |
|
497 | config.add_route( | |
494 | name='atom_feed_home', |
|
498 | name='atom_feed_home', | |
495 | pattern='/{repo_name:.*?[^/]}/feed-atom', repo_route=True) |
|
499 | pattern='/{repo_name:.*?[^/]}/feed-atom', repo_route=True) | |
496 |
|
500 | |||
497 | config.add_route( |
|
501 | config.add_route( | |
498 | name='rss_feed_home_old', |
|
502 | name='rss_feed_home_old', | |
499 | pattern='/{repo_name:.*?[^/]}/feed/rss', repo_route=True) |
|
503 | pattern='/{repo_name:.*?[^/]}/feed/rss', repo_route=True) | |
500 |
|
504 | |||
501 | config.add_route( |
|
505 | config.add_route( | |
502 | name='atom_feed_home_old', |
|
506 | name='atom_feed_home_old', | |
503 | pattern='/{repo_name:.*?[^/]}/feed/atom', repo_route=True) |
|
507 | pattern='/{repo_name:.*?[^/]}/feed/atom', repo_route=True) | |
504 |
|
508 | |||
505 | # NOTE(marcink): needs to be at the end for catch-all |
|
509 | # NOTE(marcink): needs to be at the end for catch-all | |
506 | add_route_with_slash( |
|
510 | add_route_with_slash( | |
507 | config, |
|
511 | config, | |
508 | name='repo_summary', |
|
512 | name='repo_summary', | |
509 | pattern='/{repo_name:.*?[^/]}', repo_route=True) |
|
513 | pattern='/{repo_name:.*?[^/]}', repo_route=True) | |
510 |
|
514 | |||
511 | # Scan module for configuration decorators. |
|
515 | # Scan module for configuration decorators. | |
512 | config.scan('.views', ignore='.tests') |
|
516 | config.scan('.views', ignore='.tests') |
@@ -1,503 +1,600 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2010-2019 RhodeCode GmbH |
|
3 | # Copyright (C) 2010-2019 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 |
|
21 | |||
22 | import logging |
|
22 | import logging | |
23 | import collections |
|
23 | import collections | |
24 |
|
24 | |||
25 | from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest, HTTPFound |
|
25 | from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest, HTTPFound | |
26 | from pyramid.view import view_config |
|
26 | from pyramid.view import view_config | |
27 | from pyramid.renderers import render |
|
27 | from pyramid.renderers import render | |
28 | from pyramid.response import Response |
|
28 | from pyramid.response import Response | |
29 |
|
29 | |||
30 | from rhodecode.apps._base import RepoAppView |
|
30 | from rhodecode.apps._base import RepoAppView | |
|
31 | from rhodecode.apps.file_store import utils as store_utils | |||
|
32 | from rhodecode.apps.file_store.exceptions import FileNotAllowedException, FileOverSizeException | |||
31 |
|
33 | |||
32 | from rhodecode.lib import diffs, codeblocks |
|
34 | from rhodecode.lib import diffs, codeblocks | |
33 | from rhodecode.lib.auth import ( |
|
35 | from rhodecode.lib.auth import ( | |
34 | LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, CSRFRequired) |
|
36 | LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, CSRFRequired) | |
35 |
|
37 | |||
36 | from rhodecode.lib.compat import OrderedDict |
|
38 | from rhodecode.lib.compat import OrderedDict | |
37 | from rhodecode.lib.diffs import ( |
|
39 | from rhodecode.lib.diffs import ( | |
38 | cache_diff, load_cached_diff, diff_cache_exist, get_diff_context, |
|
40 | cache_diff, load_cached_diff, diff_cache_exist, get_diff_context, | |
39 | get_diff_whitespace_flag) |
|
41 | get_diff_whitespace_flag) | |
40 | from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError |
|
42 | from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError | |
41 | import rhodecode.lib.helpers as h |
|
43 | import rhodecode.lib.helpers as h | |
42 | from rhodecode.lib.utils2 import safe_unicode, str2bool |
|
44 | from rhodecode.lib.utils2 import safe_unicode, str2bool | |
43 | from rhodecode.lib.vcs.backends.base import EmptyCommit |
|
45 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
44 | from rhodecode.lib.vcs.exceptions import ( |
|
46 | from rhodecode.lib.vcs.exceptions import ( | |
45 | RepositoryError, CommitDoesNotExistError) |
|
47 | RepositoryError, CommitDoesNotExistError) | |
46 | from rhodecode.model.db import ChangesetComment, ChangesetStatus |
|
48 | from rhodecode.model.db import ChangesetComment, ChangesetStatus, FileStore | |
47 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
49 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
48 | from rhodecode.model.comment import CommentsModel |
|
50 | from rhodecode.model.comment import CommentsModel | |
49 | from rhodecode.model.meta import Session |
|
51 | from rhodecode.model.meta import Session | |
50 | from rhodecode.model.settings import VcsSettingsModel |
|
52 | from rhodecode.model.settings import VcsSettingsModel | |
51 |
|
53 | |||
52 | log = logging.getLogger(__name__) |
|
54 | log = logging.getLogger(__name__) | |
53 |
|
55 | |||
54 |
|
56 | |||
55 | def _update_with_GET(params, request): |
|
57 | def _update_with_GET(params, request): | |
56 | for k in ['diff1', 'diff2', 'diff']: |
|
58 | for k in ['diff1', 'diff2', 'diff']: | |
57 | params[k] += request.GET.getall(k) |
|
59 | params[k] += request.GET.getall(k) | |
58 |
|
60 | |||
59 |
|
61 | |||
60 | class RepoCommitsView(RepoAppView): |
|
62 | class RepoCommitsView(RepoAppView): | |
61 | def load_default_context(self): |
|
63 | def load_default_context(self): | |
62 | c = self._get_local_tmpl_context(include_app_defaults=True) |
|
64 | c = self._get_local_tmpl_context(include_app_defaults=True) | |
63 | c.rhodecode_repo = self.rhodecode_vcs_repo |
|
65 | c.rhodecode_repo = self.rhodecode_vcs_repo | |
64 |
|
66 | |||
65 | return c |
|
67 | return c | |
66 |
|
68 | |||
67 | def _is_diff_cache_enabled(self, target_repo): |
|
69 | def _is_diff_cache_enabled(self, target_repo): | |
68 | caching_enabled = self._get_general_setting( |
|
70 | caching_enabled = self._get_general_setting( | |
69 | target_repo, 'rhodecode_diff_cache') |
|
71 | target_repo, 'rhodecode_diff_cache') | |
70 | log.debug('Diff caching enabled: %s', caching_enabled) |
|
72 | log.debug('Diff caching enabled: %s', caching_enabled) | |
71 | return caching_enabled |
|
73 | return caching_enabled | |
72 |
|
74 | |||
73 | def _commit(self, commit_id_range, method): |
|
75 | def _commit(self, commit_id_range, method): | |
74 | _ = self.request.translate |
|
76 | _ = self.request.translate | |
75 | c = self.load_default_context() |
|
77 | c = self.load_default_context() | |
76 | c.fulldiff = self.request.GET.get('fulldiff') |
|
78 | c.fulldiff = self.request.GET.get('fulldiff') | |
77 |
|
79 | |||
78 | # fetch global flags of ignore ws or context lines |
|
80 | # fetch global flags of ignore ws or context lines | |
79 | diff_context = get_diff_context(self.request) |
|
81 | diff_context = get_diff_context(self.request) | |
80 | hide_whitespace_changes = get_diff_whitespace_flag(self.request) |
|
82 | hide_whitespace_changes = get_diff_whitespace_flag(self.request) | |
81 |
|
83 | |||
82 | # diff_limit will cut off the whole diff if the limit is applied |
|
84 | # diff_limit will cut off the whole diff if the limit is applied | |
83 | # otherwise it will just hide the big files from the front-end |
|
85 | # otherwise it will just hide the big files from the front-end | |
84 | diff_limit = c.visual.cut_off_limit_diff |
|
86 | diff_limit = c.visual.cut_off_limit_diff | |
85 | file_limit = c.visual.cut_off_limit_file |
|
87 | file_limit = c.visual.cut_off_limit_file | |
86 |
|
88 | |||
87 | # get ranges of commit ids if preset |
|
89 | # get ranges of commit ids if preset | |
88 | commit_range = commit_id_range.split('...')[:2] |
|
90 | commit_range = commit_id_range.split('...')[:2] | |
89 |
|
91 | |||
90 | try: |
|
92 | try: | |
91 | pre_load = ['affected_files', 'author', 'branch', 'date', |
|
93 | pre_load = ['affected_files', 'author', 'branch', 'date', | |
92 | 'message', 'parents'] |
|
94 | 'message', 'parents'] | |
93 | if self.rhodecode_vcs_repo.alias == 'hg': |
|
95 | if self.rhodecode_vcs_repo.alias == 'hg': | |
94 | pre_load += ['hidden', 'obsolete', 'phase'] |
|
96 | pre_load += ['hidden', 'obsolete', 'phase'] | |
95 |
|
97 | |||
96 | if len(commit_range) == 2: |
|
98 | if len(commit_range) == 2: | |
97 | commits = self.rhodecode_vcs_repo.get_commits( |
|
99 | commits = self.rhodecode_vcs_repo.get_commits( | |
98 | start_id=commit_range[0], end_id=commit_range[1], |
|
100 | start_id=commit_range[0], end_id=commit_range[1], | |
99 | pre_load=pre_load, translate_tags=False) |
|
101 | pre_load=pre_load, translate_tags=False) | |
100 | commits = list(commits) |
|
102 | commits = list(commits) | |
101 | else: |
|
103 | else: | |
102 | commits = [self.rhodecode_vcs_repo.get_commit( |
|
104 | commits = [self.rhodecode_vcs_repo.get_commit( | |
103 | commit_id=commit_id_range, pre_load=pre_load)] |
|
105 | commit_id=commit_id_range, pre_load=pre_load)] | |
104 |
|
106 | |||
105 | c.commit_ranges = commits |
|
107 | c.commit_ranges = commits | |
106 | if not c.commit_ranges: |
|
108 | if not c.commit_ranges: | |
107 | raise RepositoryError('The commit range returned an empty result') |
|
109 | raise RepositoryError('The commit range returned an empty result') | |
108 | except CommitDoesNotExistError as e: |
|
110 | except CommitDoesNotExistError as e: | |
109 | msg = _('No such commit exists. Org exception: `{}`').format(e) |
|
111 | msg = _('No such commit exists. Org exception: `{}`').format(e) | |
110 | h.flash(msg, category='error') |
|
112 | h.flash(msg, category='error') | |
111 | raise HTTPNotFound() |
|
113 | raise HTTPNotFound() | |
112 | except Exception: |
|
114 | except Exception: | |
113 | log.exception("General failure") |
|
115 | log.exception("General failure") | |
114 | raise HTTPNotFound() |
|
116 | raise HTTPNotFound() | |
115 |
|
117 | |||
116 | c.changes = OrderedDict() |
|
118 | c.changes = OrderedDict() | |
117 | c.lines_added = 0 |
|
119 | c.lines_added = 0 | |
118 | c.lines_deleted = 0 |
|
120 | c.lines_deleted = 0 | |
119 |
|
121 | |||
120 | # auto collapse if we have more than limit |
|
122 | # auto collapse if we have more than limit | |
121 | collapse_limit = diffs.DiffProcessor._collapse_commits_over |
|
123 | collapse_limit = diffs.DiffProcessor._collapse_commits_over | |
122 | c.collapse_all_commits = len(c.commit_ranges) > collapse_limit |
|
124 | c.collapse_all_commits = len(c.commit_ranges) > collapse_limit | |
123 |
|
125 | |||
124 | c.commit_statuses = ChangesetStatus.STATUSES |
|
126 | c.commit_statuses = ChangesetStatus.STATUSES | |
125 | c.inline_comments = [] |
|
127 | c.inline_comments = [] | |
126 | c.files = [] |
|
128 | c.files = [] | |
127 |
|
129 | |||
128 | c.statuses = [] |
|
130 | c.statuses = [] | |
129 | c.comments = [] |
|
131 | c.comments = [] | |
130 | c.unresolved_comments = [] |
|
132 | c.unresolved_comments = [] | |
131 | c.resolved_comments = [] |
|
133 | c.resolved_comments = [] | |
132 | if len(c.commit_ranges) == 1: |
|
134 | if len(c.commit_ranges) == 1: | |
133 | commit = c.commit_ranges[0] |
|
135 | commit = c.commit_ranges[0] | |
134 | c.comments = CommentsModel().get_comments( |
|
136 | c.comments = CommentsModel().get_comments( | |
135 | self.db_repo.repo_id, |
|
137 | self.db_repo.repo_id, | |
136 | revision=commit.raw_id) |
|
138 | revision=commit.raw_id) | |
137 | c.statuses.append(ChangesetStatusModel().get_status( |
|
139 | c.statuses.append(ChangesetStatusModel().get_status( | |
138 | self.db_repo.repo_id, commit.raw_id)) |
|
140 | self.db_repo.repo_id, commit.raw_id)) | |
139 | # comments from PR |
|
141 | # comments from PR | |
140 | statuses = ChangesetStatusModel().get_statuses( |
|
142 | statuses = ChangesetStatusModel().get_statuses( | |
141 | self.db_repo.repo_id, commit.raw_id, |
|
143 | self.db_repo.repo_id, commit.raw_id, | |
142 | with_revisions=True) |
|
144 | with_revisions=True) | |
143 | prs = set(st.pull_request for st in statuses |
|
145 | prs = set(st.pull_request for st in statuses | |
144 | if st.pull_request is not None) |
|
146 | if st.pull_request is not None) | |
145 | # from associated statuses, check the pull requests, and |
|
147 | # from associated statuses, check the pull requests, and | |
146 | # show comments from them |
|
148 | # show comments from them | |
147 | for pr in prs: |
|
149 | for pr in prs: | |
148 | c.comments.extend(pr.comments) |
|
150 | c.comments.extend(pr.comments) | |
149 |
|
151 | |||
150 | c.unresolved_comments = CommentsModel()\ |
|
152 | c.unresolved_comments = CommentsModel()\ | |
151 | .get_commit_unresolved_todos(commit.raw_id) |
|
153 | .get_commit_unresolved_todos(commit.raw_id) | |
152 | c.resolved_comments = CommentsModel()\ |
|
154 | c.resolved_comments = CommentsModel()\ | |
153 | .get_commit_resolved_todos(commit.raw_id) |
|
155 | .get_commit_resolved_todos(commit.raw_id) | |
154 |
|
156 | |||
155 | diff = None |
|
157 | diff = None | |
156 | # Iterate over ranges (default commit view is always one commit) |
|
158 | # Iterate over ranges (default commit view is always one commit) | |
157 | for commit in c.commit_ranges: |
|
159 | for commit in c.commit_ranges: | |
158 | c.changes[commit.raw_id] = [] |
|
160 | c.changes[commit.raw_id] = [] | |
159 |
|
161 | |||
160 | commit2 = commit |
|
162 | commit2 = commit | |
161 | commit1 = commit.first_parent |
|
163 | commit1 = commit.first_parent | |
162 |
|
164 | |||
163 | if method == 'show': |
|
165 | if method == 'show': | |
164 | inline_comments = CommentsModel().get_inline_comments( |
|
166 | inline_comments = CommentsModel().get_inline_comments( | |
165 | self.db_repo.repo_id, revision=commit.raw_id) |
|
167 | self.db_repo.repo_id, revision=commit.raw_id) | |
166 | c.inline_cnt = CommentsModel().get_inline_comments_count( |
|
168 | c.inline_cnt = CommentsModel().get_inline_comments_count( | |
167 | inline_comments) |
|
169 | inline_comments) | |
168 | c.inline_comments = inline_comments |
|
170 | c.inline_comments = inline_comments | |
169 |
|
171 | |||
170 | cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path( |
|
172 | cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path( | |
171 | self.db_repo) |
|
173 | self.db_repo) | |
172 | cache_file_path = diff_cache_exist( |
|
174 | cache_file_path = diff_cache_exist( | |
173 | cache_path, 'diff', commit.raw_id, |
|
175 | cache_path, 'diff', commit.raw_id, | |
174 | hide_whitespace_changes, diff_context, c.fulldiff) |
|
176 | hide_whitespace_changes, diff_context, c.fulldiff) | |
175 |
|
177 | |||
176 | caching_enabled = self._is_diff_cache_enabled(self.db_repo) |
|
178 | caching_enabled = self._is_diff_cache_enabled(self.db_repo) | |
177 | force_recache = str2bool(self.request.GET.get('force_recache')) |
|
179 | force_recache = str2bool(self.request.GET.get('force_recache')) | |
178 |
|
180 | |||
179 | cached_diff = None |
|
181 | cached_diff = None | |
180 | if caching_enabled: |
|
182 | if caching_enabled: | |
181 | cached_diff = load_cached_diff(cache_file_path) |
|
183 | cached_diff = load_cached_diff(cache_file_path) | |
182 |
|
184 | |||
183 | has_proper_diff_cache = cached_diff and cached_diff.get('diff') |
|
185 | has_proper_diff_cache = cached_diff and cached_diff.get('diff') | |
184 | if not force_recache and has_proper_diff_cache: |
|
186 | if not force_recache and has_proper_diff_cache: | |
185 | diffset = cached_diff['diff'] |
|
187 | diffset = cached_diff['diff'] | |
186 | else: |
|
188 | else: | |
187 | vcs_diff = self.rhodecode_vcs_repo.get_diff( |
|
189 | vcs_diff = self.rhodecode_vcs_repo.get_diff( | |
188 | commit1, commit2, |
|
190 | commit1, commit2, | |
189 | ignore_whitespace=hide_whitespace_changes, |
|
191 | ignore_whitespace=hide_whitespace_changes, | |
190 | context=diff_context) |
|
192 | context=diff_context) | |
191 |
|
193 | |||
192 | diff_processor = diffs.DiffProcessor( |
|
194 | diff_processor = diffs.DiffProcessor( | |
193 | vcs_diff, format='newdiff', diff_limit=diff_limit, |
|
195 | vcs_diff, format='newdiff', diff_limit=diff_limit, | |
194 | file_limit=file_limit, show_full_diff=c.fulldiff) |
|
196 | file_limit=file_limit, show_full_diff=c.fulldiff) | |
195 |
|
197 | |||
196 | _parsed = diff_processor.prepare() |
|
198 | _parsed = diff_processor.prepare() | |
197 |
|
199 | |||
198 | diffset = codeblocks.DiffSet( |
|
200 | diffset = codeblocks.DiffSet( | |
199 | repo_name=self.db_repo_name, |
|
201 | repo_name=self.db_repo_name, | |
200 | source_node_getter=codeblocks.diffset_node_getter(commit1), |
|
202 | source_node_getter=codeblocks.diffset_node_getter(commit1), | |
201 | target_node_getter=codeblocks.diffset_node_getter(commit2)) |
|
203 | target_node_getter=codeblocks.diffset_node_getter(commit2)) | |
202 |
|
204 | |||
203 | diffset = self.path_filter.render_patchset_filtered( |
|
205 | diffset = self.path_filter.render_patchset_filtered( | |
204 | diffset, _parsed, commit1.raw_id, commit2.raw_id) |
|
206 | diffset, _parsed, commit1.raw_id, commit2.raw_id) | |
205 |
|
207 | |||
206 | # save cached diff |
|
208 | # save cached diff | |
207 | if caching_enabled: |
|
209 | if caching_enabled: | |
208 | cache_diff(cache_file_path, diffset, None) |
|
210 | cache_diff(cache_file_path, diffset, None) | |
209 |
|
211 | |||
210 | c.limited_diff = diffset.limited_diff |
|
212 | c.limited_diff = diffset.limited_diff | |
211 | c.changes[commit.raw_id] = diffset |
|
213 | c.changes[commit.raw_id] = diffset | |
212 | else: |
|
214 | else: | |
213 | # TODO(marcink): no cache usage here... |
|
215 | # TODO(marcink): no cache usage here... | |
214 | _diff = self.rhodecode_vcs_repo.get_diff( |
|
216 | _diff = self.rhodecode_vcs_repo.get_diff( | |
215 | commit1, commit2, |
|
217 | commit1, commit2, | |
216 | ignore_whitespace=hide_whitespace_changes, context=diff_context) |
|
218 | ignore_whitespace=hide_whitespace_changes, context=diff_context) | |
217 | diff_processor = diffs.DiffProcessor( |
|
219 | diff_processor = diffs.DiffProcessor( | |
218 | _diff, format='newdiff', diff_limit=diff_limit, |
|
220 | _diff, format='newdiff', diff_limit=diff_limit, | |
219 | file_limit=file_limit, show_full_diff=c.fulldiff) |
|
221 | file_limit=file_limit, show_full_diff=c.fulldiff) | |
220 | # downloads/raw we only need RAW diff nothing else |
|
222 | # downloads/raw we only need RAW diff nothing else | |
221 | diff = self.path_filter.get_raw_patch(diff_processor) |
|
223 | diff = self.path_filter.get_raw_patch(diff_processor) | |
222 | c.changes[commit.raw_id] = [None, None, None, None, diff, None, None] |
|
224 | c.changes[commit.raw_id] = [None, None, None, None, diff, None, None] | |
223 |
|
225 | |||
224 | # sort comments by how they were generated |
|
226 | # sort comments by how they were generated | |
225 | c.comments = sorted(c.comments, key=lambda x: x.comment_id) |
|
227 | c.comments = sorted(c.comments, key=lambda x: x.comment_id) | |
226 |
|
228 | |||
227 | if len(c.commit_ranges) == 1: |
|
229 | if len(c.commit_ranges) == 1: | |
228 | c.commit = c.commit_ranges[0] |
|
230 | c.commit = c.commit_ranges[0] | |
229 | c.parent_tmpl = ''.join( |
|
231 | c.parent_tmpl = ''.join( | |
230 | '# Parent %s\n' % x.raw_id for x in c.commit.parents) |
|
232 | '# Parent %s\n' % x.raw_id for x in c.commit.parents) | |
231 |
|
233 | |||
232 | if method == 'download': |
|
234 | if method == 'download': | |
233 | response = Response(diff) |
|
235 | response = Response(diff) | |
234 | response.content_type = 'text/plain' |
|
236 | response.content_type = 'text/plain' | |
235 | response.content_disposition = ( |
|
237 | response.content_disposition = ( | |
236 | 'attachment; filename=%s.diff' % commit_id_range[:12]) |
|
238 | 'attachment; filename=%s.diff' % commit_id_range[:12]) | |
237 | return response |
|
239 | return response | |
238 | elif method == 'patch': |
|
240 | elif method == 'patch': | |
239 | c.diff = safe_unicode(diff) |
|
241 | c.diff = safe_unicode(diff) | |
240 | patch = render( |
|
242 | patch = render( | |
241 | 'rhodecode:templates/changeset/patch_changeset.mako', |
|
243 | 'rhodecode:templates/changeset/patch_changeset.mako', | |
242 | self._get_template_context(c), self.request) |
|
244 | self._get_template_context(c), self.request) | |
243 | response = Response(patch) |
|
245 | response = Response(patch) | |
244 | response.content_type = 'text/plain' |
|
246 | response.content_type = 'text/plain' | |
245 | return response |
|
247 | return response | |
246 | elif method == 'raw': |
|
248 | elif method == 'raw': | |
247 | response = Response(diff) |
|
249 | response = Response(diff) | |
248 | response.content_type = 'text/plain' |
|
250 | response.content_type = 'text/plain' | |
249 | return response |
|
251 | return response | |
250 | elif method == 'show': |
|
252 | elif method == 'show': | |
251 | if len(c.commit_ranges) == 1: |
|
253 | if len(c.commit_ranges) == 1: | |
252 | html = render( |
|
254 | html = render( | |
253 | 'rhodecode:templates/changeset/changeset.mako', |
|
255 | 'rhodecode:templates/changeset/changeset.mako', | |
254 | self._get_template_context(c), self.request) |
|
256 | self._get_template_context(c), self.request) | |
255 | return Response(html) |
|
257 | return Response(html) | |
256 | else: |
|
258 | else: | |
257 | c.ancestor = None |
|
259 | c.ancestor = None | |
258 | c.target_repo = self.db_repo |
|
260 | c.target_repo = self.db_repo | |
259 | html = render( |
|
261 | html = render( | |
260 | 'rhodecode:templates/changeset/changeset_range.mako', |
|
262 | 'rhodecode:templates/changeset/changeset_range.mako', | |
261 | self._get_template_context(c), self.request) |
|
263 | self._get_template_context(c), self.request) | |
262 | return Response(html) |
|
264 | return Response(html) | |
263 |
|
265 | |||
264 | raise HTTPBadRequest() |
|
266 | raise HTTPBadRequest() | |
265 |
|
267 | |||
266 | @LoginRequired() |
|
268 | @LoginRequired() | |
267 | @HasRepoPermissionAnyDecorator( |
|
269 | @HasRepoPermissionAnyDecorator( | |
268 | 'repository.read', 'repository.write', 'repository.admin') |
|
270 | 'repository.read', 'repository.write', 'repository.admin') | |
269 | @view_config( |
|
271 | @view_config( | |
270 | route_name='repo_commit', request_method='GET', |
|
272 | route_name='repo_commit', request_method='GET', | |
271 | renderer=None) |
|
273 | renderer=None) | |
272 | def repo_commit_show(self): |
|
274 | def repo_commit_show(self): | |
273 | commit_id = self.request.matchdict['commit_id'] |
|
275 | commit_id = self.request.matchdict['commit_id'] | |
274 | return self._commit(commit_id, method='show') |
|
276 | return self._commit(commit_id, method='show') | |
275 |
|
277 | |||
276 | @LoginRequired() |
|
278 | @LoginRequired() | |
277 | @HasRepoPermissionAnyDecorator( |
|
279 | @HasRepoPermissionAnyDecorator( | |
278 | 'repository.read', 'repository.write', 'repository.admin') |
|
280 | 'repository.read', 'repository.write', 'repository.admin') | |
279 | @view_config( |
|
281 | @view_config( | |
280 | route_name='repo_commit_raw', request_method='GET', |
|
282 | route_name='repo_commit_raw', request_method='GET', | |
281 | renderer=None) |
|
283 | renderer=None) | |
282 | @view_config( |
|
284 | @view_config( | |
283 | route_name='repo_commit_raw_deprecated', request_method='GET', |
|
285 | route_name='repo_commit_raw_deprecated', request_method='GET', | |
284 | renderer=None) |
|
286 | renderer=None) | |
285 | def repo_commit_raw(self): |
|
287 | def repo_commit_raw(self): | |
286 | commit_id = self.request.matchdict['commit_id'] |
|
288 | commit_id = self.request.matchdict['commit_id'] | |
287 | return self._commit(commit_id, method='raw') |
|
289 | return self._commit(commit_id, method='raw') | |
288 |
|
290 | |||
289 | @LoginRequired() |
|
291 | @LoginRequired() | |
290 | @HasRepoPermissionAnyDecorator( |
|
292 | @HasRepoPermissionAnyDecorator( | |
291 | 'repository.read', 'repository.write', 'repository.admin') |
|
293 | 'repository.read', 'repository.write', 'repository.admin') | |
292 | @view_config( |
|
294 | @view_config( | |
293 | route_name='repo_commit_patch', request_method='GET', |
|
295 | route_name='repo_commit_patch', request_method='GET', | |
294 | renderer=None) |
|
296 | renderer=None) | |
295 | def repo_commit_patch(self): |
|
297 | def repo_commit_patch(self): | |
296 | commit_id = self.request.matchdict['commit_id'] |
|
298 | commit_id = self.request.matchdict['commit_id'] | |
297 | return self._commit(commit_id, method='patch') |
|
299 | return self._commit(commit_id, method='patch') | |
298 |
|
300 | |||
299 | @LoginRequired() |
|
301 | @LoginRequired() | |
300 | @HasRepoPermissionAnyDecorator( |
|
302 | @HasRepoPermissionAnyDecorator( | |
301 | 'repository.read', 'repository.write', 'repository.admin') |
|
303 | 'repository.read', 'repository.write', 'repository.admin') | |
302 | @view_config( |
|
304 | @view_config( | |
303 | route_name='repo_commit_download', request_method='GET', |
|
305 | route_name='repo_commit_download', request_method='GET', | |
304 | renderer=None) |
|
306 | renderer=None) | |
305 | def repo_commit_download(self): |
|
307 | def repo_commit_download(self): | |
306 | commit_id = self.request.matchdict['commit_id'] |
|
308 | commit_id = self.request.matchdict['commit_id'] | |
307 | return self._commit(commit_id, method='download') |
|
309 | return self._commit(commit_id, method='download') | |
308 |
|
310 | |||
309 | @LoginRequired() |
|
311 | @LoginRequired() | |
310 | @NotAnonymous() |
|
312 | @NotAnonymous() | |
311 | @HasRepoPermissionAnyDecorator( |
|
313 | @HasRepoPermissionAnyDecorator( | |
312 | 'repository.read', 'repository.write', 'repository.admin') |
|
314 | 'repository.read', 'repository.write', 'repository.admin') | |
313 | @CSRFRequired() |
|
315 | @CSRFRequired() | |
314 | @view_config( |
|
316 | @view_config( | |
315 | route_name='repo_commit_comment_create', request_method='POST', |
|
317 | route_name='repo_commit_comment_create', request_method='POST', | |
316 | renderer='json_ext') |
|
318 | renderer='json_ext') | |
317 | def repo_commit_comment_create(self): |
|
319 | def repo_commit_comment_create(self): | |
318 | _ = self.request.translate |
|
320 | _ = self.request.translate | |
319 | commit_id = self.request.matchdict['commit_id'] |
|
321 | commit_id = self.request.matchdict['commit_id'] | |
320 |
|
322 | |||
321 | c = self.load_default_context() |
|
323 | c = self.load_default_context() | |
322 | status = self.request.POST.get('changeset_status', None) |
|
324 | status = self.request.POST.get('changeset_status', None) | |
323 | text = self.request.POST.get('text') |
|
325 | text = self.request.POST.get('text') | |
324 | comment_type = self.request.POST.get('comment_type') |
|
326 | comment_type = self.request.POST.get('comment_type') | |
325 | resolves_comment_id = self.request.POST.get('resolves_comment_id', None) |
|
327 | resolves_comment_id = self.request.POST.get('resolves_comment_id', None) | |
326 |
|
328 | |||
327 | if status: |
|
329 | if status: | |
328 | text = text or (_('Status change %(transition_icon)s %(status)s') |
|
330 | text = text or (_('Status change %(transition_icon)s %(status)s') | |
329 | % {'transition_icon': '>', |
|
331 | % {'transition_icon': '>', | |
330 | 'status': ChangesetStatus.get_status_lbl(status)}) |
|
332 | 'status': ChangesetStatus.get_status_lbl(status)}) | |
331 |
|
333 | |||
332 | multi_commit_ids = [] |
|
334 | multi_commit_ids = [] | |
333 | for _commit_id in self.request.POST.get('commit_ids', '').split(','): |
|
335 | for _commit_id in self.request.POST.get('commit_ids', '').split(','): | |
334 | if _commit_id not in ['', None, EmptyCommit.raw_id]: |
|
336 | if _commit_id not in ['', None, EmptyCommit.raw_id]: | |
335 | if _commit_id not in multi_commit_ids: |
|
337 | if _commit_id not in multi_commit_ids: | |
336 | multi_commit_ids.append(_commit_id) |
|
338 | multi_commit_ids.append(_commit_id) | |
337 |
|
339 | |||
338 | commit_ids = multi_commit_ids or [commit_id] |
|
340 | commit_ids = multi_commit_ids or [commit_id] | |
339 |
|
341 | |||
340 | comment = None |
|
342 | comment = None | |
341 | for current_id in filter(None, commit_ids): |
|
343 | for current_id in filter(None, commit_ids): | |
342 | comment = CommentsModel().create( |
|
344 | comment = CommentsModel().create( | |
343 | text=text, |
|
345 | text=text, | |
344 | repo=self.db_repo.repo_id, |
|
346 | repo=self.db_repo.repo_id, | |
345 | user=self._rhodecode_db_user.user_id, |
|
347 | user=self._rhodecode_db_user.user_id, | |
346 | commit_id=current_id, |
|
348 | commit_id=current_id, | |
347 | f_path=self.request.POST.get('f_path'), |
|
349 | f_path=self.request.POST.get('f_path'), | |
348 | line_no=self.request.POST.get('line'), |
|
350 | line_no=self.request.POST.get('line'), | |
349 | status_change=(ChangesetStatus.get_status_lbl(status) |
|
351 | status_change=(ChangesetStatus.get_status_lbl(status) | |
350 | if status else None), |
|
352 | if status else None), | |
351 | status_change_type=status, |
|
353 | status_change_type=status, | |
352 | comment_type=comment_type, |
|
354 | comment_type=comment_type, | |
353 | resolves_comment_id=resolves_comment_id, |
|
355 | resolves_comment_id=resolves_comment_id, | |
354 | auth_user=self._rhodecode_user |
|
356 | auth_user=self._rhodecode_user | |
355 | ) |
|
357 | ) | |
356 |
|
358 | |||
357 | # get status if set ! |
|
359 | # get status if set ! | |
358 | if status: |
|
360 | if status: | |
359 | # if latest status was from pull request and it's closed |
|
361 | # if latest status was from pull request and it's closed | |
360 | # disallow changing status ! |
|
362 | # disallow changing status ! | |
361 | # dont_allow_on_closed_pull_request = True ! |
|
363 | # dont_allow_on_closed_pull_request = True ! | |
362 |
|
364 | |||
363 | try: |
|
365 | try: | |
364 | ChangesetStatusModel().set_status( |
|
366 | ChangesetStatusModel().set_status( | |
365 | self.db_repo.repo_id, |
|
367 | self.db_repo.repo_id, | |
366 | status, |
|
368 | status, | |
367 | self._rhodecode_db_user.user_id, |
|
369 | self._rhodecode_db_user.user_id, | |
368 | comment, |
|
370 | comment, | |
369 | revision=current_id, |
|
371 | revision=current_id, | |
370 | dont_allow_on_closed_pull_request=True |
|
372 | dont_allow_on_closed_pull_request=True | |
371 | ) |
|
373 | ) | |
372 | except StatusChangeOnClosedPullRequestError: |
|
374 | except StatusChangeOnClosedPullRequestError: | |
373 | msg = _('Changing the status of a commit associated with ' |
|
375 | msg = _('Changing the status of a commit associated with ' | |
374 | 'a closed pull request is not allowed') |
|
376 | 'a closed pull request is not allowed') | |
375 | log.exception(msg) |
|
377 | log.exception(msg) | |
376 | h.flash(msg, category='warning') |
|
378 | h.flash(msg, category='warning') | |
377 | raise HTTPFound(h.route_path( |
|
379 | raise HTTPFound(h.route_path( | |
378 | 'repo_commit', repo_name=self.db_repo_name, |
|
380 | 'repo_commit', repo_name=self.db_repo_name, | |
379 | commit_id=current_id)) |
|
381 | commit_id=current_id)) | |
380 |
|
382 | |||
381 | # finalize, commit and redirect |
|
383 | # finalize, commit and redirect | |
382 | Session().commit() |
|
384 | Session().commit() | |
383 |
|
385 | |||
384 | data = { |
|
386 | data = { | |
385 | 'target_id': h.safeid(h.safe_unicode( |
|
387 | 'target_id': h.safeid(h.safe_unicode( | |
386 | self.request.POST.get('f_path'))), |
|
388 | self.request.POST.get('f_path'))), | |
387 | } |
|
389 | } | |
388 | if comment: |
|
390 | if comment: | |
389 | c.co = comment |
|
391 | c.co = comment | |
390 | rendered_comment = render( |
|
392 | rendered_comment = render( | |
391 | 'rhodecode:templates/changeset/changeset_comment_block.mako', |
|
393 | 'rhodecode:templates/changeset/changeset_comment_block.mako', | |
392 | self._get_template_context(c), self.request) |
|
394 | self._get_template_context(c), self.request) | |
393 |
|
395 | |||
394 | data.update(comment.get_dict()) |
|
396 | data.update(comment.get_dict()) | |
395 | data.update({'rendered_text': rendered_comment}) |
|
397 | data.update({'rendered_text': rendered_comment}) | |
396 |
|
398 | |||
397 | return data |
|
399 | return data | |
398 |
|
400 | |||
399 | @LoginRequired() |
|
401 | @LoginRequired() | |
400 | @NotAnonymous() |
|
402 | @NotAnonymous() | |
401 | @HasRepoPermissionAnyDecorator( |
|
403 | @HasRepoPermissionAnyDecorator( | |
402 | 'repository.read', 'repository.write', 'repository.admin') |
|
404 | 'repository.read', 'repository.write', 'repository.admin') | |
403 | @CSRFRequired() |
|
405 | @CSRFRequired() | |
404 | @view_config( |
|
406 | @view_config( | |
405 | route_name='repo_commit_comment_preview', request_method='POST', |
|
407 | route_name='repo_commit_comment_preview', request_method='POST', | |
406 | renderer='string', xhr=True) |
|
408 | renderer='string', xhr=True) | |
407 | def repo_commit_comment_preview(self): |
|
409 | def repo_commit_comment_preview(self): | |
408 | # Technically a CSRF token is not needed as no state changes with this |
|
410 | # Technically a CSRF token is not needed as no state changes with this | |
409 | # call. However, as this is a POST is better to have it, so automated |
|
411 | # call. However, as this is a POST is better to have it, so automated | |
410 | # tools don't flag it as potential CSRF. |
|
412 | # tools don't flag it as potential CSRF. | |
411 | # Post is required because the payload could be bigger than the maximum |
|
413 | # Post is required because the payload could be bigger than the maximum | |
412 | # allowed by GET. |
|
414 | # allowed by GET. | |
413 |
|
415 | |||
414 | text = self.request.POST.get('text') |
|
416 | text = self.request.POST.get('text') | |
415 | renderer = self.request.POST.get('renderer') or 'rst' |
|
417 | renderer = self.request.POST.get('renderer') or 'rst' | |
416 | if text: |
|
418 | if text: | |
417 | return h.render(text, renderer=renderer, mentions=True) |
|
419 | return h.render(text, renderer=renderer, mentions=True) | |
418 | return '' |
|
420 | return '' | |
419 |
|
421 | |||
420 | @LoginRequired() |
|
422 | @LoginRequired() | |
421 | @NotAnonymous() |
|
423 | @NotAnonymous() | |
422 | @HasRepoPermissionAnyDecorator( |
|
424 | @HasRepoPermissionAnyDecorator( | |
423 | 'repository.read', 'repository.write', 'repository.admin') |
|
425 | 'repository.read', 'repository.write', 'repository.admin') | |
424 | @CSRFRequired() |
|
426 | @CSRFRequired() | |
425 | @view_config( |
|
427 | @view_config( | |
|
428 | route_name='repo_commit_comment_attachment_upload', request_method='POST', | |||
|
429 | renderer='json_ext', xhr=True) | |||
|
430 | def repo_commit_comment_attachment_upload(self): | |||
|
431 | c = self.load_default_context() | |||
|
432 | upload_key = 'attachment' | |||
|
433 | ||||
|
434 | file_obj = self.request.POST.get(upload_key) | |||
|
435 | ||||
|
436 | if file_obj is None: | |||
|
437 | self.request.response.status = 400 | |||
|
438 | return {'store_fid': None, | |||
|
439 | 'access_path': None, | |||
|
440 | 'error': '{} data field is missing'.format(upload_key)} | |||
|
441 | ||||
|
442 | if not hasattr(file_obj, 'filename'): | |||
|
443 | self.request.response.status = 400 | |||
|
444 | return {'store_fid': None, | |||
|
445 | 'access_path': None, | |||
|
446 | 'error': 'filename cannot be read from the data field'} | |||
|
447 | ||||
|
448 | filename = file_obj.filename | |||
|
449 | file_display_name = filename | |||
|
450 | ||||
|
451 | metadata = { | |||
|
452 | 'user_uploaded': {'username': self._rhodecode_user.username, | |||
|
453 | 'user_id': self._rhodecode_user.user_id, | |||
|
454 | 'ip': self._rhodecode_user.ip_addr}} | |||
|
455 | ||||
|
456 | # TODO(marcink): allow .ini configuration for allowed_extensions, and file-size | |||
|
457 | allowed_extensions = [ | |||
|
458 | 'gif', '.jpeg', '.jpg', '.png', '.docx', '.gz', '.log', '.pdf', | |||
|
459 | '.pptx', '.txt', '.xlsx', '.zip'] | |||
|
460 | max_file_size = 10 * 1024 * 1024 # 10MB, also validated via dropzone.js | |||
|
461 | ||||
|
462 | try: | |||
|
463 | storage = store_utils.get_file_storage(self.request.registry.settings) | |||
|
464 | store_uid, metadata = storage.save_file( | |||
|
465 | file_obj.file, filename, extra_metadata=metadata, | |||
|
466 | extensions=allowed_extensions, max_filesize=max_file_size) | |||
|
467 | except FileNotAllowedException: | |||
|
468 | self.request.response.status = 400 | |||
|
469 | permitted_extensions = ', '.join(allowed_extensions) | |||
|
470 | error_msg = 'File `{}` is not allowed. ' \ | |||
|
471 | 'Only following extensions are permitted: {}'.format( | |||
|
472 | filename, permitted_extensions) | |||
|
473 | return {'store_fid': None, | |||
|
474 | 'access_path': None, | |||
|
475 | 'error': error_msg} | |||
|
476 | except FileOverSizeException: | |||
|
477 | self.request.response.status = 400 | |||
|
478 | limit_mb = h.format_byte_size_binary(max_file_size) | |||
|
479 | return {'store_fid': None, | |||
|
480 | 'access_path': None, | |||
|
481 | 'error': 'File {} is exceeding allowed limit of {}.'.format( | |||
|
482 | filename, limit_mb)} | |||
|
483 | ||||
|
484 | try: | |||
|
485 | entry = FileStore.create( | |||
|
486 | file_uid=store_uid, filename=metadata["filename"], | |||
|
487 | file_hash=metadata["sha256"], file_size=metadata["size"], | |||
|
488 | file_display_name=file_display_name, | |||
|
489 | file_description=u'comment attachment `{}`'.format(safe_unicode(filename)), | |||
|
490 | hidden=True, check_acl=True, user_id=self._rhodecode_user.user_id, | |||
|
491 | scope_repo_id=self.db_repo.repo_id | |||
|
492 | ) | |||
|
493 | Session().add(entry) | |||
|
494 | Session().commit() | |||
|
495 | log.debug('Stored upload in DB as %s', entry) | |||
|
496 | except Exception: | |||
|
497 | log.exception('Failed to store file %s', filename) | |||
|
498 | self.request.response.status = 400 | |||
|
499 | return {'store_fid': None, | |||
|
500 | 'access_path': None, | |||
|
501 | 'error': 'File {} failed to store in DB.'.format(filename)} | |||
|
502 | ||||
|
503 | Session().commit() | |||
|
504 | ||||
|
505 | return { | |||
|
506 | 'store_fid': store_uid, | |||
|
507 | 'access_path': h.route_path( | |||
|
508 | 'download_file', fid=store_uid), | |||
|
509 | 'fqn_access_path': h.route_url( | |||
|
510 | 'download_file', fid=store_uid), | |||
|
511 | 'repo_access_path': h.route_path( | |||
|
512 | 'repo_artifacts_get', repo_name=self.db_repo_name, uid=store_uid), | |||
|
513 | 'repo_fqn_access_path': h.route_url( | |||
|
514 | 'repo_artifacts_get', repo_name=self.db_repo_name, uid=store_uid), | |||
|
515 | } | |||
|
516 | ||||
|
517 | @LoginRequired() | |||
|
518 | @NotAnonymous() | |||
|
519 | @HasRepoPermissionAnyDecorator( | |||
|
520 | 'repository.read', 'repository.write', 'repository.admin') | |||
|
521 | @CSRFRequired() | |||
|
522 | @view_config( | |||
426 | route_name='repo_commit_comment_delete', request_method='POST', |
|
523 | route_name='repo_commit_comment_delete', request_method='POST', | |
427 | renderer='json_ext') |
|
524 | renderer='json_ext') | |
428 | def repo_commit_comment_delete(self): |
|
525 | def repo_commit_comment_delete(self): | |
429 | commit_id = self.request.matchdict['commit_id'] |
|
526 | commit_id = self.request.matchdict['commit_id'] | |
430 | comment_id = self.request.matchdict['comment_id'] |
|
527 | comment_id = self.request.matchdict['comment_id'] | |
431 |
|
528 | |||
432 | comment = ChangesetComment.get_or_404(comment_id) |
|
529 | comment = ChangesetComment.get_or_404(comment_id) | |
433 | if not comment: |
|
530 | if not comment: | |
434 | log.debug('Comment with id:%s not found, skipping', comment_id) |
|
531 | log.debug('Comment with id:%s not found, skipping', comment_id) | |
435 | # comment already deleted in another call probably |
|
532 | # comment already deleted in another call probably | |
436 | return True |
|
533 | return True | |
437 |
|
534 | |||
438 | is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name) |
|
535 | is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name) | |
439 | super_admin = h.HasPermissionAny('hg.admin')() |
|
536 | super_admin = h.HasPermissionAny('hg.admin')() | |
440 | comment_owner = (comment.author.user_id == self._rhodecode_db_user.user_id) |
|
537 | comment_owner = (comment.author.user_id == self._rhodecode_db_user.user_id) | |
441 | is_repo_comment = comment.repo.repo_name == self.db_repo_name |
|
538 | is_repo_comment = comment.repo.repo_name == self.db_repo_name | |
442 | comment_repo_admin = is_repo_admin and is_repo_comment |
|
539 | comment_repo_admin = is_repo_admin and is_repo_comment | |
443 |
|
540 | |||
444 | if super_admin or comment_owner or comment_repo_admin: |
|
541 | if super_admin or comment_owner or comment_repo_admin: | |
445 | CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user) |
|
542 | CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user) | |
446 | Session().commit() |
|
543 | Session().commit() | |
447 | return True |
|
544 | return True | |
448 | else: |
|
545 | else: | |
449 | log.warning('No permissions for user %s to delete comment_id: %s', |
|
546 | log.warning('No permissions for user %s to delete comment_id: %s', | |
450 | self._rhodecode_db_user, comment_id) |
|
547 | self._rhodecode_db_user, comment_id) | |
451 | raise HTTPNotFound() |
|
548 | raise HTTPNotFound() | |
452 |
|
549 | |||
453 | @LoginRequired() |
|
550 | @LoginRequired() | |
454 | @HasRepoPermissionAnyDecorator( |
|
551 | @HasRepoPermissionAnyDecorator( | |
455 | 'repository.read', 'repository.write', 'repository.admin') |
|
552 | 'repository.read', 'repository.write', 'repository.admin') | |
456 | @view_config( |
|
553 | @view_config( | |
457 | route_name='repo_commit_data', request_method='GET', |
|
554 | route_name='repo_commit_data', request_method='GET', | |
458 | renderer='json_ext', xhr=True) |
|
555 | renderer='json_ext', xhr=True) | |
459 | def repo_commit_data(self): |
|
556 | def repo_commit_data(self): | |
460 | commit_id = self.request.matchdict['commit_id'] |
|
557 | commit_id = self.request.matchdict['commit_id'] | |
461 | self.load_default_context() |
|
558 | self.load_default_context() | |
462 |
|
559 | |||
463 | try: |
|
560 | try: | |
464 | return self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) |
|
561 | return self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) | |
465 | except CommitDoesNotExistError as e: |
|
562 | except CommitDoesNotExistError as e: | |
466 | return EmptyCommit(message=str(e)) |
|
563 | return EmptyCommit(message=str(e)) | |
467 |
|
564 | |||
468 | @LoginRequired() |
|
565 | @LoginRequired() | |
469 | @HasRepoPermissionAnyDecorator( |
|
566 | @HasRepoPermissionAnyDecorator( | |
470 | 'repository.read', 'repository.write', 'repository.admin') |
|
567 | 'repository.read', 'repository.write', 'repository.admin') | |
471 | @view_config( |
|
568 | @view_config( | |
472 | route_name='repo_commit_children', request_method='GET', |
|
569 | route_name='repo_commit_children', request_method='GET', | |
473 | renderer='json_ext', xhr=True) |
|
570 | renderer='json_ext', xhr=True) | |
474 | def repo_commit_children(self): |
|
571 | def repo_commit_children(self): | |
475 | commit_id = self.request.matchdict['commit_id'] |
|
572 | commit_id = self.request.matchdict['commit_id'] | |
476 | self.load_default_context() |
|
573 | self.load_default_context() | |
477 |
|
574 | |||
478 | try: |
|
575 | try: | |
479 | commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) |
|
576 | commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) | |
480 | children = commit.children |
|
577 | children = commit.children | |
481 | except CommitDoesNotExistError: |
|
578 | except CommitDoesNotExistError: | |
482 | children = [] |
|
579 | children = [] | |
483 |
|
580 | |||
484 | result = {"results": children} |
|
581 | result = {"results": children} | |
485 | return result |
|
582 | return result | |
486 |
|
583 | |||
487 | @LoginRequired() |
|
584 | @LoginRequired() | |
488 | @HasRepoPermissionAnyDecorator( |
|
585 | @HasRepoPermissionAnyDecorator( | |
489 | 'repository.read', 'repository.write', 'repository.admin') |
|
586 | 'repository.read', 'repository.write', 'repository.admin') | |
490 | @view_config( |
|
587 | @view_config( | |
491 | route_name='repo_commit_parents', request_method='GET', |
|
588 | route_name='repo_commit_parents', request_method='GET', | |
492 | renderer='json_ext') |
|
589 | renderer='json_ext') | |
493 | def repo_commit_parents(self): |
|
590 | def repo_commit_parents(self): | |
494 | commit_id = self.request.matchdict['commit_id'] |
|
591 | commit_id = self.request.matchdict['commit_id'] | |
495 | self.load_default_context() |
|
592 | self.load_default_context() | |
496 |
|
593 | |||
497 | try: |
|
594 | try: | |
498 | commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) |
|
595 | commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id) | |
499 | parents = commit.parents |
|
596 | parents = commit.parents | |
500 | except CommitDoesNotExistError: |
|
597 | except CommitDoesNotExistError: | |
501 | parents = [] |
|
598 | parents = [] | |
502 | result = {"results": parents} |
|
599 | result = {"results": parents} | |
503 | return result |
|
600 | return result |
@@ -1,5216 +1,5218 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2010-2019 RhodeCode GmbH |
|
3 | # Copyright (C) 2010-2019 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
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 string |
|
28 | import string | |
29 | import hashlib |
|
29 | import hashlib | |
30 | import logging |
|
30 | import logging | |
31 | import datetime |
|
31 | import datetime | |
32 | import uuid |
|
32 | import uuid | |
33 | import warnings |
|
33 | import warnings | |
34 | import ipaddress |
|
34 | import ipaddress | |
35 | import functools |
|
35 | import functools | |
36 | import traceback |
|
36 | import traceback | |
37 | import collections |
|
37 | import collections | |
38 |
|
38 | |||
39 | from sqlalchemy import ( |
|
39 | from sqlalchemy import ( | |
40 | or_, and_, not_, func, TypeDecorator, event, |
|
40 | or_, and_, not_, func, TypeDecorator, event, | |
41 | Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column, |
|
41 | Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column, | |
42 | Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary, |
|
42 | Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary, | |
43 | Text, Float, PickleType) |
|
43 | Text, Float, PickleType) | |
44 | from sqlalchemy.sql.expression import true, false, case |
|
44 | from sqlalchemy.sql.expression import true, false, case | |
45 | from sqlalchemy.sql.functions import coalesce, count # pragma: no cover |
|
45 | from sqlalchemy.sql.functions import coalesce, count # pragma: no cover | |
46 | from sqlalchemy.orm import ( |
|
46 | from sqlalchemy.orm import ( | |
47 | relationship, joinedload, class_mapper, validates, aliased) |
|
47 | relationship, joinedload, class_mapper, validates, aliased) | |
48 | from sqlalchemy.ext.declarative import declared_attr |
|
48 | from sqlalchemy.ext.declarative import declared_attr | |
49 | from sqlalchemy.ext.hybrid import hybrid_property |
|
49 | from sqlalchemy.ext.hybrid import hybrid_property | |
50 | from sqlalchemy.exc import IntegrityError # pragma: no cover |
|
50 | from sqlalchemy.exc import IntegrityError # pragma: no cover | |
51 | from sqlalchemy.dialects.mysql import LONGTEXT |
|
51 | from sqlalchemy.dialects.mysql import LONGTEXT | |
52 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
52 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
53 | from pyramid import compat |
|
53 | from pyramid import compat | |
54 | from pyramid.threadlocal import get_current_request |
|
54 | from pyramid.threadlocal import get_current_request | |
55 | from webhelpers.text import collapse, remove_formatting |
|
55 | from webhelpers.text import collapse, remove_formatting | |
56 |
|
56 | |||
57 | from rhodecode.translation import _ |
|
57 | from rhodecode.translation import _ | |
58 | from rhodecode.lib.vcs import get_vcs_instance |
|
58 | from rhodecode.lib.vcs import get_vcs_instance | |
59 | from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference |
|
59 | from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference | |
60 | from rhodecode.lib.utils2 import ( |
|
60 | from rhodecode.lib.utils2 import ( | |
61 | str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe, |
|
61 | str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe, | |
62 | time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict, |
|
62 | time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict, | |
63 | glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time, OrderedDefaultDict) |
|
63 | glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time, OrderedDefaultDict) | |
64 | from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \ |
|
64 | from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \ | |
65 | JsonRaw |
|
65 | JsonRaw | |
66 | from rhodecode.lib.ext_json import json |
|
66 | from rhodecode.lib.ext_json import json | |
67 | from rhodecode.lib.caching_query import FromCache |
|
67 | from rhodecode.lib.caching_query import FromCache | |
68 | from rhodecode.lib.encrypt import AESCipher, validate_and_get_enc_data |
|
68 | from rhodecode.lib.encrypt import AESCipher, validate_and_get_enc_data | |
69 | from rhodecode.lib.encrypt2 import Encryptor |
|
69 | from rhodecode.lib.encrypt2 import Encryptor | |
70 | from rhodecode.model.meta import Base, Session |
|
70 | from rhodecode.model.meta import Base, Session | |
71 |
|
71 | |||
72 | URL_SEP = '/' |
|
72 | URL_SEP = '/' | |
73 | log = logging.getLogger(__name__) |
|
73 | log = logging.getLogger(__name__) | |
74 |
|
74 | |||
75 | # ============================================================================= |
|
75 | # ============================================================================= | |
76 | # BASE CLASSES |
|
76 | # BASE CLASSES | |
77 | # ============================================================================= |
|
77 | # ============================================================================= | |
78 |
|
78 | |||
79 | # this is propagated from .ini file rhodecode.encrypted_values.secret or |
|
79 | # this is propagated from .ini file rhodecode.encrypted_values.secret or | |
80 | # beaker.session.secret if first is not set. |
|
80 | # beaker.session.secret if first is not set. | |
81 | # and initialized at environment.py |
|
81 | # and initialized at environment.py | |
82 | ENCRYPTION_KEY = None |
|
82 | ENCRYPTION_KEY = None | |
83 |
|
83 | |||
84 | # used to sort permissions by types, '#' used here is not allowed to be in |
|
84 | # used to sort permissions by types, '#' used here is not allowed to be in | |
85 | # usernames, and it's very early in sorted string.printable table. |
|
85 | # usernames, and it's very early in sorted string.printable table. | |
86 | PERMISSION_TYPE_SORT = { |
|
86 | PERMISSION_TYPE_SORT = { | |
87 | 'admin': '####', |
|
87 | 'admin': '####', | |
88 | 'write': '###', |
|
88 | 'write': '###', | |
89 | 'read': '##', |
|
89 | 'read': '##', | |
90 | 'none': '#', |
|
90 | 'none': '#', | |
91 | } |
|
91 | } | |
92 |
|
92 | |||
93 |
|
93 | |||
94 | def display_user_sort(obj): |
|
94 | def display_user_sort(obj): | |
95 | """ |
|
95 | """ | |
96 | Sort function used to sort permissions in .permissions() function of |
|
96 | Sort function used to sort permissions in .permissions() function of | |
97 | Repository, RepoGroup, UserGroup. Also it put the default user in front |
|
97 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
98 | of all other resources |
|
98 | of all other resources | |
99 | """ |
|
99 | """ | |
100 |
|
100 | |||
101 | if obj.username == User.DEFAULT_USER: |
|
101 | if obj.username == User.DEFAULT_USER: | |
102 | return '#####' |
|
102 | return '#####' | |
103 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') |
|
103 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
104 | return prefix + obj.username |
|
104 | return prefix + obj.username | |
105 |
|
105 | |||
106 |
|
106 | |||
107 | def display_user_group_sort(obj): |
|
107 | def display_user_group_sort(obj): | |
108 | """ |
|
108 | """ | |
109 | Sort function used to sort permissions in .permissions() function of |
|
109 | Sort function used to sort permissions in .permissions() function of | |
110 | Repository, RepoGroup, UserGroup. Also it put the default user in front |
|
110 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
111 | of all other resources |
|
111 | of all other resources | |
112 | """ |
|
112 | """ | |
113 |
|
113 | |||
114 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') |
|
114 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
115 | return prefix + obj.users_group_name |
|
115 | return prefix + obj.users_group_name | |
116 |
|
116 | |||
117 |
|
117 | |||
118 | def _hash_key(k): |
|
118 | def _hash_key(k): | |
119 | return sha1_safe(k) |
|
119 | return sha1_safe(k) | |
120 |
|
120 | |||
121 |
|
121 | |||
122 | def in_filter_generator(qry, items, limit=500): |
|
122 | def in_filter_generator(qry, items, limit=500): | |
123 | """ |
|
123 | """ | |
124 | Splits IN() into multiple with OR |
|
124 | Splits IN() into multiple with OR | |
125 | e.g.:: |
|
125 | e.g.:: | |
126 | cnt = Repository.query().filter( |
|
126 | cnt = Repository.query().filter( | |
127 | or_( |
|
127 | or_( | |
128 | *in_filter_generator(Repository.repo_id, range(100000)) |
|
128 | *in_filter_generator(Repository.repo_id, range(100000)) | |
129 | )).count() |
|
129 | )).count() | |
130 | """ |
|
130 | """ | |
131 | if not items: |
|
131 | if not items: | |
132 | # empty list will cause empty query which might cause security issues |
|
132 | # empty list will cause empty query which might cause security issues | |
133 | # this can lead to hidden unpleasant results |
|
133 | # this can lead to hidden unpleasant results | |
134 | items = [-1] |
|
134 | items = [-1] | |
135 |
|
135 | |||
136 | parts = [] |
|
136 | parts = [] | |
137 | for chunk in xrange(0, len(items), limit): |
|
137 | for chunk in xrange(0, len(items), limit): | |
138 | parts.append( |
|
138 | parts.append( | |
139 | qry.in_(items[chunk: chunk + limit]) |
|
139 | qry.in_(items[chunk: chunk + limit]) | |
140 | ) |
|
140 | ) | |
141 |
|
141 | |||
142 | return parts |
|
142 | return parts | |
143 |
|
143 | |||
144 |
|
144 | |||
145 | base_table_args = { |
|
145 | base_table_args = { | |
146 | 'extend_existing': True, |
|
146 | 'extend_existing': True, | |
147 | 'mysql_engine': 'InnoDB', |
|
147 | 'mysql_engine': 'InnoDB', | |
148 | 'mysql_charset': 'utf8', |
|
148 | 'mysql_charset': 'utf8', | |
149 | 'sqlite_autoincrement': True |
|
149 | 'sqlite_autoincrement': True | |
150 | } |
|
150 | } | |
151 |
|
151 | |||
152 |
|
152 | |||
153 | class EncryptedTextValue(TypeDecorator): |
|
153 | class EncryptedTextValue(TypeDecorator): | |
154 | """ |
|
154 | """ | |
155 | Special column for encrypted long text data, use like:: |
|
155 | Special column for encrypted long text data, use like:: | |
156 |
|
156 | |||
157 | value = Column("encrypted_value", EncryptedValue(), nullable=False) |
|
157 | value = Column("encrypted_value", EncryptedValue(), nullable=False) | |
158 |
|
158 | |||
159 | This column is intelligent so if value is in unencrypted form it return |
|
159 | This column is intelligent so if value is in unencrypted form it return | |
160 | unencrypted form, but on save it always encrypts |
|
160 | unencrypted form, but on save it always encrypts | |
161 | """ |
|
161 | """ | |
162 | impl = Text |
|
162 | impl = Text | |
163 |
|
163 | |||
164 | def process_bind_param(self, value, dialect): |
|
164 | def process_bind_param(self, value, dialect): | |
165 | """ |
|
165 | """ | |
166 | Setter for storing value |
|
166 | Setter for storing value | |
167 | """ |
|
167 | """ | |
168 | import rhodecode |
|
168 | import rhodecode | |
169 | if not value: |
|
169 | if not value: | |
170 | return value |
|
170 | return value | |
171 |
|
171 | |||
172 | # protect against double encrypting if values is already encrypted |
|
172 | # protect against double encrypting if values is already encrypted | |
173 | if value.startswith('enc$aes$') \ |
|
173 | if value.startswith('enc$aes$') \ | |
174 | or value.startswith('enc$aes_hmac$') \ |
|
174 | or value.startswith('enc$aes_hmac$') \ | |
175 | or value.startswith('enc2$'): |
|
175 | or value.startswith('enc2$'): | |
176 | raise ValueError('value needs to be in unencrypted format, ' |
|
176 | raise ValueError('value needs to be in unencrypted format, ' | |
177 | 'ie. not starting with enc$ or enc2$') |
|
177 | 'ie. not starting with enc$ or enc2$') | |
178 |
|
178 | |||
179 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' |
|
179 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' | |
180 | if algo == 'aes': |
|
180 | if algo == 'aes': | |
181 | return 'enc$aes_hmac$%s' % AESCipher(ENCRYPTION_KEY, hmac=True).encrypt(value) |
|
181 | return 'enc$aes_hmac$%s' % AESCipher(ENCRYPTION_KEY, hmac=True).encrypt(value) | |
182 | elif algo == 'fernet': |
|
182 | elif algo == 'fernet': | |
183 | return Encryptor(ENCRYPTION_KEY).encrypt(value) |
|
183 | return Encryptor(ENCRYPTION_KEY).encrypt(value) | |
184 | else: |
|
184 | else: | |
185 | ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo)) |
|
185 | ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo)) | |
186 |
|
186 | |||
187 | def process_result_value(self, value, dialect): |
|
187 | def process_result_value(self, value, dialect): | |
188 | """ |
|
188 | """ | |
189 | Getter for retrieving value |
|
189 | Getter for retrieving value | |
190 | """ |
|
190 | """ | |
191 |
|
191 | |||
192 | import rhodecode |
|
192 | import rhodecode | |
193 | if not value: |
|
193 | if not value: | |
194 | return value |
|
194 | return value | |
195 |
|
195 | |||
196 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' |
|
196 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' | |
197 | enc_strict_mode = str2bool(rhodecode.CONFIG.get('rhodecode.encrypted_values.strict') or True) |
|
197 | enc_strict_mode = str2bool(rhodecode.CONFIG.get('rhodecode.encrypted_values.strict') or True) | |
198 | if algo == 'aes': |
|
198 | if algo == 'aes': | |
199 | decrypted_data = validate_and_get_enc_data(value, ENCRYPTION_KEY, enc_strict_mode) |
|
199 | decrypted_data = validate_and_get_enc_data(value, ENCRYPTION_KEY, enc_strict_mode) | |
200 | elif algo == 'fernet': |
|
200 | elif algo == 'fernet': | |
201 | return Encryptor(ENCRYPTION_KEY).decrypt(value) |
|
201 | return Encryptor(ENCRYPTION_KEY).decrypt(value) | |
202 | else: |
|
202 | else: | |
203 | ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo)) |
|
203 | ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo)) | |
204 | return decrypted_data |
|
204 | return decrypted_data | |
205 |
|
205 | |||
206 |
|
206 | |||
207 | class BaseModel(object): |
|
207 | class BaseModel(object): | |
208 | """ |
|
208 | """ | |
209 | Base Model for all classes |
|
209 | Base Model for all classes | |
210 | """ |
|
210 | """ | |
211 |
|
211 | |||
212 | @classmethod |
|
212 | @classmethod | |
213 | def _get_keys(cls): |
|
213 | def _get_keys(cls): | |
214 | """return column names for this model """ |
|
214 | """return column names for this model """ | |
215 | return class_mapper(cls).c.keys() |
|
215 | return class_mapper(cls).c.keys() | |
216 |
|
216 | |||
217 | def get_dict(self): |
|
217 | def get_dict(self): | |
218 | """ |
|
218 | """ | |
219 | return dict with keys and values corresponding |
|
219 | return dict with keys and values corresponding | |
220 | to this model data """ |
|
220 | to this model data """ | |
221 |
|
221 | |||
222 | d = {} |
|
222 | d = {} | |
223 | for k in self._get_keys(): |
|
223 | for k in self._get_keys(): | |
224 | d[k] = getattr(self, k) |
|
224 | d[k] = getattr(self, k) | |
225 |
|
225 | |||
226 | # also use __json__() if present to get additional fields |
|
226 | # also use __json__() if present to get additional fields | |
227 | _json_attr = getattr(self, '__json__', None) |
|
227 | _json_attr = getattr(self, '__json__', None) | |
228 | if _json_attr: |
|
228 | if _json_attr: | |
229 | # update with attributes from __json__ |
|
229 | # update with attributes from __json__ | |
230 | if callable(_json_attr): |
|
230 | if callable(_json_attr): | |
231 | _json_attr = _json_attr() |
|
231 | _json_attr = _json_attr() | |
232 | for k, val in _json_attr.iteritems(): |
|
232 | for k, val in _json_attr.iteritems(): | |
233 | d[k] = val |
|
233 | d[k] = val | |
234 | return d |
|
234 | return d | |
235 |
|
235 | |||
236 | def get_appstruct(self): |
|
236 | def get_appstruct(self): | |
237 | """return list with keys and values tuples corresponding |
|
237 | """return list with keys and values tuples corresponding | |
238 | to this model data """ |
|
238 | to this model data """ | |
239 |
|
239 | |||
240 | lst = [] |
|
240 | lst = [] | |
241 | for k in self._get_keys(): |
|
241 | for k in self._get_keys(): | |
242 | lst.append((k, getattr(self, k),)) |
|
242 | lst.append((k, getattr(self, k),)) | |
243 | return lst |
|
243 | return lst | |
244 |
|
244 | |||
245 | def populate_obj(self, populate_dict): |
|
245 | def populate_obj(self, populate_dict): | |
246 | """populate model with data from given populate_dict""" |
|
246 | """populate model with data from given populate_dict""" | |
247 |
|
247 | |||
248 | for k in self._get_keys(): |
|
248 | for k in self._get_keys(): | |
249 | if k in populate_dict: |
|
249 | if k in populate_dict: | |
250 | setattr(self, k, populate_dict[k]) |
|
250 | setattr(self, k, populate_dict[k]) | |
251 |
|
251 | |||
252 | @classmethod |
|
252 | @classmethod | |
253 | def query(cls): |
|
253 | def query(cls): | |
254 | return Session().query(cls) |
|
254 | return Session().query(cls) | |
255 |
|
255 | |||
256 | @classmethod |
|
256 | @classmethod | |
257 | def get(cls, id_): |
|
257 | def get(cls, id_): | |
258 | if id_: |
|
258 | if id_: | |
259 | return cls.query().get(id_) |
|
259 | return cls.query().get(id_) | |
260 |
|
260 | |||
261 | @classmethod |
|
261 | @classmethod | |
262 | def get_or_404(cls, id_): |
|
262 | def get_or_404(cls, id_): | |
263 | from pyramid.httpexceptions import HTTPNotFound |
|
263 | from pyramid.httpexceptions import HTTPNotFound | |
264 |
|
264 | |||
265 | try: |
|
265 | try: | |
266 | id_ = int(id_) |
|
266 | id_ = int(id_) | |
267 | except (TypeError, ValueError): |
|
267 | except (TypeError, ValueError): | |
268 | raise HTTPNotFound() |
|
268 | raise HTTPNotFound() | |
269 |
|
269 | |||
270 | res = cls.query().get(id_) |
|
270 | res = cls.query().get(id_) | |
271 | if not res: |
|
271 | if not res: | |
272 | raise HTTPNotFound() |
|
272 | raise HTTPNotFound() | |
273 | return res |
|
273 | return res | |
274 |
|
274 | |||
275 | @classmethod |
|
275 | @classmethod | |
276 | def getAll(cls): |
|
276 | def getAll(cls): | |
277 | # deprecated and left for backward compatibility |
|
277 | # deprecated and left for backward compatibility | |
278 | return cls.get_all() |
|
278 | return cls.get_all() | |
279 |
|
279 | |||
280 | @classmethod |
|
280 | @classmethod | |
281 | def get_all(cls): |
|
281 | def get_all(cls): | |
282 | return cls.query().all() |
|
282 | return cls.query().all() | |
283 |
|
283 | |||
284 | @classmethod |
|
284 | @classmethod | |
285 | def delete(cls, id_): |
|
285 | def delete(cls, id_): | |
286 | obj = cls.query().get(id_) |
|
286 | obj = cls.query().get(id_) | |
287 | Session().delete(obj) |
|
287 | Session().delete(obj) | |
288 |
|
288 | |||
289 | @classmethod |
|
289 | @classmethod | |
290 | def identity_cache(cls, session, attr_name, value): |
|
290 | def identity_cache(cls, session, attr_name, value): | |
291 | exist_in_session = [] |
|
291 | exist_in_session = [] | |
292 | for (item_cls, pkey), instance in session.identity_map.items(): |
|
292 | for (item_cls, pkey), instance in session.identity_map.items(): | |
293 | if cls == item_cls and getattr(instance, attr_name) == value: |
|
293 | if cls == item_cls and getattr(instance, attr_name) == value: | |
294 | exist_in_session.append(instance) |
|
294 | exist_in_session.append(instance) | |
295 | if exist_in_session: |
|
295 | if exist_in_session: | |
296 | if len(exist_in_session) == 1: |
|
296 | if len(exist_in_session) == 1: | |
297 | return exist_in_session[0] |
|
297 | return exist_in_session[0] | |
298 | log.exception( |
|
298 | log.exception( | |
299 | 'multiple objects with attr %s and ' |
|
299 | 'multiple objects with attr %s and ' | |
300 | 'value %s found with same name: %r', |
|
300 | 'value %s found with same name: %r', | |
301 | attr_name, value, exist_in_session) |
|
301 | attr_name, value, exist_in_session) | |
302 |
|
302 | |||
303 | def __repr__(self): |
|
303 | def __repr__(self): | |
304 | if hasattr(self, '__unicode__'): |
|
304 | if hasattr(self, '__unicode__'): | |
305 | # python repr needs to return str |
|
305 | # python repr needs to return str | |
306 | try: |
|
306 | try: | |
307 | return safe_str(self.__unicode__()) |
|
307 | return safe_str(self.__unicode__()) | |
308 | except UnicodeDecodeError: |
|
308 | except UnicodeDecodeError: | |
309 | pass |
|
309 | pass | |
310 | return '<DB:%s>' % (self.__class__.__name__) |
|
310 | return '<DB:%s>' % (self.__class__.__name__) | |
311 |
|
311 | |||
312 |
|
312 | |||
313 | class RhodeCodeSetting(Base, BaseModel): |
|
313 | class RhodeCodeSetting(Base, BaseModel): | |
314 | __tablename__ = 'rhodecode_settings' |
|
314 | __tablename__ = 'rhodecode_settings' | |
315 | __table_args__ = ( |
|
315 | __table_args__ = ( | |
316 | UniqueConstraint('app_settings_name'), |
|
316 | UniqueConstraint('app_settings_name'), | |
317 | base_table_args |
|
317 | base_table_args | |
318 | ) |
|
318 | ) | |
319 |
|
319 | |||
320 | SETTINGS_TYPES = { |
|
320 | SETTINGS_TYPES = { | |
321 | 'str': safe_str, |
|
321 | 'str': safe_str, | |
322 | 'int': safe_int, |
|
322 | 'int': safe_int, | |
323 | 'unicode': safe_unicode, |
|
323 | 'unicode': safe_unicode, | |
324 | 'bool': str2bool, |
|
324 | 'bool': str2bool, | |
325 | 'list': functools.partial(aslist, sep=',') |
|
325 | 'list': functools.partial(aslist, sep=',') | |
326 | } |
|
326 | } | |
327 | DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions' |
|
327 | DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions' | |
328 | GLOBAL_CONF_KEY = 'app_settings' |
|
328 | GLOBAL_CONF_KEY = 'app_settings' | |
329 |
|
329 | |||
330 | app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
330 | app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
331 | app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None) |
|
331 | app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None) | |
332 | _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None) |
|
332 | _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None) | |
333 | _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None) |
|
333 | _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None) | |
334 |
|
334 | |||
335 | def __init__(self, key='', val='', type='unicode'): |
|
335 | def __init__(self, key='', val='', type='unicode'): | |
336 | self.app_settings_name = key |
|
336 | self.app_settings_name = key | |
337 | self.app_settings_type = type |
|
337 | self.app_settings_type = type | |
338 | self.app_settings_value = val |
|
338 | self.app_settings_value = val | |
339 |
|
339 | |||
340 | @validates('_app_settings_value') |
|
340 | @validates('_app_settings_value') | |
341 | def validate_settings_value(self, key, val): |
|
341 | def validate_settings_value(self, key, val): | |
342 | assert type(val) == unicode |
|
342 | assert type(val) == unicode | |
343 | return val |
|
343 | return val | |
344 |
|
344 | |||
345 | @hybrid_property |
|
345 | @hybrid_property | |
346 | def app_settings_value(self): |
|
346 | def app_settings_value(self): | |
347 | v = self._app_settings_value |
|
347 | v = self._app_settings_value | |
348 | _type = self.app_settings_type |
|
348 | _type = self.app_settings_type | |
349 | if _type: |
|
349 | if _type: | |
350 | _type = self.app_settings_type.split('.')[0] |
|
350 | _type = self.app_settings_type.split('.')[0] | |
351 | # decode the encrypted value |
|
351 | # decode the encrypted value | |
352 | if 'encrypted' in self.app_settings_type: |
|
352 | if 'encrypted' in self.app_settings_type: | |
353 | cipher = EncryptedTextValue() |
|
353 | cipher = EncryptedTextValue() | |
354 | v = safe_unicode(cipher.process_result_value(v, None)) |
|
354 | v = safe_unicode(cipher.process_result_value(v, None)) | |
355 |
|
355 | |||
356 | converter = self.SETTINGS_TYPES.get(_type) or \ |
|
356 | converter = self.SETTINGS_TYPES.get(_type) or \ | |
357 | self.SETTINGS_TYPES['unicode'] |
|
357 | self.SETTINGS_TYPES['unicode'] | |
358 | return converter(v) |
|
358 | return converter(v) | |
359 |
|
359 | |||
360 | @app_settings_value.setter |
|
360 | @app_settings_value.setter | |
361 | def app_settings_value(self, val): |
|
361 | def app_settings_value(self, val): | |
362 | """ |
|
362 | """ | |
363 | Setter that will always make sure we use unicode in app_settings_value |
|
363 | Setter that will always make sure we use unicode in app_settings_value | |
364 |
|
364 | |||
365 | :param val: |
|
365 | :param val: | |
366 | """ |
|
366 | """ | |
367 | val = safe_unicode(val) |
|
367 | val = safe_unicode(val) | |
368 | # encode the encrypted value |
|
368 | # encode the encrypted value | |
369 | if 'encrypted' in self.app_settings_type: |
|
369 | if 'encrypted' in self.app_settings_type: | |
370 | cipher = EncryptedTextValue() |
|
370 | cipher = EncryptedTextValue() | |
371 | val = safe_unicode(cipher.process_bind_param(val, None)) |
|
371 | val = safe_unicode(cipher.process_bind_param(val, None)) | |
372 | self._app_settings_value = val |
|
372 | self._app_settings_value = val | |
373 |
|
373 | |||
374 | @hybrid_property |
|
374 | @hybrid_property | |
375 | def app_settings_type(self): |
|
375 | def app_settings_type(self): | |
376 | return self._app_settings_type |
|
376 | return self._app_settings_type | |
377 |
|
377 | |||
378 | @app_settings_type.setter |
|
378 | @app_settings_type.setter | |
379 | def app_settings_type(self, val): |
|
379 | def app_settings_type(self, val): | |
380 | if val.split('.')[0] not in self.SETTINGS_TYPES: |
|
380 | if val.split('.')[0] not in self.SETTINGS_TYPES: | |
381 | raise Exception('type must be one of %s got %s' |
|
381 | raise Exception('type must be one of %s got %s' | |
382 | % (self.SETTINGS_TYPES.keys(), val)) |
|
382 | % (self.SETTINGS_TYPES.keys(), val)) | |
383 | self._app_settings_type = val |
|
383 | self._app_settings_type = val | |
384 |
|
384 | |||
385 | @classmethod |
|
385 | @classmethod | |
386 | def get_by_prefix(cls, prefix): |
|
386 | def get_by_prefix(cls, prefix): | |
387 | return RhodeCodeSetting.query()\ |
|
387 | return RhodeCodeSetting.query()\ | |
388 | .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\ |
|
388 | .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\ | |
389 | .all() |
|
389 | .all() | |
390 |
|
390 | |||
391 | def __unicode__(self): |
|
391 | def __unicode__(self): | |
392 | return u"<%s('%s:%s[%s]')>" % ( |
|
392 | return u"<%s('%s:%s[%s]')>" % ( | |
393 | self.__class__.__name__, |
|
393 | self.__class__.__name__, | |
394 | self.app_settings_name, self.app_settings_value, |
|
394 | self.app_settings_name, self.app_settings_value, | |
395 | self.app_settings_type |
|
395 | self.app_settings_type | |
396 | ) |
|
396 | ) | |
397 |
|
397 | |||
398 |
|
398 | |||
399 | class RhodeCodeUi(Base, BaseModel): |
|
399 | class RhodeCodeUi(Base, BaseModel): | |
400 | __tablename__ = 'rhodecode_ui' |
|
400 | __tablename__ = 'rhodecode_ui' | |
401 | __table_args__ = ( |
|
401 | __table_args__ = ( | |
402 | UniqueConstraint('ui_key'), |
|
402 | UniqueConstraint('ui_key'), | |
403 | base_table_args |
|
403 | base_table_args | |
404 | ) |
|
404 | ) | |
405 |
|
405 | |||
406 | HOOK_REPO_SIZE = 'changegroup.repo_size' |
|
406 | HOOK_REPO_SIZE = 'changegroup.repo_size' | |
407 | # HG |
|
407 | # HG | |
408 | HOOK_PRE_PULL = 'preoutgoing.pre_pull' |
|
408 | HOOK_PRE_PULL = 'preoutgoing.pre_pull' | |
409 | HOOK_PULL = 'outgoing.pull_logger' |
|
409 | HOOK_PULL = 'outgoing.pull_logger' | |
410 | HOOK_PRE_PUSH = 'prechangegroup.pre_push' |
|
410 | HOOK_PRE_PUSH = 'prechangegroup.pre_push' | |
411 | HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push' |
|
411 | HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push' | |
412 | HOOK_PUSH = 'changegroup.push_logger' |
|
412 | HOOK_PUSH = 'changegroup.push_logger' | |
413 | HOOK_PUSH_KEY = 'pushkey.key_push' |
|
413 | HOOK_PUSH_KEY = 'pushkey.key_push' | |
414 |
|
414 | |||
415 | HOOKS_BUILTIN = [ |
|
415 | HOOKS_BUILTIN = [ | |
416 | HOOK_PRE_PULL, |
|
416 | HOOK_PRE_PULL, | |
417 | HOOK_PULL, |
|
417 | HOOK_PULL, | |
418 | HOOK_PRE_PUSH, |
|
418 | HOOK_PRE_PUSH, | |
419 | HOOK_PRETX_PUSH, |
|
419 | HOOK_PRETX_PUSH, | |
420 | HOOK_PUSH, |
|
420 | HOOK_PUSH, | |
421 | HOOK_PUSH_KEY, |
|
421 | HOOK_PUSH_KEY, | |
422 | ] |
|
422 | ] | |
423 |
|
423 | |||
424 | # TODO: johbo: Unify way how hooks are configured for git and hg, |
|
424 | # TODO: johbo: Unify way how hooks are configured for git and hg, | |
425 | # git part is currently hardcoded. |
|
425 | # git part is currently hardcoded. | |
426 |
|
426 | |||
427 | # SVN PATTERNS |
|
427 | # SVN PATTERNS | |
428 | SVN_BRANCH_ID = 'vcs_svn_branch' |
|
428 | SVN_BRANCH_ID = 'vcs_svn_branch' | |
429 | SVN_TAG_ID = 'vcs_svn_tag' |
|
429 | SVN_TAG_ID = 'vcs_svn_tag' | |
430 |
|
430 | |||
431 | ui_id = Column( |
|
431 | ui_id = Column( | |
432 | "ui_id", Integer(), nullable=False, unique=True, default=None, |
|
432 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
433 | primary_key=True) |
|
433 | primary_key=True) | |
434 | ui_section = Column( |
|
434 | ui_section = Column( | |
435 | "ui_section", String(255), nullable=True, unique=None, default=None) |
|
435 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
436 | ui_key = Column( |
|
436 | ui_key = Column( | |
437 | "ui_key", String(255), nullable=True, unique=None, default=None) |
|
437 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
438 | ui_value = Column( |
|
438 | ui_value = Column( | |
439 | "ui_value", String(255), nullable=True, unique=None, default=None) |
|
439 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
440 | ui_active = Column( |
|
440 | ui_active = Column( | |
441 | "ui_active", Boolean(), nullable=True, unique=None, default=True) |
|
441 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
442 |
|
442 | |||
443 | def __repr__(self): |
|
443 | def __repr__(self): | |
444 | return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section, |
|
444 | return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section, | |
445 | self.ui_key, self.ui_value) |
|
445 | self.ui_key, self.ui_value) | |
446 |
|
446 | |||
447 |
|
447 | |||
448 | class RepoRhodeCodeSetting(Base, BaseModel): |
|
448 | class RepoRhodeCodeSetting(Base, BaseModel): | |
449 | __tablename__ = 'repo_rhodecode_settings' |
|
449 | __tablename__ = 'repo_rhodecode_settings' | |
450 | __table_args__ = ( |
|
450 | __table_args__ = ( | |
451 | UniqueConstraint( |
|
451 | UniqueConstraint( | |
452 | 'app_settings_name', 'repository_id', |
|
452 | 'app_settings_name', 'repository_id', | |
453 | name='uq_repo_rhodecode_setting_name_repo_id'), |
|
453 | name='uq_repo_rhodecode_setting_name_repo_id'), | |
454 | base_table_args |
|
454 | base_table_args | |
455 | ) |
|
455 | ) | |
456 |
|
456 | |||
457 | repository_id = Column( |
|
457 | repository_id = Column( | |
458 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), |
|
458 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
459 | nullable=False) |
|
459 | nullable=False) | |
460 | app_settings_id = Column( |
|
460 | app_settings_id = Column( | |
461 | "app_settings_id", Integer(), nullable=False, unique=True, |
|
461 | "app_settings_id", Integer(), nullable=False, unique=True, | |
462 | default=None, primary_key=True) |
|
462 | default=None, primary_key=True) | |
463 | app_settings_name = Column( |
|
463 | app_settings_name = Column( | |
464 | "app_settings_name", String(255), nullable=True, unique=None, |
|
464 | "app_settings_name", String(255), nullable=True, unique=None, | |
465 | default=None) |
|
465 | default=None) | |
466 | _app_settings_value = Column( |
|
466 | _app_settings_value = Column( | |
467 | "app_settings_value", String(4096), nullable=True, unique=None, |
|
467 | "app_settings_value", String(4096), nullable=True, unique=None, | |
468 | default=None) |
|
468 | default=None) | |
469 | _app_settings_type = Column( |
|
469 | _app_settings_type = Column( | |
470 | "app_settings_type", String(255), nullable=True, unique=None, |
|
470 | "app_settings_type", String(255), nullable=True, unique=None, | |
471 | default=None) |
|
471 | default=None) | |
472 |
|
472 | |||
473 | repository = relationship('Repository') |
|
473 | repository = relationship('Repository') | |
474 |
|
474 | |||
475 | def __init__(self, repository_id, key='', val='', type='unicode'): |
|
475 | def __init__(self, repository_id, key='', val='', type='unicode'): | |
476 | self.repository_id = repository_id |
|
476 | self.repository_id = repository_id | |
477 | self.app_settings_name = key |
|
477 | self.app_settings_name = key | |
478 | self.app_settings_type = type |
|
478 | self.app_settings_type = type | |
479 | self.app_settings_value = val |
|
479 | self.app_settings_value = val | |
480 |
|
480 | |||
481 | @validates('_app_settings_value') |
|
481 | @validates('_app_settings_value') | |
482 | def validate_settings_value(self, key, val): |
|
482 | def validate_settings_value(self, key, val): | |
483 | assert type(val) == unicode |
|
483 | assert type(val) == unicode | |
484 | return val |
|
484 | return val | |
485 |
|
485 | |||
486 | @hybrid_property |
|
486 | @hybrid_property | |
487 | def app_settings_value(self): |
|
487 | def app_settings_value(self): | |
488 | v = self._app_settings_value |
|
488 | v = self._app_settings_value | |
489 | type_ = self.app_settings_type |
|
489 | type_ = self.app_settings_type | |
490 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES |
|
490 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
491 | converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode'] |
|
491 | converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode'] | |
492 | return converter(v) |
|
492 | return converter(v) | |
493 |
|
493 | |||
494 | @app_settings_value.setter |
|
494 | @app_settings_value.setter | |
495 | def app_settings_value(self, val): |
|
495 | def app_settings_value(self, val): | |
496 | """ |
|
496 | """ | |
497 | Setter that will always make sure we use unicode in app_settings_value |
|
497 | Setter that will always make sure we use unicode in app_settings_value | |
498 |
|
498 | |||
499 | :param val: |
|
499 | :param val: | |
500 | """ |
|
500 | """ | |
501 | self._app_settings_value = safe_unicode(val) |
|
501 | self._app_settings_value = safe_unicode(val) | |
502 |
|
502 | |||
503 | @hybrid_property |
|
503 | @hybrid_property | |
504 | def app_settings_type(self): |
|
504 | def app_settings_type(self): | |
505 | return self._app_settings_type |
|
505 | return self._app_settings_type | |
506 |
|
506 | |||
507 | @app_settings_type.setter |
|
507 | @app_settings_type.setter | |
508 | def app_settings_type(self, val): |
|
508 | def app_settings_type(self, val): | |
509 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES |
|
509 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
510 | if val not in SETTINGS_TYPES: |
|
510 | if val not in SETTINGS_TYPES: | |
511 | raise Exception('type must be one of %s got %s' |
|
511 | raise Exception('type must be one of %s got %s' | |
512 | % (SETTINGS_TYPES.keys(), val)) |
|
512 | % (SETTINGS_TYPES.keys(), val)) | |
513 | self._app_settings_type = val |
|
513 | self._app_settings_type = val | |
514 |
|
514 | |||
515 | def __unicode__(self): |
|
515 | def __unicode__(self): | |
516 | return u"<%s('%s:%s:%s[%s]')>" % ( |
|
516 | return u"<%s('%s:%s:%s[%s]')>" % ( | |
517 | self.__class__.__name__, self.repository.repo_name, |
|
517 | self.__class__.__name__, self.repository.repo_name, | |
518 | self.app_settings_name, self.app_settings_value, |
|
518 | self.app_settings_name, self.app_settings_value, | |
519 | self.app_settings_type |
|
519 | self.app_settings_type | |
520 | ) |
|
520 | ) | |
521 |
|
521 | |||
522 |
|
522 | |||
523 | class RepoRhodeCodeUi(Base, BaseModel): |
|
523 | class RepoRhodeCodeUi(Base, BaseModel): | |
524 | __tablename__ = 'repo_rhodecode_ui' |
|
524 | __tablename__ = 'repo_rhodecode_ui' | |
525 | __table_args__ = ( |
|
525 | __table_args__ = ( | |
526 | UniqueConstraint( |
|
526 | UniqueConstraint( | |
527 | 'repository_id', 'ui_section', 'ui_key', |
|
527 | 'repository_id', 'ui_section', 'ui_key', | |
528 | name='uq_repo_rhodecode_ui_repository_id_section_key'), |
|
528 | name='uq_repo_rhodecode_ui_repository_id_section_key'), | |
529 | base_table_args |
|
529 | base_table_args | |
530 | ) |
|
530 | ) | |
531 |
|
531 | |||
532 | repository_id = Column( |
|
532 | repository_id = Column( | |
533 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), |
|
533 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
534 | nullable=False) |
|
534 | nullable=False) | |
535 | ui_id = Column( |
|
535 | ui_id = Column( | |
536 | "ui_id", Integer(), nullable=False, unique=True, default=None, |
|
536 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
537 | primary_key=True) |
|
537 | primary_key=True) | |
538 | ui_section = Column( |
|
538 | ui_section = Column( | |
539 | "ui_section", String(255), nullable=True, unique=None, default=None) |
|
539 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
540 | ui_key = Column( |
|
540 | ui_key = Column( | |
541 | "ui_key", String(255), nullable=True, unique=None, default=None) |
|
541 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
542 | ui_value = Column( |
|
542 | ui_value = Column( | |
543 | "ui_value", String(255), nullable=True, unique=None, default=None) |
|
543 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
544 | ui_active = Column( |
|
544 | ui_active = Column( | |
545 | "ui_active", Boolean(), nullable=True, unique=None, default=True) |
|
545 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
546 |
|
546 | |||
547 | repository = relationship('Repository') |
|
547 | repository = relationship('Repository') | |
548 |
|
548 | |||
549 | def __repr__(self): |
|
549 | def __repr__(self): | |
550 | return '<%s[%s:%s]%s=>%s]>' % ( |
|
550 | return '<%s[%s:%s]%s=>%s]>' % ( | |
551 | self.__class__.__name__, self.repository.repo_name, |
|
551 | self.__class__.__name__, self.repository.repo_name, | |
552 | self.ui_section, self.ui_key, self.ui_value) |
|
552 | self.ui_section, self.ui_key, self.ui_value) | |
553 |
|
553 | |||
554 |
|
554 | |||
555 | class User(Base, BaseModel): |
|
555 | class User(Base, BaseModel): | |
556 | __tablename__ = 'users' |
|
556 | __tablename__ = 'users' | |
557 | __table_args__ = ( |
|
557 | __table_args__ = ( | |
558 | UniqueConstraint('username'), UniqueConstraint('email'), |
|
558 | UniqueConstraint('username'), UniqueConstraint('email'), | |
559 | Index('u_username_idx', 'username'), |
|
559 | Index('u_username_idx', 'username'), | |
560 | Index('u_email_idx', 'email'), |
|
560 | Index('u_email_idx', 'email'), | |
561 | base_table_args |
|
561 | base_table_args | |
562 | ) |
|
562 | ) | |
563 |
|
563 | |||
564 | DEFAULT_USER = 'default' |
|
564 | DEFAULT_USER = 'default' | |
565 | DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org' |
|
565 | DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org' | |
566 | DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}' |
|
566 | DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}' | |
567 |
|
567 | |||
568 | user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
568 | user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
569 | username = Column("username", String(255), nullable=True, unique=None, default=None) |
|
569 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
570 | password = Column("password", String(255), nullable=True, unique=None, default=None) |
|
570 | password = Column("password", String(255), nullable=True, unique=None, default=None) | |
571 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) |
|
571 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
572 | admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) |
|
572 | admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) | |
573 | name = Column("firstname", String(255), nullable=True, unique=None, default=None) |
|
573 | name = Column("firstname", String(255), nullable=True, unique=None, default=None) | |
574 | lastname = Column("lastname", String(255), nullable=True, unique=None, default=None) |
|
574 | lastname = Column("lastname", String(255), nullable=True, unique=None, default=None) | |
575 | _email = Column("email", String(255), nullable=True, unique=None, default=None) |
|
575 | _email = Column("email", String(255), nullable=True, unique=None, default=None) | |
576 | last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
576 | last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
577 | last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
577 | last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
578 |
|
578 | |||
579 | extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None) |
|
579 | extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None) | |
580 | extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None) |
|
580 | extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None) | |
581 | _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None) |
|
581 | _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None) | |
582 | inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) |
|
582 | inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
583 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
583 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
584 | _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data |
|
584 | _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data | |
585 |
|
585 | |||
586 | user_log = relationship('UserLog') |
|
586 | user_log = relationship('UserLog') | |
587 | user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all') |
|
587 | user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all') | |
588 |
|
588 | |||
589 | repositories = relationship('Repository') |
|
589 | repositories = relationship('Repository') | |
590 | repository_groups = relationship('RepoGroup') |
|
590 | repository_groups = relationship('RepoGroup') | |
591 | user_groups = relationship('UserGroup') |
|
591 | user_groups = relationship('UserGroup') | |
592 |
|
592 | |||
593 | user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all') |
|
593 | user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all') | |
594 | followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all') |
|
594 | followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all') | |
595 |
|
595 | |||
596 | repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all') |
|
596 | repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all') | |
597 | repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all') |
|
597 | repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all') | |
598 | user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all') |
|
598 | user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all') | |
599 |
|
599 | |||
600 | group_member = relationship('UserGroupMember', cascade='all') |
|
600 | group_member = relationship('UserGroupMember', cascade='all') | |
601 |
|
601 | |||
602 | notifications = relationship('UserNotification', cascade='all') |
|
602 | notifications = relationship('UserNotification', cascade='all') | |
603 | # notifications assigned to this user |
|
603 | # notifications assigned to this user | |
604 | user_created_notifications = relationship('Notification', cascade='all') |
|
604 | user_created_notifications = relationship('Notification', cascade='all') | |
605 | # comments created by this user |
|
605 | # comments created by this user | |
606 | user_comments = relationship('ChangesetComment', cascade='all') |
|
606 | user_comments = relationship('ChangesetComment', cascade='all') | |
607 | # user profile extra info |
|
607 | # user profile extra info | |
608 | user_emails = relationship('UserEmailMap', cascade='all') |
|
608 | user_emails = relationship('UserEmailMap', cascade='all') | |
609 | user_ip_map = relationship('UserIpMap', cascade='all') |
|
609 | user_ip_map = relationship('UserIpMap', cascade='all') | |
610 | user_auth_tokens = relationship('UserApiKeys', cascade='all') |
|
610 | user_auth_tokens = relationship('UserApiKeys', cascade='all') | |
611 | user_ssh_keys = relationship('UserSshKeys', cascade='all') |
|
611 | user_ssh_keys = relationship('UserSshKeys', cascade='all') | |
612 |
|
612 | |||
613 | # gists |
|
613 | # gists | |
614 | user_gists = relationship('Gist', cascade='all') |
|
614 | user_gists = relationship('Gist', cascade='all') | |
615 | # user pull requests |
|
615 | # user pull requests | |
616 | user_pull_requests = relationship('PullRequest', cascade='all') |
|
616 | user_pull_requests = relationship('PullRequest', cascade='all') | |
617 | # external identities |
|
617 | # external identities | |
618 | extenal_identities = relationship( |
|
618 | extenal_identities = relationship( | |
619 | 'ExternalIdentity', |
|
619 | 'ExternalIdentity', | |
620 | primaryjoin="User.user_id==ExternalIdentity.local_user_id", |
|
620 | primaryjoin="User.user_id==ExternalIdentity.local_user_id", | |
621 | cascade='all') |
|
621 | cascade='all') | |
622 | # review rules |
|
622 | # review rules | |
623 | user_review_rules = relationship('RepoReviewRuleUser', cascade='all') |
|
623 | user_review_rules = relationship('RepoReviewRuleUser', cascade='all') | |
624 |
|
624 | |||
625 | def __unicode__(self): |
|
625 | def __unicode__(self): | |
626 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, |
|
626 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, | |
627 | self.user_id, self.username) |
|
627 | self.user_id, self.username) | |
628 |
|
628 | |||
629 | @hybrid_property |
|
629 | @hybrid_property | |
630 | def email(self): |
|
630 | def email(self): | |
631 | return self._email |
|
631 | return self._email | |
632 |
|
632 | |||
633 | @email.setter |
|
633 | @email.setter | |
634 | def email(self, val): |
|
634 | def email(self, val): | |
635 | self._email = val.lower() if val else None |
|
635 | self._email = val.lower() if val else None | |
636 |
|
636 | |||
637 | @hybrid_property |
|
637 | @hybrid_property | |
638 | def first_name(self): |
|
638 | def first_name(self): | |
639 | from rhodecode.lib import helpers as h |
|
639 | from rhodecode.lib import helpers as h | |
640 | if self.name: |
|
640 | if self.name: | |
641 | return h.escape(self.name) |
|
641 | return h.escape(self.name) | |
642 | return self.name |
|
642 | return self.name | |
643 |
|
643 | |||
644 | @hybrid_property |
|
644 | @hybrid_property | |
645 | def last_name(self): |
|
645 | def last_name(self): | |
646 | from rhodecode.lib import helpers as h |
|
646 | from rhodecode.lib import helpers as h | |
647 | if self.lastname: |
|
647 | if self.lastname: | |
648 | return h.escape(self.lastname) |
|
648 | return h.escape(self.lastname) | |
649 | return self.lastname |
|
649 | return self.lastname | |
650 |
|
650 | |||
651 | @hybrid_property |
|
651 | @hybrid_property | |
652 | def api_key(self): |
|
652 | def api_key(self): | |
653 | """ |
|
653 | """ | |
654 | Fetch if exist an auth-token with role ALL connected to this user |
|
654 | Fetch if exist an auth-token with role ALL connected to this user | |
655 | """ |
|
655 | """ | |
656 | user_auth_token = UserApiKeys.query()\ |
|
656 | user_auth_token = UserApiKeys.query()\ | |
657 | .filter(UserApiKeys.user_id == self.user_id)\ |
|
657 | .filter(UserApiKeys.user_id == self.user_id)\ | |
658 | .filter(or_(UserApiKeys.expires == -1, |
|
658 | .filter(or_(UserApiKeys.expires == -1, | |
659 | UserApiKeys.expires >= time.time()))\ |
|
659 | UserApiKeys.expires >= time.time()))\ | |
660 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first() |
|
660 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first() | |
661 | if user_auth_token: |
|
661 | if user_auth_token: | |
662 | user_auth_token = user_auth_token.api_key |
|
662 | user_auth_token = user_auth_token.api_key | |
663 |
|
663 | |||
664 | return user_auth_token |
|
664 | return user_auth_token | |
665 |
|
665 | |||
666 | @api_key.setter |
|
666 | @api_key.setter | |
667 | def api_key(self, val): |
|
667 | def api_key(self, val): | |
668 | # don't allow to set API key this is deprecated for now |
|
668 | # don't allow to set API key this is deprecated for now | |
669 | self._api_key = None |
|
669 | self._api_key = None | |
670 |
|
670 | |||
671 | @property |
|
671 | @property | |
672 | def reviewer_pull_requests(self): |
|
672 | def reviewer_pull_requests(self): | |
673 | return PullRequestReviewers.query() \ |
|
673 | return PullRequestReviewers.query() \ | |
674 | .options(joinedload(PullRequestReviewers.pull_request)) \ |
|
674 | .options(joinedload(PullRequestReviewers.pull_request)) \ | |
675 | .filter(PullRequestReviewers.user_id == self.user_id) \ |
|
675 | .filter(PullRequestReviewers.user_id == self.user_id) \ | |
676 | .all() |
|
676 | .all() | |
677 |
|
677 | |||
678 | @property |
|
678 | @property | |
679 | def firstname(self): |
|
679 | def firstname(self): | |
680 | # alias for future |
|
680 | # alias for future | |
681 | return self.name |
|
681 | return self.name | |
682 |
|
682 | |||
683 | @property |
|
683 | @property | |
684 | def emails(self): |
|
684 | def emails(self): | |
685 | other = UserEmailMap.query()\ |
|
685 | other = UserEmailMap.query()\ | |
686 | .filter(UserEmailMap.user == self) \ |
|
686 | .filter(UserEmailMap.user == self) \ | |
687 | .order_by(UserEmailMap.email_id.asc()) \ |
|
687 | .order_by(UserEmailMap.email_id.asc()) \ | |
688 | .all() |
|
688 | .all() | |
689 | return [self.email] + [x.email for x in other] |
|
689 | return [self.email] + [x.email for x in other] | |
690 |
|
690 | |||
691 | @property |
|
691 | @property | |
692 | def auth_tokens(self): |
|
692 | def auth_tokens(self): | |
693 | auth_tokens = self.get_auth_tokens() |
|
693 | auth_tokens = self.get_auth_tokens() | |
694 | return [x.api_key for x in auth_tokens] |
|
694 | return [x.api_key for x in auth_tokens] | |
695 |
|
695 | |||
696 | def get_auth_tokens(self): |
|
696 | def get_auth_tokens(self): | |
697 | return UserApiKeys.query()\ |
|
697 | return UserApiKeys.query()\ | |
698 | .filter(UserApiKeys.user == self)\ |
|
698 | .filter(UserApiKeys.user == self)\ | |
699 | .order_by(UserApiKeys.user_api_key_id.asc())\ |
|
699 | .order_by(UserApiKeys.user_api_key_id.asc())\ | |
700 | .all() |
|
700 | .all() | |
701 |
|
701 | |||
702 | @LazyProperty |
|
702 | @LazyProperty | |
703 | def feed_token(self): |
|
703 | def feed_token(self): | |
704 | return self.get_feed_token() |
|
704 | return self.get_feed_token() | |
705 |
|
705 | |||
706 | def get_feed_token(self, cache=True): |
|
706 | def get_feed_token(self, cache=True): | |
707 | feed_tokens = UserApiKeys.query()\ |
|
707 | feed_tokens = UserApiKeys.query()\ | |
708 | .filter(UserApiKeys.user == self)\ |
|
708 | .filter(UserApiKeys.user == self)\ | |
709 | .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED) |
|
709 | .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED) | |
710 | if cache: |
|
710 | if cache: | |
711 | feed_tokens = feed_tokens.options( |
|
711 | feed_tokens = feed_tokens.options( | |
712 | FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id)) |
|
712 | FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id)) | |
713 |
|
713 | |||
714 | feed_tokens = feed_tokens.all() |
|
714 | feed_tokens = feed_tokens.all() | |
715 | if feed_tokens: |
|
715 | if feed_tokens: | |
716 | return feed_tokens[0].api_key |
|
716 | return feed_tokens[0].api_key | |
717 | return 'NO_FEED_TOKEN_AVAILABLE' |
|
717 | return 'NO_FEED_TOKEN_AVAILABLE' | |
718 |
|
718 | |||
719 | @classmethod |
|
719 | @classmethod | |
720 | def get(cls, user_id, cache=False): |
|
720 | def get(cls, user_id, cache=False): | |
721 | if not user_id: |
|
721 | if not user_id: | |
722 | return |
|
722 | return | |
723 |
|
723 | |||
724 | user = cls.query() |
|
724 | user = cls.query() | |
725 | if cache: |
|
725 | if cache: | |
726 | user = user.options( |
|
726 | user = user.options( | |
727 | FromCache("sql_cache_short", "get_users_%s" % user_id)) |
|
727 | FromCache("sql_cache_short", "get_users_%s" % user_id)) | |
728 | return user.get(user_id) |
|
728 | return user.get(user_id) | |
729 |
|
729 | |||
730 | @classmethod |
|
730 | @classmethod | |
731 | def extra_valid_auth_tokens(cls, user, role=None): |
|
731 | def extra_valid_auth_tokens(cls, user, role=None): | |
732 | tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\ |
|
732 | tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\ | |
733 | .filter(or_(UserApiKeys.expires == -1, |
|
733 | .filter(or_(UserApiKeys.expires == -1, | |
734 | UserApiKeys.expires >= time.time())) |
|
734 | UserApiKeys.expires >= time.time())) | |
735 | if role: |
|
735 | if role: | |
736 | tokens = tokens.filter(or_(UserApiKeys.role == role, |
|
736 | tokens = tokens.filter(or_(UserApiKeys.role == role, | |
737 | UserApiKeys.role == UserApiKeys.ROLE_ALL)) |
|
737 | UserApiKeys.role == UserApiKeys.ROLE_ALL)) | |
738 | return tokens.all() |
|
738 | return tokens.all() | |
739 |
|
739 | |||
740 | def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None): |
|
740 | def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None): | |
741 | from rhodecode.lib import auth |
|
741 | from rhodecode.lib import auth | |
742 |
|
742 | |||
743 | log.debug('Trying to authenticate user: %s via auth-token, ' |
|
743 | log.debug('Trying to authenticate user: %s via auth-token, ' | |
744 | 'and roles: %s', self, roles) |
|
744 | 'and roles: %s', self, roles) | |
745 |
|
745 | |||
746 | if not auth_token: |
|
746 | if not auth_token: | |
747 | return False |
|
747 | return False | |
748 |
|
748 | |||
749 | roles = (roles or []) + [UserApiKeys.ROLE_ALL] |
|
749 | roles = (roles or []) + [UserApiKeys.ROLE_ALL] | |
750 | tokens_q = UserApiKeys.query()\ |
|
750 | tokens_q = UserApiKeys.query()\ | |
751 | .filter(UserApiKeys.user_id == self.user_id)\ |
|
751 | .filter(UserApiKeys.user_id == self.user_id)\ | |
752 | .filter(or_(UserApiKeys.expires == -1, |
|
752 | .filter(or_(UserApiKeys.expires == -1, | |
753 | UserApiKeys.expires >= time.time())) |
|
753 | UserApiKeys.expires >= time.time())) | |
754 |
|
754 | |||
755 | tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles)) |
|
755 | tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles)) | |
756 |
|
756 | |||
757 | crypto_backend = auth.crypto_backend() |
|
757 | crypto_backend = auth.crypto_backend() | |
758 | enc_token_map = {} |
|
758 | enc_token_map = {} | |
759 | plain_token_map = {} |
|
759 | plain_token_map = {} | |
760 | for token in tokens_q: |
|
760 | for token in tokens_q: | |
761 | if token.api_key.startswith(crypto_backend.ENC_PREF): |
|
761 | if token.api_key.startswith(crypto_backend.ENC_PREF): | |
762 | enc_token_map[token.api_key] = token |
|
762 | enc_token_map[token.api_key] = token | |
763 | else: |
|
763 | else: | |
764 | plain_token_map[token.api_key] = token |
|
764 | plain_token_map[token.api_key] = token | |
765 | log.debug( |
|
765 | log.debug( | |
766 | 'Found %s plain and %s encrypted user tokens to check for authentication', |
|
766 | 'Found %s plain and %s encrypted user tokens to check for authentication', | |
767 | len(plain_token_map), len(enc_token_map)) |
|
767 | len(plain_token_map), len(enc_token_map)) | |
768 |
|
768 | |||
769 | # plain token match comes first |
|
769 | # plain token match comes first | |
770 | match = plain_token_map.get(auth_token) |
|
770 | match = plain_token_map.get(auth_token) | |
771 |
|
771 | |||
772 | # check encrypted tokens now |
|
772 | # check encrypted tokens now | |
773 | if not match: |
|
773 | if not match: | |
774 | for token_hash, token in enc_token_map.items(): |
|
774 | for token_hash, token in enc_token_map.items(): | |
775 | # NOTE(marcink): this is expensive to calculate, but most secure |
|
775 | # NOTE(marcink): this is expensive to calculate, but most secure | |
776 | if crypto_backend.hash_check(auth_token, token_hash): |
|
776 | if crypto_backend.hash_check(auth_token, token_hash): | |
777 | match = token |
|
777 | match = token | |
778 | break |
|
778 | break | |
779 |
|
779 | |||
780 | if match: |
|
780 | if match: | |
781 | log.debug('Found matching token %s', match) |
|
781 | log.debug('Found matching token %s', match) | |
782 | if match.repo_id: |
|
782 | if match.repo_id: | |
783 | log.debug('Found scope, checking for scope match of token %s', match) |
|
783 | log.debug('Found scope, checking for scope match of token %s', match) | |
784 | if match.repo_id == scope_repo_id: |
|
784 | if match.repo_id == scope_repo_id: | |
785 | return True |
|
785 | return True | |
786 | else: |
|
786 | else: | |
787 | log.debug( |
|
787 | log.debug( | |
788 | 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, ' |
|
788 | 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, ' | |
789 | 'and calling scope is:%s, skipping further checks', |
|
789 | 'and calling scope is:%s, skipping further checks', | |
790 | match.repo, scope_repo_id) |
|
790 | match.repo, scope_repo_id) | |
791 | return False |
|
791 | return False | |
792 | else: |
|
792 | else: | |
793 | return True |
|
793 | return True | |
794 |
|
794 | |||
795 | return False |
|
795 | return False | |
796 |
|
796 | |||
797 | @property |
|
797 | @property | |
798 | def ip_addresses(self): |
|
798 | def ip_addresses(self): | |
799 | ret = UserIpMap.query().filter(UserIpMap.user == self).all() |
|
799 | ret = UserIpMap.query().filter(UserIpMap.user == self).all() | |
800 | return [x.ip_addr for x in ret] |
|
800 | return [x.ip_addr for x in ret] | |
801 |
|
801 | |||
802 | @property |
|
802 | @property | |
803 | def username_and_name(self): |
|
803 | def username_and_name(self): | |
804 | return '%s (%s %s)' % (self.username, self.first_name, self.last_name) |
|
804 | return '%s (%s %s)' % (self.username, self.first_name, self.last_name) | |
805 |
|
805 | |||
806 | @property |
|
806 | @property | |
807 | def username_or_name_or_email(self): |
|
807 | def username_or_name_or_email(self): | |
808 | full_name = self.full_name if self.full_name is not ' ' else None |
|
808 | full_name = self.full_name if self.full_name is not ' ' else None | |
809 | return self.username or full_name or self.email |
|
809 | return self.username or full_name or self.email | |
810 |
|
810 | |||
811 | @property |
|
811 | @property | |
812 | def full_name(self): |
|
812 | def full_name(self): | |
813 | return '%s %s' % (self.first_name, self.last_name) |
|
813 | return '%s %s' % (self.first_name, self.last_name) | |
814 |
|
814 | |||
815 | @property |
|
815 | @property | |
816 | def full_name_or_username(self): |
|
816 | def full_name_or_username(self): | |
817 | return ('%s %s' % (self.first_name, self.last_name) |
|
817 | return ('%s %s' % (self.first_name, self.last_name) | |
818 | if (self.first_name and self.last_name) else self.username) |
|
818 | if (self.first_name and self.last_name) else self.username) | |
819 |
|
819 | |||
820 | @property |
|
820 | @property | |
821 | def full_contact(self): |
|
821 | def full_contact(self): | |
822 | return '%s %s <%s>' % (self.first_name, self.last_name, self.email) |
|
822 | return '%s %s <%s>' % (self.first_name, self.last_name, self.email) | |
823 |
|
823 | |||
824 | @property |
|
824 | @property | |
825 | def short_contact(self): |
|
825 | def short_contact(self): | |
826 | return '%s %s' % (self.first_name, self.last_name) |
|
826 | return '%s %s' % (self.first_name, self.last_name) | |
827 |
|
827 | |||
828 | @property |
|
828 | @property | |
829 | def is_admin(self): |
|
829 | def is_admin(self): | |
830 | return self.admin |
|
830 | return self.admin | |
831 |
|
831 | |||
832 | def AuthUser(self, **kwargs): |
|
832 | def AuthUser(self, **kwargs): | |
833 | """ |
|
833 | """ | |
834 | Returns instance of AuthUser for this user |
|
834 | Returns instance of AuthUser for this user | |
835 | """ |
|
835 | """ | |
836 | from rhodecode.lib.auth import AuthUser |
|
836 | from rhodecode.lib.auth import AuthUser | |
837 | return AuthUser(user_id=self.user_id, username=self.username, **kwargs) |
|
837 | return AuthUser(user_id=self.user_id, username=self.username, **kwargs) | |
838 |
|
838 | |||
839 | @hybrid_property |
|
839 | @hybrid_property | |
840 | def user_data(self): |
|
840 | def user_data(self): | |
841 | if not self._user_data: |
|
841 | if not self._user_data: | |
842 | return {} |
|
842 | return {} | |
843 |
|
843 | |||
844 | try: |
|
844 | try: | |
845 | return json.loads(self._user_data) |
|
845 | return json.loads(self._user_data) | |
846 | except TypeError: |
|
846 | except TypeError: | |
847 | return {} |
|
847 | return {} | |
848 |
|
848 | |||
849 | @user_data.setter |
|
849 | @user_data.setter | |
850 | def user_data(self, val): |
|
850 | def user_data(self, val): | |
851 | if not isinstance(val, dict): |
|
851 | if not isinstance(val, dict): | |
852 | raise Exception('user_data must be dict, got %s' % type(val)) |
|
852 | raise Exception('user_data must be dict, got %s' % type(val)) | |
853 | try: |
|
853 | try: | |
854 | self._user_data = json.dumps(val) |
|
854 | self._user_data = json.dumps(val) | |
855 | except Exception: |
|
855 | except Exception: | |
856 | log.error(traceback.format_exc()) |
|
856 | log.error(traceback.format_exc()) | |
857 |
|
857 | |||
858 | @classmethod |
|
858 | @classmethod | |
859 | def get_by_username(cls, username, case_insensitive=False, |
|
859 | def get_by_username(cls, username, case_insensitive=False, | |
860 | cache=False, identity_cache=False): |
|
860 | cache=False, identity_cache=False): | |
861 | session = Session() |
|
861 | session = Session() | |
862 |
|
862 | |||
863 | if case_insensitive: |
|
863 | if case_insensitive: | |
864 | q = cls.query().filter( |
|
864 | q = cls.query().filter( | |
865 | func.lower(cls.username) == func.lower(username)) |
|
865 | func.lower(cls.username) == func.lower(username)) | |
866 | else: |
|
866 | else: | |
867 | q = cls.query().filter(cls.username == username) |
|
867 | q = cls.query().filter(cls.username == username) | |
868 |
|
868 | |||
869 | if cache: |
|
869 | if cache: | |
870 | if identity_cache: |
|
870 | if identity_cache: | |
871 | val = cls.identity_cache(session, 'username', username) |
|
871 | val = cls.identity_cache(session, 'username', username) | |
872 | if val: |
|
872 | if val: | |
873 | return val |
|
873 | return val | |
874 | else: |
|
874 | else: | |
875 | cache_key = "get_user_by_name_%s" % _hash_key(username) |
|
875 | cache_key = "get_user_by_name_%s" % _hash_key(username) | |
876 | q = q.options( |
|
876 | q = q.options( | |
877 | FromCache("sql_cache_short", cache_key)) |
|
877 | FromCache("sql_cache_short", cache_key)) | |
878 |
|
878 | |||
879 | return q.scalar() |
|
879 | return q.scalar() | |
880 |
|
880 | |||
881 | @classmethod |
|
881 | @classmethod | |
882 | def get_by_auth_token(cls, auth_token, cache=False): |
|
882 | def get_by_auth_token(cls, auth_token, cache=False): | |
883 | q = UserApiKeys.query()\ |
|
883 | q = UserApiKeys.query()\ | |
884 | .filter(UserApiKeys.api_key == auth_token)\ |
|
884 | .filter(UserApiKeys.api_key == auth_token)\ | |
885 | .filter(or_(UserApiKeys.expires == -1, |
|
885 | .filter(or_(UserApiKeys.expires == -1, | |
886 | UserApiKeys.expires >= time.time())) |
|
886 | UserApiKeys.expires >= time.time())) | |
887 | if cache: |
|
887 | if cache: | |
888 | q = q.options( |
|
888 | q = q.options( | |
889 | FromCache("sql_cache_short", "get_auth_token_%s" % auth_token)) |
|
889 | FromCache("sql_cache_short", "get_auth_token_%s" % auth_token)) | |
890 |
|
890 | |||
891 | match = q.first() |
|
891 | match = q.first() | |
892 | if match: |
|
892 | if match: | |
893 | return match.user |
|
893 | return match.user | |
894 |
|
894 | |||
895 | @classmethod |
|
895 | @classmethod | |
896 | def get_by_email(cls, email, case_insensitive=False, cache=False): |
|
896 | def get_by_email(cls, email, case_insensitive=False, cache=False): | |
897 |
|
897 | |||
898 | if case_insensitive: |
|
898 | if case_insensitive: | |
899 | q = cls.query().filter(func.lower(cls.email) == func.lower(email)) |
|
899 | q = cls.query().filter(func.lower(cls.email) == func.lower(email)) | |
900 |
|
900 | |||
901 | else: |
|
901 | else: | |
902 | q = cls.query().filter(cls.email == email) |
|
902 | q = cls.query().filter(cls.email == email) | |
903 |
|
903 | |||
904 | email_key = _hash_key(email) |
|
904 | email_key = _hash_key(email) | |
905 | if cache: |
|
905 | if cache: | |
906 | q = q.options( |
|
906 | q = q.options( | |
907 | FromCache("sql_cache_short", "get_email_key_%s" % email_key)) |
|
907 | FromCache("sql_cache_short", "get_email_key_%s" % email_key)) | |
908 |
|
908 | |||
909 | ret = q.scalar() |
|
909 | ret = q.scalar() | |
910 | if ret is None: |
|
910 | if ret is None: | |
911 | q = UserEmailMap.query() |
|
911 | q = UserEmailMap.query() | |
912 | # try fetching in alternate email map |
|
912 | # try fetching in alternate email map | |
913 | if case_insensitive: |
|
913 | if case_insensitive: | |
914 | q = q.filter(func.lower(UserEmailMap.email) == func.lower(email)) |
|
914 | q = q.filter(func.lower(UserEmailMap.email) == func.lower(email)) | |
915 | else: |
|
915 | else: | |
916 | q = q.filter(UserEmailMap.email == email) |
|
916 | q = q.filter(UserEmailMap.email == email) | |
917 | q = q.options(joinedload(UserEmailMap.user)) |
|
917 | q = q.options(joinedload(UserEmailMap.user)) | |
918 | if cache: |
|
918 | if cache: | |
919 | q = q.options( |
|
919 | q = q.options( | |
920 | FromCache("sql_cache_short", "get_email_map_key_%s" % email_key)) |
|
920 | FromCache("sql_cache_short", "get_email_map_key_%s" % email_key)) | |
921 | ret = getattr(q.scalar(), 'user', None) |
|
921 | ret = getattr(q.scalar(), 'user', None) | |
922 |
|
922 | |||
923 | return ret |
|
923 | return ret | |
924 |
|
924 | |||
925 | @classmethod |
|
925 | @classmethod | |
926 | def get_from_cs_author(cls, author): |
|
926 | def get_from_cs_author(cls, author): | |
927 | """ |
|
927 | """ | |
928 | Tries to get User objects out of commit author string |
|
928 | Tries to get User objects out of commit author string | |
929 |
|
929 | |||
930 | :param author: |
|
930 | :param author: | |
931 | """ |
|
931 | """ | |
932 | from rhodecode.lib.helpers import email, author_name |
|
932 | from rhodecode.lib.helpers import email, author_name | |
933 | # Valid email in the attribute passed, see if they're in the system |
|
933 | # Valid email in the attribute passed, see if they're in the system | |
934 | _email = email(author) |
|
934 | _email = email(author) | |
935 | if _email: |
|
935 | if _email: | |
936 | user = cls.get_by_email(_email, case_insensitive=True) |
|
936 | user = cls.get_by_email(_email, case_insensitive=True) | |
937 | if user: |
|
937 | if user: | |
938 | return user |
|
938 | return user | |
939 | # Maybe we can match by username? |
|
939 | # Maybe we can match by username? | |
940 | _author = author_name(author) |
|
940 | _author = author_name(author) | |
941 | user = cls.get_by_username(_author, case_insensitive=True) |
|
941 | user = cls.get_by_username(_author, case_insensitive=True) | |
942 | if user: |
|
942 | if user: | |
943 | return user |
|
943 | return user | |
944 |
|
944 | |||
945 | def update_userdata(self, **kwargs): |
|
945 | def update_userdata(self, **kwargs): | |
946 | usr = self |
|
946 | usr = self | |
947 | old = usr.user_data |
|
947 | old = usr.user_data | |
948 | old.update(**kwargs) |
|
948 | old.update(**kwargs) | |
949 | usr.user_data = old |
|
949 | usr.user_data = old | |
950 | Session().add(usr) |
|
950 | Session().add(usr) | |
951 | log.debug('updated userdata with %s', kwargs) |
|
951 | log.debug('updated userdata with %s', kwargs) | |
952 |
|
952 | |||
953 | def update_lastlogin(self): |
|
953 | def update_lastlogin(self): | |
954 | """Update user lastlogin""" |
|
954 | """Update user lastlogin""" | |
955 | self.last_login = datetime.datetime.now() |
|
955 | self.last_login = datetime.datetime.now() | |
956 | Session().add(self) |
|
956 | Session().add(self) | |
957 | log.debug('updated user %s lastlogin', self.username) |
|
957 | log.debug('updated user %s lastlogin', self.username) | |
958 |
|
958 | |||
959 | def update_password(self, new_password): |
|
959 | def update_password(self, new_password): | |
960 | from rhodecode.lib.auth import get_crypt_password |
|
960 | from rhodecode.lib.auth import get_crypt_password | |
961 |
|
961 | |||
962 | self.password = get_crypt_password(new_password) |
|
962 | self.password = get_crypt_password(new_password) | |
963 | Session().add(self) |
|
963 | Session().add(self) | |
964 |
|
964 | |||
965 | @classmethod |
|
965 | @classmethod | |
966 | def get_first_super_admin(cls): |
|
966 | def get_first_super_admin(cls): | |
967 | user = User.query()\ |
|
967 | user = User.query()\ | |
968 | .filter(User.admin == true()) \ |
|
968 | .filter(User.admin == true()) \ | |
969 | .order_by(User.user_id.asc()) \ |
|
969 | .order_by(User.user_id.asc()) \ | |
970 | .first() |
|
970 | .first() | |
971 |
|
971 | |||
972 | if user is None: |
|
972 | if user is None: | |
973 | raise Exception('FATAL: Missing administrative account!') |
|
973 | raise Exception('FATAL: Missing administrative account!') | |
974 | return user |
|
974 | return user | |
975 |
|
975 | |||
976 | @classmethod |
|
976 | @classmethod | |
977 | def get_all_super_admins(cls, only_active=False): |
|
977 | def get_all_super_admins(cls, only_active=False): | |
978 | """ |
|
978 | """ | |
979 | Returns all admin accounts sorted by username |
|
979 | Returns all admin accounts sorted by username | |
980 | """ |
|
980 | """ | |
981 | qry = User.query().filter(User.admin == true()).order_by(User.username.asc()) |
|
981 | qry = User.query().filter(User.admin == true()).order_by(User.username.asc()) | |
982 | if only_active: |
|
982 | if only_active: | |
983 | qry = qry.filter(User.active == true()) |
|
983 | qry = qry.filter(User.active == true()) | |
984 | return qry.all() |
|
984 | return qry.all() | |
985 |
|
985 | |||
986 | @classmethod |
|
986 | @classmethod | |
987 | def get_default_user(cls, cache=False, refresh=False): |
|
987 | def get_default_user(cls, cache=False, refresh=False): | |
988 | user = User.get_by_username(User.DEFAULT_USER, cache=cache) |
|
988 | user = User.get_by_username(User.DEFAULT_USER, cache=cache) | |
989 | if user is None: |
|
989 | if user is None: | |
990 | raise Exception('FATAL: Missing default account!') |
|
990 | raise Exception('FATAL: Missing default account!') | |
991 | if refresh: |
|
991 | if refresh: | |
992 | # The default user might be based on outdated state which |
|
992 | # The default user might be based on outdated state which | |
993 | # has been loaded from the cache. |
|
993 | # has been loaded from the cache. | |
994 | # A call to refresh() ensures that the |
|
994 | # A call to refresh() ensures that the | |
995 | # latest state from the database is used. |
|
995 | # latest state from the database is used. | |
996 | Session().refresh(user) |
|
996 | Session().refresh(user) | |
997 | return user |
|
997 | return user | |
998 |
|
998 | |||
999 | def _get_default_perms(self, user, suffix=''): |
|
999 | def _get_default_perms(self, user, suffix=''): | |
1000 | from rhodecode.model.permission import PermissionModel |
|
1000 | from rhodecode.model.permission import PermissionModel | |
1001 | return PermissionModel().get_default_perms(user.user_perms, suffix) |
|
1001 | return PermissionModel().get_default_perms(user.user_perms, suffix) | |
1002 |
|
1002 | |||
1003 | def get_default_perms(self, suffix=''): |
|
1003 | def get_default_perms(self, suffix=''): | |
1004 | return self._get_default_perms(self, suffix) |
|
1004 | return self._get_default_perms(self, suffix) | |
1005 |
|
1005 | |||
1006 | def get_api_data(self, include_secrets=False, details='full'): |
|
1006 | def get_api_data(self, include_secrets=False, details='full'): | |
1007 | """ |
|
1007 | """ | |
1008 | Common function for generating user related data for API |
|
1008 | Common function for generating user related data for API | |
1009 |
|
1009 | |||
1010 | :param include_secrets: By default secrets in the API data will be replaced |
|
1010 | :param include_secrets: By default secrets in the API data will be replaced | |
1011 | by a placeholder value to prevent exposing this data by accident. In case |
|
1011 | by a placeholder value to prevent exposing this data by accident. In case | |
1012 | this data shall be exposed, set this flag to ``True``. |
|
1012 | this data shall be exposed, set this flag to ``True``. | |
1013 |
|
1013 | |||
1014 | :param details: details can be 'basic|full' basic gives only a subset of |
|
1014 | :param details: details can be 'basic|full' basic gives only a subset of | |
1015 | the available user information that includes user_id, name and emails. |
|
1015 | the available user information that includes user_id, name and emails. | |
1016 | """ |
|
1016 | """ | |
1017 | user = self |
|
1017 | user = self | |
1018 | user_data = self.user_data |
|
1018 | user_data = self.user_data | |
1019 | data = { |
|
1019 | data = { | |
1020 | 'user_id': user.user_id, |
|
1020 | 'user_id': user.user_id, | |
1021 | 'username': user.username, |
|
1021 | 'username': user.username, | |
1022 | 'firstname': user.name, |
|
1022 | 'firstname': user.name, | |
1023 | 'lastname': user.lastname, |
|
1023 | 'lastname': user.lastname, | |
1024 | 'email': user.email, |
|
1024 | 'email': user.email, | |
1025 | 'emails': user.emails, |
|
1025 | 'emails': user.emails, | |
1026 | } |
|
1026 | } | |
1027 | if details == 'basic': |
|
1027 | if details == 'basic': | |
1028 | return data |
|
1028 | return data | |
1029 |
|
1029 | |||
1030 | auth_token_length = 40 |
|
1030 | auth_token_length = 40 | |
1031 | auth_token_replacement = '*' * auth_token_length |
|
1031 | auth_token_replacement = '*' * auth_token_length | |
1032 |
|
1032 | |||
1033 | extras = { |
|
1033 | extras = { | |
1034 | 'auth_tokens': [auth_token_replacement], |
|
1034 | 'auth_tokens': [auth_token_replacement], | |
1035 | 'active': user.active, |
|
1035 | 'active': user.active, | |
1036 | 'admin': user.admin, |
|
1036 | 'admin': user.admin, | |
1037 | 'extern_type': user.extern_type, |
|
1037 | 'extern_type': user.extern_type, | |
1038 | 'extern_name': user.extern_name, |
|
1038 | 'extern_name': user.extern_name, | |
1039 | 'last_login': user.last_login, |
|
1039 | 'last_login': user.last_login, | |
1040 | 'last_activity': user.last_activity, |
|
1040 | 'last_activity': user.last_activity, | |
1041 | 'ip_addresses': user.ip_addresses, |
|
1041 | 'ip_addresses': user.ip_addresses, | |
1042 | 'language': user_data.get('language') |
|
1042 | 'language': user_data.get('language') | |
1043 | } |
|
1043 | } | |
1044 | data.update(extras) |
|
1044 | data.update(extras) | |
1045 |
|
1045 | |||
1046 | if include_secrets: |
|
1046 | if include_secrets: | |
1047 | data['auth_tokens'] = user.auth_tokens |
|
1047 | data['auth_tokens'] = user.auth_tokens | |
1048 | return data |
|
1048 | return data | |
1049 |
|
1049 | |||
1050 | def __json__(self): |
|
1050 | def __json__(self): | |
1051 | data = { |
|
1051 | data = { | |
1052 | 'full_name': self.full_name, |
|
1052 | 'full_name': self.full_name, | |
1053 | 'full_name_or_username': self.full_name_or_username, |
|
1053 | 'full_name_or_username': self.full_name_or_username, | |
1054 | 'short_contact': self.short_contact, |
|
1054 | 'short_contact': self.short_contact, | |
1055 | 'full_contact': self.full_contact, |
|
1055 | 'full_contact': self.full_contact, | |
1056 | } |
|
1056 | } | |
1057 | data.update(self.get_api_data()) |
|
1057 | data.update(self.get_api_data()) | |
1058 | return data |
|
1058 | return data | |
1059 |
|
1059 | |||
1060 |
|
1060 | |||
1061 | class UserApiKeys(Base, BaseModel): |
|
1061 | class UserApiKeys(Base, BaseModel): | |
1062 | __tablename__ = 'user_api_keys' |
|
1062 | __tablename__ = 'user_api_keys' | |
1063 | __table_args__ = ( |
|
1063 | __table_args__ = ( | |
1064 | Index('uak_api_key_idx', 'api_key', unique=True), |
|
1064 | Index('uak_api_key_idx', 'api_key', unique=True), | |
1065 | Index('uak_api_key_expires_idx', 'api_key', 'expires'), |
|
1065 | Index('uak_api_key_expires_idx', 'api_key', 'expires'), | |
1066 | base_table_args |
|
1066 | base_table_args | |
1067 | ) |
|
1067 | ) | |
1068 | __mapper_args__ = {} |
|
1068 | __mapper_args__ = {} | |
1069 |
|
1069 | |||
1070 | # ApiKey role |
|
1070 | # ApiKey role | |
1071 | ROLE_ALL = 'token_role_all' |
|
1071 | ROLE_ALL = 'token_role_all' | |
1072 | ROLE_HTTP = 'token_role_http' |
|
1072 | ROLE_HTTP = 'token_role_http' | |
1073 | ROLE_VCS = 'token_role_vcs' |
|
1073 | ROLE_VCS = 'token_role_vcs' | |
1074 | ROLE_API = 'token_role_api' |
|
1074 | ROLE_API = 'token_role_api' | |
1075 | ROLE_FEED = 'token_role_feed' |
|
1075 | ROLE_FEED = 'token_role_feed' | |
1076 | ROLE_PASSWORD_RESET = 'token_password_reset' |
|
1076 | ROLE_PASSWORD_RESET = 'token_password_reset' | |
1077 |
|
1077 | |||
1078 | ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED] |
|
1078 | ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED] | |
1079 |
|
1079 | |||
1080 | user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1080 | user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1081 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1081 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1082 | api_key = Column("api_key", String(255), nullable=False, unique=True) |
|
1082 | api_key = Column("api_key", String(255), nullable=False, unique=True) | |
1083 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
1083 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
1084 | expires = Column('expires', Float(53), nullable=False) |
|
1084 | expires = Column('expires', Float(53), nullable=False) | |
1085 | role = Column('role', String(255), nullable=True) |
|
1085 | role = Column('role', String(255), nullable=True) | |
1086 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1086 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1087 |
|
1087 | |||
1088 | # scope columns |
|
1088 | # scope columns | |
1089 | repo_id = Column( |
|
1089 | repo_id = Column( | |
1090 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
1090 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
1091 | nullable=True, unique=None, default=None) |
|
1091 | nullable=True, unique=None, default=None) | |
1092 | repo = relationship('Repository', lazy='joined') |
|
1092 | repo = relationship('Repository', lazy='joined') | |
1093 |
|
1093 | |||
1094 | repo_group_id = Column( |
|
1094 | repo_group_id = Column( | |
1095 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), |
|
1095 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
1096 | nullable=True, unique=None, default=None) |
|
1096 | nullable=True, unique=None, default=None) | |
1097 | repo_group = relationship('RepoGroup', lazy='joined') |
|
1097 | repo_group = relationship('RepoGroup', lazy='joined') | |
1098 |
|
1098 | |||
1099 | user = relationship('User', lazy='joined') |
|
1099 | user = relationship('User', lazy='joined') | |
1100 |
|
1100 | |||
1101 | def __unicode__(self): |
|
1101 | def __unicode__(self): | |
1102 | return u"<%s('%s')>" % (self.__class__.__name__, self.role) |
|
1102 | return u"<%s('%s')>" % (self.__class__.__name__, self.role) | |
1103 |
|
1103 | |||
1104 | def __json__(self): |
|
1104 | def __json__(self): | |
1105 | data = { |
|
1105 | data = { | |
1106 | 'auth_token': self.api_key, |
|
1106 | 'auth_token': self.api_key, | |
1107 | 'role': self.role, |
|
1107 | 'role': self.role, | |
1108 | 'scope': self.scope_humanized, |
|
1108 | 'scope': self.scope_humanized, | |
1109 | 'expired': self.expired |
|
1109 | 'expired': self.expired | |
1110 | } |
|
1110 | } | |
1111 | return data |
|
1111 | return data | |
1112 |
|
1112 | |||
1113 | def get_api_data(self, include_secrets=False): |
|
1113 | def get_api_data(self, include_secrets=False): | |
1114 | data = self.__json__() |
|
1114 | data = self.__json__() | |
1115 | if include_secrets: |
|
1115 | if include_secrets: | |
1116 | return data |
|
1116 | return data | |
1117 | else: |
|
1117 | else: | |
1118 | data['auth_token'] = self.token_obfuscated |
|
1118 | data['auth_token'] = self.token_obfuscated | |
1119 | return data |
|
1119 | return data | |
1120 |
|
1120 | |||
1121 | @hybrid_property |
|
1121 | @hybrid_property | |
1122 | def description_safe(self): |
|
1122 | def description_safe(self): | |
1123 | from rhodecode.lib import helpers as h |
|
1123 | from rhodecode.lib import helpers as h | |
1124 | return h.escape(self.description) |
|
1124 | return h.escape(self.description) | |
1125 |
|
1125 | |||
1126 | @property |
|
1126 | @property | |
1127 | def expired(self): |
|
1127 | def expired(self): | |
1128 | if self.expires == -1: |
|
1128 | if self.expires == -1: | |
1129 | return False |
|
1129 | return False | |
1130 | return time.time() > self.expires |
|
1130 | return time.time() > self.expires | |
1131 |
|
1131 | |||
1132 | @classmethod |
|
1132 | @classmethod | |
1133 | def _get_role_name(cls, role): |
|
1133 | def _get_role_name(cls, role): | |
1134 | return { |
|
1134 | return { | |
1135 | cls.ROLE_ALL: _('all'), |
|
1135 | cls.ROLE_ALL: _('all'), | |
1136 | cls.ROLE_HTTP: _('http/web interface'), |
|
1136 | cls.ROLE_HTTP: _('http/web interface'), | |
1137 | cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'), |
|
1137 | cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'), | |
1138 | cls.ROLE_API: _('api calls'), |
|
1138 | cls.ROLE_API: _('api calls'), | |
1139 | cls.ROLE_FEED: _('feed access'), |
|
1139 | cls.ROLE_FEED: _('feed access'), | |
1140 | }.get(role, role) |
|
1140 | }.get(role, role) | |
1141 |
|
1141 | |||
1142 | @property |
|
1142 | @property | |
1143 | def role_humanized(self): |
|
1143 | def role_humanized(self): | |
1144 | return self._get_role_name(self.role) |
|
1144 | return self._get_role_name(self.role) | |
1145 |
|
1145 | |||
1146 | def _get_scope(self): |
|
1146 | def _get_scope(self): | |
1147 | if self.repo: |
|
1147 | if self.repo: | |
1148 | return 'Repository: {}'.format(self.repo.repo_name) |
|
1148 | return 'Repository: {}'.format(self.repo.repo_name) | |
1149 | if self.repo_group: |
|
1149 | if self.repo_group: | |
1150 | return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name) |
|
1150 | return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name) | |
1151 | return 'Global' |
|
1151 | return 'Global' | |
1152 |
|
1152 | |||
1153 | @property |
|
1153 | @property | |
1154 | def scope_humanized(self): |
|
1154 | def scope_humanized(self): | |
1155 | return self._get_scope() |
|
1155 | return self._get_scope() | |
1156 |
|
1156 | |||
1157 | @property |
|
1157 | @property | |
1158 | def token_obfuscated(self): |
|
1158 | def token_obfuscated(self): | |
1159 | if self.api_key: |
|
1159 | if self.api_key: | |
1160 | return self.api_key[:4] + "****" |
|
1160 | return self.api_key[:4] + "****" | |
1161 |
|
1161 | |||
1162 |
|
1162 | |||
1163 | class UserEmailMap(Base, BaseModel): |
|
1163 | class UserEmailMap(Base, BaseModel): | |
1164 | __tablename__ = 'user_email_map' |
|
1164 | __tablename__ = 'user_email_map' | |
1165 | __table_args__ = ( |
|
1165 | __table_args__ = ( | |
1166 | Index('uem_email_idx', 'email'), |
|
1166 | Index('uem_email_idx', 'email'), | |
1167 | UniqueConstraint('email'), |
|
1167 | UniqueConstraint('email'), | |
1168 | base_table_args |
|
1168 | base_table_args | |
1169 | ) |
|
1169 | ) | |
1170 | __mapper_args__ = {} |
|
1170 | __mapper_args__ = {} | |
1171 |
|
1171 | |||
1172 | email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1172 | email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1173 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1173 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1174 | _email = Column("email", String(255), nullable=True, unique=False, default=None) |
|
1174 | _email = Column("email", String(255), nullable=True, unique=False, default=None) | |
1175 | user = relationship('User', lazy='joined') |
|
1175 | user = relationship('User', lazy='joined') | |
1176 |
|
1176 | |||
1177 | @validates('_email') |
|
1177 | @validates('_email') | |
1178 | def validate_email(self, key, email): |
|
1178 | def validate_email(self, key, email): | |
1179 | # check if this email is not main one |
|
1179 | # check if this email is not main one | |
1180 | main_email = Session().query(User).filter(User.email == email).scalar() |
|
1180 | main_email = Session().query(User).filter(User.email == email).scalar() | |
1181 | if main_email is not None: |
|
1181 | if main_email is not None: | |
1182 | raise AttributeError('email %s is present is user table' % email) |
|
1182 | raise AttributeError('email %s is present is user table' % email) | |
1183 | return email |
|
1183 | return email | |
1184 |
|
1184 | |||
1185 | @hybrid_property |
|
1185 | @hybrid_property | |
1186 | def email(self): |
|
1186 | def email(self): | |
1187 | return self._email |
|
1187 | return self._email | |
1188 |
|
1188 | |||
1189 | @email.setter |
|
1189 | @email.setter | |
1190 | def email(self, val): |
|
1190 | def email(self, val): | |
1191 | self._email = val.lower() if val else None |
|
1191 | self._email = val.lower() if val else None | |
1192 |
|
1192 | |||
1193 |
|
1193 | |||
1194 | class UserIpMap(Base, BaseModel): |
|
1194 | class UserIpMap(Base, BaseModel): | |
1195 | __tablename__ = 'user_ip_map' |
|
1195 | __tablename__ = 'user_ip_map' | |
1196 | __table_args__ = ( |
|
1196 | __table_args__ = ( | |
1197 | UniqueConstraint('user_id', 'ip_addr'), |
|
1197 | UniqueConstraint('user_id', 'ip_addr'), | |
1198 | base_table_args |
|
1198 | base_table_args | |
1199 | ) |
|
1199 | ) | |
1200 | __mapper_args__ = {} |
|
1200 | __mapper_args__ = {} | |
1201 |
|
1201 | |||
1202 | ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1202 | ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1203 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1203 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1204 | ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None) |
|
1204 | ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None) | |
1205 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) |
|
1205 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
1206 | description = Column("description", String(10000), nullable=True, unique=None, default=None) |
|
1206 | description = Column("description", String(10000), nullable=True, unique=None, default=None) | |
1207 | user = relationship('User', lazy='joined') |
|
1207 | user = relationship('User', lazy='joined') | |
1208 |
|
1208 | |||
1209 | @hybrid_property |
|
1209 | @hybrid_property | |
1210 | def description_safe(self): |
|
1210 | def description_safe(self): | |
1211 | from rhodecode.lib import helpers as h |
|
1211 | from rhodecode.lib import helpers as h | |
1212 | return h.escape(self.description) |
|
1212 | return h.escape(self.description) | |
1213 |
|
1213 | |||
1214 | @classmethod |
|
1214 | @classmethod | |
1215 | def _get_ip_range(cls, ip_addr): |
|
1215 | def _get_ip_range(cls, ip_addr): | |
1216 | net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False) |
|
1216 | net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False) | |
1217 | return [str(net.network_address), str(net.broadcast_address)] |
|
1217 | return [str(net.network_address), str(net.broadcast_address)] | |
1218 |
|
1218 | |||
1219 | def __json__(self): |
|
1219 | def __json__(self): | |
1220 | return { |
|
1220 | return { | |
1221 | 'ip_addr': self.ip_addr, |
|
1221 | 'ip_addr': self.ip_addr, | |
1222 | 'ip_range': self._get_ip_range(self.ip_addr), |
|
1222 | 'ip_range': self._get_ip_range(self.ip_addr), | |
1223 | } |
|
1223 | } | |
1224 |
|
1224 | |||
1225 | def __unicode__(self): |
|
1225 | def __unicode__(self): | |
1226 | return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__, |
|
1226 | return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__, | |
1227 | self.user_id, self.ip_addr) |
|
1227 | self.user_id, self.ip_addr) | |
1228 |
|
1228 | |||
1229 |
|
1229 | |||
1230 | class UserSshKeys(Base, BaseModel): |
|
1230 | class UserSshKeys(Base, BaseModel): | |
1231 | __tablename__ = 'user_ssh_keys' |
|
1231 | __tablename__ = 'user_ssh_keys' | |
1232 | __table_args__ = ( |
|
1232 | __table_args__ = ( | |
1233 | Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'), |
|
1233 | Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'), | |
1234 |
|
1234 | |||
1235 | UniqueConstraint('ssh_key_fingerprint'), |
|
1235 | UniqueConstraint('ssh_key_fingerprint'), | |
1236 |
|
1236 | |||
1237 | base_table_args |
|
1237 | base_table_args | |
1238 | ) |
|
1238 | ) | |
1239 | __mapper_args__ = {} |
|
1239 | __mapper_args__ = {} | |
1240 |
|
1240 | |||
1241 | ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1241 | ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1242 | ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None) |
|
1242 | ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None) | |
1243 | ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None) |
|
1243 | ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None) | |
1244 |
|
1244 | |||
1245 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
1245 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
1246 |
|
1246 | |||
1247 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1247 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1248 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None) |
|
1248 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None) | |
1249 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1249 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1250 |
|
1250 | |||
1251 | user = relationship('User', lazy='joined') |
|
1251 | user = relationship('User', lazy='joined') | |
1252 |
|
1252 | |||
1253 | def __json__(self): |
|
1253 | def __json__(self): | |
1254 | data = { |
|
1254 | data = { | |
1255 | 'ssh_fingerprint': self.ssh_key_fingerprint, |
|
1255 | 'ssh_fingerprint': self.ssh_key_fingerprint, | |
1256 | 'description': self.description, |
|
1256 | 'description': self.description, | |
1257 | 'created_on': self.created_on |
|
1257 | 'created_on': self.created_on | |
1258 | } |
|
1258 | } | |
1259 | return data |
|
1259 | return data | |
1260 |
|
1260 | |||
1261 | def get_api_data(self): |
|
1261 | def get_api_data(self): | |
1262 | data = self.__json__() |
|
1262 | data = self.__json__() | |
1263 | return data |
|
1263 | return data | |
1264 |
|
1264 | |||
1265 |
|
1265 | |||
1266 | class UserLog(Base, BaseModel): |
|
1266 | class UserLog(Base, BaseModel): | |
1267 | __tablename__ = 'user_logs' |
|
1267 | __tablename__ = 'user_logs' | |
1268 | __table_args__ = ( |
|
1268 | __table_args__ = ( | |
1269 | base_table_args, |
|
1269 | base_table_args, | |
1270 | ) |
|
1270 | ) | |
1271 |
|
1271 | |||
1272 | VERSION_1 = 'v1' |
|
1272 | VERSION_1 = 'v1' | |
1273 | VERSION_2 = 'v2' |
|
1273 | VERSION_2 = 'v2' | |
1274 | VERSIONS = [VERSION_1, VERSION_2] |
|
1274 | VERSIONS = [VERSION_1, VERSION_2] | |
1275 |
|
1275 | |||
1276 | user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1276 | user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1277 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None) |
|
1277 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
1278 | username = Column("username", String(255), nullable=True, unique=None, default=None) |
|
1278 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
1279 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None) |
|
1279 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
1280 | repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None) |
|
1280 | repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None) | |
1281 | user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None) |
|
1281 | user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None) | |
1282 | action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None) |
|
1282 | action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None) | |
1283 | action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
1283 | action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
1284 |
|
1284 | |||
1285 | version = Column("version", String(255), nullable=True, default=VERSION_1) |
|
1285 | version = Column("version", String(255), nullable=True, default=VERSION_1) | |
1286 | user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) |
|
1286 | user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
1287 | action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) |
|
1287 | action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
1288 |
|
1288 | |||
1289 | def __unicode__(self): |
|
1289 | def __unicode__(self): | |
1290 | return u"<%s('id:%s:%s')>" % ( |
|
1290 | return u"<%s('id:%s:%s')>" % ( | |
1291 | self.__class__.__name__, self.repository_name, self.action) |
|
1291 | self.__class__.__name__, self.repository_name, self.action) | |
1292 |
|
1292 | |||
1293 | def __json__(self): |
|
1293 | def __json__(self): | |
1294 | return { |
|
1294 | return { | |
1295 | 'user_id': self.user_id, |
|
1295 | 'user_id': self.user_id, | |
1296 | 'username': self.username, |
|
1296 | 'username': self.username, | |
1297 | 'repository_id': self.repository_id, |
|
1297 | 'repository_id': self.repository_id, | |
1298 | 'repository_name': self.repository_name, |
|
1298 | 'repository_name': self.repository_name, | |
1299 | 'user_ip': self.user_ip, |
|
1299 | 'user_ip': self.user_ip, | |
1300 | 'action_date': self.action_date, |
|
1300 | 'action_date': self.action_date, | |
1301 | 'action': self.action, |
|
1301 | 'action': self.action, | |
1302 | } |
|
1302 | } | |
1303 |
|
1303 | |||
1304 | @hybrid_property |
|
1304 | @hybrid_property | |
1305 | def entry_id(self): |
|
1305 | def entry_id(self): | |
1306 | return self.user_log_id |
|
1306 | return self.user_log_id | |
1307 |
|
1307 | |||
1308 | @property |
|
1308 | @property | |
1309 | def action_as_day(self): |
|
1309 | def action_as_day(self): | |
1310 | return datetime.date(*self.action_date.timetuple()[:3]) |
|
1310 | return datetime.date(*self.action_date.timetuple()[:3]) | |
1311 |
|
1311 | |||
1312 | user = relationship('User') |
|
1312 | user = relationship('User') | |
1313 | repository = relationship('Repository', cascade='') |
|
1313 | repository = relationship('Repository', cascade='') | |
1314 |
|
1314 | |||
1315 |
|
1315 | |||
1316 | class UserGroup(Base, BaseModel): |
|
1316 | class UserGroup(Base, BaseModel): | |
1317 | __tablename__ = 'users_groups' |
|
1317 | __tablename__ = 'users_groups' | |
1318 | __table_args__ = ( |
|
1318 | __table_args__ = ( | |
1319 | base_table_args, |
|
1319 | base_table_args, | |
1320 | ) |
|
1320 | ) | |
1321 |
|
1321 | |||
1322 | users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1322 | users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1323 | users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None) |
|
1323 | users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None) | |
1324 | user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None) |
|
1324 | user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None) | |
1325 | users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) |
|
1325 | users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) | |
1326 | inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) |
|
1326 | inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
1327 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) |
|
1327 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
1328 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1328 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1329 | _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data |
|
1329 | _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data | |
1330 |
|
1330 | |||
1331 | members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined") |
|
1331 | members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined") | |
1332 | users_group_to_perm = relationship('UserGroupToPerm', cascade='all') |
|
1332 | users_group_to_perm = relationship('UserGroupToPerm', cascade='all') | |
1333 | users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all') |
|
1333 | users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all') | |
1334 | users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') |
|
1334 | users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') | |
1335 | user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all') |
|
1335 | user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all') | |
1336 | user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all') |
|
1336 | user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all') | |
1337 |
|
1337 | |||
1338 | user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all') |
|
1338 | user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all') | |
1339 | user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id") |
|
1339 | user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id") | |
1340 |
|
1340 | |||
1341 | @classmethod |
|
1341 | @classmethod | |
1342 | def _load_group_data(cls, column): |
|
1342 | def _load_group_data(cls, column): | |
1343 | if not column: |
|
1343 | if not column: | |
1344 | return {} |
|
1344 | return {} | |
1345 |
|
1345 | |||
1346 | try: |
|
1346 | try: | |
1347 | return json.loads(column) or {} |
|
1347 | return json.loads(column) or {} | |
1348 | except TypeError: |
|
1348 | except TypeError: | |
1349 | return {} |
|
1349 | return {} | |
1350 |
|
1350 | |||
1351 | @hybrid_property |
|
1351 | @hybrid_property | |
1352 | def description_safe(self): |
|
1352 | def description_safe(self): | |
1353 | from rhodecode.lib import helpers as h |
|
1353 | from rhodecode.lib import helpers as h | |
1354 | return h.escape(self.user_group_description) |
|
1354 | return h.escape(self.user_group_description) | |
1355 |
|
1355 | |||
1356 | @hybrid_property |
|
1356 | @hybrid_property | |
1357 | def group_data(self): |
|
1357 | def group_data(self): | |
1358 | return self._load_group_data(self._group_data) |
|
1358 | return self._load_group_data(self._group_data) | |
1359 |
|
1359 | |||
1360 | @group_data.expression |
|
1360 | @group_data.expression | |
1361 | def group_data(self, **kwargs): |
|
1361 | def group_data(self, **kwargs): | |
1362 | return self._group_data |
|
1362 | return self._group_data | |
1363 |
|
1363 | |||
1364 | @group_data.setter |
|
1364 | @group_data.setter | |
1365 | def group_data(self, val): |
|
1365 | def group_data(self, val): | |
1366 | try: |
|
1366 | try: | |
1367 | self._group_data = json.dumps(val) |
|
1367 | self._group_data = json.dumps(val) | |
1368 | except Exception: |
|
1368 | except Exception: | |
1369 | log.error(traceback.format_exc()) |
|
1369 | log.error(traceback.format_exc()) | |
1370 |
|
1370 | |||
1371 | @classmethod |
|
1371 | @classmethod | |
1372 | def _load_sync(cls, group_data): |
|
1372 | def _load_sync(cls, group_data): | |
1373 | if group_data: |
|
1373 | if group_data: | |
1374 | return group_data.get('extern_type') |
|
1374 | return group_data.get('extern_type') | |
1375 |
|
1375 | |||
1376 | @property |
|
1376 | @property | |
1377 | def sync(self): |
|
1377 | def sync(self): | |
1378 | return self._load_sync(self.group_data) |
|
1378 | return self._load_sync(self.group_data) | |
1379 |
|
1379 | |||
1380 | def __unicode__(self): |
|
1380 | def __unicode__(self): | |
1381 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, |
|
1381 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, | |
1382 | self.users_group_id, |
|
1382 | self.users_group_id, | |
1383 | self.users_group_name) |
|
1383 | self.users_group_name) | |
1384 |
|
1384 | |||
1385 | @classmethod |
|
1385 | @classmethod | |
1386 | def get_by_group_name(cls, group_name, cache=False, |
|
1386 | def get_by_group_name(cls, group_name, cache=False, | |
1387 | case_insensitive=False): |
|
1387 | case_insensitive=False): | |
1388 | if case_insensitive: |
|
1388 | if case_insensitive: | |
1389 | q = cls.query().filter(func.lower(cls.users_group_name) == |
|
1389 | q = cls.query().filter(func.lower(cls.users_group_name) == | |
1390 | func.lower(group_name)) |
|
1390 | func.lower(group_name)) | |
1391 |
|
1391 | |||
1392 | else: |
|
1392 | else: | |
1393 | q = cls.query().filter(cls.users_group_name == group_name) |
|
1393 | q = cls.query().filter(cls.users_group_name == group_name) | |
1394 | if cache: |
|
1394 | if cache: | |
1395 | q = q.options( |
|
1395 | q = q.options( | |
1396 | FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name))) |
|
1396 | FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name))) | |
1397 | return q.scalar() |
|
1397 | return q.scalar() | |
1398 |
|
1398 | |||
1399 | @classmethod |
|
1399 | @classmethod | |
1400 | def get(cls, user_group_id, cache=False): |
|
1400 | def get(cls, user_group_id, cache=False): | |
1401 | if not user_group_id: |
|
1401 | if not user_group_id: | |
1402 | return |
|
1402 | return | |
1403 |
|
1403 | |||
1404 | user_group = cls.query() |
|
1404 | user_group = cls.query() | |
1405 | if cache: |
|
1405 | if cache: | |
1406 | user_group = user_group.options( |
|
1406 | user_group = user_group.options( | |
1407 | FromCache("sql_cache_short", "get_users_group_%s" % user_group_id)) |
|
1407 | FromCache("sql_cache_short", "get_users_group_%s" % user_group_id)) | |
1408 | return user_group.get(user_group_id) |
|
1408 | return user_group.get(user_group_id) | |
1409 |
|
1409 | |||
1410 | def permissions(self, with_admins=True, with_owner=True, |
|
1410 | def permissions(self, with_admins=True, with_owner=True, | |
1411 | expand_from_user_groups=False): |
|
1411 | expand_from_user_groups=False): | |
1412 | """ |
|
1412 | """ | |
1413 | Permissions for user groups |
|
1413 | Permissions for user groups | |
1414 | """ |
|
1414 | """ | |
1415 | _admin_perm = 'usergroup.admin' |
|
1415 | _admin_perm = 'usergroup.admin' | |
1416 |
|
1416 | |||
1417 | owner_row = [] |
|
1417 | owner_row = [] | |
1418 | if with_owner: |
|
1418 | if with_owner: | |
1419 | usr = AttributeDict(self.user.get_dict()) |
|
1419 | usr = AttributeDict(self.user.get_dict()) | |
1420 | usr.owner_row = True |
|
1420 | usr.owner_row = True | |
1421 | usr.permission = _admin_perm |
|
1421 | usr.permission = _admin_perm | |
1422 | owner_row.append(usr) |
|
1422 | owner_row.append(usr) | |
1423 |
|
1423 | |||
1424 | super_admin_ids = [] |
|
1424 | super_admin_ids = [] | |
1425 | super_admin_rows = [] |
|
1425 | super_admin_rows = [] | |
1426 | if with_admins: |
|
1426 | if with_admins: | |
1427 | for usr in User.get_all_super_admins(): |
|
1427 | for usr in User.get_all_super_admins(): | |
1428 | super_admin_ids.append(usr.user_id) |
|
1428 | super_admin_ids.append(usr.user_id) | |
1429 | # if this admin is also owner, don't double the record |
|
1429 | # if this admin is also owner, don't double the record | |
1430 | if usr.user_id == owner_row[0].user_id: |
|
1430 | if usr.user_id == owner_row[0].user_id: | |
1431 | owner_row[0].admin_row = True |
|
1431 | owner_row[0].admin_row = True | |
1432 | else: |
|
1432 | else: | |
1433 | usr = AttributeDict(usr.get_dict()) |
|
1433 | usr = AttributeDict(usr.get_dict()) | |
1434 | usr.admin_row = True |
|
1434 | usr.admin_row = True | |
1435 | usr.permission = _admin_perm |
|
1435 | usr.permission = _admin_perm | |
1436 | super_admin_rows.append(usr) |
|
1436 | super_admin_rows.append(usr) | |
1437 |
|
1437 | |||
1438 | q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self) |
|
1438 | q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self) | |
1439 | q = q.options(joinedload(UserUserGroupToPerm.user_group), |
|
1439 | q = q.options(joinedload(UserUserGroupToPerm.user_group), | |
1440 | joinedload(UserUserGroupToPerm.user), |
|
1440 | joinedload(UserUserGroupToPerm.user), | |
1441 | joinedload(UserUserGroupToPerm.permission),) |
|
1441 | joinedload(UserUserGroupToPerm.permission),) | |
1442 |
|
1442 | |||
1443 | # get owners and admins and permissions. We do a trick of re-writing |
|
1443 | # get owners and admins and permissions. We do a trick of re-writing | |
1444 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
1444 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
1445 | # has a global reference and changing one object propagates to all |
|
1445 | # has a global reference and changing one object propagates to all | |
1446 | # others. This means if admin is also an owner admin_row that change |
|
1446 | # others. This means if admin is also an owner admin_row that change | |
1447 | # would propagate to both objects |
|
1447 | # would propagate to both objects | |
1448 | perm_rows = [] |
|
1448 | perm_rows = [] | |
1449 | for _usr in q.all(): |
|
1449 | for _usr in q.all(): | |
1450 | usr = AttributeDict(_usr.user.get_dict()) |
|
1450 | usr = AttributeDict(_usr.user.get_dict()) | |
1451 | # if this user is also owner/admin, mark as duplicate record |
|
1451 | # if this user is also owner/admin, mark as duplicate record | |
1452 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
1452 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
1453 | usr.duplicate_perm = True |
|
1453 | usr.duplicate_perm = True | |
1454 | usr.permission = _usr.permission.permission_name |
|
1454 | usr.permission = _usr.permission.permission_name | |
1455 | perm_rows.append(usr) |
|
1455 | perm_rows.append(usr) | |
1456 |
|
1456 | |||
1457 | # filter the perm rows by 'default' first and then sort them by |
|
1457 | # filter the perm rows by 'default' first and then sort them by | |
1458 | # admin,write,read,none permissions sorted again alphabetically in |
|
1458 | # admin,write,read,none permissions sorted again alphabetically in | |
1459 | # each group |
|
1459 | # each group | |
1460 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
1460 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
1461 |
|
1461 | |||
1462 | user_groups_rows = [] |
|
1462 | user_groups_rows = [] | |
1463 | if expand_from_user_groups: |
|
1463 | if expand_from_user_groups: | |
1464 | for ug in self.permission_user_groups(with_members=True): |
|
1464 | for ug in self.permission_user_groups(with_members=True): | |
1465 | for user_data in ug.members: |
|
1465 | for user_data in ug.members: | |
1466 | user_groups_rows.append(user_data) |
|
1466 | user_groups_rows.append(user_data) | |
1467 |
|
1467 | |||
1468 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
1468 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
1469 |
|
1469 | |||
1470 | def permission_user_groups(self, with_members=False): |
|
1470 | def permission_user_groups(self, with_members=False): | |
1471 | q = UserGroupUserGroupToPerm.query()\ |
|
1471 | q = UserGroupUserGroupToPerm.query()\ | |
1472 | .filter(UserGroupUserGroupToPerm.target_user_group == self) |
|
1472 | .filter(UserGroupUserGroupToPerm.target_user_group == self) | |
1473 | q = q.options(joinedload(UserGroupUserGroupToPerm.user_group), |
|
1473 | q = q.options(joinedload(UserGroupUserGroupToPerm.user_group), | |
1474 | joinedload(UserGroupUserGroupToPerm.target_user_group), |
|
1474 | joinedload(UserGroupUserGroupToPerm.target_user_group), | |
1475 | joinedload(UserGroupUserGroupToPerm.permission),) |
|
1475 | joinedload(UserGroupUserGroupToPerm.permission),) | |
1476 |
|
1476 | |||
1477 | perm_rows = [] |
|
1477 | perm_rows = [] | |
1478 | for _user_group in q.all(): |
|
1478 | for _user_group in q.all(): | |
1479 | entry = AttributeDict(_user_group.user_group.get_dict()) |
|
1479 | entry = AttributeDict(_user_group.user_group.get_dict()) | |
1480 | entry.permission = _user_group.permission.permission_name |
|
1480 | entry.permission = _user_group.permission.permission_name | |
1481 | if with_members: |
|
1481 | if with_members: | |
1482 | entry.members = [x.user.get_dict() |
|
1482 | entry.members = [x.user.get_dict() | |
1483 | for x in _user_group.user_group.members] |
|
1483 | for x in _user_group.user_group.members] | |
1484 | perm_rows.append(entry) |
|
1484 | perm_rows.append(entry) | |
1485 |
|
1485 | |||
1486 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
1486 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
1487 | return perm_rows |
|
1487 | return perm_rows | |
1488 |
|
1488 | |||
1489 | def _get_default_perms(self, user_group, suffix=''): |
|
1489 | def _get_default_perms(self, user_group, suffix=''): | |
1490 | from rhodecode.model.permission import PermissionModel |
|
1490 | from rhodecode.model.permission import PermissionModel | |
1491 | return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix) |
|
1491 | return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix) | |
1492 |
|
1492 | |||
1493 | def get_default_perms(self, suffix=''): |
|
1493 | def get_default_perms(self, suffix=''): | |
1494 | return self._get_default_perms(self, suffix) |
|
1494 | return self._get_default_perms(self, suffix) | |
1495 |
|
1495 | |||
1496 | def get_api_data(self, with_group_members=True, include_secrets=False): |
|
1496 | def get_api_data(self, with_group_members=True, include_secrets=False): | |
1497 | """ |
|
1497 | """ | |
1498 | :param include_secrets: See :meth:`User.get_api_data`, this parameter is |
|
1498 | :param include_secrets: See :meth:`User.get_api_data`, this parameter is | |
1499 | basically forwarded. |
|
1499 | basically forwarded. | |
1500 |
|
1500 | |||
1501 | """ |
|
1501 | """ | |
1502 | user_group = self |
|
1502 | user_group = self | |
1503 | data = { |
|
1503 | data = { | |
1504 | 'users_group_id': user_group.users_group_id, |
|
1504 | 'users_group_id': user_group.users_group_id, | |
1505 | 'group_name': user_group.users_group_name, |
|
1505 | 'group_name': user_group.users_group_name, | |
1506 | 'group_description': user_group.user_group_description, |
|
1506 | 'group_description': user_group.user_group_description, | |
1507 | 'active': user_group.users_group_active, |
|
1507 | 'active': user_group.users_group_active, | |
1508 | 'owner': user_group.user.username, |
|
1508 | 'owner': user_group.user.username, | |
1509 | 'sync': user_group.sync, |
|
1509 | 'sync': user_group.sync, | |
1510 | 'owner_email': user_group.user.email, |
|
1510 | 'owner_email': user_group.user.email, | |
1511 | } |
|
1511 | } | |
1512 |
|
1512 | |||
1513 | if with_group_members: |
|
1513 | if with_group_members: | |
1514 | users = [] |
|
1514 | users = [] | |
1515 | for user in user_group.members: |
|
1515 | for user in user_group.members: | |
1516 | user = user.user |
|
1516 | user = user.user | |
1517 | users.append(user.get_api_data(include_secrets=include_secrets)) |
|
1517 | users.append(user.get_api_data(include_secrets=include_secrets)) | |
1518 | data['users'] = users |
|
1518 | data['users'] = users | |
1519 |
|
1519 | |||
1520 | return data |
|
1520 | return data | |
1521 |
|
1521 | |||
1522 |
|
1522 | |||
1523 | class UserGroupMember(Base, BaseModel): |
|
1523 | class UserGroupMember(Base, BaseModel): | |
1524 | __tablename__ = 'users_groups_members' |
|
1524 | __tablename__ = 'users_groups_members' | |
1525 | __table_args__ = ( |
|
1525 | __table_args__ = ( | |
1526 | base_table_args, |
|
1526 | base_table_args, | |
1527 | ) |
|
1527 | ) | |
1528 |
|
1528 | |||
1529 | users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1529 | users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1530 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
1530 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
1531 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
1531 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
1532 |
|
1532 | |||
1533 | user = relationship('User', lazy='joined') |
|
1533 | user = relationship('User', lazy='joined') | |
1534 | users_group = relationship('UserGroup') |
|
1534 | users_group = relationship('UserGroup') | |
1535 |
|
1535 | |||
1536 | def __init__(self, gr_id='', u_id=''): |
|
1536 | def __init__(self, gr_id='', u_id=''): | |
1537 | self.users_group_id = gr_id |
|
1537 | self.users_group_id = gr_id | |
1538 | self.user_id = u_id |
|
1538 | self.user_id = u_id | |
1539 |
|
1539 | |||
1540 |
|
1540 | |||
1541 | class RepositoryField(Base, BaseModel): |
|
1541 | class RepositoryField(Base, BaseModel): | |
1542 | __tablename__ = 'repositories_fields' |
|
1542 | __tablename__ = 'repositories_fields' | |
1543 | __table_args__ = ( |
|
1543 | __table_args__ = ( | |
1544 | UniqueConstraint('repository_id', 'field_key'), # no-multi field |
|
1544 | UniqueConstraint('repository_id', 'field_key'), # no-multi field | |
1545 | base_table_args, |
|
1545 | base_table_args, | |
1546 | ) |
|
1546 | ) | |
1547 |
|
1547 | |||
1548 | PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields |
|
1548 | PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields | |
1549 |
|
1549 | |||
1550 | repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1550 | repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1551 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
1551 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
1552 | field_key = Column("field_key", String(250)) |
|
1552 | field_key = Column("field_key", String(250)) | |
1553 | field_label = Column("field_label", String(1024), nullable=False) |
|
1553 | field_label = Column("field_label", String(1024), nullable=False) | |
1554 | field_value = Column("field_value", String(10000), nullable=False) |
|
1554 | field_value = Column("field_value", String(10000), nullable=False) | |
1555 | field_desc = Column("field_desc", String(1024), nullable=False) |
|
1555 | field_desc = Column("field_desc", String(1024), nullable=False) | |
1556 | field_type = Column("field_type", String(255), nullable=False, unique=None) |
|
1556 | field_type = Column("field_type", String(255), nullable=False, unique=None) | |
1557 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1557 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1558 |
|
1558 | |||
1559 | repository = relationship('Repository') |
|
1559 | repository = relationship('Repository') | |
1560 |
|
1560 | |||
1561 | @property |
|
1561 | @property | |
1562 | def field_key_prefixed(self): |
|
1562 | def field_key_prefixed(self): | |
1563 | return 'ex_%s' % self.field_key |
|
1563 | return 'ex_%s' % self.field_key | |
1564 |
|
1564 | |||
1565 | @classmethod |
|
1565 | @classmethod | |
1566 | def un_prefix_key(cls, key): |
|
1566 | def un_prefix_key(cls, key): | |
1567 | if key.startswith(cls.PREFIX): |
|
1567 | if key.startswith(cls.PREFIX): | |
1568 | return key[len(cls.PREFIX):] |
|
1568 | return key[len(cls.PREFIX):] | |
1569 | return key |
|
1569 | return key | |
1570 |
|
1570 | |||
1571 | @classmethod |
|
1571 | @classmethod | |
1572 | def get_by_key_name(cls, key, repo): |
|
1572 | def get_by_key_name(cls, key, repo): | |
1573 | row = cls.query()\ |
|
1573 | row = cls.query()\ | |
1574 | .filter(cls.repository == repo)\ |
|
1574 | .filter(cls.repository == repo)\ | |
1575 | .filter(cls.field_key == key).scalar() |
|
1575 | .filter(cls.field_key == key).scalar() | |
1576 | return row |
|
1576 | return row | |
1577 |
|
1577 | |||
1578 |
|
1578 | |||
1579 | class Repository(Base, BaseModel): |
|
1579 | class Repository(Base, BaseModel): | |
1580 | __tablename__ = 'repositories' |
|
1580 | __tablename__ = 'repositories' | |
1581 | __table_args__ = ( |
|
1581 | __table_args__ = ( | |
1582 | Index('r_repo_name_idx', 'repo_name', mysql_length=255), |
|
1582 | Index('r_repo_name_idx', 'repo_name', mysql_length=255), | |
1583 | base_table_args, |
|
1583 | base_table_args, | |
1584 | ) |
|
1584 | ) | |
1585 | DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}' |
|
1585 | DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}' | |
1586 | DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}' |
|
1586 | DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}' | |
1587 | DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}' |
|
1587 | DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}' | |
1588 |
|
1588 | |||
1589 | STATE_CREATED = 'repo_state_created' |
|
1589 | STATE_CREATED = 'repo_state_created' | |
1590 | STATE_PENDING = 'repo_state_pending' |
|
1590 | STATE_PENDING = 'repo_state_pending' | |
1591 | STATE_ERROR = 'repo_state_error' |
|
1591 | STATE_ERROR = 'repo_state_error' | |
1592 |
|
1592 | |||
1593 | LOCK_AUTOMATIC = 'lock_auto' |
|
1593 | LOCK_AUTOMATIC = 'lock_auto' | |
1594 | LOCK_API = 'lock_api' |
|
1594 | LOCK_API = 'lock_api' | |
1595 | LOCK_WEB = 'lock_web' |
|
1595 | LOCK_WEB = 'lock_web' | |
1596 | LOCK_PULL = 'lock_pull' |
|
1596 | LOCK_PULL = 'lock_pull' | |
1597 |
|
1597 | |||
1598 | NAME_SEP = URL_SEP |
|
1598 | NAME_SEP = URL_SEP | |
1599 |
|
1599 | |||
1600 | repo_id = Column( |
|
1600 | repo_id = Column( | |
1601 | "repo_id", Integer(), nullable=False, unique=True, default=None, |
|
1601 | "repo_id", Integer(), nullable=False, unique=True, default=None, | |
1602 | primary_key=True) |
|
1602 | primary_key=True) | |
1603 | _repo_name = Column( |
|
1603 | _repo_name = Column( | |
1604 | "repo_name", Text(), nullable=False, default=None) |
|
1604 | "repo_name", Text(), nullable=False, default=None) | |
1605 | _repo_name_hash = Column( |
|
1605 | _repo_name_hash = Column( | |
1606 | "repo_name_hash", String(255), nullable=False, unique=True) |
|
1606 | "repo_name_hash", String(255), nullable=False, unique=True) | |
1607 | repo_state = Column("repo_state", String(255), nullable=True) |
|
1607 | repo_state = Column("repo_state", String(255), nullable=True) | |
1608 |
|
1608 | |||
1609 | clone_uri = Column( |
|
1609 | clone_uri = Column( | |
1610 | "clone_uri", EncryptedTextValue(), nullable=True, unique=False, |
|
1610 | "clone_uri", EncryptedTextValue(), nullable=True, unique=False, | |
1611 | default=None) |
|
1611 | default=None) | |
1612 | push_uri = Column( |
|
1612 | push_uri = Column( | |
1613 | "push_uri", EncryptedTextValue(), nullable=True, unique=False, |
|
1613 | "push_uri", EncryptedTextValue(), nullable=True, unique=False, | |
1614 | default=None) |
|
1614 | default=None) | |
1615 | repo_type = Column( |
|
1615 | repo_type = Column( | |
1616 | "repo_type", String(255), nullable=False, unique=False, default=None) |
|
1616 | "repo_type", String(255), nullable=False, unique=False, default=None) | |
1617 | user_id = Column( |
|
1617 | user_id = Column( | |
1618 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, |
|
1618 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
1619 | unique=False, default=None) |
|
1619 | unique=False, default=None) | |
1620 | private = Column( |
|
1620 | private = Column( | |
1621 | "private", Boolean(), nullable=True, unique=None, default=None) |
|
1621 | "private", Boolean(), nullable=True, unique=None, default=None) | |
1622 | archived = Column( |
|
1622 | archived = Column( | |
1623 | "archived", Boolean(), nullable=True, unique=None, default=None) |
|
1623 | "archived", Boolean(), nullable=True, unique=None, default=None) | |
1624 | enable_statistics = Column( |
|
1624 | enable_statistics = Column( | |
1625 | "statistics", Boolean(), nullable=True, unique=None, default=True) |
|
1625 | "statistics", Boolean(), nullable=True, unique=None, default=True) | |
1626 | enable_downloads = Column( |
|
1626 | enable_downloads = Column( | |
1627 | "downloads", Boolean(), nullable=True, unique=None, default=True) |
|
1627 | "downloads", Boolean(), nullable=True, unique=None, default=True) | |
1628 | description = Column( |
|
1628 | description = Column( | |
1629 | "description", String(10000), nullable=True, unique=None, default=None) |
|
1629 | "description", String(10000), nullable=True, unique=None, default=None) | |
1630 | created_on = Column( |
|
1630 | created_on = Column( | |
1631 | 'created_on', DateTime(timezone=False), nullable=True, unique=None, |
|
1631 | 'created_on', DateTime(timezone=False), nullable=True, unique=None, | |
1632 | default=datetime.datetime.now) |
|
1632 | default=datetime.datetime.now) | |
1633 | updated_on = Column( |
|
1633 | updated_on = Column( | |
1634 | 'updated_on', DateTime(timezone=False), nullable=True, unique=None, |
|
1634 | 'updated_on', DateTime(timezone=False), nullable=True, unique=None, | |
1635 | default=datetime.datetime.now) |
|
1635 | default=datetime.datetime.now) | |
1636 | _landing_revision = Column( |
|
1636 | _landing_revision = Column( | |
1637 | "landing_revision", String(255), nullable=False, unique=False, |
|
1637 | "landing_revision", String(255), nullable=False, unique=False, | |
1638 | default=None) |
|
1638 | default=None) | |
1639 | enable_locking = Column( |
|
1639 | enable_locking = Column( | |
1640 | "enable_locking", Boolean(), nullable=False, unique=None, |
|
1640 | "enable_locking", Boolean(), nullable=False, unique=None, | |
1641 | default=False) |
|
1641 | default=False) | |
1642 | _locked = Column( |
|
1642 | _locked = Column( | |
1643 | "locked", String(255), nullable=True, unique=False, default=None) |
|
1643 | "locked", String(255), nullable=True, unique=False, default=None) | |
1644 | _changeset_cache = Column( |
|
1644 | _changeset_cache = Column( | |
1645 | "changeset_cache", LargeBinary(), nullable=True) # JSON data |
|
1645 | "changeset_cache", LargeBinary(), nullable=True) # JSON data | |
1646 |
|
1646 | |||
1647 | fork_id = Column( |
|
1647 | fork_id = Column( | |
1648 | "fork_id", Integer(), ForeignKey('repositories.repo_id'), |
|
1648 | "fork_id", Integer(), ForeignKey('repositories.repo_id'), | |
1649 | nullable=True, unique=False, default=None) |
|
1649 | nullable=True, unique=False, default=None) | |
1650 | group_id = Column( |
|
1650 | group_id = Column( | |
1651 | "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, |
|
1651 | "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, | |
1652 | unique=False, default=None) |
|
1652 | unique=False, default=None) | |
1653 |
|
1653 | |||
1654 | user = relationship('User', lazy='joined') |
|
1654 | user = relationship('User', lazy='joined') | |
1655 | fork = relationship('Repository', remote_side=repo_id, lazy='joined') |
|
1655 | fork = relationship('Repository', remote_side=repo_id, lazy='joined') | |
1656 | group = relationship('RepoGroup', lazy='joined') |
|
1656 | group = relationship('RepoGroup', lazy='joined') | |
1657 | repo_to_perm = relationship( |
|
1657 | repo_to_perm = relationship( | |
1658 | 'UserRepoToPerm', cascade='all', |
|
1658 | 'UserRepoToPerm', cascade='all', | |
1659 | order_by='UserRepoToPerm.repo_to_perm_id') |
|
1659 | order_by='UserRepoToPerm.repo_to_perm_id') | |
1660 | users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all') |
|
1660 | users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all') | |
1661 | stats = relationship('Statistics', cascade='all', uselist=False) |
|
1661 | stats = relationship('Statistics', cascade='all', uselist=False) | |
1662 |
|
1662 | |||
1663 | followers = relationship( |
|
1663 | followers = relationship( | |
1664 | 'UserFollowing', |
|
1664 | 'UserFollowing', | |
1665 | primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', |
|
1665 | primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', | |
1666 | cascade='all') |
|
1666 | cascade='all') | |
1667 | extra_fields = relationship( |
|
1667 | extra_fields = relationship( | |
1668 | 'RepositoryField', cascade="all, delete, delete-orphan") |
|
1668 | 'RepositoryField', cascade="all, delete, delete-orphan") | |
1669 | logs = relationship('UserLog') |
|
1669 | logs = relationship('UserLog') | |
1670 | comments = relationship( |
|
1670 | comments = relationship( | |
1671 | 'ChangesetComment', cascade="all, delete, delete-orphan") |
|
1671 | 'ChangesetComment', cascade="all, delete, delete-orphan") | |
1672 | pull_requests_source = relationship( |
|
1672 | pull_requests_source = relationship( | |
1673 | 'PullRequest', |
|
1673 | 'PullRequest', | |
1674 | primaryjoin='PullRequest.source_repo_id==Repository.repo_id', |
|
1674 | primaryjoin='PullRequest.source_repo_id==Repository.repo_id', | |
1675 | cascade="all, delete, delete-orphan") |
|
1675 | cascade="all, delete, delete-orphan") | |
1676 | pull_requests_target = relationship( |
|
1676 | pull_requests_target = relationship( | |
1677 | 'PullRequest', |
|
1677 | 'PullRequest', | |
1678 | primaryjoin='PullRequest.target_repo_id==Repository.repo_id', |
|
1678 | primaryjoin='PullRequest.target_repo_id==Repository.repo_id', | |
1679 | cascade="all, delete, delete-orphan") |
|
1679 | cascade="all, delete, delete-orphan") | |
1680 | ui = relationship('RepoRhodeCodeUi', cascade="all") |
|
1680 | ui = relationship('RepoRhodeCodeUi', cascade="all") | |
1681 | settings = relationship('RepoRhodeCodeSetting', cascade="all") |
|
1681 | settings = relationship('RepoRhodeCodeSetting', cascade="all") | |
1682 | integrations = relationship('Integration', cascade="all, delete, delete-orphan") |
|
1682 | integrations = relationship('Integration', cascade="all, delete, delete-orphan") | |
1683 |
|
1683 | |||
1684 | scoped_tokens = relationship('UserApiKeys', cascade="all") |
|
1684 | scoped_tokens = relationship('UserApiKeys', cascade="all") | |
1685 |
|
1685 | |||
1686 | artifacts = relationship('FileStore', cascade="all") |
|
1686 | artifacts = relationship('FileStore', cascade="all") | |
1687 |
|
1687 | |||
1688 | def __unicode__(self): |
|
1688 | def __unicode__(self): | |
1689 | return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id, |
|
1689 | return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id, | |
1690 | safe_unicode(self.repo_name)) |
|
1690 | safe_unicode(self.repo_name)) | |
1691 |
|
1691 | |||
1692 | @hybrid_property |
|
1692 | @hybrid_property | |
1693 | def description_safe(self): |
|
1693 | def description_safe(self): | |
1694 | from rhodecode.lib import helpers as h |
|
1694 | from rhodecode.lib import helpers as h | |
1695 | return h.escape(self.description) |
|
1695 | return h.escape(self.description) | |
1696 |
|
1696 | |||
1697 | @hybrid_property |
|
1697 | @hybrid_property | |
1698 | def landing_rev(self): |
|
1698 | def landing_rev(self): | |
1699 | # always should return [rev_type, rev] |
|
1699 | # always should return [rev_type, rev] | |
1700 | if self._landing_revision: |
|
1700 | if self._landing_revision: | |
1701 | _rev_info = self._landing_revision.split(':') |
|
1701 | _rev_info = self._landing_revision.split(':') | |
1702 | if len(_rev_info) < 2: |
|
1702 | if len(_rev_info) < 2: | |
1703 | _rev_info.insert(0, 'rev') |
|
1703 | _rev_info.insert(0, 'rev') | |
1704 | return [_rev_info[0], _rev_info[1]] |
|
1704 | return [_rev_info[0], _rev_info[1]] | |
1705 | return [None, None] |
|
1705 | return [None, None] | |
1706 |
|
1706 | |||
1707 | @landing_rev.setter |
|
1707 | @landing_rev.setter | |
1708 | def landing_rev(self, val): |
|
1708 | def landing_rev(self, val): | |
1709 | if ':' not in val: |
|
1709 | if ':' not in val: | |
1710 | raise ValueError('value must be delimited with `:` and consist ' |
|
1710 | raise ValueError('value must be delimited with `:` and consist ' | |
1711 | 'of <rev_type>:<rev>, got %s instead' % val) |
|
1711 | 'of <rev_type>:<rev>, got %s instead' % val) | |
1712 | self._landing_revision = val |
|
1712 | self._landing_revision = val | |
1713 |
|
1713 | |||
1714 | @hybrid_property |
|
1714 | @hybrid_property | |
1715 | def locked(self): |
|
1715 | def locked(self): | |
1716 | if self._locked: |
|
1716 | if self._locked: | |
1717 | user_id, timelocked, reason = self._locked.split(':') |
|
1717 | user_id, timelocked, reason = self._locked.split(':') | |
1718 | lock_values = int(user_id), timelocked, reason |
|
1718 | lock_values = int(user_id), timelocked, reason | |
1719 | else: |
|
1719 | else: | |
1720 | lock_values = [None, None, None] |
|
1720 | lock_values = [None, None, None] | |
1721 | return lock_values |
|
1721 | return lock_values | |
1722 |
|
1722 | |||
1723 | @locked.setter |
|
1723 | @locked.setter | |
1724 | def locked(self, val): |
|
1724 | def locked(self, val): | |
1725 | if val and isinstance(val, (list, tuple)): |
|
1725 | if val and isinstance(val, (list, tuple)): | |
1726 | self._locked = ':'.join(map(str, val)) |
|
1726 | self._locked = ':'.join(map(str, val)) | |
1727 | else: |
|
1727 | else: | |
1728 | self._locked = None |
|
1728 | self._locked = None | |
1729 |
|
1729 | |||
1730 | @hybrid_property |
|
1730 | @hybrid_property | |
1731 | def changeset_cache(self): |
|
1731 | def changeset_cache(self): | |
1732 | from rhodecode.lib.vcs.backends.base import EmptyCommit |
|
1732 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
1733 | dummy = EmptyCommit().__json__() |
|
1733 | dummy = EmptyCommit().__json__() | |
1734 | if not self._changeset_cache: |
|
1734 | if not self._changeset_cache: | |
1735 | dummy['source_repo_id'] = self.repo_id |
|
1735 | dummy['source_repo_id'] = self.repo_id | |
1736 | return json.loads(json.dumps(dummy)) |
|
1736 | return json.loads(json.dumps(dummy)) | |
1737 |
|
1737 | |||
1738 | try: |
|
1738 | try: | |
1739 | return json.loads(self._changeset_cache) |
|
1739 | return json.loads(self._changeset_cache) | |
1740 | except TypeError: |
|
1740 | except TypeError: | |
1741 | return dummy |
|
1741 | return dummy | |
1742 | except Exception: |
|
1742 | except Exception: | |
1743 | log.error(traceback.format_exc()) |
|
1743 | log.error(traceback.format_exc()) | |
1744 | return dummy |
|
1744 | return dummy | |
1745 |
|
1745 | |||
1746 | @changeset_cache.setter |
|
1746 | @changeset_cache.setter | |
1747 | def changeset_cache(self, val): |
|
1747 | def changeset_cache(self, val): | |
1748 | try: |
|
1748 | try: | |
1749 | self._changeset_cache = json.dumps(val) |
|
1749 | self._changeset_cache = json.dumps(val) | |
1750 | except Exception: |
|
1750 | except Exception: | |
1751 | log.error(traceback.format_exc()) |
|
1751 | log.error(traceback.format_exc()) | |
1752 |
|
1752 | |||
1753 | @hybrid_property |
|
1753 | @hybrid_property | |
1754 | def repo_name(self): |
|
1754 | def repo_name(self): | |
1755 | return self._repo_name |
|
1755 | return self._repo_name | |
1756 |
|
1756 | |||
1757 | @repo_name.setter |
|
1757 | @repo_name.setter | |
1758 | def repo_name(self, value): |
|
1758 | def repo_name(self, value): | |
1759 | self._repo_name = value |
|
1759 | self._repo_name = value | |
1760 | self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest() |
|
1760 | self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest() | |
1761 |
|
1761 | |||
1762 | @classmethod |
|
1762 | @classmethod | |
1763 | def normalize_repo_name(cls, repo_name): |
|
1763 | def normalize_repo_name(cls, repo_name): | |
1764 | """ |
|
1764 | """ | |
1765 | Normalizes os specific repo_name to the format internally stored inside |
|
1765 | Normalizes os specific repo_name to the format internally stored inside | |
1766 | database using URL_SEP |
|
1766 | database using URL_SEP | |
1767 |
|
1767 | |||
1768 | :param cls: |
|
1768 | :param cls: | |
1769 | :param repo_name: |
|
1769 | :param repo_name: | |
1770 | """ |
|
1770 | """ | |
1771 | return cls.NAME_SEP.join(repo_name.split(os.sep)) |
|
1771 | return cls.NAME_SEP.join(repo_name.split(os.sep)) | |
1772 |
|
1772 | |||
1773 | @classmethod |
|
1773 | @classmethod | |
1774 | def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False): |
|
1774 | def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False): | |
1775 | session = Session() |
|
1775 | session = Session() | |
1776 | q = session.query(cls).filter(cls.repo_name == repo_name) |
|
1776 | q = session.query(cls).filter(cls.repo_name == repo_name) | |
1777 |
|
1777 | |||
1778 | if cache: |
|
1778 | if cache: | |
1779 | if identity_cache: |
|
1779 | if identity_cache: | |
1780 | val = cls.identity_cache(session, 'repo_name', repo_name) |
|
1780 | val = cls.identity_cache(session, 'repo_name', repo_name) | |
1781 | if val: |
|
1781 | if val: | |
1782 | return val |
|
1782 | return val | |
1783 | else: |
|
1783 | else: | |
1784 | cache_key = "get_repo_by_name_%s" % _hash_key(repo_name) |
|
1784 | cache_key = "get_repo_by_name_%s" % _hash_key(repo_name) | |
1785 | q = q.options( |
|
1785 | q = q.options( | |
1786 | FromCache("sql_cache_short", cache_key)) |
|
1786 | FromCache("sql_cache_short", cache_key)) | |
1787 |
|
1787 | |||
1788 | return q.scalar() |
|
1788 | return q.scalar() | |
1789 |
|
1789 | |||
1790 | @classmethod |
|
1790 | @classmethod | |
1791 | def get_by_id_or_repo_name(cls, repoid): |
|
1791 | def get_by_id_or_repo_name(cls, repoid): | |
1792 | if isinstance(repoid, (int, long)): |
|
1792 | if isinstance(repoid, (int, long)): | |
1793 | try: |
|
1793 | try: | |
1794 | repo = cls.get(repoid) |
|
1794 | repo = cls.get(repoid) | |
1795 | except ValueError: |
|
1795 | except ValueError: | |
1796 | repo = None |
|
1796 | repo = None | |
1797 | else: |
|
1797 | else: | |
1798 | repo = cls.get_by_repo_name(repoid) |
|
1798 | repo = cls.get_by_repo_name(repoid) | |
1799 | return repo |
|
1799 | return repo | |
1800 |
|
1800 | |||
1801 | @classmethod |
|
1801 | @classmethod | |
1802 | def get_by_full_path(cls, repo_full_path): |
|
1802 | def get_by_full_path(cls, repo_full_path): | |
1803 | repo_name = repo_full_path.split(cls.base_path(), 1)[-1] |
|
1803 | repo_name = repo_full_path.split(cls.base_path(), 1)[-1] | |
1804 | repo_name = cls.normalize_repo_name(repo_name) |
|
1804 | repo_name = cls.normalize_repo_name(repo_name) | |
1805 | return cls.get_by_repo_name(repo_name.strip(URL_SEP)) |
|
1805 | return cls.get_by_repo_name(repo_name.strip(URL_SEP)) | |
1806 |
|
1806 | |||
1807 | @classmethod |
|
1807 | @classmethod | |
1808 | def get_repo_forks(cls, repo_id): |
|
1808 | def get_repo_forks(cls, repo_id): | |
1809 | return cls.query().filter(Repository.fork_id == repo_id) |
|
1809 | return cls.query().filter(Repository.fork_id == repo_id) | |
1810 |
|
1810 | |||
1811 | @classmethod |
|
1811 | @classmethod | |
1812 | def base_path(cls): |
|
1812 | def base_path(cls): | |
1813 | """ |
|
1813 | """ | |
1814 | Returns base path when all repos are stored |
|
1814 | Returns base path when all repos are stored | |
1815 |
|
1815 | |||
1816 | :param cls: |
|
1816 | :param cls: | |
1817 | """ |
|
1817 | """ | |
1818 | q = Session().query(RhodeCodeUi)\ |
|
1818 | q = Session().query(RhodeCodeUi)\ | |
1819 | .filter(RhodeCodeUi.ui_key == cls.NAME_SEP) |
|
1819 | .filter(RhodeCodeUi.ui_key == cls.NAME_SEP) | |
1820 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) |
|
1820 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
1821 | return q.one().ui_value |
|
1821 | return q.one().ui_value | |
1822 |
|
1822 | |||
1823 | @classmethod |
|
1823 | @classmethod | |
1824 | def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None), |
|
1824 | def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None), | |
1825 | case_insensitive=True, archived=False): |
|
1825 | case_insensitive=True, archived=False): | |
1826 | q = Repository.query() |
|
1826 | q = Repository.query() | |
1827 |
|
1827 | |||
1828 | if not archived: |
|
1828 | if not archived: | |
1829 | q = q.filter(Repository.archived.isnot(true())) |
|
1829 | q = q.filter(Repository.archived.isnot(true())) | |
1830 |
|
1830 | |||
1831 | if not isinstance(user_id, Optional): |
|
1831 | if not isinstance(user_id, Optional): | |
1832 | q = q.filter(Repository.user_id == user_id) |
|
1832 | q = q.filter(Repository.user_id == user_id) | |
1833 |
|
1833 | |||
1834 | if not isinstance(group_id, Optional): |
|
1834 | if not isinstance(group_id, Optional): | |
1835 | q = q.filter(Repository.group_id == group_id) |
|
1835 | q = q.filter(Repository.group_id == group_id) | |
1836 |
|
1836 | |||
1837 | if case_insensitive: |
|
1837 | if case_insensitive: | |
1838 | q = q.order_by(func.lower(Repository.repo_name)) |
|
1838 | q = q.order_by(func.lower(Repository.repo_name)) | |
1839 | else: |
|
1839 | else: | |
1840 | q = q.order_by(Repository.repo_name) |
|
1840 | q = q.order_by(Repository.repo_name) | |
1841 |
|
1841 | |||
1842 | return q.all() |
|
1842 | return q.all() | |
1843 |
|
1843 | |||
1844 | @property |
|
1844 | @property | |
1845 | def repo_uid(self): |
|
1845 | def repo_uid(self): | |
1846 | return '_{}'.format(self.repo_id) |
|
1846 | return '_{}'.format(self.repo_id) | |
1847 |
|
1847 | |||
1848 | @property |
|
1848 | @property | |
1849 | def forks(self): |
|
1849 | def forks(self): | |
1850 | """ |
|
1850 | """ | |
1851 | Return forks of this repo |
|
1851 | Return forks of this repo | |
1852 | """ |
|
1852 | """ | |
1853 | return Repository.get_repo_forks(self.repo_id) |
|
1853 | return Repository.get_repo_forks(self.repo_id) | |
1854 |
|
1854 | |||
1855 | @property |
|
1855 | @property | |
1856 | def parent(self): |
|
1856 | def parent(self): | |
1857 | """ |
|
1857 | """ | |
1858 | Returns fork parent |
|
1858 | Returns fork parent | |
1859 | """ |
|
1859 | """ | |
1860 | return self.fork |
|
1860 | return self.fork | |
1861 |
|
1861 | |||
1862 | @property |
|
1862 | @property | |
1863 | def just_name(self): |
|
1863 | def just_name(self): | |
1864 | return self.repo_name.split(self.NAME_SEP)[-1] |
|
1864 | return self.repo_name.split(self.NAME_SEP)[-1] | |
1865 |
|
1865 | |||
1866 | @property |
|
1866 | @property | |
1867 | def groups_with_parents(self): |
|
1867 | def groups_with_parents(self): | |
1868 | groups = [] |
|
1868 | groups = [] | |
1869 | if self.group is None: |
|
1869 | if self.group is None: | |
1870 | return groups |
|
1870 | return groups | |
1871 |
|
1871 | |||
1872 | cur_gr = self.group |
|
1872 | cur_gr = self.group | |
1873 | groups.insert(0, cur_gr) |
|
1873 | groups.insert(0, cur_gr) | |
1874 | while 1: |
|
1874 | while 1: | |
1875 | gr = getattr(cur_gr, 'parent_group', None) |
|
1875 | gr = getattr(cur_gr, 'parent_group', None) | |
1876 | cur_gr = cur_gr.parent_group |
|
1876 | cur_gr = cur_gr.parent_group | |
1877 | if gr is None: |
|
1877 | if gr is None: | |
1878 | break |
|
1878 | break | |
1879 | groups.insert(0, gr) |
|
1879 | groups.insert(0, gr) | |
1880 |
|
1880 | |||
1881 | return groups |
|
1881 | return groups | |
1882 |
|
1882 | |||
1883 | @property |
|
1883 | @property | |
1884 | def groups_and_repo(self): |
|
1884 | def groups_and_repo(self): | |
1885 | return self.groups_with_parents, self |
|
1885 | return self.groups_with_parents, self | |
1886 |
|
1886 | |||
1887 | @LazyProperty |
|
1887 | @LazyProperty | |
1888 | def repo_path(self): |
|
1888 | def repo_path(self): | |
1889 | """ |
|
1889 | """ | |
1890 | Returns base full path for that repository means where it actually |
|
1890 | Returns base full path for that repository means where it actually | |
1891 | exists on a filesystem |
|
1891 | exists on a filesystem | |
1892 | """ |
|
1892 | """ | |
1893 | q = Session().query(RhodeCodeUi).filter( |
|
1893 | q = Session().query(RhodeCodeUi).filter( | |
1894 | RhodeCodeUi.ui_key == self.NAME_SEP) |
|
1894 | RhodeCodeUi.ui_key == self.NAME_SEP) | |
1895 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) |
|
1895 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
1896 | return q.one().ui_value |
|
1896 | return q.one().ui_value | |
1897 |
|
1897 | |||
1898 | @property |
|
1898 | @property | |
1899 | def repo_full_path(self): |
|
1899 | def repo_full_path(self): | |
1900 | p = [self.repo_path] |
|
1900 | p = [self.repo_path] | |
1901 | # we need to split the name by / since this is how we store the |
|
1901 | # we need to split the name by / since this is how we store the | |
1902 | # names in the database, but that eventually needs to be converted |
|
1902 | # names in the database, but that eventually needs to be converted | |
1903 | # into a valid system path |
|
1903 | # into a valid system path | |
1904 | p += self.repo_name.split(self.NAME_SEP) |
|
1904 | p += self.repo_name.split(self.NAME_SEP) | |
1905 | return os.path.join(*map(safe_unicode, p)) |
|
1905 | return os.path.join(*map(safe_unicode, p)) | |
1906 |
|
1906 | |||
1907 | @property |
|
1907 | @property | |
1908 | def cache_keys(self): |
|
1908 | def cache_keys(self): | |
1909 | """ |
|
1909 | """ | |
1910 | Returns associated cache keys for that repo |
|
1910 | Returns associated cache keys for that repo | |
1911 | """ |
|
1911 | """ | |
1912 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( |
|
1912 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( | |
1913 | repo_id=self.repo_id) |
|
1913 | repo_id=self.repo_id) | |
1914 | return CacheKey.query()\ |
|
1914 | return CacheKey.query()\ | |
1915 | .filter(CacheKey.cache_args == invalidation_namespace)\ |
|
1915 | .filter(CacheKey.cache_args == invalidation_namespace)\ | |
1916 | .order_by(CacheKey.cache_key)\ |
|
1916 | .order_by(CacheKey.cache_key)\ | |
1917 | .all() |
|
1917 | .all() | |
1918 |
|
1918 | |||
1919 | @property |
|
1919 | @property | |
1920 | def cached_diffs_relative_dir(self): |
|
1920 | def cached_diffs_relative_dir(self): | |
1921 | """ |
|
1921 | """ | |
1922 | Return a relative to the repository store path of cached diffs |
|
1922 | Return a relative to the repository store path of cached diffs | |
1923 | used for safe display for users, who shouldn't know the absolute store |
|
1923 | used for safe display for users, who shouldn't know the absolute store | |
1924 | path |
|
1924 | path | |
1925 | """ |
|
1925 | """ | |
1926 | return os.path.join( |
|
1926 | return os.path.join( | |
1927 | os.path.dirname(self.repo_name), |
|
1927 | os.path.dirname(self.repo_name), | |
1928 | self.cached_diffs_dir.split(os.path.sep)[-1]) |
|
1928 | self.cached_diffs_dir.split(os.path.sep)[-1]) | |
1929 |
|
1929 | |||
1930 | @property |
|
1930 | @property | |
1931 | def cached_diffs_dir(self): |
|
1931 | def cached_diffs_dir(self): | |
1932 | path = self.repo_full_path |
|
1932 | path = self.repo_full_path | |
1933 | return os.path.join( |
|
1933 | return os.path.join( | |
1934 | os.path.dirname(path), |
|
1934 | os.path.dirname(path), | |
1935 | '.__shadow_diff_cache_repo_{}'.format(self.repo_id)) |
|
1935 | '.__shadow_diff_cache_repo_{}'.format(self.repo_id)) | |
1936 |
|
1936 | |||
1937 | def cached_diffs(self): |
|
1937 | def cached_diffs(self): | |
1938 | diff_cache_dir = self.cached_diffs_dir |
|
1938 | diff_cache_dir = self.cached_diffs_dir | |
1939 | if os.path.isdir(diff_cache_dir): |
|
1939 | if os.path.isdir(diff_cache_dir): | |
1940 | return os.listdir(diff_cache_dir) |
|
1940 | return os.listdir(diff_cache_dir) | |
1941 | return [] |
|
1941 | return [] | |
1942 |
|
1942 | |||
1943 | def shadow_repos(self): |
|
1943 | def shadow_repos(self): | |
1944 | shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id) |
|
1944 | shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id) | |
1945 | return [ |
|
1945 | return [ | |
1946 | x for x in os.listdir(os.path.dirname(self.repo_full_path)) |
|
1946 | x for x in os.listdir(os.path.dirname(self.repo_full_path)) | |
1947 | if x.startswith(shadow_repos_pattern)] |
|
1947 | if x.startswith(shadow_repos_pattern)] | |
1948 |
|
1948 | |||
1949 | def get_new_name(self, repo_name): |
|
1949 | def get_new_name(self, repo_name): | |
1950 | """ |
|
1950 | """ | |
1951 | returns new full repository name based on assigned group and new new |
|
1951 | returns new full repository name based on assigned group and new new | |
1952 |
|
1952 | |||
1953 | :param group_name: |
|
1953 | :param group_name: | |
1954 | """ |
|
1954 | """ | |
1955 | path_prefix = self.group.full_path_splitted if self.group else [] |
|
1955 | path_prefix = self.group.full_path_splitted if self.group else [] | |
1956 | return self.NAME_SEP.join(path_prefix + [repo_name]) |
|
1956 | return self.NAME_SEP.join(path_prefix + [repo_name]) | |
1957 |
|
1957 | |||
1958 | @property |
|
1958 | @property | |
1959 | def _config(self): |
|
1959 | def _config(self): | |
1960 | """ |
|
1960 | """ | |
1961 | Returns db based config object. |
|
1961 | Returns db based config object. | |
1962 | """ |
|
1962 | """ | |
1963 | from rhodecode.lib.utils import make_db_config |
|
1963 | from rhodecode.lib.utils import make_db_config | |
1964 | return make_db_config(clear_session=False, repo=self) |
|
1964 | return make_db_config(clear_session=False, repo=self) | |
1965 |
|
1965 | |||
1966 | def permissions(self, with_admins=True, with_owner=True, |
|
1966 | def permissions(self, with_admins=True, with_owner=True, | |
1967 | expand_from_user_groups=False): |
|
1967 | expand_from_user_groups=False): | |
1968 | """ |
|
1968 | """ | |
1969 | Permissions for repositories |
|
1969 | Permissions for repositories | |
1970 | """ |
|
1970 | """ | |
1971 | _admin_perm = 'repository.admin' |
|
1971 | _admin_perm = 'repository.admin' | |
1972 |
|
1972 | |||
1973 | owner_row = [] |
|
1973 | owner_row = [] | |
1974 | if with_owner: |
|
1974 | if with_owner: | |
1975 | usr = AttributeDict(self.user.get_dict()) |
|
1975 | usr = AttributeDict(self.user.get_dict()) | |
1976 | usr.owner_row = True |
|
1976 | usr.owner_row = True | |
1977 | usr.permission = _admin_perm |
|
1977 | usr.permission = _admin_perm | |
1978 | usr.permission_id = None |
|
1978 | usr.permission_id = None | |
1979 | owner_row.append(usr) |
|
1979 | owner_row.append(usr) | |
1980 |
|
1980 | |||
1981 | super_admin_ids = [] |
|
1981 | super_admin_ids = [] | |
1982 | super_admin_rows = [] |
|
1982 | super_admin_rows = [] | |
1983 | if with_admins: |
|
1983 | if with_admins: | |
1984 | for usr in User.get_all_super_admins(): |
|
1984 | for usr in User.get_all_super_admins(): | |
1985 | super_admin_ids.append(usr.user_id) |
|
1985 | super_admin_ids.append(usr.user_id) | |
1986 | # if this admin is also owner, don't double the record |
|
1986 | # if this admin is also owner, don't double the record | |
1987 | if usr.user_id == owner_row[0].user_id: |
|
1987 | if usr.user_id == owner_row[0].user_id: | |
1988 | owner_row[0].admin_row = True |
|
1988 | owner_row[0].admin_row = True | |
1989 | else: |
|
1989 | else: | |
1990 | usr = AttributeDict(usr.get_dict()) |
|
1990 | usr = AttributeDict(usr.get_dict()) | |
1991 | usr.admin_row = True |
|
1991 | usr.admin_row = True | |
1992 | usr.permission = _admin_perm |
|
1992 | usr.permission = _admin_perm | |
1993 | usr.permission_id = None |
|
1993 | usr.permission_id = None | |
1994 | super_admin_rows.append(usr) |
|
1994 | super_admin_rows.append(usr) | |
1995 |
|
1995 | |||
1996 | q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self) |
|
1996 | q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self) | |
1997 | q = q.options(joinedload(UserRepoToPerm.repository), |
|
1997 | q = q.options(joinedload(UserRepoToPerm.repository), | |
1998 | joinedload(UserRepoToPerm.user), |
|
1998 | joinedload(UserRepoToPerm.user), | |
1999 | joinedload(UserRepoToPerm.permission),) |
|
1999 | joinedload(UserRepoToPerm.permission),) | |
2000 |
|
2000 | |||
2001 | # get owners and admins and permissions. We do a trick of re-writing |
|
2001 | # get owners and admins and permissions. We do a trick of re-writing | |
2002 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
2002 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
2003 | # has a global reference and changing one object propagates to all |
|
2003 | # has a global reference and changing one object propagates to all | |
2004 | # others. This means if admin is also an owner admin_row that change |
|
2004 | # others. This means if admin is also an owner admin_row that change | |
2005 | # would propagate to both objects |
|
2005 | # would propagate to both objects | |
2006 | perm_rows = [] |
|
2006 | perm_rows = [] | |
2007 | for _usr in q.all(): |
|
2007 | for _usr in q.all(): | |
2008 | usr = AttributeDict(_usr.user.get_dict()) |
|
2008 | usr = AttributeDict(_usr.user.get_dict()) | |
2009 | # if this user is also owner/admin, mark as duplicate record |
|
2009 | # if this user is also owner/admin, mark as duplicate record | |
2010 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
2010 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
2011 | usr.duplicate_perm = True |
|
2011 | usr.duplicate_perm = True | |
2012 | # also check if this permission is maybe used by branch_permissions |
|
2012 | # also check if this permission is maybe used by branch_permissions | |
2013 | if _usr.branch_perm_entry: |
|
2013 | if _usr.branch_perm_entry: | |
2014 | usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry] |
|
2014 | usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry] | |
2015 |
|
2015 | |||
2016 | usr.permission = _usr.permission.permission_name |
|
2016 | usr.permission = _usr.permission.permission_name | |
2017 | usr.permission_id = _usr.repo_to_perm_id |
|
2017 | usr.permission_id = _usr.repo_to_perm_id | |
2018 | perm_rows.append(usr) |
|
2018 | perm_rows.append(usr) | |
2019 |
|
2019 | |||
2020 | # filter the perm rows by 'default' first and then sort them by |
|
2020 | # filter the perm rows by 'default' first and then sort them by | |
2021 | # admin,write,read,none permissions sorted again alphabetically in |
|
2021 | # admin,write,read,none permissions sorted again alphabetically in | |
2022 | # each group |
|
2022 | # each group | |
2023 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
2023 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
2024 |
|
2024 | |||
2025 | user_groups_rows = [] |
|
2025 | user_groups_rows = [] | |
2026 | if expand_from_user_groups: |
|
2026 | if expand_from_user_groups: | |
2027 | for ug in self.permission_user_groups(with_members=True): |
|
2027 | for ug in self.permission_user_groups(with_members=True): | |
2028 | for user_data in ug.members: |
|
2028 | for user_data in ug.members: | |
2029 | user_groups_rows.append(user_data) |
|
2029 | user_groups_rows.append(user_data) | |
2030 |
|
2030 | |||
2031 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
2031 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
2032 |
|
2032 | |||
2033 | def permission_user_groups(self, with_members=True): |
|
2033 | def permission_user_groups(self, with_members=True): | |
2034 | q = UserGroupRepoToPerm.query()\ |
|
2034 | q = UserGroupRepoToPerm.query()\ | |
2035 | .filter(UserGroupRepoToPerm.repository == self) |
|
2035 | .filter(UserGroupRepoToPerm.repository == self) | |
2036 | q = q.options(joinedload(UserGroupRepoToPerm.repository), |
|
2036 | q = q.options(joinedload(UserGroupRepoToPerm.repository), | |
2037 | joinedload(UserGroupRepoToPerm.users_group), |
|
2037 | joinedload(UserGroupRepoToPerm.users_group), | |
2038 | joinedload(UserGroupRepoToPerm.permission),) |
|
2038 | joinedload(UserGroupRepoToPerm.permission),) | |
2039 |
|
2039 | |||
2040 | perm_rows = [] |
|
2040 | perm_rows = [] | |
2041 | for _user_group in q.all(): |
|
2041 | for _user_group in q.all(): | |
2042 | entry = AttributeDict(_user_group.users_group.get_dict()) |
|
2042 | entry = AttributeDict(_user_group.users_group.get_dict()) | |
2043 | entry.permission = _user_group.permission.permission_name |
|
2043 | entry.permission = _user_group.permission.permission_name | |
2044 | if with_members: |
|
2044 | if with_members: | |
2045 | entry.members = [x.user.get_dict() |
|
2045 | entry.members = [x.user.get_dict() | |
2046 | for x in _user_group.users_group.members] |
|
2046 | for x in _user_group.users_group.members] | |
2047 | perm_rows.append(entry) |
|
2047 | perm_rows.append(entry) | |
2048 |
|
2048 | |||
2049 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
2049 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
2050 | return perm_rows |
|
2050 | return perm_rows | |
2051 |
|
2051 | |||
2052 | def get_api_data(self, include_secrets=False): |
|
2052 | def get_api_data(self, include_secrets=False): | |
2053 | """ |
|
2053 | """ | |
2054 | Common function for generating repo api data |
|
2054 | Common function for generating repo api data | |
2055 |
|
2055 | |||
2056 | :param include_secrets: See :meth:`User.get_api_data`. |
|
2056 | :param include_secrets: See :meth:`User.get_api_data`. | |
2057 |
|
2057 | |||
2058 | """ |
|
2058 | """ | |
2059 | # TODO: mikhail: Here there is an anti-pattern, we probably need to |
|
2059 | # TODO: mikhail: Here there is an anti-pattern, we probably need to | |
2060 | # move this methods on models level. |
|
2060 | # move this methods on models level. | |
2061 | from rhodecode.model.settings import SettingsModel |
|
2061 | from rhodecode.model.settings import SettingsModel | |
2062 | from rhodecode.model.repo import RepoModel |
|
2062 | from rhodecode.model.repo import RepoModel | |
2063 |
|
2063 | |||
2064 | repo = self |
|
2064 | repo = self | |
2065 | _user_id, _time, _reason = self.locked |
|
2065 | _user_id, _time, _reason = self.locked | |
2066 |
|
2066 | |||
2067 | data = { |
|
2067 | data = { | |
2068 | 'repo_id': repo.repo_id, |
|
2068 | 'repo_id': repo.repo_id, | |
2069 | 'repo_name': repo.repo_name, |
|
2069 | 'repo_name': repo.repo_name, | |
2070 | 'repo_type': repo.repo_type, |
|
2070 | 'repo_type': repo.repo_type, | |
2071 | 'clone_uri': repo.clone_uri or '', |
|
2071 | 'clone_uri': repo.clone_uri or '', | |
2072 | 'push_uri': repo.push_uri or '', |
|
2072 | 'push_uri': repo.push_uri or '', | |
2073 | 'url': RepoModel().get_url(self), |
|
2073 | 'url': RepoModel().get_url(self), | |
2074 | 'private': repo.private, |
|
2074 | 'private': repo.private, | |
2075 | 'created_on': repo.created_on, |
|
2075 | 'created_on': repo.created_on, | |
2076 | 'description': repo.description_safe, |
|
2076 | 'description': repo.description_safe, | |
2077 | 'landing_rev': repo.landing_rev, |
|
2077 | 'landing_rev': repo.landing_rev, | |
2078 | 'owner': repo.user.username, |
|
2078 | 'owner': repo.user.username, | |
2079 | 'fork_of': repo.fork.repo_name if repo.fork else None, |
|
2079 | 'fork_of': repo.fork.repo_name if repo.fork else None, | |
2080 | 'fork_of_id': repo.fork.repo_id if repo.fork else None, |
|
2080 | 'fork_of_id': repo.fork.repo_id if repo.fork else None, | |
2081 | 'enable_statistics': repo.enable_statistics, |
|
2081 | 'enable_statistics': repo.enable_statistics, | |
2082 | 'enable_locking': repo.enable_locking, |
|
2082 | 'enable_locking': repo.enable_locking, | |
2083 | 'enable_downloads': repo.enable_downloads, |
|
2083 | 'enable_downloads': repo.enable_downloads, | |
2084 | 'last_changeset': repo.changeset_cache, |
|
2084 | 'last_changeset': repo.changeset_cache, | |
2085 | 'locked_by': User.get(_user_id).get_api_data( |
|
2085 | 'locked_by': User.get(_user_id).get_api_data( | |
2086 | include_secrets=include_secrets) if _user_id else None, |
|
2086 | include_secrets=include_secrets) if _user_id else None, | |
2087 | 'locked_date': time_to_datetime(_time) if _time else None, |
|
2087 | 'locked_date': time_to_datetime(_time) if _time else None, | |
2088 | 'lock_reason': _reason if _reason else None, |
|
2088 | 'lock_reason': _reason if _reason else None, | |
2089 | } |
|
2089 | } | |
2090 |
|
2090 | |||
2091 | # TODO: mikhail: should be per-repo settings here |
|
2091 | # TODO: mikhail: should be per-repo settings here | |
2092 | rc_config = SettingsModel().get_all_settings() |
|
2092 | rc_config = SettingsModel().get_all_settings() | |
2093 | repository_fields = str2bool( |
|
2093 | repository_fields = str2bool( | |
2094 | rc_config.get('rhodecode_repository_fields')) |
|
2094 | rc_config.get('rhodecode_repository_fields')) | |
2095 | if repository_fields: |
|
2095 | if repository_fields: | |
2096 | for f in self.extra_fields: |
|
2096 | for f in self.extra_fields: | |
2097 | data[f.field_key_prefixed] = f.field_value |
|
2097 | data[f.field_key_prefixed] = f.field_value | |
2098 |
|
2098 | |||
2099 | return data |
|
2099 | return data | |
2100 |
|
2100 | |||
2101 | @classmethod |
|
2101 | @classmethod | |
2102 | def lock(cls, repo, user_id, lock_time=None, lock_reason=None): |
|
2102 | def lock(cls, repo, user_id, lock_time=None, lock_reason=None): | |
2103 | if not lock_time: |
|
2103 | if not lock_time: | |
2104 | lock_time = time.time() |
|
2104 | lock_time = time.time() | |
2105 | if not lock_reason: |
|
2105 | if not lock_reason: | |
2106 | lock_reason = cls.LOCK_AUTOMATIC |
|
2106 | lock_reason = cls.LOCK_AUTOMATIC | |
2107 | repo.locked = [user_id, lock_time, lock_reason] |
|
2107 | repo.locked = [user_id, lock_time, lock_reason] | |
2108 | Session().add(repo) |
|
2108 | Session().add(repo) | |
2109 | Session().commit() |
|
2109 | Session().commit() | |
2110 |
|
2110 | |||
2111 | @classmethod |
|
2111 | @classmethod | |
2112 | def unlock(cls, repo): |
|
2112 | def unlock(cls, repo): | |
2113 | repo.locked = None |
|
2113 | repo.locked = None | |
2114 | Session().add(repo) |
|
2114 | Session().add(repo) | |
2115 | Session().commit() |
|
2115 | Session().commit() | |
2116 |
|
2116 | |||
2117 | @classmethod |
|
2117 | @classmethod | |
2118 | def getlock(cls, repo): |
|
2118 | def getlock(cls, repo): | |
2119 | return repo.locked |
|
2119 | return repo.locked | |
2120 |
|
2120 | |||
2121 | def is_user_lock(self, user_id): |
|
2121 | def is_user_lock(self, user_id): | |
2122 | if self.lock[0]: |
|
2122 | if self.lock[0]: | |
2123 | lock_user_id = safe_int(self.lock[0]) |
|
2123 | lock_user_id = safe_int(self.lock[0]) | |
2124 | user_id = safe_int(user_id) |
|
2124 | user_id = safe_int(user_id) | |
2125 | # both are ints, and they are equal |
|
2125 | # both are ints, and they are equal | |
2126 | return all([lock_user_id, user_id]) and lock_user_id == user_id |
|
2126 | return all([lock_user_id, user_id]) and lock_user_id == user_id | |
2127 |
|
2127 | |||
2128 | return False |
|
2128 | return False | |
2129 |
|
2129 | |||
2130 | def get_locking_state(self, action, user_id, only_when_enabled=True): |
|
2130 | def get_locking_state(self, action, user_id, only_when_enabled=True): | |
2131 | """ |
|
2131 | """ | |
2132 | Checks locking on this repository, if locking is enabled and lock is |
|
2132 | Checks locking on this repository, if locking is enabled and lock is | |
2133 | present returns a tuple of make_lock, locked, locked_by. |
|
2133 | present returns a tuple of make_lock, locked, locked_by. | |
2134 | make_lock can have 3 states None (do nothing) True, make lock |
|
2134 | make_lock can have 3 states None (do nothing) True, make lock | |
2135 | False release lock, This value is later propagated to hooks, which |
|
2135 | False release lock, This value is later propagated to hooks, which | |
2136 | do the locking. Think about this as signals passed to hooks what to do. |
|
2136 | do the locking. Think about this as signals passed to hooks what to do. | |
2137 |
|
2137 | |||
2138 | """ |
|
2138 | """ | |
2139 | # TODO: johbo: This is part of the business logic and should be moved |
|
2139 | # TODO: johbo: This is part of the business logic and should be moved | |
2140 | # into the RepositoryModel. |
|
2140 | # into the RepositoryModel. | |
2141 |
|
2141 | |||
2142 | if action not in ('push', 'pull'): |
|
2142 | if action not in ('push', 'pull'): | |
2143 | raise ValueError("Invalid action value: %s" % repr(action)) |
|
2143 | raise ValueError("Invalid action value: %s" % repr(action)) | |
2144 |
|
2144 | |||
2145 | # defines if locked error should be thrown to user |
|
2145 | # defines if locked error should be thrown to user | |
2146 | currently_locked = False |
|
2146 | currently_locked = False | |
2147 | # defines if new lock should be made, tri-state |
|
2147 | # defines if new lock should be made, tri-state | |
2148 | make_lock = None |
|
2148 | make_lock = None | |
2149 | repo = self |
|
2149 | repo = self | |
2150 | user = User.get(user_id) |
|
2150 | user = User.get(user_id) | |
2151 |
|
2151 | |||
2152 | lock_info = repo.locked |
|
2152 | lock_info = repo.locked | |
2153 |
|
2153 | |||
2154 | if repo and (repo.enable_locking or not only_when_enabled): |
|
2154 | if repo and (repo.enable_locking or not only_when_enabled): | |
2155 | if action == 'push': |
|
2155 | if action == 'push': | |
2156 | # check if it's already locked !, if it is compare users |
|
2156 | # check if it's already locked !, if it is compare users | |
2157 | locked_by_user_id = lock_info[0] |
|
2157 | locked_by_user_id = lock_info[0] | |
2158 | if user.user_id == locked_by_user_id: |
|
2158 | if user.user_id == locked_by_user_id: | |
2159 | log.debug( |
|
2159 | log.debug( | |
2160 | 'Got `push` action from user %s, now unlocking', user) |
|
2160 | 'Got `push` action from user %s, now unlocking', user) | |
2161 | # unlock if we have push from user who locked |
|
2161 | # unlock if we have push from user who locked | |
2162 | make_lock = False |
|
2162 | make_lock = False | |
2163 | else: |
|
2163 | else: | |
2164 | # we're not the same user who locked, ban with |
|
2164 | # we're not the same user who locked, ban with | |
2165 | # code defined in settings (default is 423 HTTP Locked) ! |
|
2165 | # code defined in settings (default is 423 HTTP Locked) ! | |
2166 | log.debug('Repo %s is currently locked by %s', repo, user) |
|
2166 | log.debug('Repo %s is currently locked by %s', repo, user) | |
2167 | currently_locked = True |
|
2167 | currently_locked = True | |
2168 | elif action == 'pull': |
|
2168 | elif action == 'pull': | |
2169 | # [0] user [1] date |
|
2169 | # [0] user [1] date | |
2170 | if lock_info[0] and lock_info[1]: |
|
2170 | if lock_info[0] and lock_info[1]: | |
2171 | log.debug('Repo %s is currently locked by %s', repo, user) |
|
2171 | log.debug('Repo %s is currently locked by %s', repo, user) | |
2172 | currently_locked = True |
|
2172 | currently_locked = True | |
2173 | else: |
|
2173 | else: | |
2174 | log.debug('Setting lock on repo %s by %s', repo, user) |
|
2174 | log.debug('Setting lock on repo %s by %s', repo, user) | |
2175 | make_lock = True |
|
2175 | make_lock = True | |
2176 |
|
2176 | |||
2177 | else: |
|
2177 | else: | |
2178 | log.debug('Repository %s do not have locking enabled', repo) |
|
2178 | log.debug('Repository %s do not have locking enabled', repo) | |
2179 |
|
2179 | |||
2180 | log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s', |
|
2180 | log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s', | |
2181 | make_lock, currently_locked, lock_info) |
|
2181 | make_lock, currently_locked, lock_info) | |
2182 |
|
2182 | |||
2183 | from rhodecode.lib.auth import HasRepoPermissionAny |
|
2183 | from rhodecode.lib.auth import HasRepoPermissionAny | |
2184 | perm_check = HasRepoPermissionAny('repository.write', 'repository.admin') |
|
2184 | perm_check = HasRepoPermissionAny('repository.write', 'repository.admin') | |
2185 | if make_lock and not perm_check(repo_name=repo.repo_name, user=user): |
|
2185 | if make_lock and not perm_check(repo_name=repo.repo_name, user=user): | |
2186 | # if we don't have at least write permission we cannot make a lock |
|
2186 | # if we don't have at least write permission we cannot make a lock | |
2187 | log.debug('lock state reset back to FALSE due to lack ' |
|
2187 | log.debug('lock state reset back to FALSE due to lack ' | |
2188 | 'of at least read permission') |
|
2188 | 'of at least read permission') | |
2189 | make_lock = False |
|
2189 | make_lock = False | |
2190 |
|
2190 | |||
2191 | return make_lock, currently_locked, lock_info |
|
2191 | return make_lock, currently_locked, lock_info | |
2192 |
|
2192 | |||
2193 | @property |
|
2193 | @property | |
2194 | def last_commit_cache_update_diff(self): |
|
2194 | def last_commit_cache_update_diff(self): | |
2195 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) |
|
2195 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) | |
2196 |
|
2196 | |||
2197 | @property |
|
2197 | @property | |
2198 | def last_commit_change(self): |
|
2198 | def last_commit_change(self): | |
2199 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
2199 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
2200 | empty_date = datetime.datetime.fromtimestamp(0) |
|
2200 | empty_date = datetime.datetime.fromtimestamp(0) | |
2201 | date_latest = self.changeset_cache.get('date', empty_date) |
|
2201 | date_latest = self.changeset_cache.get('date', empty_date) | |
2202 | try: |
|
2202 | try: | |
2203 | return parse_datetime(date_latest) |
|
2203 | return parse_datetime(date_latest) | |
2204 | except Exception: |
|
2204 | except Exception: | |
2205 | return empty_date |
|
2205 | return empty_date | |
2206 |
|
2206 | |||
2207 | @property |
|
2207 | @property | |
2208 | def last_db_change(self): |
|
2208 | def last_db_change(self): | |
2209 | return self.updated_on |
|
2209 | return self.updated_on | |
2210 |
|
2210 | |||
2211 | @property |
|
2211 | @property | |
2212 | def clone_uri_hidden(self): |
|
2212 | def clone_uri_hidden(self): | |
2213 | clone_uri = self.clone_uri |
|
2213 | clone_uri = self.clone_uri | |
2214 | if clone_uri: |
|
2214 | if clone_uri: | |
2215 | import urlobject |
|
2215 | import urlobject | |
2216 | url_obj = urlobject.URLObject(cleaned_uri(clone_uri)) |
|
2216 | url_obj = urlobject.URLObject(cleaned_uri(clone_uri)) | |
2217 | if url_obj.password: |
|
2217 | if url_obj.password: | |
2218 | clone_uri = url_obj.with_password('*****') |
|
2218 | clone_uri = url_obj.with_password('*****') | |
2219 | return clone_uri |
|
2219 | return clone_uri | |
2220 |
|
2220 | |||
2221 | @property |
|
2221 | @property | |
2222 | def push_uri_hidden(self): |
|
2222 | def push_uri_hidden(self): | |
2223 | push_uri = self.push_uri |
|
2223 | push_uri = self.push_uri | |
2224 | if push_uri: |
|
2224 | if push_uri: | |
2225 | import urlobject |
|
2225 | import urlobject | |
2226 | url_obj = urlobject.URLObject(cleaned_uri(push_uri)) |
|
2226 | url_obj = urlobject.URLObject(cleaned_uri(push_uri)) | |
2227 | if url_obj.password: |
|
2227 | if url_obj.password: | |
2228 | push_uri = url_obj.with_password('*****') |
|
2228 | push_uri = url_obj.with_password('*****') | |
2229 | return push_uri |
|
2229 | return push_uri | |
2230 |
|
2230 | |||
2231 | def clone_url(self, **override): |
|
2231 | def clone_url(self, **override): | |
2232 | from rhodecode.model.settings import SettingsModel |
|
2232 | from rhodecode.model.settings import SettingsModel | |
2233 |
|
2233 | |||
2234 | uri_tmpl = None |
|
2234 | uri_tmpl = None | |
2235 | if 'with_id' in override: |
|
2235 | if 'with_id' in override: | |
2236 | uri_tmpl = self.DEFAULT_CLONE_URI_ID |
|
2236 | uri_tmpl = self.DEFAULT_CLONE_URI_ID | |
2237 | del override['with_id'] |
|
2237 | del override['with_id'] | |
2238 |
|
2238 | |||
2239 | if 'uri_tmpl' in override: |
|
2239 | if 'uri_tmpl' in override: | |
2240 | uri_tmpl = override['uri_tmpl'] |
|
2240 | uri_tmpl = override['uri_tmpl'] | |
2241 | del override['uri_tmpl'] |
|
2241 | del override['uri_tmpl'] | |
2242 |
|
2242 | |||
2243 | ssh = False |
|
2243 | ssh = False | |
2244 | if 'ssh' in override: |
|
2244 | if 'ssh' in override: | |
2245 | ssh = True |
|
2245 | ssh = True | |
2246 | del override['ssh'] |
|
2246 | del override['ssh'] | |
2247 |
|
2247 | |||
2248 | # we didn't override our tmpl from **overrides |
|
2248 | # we didn't override our tmpl from **overrides | |
2249 | request = get_current_request() |
|
2249 | request = get_current_request() | |
2250 | if not uri_tmpl: |
|
2250 | if not uri_tmpl: | |
2251 | if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'): |
|
2251 | if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'): | |
2252 | rc_config = request.call_context.rc_config |
|
2252 | rc_config = request.call_context.rc_config | |
2253 | else: |
|
2253 | else: | |
2254 | rc_config = SettingsModel().get_all_settings(cache=True) |
|
2254 | rc_config = SettingsModel().get_all_settings(cache=True) | |
2255 | if ssh: |
|
2255 | if ssh: | |
2256 | uri_tmpl = rc_config.get( |
|
2256 | uri_tmpl = rc_config.get( | |
2257 | 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH |
|
2257 | 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH | |
2258 | else: |
|
2258 | else: | |
2259 | uri_tmpl = rc_config.get( |
|
2259 | uri_tmpl = rc_config.get( | |
2260 | 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI |
|
2260 | 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI | |
2261 |
|
2261 | |||
2262 | return get_clone_url(request=request, |
|
2262 | return get_clone_url(request=request, | |
2263 | uri_tmpl=uri_tmpl, |
|
2263 | uri_tmpl=uri_tmpl, | |
2264 | repo_name=self.repo_name, |
|
2264 | repo_name=self.repo_name, | |
2265 | repo_id=self.repo_id, **override) |
|
2265 | repo_id=self.repo_id, **override) | |
2266 |
|
2266 | |||
2267 | def set_state(self, state): |
|
2267 | def set_state(self, state): | |
2268 | self.repo_state = state |
|
2268 | self.repo_state = state | |
2269 | Session().add(self) |
|
2269 | Session().add(self) | |
2270 | #========================================================================== |
|
2270 | #========================================================================== | |
2271 | # SCM PROPERTIES |
|
2271 | # SCM PROPERTIES | |
2272 | #========================================================================== |
|
2272 | #========================================================================== | |
2273 |
|
2273 | |||
2274 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): |
|
2274 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
2275 | return get_commit_safe( |
|
2275 | return get_commit_safe( | |
2276 | self.scm_instance(), commit_id, commit_idx, pre_load=pre_load) |
|
2276 | self.scm_instance(), commit_id, commit_idx, pre_load=pre_load) | |
2277 |
|
2277 | |||
2278 | def get_changeset(self, rev=None, pre_load=None): |
|
2278 | def get_changeset(self, rev=None, pre_load=None): | |
2279 | warnings.warn("Use get_commit", DeprecationWarning) |
|
2279 | warnings.warn("Use get_commit", DeprecationWarning) | |
2280 | commit_id = None |
|
2280 | commit_id = None | |
2281 | commit_idx = None |
|
2281 | commit_idx = None | |
2282 | if isinstance(rev, compat.string_types): |
|
2282 | if isinstance(rev, compat.string_types): | |
2283 | commit_id = rev |
|
2283 | commit_id = rev | |
2284 | else: |
|
2284 | else: | |
2285 | commit_idx = rev |
|
2285 | commit_idx = rev | |
2286 | return self.get_commit(commit_id=commit_id, commit_idx=commit_idx, |
|
2286 | return self.get_commit(commit_id=commit_id, commit_idx=commit_idx, | |
2287 | pre_load=pre_load) |
|
2287 | pre_load=pre_load) | |
2288 |
|
2288 | |||
2289 | def get_landing_commit(self): |
|
2289 | def get_landing_commit(self): | |
2290 | """ |
|
2290 | """ | |
2291 | Returns landing commit, or if that doesn't exist returns the tip |
|
2291 | Returns landing commit, or if that doesn't exist returns the tip | |
2292 | """ |
|
2292 | """ | |
2293 | _rev_type, _rev = self.landing_rev |
|
2293 | _rev_type, _rev = self.landing_rev | |
2294 | commit = self.get_commit(_rev) |
|
2294 | commit = self.get_commit(_rev) | |
2295 | if isinstance(commit, EmptyCommit): |
|
2295 | if isinstance(commit, EmptyCommit): | |
2296 | return self.get_commit() |
|
2296 | return self.get_commit() | |
2297 | return commit |
|
2297 | return commit | |
2298 |
|
2298 | |||
2299 | def update_commit_cache(self, cs_cache=None, config=None): |
|
2299 | def update_commit_cache(self, cs_cache=None, config=None): | |
2300 | """ |
|
2300 | """ | |
2301 | Update cache of last commit for repository, keys should be:: |
|
2301 | Update cache of last commit for repository, keys should be:: | |
2302 |
|
2302 | |||
2303 | source_repo_id |
|
2303 | source_repo_id | |
2304 | short_id |
|
2304 | short_id | |
2305 | raw_id |
|
2305 | raw_id | |
2306 | revision |
|
2306 | revision | |
2307 | parents |
|
2307 | parents | |
2308 | message |
|
2308 | message | |
2309 | date |
|
2309 | date | |
2310 | author |
|
2310 | author | |
2311 | updated_on |
|
2311 | updated_on | |
2312 |
|
2312 | |||
2313 | """ |
|
2313 | """ | |
2314 | from rhodecode.lib.vcs.backends.base import BaseChangeset |
|
2314 | from rhodecode.lib.vcs.backends.base import BaseChangeset | |
2315 | if cs_cache is None: |
|
2315 | if cs_cache is None: | |
2316 | # use no-cache version here |
|
2316 | # use no-cache version here | |
2317 | scm_repo = self.scm_instance(cache=False, config=config) |
|
2317 | scm_repo = self.scm_instance(cache=False, config=config) | |
2318 |
|
2318 | |||
2319 | empty = scm_repo is None or scm_repo.is_empty() |
|
2319 | empty = scm_repo is None or scm_repo.is_empty() | |
2320 | if not empty: |
|
2320 | if not empty: | |
2321 | cs_cache = scm_repo.get_commit( |
|
2321 | cs_cache = scm_repo.get_commit( | |
2322 | pre_load=["author", "date", "message", "parents", "branch"]) |
|
2322 | pre_load=["author", "date", "message", "parents", "branch"]) | |
2323 | else: |
|
2323 | else: | |
2324 | cs_cache = EmptyCommit() |
|
2324 | cs_cache = EmptyCommit() | |
2325 |
|
2325 | |||
2326 | if isinstance(cs_cache, BaseChangeset): |
|
2326 | if isinstance(cs_cache, BaseChangeset): | |
2327 | cs_cache = cs_cache.__json__() |
|
2327 | cs_cache = cs_cache.__json__() | |
2328 |
|
2328 | |||
2329 | def is_outdated(new_cs_cache): |
|
2329 | def is_outdated(new_cs_cache): | |
2330 | if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or |
|
2330 | if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or | |
2331 | new_cs_cache['revision'] != self.changeset_cache['revision']): |
|
2331 | new_cs_cache['revision'] != self.changeset_cache['revision']): | |
2332 | return True |
|
2332 | return True | |
2333 | return False |
|
2333 | return False | |
2334 |
|
2334 | |||
2335 | # check if we have maybe already latest cached revision |
|
2335 | # check if we have maybe already latest cached revision | |
2336 | if is_outdated(cs_cache) or not self.changeset_cache: |
|
2336 | if is_outdated(cs_cache) or not self.changeset_cache: | |
2337 | _default = datetime.datetime.utcnow() |
|
2337 | _default = datetime.datetime.utcnow() | |
2338 | last_change = cs_cache.get('date') or _default |
|
2338 | last_change = cs_cache.get('date') or _default | |
2339 | # we check if last update is newer than the new value |
|
2339 | # we check if last update is newer than the new value | |
2340 | # if yes, we use the current timestamp instead. Imagine you get |
|
2340 | # if yes, we use the current timestamp instead. Imagine you get | |
2341 | # old commit pushed 1y ago, we'd set last update 1y to ago. |
|
2341 | # old commit pushed 1y ago, we'd set last update 1y to ago. | |
2342 | last_change_timestamp = datetime_to_time(last_change) |
|
2342 | last_change_timestamp = datetime_to_time(last_change) | |
2343 | current_timestamp = datetime_to_time(last_change) |
|
2343 | current_timestamp = datetime_to_time(last_change) | |
2344 | if last_change_timestamp > current_timestamp: |
|
2344 | if last_change_timestamp > current_timestamp: | |
2345 | cs_cache['date'] = _default |
|
2345 | cs_cache['date'] = _default | |
2346 |
|
2346 | |||
2347 | cs_cache['updated_on'] = time.time() |
|
2347 | cs_cache['updated_on'] = time.time() | |
2348 | self.changeset_cache = cs_cache |
|
2348 | self.changeset_cache = cs_cache | |
2349 | Session().add(self) |
|
2349 | Session().add(self) | |
2350 | Session().commit() |
|
2350 | Session().commit() | |
2351 |
|
2351 | |||
2352 | log.debug('updated repo %s with new commit cache %s', |
|
2352 | log.debug('updated repo %s with new commit cache %s', | |
2353 | self.repo_name, cs_cache) |
|
2353 | self.repo_name, cs_cache) | |
2354 | else: |
|
2354 | else: | |
2355 | cs_cache = self.changeset_cache |
|
2355 | cs_cache = self.changeset_cache | |
2356 | cs_cache['updated_on'] = time.time() |
|
2356 | cs_cache['updated_on'] = time.time() | |
2357 | self.changeset_cache = cs_cache |
|
2357 | self.changeset_cache = cs_cache | |
2358 | Session().add(self) |
|
2358 | Session().add(self) | |
2359 | Session().commit() |
|
2359 | Session().commit() | |
2360 |
|
2360 | |||
2361 | log.debug('Skipping update_commit_cache for repo:`%s` ' |
|
2361 | log.debug('Skipping update_commit_cache for repo:`%s` ' | |
2362 | 'commit already with latest changes', self.repo_name) |
|
2362 | 'commit already with latest changes', self.repo_name) | |
2363 |
|
2363 | |||
2364 | @property |
|
2364 | @property | |
2365 | def tip(self): |
|
2365 | def tip(self): | |
2366 | return self.get_commit('tip') |
|
2366 | return self.get_commit('tip') | |
2367 |
|
2367 | |||
2368 | @property |
|
2368 | @property | |
2369 | def author(self): |
|
2369 | def author(self): | |
2370 | return self.tip.author |
|
2370 | return self.tip.author | |
2371 |
|
2371 | |||
2372 | @property |
|
2372 | @property | |
2373 | def last_change(self): |
|
2373 | def last_change(self): | |
2374 | return self.scm_instance().last_change |
|
2374 | return self.scm_instance().last_change | |
2375 |
|
2375 | |||
2376 | def get_comments(self, revisions=None): |
|
2376 | def get_comments(self, revisions=None): | |
2377 | """ |
|
2377 | """ | |
2378 | Returns comments for this repository grouped by revisions |
|
2378 | Returns comments for this repository grouped by revisions | |
2379 |
|
2379 | |||
2380 | :param revisions: filter query by revisions only |
|
2380 | :param revisions: filter query by revisions only | |
2381 | """ |
|
2381 | """ | |
2382 | cmts = ChangesetComment.query()\ |
|
2382 | cmts = ChangesetComment.query()\ | |
2383 | .filter(ChangesetComment.repo == self) |
|
2383 | .filter(ChangesetComment.repo == self) | |
2384 | if revisions: |
|
2384 | if revisions: | |
2385 | cmts = cmts.filter(ChangesetComment.revision.in_(revisions)) |
|
2385 | cmts = cmts.filter(ChangesetComment.revision.in_(revisions)) | |
2386 | grouped = collections.defaultdict(list) |
|
2386 | grouped = collections.defaultdict(list) | |
2387 | for cmt in cmts.all(): |
|
2387 | for cmt in cmts.all(): | |
2388 | grouped[cmt.revision].append(cmt) |
|
2388 | grouped[cmt.revision].append(cmt) | |
2389 | return grouped |
|
2389 | return grouped | |
2390 |
|
2390 | |||
2391 | def statuses(self, revisions=None): |
|
2391 | def statuses(self, revisions=None): | |
2392 | """ |
|
2392 | """ | |
2393 | Returns statuses for this repository |
|
2393 | Returns statuses for this repository | |
2394 |
|
2394 | |||
2395 | :param revisions: list of revisions to get statuses for |
|
2395 | :param revisions: list of revisions to get statuses for | |
2396 | """ |
|
2396 | """ | |
2397 | statuses = ChangesetStatus.query()\ |
|
2397 | statuses = ChangesetStatus.query()\ | |
2398 | .filter(ChangesetStatus.repo == self)\ |
|
2398 | .filter(ChangesetStatus.repo == self)\ | |
2399 | .filter(ChangesetStatus.version == 0) |
|
2399 | .filter(ChangesetStatus.version == 0) | |
2400 |
|
2400 | |||
2401 | if revisions: |
|
2401 | if revisions: | |
2402 | # Try doing the filtering in chunks to avoid hitting limits |
|
2402 | # Try doing the filtering in chunks to avoid hitting limits | |
2403 | size = 500 |
|
2403 | size = 500 | |
2404 | status_results = [] |
|
2404 | status_results = [] | |
2405 | for chunk in xrange(0, len(revisions), size): |
|
2405 | for chunk in xrange(0, len(revisions), size): | |
2406 | status_results += statuses.filter( |
|
2406 | status_results += statuses.filter( | |
2407 | ChangesetStatus.revision.in_( |
|
2407 | ChangesetStatus.revision.in_( | |
2408 | revisions[chunk: chunk+size]) |
|
2408 | revisions[chunk: chunk+size]) | |
2409 | ).all() |
|
2409 | ).all() | |
2410 | else: |
|
2410 | else: | |
2411 | status_results = statuses.all() |
|
2411 | status_results = statuses.all() | |
2412 |
|
2412 | |||
2413 | grouped = {} |
|
2413 | grouped = {} | |
2414 |
|
2414 | |||
2415 | # maybe we have open new pullrequest without a status? |
|
2415 | # maybe we have open new pullrequest without a status? | |
2416 | stat = ChangesetStatus.STATUS_UNDER_REVIEW |
|
2416 | stat = ChangesetStatus.STATUS_UNDER_REVIEW | |
2417 | status_lbl = ChangesetStatus.get_status_lbl(stat) |
|
2417 | status_lbl = ChangesetStatus.get_status_lbl(stat) | |
2418 | for pr in PullRequest.query().filter(PullRequest.source_repo == self).all(): |
|
2418 | for pr in PullRequest.query().filter(PullRequest.source_repo == self).all(): | |
2419 | for rev in pr.revisions: |
|
2419 | for rev in pr.revisions: | |
2420 | pr_id = pr.pull_request_id |
|
2420 | pr_id = pr.pull_request_id | |
2421 | pr_repo = pr.target_repo.repo_name |
|
2421 | pr_repo = pr.target_repo.repo_name | |
2422 | grouped[rev] = [stat, status_lbl, pr_id, pr_repo] |
|
2422 | grouped[rev] = [stat, status_lbl, pr_id, pr_repo] | |
2423 |
|
2423 | |||
2424 | for stat in status_results: |
|
2424 | for stat in status_results: | |
2425 | pr_id = pr_repo = None |
|
2425 | pr_id = pr_repo = None | |
2426 | if stat.pull_request: |
|
2426 | if stat.pull_request: | |
2427 | pr_id = stat.pull_request.pull_request_id |
|
2427 | pr_id = stat.pull_request.pull_request_id | |
2428 | pr_repo = stat.pull_request.target_repo.repo_name |
|
2428 | pr_repo = stat.pull_request.target_repo.repo_name | |
2429 | grouped[stat.revision] = [str(stat.status), stat.status_lbl, |
|
2429 | grouped[stat.revision] = [str(stat.status), stat.status_lbl, | |
2430 | pr_id, pr_repo] |
|
2430 | pr_id, pr_repo] | |
2431 | return grouped |
|
2431 | return grouped | |
2432 |
|
2432 | |||
2433 | # ========================================================================== |
|
2433 | # ========================================================================== | |
2434 | # SCM CACHE INSTANCE |
|
2434 | # SCM CACHE INSTANCE | |
2435 | # ========================================================================== |
|
2435 | # ========================================================================== | |
2436 |
|
2436 | |||
2437 | def scm_instance(self, **kwargs): |
|
2437 | def scm_instance(self, **kwargs): | |
2438 | import rhodecode |
|
2438 | import rhodecode | |
2439 |
|
2439 | |||
2440 | # Passing a config will not hit the cache currently only used |
|
2440 | # Passing a config will not hit the cache currently only used | |
2441 | # for repo2dbmapper |
|
2441 | # for repo2dbmapper | |
2442 | config = kwargs.pop('config', None) |
|
2442 | config = kwargs.pop('config', None) | |
2443 | cache = kwargs.pop('cache', None) |
|
2443 | cache = kwargs.pop('cache', None) | |
2444 | vcs_full_cache = kwargs.pop('vcs_full_cache', None) |
|
2444 | vcs_full_cache = kwargs.pop('vcs_full_cache', None) | |
2445 | if vcs_full_cache is not None: |
|
2445 | if vcs_full_cache is not None: | |
2446 | # allows override global config |
|
2446 | # allows override global config | |
2447 | full_cache = vcs_full_cache |
|
2447 | full_cache = vcs_full_cache | |
2448 | else: |
|
2448 | else: | |
2449 | full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache')) |
|
2449 | full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache')) | |
2450 | # if cache is NOT defined use default global, else we have a full |
|
2450 | # if cache is NOT defined use default global, else we have a full | |
2451 | # control over cache behaviour |
|
2451 | # control over cache behaviour | |
2452 | if cache is None and full_cache and not config: |
|
2452 | if cache is None and full_cache and not config: | |
2453 | log.debug('Initializing pure cached instance for %s', self.repo_path) |
|
2453 | log.debug('Initializing pure cached instance for %s', self.repo_path) | |
2454 | return self._get_instance_cached() |
|
2454 | return self._get_instance_cached() | |
2455 |
|
2455 | |||
2456 | # cache here is sent to the "vcs server" |
|
2456 | # cache here is sent to the "vcs server" | |
2457 | return self._get_instance(cache=bool(cache), config=config) |
|
2457 | return self._get_instance(cache=bool(cache), config=config) | |
2458 |
|
2458 | |||
2459 | def _get_instance_cached(self): |
|
2459 | def _get_instance_cached(self): | |
2460 | from rhodecode.lib import rc_cache |
|
2460 | from rhodecode.lib import rc_cache | |
2461 |
|
2461 | |||
2462 | cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id) |
|
2462 | cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id) | |
2463 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( |
|
2463 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( | |
2464 | repo_id=self.repo_id) |
|
2464 | repo_id=self.repo_id) | |
2465 | region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid) |
|
2465 | region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid) | |
2466 |
|
2466 | |||
2467 | @region.conditional_cache_on_arguments(namespace=cache_namespace_uid) |
|
2467 | @region.conditional_cache_on_arguments(namespace=cache_namespace_uid) | |
2468 | def get_instance_cached(repo_id, context_id, _cache_state_uid): |
|
2468 | def get_instance_cached(repo_id, context_id, _cache_state_uid): | |
2469 | return self._get_instance(repo_state_uid=_cache_state_uid) |
|
2469 | return self._get_instance(repo_state_uid=_cache_state_uid) | |
2470 |
|
2470 | |||
2471 | # we must use thread scoped cache here, |
|
2471 | # we must use thread scoped cache here, | |
2472 | # because each thread of gevent needs it's own not shared connection and cache |
|
2472 | # because each thread of gevent needs it's own not shared connection and cache | |
2473 | # we also alter `args` so the cache key is individual for every green thread. |
|
2473 | # we also alter `args` so the cache key is individual for every green thread. | |
2474 | inv_context_manager = rc_cache.InvalidationContext( |
|
2474 | inv_context_manager = rc_cache.InvalidationContext( | |
2475 | uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace, |
|
2475 | uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace, | |
2476 | thread_scoped=True) |
|
2476 | thread_scoped=True) | |
2477 | with inv_context_manager as invalidation_context: |
|
2477 | with inv_context_manager as invalidation_context: | |
2478 | cache_state_uid = invalidation_context.cache_data['cache_state_uid'] |
|
2478 | cache_state_uid = invalidation_context.cache_data['cache_state_uid'] | |
2479 | args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid) |
|
2479 | args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid) | |
2480 |
|
2480 | |||
2481 | # re-compute and store cache if we get invalidate signal |
|
2481 | # re-compute and store cache if we get invalidate signal | |
2482 | if invalidation_context.should_invalidate(): |
|
2482 | if invalidation_context.should_invalidate(): | |
2483 | instance = get_instance_cached.refresh(*args) |
|
2483 | instance = get_instance_cached.refresh(*args) | |
2484 | else: |
|
2484 | else: | |
2485 | instance = get_instance_cached(*args) |
|
2485 | instance = get_instance_cached(*args) | |
2486 |
|
2486 | |||
2487 | log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time) |
|
2487 | log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time) | |
2488 | return instance |
|
2488 | return instance | |
2489 |
|
2489 | |||
2490 | def _get_instance(self, cache=True, config=None, repo_state_uid=None): |
|
2490 | def _get_instance(self, cache=True, config=None, repo_state_uid=None): | |
2491 | log.debug('Initializing %s instance `%s` with cache flag set to: %s', |
|
2491 | log.debug('Initializing %s instance `%s` with cache flag set to: %s', | |
2492 | self.repo_type, self.repo_path, cache) |
|
2492 | self.repo_type, self.repo_path, cache) | |
2493 | config = config or self._config |
|
2493 | config = config or self._config | |
2494 | custom_wire = { |
|
2494 | custom_wire = { | |
2495 | 'cache': cache, # controls the vcs.remote cache |
|
2495 | 'cache': cache, # controls the vcs.remote cache | |
2496 | 'repo_state_uid': repo_state_uid |
|
2496 | 'repo_state_uid': repo_state_uid | |
2497 | } |
|
2497 | } | |
2498 | repo = get_vcs_instance( |
|
2498 | repo = get_vcs_instance( | |
2499 | repo_path=safe_str(self.repo_full_path), |
|
2499 | repo_path=safe_str(self.repo_full_path), | |
2500 | config=config, |
|
2500 | config=config, | |
2501 | with_wire=custom_wire, |
|
2501 | with_wire=custom_wire, | |
2502 | create=False, |
|
2502 | create=False, | |
2503 | _vcs_alias=self.repo_type) |
|
2503 | _vcs_alias=self.repo_type) | |
2504 | if repo is not None: |
|
2504 | if repo is not None: | |
2505 | repo.count() # cache rebuild |
|
2505 | repo.count() # cache rebuild | |
2506 | return repo |
|
2506 | return repo | |
2507 |
|
2507 | |||
2508 | def get_shadow_repository_path(self, workspace_id): |
|
2508 | def get_shadow_repository_path(self, workspace_id): | |
2509 | from rhodecode.lib.vcs.backends.base import BaseRepository |
|
2509 | from rhodecode.lib.vcs.backends.base import BaseRepository | |
2510 | shadow_repo_path = BaseRepository._get_shadow_repository_path( |
|
2510 | shadow_repo_path = BaseRepository._get_shadow_repository_path( | |
2511 | self.repo_full_path, self.repo_id, workspace_id) |
|
2511 | self.repo_full_path, self.repo_id, workspace_id) | |
2512 | return shadow_repo_path |
|
2512 | return shadow_repo_path | |
2513 |
|
2513 | |||
2514 | def __json__(self): |
|
2514 | def __json__(self): | |
2515 | return {'landing_rev': self.landing_rev} |
|
2515 | return {'landing_rev': self.landing_rev} | |
2516 |
|
2516 | |||
2517 | def get_dict(self): |
|
2517 | def get_dict(self): | |
2518 |
|
2518 | |||
2519 | # Since we transformed `repo_name` to a hybrid property, we need to |
|
2519 | # Since we transformed `repo_name` to a hybrid property, we need to | |
2520 | # keep compatibility with the code which uses `repo_name` field. |
|
2520 | # keep compatibility with the code which uses `repo_name` field. | |
2521 |
|
2521 | |||
2522 | result = super(Repository, self).get_dict() |
|
2522 | result = super(Repository, self).get_dict() | |
2523 | result['repo_name'] = result.pop('_repo_name', None) |
|
2523 | result['repo_name'] = result.pop('_repo_name', None) | |
2524 | return result |
|
2524 | return result | |
2525 |
|
2525 | |||
2526 |
|
2526 | |||
2527 | class RepoGroup(Base, BaseModel): |
|
2527 | class RepoGroup(Base, BaseModel): | |
2528 | __tablename__ = 'groups' |
|
2528 | __tablename__ = 'groups' | |
2529 | __table_args__ = ( |
|
2529 | __table_args__ = ( | |
2530 | UniqueConstraint('group_name', 'group_parent_id'), |
|
2530 | UniqueConstraint('group_name', 'group_parent_id'), | |
2531 | base_table_args, |
|
2531 | base_table_args, | |
2532 | ) |
|
2532 | ) | |
2533 | __mapper_args__ = {'order_by': 'group_name'} |
|
2533 | __mapper_args__ = {'order_by': 'group_name'} | |
2534 |
|
2534 | |||
2535 | CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups |
|
2535 | CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups | |
2536 |
|
2536 | |||
2537 | group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
2537 | group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
2538 | _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None) |
|
2538 | _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None) | |
2539 | group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False) |
|
2539 | group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False) | |
2540 | group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) |
|
2540 | group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) | |
2541 | group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None) |
|
2541 | group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None) | |
2542 | enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False) |
|
2542 | enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False) | |
2543 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) |
|
2543 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
2544 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
2544 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
2545 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) |
|
2545 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
2546 | personal = Column('personal', Boolean(), nullable=True, unique=None, default=None) |
|
2546 | personal = Column('personal', Boolean(), nullable=True, unique=None, default=None) | |
2547 | _changeset_cache = Column( |
|
2547 | _changeset_cache = Column( | |
2548 | "changeset_cache", LargeBinary(), nullable=True) # JSON data |
|
2548 | "changeset_cache", LargeBinary(), nullable=True) # JSON data | |
2549 |
|
2549 | |||
2550 | repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id') |
|
2550 | repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id') | |
2551 | users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') |
|
2551 | users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') | |
2552 | parent_group = relationship('RepoGroup', remote_side=group_id) |
|
2552 | parent_group = relationship('RepoGroup', remote_side=group_id) | |
2553 | user = relationship('User') |
|
2553 | user = relationship('User') | |
2554 | integrations = relationship('Integration', cascade="all, delete, delete-orphan") |
|
2554 | integrations = relationship('Integration', cascade="all, delete, delete-orphan") | |
2555 |
|
2555 | |||
2556 | def __init__(self, group_name='', parent_group=None): |
|
2556 | def __init__(self, group_name='', parent_group=None): | |
2557 | self.group_name = group_name |
|
2557 | self.group_name = group_name | |
2558 | self.parent_group = parent_group |
|
2558 | self.parent_group = parent_group | |
2559 |
|
2559 | |||
2560 | def __unicode__(self): |
|
2560 | def __unicode__(self): | |
2561 | return u"<%s('id:%s:%s')>" % ( |
|
2561 | return u"<%s('id:%s:%s')>" % ( | |
2562 | self.__class__.__name__, self.group_id, self.group_name) |
|
2562 | self.__class__.__name__, self.group_id, self.group_name) | |
2563 |
|
2563 | |||
2564 | @hybrid_property |
|
2564 | @hybrid_property | |
2565 | def group_name(self): |
|
2565 | def group_name(self): | |
2566 | return self._group_name |
|
2566 | return self._group_name | |
2567 |
|
2567 | |||
2568 | @group_name.setter |
|
2568 | @group_name.setter | |
2569 | def group_name(self, value): |
|
2569 | def group_name(self, value): | |
2570 | self._group_name = value |
|
2570 | self._group_name = value | |
2571 | self.group_name_hash = self.hash_repo_group_name(value) |
|
2571 | self.group_name_hash = self.hash_repo_group_name(value) | |
2572 |
|
2572 | |||
2573 | @hybrid_property |
|
2573 | @hybrid_property | |
2574 | def changeset_cache(self): |
|
2574 | def changeset_cache(self): | |
2575 | from rhodecode.lib.vcs.backends.base import EmptyCommit |
|
2575 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
2576 | dummy = EmptyCommit().__json__() |
|
2576 | dummy = EmptyCommit().__json__() | |
2577 | if not self._changeset_cache: |
|
2577 | if not self._changeset_cache: | |
2578 | dummy['source_repo_id'] = '' |
|
2578 | dummy['source_repo_id'] = '' | |
2579 | return json.loads(json.dumps(dummy)) |
|
2579 | return json.loads(json.dumps(dummy)) | |
2580 |
|
2580 | |||
2581 | try: |
|
2581 | try: | |
2582 | return json.loads(self._changeset_cache) |
|
2582 | return json.loads(self._changeset_cache) | |
2583 | except TypeError: |
|
2583 | except TypeError: | |
2584 | return dummy |
|
2584 | return dummy | |
2585 | except Exception: |
|
2585 | except Exception: | |
2586 | log.error(traceback.format_exc()) |
|
2586 | log.error(traceback.format_exc()) | |
2587 | return dummy |
|
2587 | return dummy | |
2588 |
|
2588 | |||
2589 | @changeset_cache.setter |
|
2589 | @changeset_cache.setter | |
2590 | def changeset_cache(self, val): |
|
2590 | def changeset_cache(self, val): | |
2591 | try: |
|
2591 | try: | |
2592 | self._changeset_cache = json.dumps(val) |
|
2592 | self._changeset_cache = json.dumps(val) | |
2593 | except Exception: |
|
2593 | except Exception: | |
2594 | log.error(traceback.format_exc()) |
|
2594 | log.error(traceback.format_exc()) | |
2595 |
|
2595 | |||
2596 | @validates('group_parent_id') |
|
2596 | @validates('group_parent_id') | |
2597 | def validate_group_parent_id(self, key, val): |
|
2597 | def validate_group_parent_id(self, key, val): | |
2598 | """ |
|
2598 | """ | |
2599 | Check cycle references for a parent group to self |
|
2599 | Check cycle references for a parent group to self | |
2600 | """ |
|
2600 | """ | |
2601 | if self.group_id and val: |
|
2601 | if self.group_id and val: | |
2602 | assert val != self.group_id |
|
2602 | assert val != self.group_id | |
2603 |
|
2603 | |||
2604 | return val |
|
2604 | return val | |
2605 |
|
2605 | |||
2606 | @hybrid_property |
|
2606 | @hybrid_property | |
2607 | def description_safe(self): |
|
2607 | def description_safe(self): | |
2608 | from rhodecode.lib import helpers as h |
|
2608 | from rhodecode.lib import helpers as h | |
2609 | return h.escape(self.group_description) |
|
2609 | return h.escape(self.group_description) | |
2610 |
|
2610 | |||
2611 | @classmethod |
|
2611 | @classmethod | |
2612 | def hash_repo_group_name(cls, repo_group_name): |
|
2612 | def hash_repo_group_name(cls, repo_group_name): | |
2613 | val = remove_formatting(repo_group_name) |
|
2613 | val = remove_formatting(repo_group_name) | |
2614 | val = safe_str(val).lower() |
|
2614 | val = safe_str(val).lower() | |
2615 | chars = [] |
|
2615 | chars = [] | |
2616 | for c in val: |
|
2616 | for c in val: | |
2617 | if c not in string.ascii_letters: |
|
2617 | if c not in string.ascii_letters: | |
2618 | c = str(ord(c)) |
|
2618 | c = str(ord(c)) | |
2619 | chars.append(c) |
|
2619 | chars.append(c) | |
2620 |
|
2620 | |||
2621 | return ''.join(chars) |
|
2621 | return ''.join(chars) | |
2622 |
|
2622 | |||
2623 | @classmethod |
|
2623 | @classmethod | |
2624 | def _generate_choice(cls, repo_group): |
|
2624 | def _generate_choice(cls, repo_group): | |
2625 | from webhelpers.html import literal as _literal |
|
2625 | from webhelpers.html import literal as _literal | |
2626 | _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k)) |
|
2626 | _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k)) | |
2627 | return repo_group.group_id, _name(repo_group.full_path_splitted) |
|
2627 | return repo_group.group_id, _name(repo_group.full_path_splitted) | |
2628 |
|
2628 | |||
2629 | @classmethod |
|
2629 | @classmethod | |
2630 | def groups_choices(cls, groups=None, show_empty_group=True): |
|
2630 | def groups_choices(cls, groups=None, show_empty_group=True): | |
2631 | if not groups: |
|
2631 | if not groups: | |
2632 | groups = cls.query().all() |
|
2632 | groups = cls.query().all() | |
2633 |
|
2633 | |||
2634 | repo_groups = [] |
|
2634 | repo_groups = [] | |
2635 | if show_empty_group: |
|
2635 | if show_empty_group: | |
2636 | repo_groups = [(-1, u'-- %s --' % _('No parent'))] |
|
2636 | repo_groups = [(-1, u'-- %s --' % _('No parent'))] | |
2637 |
|
2637 | |||
2638 | repo_groups.extend([cls._generate_choice(x) for x in groups]) |
|
2638 | repo_groups.extend([cls._generate_choice(x) for x in groups]) | |
2639 |
|
2639 | |||
2640 | repo_groups = sorted( |
|
2640 | repo_groups = sorted( | |
2641 | repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0]) |
|
2641 | repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0]) | |
2642 | return repo_groups |
|
2642 | return repo_groups | |
2643 |
|
2643 | |||
2644 | @classmethod |
|
2644 | @classmethod | |
2645 | def url_sep(cls): |
|
2645 | def url_sep(cls): | |
2646 | return URL_SEP |
|
2646 | return URL_SEP | |
2647 |
|
2647 | |||
2648 | @classmethod |
|
2648 | @classmethod | |
2649 | def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): |
|
2649 | def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): | |
2650 | if case_insensitive: |
|
2650 | if case_insensitive: | |
2651 | gr = cls.query().filter(func.lower(cls.group_name) |
|
2651 | gr = cls.query().filter(func.lower(cls.group_name) | |
2652 | == func.lower(group_name)) |
|
2652 | == func.lower(group_name)) | |
2653 | else: |
|
2653 | else: | |
2654 | gr = cls.query().filter(cls.group_name == group_name) |
|
2654 | gr = cls.query().filter(cls.group_name == group_name) | |
2655 | if cache: |
|
2655 | if cache: | |
2656 | name_key = _hash_key(group_name) |
|
2656 | name_key = _hash_key(group_name) | |
2657 | gr = gr.options( |
|
2657 | gr = gr.options( | |
2658 | FromCache("sql_cache_short", "get_group_%s" % name_key)) |
|
2658 | FromCache("sql_cache_short", "get_group_%s" % name_key)) | |
2659 | return gr.scalar() |
|
2659 | return gr.scalar() | |
2660 |
|
2660 | |||
2661 | @classmethod |
|
2661 | @classmethod | |
2662 | def get_user_personal_repo_group(cls, user_id): |
|
2662 | def get_user_personal_repo_group(cls, user_id): | |
2663 | user = User.get(user_id) |
|
2663 | user = User.get(user_id) | |
2664 | if user.username == User.DEFAULT_USER: |
|
2664 | if user.username == User.DEFAULT_USER: | |
2665 | return None |
|
2665 | return None | |
2666 |
|
2666 | |||
2667 | return cls.query()\ |
|
2667 | return cls.query()\ | |
2668 | .filter(cls.personal == true()) \ |
|
2668 | .filter(cls.personal == true()) \ | |
2669 | .filter(cls.user == user) \ |
|
2669 | .filter(cls.user == user) \ | |
2670 | .order_by(cls.group_id.asc()) \ |
|
2670 | .order_by(cls.group_id.asc()) \ | |
2671 | .first() |
|
2671 | .first() | |
2672 |
|
2672 | |||
2673 | @classmethod |
|
2673 | @classmethod | |
2674 | def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None), |
|
2674 | def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None), | |
2675 | case_insensitive=True): |
|
2675 | case_insensitive=True): | |
2676 | q = RepoGroup.query() |
|
2676 | q = RepoGroup.query() | |
2677 |
|
2677 | |||
2678 | if not isinstance(user_id, Optional): |
|
2678 | if not isinstance(user_id, Optional): | |
2679 | q = q.filter(RepoGroup.user_id == user_id) |
|
2679 | q = q.filter(RepoGroup.user_id == user_id) | |
2680 |
|
2680 | |||
2681 | if not isinstance(group_id, Optional): |
|
2681 | if not isinstance(group_id, Optional): | |
2682 | q = q.filter(RepoGroup.group_parent_id == group_id) |
|
2682 | q = q.filter(RepoGroup.group_parent_id == group_id) | |
2683 |
|
2683 | |||
2684 | if case_insensitive: |
|
2684 | if case_insensitive: | |
2685 | q = q.order_by(func.lower(RepoGroup.group_name)) |
|
2685 | q = q.order_by(func.lower(RepoGroup.group_name)) | |
2686 | else: |
|
2686 | else: | |
2687 | q = q.order_by(RepoGroup.group_name) |
|
2687 | q = q.order_by(RepoGroup.group_name) | |
2688 | return q.all() |
|
2688 | return q.all() | |
2689 |
|
2689 | |||
2690 | @property |
|
2690 | @property | |
2691 | def parents(self, parents_recursion_limit = 10): |
|
2691 | def parents(self, parents_recursion_limit = 10): | |
2692 | groups = [] |
|
2692 | groups = [] | |
2693 | if self.parent_group is None: |
|
2693 | if self.parent_group is None: | |
2694 | return groups |
|
2694 | return groups | |
2695 | cur_gr = self.parent_group |
|
2695 | cur_gr = self.parent_group | |
2696 | groups.insert(0, cur_gr) |
|
2696 | groups.insert(0, cur_gr) | |
2697 | cnt = 0 |
|
2697 | cnt = 0 | |
2698 | while 1: |
|
2698 | while 1: | |
2699 | cnt += 1 |
|
2699 | cnt += 1 | |
2700 | gr = getattr(cur_gr, 'parent_group', None) |
|
2700 | gr = getattr(cur_gr, 'parent_group', None) | |
2701 | cur_gr = cur_gr.parent_group |
|
2701 | cur_gr = cur_gr.parent_group | |
2702 | if gr is None: |
|
2702 | if gr is None: | |
2703 | break |
|
2703 | break | |
2704 | if cnt == parents_recursion_limit: |
|
2704 | if cnt == parents_recursion_limit: | |
2705 | # this will prevent accidental infinit loops |
|
2705 | # this will prevent accidental infinit loops | |
2706 | log.error('more than %s parents found for group %s, stopping ' |
|
2706 | log.error('more than %s parents found for group %s, stopping ' | |
2707 | 'recursive parent fetching', parents_recursion_limit, self) |
|
2707 | 'recursive parent fetching', parents_recursion_limit, self) | |
2708 | break |
|
2708 | break | |
2709 |
|
2709 | |||
2710 | groups.insert(0, gr) |
|
2710 | groups.insert(0, gr) | |
2711 | return groups |
|
2711 | return groups | |
2712 |
|
2712 | |||
2713 | @property |
|
2713 | @property | |
2714 | def last_commit_cache_update_diff(self): |
|
2714 | def last_commit_cache_update_diff(self): | |
2715 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) |
|
2715 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) | |
2716 |
|
2716 | |||
2717 | @property |
|
2717 | @property | |
2718 | def last_commit_change(self): |
|
2718 | def last_commit_change(self): | |
2719 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
2719 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
2720 | empty_date = datetime.datetime.fromtimestamp(0) |
|
2720 | empty_date = datetime.datetime.fromtimestamp(0) | |
2721 | date_latest = self.changeset_cache.get('date', empty_date) |
|
2721 | date_latest = self.changeset_cache.get('date', empty_date) | |
2722 | try: |
|
2722 | try: | |
2723 | return parse_datetime(date_latest) |
|
2723 | return parse_datetime(date_latest) | |
2724 | except Exception: |
|
2724 | except Exception: | |
2725 | return empty_date |
|
2725 | return empty_date | |
2726 |
|
2726 | |||
2727 | @property |
|
2727 | @property | |
2728 | def last_db_change(self): |
|
2728 | def last_db_change(self): | |
2729 | return self.updated_on |
|
2729 | return self.updated_on | |
2730 |
|
2730 | |||
2731 | @property |
|
2731 | @property | |
2732 | def children(self): |
|
2732 | def children(self): | |
2733 | return RepoGroup.query().filter(RepoGroup.parent_group == self) |
|
2733 | return RepoGroup.query().filter(RepoGroup.parent_group == self) | |
2734 |
|
2734 | |||
2735 | @property |
|
2735 | @property | |
2736 | def name(self): |
|
2736 | def name(self): | |
2737 | return self.group_name.split(RepoGroup.url_sep())[-1] |
|
2737 | return self.group_name.split(RepoGroup.url_sep())[-1] | |
2738 |
|
2738 | |||
2739 | @property |
|
2739 | @property | |
2740 | def full_path(self): |
|
2740 | def full_path(self): | |
2741 | return self.group_name |
|
2741 | return self.group_name | |
2742 |
|
2742 | |||
2743 | @property |
|
2743 | @property | |
2744 | def full_path_splitted(self): |
|
2744 | def full_path_splitted(self): | |
2745 | return self.group_name.split(RepoGroup.url_sep()) |
|
2745 | return self.group_name.split(RepoGroup.url_sep()) | |
2746 |
|
2746 | |||
2747 | @property |
|
2747 | @property | |
2748 | def repositories(self): |
|
2748 | def repositories(self): | |
2749 | return Repository.query()\ |
|
2749 | return Repository.query()\ | |
2750 | .filter(Repository.group == self)\ |
|
2750 | .filter(Repository.group == self)\ | |
2751 | .order_by(Repository.repo_name) |
|
2751 | .order_by(Repository.repo_name) | |
2752 |
|
2752 | |||
2753 | @property |
|
2753 | @property | |
2754 | def repositories_recursive_count(self): |
|
2754 | def repositories_recursive_count(self): | |
2755 | cnt = self.repositories.count() |
|
2755 | cnt = self.repositories.count() | |
2756 |
|
2756 | |||
2757 | def children_count(group): |
|
2757 | def children_count(group): | |
2758 | cnt = 0 |
|
2758 | cnt = 0 | |
2759 | for child in group.children: |
|
2759 | for child in group.children: | |
2760 | cnt += child.repositories.count() |
|
2760 | cnt += child.repositories.count() | |
2761 | cnt += children_count(child) |
|
2761 | cnt += children_count(child) | |
2762 | return cnt |
|
2762 | return cnt | |
2763 |
|
2763 | |||
2764 | return cnt + children_count(self) |
|
2764 | return cnt + children_count(self) | |
2765 |
|
2765 | |||
2766 | def _recursive_objects(self, include_repos=True, include_groups=True): |
|
2766 | def _recursive_objects(self, include_repos=True, include_groups=True): | |
2767 | all_ = [] |
|
2767 | all_ = [] | |
2768 |
|
2768 | |||
2769 | def _get_members(root_gr): |
|
2769 | def _get_members(root_gr): | |
2770 | if include_repos: |
|
2770 | if include_repos: | |
2771 | for r in root_gr.repositories: |
|
2771 | for r in root_gr.repositories: | |
2772 | all_.append(r) |
|
2772 | all_.append(r) | |
2773 | childs = root_gr.children.all() |
|
2773 | childs = root_gr.children.all() | |
2774 | if childs: |
|
2774 | if childs: | |
2775 | for gr in childs: |
|
2775 | for gr in childs: | |
2776 | if include_groups: |
|
2776 | if include_groups: | |
2777 | all_.append(gr) |
|
2777 | all_.append(gr) | |
2778 | _get_members(gr) |
|
2778 | _get_members(gr) | |
2779 |
|
2779 | |||
2780 | root_group = [] |
|
2780 | root_group = [] | |
2781 | if include_groups: |
|
2781 | if include_groups: | |
2782 | root_group = [self] |
|
2782 | root_group = [self] | |
2783 |
|
2783 | |||
2784 | _get_members(self) |
|
2784 | _get_members(self) | |
2785 | return root_group + all_ |
|
2785 | return root_group + all_ | |
2786 |
|
2786 | |||
2787 | def recursive_groups_and_repos(self): |
|
2787 | def recursive_groups_and_repos(self): | |
2788 | """ |
|
2788 | """ | |
2789 | Recursive return all groups, with repositories in those groups |
|
2789 | Recursive return all groups, with repositories in those groups | |
2790 | """ |
|
2790 | """ | |
2791 | return self._recursive_objects() |
|
2791 | return self._recursive_objects() | |
2792 |
|
2792 | |||
2793 | def recursive_groups(self): |
|
2793 | def recursive_groups(self): | |
2794 | """ |
|
2794 | """ | |
2795 | Returns all children groups for this group including children of children |
|
2795 | Returns all children groups for this group including children of children | |
2796 | """ |
|
2796 | """ | |
2797 | return self._recursive_objects(include_repos=False) |
|
2797 | return self._recursive_objects(include_repos=False) | |
2798 |
|
2798 | |||
2799 | def recursive_repos(self): |
|
2799 | def recursive_repos(self): | |
2800 | """ |
|
2800 | """ | |
2801 | Returns all children repositories for this group |
|
2801 | Returns all children repositories for this group | |
2802 | """ |
|
2802 | """ | |
2803 | return self._recursive_objects(include_groups=False) |
|
2803 | return self._recursive_objects(include_groups=False) | |
2804 |
|
2804 | |||
2805 | def get_new_name(self, group_name): |
|
2805 | def get_new_name(self, group_name): | |
2806 | """ |
|
2806 | """ | |
2807 | returns new full group name based on parent and new name |
|
2807 | returns new full group name based on parent and new name | |
2808 |
|
2808 | |||
2809 | :param group_name: |
|
2809 | :param group_name: | |
2810 | """ |
|
2810 | """ | |
2811 | path_prefix = (self.parent_group.full_path_splitted if |
|
2811 | path_prefix = (self.parent_group.full_path_splitted if | |
2812 | self.parent_group else []) |
|
2812 | self.parent_group else []) | |
2813 | return RepoGroup.url_sep().join(path_prefix + [group_name]) |
|
2813 | return RepoGroup.url_sep().join(path_prefix + [group_name]) | |
2814 |
|
2814 | |||
2815 | def update_commit_cache(self, config=None): |
|
2815 | def update_commit_cache(self, config=None): | |
2816 | """ |
|
2816 | """ | |
2817 | Update cache of last changeset for newest repository inside this group, keys should be:: |
|
2817 | Update cache of last changeset for newest repository inside this group, keys should be:: | |
2818 |
|
2818 | |||
2819 | source_repo_id |
|
2819 | source_repo_id | |
2820 | short_id |
|
2820 | short_id | |
2821 | raw_id |
|
2821 | raw_id | |
2822 | revision |
|
2822 | revision | |
2823 | parents |
|
2823 | parents | |
2824 | message |
|
2824 | message | |
2825 | date |
|
2825 | date | |
2826 | author |
|
2826 | author | |
2827 |
|
2827 | |||
2828 | """ |
|
2828 | """ | |
2829 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
2829 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
2830 |
|
2830 | |||
2831 | def repo_groups_and_repos(): |
|
2831 | def repo_groups_and_repos(): | |
2832 | all_entries = OrderedDefaultDict(list) |
|
2832 | all_entries = OrderedDefaultDict(list) | |
2833 |
|
2833 | |||
2834 | def _get_members(root_gr, pos=0): |
|
2834 | def _get_members(root_gr, pos=0): | |
2835 |
|
2835 | |||
2836 | for repo in root_gr.repositories: |
|
2836 | for repo in root_gr.repositories: | |
2837 | all_entries[root_gr].append(repo) |
|
2837 | all_entries[root_gr].append(repo) | |
2838 |
|
2838 | |||
2839 | # fill in all parent positions |
|
2839 | # fill in all parent positions | |
2840 | for parent_group in root_gr.parents: |
|
2840 | for parent_group in root_gr.parents: | |
2841 | all_entries[parent_group].extend(all_entries[root_gr]) |
|
2841 | all_entries[parent_group].extend(all_entries[root_gr]) | |
2842 |
|
2842 | |||
2843 | children_groups = root_gr.children.all() |
|
2843 | children_groups = root_gr.children.all() | |
2844 | if children_groups: |
|
2844 | if children_groups: | |
2845 | for cnt, gr in enumerate(children_groups, 1): |
|
2845 | for cnt, gr in enumerate(children_groups, 1): | |
2846 | _get_members(gr, pos=pos+cnt) |
|
2846 | _get_members(gr, pos=pos+cnt) | |
2847 |
|
2847 | |||
2848 | _get_members(root_gr=self) |
|
2848 | _get_members(root_gr=self) | |
2849 | return all_entries |
|
2849 | return all_entries | |
2850 |
|
2850 | |||
2851 | empty_date = datetime.datetime.fromtimestamp(0) |
|
2851 | empty_date = datetime.datetime.fromtimestamp(0) | |
2852 | for repo_group, repos in repo_groups_and_repos().items(): |
|
2852 | for repo_group, repos in repo_groups_and_repos().items(): | |
2853 |
|
2853 | |||
2854 | latest_repo_cs_cache = {} |
|
2854 | latest_repo_cs_cache = {} | |
2855 | for repo in repos: |
|
2855 | for repo in repos: | |
2856 | repo_cs_cache = repo.changeset_cache |
|
2856 | repo_cs_cache = repo.changeset_cache | |
2857 | date_latest = latest_repo_cs_cache.get('date', empty_date) |
|
2857 | date_latest = latest_repo_cs_cache.get('date', empty_date) | |
2858 | date_current = repo_cs_cache.get('date', empty_date) |
|
2858 | date_current = repo_cs_cache.get('date', empty_date) | |
2859 | current_timestamp = datetime_to_time(parse_datetime(date_latest)) |
|
2859 | current_timestamp = datetime_to_time(parse_datetime(date_latest)) | |
2860 | if current_timestamp < datetime_to_time(parse_datetime(date_current)): |
|
2860 | if current_timestamp < datetime_to_time(parse_datetime(date_current)): | |
2861 | latest_repo_cs_cache = repo_cs_cache |
|
2861 | latest_repo_cs_cache = repo_cs_cache | |
2862 | latest_repo_cs_cache['source_repo_id'] = repo.repo_id |
|
2862 | latest_repo_cs_cache['source_repo_id'] = repo.repo_id | |
2863 |
|
2863 | |||
2864 | latest_repo_cs_cache['updated_on'] = time.time() |
|
2864 | latest_repo_cs_cache['updated_on'] = time.time() | |
2865 | repo_group.changeset_cache = latest_repo_cs_cache |
|
2865 | repo_group.changeset_cache = latest_repo_cs_cache | |
2866 | Session().add(repo_group) |
|
2866 | Session().add(repo_group) | |
2867 | Session().commit() |
|
2867 | Session().commit() | |
2868 |
|
2868 | |||
2869 | log.debug('updated repo group %s with new commit cache %s', |
|
2869 | log.debug('updated repo group %s with new commit cache %s', | |
2870 | repo_group.group_name, latest_repo_cs_cache) |
|
2870 | repo_group.group_name, latest_repo_cs_cache) | |
2871 |
|
2871 | |||
2872 | def permissions(self, with_admins=True, with_owner=True, |
|
2872 | def permissions(self, with_admins=True, with_owner=True, | |
2873 | expand_from_user_groups=False): |
|
2873 | expand_from_user_groups=False): | |
2874 | """ |
|
2874 | """ | |
2875 | Permissions for repository groups |
|
2875 | Permissions for repository groups | |
2876 | """ |
|
2876 | """ | |
2877 | _admin_perm = 'group.admin' |
|
2877 | _admin_perm = 'group.admin' | |
2878 |
|
2878 | |||
2879 | owner_row = [] |
|
2879 | owner_row = [] | |
2880 | if with_owner: |
|
2880 | if with_owner: | |
2881 | usr = AttributeDict(self.user.get_dict()) |
|
2881 | usr = AttributeDict(self.user.get_dict()) | |
2882 | usr.owner_row = True |
|
2882 | usr.owner_row = True | |
2883 | usr.permission = _admin_perm |
|
2883 | usr.permission = _admin_perm | |
2884 | owner_row.append(usr) |
|
2884 | owner_row.append(usr) | |
2885 |
|
2885 | |||
2886 | super_admin_ids = [] |
|
2886 | super_admin_ids = [] | |
2887 | super_admin_rows = [] |
|
2887 | super_admin_rows = [] | |
2888 | if with_admins: |
|
2888 | if with_admins: | |
2889 | for usr in User.get_all_super_admins(): |
|
2889 | for usr in User.get_all_super_admins(): | |
2890 | super_admin_ids.append(usr.user_id) |
|
2890 | super_admin_ids.append(usr.user_id) | |
2891 | # if this admin is also owner, don't double the record |
|
2891 | # if this admin is also owner, don't double the record | |
2892 | if usr.user_id == owner_row[0].user_id: |
|
2892 | if usr.user_id == owner_row[0].user_id: | |
2893 | owner_row[0].admin_row = True |
|
2893 | owner_row[0].admin_row = True | |
2894 | else: |
|
2894 | else: | |
2895 | usr = AttributeDict(usr.get_dict()) |
|
2895 | usr = AttributeDict(usr.get_dict()) | |
2896 | usr.admin_row = True |
|
2896 | usr.admin_row = True | |
2897 | usr.permission = _admin_perm |
|
2897 | usr.permission = _admin_perm | |
2898 | super_admin_rows.append(usr) |
|
2898 | super_admin_rows.append(usr) | |
2899 |
|
2899 | |||
2900 | q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self) |
|
2900 | q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self) | |
2901 | q = q.options(joinedload(UserRepoGroupToPerm.group), |
|
2901 | q = q.options(joinedload(UserRepoGroupToPerm.group), | |
2902 | joinedload(UserRepoGroupToPerm.user), |
|
2902 | joinedload(UserRepoGroupToPerm.user), | |
2903 | joinedload(UserRepoGroupToPerm.permission),) |
|
2903 | joinedload(UserRepoGroupToPerm.permission),) | |
2904 |
|
2904 | |||
2905 | # get owners and admins and permissions. We do a trick of re-writing |
|
2905 | # get owners and admins and permissions. We do a trick of re-writing | |
2906 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
2906 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
2907 | # has a global reference and changing one object propagates to all |
|
2907 | # has a global reference and changing one object propagates to all | |
2908 | # others. This means if admin is also an owner admin_row that change |
|
2908 | # others. This means if admin is also an owner admin_row that change | |
2909 | # would propagate to both objects |
|
2909 | # would propagate to both objects | |
2910 | perm_rows = [] |
|
2910 | perm_rows = [] | |
2911 | for _usr in q.all(): |
|
2911 | for _usr in q.all(): | |
2912 | usr = AttributeDict(_usr.user.get_dict()) |
|
2912 | usr = AttributeDict(_usr.user.get_dict()) | |
2913 | # if this user is also owner/admin, mark as duplicate record |
|
2913 | # if this user is also owner/admin, mark as duplicate record | |
2914 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
2914 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
2915 | usr.duplicate_perm = True |
|
2915 | usr.duplicate_perm = True | |
2916 | usr.permission = _usr.permission.permission_name |
|
2916 | usr.permission = _usr.permission.permission_name | |
2917 | perm_rows.append(usr) |
|
2917 | perm_rows.append(usr) | |
2918 |
|
2918 | |||
2919 | # filter the perm rows by 'default' first and then sort them by |
|
2919 | # filter the perm rows by 'default' first and then sort them by | |
2920 | # admin,write,read,none permissions sorted again alphabetically in |
|
2920 | # admin,write,read,none permissions sorted again alphabetically in | |
2921 | # each group |
|
2921 | # each group | |
2922 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
2922 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
2923 |
|
2923 | |||
2924 | user_groups_rows = [] |
|
2924 | user_groups_rows = [] | |
2925 | if expand_from_user_groups: |
|
2925 | if expand_from_user_groups: | |
2926 | for ug in self.permission_user_groups(with_members=True): |
|
2926 | for ug in self.permission_user_groups(with_members=True): | |
2927 | for user_data in ug.members: |
|
2927 | for user_data in ug.members: | |
2928 | user_groups_rows.append(user_data) |
|
2928 | user_groups_rows.append(user_data) | |
2929 |
|
2929 | |||
2930 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
2930 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
2931 |
|
2931 | |||
2932 | def permission_user_groups(self, with_members=False): |
|
2932 | def permission_user_groups(self, with_members=False): | |
2933 | q = UserGroupRepoGroupToPerm.query()\ |
|
2933 | q = UserGroupRepoGroupToPerm.query()\ | |
2934 | .filter(UserGroupRepoGroupToPerm.group == self) |
|
2934 | .filter(UserGroupRepoGroupToPerm.group == self) | |
2935 | q = q.options(joinedload(UserGroupRepoGroupToPerm.group), |
|
2935 | q = q.options(joinedload(UserGroupRepoGroupToPerm.group), | |
2936 | joinedload(UserGroupRepoGroupToPerm.users_group), |
|
2936 | joinedload(UserGroupRepoGroupToPerm.users_group), | |
2937 | joinedload(UserGroupRepoGroupToPerm.permission),) |
|
2937 | joinedload(UserGroupRepoGroupToPerm.permission),) | |
2938 |
|
2938 | |||
2939 | perm_rows = [] |
|
2939 | perm_rows = [] | |
2940 | for _user_group in q.all(): |
|
2940 | for _user_group in q.all(): | |
2941 | entry = AttributeDict(_user_group.users_group.get_dict()) |
|
2941 | entry = AttributeDict(_user_group.users_group.get_dict()) | |
2942 | entry.permission = _user_group.permission.permission_name |
|
2942 | entry.permission = _user_group.permission.permission_name | |
2943 | if with_members: |
|
2943 | if with_members: | |
2944 | entry.members = [x.user.get_dict() |
|
2944 | entry.members = [x.user.get_dict() | |
2945 | for x in _user_group.users_group.members] |
|
2945 | for x in _user_group.users_group.members] | |
2946 | perm_rows.append(entry) |
|
2946 | perm_rows.append(entry) | |
2947 |
|
2947 | |||
2948 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
2948 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
2949 | return perm_rows |
|
2949 | return perm_rows | |
2950 |
|
2950 | |||
2951 | def get_api_data(self): |
|
2951 | def get_api_data(self): | |
2952 | """ |
|
2952 | """ | |
2953 | Common function for generating api data |
|
2953 | Common function for generating api data | |
2954 |
|
2954 | |||
2955 | """ |
|
2955 | """ | |
2956 | group = self |
|
2956 | group = self | |
2957 | data = { |
|
2957 | data = { | |
2958 | 'group_id': group.group_id, |
|
2958 | 'group_id': group.group_id, | |
2959 | 'group_name': group.group_name, |
|
2959 | 'group_name': group.group_name, | |
2960 | 'group_description': group.description_safe, |
|
2960 | 'group_description': group.description_safe, | |
2961 | 'parent_group': group.parent_group.group_name if group.parent_group else None, |
|
2961 | 'parent_group': group.parent_group.group_name if group.parent_group else None, | |
2962 | 'repositories': [x.repo_name for x in group.repositories], |
|
2962 | 'repositories': [x.repo_name for x in group.repositories], | |
2963 | 'owner': group.user.username, |
|
2963 | 'owner': group.user.username, | |
2964 | } |
|
2964 | } | |
2965 | return data |
|
2965 | return data | |
2966 |
|
2966 | |||
2967 | def get_dict(self): |
|
2967 | def get_dict(self): | |
2968 | # Since we transformed `group_name` to a hybrid property, we need to |
|
2968 | # Since we transformed `group_name` to a hybrid property, we need to | |
2969 | # keep compatibility with the code which uses `group_name` field. |
|
2969 | # keep compatibility with the code which uses `group_name` field. | |
2970 | result = super(RepoGroup, self).get_dict() |
|
2970 | result = super(RepoGroup, self).get_dict() | |
2971 | result['group_name'] = result.pop('_group_name', None) |
|
2971 | result['group_name'] = result.pop('_group_name', None) | |
2972 | return result |
|
2972 | return result | |
2973 |
|
2973 | |||
2974 |
|
2974 | |||
2975 | class Permission(Base, BaseModel): |
|
2975 | class Permission(Base, BaseModel): | |
2976 | __tablename__ = 'permissions' |
|
2976 | __tablename__ = 'permissions' | |
2977 | __table_args__ = ( |
|
2977 | __table_args__ = ( | |
2978 | Index('p_perm_name_idx', 'permission_name'), |
|
2978 | Index('p_perm_name_idx', 'permission_name'), | |
2979 | base_table_args, |
|
2979 | base_table_args, | |
2980 | ) |
|
2980 | ) | |
2981 |
|
2981 | |||
2982 | PERMS = [ |
|
2982 | PERMS = [ | |
2983 | ('hg.admin', _('RhodeCode Super Administrator')), |
|
2983 | ('hg.admin', _('RhodeCode Super Administrator')), | |
2984 |
|
2984 | |||
2985 | ('repository.none', _('Repository no access')), |
|
2985 | ('repository.none', _('Repository no access')), | |
2986 | ('repository.read', _('Repository read access')), |
|
2986 | ('repository.read', _('Repository read access')), | |
2987 | ('repository.write', _('Repository write access')), |
|
2987 | ('repository.write', _('Repository write access')), | |
2988 | ('repository.admin', _('Repository admin access')), |
|
2988 | ('repository.admin', _('Repository admin access')), | |
2989 |
|
2989 | |||
2990 | ('group.none', _('Repository group no access')), |
|
2990 | ('group.none', _('Repository group no access')), | |
2991 | ('group.read', _('Repository group read access')), |
|
2991 | ('group.read', _('Repository group read access')), | |
2992 | ('group.write', _('Repository group write access')), |
|
2992 | ('group.write', _('Repository group write access')), | |
2993 | ('group.admin', _('Repository group admin access')), |
|
2993 | ('group.admin', _('Repository group admin access')), | |
2994 |
|
2994 | |||
2995 | ('usergroup.none', _('User group no access')), |
|
2995 | ('usergroup.none', _('User group no access')), | |
2996 | ('usergroup.read', _('User group read access')), |
|
2996 | ('usergroup.read', _('User group read access')), | |
2997 | ('usergroup.write', _('User group write access')), |
|
2997 | ('usergroup.write', _('User group write access')), | |
2998 | ('usergroup.admin', _('User group admin access')), |
|
2998 | ('usergroup.admin', _('User group admin access')), | |
2999 |
|
2999 | |||
3000 | ('branch.none', _('Branch no permissions')), |
|
3000 | ('branch.none', _('Branch no permissions')), | |
3001 | ('branch.merge', _('Branch access by web merge')), |
|
3001 | ('branch.merge', _('Branch access by web merge')), | |
3002 | ('branch.push', _('Branch access by push')), |
|
3002 | ('branch.push', _('Branch access by push')), | |
3003 | ('branch.push_force', _('Branch access by push with force')), |
|
3003 | ('branch.push_force', _('Branch access by push with force')), | |
3004 |
|
3004 | |||
3005 | ('hg.repogroup.create.false', _('Repository Group creation disabled')), |
|
3005 | ('hg.repogroup.create.false', _('Repository Group creation disabled')), | |
3006 | ('hg.repogroup.create.true', _('Repository Group creation enabled')), |
|
3006 | ('hg.repogroup.create.true', _('Repository Group creation enabled')), | |
3007 |
|
3007 | |||
3008 | ('hg.usergroup.create.false', _('User Group creation disabled')), |
|
3008 | ('hg.usergroup.create.false', _('User Group creation disabled')), | |
3009 | ('hg.usergroup.create.true', _('User Group creation enabled')), |
|
3009 | ('hg.usergroup.create.true', _('User Group creation enabled')), | |
3010 |
|
3010 | |||
3011 | ('hg.create.none', _('Repository creation disabled')), |
|
3011 | ('hg.create.none', _('Repository creation disabled')), | |
3012 | ('hg.create.repository', _('Repository creation enabled')), |
|
3012 | ('hg.create.repository', _('Repository creation enabled')), | |
3013 | ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')), |
|
3013 | ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')), | |
3014 | ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')), |
|
3014 | ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')), | |
3015 |
|
3015 | |||
3016 | ('hg.fork.none', _('Repository forking disabled')), |
|
3016 | ('hg.fork.none', _('Repository forking disabled')), | |
3017 | ('hg.fork.repository', _('Repository forking enabled')), |
|
3017 | ('hg.fork.repository', _('Repository forking enabled')), | |
3018 |
|
3018 | |||
3019 | ('hg.register.none', _('Registration disabled')), |
|
3019 | ('hg.register.none', _('Registration disabled')), | |
3020 | ('hg.register.manual_activate', _('User Registration with manual account activation')), |
|
3020 | ('hg.register.manual_activate', _('User Registration with manual account activation')), | |
3021 | ('hg.register.auto_activate', _('User Registration with automatic account activation')), |
|
3021 | ('hg.register.auto_activate', _('User Registration with automatic account activation')), | |
3022 |
|
3022 | |||
3023 | ('hg.password_reset.enabled', _('Password reset enabled')), |
|
3023 | ('hg.password_reset.enabled', _('Password reset enabled')), | |
3024 | ('hg.password_reset.hidden', _('Password reset hidden')), |
|
3024 | ('hg.password_reset.hidden', _('Password reset hidden')), | |
3025 | ('hg.password_reset.disabled', _('Password reset disabled')), |
|
3025 | ('hg.password_reset.disabled', _('Password reset disabled')), | |
3026 |
|
3026 | |||
3027 | ('hg.extern_activate.manual', _('Manual activation of external account')), |
|
3027 | ('hg.extern_activate.manual', _('Manual activation of external account')), | |
3028 | ('hg.extern_activate.auto', _('Automatic activation of external account')), |
|
3028 | ('hg.extern_activate.auto', _('Automatic activation of external account')), | |
3029 |
|
3029 | |||
3030 | ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')), |
|
3030 | ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')), | |
3031 | ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')), |
|
3031 | ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')), | |
3032 | ] |
|
3032 | ] | |
3033 |
|
3033 | |||
3034 | # definition of system default permissions for DEFAULT user, created on |
|
3034 | # definition of system default permissions for DEFAULT user, created on | |
3035 | # system setup |
|
3035 | # system setup | |
3036 | DEFAULT_USER_PERMISSIONS = [ |
|
3036 | DEFAULT_USER_PERMISSIONS = [ | |
3037 | # object perms |
|
3037 | # object perms | |
3038 | 'repository.read', |
|
3038 | 'repository.read', | |
3039 | 'group.read', |
|
3039 | 'group.read', | |
3040 | 'usergroup.read', |
|
3040 | 'usergroup.read', | |
3041 | # branch, for backward compat we need same value as before so forced pushed |
|
3041 | # branch, for backward compat we need same value as before so forced pushed | |
3042 | 'branch.push_force', |
|
3042 | 'branch.push_force', | |
3043 | # global |
|
3043 | # global | |
3044 | 'hg.create.repository', |
|
3044 | 'hg.create.repository', | |
3045 | 'hg.repogroup.create.false', |
|
3045 | 'hg.repogroup.create.false', | |
3046 | 'hg.usergroup.create.false', |
|
3046 | 'hg.usergroup.create.false', | |
3047 | 'hg.create.write_on_repogroup.true', |
|
3047 | 'hg.create.write_on_repogroup.true', | |
3048 | 'hg.fork.repository', |
|
3048 | 'hg.fork.repository', | |
3049 | 'hg.register.manual_activate', |
|
3049 | 'hg.register.manual_activate', | |
3050 | 'hg.password_reset.enabled', |
|
3050 | 'hg.password_reset.enabled', | |
3051 | 'hg.extern_activate.auto', |
|
3051 | 'hg.extern_activate.auto', | |
3052 | 'hg.inherit_default_perms.true', |
|
3052 | 'hg.inherit_default_perms.true', | |
3053 | ] |
|
3053 | ] | |
3054 |
|
3054 | |||
3055 | # defines which permissions are more important higher the more important |
|
3055 | # defines which permissions are more important higher the more important | |
3056 | # Weight defines which permissions are more important. |
|
3056 | # Weight defines which permissions are more important. | |
3057 | # The higher number the more important. |
|
3057 | # The higher number the more important. | |
3058 | PERM_WEIGHTS = { |
|
3058 | PERM_WEIGHTS = { | |
3059 | 'repository.none': 0, |
|
3059 | 'repository.none': 0, | |
3060 | 'repository.read': 1, |
|
3060 | 'repository.read': 1, | |
3061 | 'repository.write': 3, |
|
3061 | 'repository.write': 3, | |
3062 | 'repository.admin': 4, |
|
3062 | 'repository.admin': 4, | |
3063 |
|
3063 | |||
3064 | 'group.none': 0, |
|
3064 | 'group.none': 0, | |
3065 | 'group.read': 1, |
|
3065 | 'group.read': 1, | |
3066 | 'group.write': 3, |
|
3066 | 'group.write': 3, | |
3067 | 'group.admin': 4, |
|
3067 | 'group.admin': 4, | |
3068 |
|
3068 | |||
3069 | 'usergroup.none': 0, |
|
3069 | 'usergroup.none': 0, | |
3070 | 'usergroup.read': 1, |
|
3070 | 'usergroup.read': 1, | |
3071 | 'usergroup.write': 3, |
|
3071 | 'usergroup.write': 3, | |
3072 | 'usergroup.admin': 4, |
|
3072 | 'usergroup.admin': 4, | |
3073 |
|
3073 | |||
3074 | 'branch.none': 0, |
|
3074 | 'branch.none': 0, | |
3075 | 'branch.merge': 1, |
|
3075 | 'branch.merge': 1, | |
3076 | 'branch.push': 3, |
|
3076 | 'branch.push': 3, | |
3077 | 'branch.push_force': 4, |
|
3077 | 'branch.push_force': 4, | |
3078 |
|
3078 | |||
3079 | 'hg.repogroup.create.false': 0, |
|
3079 | 'hg.repogroup.create.false': 0, | |
3080 | 'hg.repogroup.create.true': 1, |
|
3080 | 'hg.repogroup.create.true': 1, | |
3081 |
|
3081 | |||
3082 | 'hg.usergroup.create.false': 0, |
|
3082 | 'hg.usergroup.create.false': 0, | |
3083 | 'hg.usergroup.create.true': 1, |
|
3083 | 'hg.usergroup.create.true': 1, | |
3084 |
|
3084 | |||
3085 | 'hg.fork.none': 0, |
|
3085 | 'hg.fork.none': 0, | |
3086 | 'hg.fork.repository': 1, |
|
3086 | 'hg.fork.repository': 1, | |
3087 | 'hg.create.none': 0, |
|
3087 | 'hg.create.none': 0, | |
3088 | 'hg.create.repository': 1 |
|
3088 | 'hg.create.repository': 1 | |
3089 | } |
|
3089 | } | |
3090 |
|
3090 | |||
3091 | permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3091 | permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3092 | permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None) |
|
3092 | permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None) | |
3093 | permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None) |
|
3093 | permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None) | |
3094 |
|
3094 | |||
3095 | def __unicode__(self): |
|
3095 | def __unicode__(self): | |
3096 | return u"<%s('%s:%s')>" % ( |
|
3096 | return u"<%s('%s:%s')>" % ( | |
3097 | self.__class__.__name__, self.permission_id, self.permission_name |
|
3097 | self.__class__.__name__, self.permission_id, self.permission_name | |
3098 | ) |
|
3098 | ) | |
3099 |
|
3099 | |||
3100 | @classmethod |
|
3100 | @classmethod | |
3101 | def get_by_key(cls, key): |
|
3101 | def get_by_key(cls, key): | |
3102 | return cls.query().filter(cls.permission_name == key).scalar() |
|
3102 | return cls.query().filter(cls.permission_name == key).scalar() | |
3103 |
|
3103 | |||
3104 | @classmethod |
|
3104 | @classmethod | |
3105 | def get_default_repo_perms(cls, user_id, repo_id=None): |
|
3105 | def get_default_repo_perms(cls, user_id, repo_id=None): | |
3106 | q = Session().query(UserRepoToPerm, Repository, Permission)\ |
|
3106 | q = Session().query(UserRepoToPerm, Repository, Permission)\ | |
3107 | .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\ |
|
3107 | .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\ | |
3108 | .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\ |
|
3108 | .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\ | |
3109 | .filter(UserRepoToPerm.user_id == user_id) |
|
3109 | .filter(UserRepoToPerm.user_id == user_id) | |
3110 | if repo_id: |
|
3110 | if repo_id: | |
3111 | q = q.filter(UserRepoToPerm.repository_id == repo_id) |
|
3111 | q = q.filter(UserRepoToPerm.repository_id == repo_id) | |
3112 | return q.all() |
|
3112 | return q.all() | |
3113 |
|
3113 | |||
3114 | @classmethod |
|
3114 | @classmethod | |
3115 | def get_default_repo_branch_perms(cls, user_id, repo_id=None): |
|
3115 | def get_default_repo_branch_perms(cls, user_id, repo_id=None): | |
3116 | q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \ |
|
3116 | q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \ | |
3117 | .join( |
|
3117 | .join( | |
3118 | Permission, |
|
3118 | Permission, | |
3119 | UserToRepoBranchPermission.permission_id == Permission.permission_id) \ |
|
3119 | UserToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
3120 | .join( |
|
3120 | .join( | |
3121 | UserRepoToPerm, |
|
3121 | UserRepoToPerm, | |
3122 | UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \ |
|
3122 | UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \ | |
3123 | .filter(UserRepoToPerm.user_id == user_id) |
|
3123 | .filter(UserRepoToPerm.user_id == user_id) | |
3124 |
|
3124 | |||
3125 | if repo_id: |
|
3125 | if repo_id: | |
3126 | q = q.filter(UserToRepoBranchPermission.repository_id == repo_id) |
|
3126 | q = q.filter(UserToRepoBranchPermission.repository_id == repo_id) | |
3127 | return q.order_by(UserToRepoBranchPermission.rule_order).all() |
|
3127 | return q.order_by(UserToRepoBranchPermission.rule_order).all() | |
3128 |
|
3128 | |||
3129 | @classmethod |
|
3129 | @classmethod | |
3130 | def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None): |
|
3130 | def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None): | |
3131 | q = Session().query(UserGroupRepoToPerm, Repository, Permission)\ |
|
3131 | q = Session().query(UserGroupRepoToPerm, Repository, Permission)\ | |
3132 | .join( |
|
3132 | .join( | |
3133 | Permission, |
|
3133 | Permission, | |
3134 | UserGroupRepoToPerm.permission_id == Permission.permission_id)\ |
|
3134 | UserGroupRepoToPerm.permission_id == Permission.permission_id)\ | |
3135 | .join( |
|
3135 | .join( | |
3136 | Repository, |
|
3136 | Repository, | |
3137 | UserGroupRepoToPerm.repository_id == Repository.repo_id)\ |
|
3137 | UserGroupRepoToPerm.repository_id == Repository.repo_id)\ | |
3138 | .join( |
|
3138 | .join( | |
3139 | UserGroup, |
|
3139 | UserGroup, | |
3140 | UserGroupRepoToPerm.users_group_id == |
|
3140 | UserGroupRepoToPerm.users_group_id == | |
3141 | UserGroup.users_group_id)\ |
|
3141 | UserGroup.users_group_id)\ | |
3142 | .join( |
|
3142 | .join( | |
3143 | UserGroupMember, |
|
3143 | UserGroupMember, | |
3144 | UserGroupRepoToPerm.users_group_id == |
|
3144 | UserGroupRepoToPerm.users_group_id == | |
3145 | UserGroupMember.users_group_id)\ |
|
3145 | UserGroupMember.users_group_id)\ | |
3146 | .filter( |
|
3146 | .filter( | |
3147 | UserGroupMember.user_id == user_id, |
|
3147 | UserGroupMember.user_id == user_id, | |
3148 | UserGroup.users_group_active == true()) |
|
3148 | UserGroup.users_group_active == true()) | |
3149 | if repo_id: |
|
3149 | if repo_id: | |
3150 | q = q.filter(UserGroupRepoToPerm.repository_id == repo_id) |
|
3150 | q = q.filter(UserGroupRepoToPerm.repository_id == repo_id) | |
3151 | return q.all() |
|
3151 | return q.all() | |
3152 |
|
3152 | |||
3153 | @classmethod |
|
3153 | @classmethod | |
3154 | def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None): |
|
3154 | def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None): | |
3155 | q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \ |
|
3155 | q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \ | |
3156 | .join( |
|
3156 | .join( | |
3157 | Permission, |
|
3157 | Permission, | |
3158 | UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \ |
|
3158 | UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
3159 | .join( |
|
3159 | .join( | |
3160 | UserGroupRepoToPerm, |
|
3160 | UserGroupRepoToPerm, | |
3161 | UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \ |
|
3161 | UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \ | |
3162 | .join( |
|
3162 | .join( | |
3163 | UserGroup, |
|
3163 | UserGroup, | |
3164 | UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \ |
|
3164 | UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \ | |
3165 | .join( |
|
3165 | .join( | |
3166 | UserGroupMember, |
|
3166 | UserGroupMember, | |
3167 | UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \ |
|
3167 | UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \ | |
3168 | .filter( |
|
3168 | .filter( | |
3169 | UserGroupMember.user_id == user_id, |
|
3169 | UserGroupMember.user_id == user_id, | |
3170 | UserGroup.users_group_active == true()) |
|
3170 | UserGroup.users_group_active == true()) | |
3171 |
|
3171 | |||
3172 | if repo_id: |
|
3172 | if repo_id: | |
3173 | q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id) |
|
3173 | q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id) | |
3174 | return q.order_by(UserGroupToRepoBranchPermission.rule_order).all() |
|
3174 | return q.order_by(UserGroupToRepoBranchPermission.rule_order).all() | |
3175 |
|
3175 | |||
3176 | @classmethod |
|
3176 | @classmethod | |
3177 | def get_default_group_perms(cls, user_id, repo_group_id=None): |
|
3177 | def get_default_group_perms(cls, user_id, repo_group_id=None): | |
3178 | q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\ |
|
3178 | q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\ | |
3179 | .join( |
|
3179 | .join( | |
3180 | Permission, |
|
3180 | Permission, | |
3181 | UserRepoGroupToPerm.permission_id == Permission.permission_id)\ |
|
3181 | UserRepoGroupToPerm.permission_id == Permission.permission_id)\ | |
3182 | .join( |
|
3182 | .join( | |
3183 | RepoGroup, |
|
3183 | RepoGroup, | |
3184 | UserRepoGroupToPerm.group_id == RepoGroup.group_id)\ |
|
3184 | UserRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
3185 | .filter(UserRepoGroupToPerm.user_id == user_id) |
|
3185 | .filter(UserRepoGroupToPerm.user_id == user_id) | |
3186 | if repo_group_id: |
|
3186 | if repo_group_id: | |
3187 | q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id) |
|
3187 | q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id) | |
3188 | return q.all() |
|
3188 | return q.all() | |
3189 |
|
3189 | |||
3190 | @classmethod |
|
3190 | @classmethod | |
3191 | def get_default_group_perms_from_user_group( |
|
3191 | def get_default_group_perms_from_user_group( | |
3192 | cls, user_id, repo_group_id=None): |
|
3192 | cls, user_id, repo_group_id=None): | |
3193 | q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\ |
|
3193 | q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\ | |
3194 | .join( |
|
3194 | .join( | |
3195 | Permission, |
|
3195 | Permission, | |
3196 | UserGroupRepoGroupToPerm.permission_id == |
|
3196 | UserGroupRepoGroupToPerm.permission_id == | |
3197 | Permission.permission_id)\ |
|
3197 | Permission.permission_id)\ | |
3198 | .join( |
|
3198 | .join( | |
3199 | RepoGroup, |
|
3199 | RepoGroup, | |
3200 | UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\ |
|
3200 | UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
3201 | .join( |
|
3201 | .join( | |
3202 | UserGroup, |
|
3202 | UserGroup, | |
3203 | UserGroupRepoGroupToPerm.users_group_id == |
|
3203 | UserGroupRepoGroupToPerm.users_group_id == | |
3204 | UserGroup.users_group_id)\ |
|
3204 | UserGroup.users_group_id)\ | |
3205 | .join( |
|
3205 | .join( | |
3206 | UserGroupMember, |
|
3206 | UserGroupMember, | |
3207 | UserGroupRepoGroupToPerm.users_group_id == |
|
3207 | UserGroupRepoGroupToPerm.users_group_id == | |
3208 | UserGroupMember.users_group_id)\ |
|
3208 | UserGroupMember.users_group_id)\ | |
3209 | .filter( |
|
3209 | .filter( | |
3210 | UserGroupMember.user_id == user_id, |
|
3210 | UserGroupMember.user_id == user_id, | |
3211 | UserGroup.users_group_active == true()) |
|
3211 | UserGroup.users_group_active == true()) | |
3212 | if repo_group_id: |
|
3212 | if repo_group_id: | |
3213 | q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id) |
|
3213 | q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id) | |
3214 | return q.all() |
|
3214 | return q.all() | |
3215 |
|
3215 | |||
3216 | @classmethod |
|
3216 | @classmethod | |
3217 | def get_default_user_group_perms(cls, user_id, user_group_id=None): |
|
3217 | def get_default_user_group_perms(cls, user_id, user_group_id=None): | |
3218 | q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\ |
|
3218 | q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\ | |
3219 | .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\ |
|
3219 | .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\ | |
3220 | .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\ |
|
3220 | .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\ | |
3221 | .filter(UserUserGroupToPerm.user_id == user_id) |
|
3221 | .filter(UserUserGroupToPerm.user_id == user_id) | |
3222 | if user_group_id: |
|
3222 | if user_group_id: | |
3223 | q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id) |
|
3223 | q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id) | |
3224 | return q.all() |
|
3224 | return q.all() | |
3225 |
|
3225 | |||
3226 | @classmethod |
|
3226 | @classmethod | |
3227 | def get_default_user_group_perms_from_user_group( |
|
3227 | def get_default_user_group_perms_from_user_group( | |
3228 | cls, user_id, user_group_id=None): |
|
3228 | cls, user_id, user_group_id=None): | |
3229 | TargetUserGroup = aliased(UserGroup, name='target_user_group') |
|
3229 | TargetUserGroup = aliased(UserGroup, name='target_user_group') | |
3230 | q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\ |
|
3230 | q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\ | |
3231 | .join( |
|
3231 | .join( | |
3232 | Permission, |
|
3232 | Permission, | |
3233 | UserGroupUserGroupToPerm.permission_id == |
|
3233 | UserGroupUserGroupToPerm.permission_id == | |
3234 | Permission.permission_id)\ |
|
3234 | Permission.permission_id)\ | |
3235 | .join( |
|
3235 | .join( | |
3236 | TargetUserGroup, |
|
3236 | TargetUserGroup, | |
3237 | UserGroupUserGroupToPerm.target_user_group_id == |
|
3237 | UserGroupUserGroupToPerm.target_user_group_id == | |
3238 | TargetUserGroup.users_group_id)\ |
|
3238 | TargetUserGroup.users_group_id)\ | |
3239 | .join( |
|
3239 | .join( | |
3240 | UserGroup, |
|
3240 | UserGroup, | |
3241 | UserGroupUserGroupToPerm.user_group_id == |
|
3241 | UserGroupUserGroupToPerm.user_group_id == | |
3242 | UserGroup.users_group_id)\ |
|
3242 | UserGroup.users_group_id)\ | |
3243 | .join( |
|
3243 | .join( | |
3244 | UserGroupMember, |
|
3244 | UserGroupMember, | |
3245 | UserGroupUserGroupToPerm.user_group_id == |
|
3245 | UserGroupUserGroupToPerm.user_group_id == | |
3246 | UserGroupMember.users_group_id)\ |
|
3246 | UserGroupMember.users_group_id)\ | |
3247 | .filter( |
|
3247 | .filter( | |
3248 | UserGroupMember.user_id == user_id, |
|
3248 | UserGroupMember.user_id == user_id, | |
3249 | UserGroup.users_group_active == true()) |
|
3249 | UserGroup.users_group_active == true()) | |
3250 | if user_group_id: |
|
3250 | if user_group_id: | |
3251 | q = q.filter( |
|
3251 | q = q.filter( | |
3252 | UserGroupUserGroupToPerm.user_group_id == user_group_id) |
|
3252 | UserGroupUserGroupToPerm.user_group_id == user_group_id) | |
3253 |
|
3253 | |||
3254 | return q.all() |
|
3254 | return q.all() | |
3255 |
|
3255 | |||
3256 |
|
3256 | |||
3257 | class UserRepoToPerm(Base, BaseModel): |
|
3257 | class UserRepoToPerm(Base, BaseModel): | |
3258 | __tablename__ = 'repo_to_perm' |
|
3258 | __tablename__ = 'repo_to_perm' | |
3259 | __table_args__ = ( |
|
3259 | __table_args__ = ( | |
3260 | UniqueConstraint('user_id', 'repository_id', 'permission_id'), |
|
3260 | UniqueConstraint('user_id', 'repository_id', 'permission_id'), | |
3261 | base_table_args |
|
3261 | base_table_args | |
3262 | ) |
|
3262 | ) | |
3263 |
|
3263 | |||
3264 | repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3264 | repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3265 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3265 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3266 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3266 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3267 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
3267 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
3268 |
|
3268 | |||
3269 | user = relationship('User') |
|
3269 | user = relationship('User') | |
3270 | repository = relationship('Repository') |
|
3270 | repository = relationship('Repository') | |
3271 | permission = relationship('Permission') |
|
3271 | permission = relationship('Permission') | |
3272 |
|
3272 | |||
3273 | branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete, delete-orphan", lazy='joined') |
|
3273 | branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete, delete-orphan", lazy='joined') | |
3274 |
|
3274 | |||
3275 | @classmethod |
|
3275 | @classmethod | |
3276 | def create(cls, user, repository, permission): |
|
3276 | def create(cls, user, repository, permission): | |
3277 | n = cls() |
|
3277 | n = cls() | |
3278 | n.user = user |
|
3278 | n.user = user | |
3279 | n.repository = repository |
|
3279 | n.repository = repository | |
3280 | n.permission = permission |
|
3280 | n.permission = permission | |
3281 | Session().add(n) |
|
3281 | Session().add(n) | |
3282 | return n |
|
3282 | return n | |
3283 |
|
3283 | |||
3284 | def __unicode__(self): |
|
3284 | def __unicode__(self): | |
3285 | return u'<%s => %s >' % (self.user, self.repository) |
|
3285 | return u'<%s => %s >' % (self.user, self.repository) | |
3286 |
|
3286 | |||
3287 |
|
3287 | |||
3288 | class UserUserGroupToPerm(Base, BaseModel): |
|
3288 | class UserUserGroupToPerm(Base, BaseModel): | |
3289 | __tablename__ = 'user_user_group_to_perm' |
|
3289 | __tablename__ = 'user_user_group_to_perm' | |
3290 | __table_args__ = ( |
|
3290 | __table_args__ = ( | |
3291 | UniqueConstraint('user_id', 'user_group_id', 'permission_id'), |
|
3291 | UniqueConstraint('user_id', 'user_group_id', 'permission_id'), | |
3292 | base_table_args |
|
3292 | base_table_args | |
3293 | ) |
|
3293 | ) | |
3294 |
|
3294 | |||
3295 | user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3295 | user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3296 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3296 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3297 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3297 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3298 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3298 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3299 |
|
3299 | |||
3300 | user = relationship('User') |
|
3300 | user = relationship('User') | |
3301 | user_group = relationship('UserGroup') |
|
3301 | user_group = relationship('UserGroup') | |
3302 | permission = relationship('Permission') |
|
3302 | permission = relationship('Permission') | |
3303 |
|
3303 | |||
3304 | @classmethod |
|
3304 | @classmethod | |
3305 | def create(cls, user, user_group, permission): |
|
3305 | def create(cls, user, user_group, permission): | |
3306 | n = cls() |
|
3306 | n = cls() | |
3307 | n.user = user |
|
3307 | n.user = user | |
3308 | n.user_group = user_group |
|
3308 | n.user_group = user_group | |
3309 | n.permission = permission |
|
3309 | n.permission = permission | |
3310 | Session().add(n) |
|
3310 | Session().add(n) | |
3311 | return n |
|
3311 | return n | |
3312 |
|
3312 | |||
3313 | def __unicode__(self): |
|
3313 | def __unicode__(self): | |
3314 | return u'<%s => %s >' % (self.user, self.user_group) |
|
3314 | return u'<%s => %s >' % (self.user, self.user_group) | |
3315 |
|
3315 | |||
3316 |
|
3316 | |||
3317 | class UserToPerm(Base, BaseModel): |
|
3317 | class UserToPerm(Base, BaseModel): | |
3318 | __tablename__ = 'user_to_perm' |
|
3318 | __tablename__ = 'user_to_perm' | |
3319 | __table_args__ = ( |
|
3319 | __table_args__ = ( | |
3320 | UniqueConstraint('user_id', 'permission_id'), |
|
3320 | UniqueConstraint('user_id', 'permission_id'), | |
3321 | base_table_args |
|
3321 | base_table_args | |
3322 | ) |
|
3322 | ) | |
3323 |
|
3323 | |||
3324 | user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3324 | user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3325 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3325 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3326 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3326 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3327 |
|
3327 | |||
3328 | user = relationship('User') |
|
3328 | user = relationship('User') | |
3329 | permission = relationship('Permission', lazy='joined') |
|
3329 | permission = relationship('Permission', lazy='joined') | |
3330 |
|
3330 | |||
3331 | def __unicode__(self): |
|
3331 | def __unicode__(self): | |
3332 | return u'<%s => %s >' % (self.user, self.permission) |
|
3332 | return u'<%s => %s >' % (self.user, self.permission) | |
3333 |
|
3333 | |||
3334 |
|
3334 | |||
3335 | class UserGroupRepoToPerm(Base, BaseModel): |
|
3335 | class UserGroupRepoToPerm(Base, BaseModel): | |
3336 | __tablename__ = 'users_group_repo_to_perm' |
|
3336 | __tablename__ = 'users_group_repo_to_perm' | |
3337 | __table_args__ = ( |
|
3337 | __table_args__ = ( | |
3338 | UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), |
|
3338 | UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), | |
3339 | base_table_args |
|
3339 | base_table_args | |
3340 | ) |
|
3340 | ) | |
3341 |
|
3341 | |||
3342 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3342 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3343 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3343 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3344 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3344 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3345 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
3345 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
3346 |
|
3346 | |||
3347 | users_group = relationship('UserGroup') |
|
3347 | users_group = relationship('UserGroup') | |
3348 | permission = relationship('Permission') |
|
3348 | permission = relationship('Permission') | |
3349 | repository = relationship('Repository') |
|
3349 | repository = relationship('Repository') | |
3350 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all') |
|
3350 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all') | |
3351 |
|
3351 | |||
3352 | @classmethod |
|
3352 | @classmethod | |
3353 | def create(cls, users_group, repository, permission): |
|
3353 | def create(cls, users_group, repository, permission): | |
3354 | n = cls() |
|
3354 | n = cls() | |
3355 | n.users_group = users_group |
|
3355 | n.users_group = users_group | |
3356 | n.repository = repository |
|
3356 | n.repository = repository | |
3357 | n.permission = permission |
|
3357 | n.permission = permission | |
3358 | Session().add(n) |
|
3358 | Session().add(n) | |
3359 | return n |
|
3359 | return n | |
3360 |
|
3360 | |||
3361 | def __unicode__(self): |
|
3361 | def __unicode__(self): | |
3362 | return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository) |
|
3362 | return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository) | |
3363 |
|
3363 | |||
3364 |
|
3364 | |||
3365 | class UserGroupUserGroupToPerm(Base, BaseModel): |
|
3365 | class UserGroupUserGroupToPerm(Base, BaseModel): | |
3366 | __tablename__ = 'user_group_user_group_to_perm' |
|
3366 | __tablename__ = 'user_group_user_group_to_perm' | |
3367 | __table_args__ = ( |
|
3367 | __table_args__ = ( | |
3368 | UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'), |
|
3368 | UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'), | |
3369 | CheckConstraint('target_user_group_id != user_group_id'), |
|
3369 | CheckConstraint('target_user_group_id != user_group_id'), | |
3370 | base_table_args |
|
3370 | base_table_args | |
3371 | ) |
|
3371 | ) | |
3372 |
|
3372 | |||
3373 | 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) |
|
3373 | 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) | |
3374 | target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3374 | target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3375 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3375 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3376 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3376 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3377 |
|
3377 | |||
3378 | target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id') |
|
3378 | target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id') | |
3379 | user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id') |
|
3379 | user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id') | |
3380 | permission = relationship('Permission') |
|
3380 | permission = relationship('Permission') | |
3381 |
|
3381 | |||
3382 | @classmethod |
|
3382 | @classmethod | |
3383 | def create(cls, target_user_group, user_group, permission): |
|
3383 | def create(cls, target_user_group, user_group, permission): | |
3384 | n = cls() |
|
3384 | n = cls() | |
3385 | n.target_user_group = target_user_group |
|
3385 | n.target_user_group = target_user_group | |
3386 | n.user_group = user_group |
|
3386 | n.user_group = user_group | |
3387 | n.permission = permission |
|
3387 | n.permission = permission | |
3388 | Session().add(n) |
|
3388 | Session().add(n) | |
3389 | return n |
|
3389 | return n | |
3390 |
|
3390 | |||
3391 | def __unicode__(self): |
|
3391 | def __unicode__(self): | |
3392 | return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group) |
|
3392 | return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group) | |
3393 |
|
3393 | |||
3394 |
|
3394 | |||
3395 | class UserGroupToPerm(Base, BaseModel): |
|
3395 | class UserGroupToPerm(Base, BaseModel): | |
3396 | __tablename__ = 'users_group_to_perm' |
|
3396 | __tablename__ = 'users_group_to_perm' | |
3397 | __table_args__ = ( |
|
3397 | __table_args__ = ( | |
3398 | UniqueConstraint('users_group_id', 'permission_id',), |
|
3398 | UniqueConstraint('users_group_id', 'permission_id',), | |
3399 | base_table_args |
|
3399 | base_table_args | |
3400 | ) |
|
3400 | ) | |
3401 |
|
3401 | |||
3402 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3402 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3403 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3403 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3404 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3404 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3405 |
|
3405 | |||
3406 | users_group = relationship('UserGroup') |
|
3406 | users_group = relationship('UserGroup') | |
3407 | permission = relationship('Permission') |
|
3407 | permission = relationship('Permission') | |
3408 |
|
3408 | |||
3409 |
|
3409 | |||
3410 | class UserRepoGroupToPerm(Base, BaseModel): |
|
3410 | class UserRepoGroupToPerm(Base, BaseModel): | |
3411 | __tablename__ = 'user_repo_group_to_perm' |
|
3411 | __tablename__ = 'user_repo_group_to_perm' | |
3412 | __table_args__ = ( |
|
3412 | __table_args__ = ( | |
3413 | UniqueConstraint('user_id', 'group_id', 'permission_id'), |
|
3413 | UniqueConstraint('user_id', 'group_id', 'permission_id'), | |
3414 | base_table_args |
|
3414 | base_table_args | |
3415 | ) |
|
3415 | ) | |
3416 |
|
3416 | |||
3417 | group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3417 | group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3418 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3418 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3419 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) |
|
3419 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
3420 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3420 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3421 |
|
3421 | |||
3422 | user = relationship('User') |
|
3422 | user = relationship('User') | |
3423 | group = relationship('RepoGroup') |
|
3423 | group = relationship('RepoGroup') | |
3424 | permission = relationship('Permission') |
|
3424 | permission = relationship('Permission') | |
3425 |
|
3425 | |||
3426 | @classmethod |
|
3426 | @classmethod | |
3427 | def create(cls, user, repository_group, permission): |
|
3427 | def create(cls, user, repository_group, permission): | |
3428 | n = cls() |
|
3428 | n = cls() | |
3429 | n.user = user |
|
3429 | n.user = user | |
3430 | n.group = repository_group |
|
3430 | n.group = repository_group | |
3431 | n.permission = permission |
|
3431 | n.permission = permission | |
3432 | Session().add(n) |
|
3432 | Session().add(n) | |
3433 | return n |
|
3433 | return n | |
3434 |
|
3434 | |||
3435 |
|
3435 | |||
3436 | class UserGroupRepoGroupToPerm(Base, BaseModel): |
|
3436 | class UserGroupRepoGroupToPerm(Base, BaseModel): | |
3437 | __tablename__ = 'users_group_repo_group_to_perm' |
|
3437 | __tablename__ = 'users_group_repo_group_to_perm' | |
3438 | __table_args__ = ( |
|
3438 | __table_args__ = ( | |
3439 | UniqueConstraint('users_group_id', 'group_id'), |
|
3439 | UniqueConstraint('users_group_id', 'group_id'), | |
3440 | base_table_args |
|
3440 | base_table_args | |
3441 | ) |
|
3441 | ) | |
3442 |
|
3442 | |||
3443 | 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) |
|
3443 | 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) | |
3444 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3444 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3445 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) |
|
3445 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
3446 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3446 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3447 |
|
3447 | |||
3448 | users_group = relationship('UserGroup') |
|
3448 | users_group = relationship('UserGroup') | |
3449 | permission = relationship('Permission') |
|
3449 | permission = relationship('Permission') | |
3450 | group = relationship('RepoGroup') |
|
3450 | group = relationship('RepoGroup') | |
3451 |
|
3451 | |||
3452 | @classmethod |
|
3452 | @classmethod | |
3453 | def create(cls, user_group, repository_group, permission): |
|
3453 | def create(cls, user_group, repository_group, permission): | |
3454 | n = cls() |
|
3454 | n = cls() | |
3455 | n.users_group = user_group |
|
3455 | n.users_group = user_group | |
3456 | n.group = repository_group |
|
3456 | n.group = repository_group | |
3457 | n.permission = permission |
|
3457 | n.permission = permission | |
3458 | Session().add(n) |
|
3458 | Session().add(n) | |
3459 | return n |
|
3459 | return n | |
3460 |
|
3460 | |||
3461 | def __unicode__(self): |
|
3461 | def __unicode__(self): | |
3462 | return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group) |
|
3462 | return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group) | |
3463 |
|
3463 | |||
3464 |
|
3464 | |||
3465 | class Statistics(Base, BaseModel): |
|
3465 | class Statistics(Base, BaseModel): | |
3466 | __tablename__ = 'statistics' |
|
3466 | __tablename__ = 'statistics' | |
3467 | __table_args__ = ( |
|
3467 | __table_args__ = ( | |
3468 | base_table_args |
|
3468 | base_table_args | |
3469 | ) |
|
3469 | ) | |
3470 |
|
3470 | |||
3471 | stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3471 | stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3472 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) |
|
3472 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) | |
3473 | stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) |
|
3473 | stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) | |
3474 | commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data |
|
3474 | commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data | |
3475 | commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data |
|
3475 | commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data | |
3476 | languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data |
|
3476 | languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data | |
3477 |
|
3477 | |||
3478 | repository = relationship('Repository', single_parent=True) |
|
3478 | repository = relationship('Repository', single_parent=True) | |
3479 |
|
3479 | |||
3480 |
|
3480 | |||
3481 | class UserFollowing(Base, BaseModel): |
|
3481 | class UserFollowing(Base, BaseModel): | |
3482 | __tablename__ = 'user_followings' |
|
3482 | __tablename__ = 'user_followings' | |
3483 | __table_args__ = ( |
|
3483 | __table_args__ = ( | |
3484 | UniqueConstraint('user_id', 'follows_repository_id'), |
|
3484 | UniqueConstraint('user_id', 'follows_repository_id'), | |
3485 | UniqueConstraint('user_id', 'follows_user_id'), |
|
3485 | UniqueConstraint('user_id', 'follows_user_id'), | |
3486 | base_table_args |
|
3486 | base_table_args | |
3487 | ) |
|
3487 | ) | |
3488 |
|
3488 | |||
3489 | user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3489 | user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3490 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3490 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3491 | follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) |
|
3491 | follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) | |
3492 | follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
3492 | follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
3493 | follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) |
|
3493 | follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
3494 |
|
3494 | |||
3495 | user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id') |
|
3495 | user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id') | |
3496 |
|
3496 | |||
3497 | follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') |
|
3497 | follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') | |
3498 | follows_repository = relationship('Repository', order_by='Repository.repo_name') |
|
3498 | follows_repository = relationship('Repository', order_by='Repository.repo_name') | |
3499 |
|
3499 | |||
3500 | @classmethod |
|
3500 | @classmethod | |
3501 | def get_repo_followers(cls, repo_id): |
|
3501 | def get_repo_followers(cls, repo_id): | |
3502 | return cls.query().filter(cls.follows_repo_id == repo_id) |
|
3502 | return cls.query().filter(cls.follows_repo_id == repo_id) | |
3503 |
|
3503 | |||
3504 |
|
3504 | |||
3505 | class CacheKey(Base, BaseModel): |
|
3505 | class CacheKey(Base, BaseModel): | |
3506 | __tablename__ = 'cache_invalidation' |
|
3506 | __tablename__ = 'cache_invalidation' | |
3507 | __table_args__ = ( |
|
3507 | __table_args__ = ( | |
3508 | UniqueConstraint('cache_key'), |
|
3508 | UniqueConstraint('cache_key'), | |
3509 | Index('key_idx', 'cache_key'), |
|
3509 | Index('key_idx', 'cache_key'), | |
3510 | base_table_args, |
|
3510 | base_table_args, | |
3511 | ) |
|
3511 | ) | |
3512 |
|
3512 | |||
3513 | CACHE_TYPE_FEED = 'FEED' |
|
3513 | CACHE_TYPE_FEED = 'FEED' | |
3514 |
|
3514 | |||
3515 | # namespaces used to register process/thread aware caches |
|
3515 | # namespaces used to register process/thread aware caches | |
3516 | REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}' |
|
3516 | REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}' | |
3517 | SETTINGS_INVALIDATION_NAMESPACE = 'system_settings' |
|
3517 | SETTINGS_INVALIDATION_NAMESPACE = 'system_settings' | |
3518 |
|
3518 | |||
3519 | cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3519 | cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3520 | cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None) |
|
3520 | cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None) | |
3521 | cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None) |
|
3521 | cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None) | |
3522 | cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None) |
|
3522 | cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None) | |
3523 | cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) |
|
3523 | cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) | |
3524 |
|
3524 | |||
3525 | def __init__(self, cache_key, cache_args='', cache_state_uid=None): |
|
3525 | def __init__(self, cache_key, cache_args='', cache_state_uid=None): | |
3526 | self.cache_key = cache_key |
|
3526 | self.cache_key = cache_key | |
3527 | self.cache_args = cache_args |
|
3527 | self.cache_args = cache_args | |
3528 | self.cache_active = False |
|
3528 | self.cache_active = False | |
3529 | # first key should be same for all entries, since all workers should share it |
|
3529 | # first key should be same for all entries, since all workers should share it | |
3530 | self.cache_state_uid = cache_state_uid or self.generate_new_state_uid() |
|
3530 | self.cache_state_uid = cache_state_uid or self.generate_new_state_uid() | |
3531 |
|
3531 | |||
3532 | def __unicode__(self): |
|
3532 | def __unicode__(self): | |
3533 | return u"<%s('%s:%s[%s]')>" % ( |
|
3533 | return u"<%s('%s:%s[%s]')>" % ( | |
3534 | self.__class__.__name__, |
|
3534 | self.__class__.__name__, | |
3535 | self.cache_id, self.cache_key, self.cache_active) |
|
3535 | self.cache_id, self.cache_key, self.cache_active) | |
3536 |
|
3536 | |||
3537 | def _cache_key_partition(self): |
|
3537 | def _cache_key_partition(self): | |
3538 | prefix, repo_name, suffix = self.cache_key.partition(self.cache_args) |
|
3538 | prefix, repo_name, suffix = self.cache_key.partition(self.cache_args) | |
3539 | return prefix, repo_name, suffix |
|
3539 | return prefix, repo_name, suffix | |
3540 |
|
3540 | |||
3541 | def get_prefix(self): |
|
3541 | def get_prefix(self): | |
3542 | """ |
|
3542 | """ | |
3543 | Try to extract prefix from existing cache key. The key could consist |
|
3543 | Try to extract prefix from existing cache key. The key could consist | |
3544 | of prefix, repo_name, suffix |
|
3544 | of prefix, repo_name, suffix | |
3545 | """ |
|
3545 | """ | |
3546 | # this returns prefix, repo_name, suffix |
|
3546 | # this returns prefix, repo_name, suffix | |
3547 | return self._cache_key_partition()[0] |
|
3547 | return self._cache_key_partition()[0] | |
3548 |
|
3548 | |||
3549 | def get_suffix(self): |
|
3549 | def get_suffix(self): | |
3550 | """ |
|
3550 | """ | |
3551 | get suffix that might have been used in _get_cache_key to |
|
3551 | get suffix that might have been used in _get_cache_key to | |
3552 | generate self.cache_key. Only used for informational purposes |
|
3552 | generate self.cache_key. Only used for informational purposes | |
3553 | in repo_edit.mako. |
|
3553 | in repo_edit.mako. | |
3554 | """ |
|
3554 | """ | |
3555 | # prefix, repo_name, suffix |
|
3555 | # prefix, repo_name, suffix | |
3556 | return self._cache_key_partition()[2] |
|
3556 | return self._cache_key_partition()[2] | |
3557 |
|
3557 | |||
3558 | @classmethod |
|
3558 | @classmethod | |
3559 | def generate_new_state_uid(cls, based_on=None): |
|
3559 | def generate_new_state_uid(cls, based_on=None): | |
3560 | if based_on: |
|
3560 | if based_on: | |
3561 | return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on))) |
|
3561 | return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on))) | |
3562 | else: |
|
3562 | else: | |
3563 | return str(uuid.uuid4()) |
|
3563 | return str(uuid.uuid4()) | |
3564 |
|
3564 | |||
3565 | @classmethod |
|
3565 | @classmethod | |
3566 | def delete_all_cache(cls): |
|
3566 | def delete_all_cache(cls): | |
3567 | """ |
|
3567 | """ | |
3568 | Delete all cache keys from database. |
|
3568 | Delete all cache keys from database. | |
3569 | Should only be run when all instances are down and all entries |
|
3569 | Should only be run when all instances are down and all entries | |
3570 | thus stale. |
|
3570 | thus stale. | |
3571 | """ |
|
3571 | """ | |
3572 | cls.query().delete() |
|
3572 | cls.query().delete() | |
3573 | Session().commit() |
|
3573 | Session().commit() | |
3574 |
|
3574 | |||
3575 | @classmethod |
|
3575 | @classmethod | |
3576 | def set_invalidate(cls, cache_uid, delete=False): |
|
3576 | def set_invalidate(cls, cache_uid, delete=False): | |
3577 | """ |
|
3577 | """ | |
3578 | Mark all caches of a repo as invalid in the database. |
|
3578 | Mark all caches of a repo as invalid in the database. | |
3579 | """ |
|
3579 | """ | |
3580 |
|
3580 | |||
3581 | try: |
|
3581 | try: | |
3582 | qry = Session().query(cls).filter(cls.cache_args == cache_uid) |
|
3582 | qry = Session().query(cls).filter(cls.cache_args == cache_uid) | |
3583 | if delete: |
|
3583 | if delete: | |
3584 | qry.delete() |
|
3584 | qry.delete() | |
3585 | log.debug('cache objects deleted for cache args %s', |
|
3585 | log.debug('cache objects deleted for cache args %s', | |
3586 | safe_str(cache_uid)) |
|
3586 | safe_str(cache_uid)) | |
3587 | else: |
|
3587 | else: | |
3588 | qry.update({"cache_active": False, |
|
3588 | qry.update({"cache_active": False, | |
3589 | "cache_state_uid": cls.generate_new_state_uid()}) |
|
3589 | "cache_state_uid": cls.generate_new_state_uid()}) | |
3590 | log.debug('cache objects marked as invalid for cache args %s', |
|
3590 | log.debug('cache objects marked as invalid for cache args %s', | |
3591 | safe_str(cache_uid)) |
|
3591 | safe_str(cache_uid)) | |
3592 |
|
3592 | |||
3593 | Session().commit() |
|
3593 | Session().commit() | |
3594 | except Exception: |
|
3594 | except Exception: | |
3595 | log.exception( |
|
3595 | log.exception( | |
3596 | 'Cache key invalidation failed for cache args %s', |
|
3596 | 'Cache key invalidation failed for cache args %s', | |
3597 | safe_str(cache_uid)) |
|
3597 | safe_str(cache_uid)) | |
3598 | Session().rollback() |
|
3598 | Session().rollback() | |
3599 |
|
3599 | |||
3600 | @classmethod |
|
3600 | @classmethod | |
3601 | def get_active_cache(cls, cache_key): |
|
3601 | def get_active_cache(cls, cache_key): | |
3602 | inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar() |
|
3602 | inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar() | |
3603 | if inv_obj: |
|
3603 | if inv_obj: | |
3604 | return inv_obj |
|
3604 | return inv_obj | |
3605 | return None |
|
3605 | return None | |
3606 |
|
3606 | |||
3607 | @classmethod |
|
3607 | @classmethod | |
3608 | def get_namespace_map(cls, namespace): |
|
3608 | def get_namespace_map(cls, namespace): | |
3609 | return { |
|
3609 | return { | |
3610 | x.cache_key: x |
|
3610 | x.cache_key: x | |
3611 | for x in cls.query().filter(cls.cache_args == namespace)} |
|
3611 | for x in cls.query().filter(cls.cache_args == namespace)} | |
3612 |
|
3612 | |||
3613 |
|
3613 | |||
3614 | class ChangesetComment(Base, BaseModel): |
|
3614 | class ChangesetComment(Base, BaseModel): | |
3615 | __tablename__ = 'changeset_comments' |
|
3615 | __tablename__ = 'changeset_comments' | |
3616 | __table_args__ = ( |
|
3616 | __table_args__ = ( | |
3617 | Index('cc_revision_idx', 'revision'), |
|
3617 | Index('cc_revision_idx', 'revision'), | |
3618 | base_table_args, |
|
3618 | base_table_args, | |
3619 | ) |
|
3619 | ) | |
3620 |
|
3620 | |||
3621 | COMMENT_OUTDATED = u'comment_outdated' |
|
3621 | COMMENT_OUTDATED = u'comment_outdated' | |
3622 | COMMENT_TYPE_NOTE = u'note' |
|
3622 | COMMENT_TYPE_NOTE = u'note' | |
3623 | COMMENT_TYPE_TODO = u'todo' |
|
3623 | COMMENT_TYPE_TODO = u'todo' | |
3624 | COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO] |
|
3624 | COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO] | |
3625 |
|
3625 | |||
3626 | comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True) |
|
3626 | comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True) | |
3627 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) |
|
3627 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
3628 | revision = Column('revision', String(40), nullable=True) |
|
3628 | revision = Column('revision', String(40), nullable=True) | |
3629 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) |
|
3629 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
3630 | pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True) |
|
3630 | pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True) | |
3631 | line_no = Column('line_no', Unicode(10), nullable=True) |
|
3631 | line_no = Column('line_no', Unicode(10), nullable=True) | |
3632 | hl_lines = Column('hl_lines', Unicode(512), nullable=True) |
|
3632 | hl_lines = Column('hl_lines', Unicode(512), nullable=True) | |
3633 | f_path = Column('f_path', Unicode(1000), nullable=True) |
|
3633 | f_path = Column('f_path', Unicode(1000), nullable=True) | |
3634 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) |
|
3634 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
3635 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) |
|
3635 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) | |
3636 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
3636 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
3637 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
3637 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
3638 | renderer = Column('renderer', Unicode(64), nullable=True) |
|
3638 | renderer = Column('renderer', Unicode(64), nullable=True) | |
3639 | display_state = Column('display_state', Unicode(128), nullable=True) |
|
3639 | display_state = Column('display_state', Unicode(128), nullable=True) | |
3640 |
|
3640 | |||
3641 | comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE) |
|
3641 | comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE) | |
3642 | resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True) |
|
3642 | resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True) | |
3643 |
|
3643 | |||
3644 | resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by') |
|
3644 | resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by') | |
3645 | resolved_by = relationship('ChangesetComment', back_populates='resolved_comment') |
|
3645 | resolved_by = relationship('ChangesetComment', back_populates='resolved_comment') | |
3646 |
|
3646 | |||
3647 | author = relationship('User', lazy='joined') |
|
3647 | author = relationship('User', lazy='joined') | |
3648 | repo = relationship('Repository') |
|
3648 | repo = relationship('Repository') | |
3649 | status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined') |
|
3649 | status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined') | |
3650 | pull_request = relationship('PullRequest', lazy='joined') |
|
3650 | pull_request = relationship('PullRequest', lazy='joined') | |
3651 | pull_request_version = relationship('PullRequestVersion') |
|
3651 | pull_request_version = relationship('PullRequestVersion') | |
3652 |
|
3652 | |||
3653 | @classmethod |
|
3653 | @classmethod | |
3654 | def get_users(cls, revision=None, pull_request_id=None): |
|
3654 | def get_users(cls, revision=None, pull_request_id=None): | |
3655 | """ |
|
3655 | """ | |
3656 | Returns user associated with this ChangesetComment. ie those |
|
3656 | Returns user associated with this ChangesetComment. ie those | |
3657 | who actually commented |
|
3657 | who actually commented | |
3658 |
|
3658 | |||
3659 | :param cls: |
|
3659 | :param cls: | |
3660 | :param revision: |
|
3660 | :param revision: | |
3661 | """ |
|
3661 | """ | |
3662 | q = Session().query(User)\ |
|
3662 | q = Session().query(User)\ | |
3663 | .join(ChangesetComment.author) |
|
3663 | .join(ChangesetComment.author) | |
3664 | if revision: |
|
3664 | if revision: | |
3665 | q = q.filter(cls.revision == revision) |
|
3665 | q = q.filter(cls.revision == revision) | |
3666 | elif pull_request_id: |
|
3666 | elif pull_request_id: | |
3667 | q = q.filter(cls.pull_request_id == pull_request_id) |
|
3667 | q = q.filter(cls.pull_request_id == pull_request_id) | |
3668 | return q.all() |
|
3668 | return q.all() | |
3669 |
|
3669 | |||
3670 | @classmethod |
|
3670 | @classmethod | |
3671 | def get_index_from_version(cls, pr_version, versions): |
|
3671 | def get_index_from_version(cls, pr_version, versions): | |
3672 | num_versions = [x.pull_request_version_id for x in versions] |
|
3672 | num_versions = [x.pull_request_version_id for x in versions] | |
3673 | try: |
|
3673 | try: | |
3674 | return num_versions.index(pr_version) +1 |
|
3674 | return num_versions.index(pr_version) +1 | |
3675 | except (IndexError, ValueError): |
|
3675 | except (IndexError, ValueError): | |
3676 | return |
|
3676 | return | |
3677 |
|
3677 | |||
3678 | @property |
|
3678 | @property | |
3679 | def outdated(self): |
|
3679 | def outdated(self): | |
3680 | return self.display_state == self.COMMENT_OUTDATED |
|
3680 | return self.display_state == self.COMMENT_OUTDATED | |
3681 |
|
3681 | |||
3682 | def outdated_at_version(self, version): |
|
3682 | def outdated_at_version(self, version): | |
3683 | """ |
|
3683 | """ | |
3684 | Checks if comment is outdated for given pull request version |
|
3684 | Checks if comment is outdated for given pull request version | |
3685 | """ |
|
3685 | """ | |
3686 | return self.outdated and self.pull_request_version_id != version |
|
3686 | return self.outdated and self.pull_request_version_id != version | |
3687 |
|
3687 | |||
3688 | def older_than_version(self, version): |
|
3688 | def older_than_version(self, version): | |
3689 | """ |
|
3689 | """ | |
3690 | Checks if comment is made from previous version than given |
|
3690 | Checks if comment is made from previous version than given | |
3691 | """ |
|
3691 | """ | |
3692 | if version is None: |
|
3692 | if version is None: | |
3693 | return self.pull_request_version_id is not None |
|
3693 | return self.pull_request_version_id is not None | |
3694 |
|
3694 | |||
3695 | return self.pull_request_version_id < version |
|
3695 | return self.pull_request_version_id < version | |
3696 |
|
3696 | |||
3697 | @property |
|
3697 | @property | |
3698 | def resolved(self): |
|
3698 | def resolved(self): | |
3699 | return self.resolved_by[0] if self.resolved_by else None |
|
3699 | return self.resolved_by[0] if self.resolved_by else None | |
3700 |
|
3700 | |||
3701 | @property |
|
3701 | @property | |
3702 | def is_todo(self): |
|
3702 | def is_todo(self): | |
3703 | return self.comment_type == self.COMMENT_TYPE_TODO |
|
3703 | return self.comment_type == self.COMMENT_TYPE_TODO | |
3704 |
|
3704 | |||
3705 | @property |
|
3705 | @property | |
3706 | def is_inline(self): |
|
3706 | def is_inline(self): | |
3707 | return self.line_no and self.f_path |
|
3707 | return self.line_no and self.f_path | |
3708 |
|
3708 | |||
3709 | def get_index_version(self, versions): |
|
3709 | def get_index_version(self, versions): | |
3710 | return self.get_index_from_version( |
|
3710 | return self.get_index_from_version( | |
3711 | self.pull_request_version_id, versions) |
|
3711 | self.pull_request_version_id, versions) | |
3712 |
|
3712 | |||
3713 | def __repr__(self): |
|
3713 | def __repr__(self): | |
3714 | if self.comment_id: |
|
3714 | if self.comment_id: | |
3715 | return '<DB:Comment #%s>' % self.comment_id |
|
3715 | return '<DB:Comment #%s>' % self.comment_id | |
3716 | else: |
|
3716 | else: | |
3717 | return '<DB:Comment at %#x>' % id(self) |
|
3717 | return '<DB:Comment at %#x>' % id(self) | |
3718 |
|
3718 | |||
3719 | def get_api_data(self): |
|
3719 | def get_api_data(self): | |
3720 | comment = self |
|
3720 | comment = self | |
3721 | data = { |
|
3721 | data = { | |
3722 | 'comment_id': comment.comment_id, |
|
3722 | 'comment_id': comment.comment_id, | |
3723 | 'comment_type': comment.comment_type, |
|
3723 | 'comment_type': comment.comment_type, | |
3724 | 'comment_text': comment.text, |
|
3724 | 'comment_text': comment.text, | |
3725 | 'comment_status': comment.status_change, |
|
3725 | 'comment_status': comment.status_change, | |
3726 | 'comment_f_path': comment.f_path, |
|
3726 | 'comment_f_path': comment.f_path, | |
3727 | 'comment_lineno': comment.line_no, |
|
3727 | 'comment_lineno': comment.line_no, | |
3728 | 'comment_author': comment.author, |
|
3728 | 'comment_author': comment.author, | |
3729 | 'comment_created_on': comment.created_on, |
|
3729 | 'comment_created_on': comment.created_on, | |
3730 | 'comment_resolved_by': self.resolved |
|
3730 | 'comment_resolved_by': self.resolved | |
3731 | } |
|
3731 | } | |
3732 | return data |
|
3732 | return data | |
3733 |
|
3733 | |||
3734 | def __json__(self): |
|
3734 | def __json__(self): | |
3735 | data = dict() |
|
3735 | data = dict() | |
3736 | data.update(self.get_api_data()) |
|
3736 | data.update(self.get_api_data()) | |
3737 | return data |
|
3737 | return data | |
3738 |
|
3738 | |||
3739 |
|
3739 | |||
3740 | class ChangesetStatus(Base, BaseModel): |
|
3740 | class ChangesetStatus(Base, BaseModel): | |
3741 | __tablename__ = 'changeset_statuses' |
|
3741 | __tablename__ = 'changeset_statuses' | |
3742 | __table_args__ = ( |
|
3742 | __table_args__ = ( | |
3743 | Index('cs_revision_idx', 'revision'), |
|
3743 | Index('cs_revision_idx', 'revision'), | |
3744 | Index('cs_version_idx', 'version'), |
|
3744 | Index('cs_version_idx', 'version'), | |
3745 | UniqueConstraint('repo_id', 'revision', 'version'), |
|
3745 | UniqueConstraint('repo_id', 'revision', 'version'), | |
3746 | base_table_args |
|
3746 | base_table_args | |
3747 | ) |
|
3747 | ) | |
3748 |
|
3748 | |||
3749 | STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed' |
|
3749 | STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed' | |
3750 | STATUS_APPROVED = 'approved' |
|
3750 | STATUS_APPROVED = 'approved' | |
3751 | STATUS_REJECTED = 'rejected' |
|
3751 | STATUS_REJECTED = 'rejected' | |
3752 | STATUS_UNDER_REVIEW = 'under_review' |
|
3752 | STATUS_UNDER_REVIEW = 'under_review' | |
3753 |
|
3753 | |||
3754 | STATUSES = [ |
|
3754 | STATUSES = [ | |
3755 | (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default |
|
3755 | (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default | |
3756 | (STATUS_APPROVED, _("Approved")), |
|
3756 | (STATUS_APPROVED, _("Approved")), | |
3757 | (STATUS_REJECTED, _("Rejected")), |
|
3757 | (STATUS_REJECTED, _("Rejected")), | |
3758 | (STATUS_UNDER_REVIEW, _("Under Review")), |
|
3758 | (STATUS_UNDER_REVIEW, _("Under Review")), | |
3759 | ] |
|
3759 | ] | |
3760 |
|
3760 | |||
3761 | changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True) |
|
3761 | changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True) | |
3762 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) |
|
3762 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
3763 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None) |
|
3763 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None) | |
3764 | revision = Column('revision', String(40), nullable=False) |
|
3764 | revision = Column('revision', String(40), nullable=False) | |
3765 | status = Column('status', String(128), nullable=False, default=DEFAULT) |
|
3765 | status = Column('status', String(128), nullable=False, default=DEFAULT) | |
3766 | changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id')) |
|
3766 | changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id')) | |
3767 | modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now) |
|
3767 | modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now) | |
3768 | version = Column('version', Integer(), nullable=False, default=0) |
|
3768 | version = Column('version', Integer(), nullable=False, default=0) | |
3769 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) |
|
3769 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
3770 |
|
3770 | |||
3771 | author = relationship('User', lazy='joined') |
|
3771 | author = relationship('User', lazy='joined') | |
3772 | repo = relationship('Repository') |
|
3772 | repo = relationship('Repository') | |
3773 | comment = relationship('ChangesetComment', lazy='joined') |
|
3773 | comment = relationship('ChangesetComment', lazy='joined') | |
3774 | pull_request = relationship('PullRequest', lazy='joined') |
|
3774 | pull_request = relationship('PullRequest', lazy='joined') | |
3775 |
|
3775 | |||
3776 | def __unicode__(self): |
|
3776 | def __unicode__(self): | |
3777 | return u"<%s('%s[v%s]:%s')>" % ( |
|
3777 | return u"<%s('%s[v%s]:%s')>" % ( | |
3778 | self.__class__.__name__, |
|
3778 | self.__class__.__name__, | |
3779 | self.status, self.version, self.author |
|
3779 | self.status, self.version, self.author | |
3780 | ) |
|
3780 | ) | |
3781 |
|
3781 | |||
3782 | @classmethod |
|
3782 | @classmethod | |
3783 | def get_status_lbl(cls, value): |
|
3783 | def get_status_lbl(cls, value): | |
3784 | return dict(cls.STATUSES).get(value) |
|
3784 | return dict(cls.STATUSES).get(value) | |
3785 |
|
3785 | |||
3786 | @property |
|
3786 | @property | |
3787 | def status_lbl(self): |
|
3787 | def status_lbl(self): | |
3788 | return ChangesetStatus.get_status_lbl(self.status) |
|
3788 | return ChangesetStatus.get_status_lbl(self.status) | |
3789 |
|
3789 | |||
3790 | def get_api_data(self): |
|
3790 | def get_api_data(self): | |
3791 | status = self |
|
3791 | status = self | |
3792 | data = { |
|
3792 | data = { | |
3793 | 'status_id': status.changeset_status_id, |
|
3793 | 'status_id': status.changeset_status_id, | |
3794 | 'status': status.status, |
|
3794 | 'status': status.status, | |
3795 | } |
|
3795 | } | |
3796 | return data |
|
3796 | return data | |
3797 |
|
3797 | |||
3798 | def __json__(self): |
|
3798 | def __json__(self): | |
3799 | data = dict() |
|
3799 | data = dict() | |
3800 | data.update(self.get_api_data()) |
|
3800 | data.update(self.get_api_data()) | |
3801 | return data |
|
3801 | return data | |
3802 |
|
3802 | |||
3803 |
|
3803 | |||
3804 | class _SetState(object): |
|
3804 | class _SetState(object): | |
3805 | """ |
|
3805 | """ | |
3806 | Context processor allowing changing state for sensitive operation such as |
|
3806 | Context processor allowing changing state for sensitive operation such as | |
3807 | pull request update or merge |
|
3807 | pull request update or merge | |
3808 | """ |
|
3808 | """ | |
3809 |
|
3809 | |||
3810 | def __init__(self, pull_request, pr_state, back_state=None): |
|
3810 | def __init__(self, pull_request, pr_state, back_state=None): | |
3811 | self._pr = pull_request |
|
3811 | self._pr = pull_request | |
3812 | self._org_state = back_state or pull_request.pull_request_state |
|
3812 | self._org_state = back_state or pull_request.pull_request_state | |
3813 | self._pr_state = pr_state |
|
3813 | self._pr_state = pr_state | |
3814 | self._current_state = None |
|
3814 | self._current_state = None | |
3815 |
|
3815 | |||
3816 | def __enter__(self): |
|
3816 | def __enter__(self): | |
3817 | log.debug('StateLock: entering set state context, setting state to: `%s`', |
|
3817 | log.debug('StateLock: entering set state context, setting state to: `%s`', | |
3818 | self._pr_state) |
|
3818 | self._pr_state) | |
3819 | self.set_pr_state(self._pr_state) |
|
3819 | self.set_pr_state(self._pr_state) | |
3820 | return self |
|
3820 | return self | |
3821 |
|
3821 | |||
3822 | def __exit__(self, exc_type, exc_val, exc_tb): |
|
3822 | def __exit__(self, exc_type, exc_val, exc_tb): | |
3823 | if exc_val is not None: |
|
3823 | if exc_val is not None: | |
3824 | log.error(traceback.format_exc(exc_tb)) |
|
3824 | log.error(traceback.format_exc(exc_tb)) | |
3825 | return None |
|
3825 | return None | |
3826 |
|
3826 | |||
3827 | self.set_pr_state(self._org_state) |
|
3827 | self.set_pr_state(self._org_state) | |
3828 | log.debug('StateLock: exiting set state context, setting state to: `%s`', |
|
3828 | log.debug('StateLock: exiting set state context, setting state to: `%s`', | |
3829 | self._org_state) |
|
3829 | self._org_state) | |
3830 | @property |
|
3830 | @property | |
3831 | def state(self): |
|
3831 | def state(self): | |
3832 | return self._current_state |
|
3832 | return self._current_state | |
3833 |
|
3833 | |||
3834 | def set_pr_state(self, pr_state): |
|
3834 | def set_pr_state(self, pr_state): | |
3835 | try: |
|
3835 | try: | |
3836 | self._pr.pull_request_state = pr_state |
|
3836 | self._pr.pull_request_state = pr_state | |
3837 | Session().add(self._pr) |
|
3837 | Session().add(self._pr) | |
3838 | Session().commit() |
|
3838 | Session().commit() | |
3839 | self._current_state = pr_state |
|
3839 | self._current_state = pr_state | |
3840 | except Exception: |
|
3840 | except Exception: | |
3841 | log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state) |
|
3841 | log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state) | |
3842 | raise |
|
3842 | raise | |
3843 |
|
3843 | |||
3844 | class _PullRequestBase(BaseModel): |
|
3844 | class _PullRequestBase(BaseModel): | |
3845 | """ |
|
3845 | """ | |
3846 | Common attributes of pull request and version entries. |
|
3846 | Common attributes of pull request and version entries. | |
3847 | """ |
|
3847 | """ | |
3848 |
|
3848 | |||
3849 | # .status values |
|
3849 | # .status values | |
3850 | STATUS_NEW = u'new' |
|
3850 | STATUS_NEW = u'new' | |
3851 | STATUS_OPEN = u'open' |
|
3851 | STATUS_OPEN = u'open' | |
3852 | STATUS_CLOSED = u'closed' |
|
3852 | STATUS_CLOSED = u'closed' | |
3853 |
|
3853 | |||
3854 | # available states |
|
3854 | # available states | |
3855 | STATE_CREATING = u'creating' |
|
3855 | STATE_CREATING = u'creating' | |
3856 | STATE_UPDATING = u'updating' |
|
3856 | STATE_UPDATING = u'updating' | |
3857 | STATE_MERGING = u'merging' |
|
3857 | STATE_MERGING = u'merging' | |
3858 | STATE_CREATED = u'created' |
|
3858 | STATE_CREATED = u'created' | |
3859 |
|
3859 | |||
3860 | title = Column('title', Unicode(255), nullable=True) |
|
3860 | title = Column('title', Unicode(255), nullable=True) | |
3861 | description = Column( |
|
3861 | description = Column( | |
3862 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), |
|
3862 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), | |
3863 | nullable=True) |
|
3863 | nullable=True) | |
3864 | description_renderer = Column('description_renderer', Unicode(64), nullable=True) |
|
3864 | description_renderer = Column('description_renderer', Unicode(64), nullable=True) | |
3865 |
|
3865 | |||
3866 | # new/open/closed status of pull request (not approve/reject/etc) |
|
3866 | # new/open/closed status of pull request (not approve/reject/etc) | |
3867 | status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW) |
|
3867 | status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW) | |
3868 | created_on = Column( |
|
3868 | created_on = Column( | |
3869 | 'created_on', DateTime(timezone=False), nullable=False, |
|
3869 | 'created_on', DateTime(timezone=False), nullable=False, | |
3870 | default=datetime.datetime.now) |
|
3870 | default=datetime.datetime.now) | |
3871 | updated_on = Column( |
|
3871 | updated_on = Column( | |
3872 | 'updated_on', DateTime(timezone=False), nullable=False, |
|
3872 | 'updated_on', DateTime(timezone=False), nullable=False, | |
3873 | default=datetime.datetime.now) |
|
3873 | default=datetime.datetime.now) | |
3874 |
|
3874 | |||
3875 | pull_request_state = Column("pull_request_state", String(255), nullable=True) |
|
3875 | pull_request_state = Column("pull_request_state", String(255), nullable=True) | |
3876 |
|
3876 | |||
3877 | @declared_attr |
|
3877 | @declared_attr | |
3878 | def user_id(cls): |
|
3878 | def user_id(cls): | |
3879 | return Column( |
|
3879 | return Column( | |
3880 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, |
|
3880 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
3881 | unique=None) |
|
3881 | unique=None) | |
3882 |
|
3882 | |||
3883 | # 500 revisions max |
|
3883 | # 500 revisions max | |
3884 | _revisions = Column( |
|
3884 | _revisions = Column( | |
3885 | 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql')) |
|
3885 | 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql')) | |
3886 |
|
3886 | |||
3887 | @declared_attr |
|
3887 | @declared_attr | |
3888 | def source_repo_id(cls): |
|
3888 | def source_repo_id(cls): | |
3889 | # TODO: dan: rename column to source_repo_id |
|
3889 | # TODO: dan: rename column to source_repo_id | |
3890 | return Column( |
|
3890 | return Column( | |
3891 | 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
3891 | 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
3892 | nullable=False) |
|
3892 | nullable=False) | |
3893 |
|
3893 | |||
3894 | _source_ref = Column('org_ref', Unicode(255), nullable=False) |
|
3894 | _source_ref = Column('org_ref', Unicode(255), nullable=False) | |
3895 |
|
3895 | |||
3896 | @hybrid_property |
|
3896 | @hybrid_property | |
3897 | def source_ref(self): |
|
3897 | def source_ref(self): | |
3898 | return self._source_ref |
|
3898 | return self._source_ref | |
3899 |
|
3899 | |||
3900 | @source_ref.setter |
|
3900 | @source_ref.setter | |
3901 | def source_ref(self, val): |
|
3901 | def source_ref(self, val): | |
3902 | parts = (val or '').split(':') |
|
3902 | parts = (val or '').split(':') | |
3903 | if len(parts) != 3: |
|
3903 | if len(parts) != 3: | |
3904 | raise ValueError( |
|
3904 | raise ValueError( | |
3905 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) |
|
3905 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
3906 | self._source_ref = safe_unicode(val) |
|
3906 | self._source_ref = safe_unicode(val) | |
3907 |
|
3907 | |||
3908 | _target_ref = Column('other_ref', Unicode(255), nullable=False) |
|
3908 | _target_ref = Column('other_ref', Unicode(255), nullable=False) | |
3909 |
|
3909 | |||
3910 | @hybrid_property |
|
3910 | @hybrid_property | |
3911 | def target_ref(self): |
|
3911 | def target_ref(self): | |
3912 | return self._target_ref |
|
3912 | return self._target_ref | |
3913 |
|
3913 | |||
3914 | @target_ref.setter |
|
3914 | @target_ref.setter | |
3915 | def target_ref(self, val): |
|
3915 | def target_ref(self, val): | |
3916 | parts = (val or '').split(':') |
|
3916 | parts = (val or '').split(':') | |
3917 | if len(parts) != 3: |
|
3917 | if len(parts) != 3: | |
3918 | raise ValueError( |
|
3918 | raise ValueError( | |
3919 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) |
|
3919 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
3920 | self._target_ref = safe_unicode(val) |
|
3920 | self._target_ref = safe_unicode(val) | |
3921 |
|
3921 | |||
3922 | @declared_attr |
|
3922 | @declared_attr | |
3923 | def target_repo_id(cls): |
|
3923 | def target_repo_id(cls): | |
3924 | # TODO: dan: rename column to target_repo_id |
|
3924 | # TODO: dan: rename column to target_repo_id | |
3925 | return Column( |
|
3925 | return Column( | |
3926 | 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
3926 | 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
3927 | nullable=False) |
|
3927 | nullable=False) | |
3928 |
|
3928 | |||
3929 | _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True) |
|
3929 | _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True) | |
3930 |
|
3930 | |||
3931 | # TODO: dan: rename column to last_merge_source_rev |
|
3931 | # TODO: dan: rename column to last_merge_source_rev | |
3932 | _last_merge_source_rev = Column( |
|
3932 | _last_merge_source_rev = Column( | |
3933 | 'last_merge_org_rev', String(40), nullable=True) |
|
3933 | 'last_merge_org_rev', String(40), nullable=True) | |
3934 | # TODO: dan: rename column to last_merge_target_rev |
|
3934 | # TODO: dan: rename column to last_merge_target_rev | |
3935 | _last_merge_target_rev = Column( |
|
3935 | _last_merge_target_rev = Column( | |
3936 | 'last_merge_other_rev', String(40), nullable=True) |
|
3936 | 'last_merge_other_rev', String(40), nullable=True) | |
3937 | _last_merge_status = Column('merge_status', Integer(), nullable=True) |
|
3937 | _last_merge_status = Column('merge_status', Integer(), nullable=True) | |
3938 | merge_rev = Column('merge_rev', String(40), nullable=True) |
|
3938 | merge_rev = Column('merge_rev', String(40), nullable=True) | |
3939 |
|
3939 | |||
3940 | reviewer_data = Column( |
|
3940 | reviewer_data = Column( | |
3941 | 'reviewer_data_json', MutationObj.as_mutable( |
|
3941 | 'reviewer_data_json', MutationObj.as_mutable( | |
3942 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) |
|
3942 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
3943 |
|
3943 | |||
3944 | @property |
|
3944 | @property | |
3945 | def reviewer_data_json(self): |
|
3945 | def reviewer_data_json(self): | |
3946 | return json.dumps(self.reviewer_data) |
|
3946 | return json.dumps(self.reviewer_data) | |
3947 |
|
3947 | |||
3948 | @hybrid_property |
|
3948 | @hybrid_property | |
3949 | def description_safe(self): |
|
3949 | def description_safe(self): | |
3950 | from rhodecode.lib import helpers as h |
|
3950 | from rhodecode.lib import helpers as h | |
3951 | return h.escape(self.description) |
|
3951 | return h.escape(self.description) | |
3952 |
|
3952 | |||
3953 | @hybrid_property |
|
3953 | @hybrid_property | |
3954 | def revisions(self): |
|
3954 | def revisions(self): | |
3955 | return self._revisions.split(':') if self._revisions else [] |
|
3955 | return self._revisions.split(':') if self._revisions else [] | |
3956 |
|
3956 | |||
3957 | @revisions.setter |
|
3957 | @revisions.setter | |
3958 | def revisions(self, val): |
|
3958 | def revisions(self, val): | |
3959 | self._revisions = u':'.join(val) |
|
3959 | self._revisions = u':'.join(val) | |
3960 |
|
3960 | |||
3961 | @hybrid_property |
|
3961 | @hybrid_property | |
3962 | def last_merge_status(self): |
|
3962 | def last_merge_status(self): | |
3963 | return safe_int(self._last_merge_status) |
|
3963 | return safe_int(self._last_merge_status) | |
3964 |
|
3964 | |||
3965 | @last_merge_status.setter |
|
3965 | @last_merge_status.setter | |
3966 | def last_merge_status(self, val): |
|
3966 | def last_merge_status(self, val): | |
3967 | self._last_merge_status = val |
|
3967 | self._last_merge_status = val | |
3968 |
|
3968 | |||
3969 | @declared_attr |
|
3969 | @declared_attr | |
3970 | def author(cls): |
|
3970 | def author(cls): | |
3971 | return relationship('User', lazy='joined') |
|
3971 | return relationship('User', lazy='joined') | |
3972 |
|
3972 | |||
3973 | @declared_attr |
|
3973 | @declared_attr | |
3974 | def source_repo(cls): |
|
3974 | def source_repo(cls): | |
3975 | return relationship( |
|
3975 | return relationship( | |
3976 | 'Repository', |
|
3976 | 'Repository', | |
3977 | primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__) |
|
3977 | primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__) | |
3978 |
|
3978 | |||
3979 | @property |
|
3979 | @property | |
3980 | def source_ref_parts(self): |
|
3980 | def source_ref_parts(self): | |
3981 | return self.unicode_to_reference(self.source_ref) |
|
3981 | return self.unicode_to_reference(self.source_ref) | |
3982 |
|
3982 | |||
3983 | @declared_attr |
|
3983 | @declared_attr | |
3984 | def target_repo(cls): |
|
3984 | def target_repo(cls): | |
3985 | return relationship( |
|
3985 | return relationship( | |
3986 | 'Repository', |
|
3986 | 'Repository', | |
3987 | primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__) |
|
3987 | primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__) | |
3988 |
|
3988 | |||
3989 | @property |
|
3989 | @property | |
3990 | def target_ref_parts(self): |
|
3990 | def target_ref_parts(self): | |
3991 | return self.unicode_to_reference(self.target_ref) |
|
3991 | return self.unicode_to_reference(self.target_ref) | |
3992 |
|
3992 | |||
3993 | @property |
|
3993 | @property | |
3994 | def shadow_merge_ref(self): |
|
3994 | def shadow_merge_ref(self): | |
3995 | return self.unicode_to_reference(self._shadow_merge_ref) |
|
3995 | return self.unicode_to_reference(self._shadow_merge_ref) | |
3996 |
|
3996 | |||
3997 | @shadow_merge_ref.setter |
|
3997 | @shadow_merge_ref.setter | |
3998 | def shadow_merge_ref(self, ref): |
|
3998 | def shadow_merge_ref(self, ref): | |
3999 | self._shadow_merge_ref = self.reference_to_unicode(ref) |
|
3999 | self._shadow_merge_ref = self.reference_to_unicode(ref) | |
4000 |
|
4000 | |||
4001 | @staticmethod |
|
4001 | @staticmethod | |
4002 | def unicode_to_reference(raw): |
|
4002 | def unicode_to_reference(raw): | |
4003 | """ |
|
4003 | """ | |
4004 | Convert a unicode (or string) to a reference object. |
|
4004 | Convert a unicode (or string) to a reference object. | |
4005 | If unicode evaluates to False it returns None. |
|
4005 | If unicode evaluates to False it returns None. | |
4006 | """ |
|
4006 | """ | |
4007 | if raw: |
|
4007 | if raw: | |
4008 | refs = raw.split(':') |
|
4008 | refs = raw.split(':') | |
4009 | return Reference(*refs) |
|
4009 | return Reference(*refs) | |
4010 | else: |
|
4010 | else: | |
4011 | return None |
|
4011 | return None | |
4012 |
|
4012 | |||
4013 | @staticmethod |
|
4013 | @staticmethod | |
4014 | def reference_to_unicode(ref): |
|
4014 | def reference_to_unicode(ref): | |
4015 | """ |
|
4015 | """ | |
4016 | Convert a reference object to unicode. |
|
4016 | Convert a reference object to unicode. | |
4017 | If reference is None it returns None. |
|
4017 | If reference is None it returns None. | |
4018 | """ |
|
4018 | """ | |
4019 | if ref: |
|
4019 | if ref: | |
4020 | return u':'.join(ref) |
|
4020 | return u':'.join(ref) | |
4021 | else: |
|
4021 | else: | |
4022 | return None |
|
4022 | return None | |
4023 |
|
4023 | |||
4024 | def get_api_data(self, with_merge_state=True): |
|
4024 | def get_api_data(self, with_merge_state=True): | |
4025 | from rhodecode.model.pull_request import PullRequestModel |
|
4025 | from rhodecode.model.pull_request import PullRequestModel | |
4026 |
|
4026 | |||
4027 | pull_request = self |
|
4027 | pull_request = self | |
4028 | if with_merge_state: |
|
4028 | if with_merge_state: | |
4029 | merge_status = PullRequestModel().merge_status(pull_request) |
|
4029 | merge_status = PullRequestModel().merge_status(pull_request) | |
4030 | merge_state = { |
|
4030 | merge_state = { | |
4031 | 'status': merge_status[0], |
|
4031 | 'status': merge_status[0], | |
4032 | 'message': safe_unicode(merge_status[1]), |
|
4032 | 'message': safe_unicode(merge_status[1]), | |
4033 | } |
|
4033 | } | |
4034 | else: |
|
4034 | else: | |
4035 | merge_state = {'status': 'not_available', |
|
4035 | merge_state = {'status': 'not_available', | |
4036 | 'message': 'not_available'} |
|
4036 | 'message': 'not_available'} | |
4037 |
|
4037 | |||
4038 | merge_data = { |
|
4038 | merge_data = { | |
4039 | 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request), |
|
4039 | 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request), | |
4040 | 'reference': ( |
|
4040 | 'reference': ( | |
4041 | pull_request.shadow_merge_ref._asdict() |
|
4041 | pull_request.shadow_merge_ref._asdict() | |
4042 | if pull_request.shadow_merge_ref else None), |
|
4042 | if pull_request.shadow_merge_ref else None), | |
4043 | } |
|
4043 | } | |
4044 |
|
4044 | |||
4045 | data = { |
|
4045 | data = { | |
4046 | 'pull_request_id': pull_request.pull_request_id, |
|
4046 | 'pull_request_id': pull_request.pull_request_id, | |
4047 | 'url': PullRequestModel().get_url(pull_request), |
|
4047 | 'url': PullRequestModel().get_url(pull_request), | |
4048 | 'title': pull_request.title, |
|
4048 | 'title': pull_request.title, | |
4049 | 'description': pull_request.description, |
|
4049 | 'description': pull_request.description, | |
4050 | 'status': pull_request.status, |
|
4050 | 'status': pull_request.status, | |
4051 | 'state': pull_request.pull_request_state, |
|
4051 | 'state': pull_request.pull_request_state, | |
4052 | 'created_on': pull_request.created_on, |
|
4052 | 'created_on': pull_request.created_on, | |
4053 | 'updated_on': pull_request.updated_on, |
|
4053 | 'updated_on': pull_request.updated_on, | |
4054 | 'commit_ids': pull_request.revisions, |
|
4054 | 'commit_ids': pull_request.revisions, | |
4055 | 'review_status': pull_request.calculated_review_status(), |
|
4055 | 'review_status': pull_request.calculated_review_status(), | |
4056 | 'mergeable': merge_state, |
|
4056 | 'mergeable': merge_state, | |
4057 | 'source': { |
|
4057 | 'source': { | |
4058 | 'clone_url': pull_request.source_repo.clone_url(), |
|
4058 | 'clone_url': pull_request.source_repo.clone_url(), | |
4059 | 'repository': pull_request.source_repo.repo_name, |
|
4059 | 'repository': pull_request.source_repo.repo_name, | |
4060 | 'reference': { |
|
4060 | 'reference': { | |
4061 | 'name': pull_request.source_ref_parts.name, |
|
4061 | 'name': pull_request.source_ref_parts.name, | |
4062 | 'type': pull_request.source_ref_parts.type, |
|
4062 | 'type': pull_request.source_ref_parts.type, | |
4063 | 'commit_id': pull_request.source_ref_parts.commit_id, |
|
4063 | 'commit_id': pull_request.source_ref_parts.commit_id, | |
4064 | }, |
|
4064 | }, | |
4065 | }, |
|
4065 | }, | |
4066 | 'target': { |
|
4066 | 'target': { | |
4067 | 'clone_url': pull_request.target_repo.clone_url(), |
|
4067 | 'clone_url': pull_request.target_repo.clone_url(), | |
4068 | 'repository': pull_request.target_repo.repo_name, |
|
4068 | 'repository': pull_request.target_repo.repo_name, | |
4069 | 'reference': { |
|
4069 | 'reference': { | |
4070 | 'name': pull_request.target_ref_parts.name, |
|
4070 | 'name': pull_request.target_ref_parts.name, | |
4071 | 'type': pull_request.target_ref_parts.type, |
|
4071 | 'type': pull_request.target_ref_parts.type, | |
4072 | 'commit_id': pull_request.target_ref_parts.commit_id, |
|
4072 | 'commit_id': pull_request.target_ref_parts.commit_id, | |
4073 | }, |
|
4073 | }, | |
4074 | }, |
|
4074 | }, | |
4075 | 'merge': merge_data, |
|
4075 | 'merge': merge_data, | |
4076 | 'author': pull_request.author.get_api_data(include_secrets=False, |
|
4076 | 'author': pull_request.author.get_api_data(include_secrets=False, | |
4077 | details='basic'), |
|
4077 | details='basic'), | |
4078 | 'reviewers': [ |
|
4078 | 'reviewers': [ | |
4079 | { |
|
4079 | { | |
4080 | 'user': reviewer.get_api_data(include_secrets=False, |
|
4080 | 'user': reviewer.get_api_data(include_secrets=False, | |
4081 | details='basic'), |
|
4081 | details='basic'), | |
4082 | 'reasons': reasons, |
|
4082 | 'reasons': reasons, | |
4083 | 'review_status': st[0][1].status if st else 'not_reviewed', |
|
4083 | 'review_status': st[0][1].status if st else 'not_reviewed', | |
4084 | } |
|
4084 | } | |
4085 | for obj, reviewer, reasons, mandatory, st in |
|
4085 | for obj, reviewer, reasons, mandatory, st in | |
4086 | pull_request.reviewers_statuses() |
|
4086 | pull_request.reviewers_statuses() | |
4087 | ] |
|
4087 | ] | |
4088 | } |
|
4088 | } | |
4089 |
|
4089 | |||
4090 | return data |
|
4090 | return data | |
4091 |
|
4091 | |||
4092 | def set_state(self, pull_request_state, final_state=None): |
|
4092 | def set_state(self, pull_request_state, final_state=None): | |
4093 | """ |
|
4093 | """ | |
4094 | # goes from initial state to updating to initial state. |
|
4094 | # goes from initial state to updating to initial state. | |
4095 | # initial state can be changed by specifying back_state= |
|
4095 | # initial state can be changed by specifying back_state= | |
4096 | with pull_request_obj.set_state(PullRequest.STATE_UPDATING): |
|
4096 | with pull_request_obj.set_state(PullRequest.STATE_UPDATING): | |
4097 | pull_request.merge() |
|
4097 | pull_request.merge() | |
4098 |
|
4098 | |||
4099 | :param pull_request_state: |
|
4099 | :param pull_request_state: | |
4100 | :param final_state: |
|
4100 | :param final_state: | |
4101 |
|
4101 | |||
4102 | """ |
|
4102 | """ | |
4103 |
|
4103 | |||
4104 | return _SetState(self, pull_request_state, back_state=final_state) |
|
4104 | return _SetState(self, pull_request_state, back_state=final_state) | |
4105 |
|
4105 | |||
4106 |
|
4106 | |||
4107 | class PullRequest(Base, _PullRequestBase): |
|
4107 | class PullRequest(Base, _PullRequestBase): | |
4108 | __tablename__ = 'pull_requests' |
|
4108 | __tablename__ = 'pull_requests' | |
4109 | __table_args__ = ( |
|
4109 | __table_args__ = ( | |
4110 | base_table_args, |
|
4110 | base_table_args, | |
4111 | ) |
|
4111 | ) | |
4112 |
|
4112 | |||
4113 | pull_request_id = Column( |
|
4113 | pull_request_id = Column( | |
4114 | 'pull_request_id', Integer(), nullable=False, primary_key=True) |
|
4114 | 'pull_request_id', Integer(), nullable=False, primary_key=True) | |
4115 |
|
4115 | |||
4116 | def __repr__(self): |
|
4116 | def __repr__(self): | |
4117 | if self.pull_request_id: |
|
4117 | if self.pull_request_id: | |
4118 | return '<DB:PullRequest #%s>' % self.pull_request_id |
|
4118 | return '<DB:PullRequest #%s>' % self.pull_request_id | |
4119 | else: |
|
4119 | else: | |
4120 | return '<DB:PullRequest at %#x>' % id(self) |
|
4120 | return '<DB:PullRequest at %#x>' % id(self) | |
4121 |
|
4121 | |||
4122 | reviewers = relationship('PullRequestReviewers', |
|
4122 | reviewers = relationship('PullRequestReviewers', | |
4123 | cascade="all, delete, delete-orphan") |
|
4123 | cascade="all, delete, delete-orphan") | |
4124 | statuses = relationship('ChangesetStatus', |
|
4124 | statuses = relationship('ChangesetStatus', | |
4125 | cascade="all, delete, delete-orphan") |
|
4125 | cascade="all, delete, delete-orphan") | |
4126 | comments = relationship('ChangesetComment', |
|
4126 | comments = relationship('ChangesetComment', | |
4127 | cascade="all, delete, delete-orphan") |
|
4127 | cascade="all, delete, delete-orphan") | |
4128 | versions = relationship('PullRequestVersion', |
|
4128 | versions = relationship('PullRequestVersion', | |
4129 | cascade="all, delete, delete-orphan", |
|
4129 | cascade="all, delete, delete-orphan", | |
4130 | lazy='dynamic') |
|
4130 | lazy='dynamic') | |
4131 |
|
4131 | |||
4132 | @classmethod |
|
4132 | @classmethod | |
4133 | def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj, |
|
4133 | def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj, | |
4134 | internal_methods=None): |
|
4134 | internal_methods=None): | |
4135 |
|
4135 | |||
4136 | class PullRequestDisplay(object): |
|
4136 | class PullRequestDisplay(object): | |
4137 | """ |
|
4137 | """ | |
4138 | Special object wrapper for showing PullRequest data via Versions |
|
4138 | Special object wrapper for showing PullRequest data via Versions | |
4139 | It mimics PR object as close as possible. This is read only object |
|
4139 | It mimics PR object as close as possible. This is read only object | |
4140 | just for display |
|
4140 | just for display | |
4141 | """ |
|
4141 | """ | |
4142 |
|
4142 | |||
4143 | def __init__(self, attrs, internal=None): |
|
4143 | def __init__(self, attrs, internal=None): | |
4144 | self.attrs = attrs |
|
4144 | self.attrs = attrs | |
4145 | # internal have priority over the given ones via attrs |
|
4145 | # internal have priority over the given ones via attrs | |
4146 | self.internal = internal or ['versions'] |
|
4146 | self.internal = internal or ['versions'] | |
4147 |
|
4147 | |||
4148 | def __getattr__(self, item): |
|
4148 | def __getattr__(self, item): | |
4149 | if item in self.internal: |
|
4149 | if item in self.internal: | |
4150 | return getattr(self, item) |
|
4150 | return getattr(self, item) | |
4151 | try: |
|
4151 | try: | |
4152 | return self.attrs[item] |
|
4152 | return self.attrs[item] | |
4153 | except KeyError: |
|
4153 | except KeyError: | |
4154 | raise AttributeError( |
|
4154 | raise AttributeError( | |
4155 | '%s object has no attribute %s' % (self, item)) |
|
4155 | '%s object has no attribute %s' % (self, item)) | |
4156 |
|
4156 | |||
4157 | def __repr__(self): |
|
4157 | def __repr__(self): | |
4158 | return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id') |
|
4158 | return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id') | |
4159 |
|
4159 | |||
4160 | def versions(self): |
|
4160 | def versions(self): | |
4161 | return pull_request_obj.versions.order_by( |
|
4161 | return pull_request_obj.versions.order_by( | |
4162 | PullRequestVersion.pull_request_version_id).all() |
|
4162 | PullRequestVersion.pull_request_version_id).all() | |
4163 |
|
4163 | |||
4164 | def is_closed(self): |
|
4164 | def is_closed(self): | |
4165 | return pull_request_obj.is_closed() |
|
4165 | return pull_request_obj.is_closed() | |
4166 |
|
4166 | |||
4167 | @property |
|
4167 | @property | |
4168 | def pull_request_version_id(self): |
|
4168 | def pull_request_version_id(self): | |
4169 | return getattr(pull_request_obj, 'pull_request_version_id', None) |
|
4169 | return getattr(pull_request_obj, 'pull_request_version_id', None) | |
4170 |
|
4170 | |||
4171 | attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False)) |
|
4171 | attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False)) | |
4172 |
|
4172 | |||
4173 | attrs.author = StrictAttributeDict( |
|
4173 | attrs.author = StrictAttributeDict( | |
4174 | pull_request_obj.author.get_api_data()) |
|
4174 | pull_request_obj.author.get_api_data()) | |
4175 | if pull_request_obj.target_repo: |
|
4175 | if pull_request_obj.target_repo: | |
4176 | attrs.target_repo = StrictAttributeDict( |
|
4176 | attrs.target_repo = StrictAttributeDict( | |
4177 | pull_request_obj.target_repo.get_api_data()) |
|
4177 | pull_request_obj.target_repo.get_api_data()) | |
4178 | attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url |
|
4178 | attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url | |
4179 |
|
4179 | |||
4180 | if pull_request_obj.source_repo: |
|
4180 | if pull_request_obj.source_repo: | |
4181 | attrs.source_repo = StrictAttributeDict( |
|
4181 | attrs.source_repo = StrictAttributeDict( | |
4182 | pull_request_obj.source_repo.get_api_data()) |
|
4182 | pull_request_obj.source_repo.get_api_data()) | |
4183 | attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url |
|
4183 | attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url | |
4184 |
|
4184 | |||
4185 | attrs.source_ref_parts = pull_request_obj.source_ref_parts |
|
4185 | attrs.source_ref_parts = pull_request_obj.source_ref_parts | |
4186 | attrs.target_ref_parts = pull_request_obj.target_ref_parts |
|
4186 | attrs.target_ref_parts = pull_request_obj.target_ref_parts | |
4187 | attrs.revisions = pull_request_obj.revisions |
|
4187 | attrs.revisions = pull_request_obj.revisions | |
4188 |
|
4188 | |||
4189 | attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref |
|
4189 | attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref | |
4190 | attrs.reviewer_data = org_pull_request_obj.reviewer_data |
|
4190 | attrs.reviewer_data = org_pull_request_obj.reviewer_data | |
4191 | attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json |
|
4191 | attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json | |
4192 |
|
4192 | |||
4193 | return PullRequestDisplay(attrs, internal=internal_methods) |
|
4193 | return PullRequestDisplay(attrs, internal=internal_methods) | |
4194 |
|
4194 | |||
4195 | def is_closed(self): |
|
4195 | def is_closed(self): | |
4196 | return self.status == self.STATUS_CLOSED |
|
4196 | return self.status == self.STATUS_CLOSED | |
4197 |
|
4197 | |||
4198 | def __json__(self): |
|
4198 | def __json__(self): | |
4199 | return { |
|
4199 | return { | |
4200 | 'revisions': self.revisions, |
|
4200 | 'revisions': self.revisions, | |
4201 | } |
|
4201 | } | |
4202 |
|
4202 | |||
4203 | def calculated_review_status(self): |
|
4203 | def calculated_review_status(self): | |
4204 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
4204 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
4205 | return ChangesetStatusModel().calculated_review_status(self) |
|
4205 | return ChangesetStatusModel().calculated_review_status(self) | |
4206 |
|
4206 | |||
4207 | def reviewers_statuses(self): |
|
4207 | def reviewers_statuses(self): | |
4208 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
4208 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
4209 | return ChangesetStatusModel().reviewers_statuses(self) |
|
4209 | return ChangesetStatusModel().reviewers_statuses(self) | |
4210 |
|
4210 | |||
4211 | @property |
|
4211 | @property | |
4212 | def workspace_id(self): |
|
4212 | def workspace_id(self): | |
4213 | from rhodecode.model.pull_request import PullRequestModel |
|
4213 | from rhodecode.model.pull_request import PullRequestModel | |
4214 | return PullRequestModel()._workspace_id(self) |
|
4214 | return PullRequestModel()._workspace_id(self) | |
4215 |
|
4215 | |||
4216 | def get_shadow_repo(self): |
|
4216 | def get_shadow_repo(self): | |
4217 | workspace_id = self.workspace_id |
|
4217 | workspace_id = self.workspace_id | |
4218 | shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id) |
|
4218 | shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id) | |
4219 | if os.path.isdir(shadow_repository_path): |
|
4219 | if os.path.isdir(shadow_repository_path): | |
4220 | vcs_obj = self.target_repo.scm_instance() |
|
4220 | vcs_obj = self.target_repo.scm_instance() | |
4221 | return vcs_obj.get_shadow_instance(shadow_repository_path) |
|
4221 | return vcs_obj.get_shadow_instance(shadow_repository_path) | |
4222 |
|
4222 | |||
4223 |
|
4223 | |||
4224 | class PullRequestVersion(Base, _PullRequestBase): |
|
4224 | class PullRequestVersion(Base, _PullRequestBase): | |
4225 | __tablename__ = 'pull_request_versions' |
|
4225 | __tablename__ = 'pull_request_versions' | |
4226 | __table_args__ = ( |
|
4226 | __table_args__ = ( | |
4227 | base_table_args, |
|
4227 | base_table_args, | |
4228 | ) |
|
4228 | ) | |
4229 |
|
4229 | |||
4230 | pull_request_version_id = Column( |
|
4230 | pull_request_version_id = Column( | |
4231 | 'pull_request_version_id', Integer(), nullable=False, primary_key=True) |
|
4231 | 'pull_request_version_id', Integer(), nullable=False, primary_key=True) | |
4232 | pull_request_id = Column( |
|
4232 | pull_request_id = Column( | |
4233 | 'pull_request_id', Integer(), |
|
4233 | 'pull_request_id', Integer(), | |
4234 | ForeignKey('pull_requests.pull_request_id'), nullable=False) |
|
4234 | ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
4235 | pull_request = relationship('PullRequest') |
|
4235 | pull_request = relationship('PullRequest') | |
4236 |
|
4236 | |||
4237 | def __repr__(self): |
|
4237 | def __repr__(self): | |
4238 | if self.pull_request_version_id: |
|
4238 | if self.pull_request_version_id: | |
4239 | return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id |
|
4239 | return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id | |
4240 | else: |
|
4240 | else: | |
4241 | return '<DB:PullRequestVersion at %#x>' % id(self) |
|
4241 | return '<DB:PullRequestVersion at %#x>' % id(self) | |
4242 |
|
4242 | |||
4243 | @property |
|
4243 | @property | |
4244 | def reviewers(self): |
|
4244 | def reviewers(self): | |
4245 | return self.pull_request.reviewers |
|
4245 | return self.pull_request.reviewers | |
4246 |
|
4246 | |||
4247 | @property |
|
4247 | @property | |
4248 | def versions(self): |
|
4248 | def versions(self): | |
4249 | return self.pull_request.versions |
|
4249 | return self.pull_request.versions | |
4250 |
|
4250 | |||
4251 | def is_closed(self): |
|
4251 | def is_closed(self): | |
4252 | # calculate from original |
|
4252 | # calculate from original | |
4253 | return self.pull_request.status == self.STATUS_CLOSED |
|
4253 | return self.pull_request.status == self.STATUS_CLOSED | |
4254 |
|
4254 | |||
4255 | def calculated_review_status(self): |
|
4255 | def calculated_review_status(self): | |
4256 | return self.pull_request.calculated_review_status() |
|
4256 | return self.pull_request.calculated_review_status() | |
4257 |
|
4257 | |||
4258 | def reviewers_statuses(self): |
|
4258 | def reviewers_statuses(self): | |
4259 | return self.pull_request.reviewers_statuses() |
|
4259 | return self.pull_request.reviewers_statuses() | |
4260 |
|
4260 | |||
4261 |
|
4261 | |||
4262 | class PullRequestReviewers(Base, BaseModel): |
|
4262 | class PullRequestReviewers(Base, BaseModel): | |
4263 | __tablename__ = 'pull_request_reviewers' |
|
4263 | __tablename__ = 'pull_request_reviewers' | |
4264 | __table_args__ = ( |
|
4264 | __table_args__ = ( | |
4265 | base_table_args, |
|
4265 | base_table_args, | |
4266 | ) |
|
4266 | ) | |
4267 |
|
4267 | |||
4268 | @hybrid_property |
|
4268 | @hybrid_property | |
4269 | def reasons(self): |
|
4269 | def reasons(self): | |
4270 | if not self._reasons: |
|
4270 | if not self._reasons: | |
4271 | return [] |
|
4271 | return [] | |
4272 | return self._reasons |
|
4272 | return self._reasons | |
4273 |
|
4273 | |||
4274 | @reasons.setter |
|
4274 | @reasons.setter | |
4275 | def reasons(self, val): |
|
4275 | def reasons(self, val): | |
4276 | val = val or [] |
|
4276 | val = val or [] | |
4277 | if any(not isinstance(x, compat.string_types) for x in val): |
|
4277 | if any(not isinstance(x, compat.string_types) for x in val): | |
4278 | raise Exception('invalid reasons type, must be list of strings') |
|
4278 | raise Exception('invalid reasons type, must be list of strings') | |
4279 | self._reasons = val |
|
4279 | self._reasons = val | |
4280 |
|
4280 | |||
4281 | pull_requests_reviewers_id = Column( |
|
4281 | pull_requests_reviewers_id = Column( | |
4282 | 'pull_requests_reviewers_id', Integer(), nullable=False, |
|
4282 | 'pull_requests_reviewers_id', Integer(), nullable=False, | |
4283 | primary_key=True) |
|
4283 | primary_key=True) | |
4284 | pull_request_id = Column( |
|
4284 | pull_request_id = Column( | |
4285 | "pull_request_id", Integer(), |
|
4285 | "pull_request_id", Integer(), | |
4286 | ForeignKey('pull_requests.pull_request_id'), nullable=False) |
|
4286 | ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
4287 | user_id = Column( |
|
4287 | user_id = Column( | |
4288 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4288 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=True) | |
4289 | _reasons = Column( |
|
4289 | _reasons = Column( | |
4290 | 'reason', MutationList.as_mutable( |
|
4290 | 'reason', MutationList.as_mutable( | |
4291 | JsonType('list', dialect_map=dict(mysql=UnicodeText(16384))))) |
|
4291 | JsonType('list', dialect_map=dict(mysql=UnicodeText(16384))))) | |
4292 |
|
4292 | |||
4293 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
4293 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
4294 | user = relationship('User') |
|
4294 | user = relationship('User') | |
4295 | pull_request = relationship('PullRequest') |
|
4295 | pull_request = relationship('PullRequest') | |
4296 |
|
4296 | |||
4297 | rule_data = Column( |
|
4297 | rule_data = Column( | |
4298 | 'rule_data_json', |
|
4298 | 'rule_data_json', | |
4299 | JsonType(dialect_map=dict(mysql=UnicodeText(16384)))) |
|
4299 | JsonType(dialect_map=dict(mysql=UnicodeText(16384)))) | |
4300 |
|
4300 | |||
4301 | def rule_user_group_data(self): |
|
4301 | def rule_user_group_data(self): | |
4302 | """ |
|
4302 | """ | |
4303 | Returns the voting user group rule data for this reviewer |
|
4303 | Returns the voting user group rule data for this reviewer | |
4304 | """ |
|
4304 | """ | |
4305 |
|
4305 | |||
4306 | if self.rule_data and 'vote_rule' in self.rule_data: |
|
4306 | if self.rule_data and 'vote_rule' in self.rule_data: | |
4307 | user_group_data = {} |
|
4307 | user_group_data = {} | |
4308 | if 'rule_user_group_entry_id' in self.rule_data: |
|
4308 | if 'rule_user_group_entry_id' in self.rule_data: | |
4309 | # means a group with voting rules ! |
|
4309 | # means a group with voting rules ! | |
4310 | user_group_data['id'] = self.rule_data['rule_user_group_entry_id'] |
|
4310 | user_group_data['id'] = self.rule_data['rule_user_group_entry_id'] | |
4311 | user_group_data['name'] = self.rule_data['rule_name'] |
|
4311 | user_group_data['name'] = self.rule_data['rule_name'] | |
4312 | user_group_data['vote_rule'] = self.rule_data['vote_rule'] |
|
4312 | user_group_data['vote_rule'] = self.rule_data['vote_rule'] | |
4313 |
|
4313 | |||
4314 | return user_group_data |
|
4314 | return user_group_data | |
4315 |
|
4315 | |||
4316 | def __unicode__(self): |
|
4316 | def __unicode__(self): | |
4317 | return u"<%s('id:%s')>" % (self.__class__.__name__, |
|
4317 | return u"<%s('id:%s')>" % (self.__class__.__name__, | |
4318 | self.pull_requests_reviewers_id) |
|
4318 | self.pull_requests_reviewers_id) | |
4319 |
|
4319 | |||
4320 |
|
4320 | |||
4321 | class Notification(Base, BaseModel): |
|
4321 | class Notification(Base, BaseModel): | |
4322 | __tablename__ = 'notifications' |
|
4322 | __tablename__ = 'notifications' | |
4323 | __table_args__ = ( |
|
4323 | __table_args__ = ( | |
4324 | Index('notification_type_idx', 'type'), |
|
4324 | Index('notification_type_idx', 'type'), | |
4325 | base_table_args, |
|
4325 | base_table_args, | |
4326 | ) |
|
4326 | ) | |
4327 |
|
4327 | |||
4328 | TYPE_CHANGESET_COMMENT = u'cs_comment' |
|
4328 | TYPE_CHANGESET_COMMENT = u'cs_comment' | |
4329 | TYPE_MESSAGE = u'message' |
|
4329 | TYPE_MESSAGE = u'message' | |
4330 | TYPE_MENTION = u'mention' |
|
4330 | TYPE_MENTION = u'mention' | |
4331 | TYPE_REGISTRATION = u'registration' |
|
4331 | TYPE_REGISTRATION = u'registration' | |
4332 | TYPE_PULL_REQUEST = u'pull_request' |
|
4332 | TYPE_PULL_REQUEST = u'pull_request' | |
4333 | TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment' |
|
4333 | TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment' | |
4334 |
|
4334 | |||
4335 | notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True) |
|
4335 | notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True) | |
4336 | subject = Column('subject', Unicode(512), nullable=True) |
|
4336 | subject = Column('subject', Unicode(512), nullable=True) | |
4337 | body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) |
|
4337 | body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) | |
4338 | created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4338 | created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True) | |
4339 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4339 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4340 | type_ = Column('type', Unicode(255)) |
|
4340 | type_ = Column('type', Unicode(255)) | |
4341 |
|
4341 | |||
4342 | created_by_user = relationship('User') |
|
4342 | created_by_user = relationship('User') | |
4343 | notifications_to_users = relationship('UserNotification', lazy='joined', |
|
4343 | notifications_to_users = relationship('UserNotification', lazy='joined', | |
4344 | cascade="all, delete, delete-orphan") |
|
4344 | cascade="all, delete, delete-orphan") | |
4345 |
|
4345 | |||
4346 | @property |
|
4346 | @property | |
4347 | def recipients(self): |
|
4347 | def recipients(self): | |
4348 | return [x.user for x in UserNotification.query()\ |
|
4348 | return [x.user for x in UserNotification.query()\ | |
4349 | .filter(UserNotification.notification == self)\ |
|
4349 | .filter(UserNotification.notification == self)\ | |
4350 | .order_by(UserNotification.user_id.asc()).all()] |
|
4350 | .order_by(UserNotification.user_id.asc()).all()] | |
4351 |
|
4351 | |||
4352 | @classmethod |
|
4352 | @classmethod | |
4353 | def create(cls, created_by, subject, body, recipients, type_=None): |
|
4353 | def create(cls, created_by, subject, body, recipients, type_=None): | |
4354 | if type_ is None: |
|
4354 | if type_ is None: | |
4355 | type_ = Notification.TYPE_MESSAGE |
|
4355 | type_ = Notification.TYPE_MESSAGE | |
4356 |
|
4356 | |||
4357 | notification = cls() |
|
4357 | notification = cls() | |
4358 | notification.created_by_user = created_by |
|
4358 | notification.created_by_user = created_by | |
4359 | notification.subject = subject |
|
4359 | notification.subject = subject | |
4360 | notification.body = body |
|
4360 | notification.body = body | |
4361 | notification.type_ = type_ |
|
4361 | notification.type_ = type_ | |
4362 | notification.created_on = datetime.datetime.now() |
|
4362 | notification.created_on = datetime.datetime.now() | |
4363 |
|
4363 | |||
4364 | # For each recipient link the created notification to his account |
|
4364 | # For each recipient link the created notification to his account | |
4365 | for u in recipients: |
|
4365 | for u in recipients: | |
4366 | assoc = UserNotification() |
|
4366 | assoc = UserNotification() | |
4367 | assoc.user_id = u.user_id |
|
4367 | assoc.user_id = u.user_id | |
4368 | assoc.notification = notification |
|
4368 | assoc.notification = notification | |
4369 |
|
4369 | |||
4370 | # if created_by is inside recipients mark his notification |
|
4370 | # if created_by is inside recipients mark his notification | |
4371 | # as read |
|
4371 | # as read | |
4372 | if u.user_id == created_by.user_id: |
|
4372 | if u.user_id == created_by.user_id: | |
4373 | assoc.read = True |
|
4373 | assoc.read = True | |
4374 | Session().add(assoc) |
|
4374 | Session().add(assoc) | |
4375 |
|
4375 | |||
4376 | Session().add(notification) |
|
4376 | Session().add(notification) | |
4377 |
|
4377 | |||
4378 | return notification |
|
4378 | return notification | |
4379 |
|
4379 | |||
4380 |
|
4380 | |||
4381 | class UserNotification(Base, BaseModel): |
|
4381 | class UserNotification(Base, BaseModel): | |
4382 | __tablename__ = 'user_to_notification' |
|
4382 | __tablename__ = 'user_to_notification' | |
4383 | __table_args__ = ( |
|
4383 | __table_args__ = ( | |
4384 | UniqueConstraint('user_id', 'notification_id'), |
|
4384 | UniqueConstraint('user_id', 'notification_id'), | |
4385 | base_table_args |
|
4385 | base_table_args | |
4386 | ) |
|
4386 | ) | |
4387 |
|
4387 | |||
4388 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) |
|
4388 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
4389 | notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True) |
|
4389 | notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True) | |
4390 | read = Column('read', Boolean, default=False) |
|
4390 | read = Column('read', Boolean, default=False) | |
4391 | sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None) |
|
4391 | sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None) | |
4392 |
|
4392 | |||
4393 | user = relationship('User', lazy="joined") |
|
4393 | user = relationship('User', lazy="joined") | |
4394 | notification = relationship('Notification', lazy="joined", |
|
4394 | notification = relationship('Notification', lazy="joined", | |
4395 | order_by=lambda: Notification.created_on.desc(),) |
|
4395 | order_by=lambda: Notification.created_on.desc(),) | |
4396 |
|
4396 | |||
4397 | def mark_as_read(self): |
|
4397 | def mark_as_read(self): | |
4398 | self.read = True |
|
4398 | self.read = True | |
4399 | Session().add(self) |
|
4399 | Session().add(self) | |
4400 |
|
4400 | |||
4401 |
|
4401 | |||
4402 | class Gist(Base, BaseModel): |
|
4402 | class Gist(Base, BaseModel): | |
4403 | __tablename__ = 'gists' |
|
4403 | __tablename__ = 'gists' | |
4404 | __table_args__ = ( |
|
4404 | __table_args__ = ( | |
4405 | Index('g_gist_access_id_idx', 'gist_access_id'), |
|
4405 | Index('g_gist_access_id_idx', 'gist_access_id'), | |
4406 | Index('g_created_on_idx', 'created_on'), |
|
4406 | Index('g_created_on_idx', 'created_on'), | |
4407 | base_table_args |
|
4407 | base_table_args | |
4408 | ) |
|
4408 | ) | |
4409 |
|
4409 | |||
4410 | GIST_PUBLIC = u'public' |
|
4410 | GIST_PUBLIC = u'public' | |
4411 | GIST_PRIVATE = u'private' |
|
4411 | GIST_PRIVATE = u'private' | |
4412 | DEFAULT_FILENAME = u'gistfile1.txt' |
|
4412 | DEFAULT_FILENAME = u'gistfile1.txt' | |
4413 |
|
4413 | |||
4414 | ACL_LEVEL_PUBLIC = u'acl_public' |
|
4414 | ACL_LEVEL_PUBLIC = u'acl_public' | |
4415 | ACL_LEVEL_PRIVATE = u'acl_private' |
|
4415 | ACL_LEVEL_PRIVATE = u'acl_private' | |
4416 |
|
4416 | |||
4417 | gist_id = Column('gist_id', Integer(), primary_key=True) |
|
4417 | gist_id = Column('gist_id', Integer(), primary_key=True) | |
4418 | gist_access_id = Column('gist_access_id', Unicode(250)) |
|
4418 | gist_access_id = Column('gist_access_id', Unicode(250)) | |
4419 | gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
4419 | gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
4420 | gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4420 | gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True) | |
4421 | gist_expires = Column('gist_expires', Float(53), nullable=False) |
|
4421 | gist_expires = Column('gist_expires', Float(53), nullable=False) | |
4422 | gist_type = Column('gist_type', Unicode(128), nullable=False) |
|
4422 | gist_type = Column('gist_type', Unicode(128), nullable=False) | |
4423 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4423 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4424 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4424 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4425 | acl_level = Column('acl_level', Unicode(128), nullable=True) |
|
4425 | acl_level = Column('acl_level', Unicode(128), nullable=True) | |
4426 |
|
4426 | |||
4427 | owner = relationship('User') |
|
4427 | owner = relationship('User') | |
4428 |
|
4428 | |||
4429 | def __repr__(self): |
|
4429 | def __repr__(self): | |
4430 | return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id) |
|
4430 | return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id) | |
4431 |
|
4431 | |||
4432 | @hybrid_property |
|
4432 | @hybrid_property | |
4433 | def description_safe(self): |
|
4433 | def description_safe(self): | |
4434 | from rhodecode.lib import helpers as h |
|
4434 | from rhodecode.lib import helpers as h | |
4435 | return h.escape(self.gist_description) |
|
4435 | return h.escape(self.gist_description) | |
4436 |
|
4436 | |||
4437 | @classmethod |
|
4437 | @classmethod | |
4438 | def get_or_404(cls, id_): |
|
4438 | def get_or_404(cls, id_): | |
4439 | from pyramid.httpexceptions import HTTPNotFound |
|
4439 | from pyramid.httpexceptions import HTTPNotFound | |
4440 |
|
4440 | |||
4441 | res = cls.query().filter(cls.gist_access_id == id_).scalar() |
|
4441 | res = cls.query().filter(cls.gist_access_id == id_).scalar() | |
4442 | if not res: |
|
4442 | if not res: | |
4443 | raise HTTPNotFound() |
|
4443 | raise HTTPNotFound() | |
4444 | return res |
|
4444 | return res | |
4445 |
|
4445 | |||
4446 | @classmethod |
|
4446 | @classmethod | |
4447 | def get_by_access_id(cls, gist_access_id): |
|
4447 | def get_by_access_id(cls, gist_access_id): | |
4448 | return cls.query().filter(cls.gist_access_id == gist_access_id).scalar() |
|
4448 | return cls.query().filter(cls.gist_access_id == gist_access_id).scalar() | |
4449 |
|
4449 | |||
4450 | def gist_url(self): |
|
4450 | def gist_url(self): | |
4451 | from rhodecode.model.gist import GistModel |
|
4451 | from rhodecode.model.gist import GistModel | |
4452 | return GistModel().get_url(self) |
|
4452 | return GistModel().get_url(self) | |
4453 |
|
4453 | |||
4454 | @classmethod |
|
4454 | @classmethod | |
4455 | def base_path(cls): |
|
4455 | def base_path(cls): | |
4456 | """ |
|
4456 | """ | |
4457 | Returns base path when all gists are stored |
|
4457 | Returns base path when all gists are stored | |
4458 |
|
4458 | |||
4459 | :param cls: |
|
4459 | :param cls: | |
4460 | """ |
|
4460 | """ | |
4461 | from rhodecode.model.gist import GIST_STORE_LOC |
|
4461 | from rhodecode.model.gist import GIST_STORE_LOC | |
4462 | q = Session().query(RhodeCodeUi)\ |
|
4462 | q = Session().query(RhodeCodeUi)\ | |
4463 | .filter(RhodeCodeUi.ui_key == URL_SEP) |
|
4463 | .filter(RhodeCodeUi.ui_key == URL_SEP) | |
4464 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) |
|
4464 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
4465 | return os.path.join(q.one().ui_value, GIST_STORE_LOC) |
|
4465 | return os.path.join(q.one().ui_value, GIST_STORE_LOC) | |
4466 |
|
4466 | |||
4467 | def get_api_data(self): |
|
4467 | def get_api_data(self): | |
4468 | """ |
|
4468 | """ | |
4469 | Common function for generating gist related data for API |
|
4469 | Common function for generating gist related data for API | |
4470 | """ |
|
4470 | """ | |
4471 | gist = self |
|
4471 | gist = self | |
4472 | data = { |
|
4472 | data = { | |
4473 | 'gist_id': gist.gist_id, |
|
4473 | 'gist_id': gist.gist_id, | |
4474 | 'type': gist.gist_type, |
|
4474 | 'type': gist.gist_type, | |
4475 | 'access_id': gist.gist_access_id, |
|
4475 | 'access_id': gist.gist_access_id, | |
4476 | 'description': gist.gist_description, |
|
4476 | 'description': gist.gist_description, | |
4477 | 'url': gist.gist_url(), |
|
4477 | 'url': gist.gist_url(), | |
4478 | 'expires': gist.gist_expires, |
|
4478 | 'expires': gist.gist_expires, | |
4479 | 'created_on': gist.created_on, |
|
4479 | 'created_on': gist.created_on, | |
4480 | 'modified_at': gist.modified_at, |
|
4480 | 'modified_at': gist.modified_at, | |
4481 | 'content': None, |
|
4481 | 'content': None, | |
4482 | 'acl_level': gist.acl_level, |
|
4482 | 'acl_level': gist.acl_level, | |
4483 | } |
|
4483 | } | |
4484 | return data |
|
4484 | return data | |
4485 |
|
4485 | |||
4486 | def __json__(self): |
|
4486 | def __json__(self): | |
4487 | data = dict( |
|
4487 | data = dict( | |
4488 | ) |
|
4488 | ) | |
4489 | data.update(self.get_api_data()) |
|
4489 | data.update(self.get_api_data()) | |
4490 | return data |
|
4490 | return data | |
4491 | # SCM functions |
|
4491 | # SCM functions | |
4492 |
|
4492 | |||
4493 | def scm_instance(self, **kwargs): |
|
4493 | def scm_instance(self, **kwargs): | |
4494 | """ |
|
4494 | """ | |
4495 | Get an instance of VCS Repository |
|
4495 | Get an instance of VCS Repository | |
4496 |
|
4496 | |||
4497 | :param kwargs: |
|
4497 | :param kwargs: | |
4498 | """ |
|
4498 | """ | |
4499 | from rhodecode.model.gist import GistModel |
|
4499 | from rhodecode.model.gist import GistModel | |
4500 | full_repo_path = os.path.join(self.base_path(), self.gist_access_id) |
|
4500 | full_repo_path = os.path.join(self.base_path(), self.gist_access_id) | |
4501 | return get_vcs_instance( |
|
4501 | return get_vcs_instance( | |
4502 | repo_path=safe_str(full_repo_path), create=False, |
|
4502 | repo_path=safe_str(full_repo_path), create=False, | |
4503 | _vcs_alias=GistModel.vcs_backend) |
|
4503 | _vcs_alias=GistModel.vcs_backend) | |
4504 |
|
4504 | |||
4505 |
|
4505 | |||
4506 | class ExternalIdentity(Base, BaseModel): |
|
4506 | class ExternalIdentity(Base, BaseModel): | |
4507 | __tablename__ = 'external_identities' |
|
4507 | __tablename__ = 'external_identities' | |
4508 | __table_args__ = ( |
|
4508 | __table_args__ = ( | |
4509 | Index('local_user_id_idx', 'local_user_id'), |
|
4509 | Index('local_user_id_idx', 'local_user_id'), | |
4510 | Index('external_id_idx', 'external_id'), |
|
4510 | Index('external_id_idx', 'external_id'), | |
4511 | base_table_args |
|
4511 | base_table_args | |
4512 | ) |
|
4512 | ) | |
4513 |
|
4513 | |||
4514 | external_id = Column('external_id', Unicode(255), default=u'', primary_key=True) |
|
4514 | external_id = Column('external_id', Unicode(255), default=u'', primary_key=True) | |
4515 | external_username = Column('external_username', Unicode(1024), default=u'') |
|
4515 | external_username = Column('external_username', Unicode(1024), default=u'') | |
4516 | local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) |
|
4516 | local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
4517 | provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True) |
|
4517 | provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True) | |
4518 | access_token = Column('access_token', String(1024), default=u'') |
|
4518 | access_token = Column('access_token', String(1024), default=u'') | |
4519 | alt_token = Column('alt_token', String(1024), default=u'') |
|
4519 | alt_token = Column('alt_token', String(1024), default=u'') | |
4520 | token_secret = Column('token_secret', String(1024), default=u'') |
|
4520 | token_secret = Column('token_secret', String(1024), default=u'') | |
4521 |
|
4521 | |||
4522 | @classmethod |
|
4522 | @classmethod | |
4523 | def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None): |
|
4523 | def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None): | |
4524 | """ |
|
4524 | """ | |
4525 | Returns ExternalIdentity instance based on search params |
|
4525 | Returns ExternalIdentity instance based on search params | |
4526 |
|
4526 | |||
4527 | :param external_id: |
|
4527 | :param external_id: | |
4528 | :param provider_name: |
|
4528 | :param provider_name: | |
4529 | :return: ExternalIdentity |
|
4529 | :return: ExternalIdentity | |
4530 | """ |
|
4530 | """ | |
4531 | query = cls.query() |
|
4531 | query = cls.query() | |
4532 | query = query.filter(cls.external_id == external_id) |
|
4532 | query = query.filter(cls.external_id == external_id) | |
4533 | query = query.filter(cls.provider_name == provider_name) |
|
4533 | query = query.filter(cls.provider_name == provider_name) | |
4534 | if local_user_id: |
|
4534 | if local_user_id: | |
4535 | query = query.filter(cls.local_user_id == local_user_id) |
|
4535 | query = query.filter(cls.local_user_id == local_user_id) | |
4536 | return query.first() |
|
4536 | return query.first() | |
4537 |
|
4537 | |||
4538 | @classmethod |
|
4538 | @classmethod | |
4539 | def user_by_external_id_and_provider(cls, external_id, provider_name): |
|
4539 | def user_by_external_id_and_provider(cls, external_id, provider_name): | |
4540 | """ |
|
4540 | """ | |
4541 | Returns User instance based on search params |
|
4541 | Returns User instance based on search params | |
4542 |
|
4542 | |||
4543 | :param external_id: |
|
4543 | :param external_id: | |
4544 | :param provider_name: |
|
4544 | :param provider_name: | |
4545 | :return: User |
|
4545 | :return: User | |
4546 | """ |
|
4546 | """ | |
4547 | query = User.query() |
|
4547 | query = User.query() | |
4548 | query = query.filter(cls.external_id == external_id) |
|
4548 | query = query.filter(cls.external_id == external_id) | |
4549 | query = query.filter(cls.provider_name == provider_name) |
|
4549 | query = query.filter(cls.provider_name == provider_name) | |
4550 | query = query.filter(User.user_id == cls.local_user_id) |
|
4550 | query = query.filter(User.user_id == cls.local_user_id) | |
4551 | return query.first() |
|
4551 | return query.first() | |
4552 |
|
4552 | |||
4553 | @classmethod |
|
4553 | @classmethod | |
4554 | def by_local_user_id(cls, local_user_id): |
|
4554 | def by_local_user_id(cls, local_user_id): | |
4555 | """ |
|
4555 | """ | |
4556 | Returns all tokens for user |
|
4556 | Returns all tokens for user | |
4557 |
|
4557 | |||
4558 | :param local_user_id: |
|
4558 | :param local_user_id: | |
4559 | :return: ExternalIdentity |
|
4559 | :return: ExternalIdentity | |
4560 | """ |
|
4560 | """ | |
4561 | query = cls.query() |
|
4561 | query = cls.query() | |
4562 | query = query.filter(cls.local_user_id == local_user_id) |
|
4562 | query = query.filter(cls.local_user_id == local_user_id) | |
4563 | return query |
|
4563 | return query | |
4564 |
|
4564 | |||
4565 | @classmethod |
|
4565 | @classmethod | |
4566 | def load_provider_plugin(cls, plugin_id): |
|
4566 | def load_provider_plugin(cls, plugin_id): | |
4567 | from rhodecode.authentication.base import loadplugin |
|
4567 | from rhodecode.authentication.base import loadplugin | |
4568 | _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id) |
|
4568 | _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id) | |
4569 | auth_plugin = loadplugin(_plugin_id) |
|
4569 | auth_plugin = loadplugin(_plugin_id) | |
4570 | return auth_plugin |
|
4570 | return auth_plugin | |
4571 |
|
4571 | |||
4572 |
|
4572 | |||
4573 | class Integration(Base, BaseModel): |
|
4573 | class Integration(Base, BaseModel): | |
4574 | __tablename__ = 'integrations' |
|
4574 | __tablename__ = 'integrations' | |
4575 | __table_args__ = ( |
|
4575 | __table_args__ = ( | |
4576 | base_table_args |
|
4576 | base_table_args | |
4577 | ) |
|
4577 | ) | |
4578 |
|
4578 | |||
4579 | integration_id = Column('integration_id', Integer(), primary_key=True) |
|
4579 | integration_id = Column('integration_id', Integer(), primary_key=True) | |
4580 | integration_type = Column('integration_type', String(255)) |
|
4580 | integration_type = Column('integration_type', String(255)) | |
4581 | enabled = Column('enabled', Boolean(), nullable=False) |
|
4581 | enabled = Column('enabled', Boolean(), nullable=False) | |
4582 | name = Column('name', String(255), nullable=False) |
|
4582 | name = Column('name', String(255), nullable=False) | |
4583 | child_repos_only = Column('child_repos_only', Boolean(), nullable=False, |
|
4583 | child_repos_only = Column('child_repos_only', Boolean(), nullable=False, | |
4584 | default=False) |
|
4584 | default=False) | |
4585 |
|
4585 | |||
4586 | settings = Column( |
|
4586 | settings = Column( | |
4587 | 'settings_json', MutationObj.as_mutable( |
|
4587 | 'settings_json', MutationObj.as_mutable( | |
4588 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) |
|
4588 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
4589 | repo_id = Column( |
|
4589 | repo_id = Column( | |
4590 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
4590 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
4591 | nullable=True, unique=None, default=None) |
|
4591 | nullable=True, unique=None, default=None) | |
4592 | repo = relationship('Repository', lazy='joined') |
|
4592 | repo = relationship('Repository', lazy='joined') | |
4593 |
|
4593 | |||
4594 | repo_group_id = Column( |
|
4594 | repo_group_id = Column( | |
4595 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), |
|
4595 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
4596 | nullable=True, unique=None, default=None) |
|
4596 | nullable=True, unique=None, default=None) | |
4597 | repo_group = relationship('RepoGroup', lazy='joined') |
|
4597 | repo_group = relationship('RepoGroup', lazy='joined') | |
4598 |
|
4598 | |||
4599 | @property |
|
4599 | @property | |
4600 | def scope(self): |
|
4600 | def scope(self): | |
4601 | if self.repo: |
|
4601 | if self.repo: | |
4602 | return repr(self.repo) |
|
4602 | return repr(self.repo) | |
4603 | if self.repo_group: |
|
4603 | if self.repo_group: | |
4604 | if self.child_repos_only: |
|
4604 | if self.child_repos_only: | |
4605 | return repr(self.repo_group) + ' (child repos only)' |
|
4605 | return repr(self.repo_group) + ' (child repos only)' | |
4606 | else: |
|
4606 | else: | |
4607 | return repr(self.repo_group) + ' (recursive)' |
|
4607 | return repr(self.repo_group) + ' (recursive)' | |
4608 | if self.child_repos_only: |
|
4608 | if self.child_repos_only: | |
4609 | return 'root_repos' |
|
4609 | return 'root_repos' | |
4610 | return 'global' |
|
4610 | return 'global' | |
4611 |
|
4611 | |||
4612 | def __repr__(self): |
|
4612 | def __repr__(self): | |
4613 | return '<Integration(%r, %r)>' % (self.integration_type, self.scope) |
|
4613 | return '<Integration(%r, %r)>' % (self.integration_type, self.scope) | |
4614 |
|
4614 | |||
4615 |
|
4615 | |||
4616 | class RepoReviewRuleUser(Base, BaseModel): |
|
4616 | class RepoReviewRuleUser(Base, BaseModel): | |
4617 | __tablename__ = 'repo_review_rules_users' |
|
4617 | __tablename__ = 'repo_review_rules_users' | |
4618 | __table_args__ = ( |
|
4618 | __table_args__ = ( | |
4619 | base_table_args |
|
4619 | base_table_args | |
4620 | ) |
|
4620 | ) | |
4621 |
|
4621 | |||
4622 | repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True) |
|
4622 | repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True) | |
4623 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) |
|
4623 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
4624 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False) |
|
4624 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False) | |
4625 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
4625 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
4626 | user = relationship('User') |
|
4626 | user = relationship('User') | |
4627 |
|
4627 | |||
4628 | def rule_data(self): |
|
4628 | def rule_data(self): | |
4629 | return { |
|
4629 | return { | |
4630 | 'mandatory': self.mandatory |
|
4630 | 'mandatory': self.mandatory | |
4631 | } |
|
4631 | } | |
4632 |
|
4632 | |||
4633 |
|
4633 | |||
4634 | class RepoReviewRuleUserGroup(Base, BaseModel): |
|
4634 | class RepoReviewRuleUserGroup(Base, BaseModel): | |
4635 | __tablename__ = 'repo_review_rules_users_groups' |
|
4635 | __tablename__ = 'repo_review_rules_users_groups' | |
4636 | __table_args__ = ( |
|
4636 | __table_args__ = ( | |
4637 | base_table_args |
|
4637 | base_table_args | |
4638 | ) |
|
4638 | ) | |
4639 |
|
4639 | |||
4640 | VOTE_RULE_ALL = -1 |
|
4640 | VOTE_RULE_ALL = -1 | |
4641 |
|
4641 | |||
4642 | repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True) |
|
4642 | repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True) | |
4643 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) |
|
4643 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
4644 | users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False) |
|
4644 | users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False) | |
4645 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
4645 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
4646 | vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL) |
|
4646 | vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL) | |
4647 | users_group = relationship('UserGroup') |
|
4647 | users_group = relationship('UserGroup') | |
4648 |
|
4648 | |||
4649 | def rule_data(self): |
|
4649 | def rule_data(self): | |
4650 | return { |
|
4650 | return { | |
4651 | 'mandatory': self.mandatory, |
|
4651 | 'mandatory': self.mandatory, | |
4652 | 'vote_rule': self.vote_rule |
|
4652 | 'vote_rule': self.vote_rule | |
4653 | } |
|
4653 | } | |
4654 |
|
4654 | |||
4655 | @property |
|
4655 | @property | |
4656 | def vote_rule_label(self): |
|
4656 | def vote_rule_label(self): | |
4657 | if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL: |
|
4657 | if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL: | |
4658 | return 'all must vote' |
|
4658 | return 'all must vote' | |
4659 | else: |
|
4659 | else: | |
4660 | return 'min. vote {}'.format(self.vote_rule) |
|
4660 | return 'min. vote {}'.format(self.vote_rule) | |
4661 |
|
4661 | |||
4662 |
|
4662 | |||
4663 | class RepoReviewRule(Base, BaseModel): |
|
4663 | class RepoReviewRule(Base, BaseModel): | |
4664 | __tablename__ = 'repo_review_rules' |
|
4664 | __tablename__ = 'repo_review_rules' | |
4665 | __table_args__ = ( |
|
4665 | __table_args__ = ( | |
4666 | base_table_args |
|
4666 | base_table_args | |
4667 | ) |
|
4667 | ) | |
4668 |
|
4668 | |||
4669 | repo_review_rule_id = Column( |
|
4669 | repo_review_rule_id = Column( | |
4670 | 'repo_review_rule_id', Integer(), primary_key=True) |
|
4670 | 'repo_review_rule_id', Integer(), primary_key=True) | |
4671 | repo_id = Column( |
|
4671 | repo_id = Column( | |
4672 | "repo_id", Integer(), ForeignKey('repositories.repo_id')) |
|
4672 | "repo_id", Integer(), ForeignKey('repositories.repo_id')) | |
4673 | repo = relationship('Repository', backref='review_rules') |
|
4673 | repo = relationship('Repository', backref='review_rules') | |
4674 |
|
4674 | |||
4675 | review_rule_name = Column('review_rule_name', String(255)) |
|
4675 | review_rule_name = Column('review_rule_name', String(255)) | |
4676 | _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob |
|
4676 | _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
4677 | _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob |
|
4677 | _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
4678 | _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob |
|
4678 | _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
4679 |
|
4679 | |||
4680 | use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False) |
|
4680 | use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False) | |
4681 | forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False) |
|
4681 | forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False) | |
4682 | forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False) |
|
4682 | forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False) | |
4683 | forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False) |
|
4683 | forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False) | |
4684 |
|
4684 | |||
4685 | rule_users = relationship('RepoReviewRuleUser') |
|
4685 | rule_users = relationship('RepoReviewRuleUser') | |
4686 | rule_user_groups = relationship('RepoReviewRuleUserGroup') |
|
4686 | rule_user_groups = relationship('RepoReviewRuleUserGroup') | |
4687 |
|
4687 | |||
4688 | def _validate_pattern(self, value): |
|
4688 | def _validate_pattern(self, value): | |
4689 | re.compile('^' + glob2re(value) + '$') |
|
4689 | re.compile('^' + glob2re(value) + '$') | |
4690 |
|
4690 | |||
4691 | @hybrid_property |
|
4691 | @hybrid_property | |
4692 | def source_branch_pattern(self): |
|
4692 | def source_branch_pattern(self): | |
4693 | return self._branch_pattern or '*' |
|
4693 | return self._branch_pattern or '*' | |
4694 |
|
4694 | |||
4695 | @source_branch_pattern.setter |
|
4695 | @source_branch_pattern.setter | |
4696 | def source_branch_pattern(self, value): |
|
4696 | def source_branch_pattern(self, value): | |
4697 | self._validate_pattern(value) |
|
4697 | self._validate_pattern(value) | |
4698 | self._branch_pattern = value or '*' |
|
4698 | self._branch_pattern = value or '*' | |
4699 |
|
4699 | |||
4700 | @hybrid_property |
|
4700 | @hybrid_property | |
4701 | def target_branch_pattern(self): |
|
4701 | def target_branch_pattern(self): | |
4702 | return self._target_branch_pattern or '*' |
|
4702 | return self._target_branch_pattern or '*' | |
4703 |
|
4703 | |||
4704 | @target_branch_pattern.setter |
|
4704 | @target_branch_pattern.setter | |
4705 | def target_branch_pattern(self, value): |
|
4705 | def target_branch_pattern(self, value): | |
4706 | self._validate_pattern(value) |
|
4706 | self._validate_pattern(value) | |
4707 | self._target_branch_pattern = value or '*' |
|
4707 | self._target_branch_pattern = value or '*' | |
4708 |
|
4708 | |||
4709 | @hybrid_property |
|
4709 | @hybrid_property | |
4710 | def file_pattern(self): |
|
4710 | def file_pattern(self): | |
4711 | return self._file_pattern or '*' |
|
4711 | return self._file_pattern or '*' | |
4712 |
|
4712 | |||
4713 | @file_pattern.setter |
|
4713 | @file_pattern.setter | |
4714 | def file_pattern(self, value): |
|
4714 | def file_pattern(self, value): | |
4715 | self._validate_pattern(value) |
|
4715 | self._validate_pattern(value) | |
4716 | self._file_pattern = value or '*' |
|
4716 | self._file_pattern = value or '*' | |
4717 |
|
4717 | |||
4718 | def matches(self, source_branch, target_branch, files_changed): |
|
4718 | def matches(self, source_branch, target_branch, files_changed): | |
4719 | """ |
|
4719 | """ | |
4720 | Check if this review rule matches a branch/files in a pull request |
|
4720 | Check if this review rule matches a branch/files in a pull request | |
4721 |
|
4721 | |||
4722 | :param source_branch: source branch name for the commit |
|
4722 | :param source_branch: source branch name for the commit | |
4723 | :param target_branch: target branch name for the commit |
|
4723 | :param target_branch: target branch name for the commit | |
4724 | :param files_changed: list of file paths changed in the pull request |
|
4724 | :param files_changed: list of file paths changed in the pull request | |
4725 | """ |
|
4725 | """ | |
4726 |
|
4726 | |||
4727 | source_branch = source_branch or '' |
|
4727 | source_branch = source_branch or '' | |
4728 | target_branch = target_branch or '' |
|
4728 | target_branch = target_branch or '' | |
4729 | files_changed = files_changed or [] |
|
4729 | files_changed = files_changed or [] | |
4730 |
|
4730 | |||
4731 | branch_matches = True |
|
4731 | branch_matches = True | |
4732 | if source_branch or target_branch: |
|
4732 | if source_branch or target_branch: | |
4733 | if self.source_branch_pattern == '*': |
|
4733 | if self.source_branch_pattern == '*': | |
4734 | source_branch_match = True |
|
4734 | source_branch_match = True | |
4735 | else: |
|
4735 | else: | |
4736 | if self.source_branch_pattern.startswith('re:'): |
|
4736 | if self.source_branch_pattern.startswith('re:'): | |
4737 | source_pattern = self.source_branch_pattern[3:] |
|
4737 | source_pattern = self.source_branch_pattern[3:] | |
4738 | else: |
|
4738 | else: | |
4739 | source_pattern = '^' + glob2re(self.source_branch_pattern) + '$' |
|
4739 | source_pattern = '^' + glob2re(self.source_branch_pattern) + '$' | |
4740 | source_branch_regex = re.compile(source_pattern) |
|
4740 | source_branch_regex = re.compile(source_pattern) | |
4741 | source_branch_match = bool(source_branch_regex.search(source_branch)) |
|
4741 | source_branch_match = bool(source_branch_regex.search(source_branch)) | |
4742 | if self.target_branch_pattern == '*': |
|
4742 | if self.target_branch_pattern == '*': | |
4743 | target_branch_match = True |
|
4743 | target_branch_match = True | |
4744 | else: |
|
4744 | else: | |
4745 | if self.target_branch_pattern.startswith('re:'): |
|
4745 | if self.target_branch_pattern.startswith('re:'): | |
4746 | target_pattern = self.target_branch_pattern[3:] |
|
4746 | target_pattern = self.target_branch_pattern[3:] | |
4747 | else: |
|
4747 | else: | |
4748 | target_pattern = '^' + glob2re(self.target_branch_pattern) + '$' |
|
4748 | target_pattern = '^' + glob2re(self.target_branch_pattern) + '$' | |
4749 | target_branch_regex = re.compile(target_pattern) |
|
4749 | target_branch_regex = re.compile(target_pattern) | |
4750 | target_branch_match = bool(target_branch_regex.search(target_branch)) |
|
4750 | target_branch_match = bool(target_branch_regex.search(target_branch)) | |
4751 |
|
4751 | |||
4752 | branch_matches = source_branch_match and target_branch_match |
|
4752 | branch_matches = source_branch_match and target_branch_match | |
4753 |
|
4753 | |||
4754 | files_matches = True |
|
4754 | files_matches = True | |
4755 | if self.file_pattern != '*': |
|
4755 | if self.file_pattern != '*': | |
4756 | files_matches = False |
|
4756 | files_matches = False | |
4757 | if self.file_pattern.startswith('re:'): |
|
4757 | if self.file_pattern.startswith('re:'): | |
4758 | file_pattern = self.file_pattern[3:] |
|
4758 | file_pattern = self.file_pattern[3:] | |
4759 | else: |
|
4759 | else: | |
4760 | file_pattern = glob2re(self.file_pattern) |
|
4760 | file_pattern = glob2re(self.file_pattern) | |
4761 | file_regex = re.compile(file_pattern) |
|
4761 | file_regex = re.compile(file_pattern) | |
4762 | for filename in files_changed: |
|
4762 | for filename in files_changed: | |
4763 | if file_regex.search(filename): |
|
4763 | if file_regex.search(filename): | |
4764 | files_matches = True |
|
4764 | files_matches = True | |
4765 | break |
|
4765 | break | |
4766 |
|
4766 | |||
4767 | return branch_matches and files_matches |
|
4767 | return branch_matches and files_matches | |
4768 |
|
4768 | |||
4769 | @property |
|
4769 | @property | |
4770 | def review_users(self): |
|
4770 | def review_users(self): | |
4771 | """ Returns the users which this rule applies to """ |
|
4771 | """ Returns the users which this rule applies to """ | |
4772 |
|
4772 | |||
4773 | users = collections.OrderedDict() |
|
4773 | users = collections.OrderedDict() | |
4774 |
|
4774 | |||
4775 | for rule_user in self.rule_users: |
|
4775 | for rule_user in self.rule_users: | |
4776 | if rule_user.user.active: |
|
4776 | if rule_user.user.active: | |
4777 | if rule_user.user not in users: |
|
4777 | if rule_user.user not in users: | |
4778 | users[rule_user.user.username] = { |
|
4778 | users[rule_user.user.username] = { | |
4779 | 'user': rule_user.user, |
|
4779 | 'user': rule_user.user, | |
4780 | 'source': 'user', |
|
4780 | 'source': 'user', | |
4781 | 'source_data': {}, |
|
4781 | 'source_data': {}, | |
4782 | 'data': rule_user.rule_data() |
|
4782 | 'data': rule_user.rule_data() | |
4783 | } |
|
4783 | } | |
4784 |
|
4784 | |||
4785 | for rule_user_group in self.rule_user_groups: |
|
4785 | for rule_user_group in self.rule_user_groups: | |
4786 | source_data = { |
|
4786 | source_data = { | |
4787 | 'user_group_id': rule_user_group.users_group.users_group_id, |
|
4787 | 'user_group_id': rule_user_group.users_group.users_group_id, | |
4788 | 'name': rule_user_group.users_group.users_group_name, |
|
4788 | 'name': rule_user_group.users_group.users_group_name, | |
4789 | 'members': len(rule_user_group.users_group.members) |
|
4789 | 'members': len(rule_user_group.users_group.members) | |
4790 | } |
|
4790 | } | |
4791 | for member in rule_user_group.users_group.members: |
|
4791 | for member in rule_user_group.users_group.members: | |
4792 | if member.user.active: |
|
4792 | if member.user.active: | |
4793 | key = member.user.username |
|
4793 | key = member.user.username | |
4794 | if key in users: |
|
4794 | if key in users: | |
4795 | # skip this member as we have him already |
|
4795 | # skip this member as we have him already | |
4796 | # this prevents from override the "first" matched |
|
4796 | # this prevents from override the "first" matched | |
4797 | # users with duplicates in multiple groups |
|
4797 | # users with duplicates in multiple groups | |
4798 | continue |
|
4798 | continue | |
4799 |
|
4799 | |||
4800 | users[key] = { |
|
4800 | users[key] = { | |
4801 | 'user': member.user, |
|
4801 | 'user': member.user, | |
4802 | 'source': 'user_group', |
|
4802 | 'source': 'user_group', | |
4803 | 'source_data': source_data, |
|
4803 | 'source_data': source_data, | |
4804 | 'data': rule_user_group.rule_data() |
|
4804 | 'data': rule_user_group.rule_data() | |
4805 | } |
|
4805 | } | |
4806 |
|
4806 | |||
4807 | return users |
|
4807 | return users | |
4808 |
|
4808 | |||
4809 | def user_group_vote_rule(self, user_id): |
|
4809 | def user_group_vote_rule(self, user_id): | |
4810 |
|
4810 | |||
4811 | rules = [] |
|
4811 | rules = [] | |
4812 | if not self.rule_user_groups: |
|
4812 | if not self.rule_user_groups: | |
4813 | return rules |
|
4813 | return rules | |
4814 |
|
4814 | |||
4815 | for user_group in self.rule_user_groups: |
|
4815 | for user_group in self.rule_user_groups: | |
4816 | user_group_members = [x.user_id for x in user_group.users_group.members] |
|
4816 | user_group_members = [x.user_id for x in user_group.users_group.members] | |
4817 | if user_id in user_group_members: |
|
4817 | if user_id in user_group_members: | |
4818 | rules.append(user_group) |
|
4818 | rules.append(user_group) | |
4819 | return rules |
|
4819 | return rules | |
4820 |
|
4820 | |||
4821 | def __repr__(self): |
|
4821 | def __repr__(self): | |
4822 | return '<RepoReviewerRule(id=%r, repo=%r)>' % ( |
|
4822 | return '<RepoReviewerRule(id=%r, repo=%r)>' % ( | |
4823 | self.repo_review_rule_id, self.repo) |
|
4823 | self.repo_review_rule_id, self.repo) | |
4824 |
|
4824 | |||
4825 |
|
4825 | |||
4826 | class ScheduleEntry(Base, BaseModel): |
|
4826 | class ScheduleEntry(Base, BaseModel): | |
4827 | __tablename__ = 'schedule_entries' |
|
4827 | __tablename__ = 'schedule_entries' | |
4828 | __table_args__ = ( |
|
4828 | __table_args__ = ( | |
4829 | UniqueConstraint('schedule_name', name='s_schedule_name_idx'), |
|
4829 | UniqueConstraint('schedule_name', name='s_schedule_name_idx'), | |
4830 | UniqueConstraint('task_uid', name='s_task_uid_idx'), |
|
4830 | UniqueConstraint('task_uid', name='s_task_uid_idx'), | |
4831 | base_table_args, |
|
4831 | base_table_args, | |
4832 | ) |
|
4832 | ) | |
4833 |
|
4833 | |||
4834 | schedule_types = ['crontab', 'timedelta', 'integer'] |
|
4834 | schedule_types = ['crontab', 'timedelta', 'integer'] | |
4835 | schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True) |
|
4835 | schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True) | |
4836 |
|
4836 | |||
4837 | schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None) |
|
4837 | schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None) | |
4838 | schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None) |
|
4838 | schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None) | |
4839 | schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True) |
|
4839 | schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True) | |
4840 |
|
4840 | |||
4841 | _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None) |
|
4841 | _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None) | |
4842 | schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT())))) |
|
4842 | schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT())))) | |
4843 |
|
4843 | |||
4844 | schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
4844 | schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
4845 | schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0) |
|
4845 | schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0) | |
4846 |
|
4846 | |||
4847 | # task |
|
4847 | # task | |
4848 | task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None) |
|
4848 | task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None) | |
4849 | task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None) |
|
4849 | task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None) | |
4850 | task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT())))) |
|
4850 | task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT())))) | |
4851 | task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT())))) |
|
4851 | task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT())))) | |
4852 |
|
4852 | |||
4853 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4853 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4854 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
4854 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
4855 |
|
4855 | |||
4856 | @hybrid_property |
|
4856 | @hybrid_property | |
4857 | def schedule_type(self): |
|
4857 | def schedule_type(self): | |
4858 | return self._schedule_type |
|
4858 | return self._schedule_type | |
4859 |
|
4859 | |||
4860 | @schedule_type.setter |
|
4860 | @schedule_type.setter | |
4861 | def schedule_type(self, val): |
|
4861 | def schedule_type(self, val): | |
4862 | if val not in self.schedule_types: |
|
4862 | if val not in self.schedule_types: | |
4863 | raise ValueError('Value must be on of `{}` and got `{}`'.format( |
|
4863 | raise ValueError('Value must be on of `{}` and got `{}`'.format( | |
4864 | val, self.schedule_type)) |
|
4864 | val, self.schedule_type)) | |
4865 |
|
4865 | |||
4866 | self._schedule_type = val |
|
4866 | self._schedule_type = val | |
4867 |
|
4867 | |||
4868 | @classmethod |
|
4868 | @classmethod | |
4869 | def get_uid(cls, obj): |
|
4869 | def get_uid(cls, obj): | |
4870 | args = obj.task_args |
|
4870 | args = obj.task_args | |
4871 | kwargs = obj.task_kwargs |
|
4871 | kwargs = obj.task_kwargs | |
4872 | if isinstance(args, JsonRaw): |
|
4872 | if isinstance(args, JsonRaw): | |
4873 | try: |
|
4873 | try: | |
4874 | args = json.loads(args) |
|
4874 | args = json.loads(args) | |
4875 | except ValueError: |
|
4875 | except ValueError: | |
4876 | args = tuple() |
|
4876 | args = tuple() | |
4877 |
|
4877 | |||
4878 | if isinstance(kwargs, JsonRaw): |
|
4878 | if isinstance(kwargs, JsonRaw): | |
4879 | try: |
|
4879 | try: | |
4880 | kwargs = json.loads(kwargs) |
|
4880 | kwargs = json.loads(kwargs) | |
4881 | except ValueError: |
|
4881 | except ValueError: | |
4882 | kwargs = dict() |
|
4882 | kwargs = dict() | |
4883 |
|
4883 | |||
4884 | dot_notation = obj.task_dot_notation |
|
4884 | dot_notation = obj.task_dot_notation | |
4885 | val = '.'.join(map(safe_str, [ |
|
4885 | val = '.'.join(map(safe_str, [ | |
4886 | sorted(dot_notation), args, sorted(kwargs.items())])) |
|
4886 | sorted(dot_notation), args, sorted(kwargs.items())])) | |
4887 | return hashlib.sha1(val).hexdigest() |
|
4887 | return hashlib.sha1(val).hexdigest() | |
4888 |
|
4888 | |||
4889 | @classmethod |
|
4889 | @classmethod | |
4890 | def get_by_schedule_name(cls, schedule_name): |
|
4890 | def get_by_schedule_name(cls, schedule_name): | |
4891 | return cls.query().filter(cls.schedule_name == schedule_name).scalar() |
|
4891 | return cls.query().filter(cls.schedule_name == schedule_name).scalar() | |
4892 |
|
4892 | |||
4893 | @classmethod |
|
4893 | @classmethod | |
4894 | def get_by_schedule_id(cls, schedule_id): |
|
4894 | def get_by_schedule_id(cls, schedule_id): | |
4895 | return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar() |
|
4895 | return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar() | |
4896 |
|
4896 | |||
4897 | @property |
|
4897 | @property | |
4898 | def task(self): |
|
4898 | def task(self): | |
4899 | return self.task_dot_notation |
|
4899 | return self.task_dot_notation | |
4900 |
|
4900 | |||
4901 | @property |
|
4901 | @property | |
4902 | def schedule(self): |
|
4902 | def schedule(self): | |
4903 | from rhodecode.lib.celerylib.utils import raw_2_schedule |
|
4903 | from rhodecode.lib.celerylib.utils import raw_2_schedule | |
4904 | schedule = raw_2_schedule(self.schedule_definition, self.schedule_type) |
|
4904 | schedule = raw_2_schedule(self.schedule_definition, self.schedule_type) | |
4905 | return schedule |
|
4905 | return schedule | |
4906 |
|
4906 | |||
4907 | @property |
|
4907 | @property | |
4908 | def args(self): |
|
4908 | def args(self): | |
4909 | try: |
|
4909 | try: | |
4910 | return list(self.task_args or []) |
|
4910 | return list(self.task_args or []) | |
4911 | except ValueError: |
|
4911 | except ValueError: | |
4912 | return list() |
|
4912 | return list() | |
4913 |
|
4913 | |||
4914 | @property |
|
4914 | @property | |
4915 | def kwargs(self): |
|
4915 | def kwargs(self): | |
4916 | try: |
|
4916 | try: | |
4917 | return dict(self.task_kwargs or {}) |
|
4917 | return dict(self.task_kwargs or {}) | |
4918 | except ValueError: |
|
4918 | except ValueError: | |
4919 | return dict() |
|
4919 | return dict() | |
4920 |
|
4920 | |||
4921 | def _as_raw(self, val): |
|
4921 | def _as_raw(self, val): | |
4922 | if hasattr(val, 'de_coerce'): |
|
4922 | if hasattr(val, 'de_coerce'): | |
4923 | val = val.de_coerce() |
|
4923 | val = val.de_coerce() | |
4924 | if val: |
|
4924 | if val: | |
4925 | val = json.dumps(val) |
|
4925 | val = json.dumps(val) | |
4926 |
|
4926 | |||
4927 | return val |
|
4927 | return val | |
4928 |
|
4928 | |||
4929 | @property |
|
4929 | @property | |
4930 | def schedule_definition_raw(self): |
|
4930 | def schedule_definition_raw(self): | |
4931 | return self._as_raw(self.schedule_definition) |
|
4931 | return self._as_raw(self.schedule_definition) | |
4932 |
|
4932 | |||
4933 | @property |
|
4933 | @property | |
4934 | def args_raw(self): |
|
4934 | def args_raw(self): | |
4935 | return self._as_raw(self.task_args) |
|
4935 | return self._as_raw(self.task_args) | |
4936 |
|
4936 | |||
4937 | @property |
|
4937 | @property | |
4938 | def kwargs_raw(self): |
|
4938 | def kwargs_raw(self): | |
4939 | return self._as_raw(self.task_kwargs) |
|
4939 | return self._as_raw(self.task_kwargs) | |
4940 |
|
4940 | |||
4941 | def __repr__(self): |
|
4941 | def __repr__(self): | |
4942 | return '<DB:ScheduleEntry({}:{})>'.format( |
|
4942 | return '<DB:ScheduleEntry({}:{})>'.format( | |
4943 | self.schedule_entry_id, self.schedule_name) |
|
4943 | self.schedule_entry_id, self.schedule_name) | |
4944 |
|
4944 | |||
4945 |
|
4945 | |||
4946 | @event.listens_for(ScheduleEntry, 'before_update') |
|
4946 | @event.listens_for(ScheduleEntry, 'before_update') | |
4947 | def update_task_uid(mapper, connection, target): |
|
4947 | def update_task_uid(mapper, connection, target): | |
4948 | target.task_uid = ScheduleEntry.get_uid(target) |
|
4948 | target.task_uid = ScheduleEntry.get_uid(target) | |
4949 |
|
4949 | |||
4950 |
|
4950 | |||
4951 | @event.listens_for(ScheduleEntry, 'before_insert') |
|
4951 | @event.listens_for(ScheduleEntry, 'before_insert') | |
4952 | def set_task_uid(mapper, connection, target): |
|
4952 | def set_task_uid(mapper, connection, target): | |
4953 | target.task_uid = ScheduleEntry.get_uid(target) |
|
4953 | target.task_uid = ScheduleEntry.get_uid(target) | |
4954 |
|
4954 | |||
4955 |
|
4955 | |||
4956 | class _BaseBranchPerms(BaseModel): |
|
4956 | class _BaseBranchPerms(BaseModel): | |
4957 | @classmethod |
|
4957 | @classmethod | |
4958 | def compute_hash(cls, value): |
|
4958 | def compute_hash(cls, value): | |
4959 | return sha1_safe(value) |
|
4959 | return sha1_safe(value) | |
4960 |
|
4960 | |||
4961 | @hybrid_property |
|
4961 | @hybrid_property | |
4962 | def branch_pattern(self): |
|
4962 | def branch_pattern(self): | |
4963 | return self._branch_pattern or '*' |
|
4963 | return self._branch_pattern or '*' | |
4964 |
|
4964 | |||
4965 | @hybrid_property |
|
4965 | @hybrid_property | |
4966 | def branch_hash(self): |
|
4966 | def branch_hash(self): | |
4967 | return self._branch_hash |
|
4967 | return self._branch_hash | |
4968 |
|
4968 | |||
4969 | def _validate_glob(self, value): |
|
4969 | def _validate_glob(self, value): | |
4970 | re.compile('^' + glob2re(value) + '$') |
|
4970 | re.compile('^' + glob2re(value) + '$') | |
4971 |
|
4971 | |||
4972 | @branch_pattern.setter |
|
4972 | @branch_pattern.setter | |
4973 | def branch_pattern(self, value): |
|
4973 | def branch_pattern(self, value): | |
4974 | self._validate_glob(value) |
|
4974 | self._validate_glob(value) | |
4975 | self._branch_pattern = value or '*' |
|
4975 | self._branch_pattern = value or '*' | |
4976 | # set the Hash when setting the branch pattern |
|
4976 | # set the Hash when setting the branch pattern | |
4977 | self._branch_hash = self.compute_hash(self._branch_pattern) |
|
4977 | self._branch_hash = self.compute_hash(self._branch_pattern) | |
4978 |
|
4978 | |||
4979 | def matches(self, branch): |
|
4979 | def matches(self, branch): | |
4980 | """ |
|
4980 | """ | |
4981 | Check if this the branch matches entry |
|
4981 | Check if this the branch matches entry | |
4982 |
|
4982 | |||
4983 | :param branch: branch name for the commit |
|
4983 | :param branch: branch name for the commit | |
4984 | """ |
|
4984 | """ | |
4985 |
|
4985 | |||
4986 | branch = branch or '' |
|
4986 | branch = branch or '' | |
4987 |
|
4987 | |||
4988 | branch_matches = True |
|
4988 | branch_matches = True | |
4989 | if branch: |
|
4989 | if branch: | |
4990 | branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$') |
|
4990 | branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$') | |
4991 | branch_matches = bool(branch_regex.search(branch)) |
|
4991 | branch_matches = bool(branch_regex.search(branch)) | |
4992 |
|
4992 | |||
4993 | return branch_matches |
|
4993 | return branch_matches | |
4994 |
|
4994 | |||
4995 |
|
4995 | |||
4996 | class UserToRepoBranchPermission(Base, _BaseBranchPerms): |
|
4996 | class UserToRepoBranchPermission(Base, _BaseBranchPerms): | |
4997 | __tablename__ = 'user_to_repo_branch_permissions' |
|
4997 | __tablename__ = 'user_to_repo_branch_permissions' | |
4998 | __table_args__ = ( |
|
4998 | __table_args__ = ( | |
4999 | {'extend_existing': True, 'mysql_engine': 'InnoDB', |
|
4999 | {'extend_existing': True, 'mysql_engine': 'InnoDB', | |
5000 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} |
|
5000 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} | |
5001 | ) |
|
5001 | ) | |
5002 |
|
5002 | |||
5003 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) |
|
5003 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
5004 |
|
5004 | |||
5005 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
5005 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
5006 | repo = relationship('Repository', backref='user_branch_perms') |
|
5006 | repo = relationship('Repository', backref='user_branch_perms') | |
5007 |
|
5007 | |||
5008 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
5008 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
5009 | permission = relationship('Permission') |
|
5009 | permission = relationship('Permission') | |
5010 |
|
5010 | |||
5011 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None) |
|
5011 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None) | |
5012 | user_repo_to_perm = relationship('UserRepoToPerm') |
|
5012 | user_repo_to_perm = relationship('UserRepoToPerm') | |
5013 |
|
5013 | |||
5014 | rule_order = Column('rule_order', Integer(), nullable=False) |
|
5014 | rule_order = Column('rule_order', Integer(), nullable=False) | |
5015 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob |
|
5015 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob | |
5016 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) |
|
5016 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
5017 |
|
5017 | |||
5018 | def __unicode__(self): |
|
5018 | def __unicode__(self): | |
5019 | return u'<UserBranchPermission(%s => %r)>' % ( |
|
5019 | return u'<UserBranchPermission(%s => %r)>' % ( | |
5020 | self.user_repo_to_perm, self.branch_pattern) |
|
5020 | self.user_repo_to_perm, self.branch_pattern) | |
5021 |
|
5021 | |||
5022 |
|
5022 | |||
5023 | class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms): |
|
5023 | class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms): | |
5024 | __tablename__ = 'user_group_to_repo_branch_permissions' |
|
5024 | __tablename__ = 'user_group_to_repo_branch_permissions' | |
5025 | __table_args__ = ( |
|
5025 | __table_args__ = ( | |
5026 | {'extend_existing': True, 'mysql_engine': 'InnoDB', |
|
5026 | {'extend_existing': True, 'mysql_engine': 'InnoDB', | |
5027 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} |
|
5027 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} | |
5028 | ) |
|
5028 | ) | |
5029 |
|
5029 | |||
5030 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) |
|
5030 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
5031 |
|
5031 | |||
5032 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
5032 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
5033 | repo = relationship('Repository', backref='user_group_branch_perms') |
|
5033 | repo = relationship('Repository', backref='user_group_branch_perms') | |
5034 |
|
5034 | |||
5035 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
5035 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
5036 | permission = relationship('Permission') |
|
5036 | permission = relationship('Permission') | |
5037 |
|
5037 | |||
5038 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None) |
|
5038 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None) | |
5039 | user_group_repo_to_perm = relationship('UserGroupRepoToPerm') |
|
5039 | user_group_repo_to_perm = relationship('UserGroupRepoToPerm') | |
5040 |
|
5040 | |||
5041 | rule_order = Column('rule_order', Integer(), nullable=False) |
|
5041 | rule_order = Column('rule_order', Integer(), nullable=False) | |
5042 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob |
|
5042 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob | |
5043 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) |
|
5043 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
5044 |
|
5044 | |||
5045 | def __unicode__(self): |
|
5045 | def __unicode__(self): | |
5046 | return u'<UserBranchPermission(%s => %r)>' % ( |
|
5046 | return u'<UserBranchPermission(%s => %r)>' % ( | |
5047 | self.user_group_repo_to_perm, self.branch_pattern) |
|
5047 | self.user_group_repo_to_perm, self.branch_pattern) | |
5048 |
|
5048 | |||
5049 |
|
5049 | |||
5050 | class UserBookmark(Base, BaseModel): |
|
5050 | class UserBookmark(Base, BaseModel): | |
5051 | __tablename__ = 'user_bookmarks' |
|
5051 | __tablename__ = 'user_bookmarks' | |
5052 | __table_args__ = ( |
|
5052 | __table_args__ = ( | |
5053 | UniqueConstraint('user_id', 'bookmark_repo_id'), |
|
5053 | UniqueConstraint('user_id', 'bookmark_repo_id'), | |
5054 | UniqueConstraint('user_id', 'bookmark_repo_group_id'), |
|
5054 | UniqueConstraint('user_id', 'bookmark_repo_group_id'), | |
5055 | UniqueConstraint('user_id', 'bookmark_position'), |
|
5055 | UniqueConstraint('user_id', 'bookmark_position'), | |
5056 | base_table_args |
|
5056 | base_table_args | |
5057 | ) |
|
5057 | ) | |
5058 |
|
5058 | |||
5059 | user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
5059 | user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
5060 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
5060 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
5061 | position = Column("bookmark_position", Integer(), nullable=False) |
|
5061 | position = Column("bookmark_position", Integer(), nullable=False) | |
5062 | title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None) |
|
5062 | title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None) | |
5063 | redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None) |
|
5063 | redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None) | |
5064 | created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5064 | created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5065 |
|
5065 | |||
5066 | bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None) |
|
5066 | bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None) | |
5067 | bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None) |
|
5067 | bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None) | |
5068 |
|
5068 | |||
5069 | user = relationship("User") |
|
5069 | user = relationship("User") | |
5070 |
|
5070 | |||
5071 | repository = relationship("Repository") |
|
5071 | repository = relationship("Repository") | |
5072 | repository_group = relationship("RepoGroup") |
|
5072 | repository_group = relationship("RepoGroup") | |
5073 |
|
5073 | |||
5074 | @classmethod |
|
5074 | @classmethod | |
5075 | def get_by_position_for_user(cls, position, user_id): |
|
5075 | def get_by_position_for_user(cls, position, user_id): | |
5076 | return cls.query() \ |
|
5076 | return cls.query() \ | |
5077 | .filter(UserBookmark.user_id == user_id) \ |
|
5077 | .filter(UserBookmark.user_id == user_id) \ | |
5078 | .filter(UserBookmark.position == position).scalar() |
|
5078 | .filter(UserBookmark.position == position).scalar() | |
5079 |
|
5079 | |||
5080 | @classmethod |
|
5080 | @classmethod | |
5081 | def get_bookmarks_for_user(cls, user_id): |
|
5081 | def get_bookmarks_for_user(cls, user_id): | |
5082 | return cls.query() \ |
|
5082 | return cls.query() \ | |
5083 | .filter(UserBookmark.user_id == user_id) \ |
|
5083 | .filter(UserBookmark.user_id == user_id) \ | |
5084 | .options(joinedload(UserBookmark.repository)) \ |
|
5084 | .options(joinedload(UserBookmark.repository)) \ | |
5085 | .options(joinedload(UserBookmark.repository_group)) \ |
|
5085 | .options(joinedload(UserBookmark.repository_group)) \ | |
5086 | .order_by(UserBookmark.position.asc()) \ |
|
5086 | .order_by(UserBookmark.position.asc()) \ | |
5087 | .all() |
|
5087 | .all() | |
5088 |
|
5088 | |||
5089 | def __unicode__(self): |
|
5089 | def __unicode__(self): | |
5090 | return u'<UserBookmark(%d @ %r)>' % (self.position, self.redirect_url) |
|
5090 | return u'<UserBookmark(%d @ %r)>' % (self.position, self.redirect_url) | |
5091 |
|
5091 | |||
5092 |
|
5092 | |||
5093 | class FileStore(Base, BaseModel): |
|
5093 | class FileStore(Base, BaseModel): | |
5094 | __tablename__ = 'file_store' |
|
5094 | __tablename__ = 'file_store' | |
5095 | __table_args__ = ( |
|
5095 | __table_args__ = ( | |
5096 | base_table_args |
|
5096 | base_table_args | |
5097 | ) |
|
5097 | ) | |
5098 |
|
5098 | |||
5099 | file_store_id = Column('file_store_id', Integer(), primary_key=True) |
|
5099 | file_store_id = Column('file_store_id', Integer(), primary_key=True) | |
5100 | file_uid = Column('file_uid', String(1024), nullable=False) |
|
5100 | file_uid = Column('file_uid', String(1024), nullable=False) | |
5101 | file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True) |
|
5101 | file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True) | |
5102 | file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True) |
|
5102 | file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True) | |
5103 | file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False) |
|
5103 | file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False) | |
5104 |
|
5104 | |||
5105 | # sha256 hash |
|
5105 | # sha256 hash | |
5106 | file_hash = Column('file_hash', String(512), nullable=False) |
|
5106 | file_hash = Column('file_hash', String(512), nullable=False) | |
5107 | file_size = Column('file_size', Integer(), nullable=False) |
|
5107 | file_size = Column('file_size', Integer(), nullable=False) | |
5108 |
|
5108 | |||
5109 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5109 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5110 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True) |
|
5110 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True) | |
5111 | accessed_count = Column('accessed_count', Integer(), default=0) |
|
5111 | accessed_count = Column('accessed_count', Integer(), default=0) | |
5112 |
|
5112 | |||
5113 | enabled = Column('enabled', Boolean(), nullable=False, default=True) |
|
5113 | enabled = Column('enabled', Boolean(), nullable=False, default=True) | |
5114 |
|
5114 | |||
5115 | # if repo/repo_group reference is set, check for permissions |
|
5115 | # if repo/repo_group reference is set, check for permissions | |
5116 | check_acl = Column('check_acl', Boolean(), nullable=False, default=True) |
|
5116 | check_acl = Column('check_acl', Boolean(), nullable=False, default=True) | |
5117 |
|
5117 | |||
5118 |
# hidden defines an attach |
|
5118 | # hidden defines an attachment that should be hidden from showing in artifact listing | |
5119 | hidden = Column('hidden', Boolean(), nullable=False, default=False) |
|
5119 | hidden = Column('hidden', Boolean(), nullable=False, default=False) | |
5120 |
|
5120 | |||
5121 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) |
|
5121 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
5122 | upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id') |
|
5122 | upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id') | |
5123 |
|
5123 | |||
5124 | # scope limited to user, which requester have access to |
|
5124 | # scope limited to user, which requester have access to | |
5125 | scope_user_id = Column( |
|
5125 | scope_user_id = Column( | |
5126 | 'scope_user_id', Integer(), ForeignKey('users.user_id'), |
|
5126 | 'scope_user_id', Integer(), ForeignKey('users.user_id'), | |
5127 | nullable=True, unique=None, default=None) |
|
5127 | nullable=True, unique=None, default=None) | |
5128 | user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id') |
|
5128 | user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id') | |
5129 |
|
5129 | |||
5130 | # scope limited to user group, which requester have access to |
|
5130 | # scope limited to user group, which requester have access to | |
5131 | scope_user_group_id = Column( |
|
5131 | scope_user_group_id = Column( | |
5132 | 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'), |
|
5132 | 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'), | |
5133 | nullable=True, unique=None, default=None) |
|
5133 | nullable=True, unique=None, default=None) | |
5134 | user_group = relationship('UserGroup', lazy='joined') |
|
5134 | user_group = relationship('UserGroup', lazy='joined') | |
5135 |
|
5135 | |||
5136 | # scope limited to repo, which requester have access to |
|
5136 | # scope limited to repo, which requester have access to | |
5137 | scope_repo_id = Column( |
|
5137 | scope_repo_id = Column( | |
5138 | 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
5138 | 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
5139 | nullable=True, unique=None, default=None) |
|
5139 | nullable=True, unique=None, default=None) | |
5140 | repo = relationship('Repository', lazy='joined') |
|
5140 | repo = relationship('Repository', lazy='joined') | |
5141 |
|
5141 | |||
5142 | # scope limited to repo group, which requester have access to |
|
5142 | # scope limited to repo group, which requester have access to | |
5143 | scope_repo_group_id = Column( |
|
5143 | scope_repo_group_id = Column( | |
5144 | 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'), |
|
5144 | 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
5145 | nullable=True, unique=None, default=None) |
|
5145 | nullable=True, unique=None, default=None) | |
5146 | repo_group = relationship('RepoGroup', lazy='joined') |
|
5146 | repo_group = relationship('RepoGroup', lazy='joined') | |
5147 |
|
5147 | |||
5148 | @classmethod |
|
5148 | @classmethod | |
5149 | def create(cls, file_uid, filename, file_hash, file_size, file_display_name='', |
|
5149 | def create(cls, file_uid, filename, file_hash, file_size, file_display_name='', | |
5150 |
file_description='', enabled=True, check_acl=True, |
|
5150 | file_description='', enabled=True, hidden=False, check_acl=True, | |
5151 | scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None): |
|
5151 | user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None): | |
5152 |
|
5152 | |||
5153 | store_entry = FileStore() |
|
5153 | store_entry = FileStore() | |
5154 | store_entry.file_uid = file_uid |
|
5154 | store_entry.file_uid = file_uid | |
5155 | store_entry.file_display_name = file_display_name |
|
5155 | store_entry.file_display_name = file_display_name | |
5156 | store_entry.file_org_name = filename |
|
5156 | store_entry.file_org_name = filename | |
5157 | store_entry.file_size = file_size |
|
5157 | store_entry.file_size = file_size | |
5158 | store_entry.file_hash = file_hash |
|
5158 | store_entry.file_hash = file_hash | |
5159 | store_entry.file_description = file_description |
|
5159 | store_entry.file_description = file_description | |
5160 |
|
5160 | |||
5161 | store_entry.check_acl = check_acl |
|
5161 | store_entry.check_acl = check_acl | |
5162 | store_entry.enabled = enabled |
|
5162 | store_entry.enabled = enabled | |
|
5163 | store_entry.hidden = hidden | |||
5163 |
|
5164 | |||
5164 | store_entry.user_id = user_id |
|
5165 | store_entry.user_id = user_id | |
5165 | store_entry.scope_user_id = scope_user_id |
|
5166 | store_entry.scope_user_id = scope_user_id | |
5166 | store_entry.scope_repo_id = scope_repo_id |
|
5167 | store_entry.scope_repo_id = scope_repo_id | |
5167 | store_entry.scope_repo_group_id = scope_repo_group_id |
|
5168 | store_entry.scope_repo_group_id = scope_repo_group_id | |
|
5169 | ||||
5168 | return store_entry |
|
5170 | return store_entry | |
5169 |
|
5171 | |||
5170 | @classmethod |
|
5172 | @classmethod | |
5171 | def bump_access_counter(cls, file_uid, commit=True): |
|
5173 | def bump_access_counter(cls, file_uid, commit=True): | |
5172 | FileStore().query()\ |
|
5174 | FileStore().query()\ | |
5173 | .filter(FileStore.file_uid == file_uid)\ |
|
5175 | .filter(FileStore.file_uid == file_uid)\ | |
5174 | .update({FileStore.accessed_count: (FileStore.accessed_count + 1), |
|
5176 | .update({FileStore.accessed_count: (FileStore.accessed_count + 1), | |
5175 | FileStore.accessed_on: datetime.datetime.now()}) |
|
5177 | FileStore.accessed_on: datetime.datetime.now()}) | |
5176 | if commit: |
|
5178 | if commit: | |
5177 | Session().commit() |
|
5179 | Session().commit() | |
5178 |
|
5180 | |||
5179 | def __repr__(self): |
|
5181 | def __repr__(self): | |
5180 | return '<FileStore({})>'.format(self.file_store_id) |
|
5182 | return '<FileStore({})>'.format(self.file_store_id) | |
5181 |
|
5183 | |||
5182 |
|
5184 | |||
5183 | class DbMigrateVersion(Base, BaseModel): |
|
5185 | class DbMigrateVersion(Base, BaseModel): | |
5184 | __tablename__ = 'db_migrate_version' |
|
5186 | __tablename__ = 'db_migrate_version' | |
5185 | __table_args__ = ( |
|
5187 | __table_args__ = ( | |
5186 | base_table_args, |
|
5188 | base_table_args, | |
5187 | ) |
|
5189 | ) | |
5188 |
|
5190 | |||
5189 | repository_id = Column('repository_id', String(250), primary_key=True) |
|
5191 | repository_id = Column('repository_id', String(250), primary_key=True) | |
5190 | repository_path = Column('repository_path', Text) |
|
5192 | repository_path = Column('repository_path', Text) | |
5191 | version = Column('version', Integer) |
|
5193 | version = Column('version', Integer) | |
5192 |
|
5194 | |||
5193 | @classmethod |
|
5195 | @classmethod | |
5194 | def set_version(cls, version): |
|
5196 | def set_version(cls, version): | |
5195 | """ |
|
5197 | """ | |
5196 | Helper for forcing a different version, usually for debugging purposes via ishell. |
|
5198 | Helper for forcing a different version, usually for debugging purposes via ishell. | |
5197 | """ |
|
5199 | """ | |
5198 | ver = DbMigrateVersion.query().first() |
|
5200 | ver = DbMigrateVersion.query().first() | |
5199 | ver.version = version |
|
5201 | ver.version = version | |
5200 | Session().commit() |
|
5202 | Session().commit() | |
5201 |
|
5203 | |||
5202 |
|
5204 | |||
5203 | class DbSession(Base, BaseModel): |
|
5205 | class DbSession(Base, BaseModel): | |
5204 | __tablename__ = 'db_session' |
|
5206 | __tablename__ = 'db_session' | |
5205 | __table_args__ = ( |
|
5207 | __table_args__ = ( | |
5206 | base_table_args, |
|
5208 | base_table_args, | |
5207 | ) |
|
5209 | ) | |
5208 |
|
5210 | |||
5209 | def __repr__(self): |
|
5211 | def __repr__(self): | |
5210 | return '<DB:DbSession({})>'.format(self.id) |
|
5212 | return '<DB:DbSession({})>'.format(self.id) | |
5211 |
|
5213 | |||
5212 | id = Column('id', Integer()) |
|
5214 | id = Column('id', Integer()) | |
5213 | namespace = Column('namespace', String(255), primary_key=True) |
|
5215 | namespace = Column('namespace', String(255), primary_key=True) | |
5214 | accessed = Column('accessed', DateTime, nullable=False) |
|
5216 | accessed = Column('accessed', DateTime, nullable=False) | |
5215 | created = Column('created', DateTime, nullable=False) |
|
5217 | created = Column('created', DateTime, nullable=False) | |
5216 | data = Column('data', PickleType, nullable=False) |
|
5218 | data = Column('data', PickleType, nullable=False) |
@@ -1,585 +1,611 b'' | |||||
1 | // comments.less |
|
1 | // comments.less | |
2 | // For use in RhodeCode applications; |
|
2 | // For use in RhodeCode applications; | |
3 | // see style guide documentation for guidelines. |
|
3 | // see style guide documentation for guidelines. | |
4 |
|
4 | |||
5 |
|
5 | |||
6 | // Comments |
|
6 | // Comments | |
7 | @comment-outdated-opacity: 0.6; |
|
7 | @comment-outdated-opacity: 0.6; | |
8 |
|
8 | |||
9 | .comments { |
|
9 | .comments { | |
10 | width: 100%; |
|
10 | width: 100%; | |
11 | } |
|
11 | } | |
12 |
|
12 | |||
13 | .comments-heading { |
|
13 | .comments-heading { | |
14 | margin-bottom: -1px; |
|
14 | margin-bottom: -1px; | |
15 | background: @grey6; |
|
15 | background: @grey6; | |
16 | display: block; |
|
16 | display: block; | |
17 | padding: 10px 0px; |
|
17 | padding: 10px 0px; | |
18 | font-size: 18px |
|
18 | font-size: 18px | |
19 | } |
|
19 | } | |
20 |
|
20 | |||
21 | #comment-tr-show { |
|
21 | #comment-tr-show { | |
22 | padding: 5px 0; |
|
22 | padding: 5px 0; | |
23 | } |
|
23 | } | |
24 |
|
24 | |||
25 | tr.inline-comments div { |
|
25 | tr.inline-comments div { | |
26 | max-width: 100%; |
|
26 | max-width: 100%; | |
27 |
|
27 | |||
28 | p { |
|
28 | p { | |
29 | white-space: normal; |
|
29 | white-space: normal; | |
30 | } |
|
30 | } | |
31 |
|
31 | |||
32 | code, pre, .code, dd { |
|
32 | code, pre, .code, dd { | |
33 | overflow-x: auto; |
|
33 | overflow-x: auto; | |
34 | width: 1062px; |
|
34 | width: 1062px; | |
35 | } |
|
35 | } | |
36 |
|
36 | |||
37 | dd { |
|
37 | dd { | |
38 | width: auto; |
|
38 | width: auto; | |
39 | } |
|
39 | } | |
40 | } |
|
40 | } | |
41 |
|
41 | |||
42 | #injected_page_comments { |
|
42 | #injected_page_comments { | |
43 | .comment-previous-link, |
|
43 | .comment-previous-link, | |
44 | .comment-next-link, |
|
44 | .comment-next-link, | |
45 | .comment-links-divider { |
|
45 | .comment-links-divider { | |
46 | display: none; |
|
46 | display: none; | |
47 | } |
|
47 | } | |
48 | } |
|
48 | } | |
49 |
|
49 | |||
50 | .add-comment { |
|
50 | .add-comment { | |
51 | margin-bottom: 10px; |
|
51 | margin-bottom: 10px; | |
52 | } |
|
52 | } | |
53 | .hide-comment-button .add-comment { |
|
53 | .hide-comment-button .add-comment { | |
54 | display: none; |
|
54 | display: none; | |
55 | } |
|
55 | } | |
56 |
|
56 | |||
57 | .comment-bubble { |
|
57 | .comment-bubble { | |
58 | color: @grey4; |
|
58 | color: @grey4; | |
59 | margin-top: 4px; |
|
59 | margin-top: 4px; | |
60 | margin-right: 30px; |
|
60 | margin-right: 30px; | |
61 | visibility: hidden; |
|
61 | visibility: hidden; | |
62 | } |
|
62 | } | |
63 |
|
63 | |||
64 | .comment-label { |
|
64 | .comment-label { | |
65 | float: left; |
|
65 | float: left; | |
66 |
|
66 | |||
67 | padding: 0.4em 0.4em; |
|
67 | padding: 0.4em 0.4em; | |
68 | margin: 3px 5px 0px -10px; |
|
68 | margin: 3px 5px 0px -10px; | |
69 | display: inline-block; |
|
69 | display: inline-block; | |
70 | min-height: 0; |
|
70 | min-height: 0; | |
71 |
|
71 | |||
72 | text-align: center; |
|
72 | text-align: center; | |
73 | font-size: 10px; |
|
73 | font-size: 10px; | |
74 | line-height: .8em; |
|
74 | line-height: .8em; | |
75 |
|
75 | |||
76 | font-family: @text-italic; |
|
76 | font-family: @text-italic; | |
77 | font-style: italic; |
|
77 | font-style: italic; | |
78 | background: #fff none; |
|
78 | background: #fff none; | |
79 | color: @grey4; |
|
79 | color: @grey4; | |
80 | border: 1px solid @grey4; |
|
80 | border: 1px solid @grey4; | |
81 | white-space: nowrap; |
|
81 | white-space: nowrap; | |
82 |
|
82 | |||
83 | text-transform: uppercase; |
|
83 | text-transform: uppercase; | |
84 | min-width: 40px; |
|
84 | min-width: 40px; | |
85 |
|
85 | |||
86 | &.todo { |
|
86 | &.todo { | |
87 | color: @color5; |
|
87 | color: @color5; | |
88 | font-style: italic; |
|
88 | font-style: italic; | |
89 | font-weight: @text-bold-italic-weight; |
|
89 | font-weight: @text-bold-italic-weight; | |
90 | font-family: @text-bold-italic; |
|
90 | font-family: @text-bold-italic; | |
91 | } |
|
91 | } | |
92 |
|
92 | |||
93 | .resolve { |
|
93 | .resolve { | |
94 | cursor: pointer; |
|
94 | cursor: pointer; | |
95 | text-decoration: underline; |
|
95 | text-decoration: underline; | |
96 | } |
|
96 | } | |
97 |
|
97 | |||
98 | .resolved { |
|
98 | .resolved { | |
99 | text-decoration: line-through; |
|
99 | text-decoration: line-through; | |
100 | color: @color1; |
|
100 | color: @color1; | |
101 | } |
|
101 | } | |
102 | .resolved a { |
|
102 | .resolved a { | |
103 | text-decoration: line-through; |
|
103 | text-decoration: line-through; | |
104 | color: @color1; |
|
104 | color: @color1; | |
105 | } |
|
105 | } | |
106 | .resolve-text { |
|
106 | .resolve-text { | |
107 | color: @color1; |
|
107 | color: @color1; | |
108 | margin: 2px 8px; |
|
108 | margin: 2px 8px; | |
109 | font-family: @text-italic; |
|
109 | font-family: @text-italic; | |
110 | font-style: italic; |
|
110 | font-style: italic; | |
111 | } |
|
111 | } | |
112 | } |
|
112 | } | |
113 |
|
113 | |||
114 | .has-spacer-after { |
|
114 | .has-spacer-after { | |
115 | &:after { |
|
115 | &:after { | |
116 | content: ' | '; |
|
116 | content: ' | '; | |
117 | color: @grey5; |
|
117 | color: @grey5; | |
118 | } |
|
118 | } | |
119 | } |
|
119 | } | |
120 |
|
120 | |||
121 | .has-spacer-before { |
|
121 | .has-spacer-before { | |
122 | &:before { |
|
122 | &:before { | |
123 | content: ' | '; |
|
123 | content: ' | '; | |
124 | color: @grey5; |
|
124 | color: @grey5; | |
125 | } |
|
125 | } | |
126 | } |
|
126 | } | |
127 |
|
127 | |||
128 | .comment { |
|
128 | .comment { | |
129 |
|
129 | |||
130 | &.comment-general { |
|
130 | &.comment-general { | |
131 | border: 1px solid @grey5; |
|
131 | border: 1px solid @grey5; | |
132 | padding: 5px 5px 5px 5px; |
|
132 | padding: 5px 5px 5px 5px; | |
133 | } |
|
133 | } | |
134 |
|
134 | |||
135 | margin: @padding 0; |
|
135 | margin: @padding 0; | |
136 | padding: 4px 0 0 0; |
|
136 | padding: 4px 0 0 0; | |
137 | line-height: 1em; |
|
137 | line-height: 1em; | |
138 |
|
138 | |||
139 | .rc-user { |
|
139 | .rc-user { | |
140 | min-width: 0; |
|
140 | min-width: 0; | |
141 | margin: 0px .5em 0 0; |
|
141 | margin: 0px .5em 0 0; | |
142 |
|
142 | |||
143 | .user { |
|
143 | .user { | |
144 | display: inline; |
|
144 | display: inline; | |
145 | } |
|
145 | } | |
146 | } |
|
146 | } | |
147 |
|
147 | |||
148 | .meta { |
|
148 | .meta { | |
149 | position: relative; |
|
149 | position: relative; | |
150 | width: 100%; |
|
150 | width: 100%; | |
151 | border-bottom: 1px solid @grey5; |
|
151 | border-bottom: 1px solid @grey5; | |
152 | margin: -5px 0px; |
|
152 | margin: -5px 0px; | |
153 | line-height: 24px; |
|
153 | line-height: 24px; | |
154 |
|
154 | |||
155 | &:hover .permalink { |
|
155 | &:hover .permalink { | |
156 | visibility: visible; |
|
156 | visibility: visible; | |
157 | color: @rcblue; |
|
157 | color: @rcblue; | |
158 | } |
|
158 | } | |
159 | } |
|
159 | } | |
160 |
|
160 | |||
161 | .author, |
|
161 | .author, | |
162 | .date { |
|
162 | .date { | |
163 | display: inline; |
|
163 | display: inline; | |
164 |
|
164 | |||
165 | &:after { |
|
165 | &:after { | |
166 | content: ' | '; |
|
166 | content: ' | '; | |
167 | color: @grey5; |
|
167 | color: @grey5; | |
168 | } |
|
168 | } | |
169 | } |
|
169 | } | |
170 |
|
170 | |||
171 | .author-general img { |
|
171 | .author-general img { | |
172 | top: 3px; |
|
172 | top: 3px; | |
173 | } |
|
173 | } | |
174 | .author-inline img { |
|
174 | .author-inline img { | |
175 | top: 3px; |
|
175 | top: 3px; | |
176 | } |
|
176 | } | |
177 |
|
177 | |||
178 | .status-change, |
|
178 | .status-change, | |
179 | .permalink, |
|
179 | .permalink, | |
180 | .changeset-status-lbl { |
|
180 | .changeset-status-lbl { | |
181 | display: inline; |
|
181 | display: inline; | |
182 | } |
|
182 | } | |
183 |
|
183 | |||
184 | .permalink { |
|
184 | .permalink { | |
185 | visibility: hidden; |
|
185 | visibility: hidden; | |
186 | } |
|
186 | } | |
187 |
|
187 | |||
188 | .comment-links-divider { |
|
188 | .comment-links-divider { | |
189 | display: inline; |
|
189 | display: inline; | |
190 | } |
|
190 | } | |
191 |
|
191 | |||
192 | .comment-links-block { |
|
192 | .comment-links-block { | |
193 | float:right; |
|
193 | float:right; | |
194 | text-align: right; |
|
194 | text-align: right; | |
195 | min-width: 85px; |
|
195 | min-width: 85px; | |
196 |
|
196 | |||
197 | [class^="icon-"]:before, |
|
197 | [class^="icon-"]:before, | |
198 | [class*=" icon-"]:before { |
|
198 | [class*=" icon-"]:before { | |
199 | margin-left: 0; |
|
199 | margin-left: 0; | |
200 | margin-right: 0; |
|
200 | margin-right: 0; | |
201 | } |
|
201 | } | |
202 | } |
|
202 | } | |
203 |
|
203 | |||
204 | .comment-previous-link { |
|
204 | .comment-previous-link { | |
205 | display: inline-block; |
|
205 | display: inline-block; | |
206 |
|
206 | |||
207 | .arrow_comment_link{ |
|
207 | .arrow_comment_link{ | |
208 | cursor: pointer; |
|
208 | cursor: pointer; | |
209 | i { |
|
209 | i { | |
210 | font-size:10px; |
|
210 | font-size:10px; | |
211 | } |
|
211 | } | |
212 | } |
|
212 | } | |
213 | .arrow_comment_link.disabled { |
|
213 | .arrow_comment_link.disabled { | |
214 | cursor: default; |
|
214 | cursor: default; | |
215 | color: @grey5; |
|
215 | color: @grey5; | |
216 | } |
|
216 | } | |
217 | } |
|
217 | } | |
218 |
|
218 | |||
219 | .comment-next-link { |
|
219 | .comment-next-link { | |
220 | display: inline-block; |
|
220 | display: inline-block; | |
221 |
|
221 | |||
222 | .arrow_comment_link{ |
|
222 | .arrow_comment_link{ | |
223 | cursor: pointer; |
|
223 | cursor: pointer; | |
224 | i { |
|
224 | i { | |
225 | font-size:10px; |
|
225 | font-size:10px; | |
226 | } |
|
226 | } | |
227 | } |
|
227 | } | |
228 | .arrow_comment_link.disabled { |
|
228 | .arrow_comment_link.disabled { | |
229 | cursor: default; |
|
229 | cursor: default; | |
230 | color: @grey5; |
|
230 | color: @grey5; | |
231 | } |
|
231 | } | |
232 | } |
|
232 | } | |
233 |
|
233 | |||
234 | .delete-comment { |
|
234 | .delete-comment { | |
235 | display: inline-block; |
|
235 | display: inline-block; | |
236 | color: @rcblue; |
|
236 | color: @rcblue; | |
237 |
|
237 | |||
238 | &:hover { |
|
238 | &:hover { | |
239 | cursor: pointer; |
|
239 | cursor: pointer; | |
240 | } |
|
240 | } | |
241 | } |
|
241 | } | |
242 |
|
242 | |||
243 | .text { |
|
243 | .text { | |
244 | clear: both; |
|
244 | clear: both; | |
245 | .border-radius(@border-radius); |
|
245 | .border-radius(@border-radius); | |
246 | .box-sizing(border-box); |
|
246 | .box-sizing(border-box); | |
247 |
|
247 | |||
248 | .markdown-block p, |
|
248 | .markdown-block p, | |
249 | .rst-block p { |
|
249 | .rst-block p { | |
250 | margin: .5em 0 !important; |
|
250 | margin: .5em 0 !important; | |
251 | // TODO: lisa: This is needed because of other rst !important rules :[ |
|
251 | // TODO: lisa: This is needed because of other rst !important rules :[ | |
252 | } |
|
252 | } | |
253 | } |
|
253 | } | |
254 |
|
254 | |||
255 | .pr-version { |
|
255 | .pr-version { | |
256 | float: left; |
|
256 | float: left; | |
257 | margin: 0px 4px; |
|
257 | margin: 0px 4px; | |
258 | } |
|
258 | } | |
259 | .pr-version-inline { |
|
259 | .pr-version-inline { | |
260 | float: left; |
|
260 | float: left; | |
261 | margin: 0px 4px; |
|
261 | margin: 0px 4px; | |
262 | } |
|
262 | } | |
263 | .pr-version-num { |
|
263 | .pr-version-num { | |
264 | font-size: 10px; |
|
264 | font-size: 10px; | |
265 | } |
|
265 | } | |
266 | } |
|
266 | } | |
267 |
|
267 | |||
268 | @comment-padding: 5px; |
|
268 | @comment-padding: 5px; | |
269 |
|
269 | |||
270 | .general-comments { |
|
270 | .general-comments { | |
271 | .comment-outdated { |
|
271 | .comment-outdated { | |
272 | opacity: @comment-outdated-opacity; |
|
272 | opacity: @comment-outdated-opacity; | |
273 | } |
|
273 | } | |
274 | } |
|
274 | } | |
275 |
|
275 | |||
276 | .inline-comments { |
|
276 | .inline-comments { | |
277 | border-radius: @border-radius; |
|
277 | border-radius: @border-radius; | |
278 | .comment { |
|
278 | .comment { | |
279 | margin: 0; |
|
279 | margin: 0; | |
280 | border-radius: @border-radius; |
|
280 | border-radius: @border-radius; | |
281 | } |
|
281 | } | |
282 | .comment-outdated { |
|
282 | .comment-outdated { | |
283 | opacity: @comment-outdated-opacity; |
|
283 | opacity: @comment-outdated-opacity; | |
284 | } |
|
284 | } | |
285 |
|
285 | |||
286 | .comment-inline { |
|
286 | .comment-inline { | |
287 | background: white; |
|
287 | background: white; | |
288 | padding: @comment-padding @comment-padding; |
|
288 | padding: @comment-padding @comment-padding; | |
289 | border: @comment-padding solid @grey6; |
|
289 | border: @comment-padding solid @grey6; | |
290 |
|
290 | |||
291 | .text { |
|
291 | .text { | |
292 | border: none; |
|
292 | border: none; | |
293 | } |
|
293 | } | |
294 | .meta { |
|
294 | .meta { | |
295 | border-bottom: 1px solid @grey6; |
|
295 | border-bottom: 1px solid @grey6; | |
296 | margin: -5px 0px; |
|
296 | margin: -5px 0px; | |
297 | line-height: 24px; |
|
297 | line-height: 24px; | |
298 | } |
|
298 | } | |
299 | } |
|
299 | } | |
300 | .comment-selected { |
|
300 | .comment-selected { | |
301 | border-left: 6px solid @comment-highlight-color; |
|
301 | border-left: 6px solid @comment-highlight-color; | |
302 | } |
|
302 | } | |
303 | .comment-inline-form { |
|
303 | .comment-inline-form { | |
304 | padding: @comment-padding; |
|
304 | padding: @comment-padding; | |
305 | display: none; |
|
305 | display: none; | |
306 | } |
|
306 | } | |
307 | .cb-comment-add-button { |
|
307 | .cb-comment-add-button { | |
308 | margin: @comment-padding; |
|
308 | margin: @comment-padding; | |
309 | } |
|
309 | } | |
310 | /* hide add comment button when form is open */ |
|
310 | /* hide add comment button when form is open */ | |
311 | .comment-inline-form-open ~ .cb-comment-add-button { |
|
311 | .comment-inline-form-open ~ .cb-comment-add-button { | |
312 | display: none; |
|
312 | display: none; | |
313 | } |
|
313 | } | |
314 | .comment-inline-form-open { |
|
314 | .comment-inline-form-open { | |
315 | display: block; |
|
315 | display: block; | |
316 | } |
|
316 | } | |
317 | /* hide add comment button when form but no comments */ |
|
317 | /* hide add comment button when form but no comments */ | |
318 | .comment-inline-form:first-child + .cb-comment-add-button { |
|
318 | .comment-inline-form:first-child + .cb-comment-add-button { | |
319 | display: none; |
|
319 | display: none; | |
320 | } |
|
320 | } | |
321 | /* hide add comment button when no comments or form */ |
|
321 | /* hide add comment button when no comments or form */ | |
322 | .cb-comment-add-button:first-child { |
|
322 | .cb-comment-add-button:first-child { | |
323 | display: none; |
|
323 | display: none; | |
324 | } |
|
324 | } | |
325 | /* hide add comment button when only comment is being deleted */ |
|
325 | /* hide add comment button when only comment is being deleted */ | |
326 | .comment-deleting:first-child + .cb-comment-add-button { |
|
326 | .comment-deleting:first-child + .cb-comment-add-button { | |
327 | display: none; |
|
327 | display: none; | |
328 | } |
|
328 | } | |
329 | } |
|
329 | } | |
330 |
|
330 | |||
331 |
|
331 | |||
332 | .show-outdated-comments { |
|
332 | .show-outdated-comments { | |
333 | display: inline; |
|
333 | display: inline; | |
334 | color: @rcblue; |
|
334 | color: @rcblue; | |
335 | } |
|
335 | } | |
336 |
|
336 | |||
337 | // Comment Form |
|
337 | // Comment Form | |
338 | div.comment-form { |
|
338 | div.comment-form { | |
339 | margin-top: 20px; |
|
339 | margin-top: 20px; | |
340 | } |
|
340 | } | |
341 |
|
341 | |||
342 | .comment-form strong { |
|
342 | .comment-form strong { | |
343 | display: block; |
|
343 | display: block; | |
344 | margin-bottom: 15px; |
|
344 | margin-bottom: 15px; | |
345 | } |
|
345 | } | |
346 |
|
346 | |||
347 | .comment-form textarea { |
|
347 | .comment-form textarea { | |
348 | width: 100%; |
|
348 | width: 100%; | |
349 | height: 100px; |
|
349 | height: 100px; | |
350 | font-family: @text-monospace; |
|
350 | font-family: @text-monospace; | |
351 | } |
|
351 | } | |
352 |
|
352 | |||
353 | form.comment-form { |
|
353 | form.comment-form { | |
354 | margin-top: 10px; |
|
354 | margin-top: 10px; | |
355 | margin-left: 10px; |
|
355 | margin-left: 10px; | |
356 | } |
|
356 | } | |
357 |
|
357 | |||
358 | .comment-inline-form .comment-block-ta, |
|
358 | .comment-inline-form .comment-block-ta, | |
359 | .comment-form .comment-block-ta, |
|
359 | .comment-form .comment-block-ta, | |
360 | .comment-form .preview-box { |
|
360 | .comment-form .preview-box { | |
361 | .border-radius(@border-radius); |
|
361 | .border-radius(@border-radius); | |
362 | .box-sizing(border-box); |
|
362 | .box-sizing(border-box); | |
363 | background-color: white; |
|
363 | background-color: white; | |
364 | } |
|
364 | } | |
365 |
|
365 | |||
366 | .comment-form-submit { |
|
366 | .comment-form-submit { | |
367 | margin-top: 5px; |
|
367 | margin-top: 5px; | |
368 | margin-left: 525px; |
|
368 | margin-left: 525px; | |
369 | } |
|
369 | } | |
370 |
|
370 | |||
371 | .file-comments { |
|
371 | .file-comments { | |
372 | display: none; |
|
372 | display: none; | |
373 | } |
|
373 | } | |
374 |
|
374 | |||
375 | .comment-form .preview-box.unloaded, |
|
375 | .comment-form .preview-box.unloaded, | |
376 | .comment-inline-form .preview-box.unloaded { |
|
376 | .comment-inline-form .preview-box.unloaded { | |
377 | height: 50px; |
|
377 | height: 50px; | |
378 | text-align: center; |
|
378 | text-align: center; | |
379 | padding: 20px; |
|
379 | padding: 20px; | |
380 | background-color: white; |
|
380 | background-color: white; | |
381 | } |
|
381 | } | |
382 |
|
382 | |||
383 | .comment-footer { |
|
383 | .comment-footer { | |
384 | position: relative; |
|
384 | position: relative; | |
385 | width: 100%; |
|
385 | width: 100%; | |
386 | min-height: 42px; |
|
386 | min-height: 42px; | |
387 |
|
387 | |||
388 | .status_box, |
|
388 | .status_box, | |
389 | .cancel-button { |
|
389 | .cancel-button { | |
390 | float: left; |
|
390 | float: left; | |
391 | display: inline-block; |
|
391 | display: inline-block; | |
392 | } |
|
392 | } | |
393 |
|
393 | |||
394 | .action-buttons { |
|
394 | .action-buttons { | |
395 | float: right; |
|
395 | float: right; | |
396 | display: inline-block; |
|
396 | display: inline-block; | |
397 | } |
|
397 | } | |
398 |
|
398 | |||
399 | .action-buttons-extra { |
|
399 | .action-buttons-extra { | |
400 | display: inline-block; |
|
400 | display: inline-block; | |
401 | } |
|
401 | } | |
402 | } |
|
402 | } | |
403 |
|
403 | |||
404 | .comment-form { |
|
404 | .comment-form { | |
405 |
|
405 | |||
406 | .comment { |
|
406 | .comment { | |
407 | margin-left: 10px; |
|
407 | margin-left: 10px; | |
408 | } |
|
408 | } | |
409 |
|
409 | |||
410 | .comment-help { |
|
410 | .comment-help { | |
411 | color: @grey4; |
|
411 | color: @grey4; | |
412 | padding: 5px 0 5px 0; |
|
412 | padding: 5px 0 5px 0; | |
413 | } |
|
413 | } | |
414 |
|
414 | |||
415 | .comment-title { |
|
415 | .comment-title { | |
416 | padding: 5px 0 5px 0; |
|
416 | padding: 5px 0 5px 0; | |
417 | } |
|
417 | } | |
418 |
|
418 | |||
419 | .comment-button { |
|
419 | .comment-button { | |
420 | display: inline-block; |
|
420 | display: inline-block; | |
421 | } |
|
421 | } | |
422 |
|
422 | |||
423 | .comment-button-input { |
|
423 | .comment-button-input { | |
424 | margin-right: 0; |
|
424 | margin-right: 0; | |
425 | } |
|
425 | } | |
426 |
|
426 | |||
427 | .comment-footer { |
|
427 | .comment-footer { | |
428 | margin-bottom: 110px; |
|
428 | margin-bottom: 110px; | |
429 | margin-top: 10px; |
|
429 | margin-top: 10px; | |
430 | } |
|
430 | } | |
431 | } |
|
431 | } | |
432 |
|
432 | |||
433 |
|
433 | |||
434 | .comment-form-login { |
|
434 | .comment-form-login { | |
435 | .comment-help { |
|
435 | .comment-help { | |
436 | padding: 0.7em; //same as the button |
|
436 | padding: 0.7em; //same as the button | |
437 | } |
|
437 | } | |
438 |
|
438 | |||
439 | div.clearfix { |
|
439 | div.clearfix { | |
440 | clear: both; |
|
440 | clear: both; | |
441 | width: 100%; |
|
441 | width: 100%; | |
442 | display: block; |
|
442 | display: block; | |
443 | } |
|
443 | } | |
444 | } |
|
444 | } | |
445 |
|
445 | |||
446 | .comment-type { |
|
446 | .comment-type { | |
447 | margin: 0px; |
|
447 | margin: 0px; | |
448 | border-radius: inherit; |
|
448 | border-radius: inherit; | |
449 | border-color: @grey6; |
|
449 | border-color: @grey6; | |
450 | } |
|
450 | } | |
451 |
|
451 | |||
452 | .preview-box { |
|
452 | .preview-box { | |
453 | min-height: 105px; |
|
453 | min-height: 105px; | |
454 | margin-bottom: 15px; |
|
454 | margin-bottom: 15px; | |
455 | background-color: white; |
|
455 | background-color: white; | |
456 | .border-radius(@border-radius); |
|
456 | .border-radius(@border-radius); | |
457 | .box-sizing(border-box); |
|
457 | .box-sizing(border-box); | |
458 | } |
|
458 | } | |
459 |
|
459 | |||
460 | .add-another-button { |
|
460 | .add-another-button { | |
461 | margin-left: 10px; |
|
461 | margin-left: 10px; | |
462 | margin-top: 10px; |
|
462 | margin-top: 10px; | |
463 | margin-bottom: 10px; |
|
463 | margin-bottom: 10px; | |
464 | } |
|
464 | } | |
465 |
|
465 | |||
466 | .comment .buttons { |
|
466 | .comment .buttons { | |
467 | float: right; |
|
467 | float: right; | |
468 | margin: -1px 0px 0px 0px; |
|
468 | margin: -1px 0px 0px 0px; | |
469 | } |
|
469 | } | |
470 |
|
470 | |||
471 | // Inline Comment Form |
|
471 | // Inline Comment Form | |
472 | .injected_diff .comment-inline-form, |
|
472 | .injected_diff .comment-inline-form, | |
473 | .comment-inline-form { |
|
473 | .comment-inline-form { | |
474 | background-color: white; |
|
474 | background-color: white; | |
475 | margin-top: 10px; |
|
475 | margin-top: 10px; | |
476 | margin-bottom: 20px; |
|
476 | margin-bottom: 20px; | |
477 | } |
|
477 | } | |
478 |
|
478 | |||
479 | .inline-form { |
|
479 | .inline-form { | |
480 | padding: 10px 7px; |
|
480 | padding: 10px 7px; | |
481 | } |
|
481 | } | |
482 |
|
482 | |||
483 | .inline-form div { |
|
483 | .inline-form div { | |
484 | max-width: 100%; |
|
484 | max-width: 100%; | |
485 | } |
|
485 | } | |
486 |
|
486 | |||
487 | .overlay { |
|
487 | .overlay { | |
488 | display: none; |
|
488 | display: none; | |
489 | position: absolute; |
|
489 | position: absolute; | |
490 | width: 100%; |
|
490 | width: 100%; | |
491 | text-align: center; |
|
491 | text-align: center; | |
492 | vertical-align: middle; |
|
492 | vertical-align: middle; | |
493 | font-size: 16px; |
|
493 | font-size: 16px; | |
494 | background: none repeat scroll 0 0 white; |
|
494 | background: none repeat scroll 0 0 white; | |
495 |
|
495 | |||
496 | &.submitting { |
|
496 | &.submitting { | |
497 | display: block; |
|
497 | display: block; | |
498 | opacity: 0.5; |
|
498 | opacity: 0.5; | |
499 | z-index: 100; |
|
499 | z-index: 100; | |
500 | } |
|
500 | } | |
501 | } |
|
501 | } | |
502 | .comment-inline-form .overlay.submitting .overlay-text { |
|
502 | .comment-inline-form .overlay.submitting .overlay-text { | |
503 | margin-top: 5%; |
|
503 | margin-top: 5%; | |
504 | } |
|
504 | } | |
505 |
|
505 | |||
506 | .comment-inline-form .clearfix, |
|
506 | .comment-inline-form .clearfix, | |
507 | .comment-form .clearfix { |
|
507 | .comment-form .clearfix { | |
508 | .border-radius(@border-radius); |
|
508 | .border-radius(@border-radius); | |
509 | margin: 0px; |
|
509 | margin: 0px; | |
510 | } |
|
510 | } | |
511 |
|
511 | |||
512 | .comment-inline-form .comment-footer { |
|
512 | .comment-inline-form .comment-footer { | |
513 | margin: 10px 0px 0px 0px; |
|
513 | margin: 10px 0px 0px 0px; | |
514 | } |
|
514 | } | |
515 |
|
515 | |||
516 | .hide-inline-form-button { |
|
516 | .hide-inline-form-button { | |
517 | margin-left: 5px; |
|
517 | margin-left: 5px; | |
518 | } |
|
518 | } | |
519 | .comment-button .hide-inline-form { |
|
519 | .comment-button .hide-inline-form { | |
520 | background: white; |
|
520 | background: white; | |
521 | } |
|
521 | } | |
522 |
|
522 | |||
523 | .comment-area { |
|
523 | .comment-area { | |
524 | padding: 8px 12px; |
|
524 | padding: 8px 12px; | |
525 | border: 1px solid @grey5; |
|
525 | border: 1px solid @grey5; | |
526 | .border-radius(@border-radius); |
|
526 | .border-radius(@border-radius); | |
527 |
|
527 | |||
528 | .resolve-action { |
|
528 | .resolve-action { | |
529 | padding: 1px 0px 0px 6px; |
|
529 | padding: 1px 0px 0px 6px; | |
530 | } |
|
530 | } | |
531 |
|
531 | |||
532 | } |
|
532 | } | |
533 |
|
533 | |||
534 | .comment-area-header .nav-links { |
|
534 | .comment-area-header .nav-links { | |
535 | display: flex; |
|
535 | display: flex; | |
536 | flex-flow: row wrap; |
|
536 | flex-flow: row wrap; | |
537 | -webkit-flex-flow: row wrap; |
|
537 | -webkit-flex-flow: row wrap; | |
538 | width: 100%; |
|
538 | width: 100%; | |
539 | } |
|
539 | } | |
540 |
|
540 | |||
541 | .comment-area-footer { |
|
541 | .comment-area-footer { | |
542 | display: flex; |
|
542 | min-height: 30px; | |
543 | } |
|
543 | } | |
544 |
|
544 | |||
545 | .comment-footer .toolbar { |
|
545 | .comment-footer .toolbar { | |
546 |
|
546 | |||
547 | } |
|
547 | } | |
548 |
|
548 | |||
|
549 | .comment-attachment-uploader { | |||
|
550 | border: 1px dashed white; | |||
|
551 | border-radius: @border-radius; | |||
|
552 | margin-top: -10px; | |||
|
553 | ||||
|
554 | &.dz-drag-hover { | |||
|
555 | border-color: @grey3; | |||
|
556 | } | |||
|
557 | ||||
|
558 | .dz-error-message { | |||
|
559 | padding-top: 0; | |||
|
560 | } | |||
|
561 | } | |||
|
562 | ||||
|
563 | .comment-attachment-text { | |||
|
564 | clear: both; | |||
|
565 | font-size: 11px; | |||
|
566 | color: #8F8F8F; | |||
|
567 | width: 100%; | |||
|
568 | .pick-attachment { | |||
|
569 | color: #8F8F8F; | |||
|
570 | } | |||
|
571 | .pick-attachment:hover { | |||
|
572 | color: @rcblue; | |||
|
573 | } | |||
|
574 | } | |||
|
575 | ||||
549 | .nav-links { |
|
576 | .nav-links { | |
550 | padding: 0; |
|
577 | padding: 0; | |
551 | margin: 0; |
|
578 | margin: 0; | |
552 | list-style: none; |
|
579 | list-style: none; | |
553 | height: auto; |
|
580 | height: auto; | |
554 | border-bottom: 1px solid @grey5; |
|
581 | border-bottom: 1px solid @grey5; | |
555 | } |
|
582 | } | |
556 | .nav-links li { |
|
583 | .nav-links li { | |
557 | display: inline-block; |
|
584 | display: inline-block; | |
558 | list-style-type: none; |
|
585 | list-style-type: none; | |
559 | } |
|
586 | } | |
560 |
|
587 | |||
561 | .nav-links li a.disabled { |
|
588 | .nav-links li a.disabled { | |
562 | cursor: not-allowed; |
|
589 | cursor: not-allowed; | |
563 | } |
|
590 | } | |
564 |
|
591 | |||
565 | .nav-links li.active a { |
|
592 | .nav-links li.active a { | |
566 | border-bottom: 2px solid @rcblue; |
|
593 | border-bottom: 2px solid @rcblue; | |
567 | color: #000; |
|
594 | color: #000; | |
568 | font-weight: 600; |
|
595 | font-weight: 600; | |
569 | } |
|
596 | } | |
570 | .nav-links li a { |
|
597 | .nav-links li a { | |
571 | display: inline-block; |
|
598 | display: inline-block; | |
572 | padding: 0px 10px 5px 10px; |
|
599 | padding: 0px 10px 5px 10px; | |
573 | margin-bottom: -1px; |
|
600 | margin-bottom: -1px; | |
574 | font-size: 14px; |
|
601 | font-size: 14px; | |
575 | line-height: 28px; |
|
602 | line-height: 28px; | |
576 | color: #8f8f8f; |
|
603 | color: #8f8f8f; | |
577 | border-bottom: 2px solid transparent; |
|
604 | border-bottom: 2px solid transparent; | |
578 | } |
|
605 | } | |
579 |
|
606 | |||
580 | .toolbar-text { |
|
607 | .toolbar-text { | |
581 | float: left; |
|
608 | float: left; | |
582 | margin: -5px 0px 0px 0px; |
|
|||
583 | font-size: 12px; |
|
609 | font-size: 12px; | |
584 | } |
|
610 | } | |
585 |
|
611 |
@@ -1,397 +1,398 b'' | |||||
1 |
|
1 | |||
2 | /** MODAL **/ |
|
2 | /** MODAL **/ | |
3 | .modal-open { |
|
3 | .modal-open { | |
4 | overflow:hidden; |
|
4 | overflow:hidden; | |
5 | } |
|
5 | } | |
6 | body.modal-open, .modal-open .navbar-fixed-top, .modal-open .navbar-fixed-bottom { |
|
6 | body.modal-open, .modal-open .navbar-fixed-top, .modal-open .navbar-fixed-bottom { | |
7 | margin-right:15px; |
|
7 | margin-right:15px; | |
8 | } |
|
8 | } | |
9 | .modal { |
|
9 | .modal { | |
10 | position:fixed; |
|
10 | position:fixed; | |
11 | top:0; |
|
11 | top:0; | |
12 | right:0; |
|
12 | right:0; | |
13 | bottom:0; |
|
13 | bottom:0; | |
14 | left:0; |
|
14 | left:0; | |
15 | z-index:1040; |
|
15 | z-index:1040; | |
16 | display:none; |
|
16 | display:none; | |
17 | overflow-y:scroll; |
|
17 | overflow-y:scroll; | |
18 | &.fade .modal-dialog { |
|
18 | &.fade .modal-dialog { | |
19 | -webkit-transform:translate(0,-25%); |
|
19 | -webkit-transform:translate(0,-25%); | |
20 | -ms-transform:translate(0,-25%); |
|
20 | -ms-transform:translate(0,-25%); | |
21 | transform:translate(0,-25%); |
|
21 | transform:translate(0,-25%); | |
22 | -webkit-transition:-webkit-transform 0.3s ease-out; |
|
22 | -webkit-transition:-webkit-transform 0.3s ease-out; | |
23 | -moz-transition:-moz-transform 0.3s ease-out; |
|
23 | -moz-transition:-moz-transform 0.3s ease-out; | |
24 | -o-transition:-o-transform 0.3s ease-out; |
|
24 | -o-transition:-o-transform 0.3s ease-out; | |
25 | transition:transform 0.3s ease-out; |
|
25 | transition:transform 0.3s ease-out; | |
26 | } |
|
26 | } | |
27 | &.in .modal-dialog { |
|
27 | &.in .modal-dialog { | |
28 | -webkit-transform:translate(0,0); |
|
28 | -webkit-transform:translate(0,0); | |
29 | -ms-transform:translate(0,0); |
|
29 | -ms-transform:translate(0,0); | |
30 | transform:translate(0,0); |
|
30 | transform:translate(0,0); | |
31 | } |
|
31 | } | |
32 | } |
|
32 | } | |
33 | .modal-dialog { |
|
33 | .modal-dialog { | |
34 | z-index:1050; |
|
34 | z-index:1050; | |
35 | width:auto; |
|
35 | width:auto; | |
36 | padding:10px; |
|
36 | padding:10px; | |
37 | margin-right:auto; |
|
37 | margin-right:auto; | |
38 | margin-left:auto; |
|
38 | margin-left:auto; | |
39 | } |
|
39 | } | |
40 | .modal-content { |
|
40 | .modal-content { | |
41 | position:relative; |
|
41 | position:relative; | |
42 | background-color:#ffffff; |
|
42 | background-color:#ffffff; | |
43 | border: @border-thickness solid rgba(0,0,0,0.2); |
|
43 | border: @border-thickness solid rgba(0,0,0,0.2); | |
44 | .border-radius(@border-radius); |
|
44 | .border-radius(@border-radius); | |
45 | outline:none; |
|
45 | outline:none; | |
46 | -webkit-box-shadow:0 3px 9px rgba(0,0,0,0.5); |
|
46 | -webkit-box-shadow:0 3px 9px rgba(0,0,0,0.5); | |
47 | box-shadow:0 3px 9px rgba(0,0,0,0.5); |
|
47 | box-shadow:0 3px 9px rgba(0,0,0,0.5); | |
48 | background-clip:padding-box; |
|
48 | background-clip:padding-box; | |
49 | } |
|
49 | } | |
50 | .modal-backdrop { |
|
50 | .modal-backdrop { | |
51 | position:fixed; |
|
51 | position:fixed; | |
52 | top:0; |
|
52 | top:0; | |
53 | right:0; |
|
53 | right:0; | |
54 | bottom:0; |
|
54 | bottom:0; | |
55 | left:0; |
|
55 | left:0; | |
56 | z-index:1030; |
|
56 | z-index:1030; | |
57 | background-color:#000000; |
|
57 | background-color:#000000; | |
58 |
|
58 | |||
59 | &.modal-backdrop.fade { |
|
59 | &.modal-backdrop.fade { | |
60 | opacity:0; |
|
60 | opacity:0; | |
61 | filter:alpha(opacity=0); |
|
61 | filter:alpha(opacity=0); | |
62 | } |
|
62 | } | |
63 | &.in { |
|
63 | &.in { | |
64 | opacity:0.5; |
|
64 | opacity:0.5; | |
65 | filter:alpha(opacity=50); |
|
65 | filter:alpha(opacity=50); | |
66 | } |
|
66 | } | |
67 | } |
|
67 | } | |
68 | .modal-header { |
|
68 | .modal-header { | |
69 | min-height:16.428571429px; |
|
69 | min-height:16.428571429px; | |
70 | padding:15px; |
|
70 | padding:15px; | |
71 | border-bottom: @border-thickness solid @grey6; |
|
71 | border-bottom: @border-thickness solid @grey6; | |
72 | .close { |
|
72 | .close { | |
73 | margin-top:-2px; |
|
73 | margin-top:-2px; | |
74 | } |
|
74 | } | |
75 | } |
|
75 | } | |
76 | .modal-title { |
|
76 | .modal-title { | |
77 | margin:0; |
|
77 | margin:0; | |
78 | line-height:1.428571429; |
|
78 | line-height:1.428571429; | |
79 | } |
|
79 | } | |
80 | .modal-body { |
|
80 | .modal-body { | |
81 | position:relative; |
|
81 | position:relative; | |
82 | padding:20px; |
|
82 | padding:20px; | |
83 | } |
|
83 | } | |
84 | .modal-footer { |
|
84 | .modal-footer { | |
85 | padding:19px 20px 20px; |
|
85 | padding:19px 20px 20px; | |
86 | margin-top:15px; |
|
86 | margin-top:15px; | |
87 | text-align:right; |
|
87 | text-align:right; | |
88 | border-top:1px solid #e5e5e5; |
|
88 | border-top:1px solid #e5e5e5; | |
89 | .btn + .btn { |
|
89 | .btn + .btn { | |
90 | margin-bottom:0; |
|
90 | margin-bottom:0; | |
91 | margin-left:5px; |
|
91 | margin-left:5px; | |
92 | } |
|
92 | } | |
93 | .btn-group .btn + .btn { |
|
93 | .btn-group .btn + .btn { | |
94 | margin-left:-1px; |
|
94 | margin-left:-1px; | |
95 | } |
|
95 | } | |
96 | .btn-block + .btn-block { |
|
96 | .btn-block + .btn-block { | |
97 | margin-left:0; |
|
97 | margin-left:0; | |
98 | } |
|
98 | } | |
99 | &:before { |
|
99 | &:before { | |
100 | display:table; |
|
100 | display:table; | |
101 | content:" "; |
|
101 | content:" "; | |
102 | } |
|
102 | } | |
103 | &:after { |
|
103 | &:after { | |
104 | display:table; |
|
104 | display:table; | |
105 | content:" "; |
|
105 | content:" "; | |
106 | clear:both; |
|
106 | clear:both; | |
107 | } |
|
107 | } | |
108 | } |
|
108 | } | |
109 |
|
109 | |||
110 | /** MARKDOWN styling **/ |
|
110 | /** MARKDOWN styling **/ | |
111 | div.markdown-block { |
|
111 | div.markdown-block { | |
112 | clear: both; |
|
112 | clear: both; | |
113 | overflow: hidden; |
|
113 | overflow: hidden; | |
114 | margin: 0; |
|
114 | margin: 0; | |
115 | padding: 3px 15px 3px; |
|
115 | padding: 3px 15px 3px; | |
116 | } |
|
116 | } | |
117 |
|
117 | |||
118 | div.markdown-block h1, |
|
118 | div.markdown-block h1, | |
119 | div.markdown-block h2, |
|
119 | div.markdown-block h2, | |
120 | div.markdown-block h3, |
|
120 | div.markdown-block h3, | |
121 | div.markdown-block h4, |
|
121 | div.markdown-block h4, | |
122 | div.markdown-block h5, |
|
122 | div.markdown-block h5, | |
123 | div.markdown-block h6 { |
|
123 | div.markdown-block h6 { | |
124 | border-bottom: none !important; |
|
124 | border-bottom: none !important; | |
125 | padding: 0 !important; |
|
125 | padding: 0 !important; | |
126 | overflow: visible !important; |
|
126 | overflow: visible !important; | |
127 | } |
|
127 | } | |
128 |
|
128 | |||
129 | div.markdown-block h1, |
|
129 | div.markdown-block h1, | |
130 | div.markdown-block h2 { |
|
130 | div.markdown-block h2 { | |
131 | border-bottom: 1px #e6e5e5 solid !important; |
|
131 | border-bottom: 1px #e6e5e5 solid !important; | |
132 | } |
|
132 | } | |
133 |
|
133 | |||
134 | div.markdown-block h1 { |
|
134 | div.markdown-block h1 { | |
135 | font-size: 32px; |
|
135 | font-size: 32px; | |
136 | margin: 15px 0 15px 0 !important; |
|
136 | margin: 15px 0 15px 0 !important; | |
137 | padding-bottom: 5px !important; |
|
137 | padding-bottom: 5px !important; | |
138 | } |
|
138 | } | |
139 |
|
139 | |||
140 | div.markdown-block h2 { |
|
140 | div.markdown-block h2 { | |
141 | font-size: 24px !important; |
|
141 | font-size: 24px !important; | |
142 | margin: 34px 0 10px 0 !important; |
|
142 | margin: 34px 0 10px 0 !important; | |
143 | padding-top: 15px !important; |
|
143 | padding-top: 15px !important; | |
144 | padding-bottom: 8px !important; |
|
144 | padding-bottom: 8px !important; | |
145 | } |
|
145 | } | |
146 |
|
146 | |||
147 | div.markdown-block h3 { |
|
147 | div.markdown-block h3 { | |
148 | font-size: 18px !important; |
|
148 | font-size: 18px !important; | |
149 | margin: 30px 0 8px 0 !important; |
|
149 | margin: 30px 0 8px 0 !important; | |
150 | padding-bottom: 2px !important; |
|
150 | padding-bottom: 2px !important; | |
151 | } |
|
151 | } | |
152 |
|
152 | |||
153 | div.markdown-block h4 { |
|
153 | div.markdown-block h4 { | |
154 | font-size: 13px !important; |
|
154 | font-size: 13px !important; | |
155 | margin: 18px 0 3px 0 !important; |
|
155 | margin: 18px 0 3px 0 !important; | |
156 | } |
|
156 | } | |
157 |
|
157 | |||
158 | div.markdown-block h5 { |
|
158 | div.markdown-block h5 { | |
159 | font-size: 12px !important; |
|
159 | font-size: 12px !important; | |
160 | margin: 15px 0 3px 0 !important; |
|
160 | margin: 15px 0 3px 0 !important; | |
161 | } |
|
161 | } | |
162 |
|
162 | |||
163 | div.markdown-block h6 { |
|
163 | div.markdown-block h6 { | |
164 | font-size: 12px; |
|
164 | font-size: 12px; | |
165 | color: #777777; |
|
165 | color: #777777; | |
166 | margin: 15px 0 3px 0 !important; |
|
166 | margin: 15px 0 3px 0 !important; | |
167 | } |
|
167 | } | |
168 |
|
168 | |||
169 | div.markdown-block hr { |
|
169 | div.markdown-block hr { | |
170 | border: 0; |
|
170 | border: 0; | |
171 | color: #e6e5e5; |
|
171 | color: #e6e5e5; | |
172 | background-color: #e6e5e5; |
|
172 | background-color: #e6e5e5; | |
173 | height: 3px; |
|
173 | height: 3px; | |
174 | margin-bottom: 13px; |
|
174 | margin-bottom: 13px; | |
175 | } |
|
175 | } | |
176 |
|
176 | |||
177 | div.markdown-block ol, |
|
177 | div.markdown-block ol, | |
178 | div.markdown-block ul, |
|
178 | div.markdown-block ul, | |
179 | div.markdown-block p, |
|
179 | div.markdown-block p, | |
180 | div.markdown-block blockquote, |
|
180 | div.markdown-block blockquote, | |
181 | div.markdown-block dl, |
|
181 | div.markdown-block dl, | |
182 | div.markdown-block li, |
|
182 | div.markdown-block li, | |
183 | div.markdown-block table { |
|
183 | div.markdown-block table { | |
184 | margin: 3px 0px 13px 0px !important; |
|
184 | margin: 3px 0px 13px 0px !important; | |
185 | color: #424242 !important; |
|
185 | color: #424242 !important; | |
186 | font-size: 13px !important; |
|
186 | font-size: 13px !important; | |
187 | font-family: @text-regular; |
|
187 | font-family: @text-regular; | |
188 | font-weight: normal !important; |
|
188 | font-weight: normal !important; | |
189 | overflow: visible !important; |
|
189 | overflow: visible !important; | |
190 | line-height: 140% !important; |
|
190 | line-height: 140% !important; | |
191 | } |
|
191 | } | |
192 |
|
192 | |||
193 | div.markdown-block pre { |
|
193 | div.markdown-block pre { | |
194 | margin: 3px 0px 13px 0px !important; |
|
194 | margin: 3px 0px 13px 0px !important; | |
195 | padding: .5em; |
|
195 | padding: .5em; | |
196 | color: #424242 !important; |
|
196 | color: #424242 !important; | |
197 | font-size: 13px !important; |
|
197 | font-size: 13px !important; | |
198 | overflow: visible !important; |
|
198 | overflow: visible !important; | |
199 | line-height: 140% !important; |
|
199 | line-height: 140% !important; | |
200 | background-color: @grey7; |
|
200 | background-color: @grey7; | |
201 | } |
|
201 | } | |
202 |
|
202 | |||
203 | div.markdown-block img { |
|
203 | div.markdown-block img { | |
204 | border-style: none; |
|
204 | border-style: none; | |
205 | background-color: #fff; |
|
205 | background-color: #fff; | |
206 | padding-right: 20px; |
|
206 | padding-right: 20px; | |
|
207 | max-width: 100%; | |||
207 | } |
|
208 | } | |
208 |
|
209 | |||
209 |
|
210 | |||
210 | div.markdown-block strong { |
|
211 | div.markdown-block strong { | |
211 | font-weight: 600; |
|
212 | font-weight: 600; | |
212 | margin: 0; |
|
213 | margin: 0; | |
213 | } |
|
214 | } | |
214 |
|
215 | |||
215 | div.markdown-block ul.checkbox, |
|
216 | div.markdown-block ul.checkbox, | |
216 | div.markdown-block ol.checkbox { |
|
217 | div.markdown-block ol.checkbox { | |
217 | padding-left: 20px !important; |
|
218 | padding-left: 20px !important; | |
218 | margin-top: 0px !important; |
|
219 | margin-top: 0px !important; | |
219 | margin-bottom: 18px !important; |
|
220 | margin-bottom: 18px !important; | |
220 | } |
|
221 | } | |
221 |
|
222 | |||
222 | div.markdown-block ul, |
|
223 | div.markdown-block ul, | |
223 | div.markdown-block ol { |
|
224 | div.markdown-block ol { | |
224 | padding-left: 30px !important; |
|
225 | padding-left: 30px !important; | |
225 | margin-top: 0px !important; |
|
226 | margin-top: 0px !important; | |
226 | margin-bottom: 18px !important; |
|
227 | margin-bottom: 18px !important; | |
227 | } |
|
228 | } | |
228 |
|
229 | |||
229 | div.markdown-block ul.checkbox li, |
|
230 | div.markdown-block ul.checkbox li, | |
230 | div.markdown-block ol.checkbox li { |
|
231 | div.markdown-block ol.checkbox li { | |
231 | list-style: none !important; |
|
232 | list-style: none !important; | |
232 | margin: 6px !important; |
|
233 | margin: 6px !important; | |
233 | padding: 0 !important; |
|
234 | padding: 0 !important; | |
234 | } |
|
235 | } | |
235 |
|
236 | |||
236 | div.markdown-block ul li, |
|
237 | div.markdown-block ul li, | |
237 | div.markdown-block ol li { |
|
238 | div.markdown-block ol li { | |
238 | list-style: disc !important; |
|
239 | list-style: disc !important; | |
239 | margin: 6px !important; |
|
240 | margin: 6px !important; | |
240 | padding: 0 !important; |
|
241 | padding: 0 !important; | |
241 | } |
|
242 | } | |
242 |
|
243 | |||
243 | div.markdown-block ol li { |
|
244 | div.markdown-block ol li { | |
244 | list-style: decimal !important; |
|
245 | list-style: decimal !important; | |
245 | } |
|
246 | } | |
246 |
|
247 | |||
247 | /* |
|
248 | /* | |
248 | div.markdown-block a, |
|
249 | div.markdown-block a, | |
249 | div.markdown-block a:visited { |
|
250 | div.markdown-block a:visited { | |
250 | color: #4183C4 !important; |
|
251 | color: #4183C4 !important; | |
251 | background-color: inherit; |
|
252 | background-color: inherit; | |
252 | text-decoration: none; |
|
253 | text-decoration: none; | |
253 | } |
|
254 | } | |
254 | */ |
|
255 | */ | |
255 |
|
256 | |||
256 | div.markdown-block #message { |
|
257 | div.markdown-block #message { | |
257 | .border-radius(@border-radius); |
|
258 | .border-radius(@border-radius); | |
258 | border: @border-thickness solid @grey5; |
|
259 | border: @border-thickness solid @grey5; | |
259 | display: block; |
|
260 | display: block; | |
260 | width: 100%; |
|
261 | width: 100%; | |
261 | height: 60px; |
|
262 | height: 60px; | |
262 | margin: 6px 0px; |
|
263 | margin: 6px 0px; | |
263 | } |
|
264 | } | |
264 |
|
265 | |||
265 | div.markdown-block button, |
|
266 | div.markdown-block button, | |
266 | div.markdown-block #ws { |
|
267 | div.markdown-block #ws { | |
267 | font-size: @basefontsize; |
|
268 | font-size: @basefontsize; | |
268 | padding: 4px 6px; |
|
269 | padding: 4px 6px; | |
269 | .border-radius(@border-radius); |
|
270 | .border-radius(@border-radius); | |
270 | border: @border-thickness solid @grey5; |
|
271 | border: @border-thickness solid @grey5; | |
271 | background-color: @grey6; |
|
272 | background-color: @grey6; | |
272 | } |
|
273 | } | |
273 |
|
274 | |||
274 | div.markdown-block code, |
|
275 | div.markdown-block code, | |
275 | div.markdown-block pre, |
|
276 | div.markdown-block pre, | |
276 | div.markdown-block #ws, |
|
277 | div.markdown-block #ws, | |
277 | div.markdown-block #message { |
|
278 | div.markdown-block #message { | |
278 | font-family: @text-monospace; |
|
279 | font-family: @text-monospace; | |
279 | font-size: 11px; |
|
280 | font-size: 11px; | |
280 | .border-radius(@border-radius); |
|
281 | .border-radius(@border-radius); | |
281 | background-color: white; |
|
282 | background-color: white; | |
282 | color: @grey3; |
|
283 | color: @grey3; | |
283 | } |
|
284 | } | |
284 |
|
285 | |||
285 |
|
286 | |||
286 | div.markdown-block code { |
|
287 | div.markdown-block code { | |
287 | border: @border-thickness solid @grey6; |
|
288 | border: @border-thickness solid @grey6; | |
288 | margin: 0 2px; |
|
289 | margin: 0 2px; | |
289 | padding: 0 5px; |
|
290 | padding: 0 5px; | |
290 | } |
|
291 | } | |
291 |
|
292 | |||
292 | div.markdown-block pre { |
|
293 | div.markdown-block pre { | |
293 | border: @border-thickness solid @grey5; |
|
294 | border: @border-thickness solid @grey5; | |
294 | overflow: auto; |
|
295 | overflow: auto; | |
295 | padding: .5em; |
|
296 | padding: .5em; | |
296 | background-color: @grey7; |
|
297 | background-color: @grey7; | |
297 | } |
|
298 | } | |
298 |
|
299 | |||
299 | div.markdown-block pre > code { |
|
300 | div.markdown-block pre > code { | |
300 | border: 0; |
|
301 | border: 0; | |
301 | margin: 0; |
|
302 | margin: 0; | |
302 | padding: 0; |
|
303 | padding: 0; | |
303 | } |
|
304 | } | |
304 |
|
305 | |||
305 | /** RST STYLE **/ |
|
306 | /** RST STYLE **/ | |
306 | div.rst-block { |
|
307 | div.rst-block { | |
307 | clear: both; |
|
308 | clear: both; | |
308 | overflow: hidden; |
|
309 | overflow: hidden; | |
309 | margin: 0; |
|
310 | margin: 0; | |
310 | padding: 3px 15px 3px; |
|
311 | padding: 3px 15px 3px; | |
311 | } |
|
312 | } | |
312 |
|
313 | |||
313 | div.rst-block h2 { |
|
314 | div.rst-block h2 { | |
314 | font-weight: normal; |
|
315 | font-weight: normal; | |
315 | } |
|
316 | } | |
316 |
|
317 | |||
317 | div.rst-block h1, |
|
318 | div.rst-block h1, | |
318 | div.rst-block h2, |
|
319 | div.rst-block h2, | |
319 | div.rst-block h3, |
|
320 | div.rst-block h3, | |
320 | div.rst-block h4, |
|
321 | div.rst-block h4, | |
321 | div.rst-block h5, |
|
322 | div.rst-block h5, | |
322 | div.rst-block h6 { |
|
323 | div.rst-block h6 { | |
323 | border-bottom: 0 !important; |
|
324 | border-bottom: 0 !important; | |
324 | margin: 0 !important; |
|
325 | margin: 0 !important; | |
325 | padding: 0 !important; |
|
326 | padding: 0 !important; | |
326 | line-height: 1.5em !important; |
|
327 | line-height: 1.5em !important; | |
327 | } |
|
328 | } | |
328 |
|
329 | |||
329 |
|
330 | |||
330 | div.rst-block h1:first-child { |
|
331 | div.rst-block h1:first-child { | |
331 | padding-top: .25em !important; |
|
332 | padding-top: .25em !important; | |
332 | } |
|
333 | } | |
333 |
|
334 | |||
334 | div.rst-block h2, |
|
335 | div.rst-block h2, | |
335 | div.rst-block h3 { |
|
336 | div.rst-block h3 { | |
336 | margin: 1em 0 !important; |
|
337 | margin: 1em 0 !important; | |
337 | } |
|
338 | } | |
338 |
|
339 | |||
339 | div.rst-block h1, |
|
340 | div.rst-block h1, | |
340 | div.rst-block h2 { |
|
341 | div.rst-block h2 { | |
341 | border-bottom: 1px #e6e5e5 solid !important; |
|
342 | border-bottom: 1px #e6e5e5 solid !important; | |
342 | } |
|
343 | } | |
343 |
|
344 | |||
344 | div.rst-block h2 { |
|
345 | div.rst-block h2 { | |
345 | margin-top: 1.5em !important; |
|
346 | margin-top: 1.5em !important; | |
346 | padding-top: .5em !important; |
|
347 | padding-top: .5em !important; | |
347 | } |
|
348 | } | |
348 |
|
349 | |||
349 | div.rst-block p { |
|
350 | div.rst-block p { | |
350 | color: black !important; |
|
351 | color: black !important; | |
351 | margin: 1em 0 !important; |
|
352 | margin: 1em 0 !important; | |
352 | line-height: 1.5em !important; |
|
353 | line-height: 1.5em !important; | |
353 | } |
|
354 | } | |
354 |
|
355 | |||
355 | div.rst-block ul { |
|
356 | div.rst-block ul { | |
356 | list-style: disc !important; |
|
357 | list-style: disc !important; | |
357 | margin: 1em 0 1em 2em !important; |
|
358 | margin: 1em 0 1em 2em !important; | |
358 | clear: both; |
|
359 | clear: both; | |
359 | } |
|
360 | } | |
360 |
|
361 | |||
361 | div.rst-block ol { |
|
362 | div.rst-block ol { | |
362 | list-style: decimal; |
|
363 | list-style: decimal; | |
363 | margin: 1em 0 1em 2em !important; |
|
364 | margin: 1em 0 1em 2em !important; | |
364 | } |
|
365 | } | |
365 |
|
366 | |||
366 | div.rst-block pre, |
|
367 | div.rst-block pre, | |
367 | div.rst-block code { |
|
368 | div.rst-block code { | |
368 | font: 12px "Bitstream Vera Sans Mono","Courier",monospace; |
|
369 | font: 12px "Bitstream Vera Sans Mono","Courier",monospace; | |
369 | } |
|
370 | } | |
370 |
|
371 | |||
371 | div.rst-block code { |
|
372 | div.rst-block code { | |
372 | font-size: 12px !important; |
|
373 | font-size: 12px !important; | |
373 | background-color: ghostWhite !important; |
|
374 | background-color: ghostWhite !important; | |
374 | color: #444 !important; |
|
375 | color: #444 !important; | |
375 | padding: 0 .2em !important; |
|
376 | padding: 0 .2em !important; | |
376 | border: 1px solid #dedede !important; |
|
377 | border: 1px solid #dedede !important; | |
377 | } |
|
378 | } | |
378 |
|
379 | |||
379 | div.rst-block pre code { |
|
380 | div.rst-block pre code { | |
380 | padding: 0 !important; |
|
381 | padding: 0 !important; | |
381 | font-size: 12px !important; |
|
382 | font-size: 12px !important; | |
382 | background-color: #eee !important; |
|
383 | background-color: #eee !important; | |
383 | border: none !important; |
|
384 | border: none !important; | |
384 | } |
|
385 | } | |
385 |
|
386 | |||
386 | div.rst-block pre { |
|
387 | div.rst-block pre { | |
387 | margin: 1em 0; |
|
388 | margin: 1em 0; | |
388 | padding: @padding; |
|
389 | padding: @padding; | |
389 | border: 1px solid @grey6; |
|
390 | border: 1px solid @grey6; | |
390 | .border-radius(@border-radius); |
|
391 | .border-radius(@border-radius); | |
391 | overflow: auto; |
|
392 | overflow: auto; | |
392 | font-size: 12px; |
|
393 | font-size: 12px; | |
393 | color: #444; |
|
394 | color: #444; | |
394 | background-color: @grey7; |
|
395 | background-color: @grey7; | |
395 | } |
|
396 | } | |
396 |
|
397 | |||
397 |
|
398 |
@@ -1,510 +1,514 b'' | |||||
1 |
|
1 | |||
2 | // tables.less |
|
2 | // tables.less | |
3 | // For use in RhodeCode application tables; |
|
3 | // For use in RhodeCode application tables; | |
4 | // see style guide documentation for guidelines. |
|
4 | // see style guide documentation for guidelines. | |
5 |
|
5 | |||
6 | // TABLES |
|
6 | // TABLES | |
7 |
|
7 | |||
8 | .rctable, |
|
8 | .rctable, | |
9 | table.rctable, |
|
9 | table.rctable, | |
10 | table.dataTable { |
|
10 | table.dataTable { | |
11 | clear:both; |
|
11 | clear:both; | |
12 | width: 100%; |
|
12 | width: 100%; | |
13 | margin: 0 auto @padding; |
|
13 | margin: 0 auto @padding; | |
14 | padding: 0; |
|
14 | padding: 0; | |
15 | vertical-align: baseline; |
|
15 | vertical-align: baseline; | |
16 | line-height:1.5em; |
|
16 | line-height:1.5em; | |
17 | border: none; |
|
17 | border: none; | |
18 | outline: none; |
|
18 | outline: none; | |
19 | border-collapse: collapse; |
|
19 | border-collapse: collapse; | |
20 | border-spacing: 0; |
|
20 | border-spacing: 0; | |
21 | color: @grey2; |
|
21 | color: @grey2; | |
22 |
|
22 | |||
23 | b { |
|
23 | b { | |
24 | font-weight: normal; |
|
24 | font-weight: normal; | |
25 | } |
|
25 | } | |
26 |
|
26 | |||
27 | em { |
|
27 | em { | |
28 | font-weight: bold; |
|
28 | font-weight: bold; | |
29 | font-style: normal; |
|
29 | font-style: normal; | |
30 | } |
|
30 | } | |
31 |
|
31 | |||
32 | th, |
|
32 | th, | |
33 | td { |
|
33 | td { | |
34 | height: auto; |
|
34 | height: auto; | |
35 | max-width: 20%; |
|
35 | max-width: 20%; | |
36 | padding: .65em 0 .65em 1em; |
|
36 | padding: .65em 0 .65em 1em; | |
37 | vertical-align: middle; |
|
37 | vertical-align: middle; | |
38 | border-bottom: @border-thickness solid @grey5; |
|
38 | border-bottom: @border-thickness solid @grey5; | |
39 | white-space: normal; |
|
39 | white-space: normal; | |
40 |
|
40 | |||
41 | &.td-radio, |
|
41 | &.td-radio, | |
42 | &.td-checkbox { |
|
42 | &.td-checkbox { | |
43 | padding-right: 0; |
|
43 | padding-right: 0; | |
44 | text-align: center; |
|
44 | text-align: center; | |
45 |
|
45 | |||
46 | input { |
|
46 | input { | |
47 | margin: 0 1em; |
|
47 | margin: 0 1em; | |
48 | } |
|
48 | } | |
49 | } |
|
49 | } | |
50 |
|
50 | |||
51 | &.truncate-wrap { |
|
51 | &.truncate-wrap { | |
52 | white-space: nowrap !important; |
|
52 | white-space: nowrap !important; | |
53 | } |
|
53 | } | |
54 |
|
54 | |||
55 | pre { |
|
55 | pre { | |
56 | margin: 0; |
|
56 | margin: 0; | |
57 | } |
|
57 | } | |
58 |
|
58 | |||
59 | .show_more { |
|
59 | .show_more { | |
60 | height: inherit; |
|
60 | height: inherit; | |
61 | } |
|
61 | } | |
62 | } |
|
62 | } | |
63 |
|
63 | |||
64 | .expired td { |
|
64 | .expired td { | |
65 | background-color: @grey7; |
|
65 | background-color: @grey7; | |
66 | } |
|
66 | } | |
67 | .inactive td { |
|
67 | .inactive td { | |
68 | background-color: @grey6; |
|
68 | background-color: @grey6; | |
69 | } |
|
69 | } | |
70 | th { |
|
70 | th { | |
71 | text-align: left; |
|
71 | text-align: left; | |
72 | font-weight: @text-semibold-weight; |
|
72 | font-weight: @text-semibold-weight; | |
73 | font-family: @text-semibold; |
|
73 | font-family: @text-semibold; | |
74 | } |
|
74 | } | |
75 |
|
75 | |||
76 | .hl { |
|
76 | .hl { | |
77 | td { |
|
77 | td { | |
78 | background-color: lighten(@alert4,25%); |
|
78 | background-color: lighten(@alert4,25%); | |
79 | } |
|
79 | } | |
80 | } |
|
80 | } | |
81 |
|
81 | |||
82 | // Special Data Cell Types |
|
82 | // Special Data Cell Types | |
83 | // See style guide for desciptions and examples. |
|
83 | // See style guide for desciptions and examples. | |
84 |
|
84 | |||
85 | td { |
|
85 | td { | |
86 |
|
86 | |||
87 | &.user { |
|
87 | &.user { | |
88 | padding-left: 1em; |
|
88 | padding-left: 1em; | |
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 | &.td-rss { |
|
91 | &.td-rss { | |
92 | width: 20px; |
|
92 | width: 20px; | |
93 | min-width: 0; |
|
93 | min-width: 0; | |
94 | margin: 0; |
|
94 | margin: 0; | |
95 | } |
|
95 | } | |
96 |
|
96 | |||
97 | &.quick_repo_menu { |
|
97 | &.quick_repo_menu { | |
98 | width: 15px; |
|
98 | width: 15px; | |
99 | text-align: center; |
|
99 | text-align: center; | |
100 |
|
100 | |||
101 | &:hover { |
|
101 | &:hover { | |
102 | background-color: @grey5; |
|
102 | background-color: @grey5; | |
103 | } |
|
103 | } | |
104 | } |
|
104 | } | |
105 |
|
105 | |||
106 | &.td-icon { |
|
106 | &.td-icon { | |
107 | min-width: 20px; |
|
107 | min-width: 20px; | |
108 | width: 20px; |
|
108 | width: 20px; | |
109 | } |
|
109 | } | |
110 |
|
110 | |||
111 | &.td-hash { |
|
111 | &.td-hash { | |
112 | min-width: 80px; |
|
112 | min-width: 80px; | |
113 | width: 200px; |
|
113 | width: 200px; | |
114 |
|
114 | |||
115 | .obsolete { |
|
115 | .obsolete { | |
116 | text-decoration: line-through; |
|
116 | text-decoration: line-through; | |
117 | color: lighten(@grey2,25%); |
|
117 | color: lighten(@grey2,25%); | |
118 | } |
|
118 | } | |
119 | } |
|
119 | } | |
120 |
|
120 | |||
|
121 | &.td-sha { | |||
|
122 | white-space: nowrap; | |||
|
123 | } | |||
|
124 | ||||
121 | &.td-graphbox { |
|
125 | &.td-graphbox { | |
122 | width: 100px; |
|
126 | width: 100px; | |
123 | max-width: 100px; |
|
127 | max-width: 100px; | |
124 | min-width: 100px; |
|
128 | min-width: 100px; | |
125 | } |
|
129 | } | |
126 |
|
130 | |||
127 | &.td-time { |
|
131 | &.td-time { | |
128 | width: 160px; |
|
132 | width: 160px; | |
129 | white-space: nowrap; |
|
133 | white-space: nowrap; | |
130 | } |
|
134 | } | |
131 |
|
135 | |||
132 | &.annotate{ |
|
136 | &.annotate{ | |
133 | padding-right: 0; |
|
137 | padding-right: 0; | |
134 |
|
138 | |||
135 | div.annotatediv{ |
|
139 | div.annotatediv{ | |
136 | margin: 0 0.7em; |
|
140 | margin: 0 0.7em; | |
137 | } |
|
141 | } | |
138 | } |
|
142 | } | |
139 |
|
143 | |||
140 | &.tags-col { |
|
144 | &.tags-col { | |
141 | padding-right: 0; |
|
145 | padding-right: 0; | |
142 | } |
|
146 | } | |
143 |
|
147 | |||
144 | &.td-description { |
|
148 | &.td-description { | |
145 | min-width: 350px; |
|
149 | min-width: 350px; | |
146 |
|
150 | |||
147 | &.truncate, .truncate-wrap { |
|
151 | &.truncate, .truncate-wrap { | |
148 | white-space: nowrap; |
|
152 | white-space: nowrap; | |
149 | overflow: hidden; |
|
153 | overflow: hidden; | |
150 | text-overflow: ellipsis; |
|
154 | text-overflow: ellipsis; | |
151 | max-width: 350px; |
|
155 | max-width: 350px; | |
152 | } |
|
156 | } | |
153 | } |
|
157 | } | |
154 |
|
158 | |||
155 | &.td-grid-name { |
|
159 | &.td-grid-name { | |
156 | white-space: nowrap; |
|
160 | white-space: nowrap; | |
157 | min-width: 300px; |
|
161 | min-width: 300px; | |
158 | } |
|
162 | } | |
159 |
|
163 | |||
160 | &.td-componentname { |
|
164 | &.td-componentname { | |
161 | white-space: nowrap; |
|
165 | white-space: nowrap; | |
162 | } |
|
166 | } | |
163 |
|
167 | |||
164 | &.td-name { |
|
168 | &.td-name { | |
165 |
|
169 | |||
166 | } |
|
170 | } | |
167 |
|
171 | |||
168 | &.td-journalaction { |
|
172 | &.td-journalaction { | |
169 | min-width: 300px; |
|
173 | min-width: 300px; | |
170 |
|
174 | |||
171 | .journal_action_params { |
|
175 | .journal_action_params { | |
172 | // waiting for feedback |
|
176 | // waiting for feedback | |
173 | } |
|
177 | } | |
174 | } |
|
178 | } | |
175 |
|
179 | |||
176 | &.td-active { |
|
180 | &.td-active { | |
177 | padding-left: .65em; |
|
181 | padding-left: .65em; | |
178 | } |
|
182 | } | |
179 |
|
183 | |||
180 | &.td-url { |
|
184 | &.td-url { | |
181 | white-space: nowrap; |
|
185 | white-space: nowrap; | |
182 | } |
|
186 | } | |
183 |
|
187 | |||
184 | &.td-comments { |
|
188 | &.td-comments { | |
185 | min-width: 3em; |
|
189 | min-width: 3em; | |
186 | } |
|
190 | } | |
187 |
|
191 | |||
188 | &.td-buttons { |
|
192 | &.td-buttons { | |
189 | padding: .3em 0; |
|
193 | padding: .3em 0; | |
190 | } |
|
194 | } | |
191 | &.td-align-top { |
|
195 | &.td-align-top { | |
192 | vertical-align: text-top |
|
196 | vertical-align: text-top | |
193 | } |
|
197 | } | |
194 | &.td-action { |
|
198 | &.td-action { | |
195 | // this is for the remove/delete/edit buttons |
|
199 | // this is for the remove/delete/edit buttons | |
196 | padding-right: 0; |
|
200 | padding-right: 0; | |
197 | min-width: 95px; |
|
201 | min-width: 95px; | |
198 | text-transform: capitalize; |
|
202 | text-transform: capitalize; | |
199 |
|
203 | |||
200 | i { |
|
204 | i { | |
201 | display: none; |
|
205 | display: none; | |
202 | } |
|
206 | } | |
203 | } |
|
207 | } | |
204 |
|
208 | |||
205 | // TODO: lisa: this needs to be cleaned up with the buttons |
|
209 | // TODO: lisa: this needs to be cleaned up with the buttons | |
206 | .grid_edit, |
|
210 | .grid_edit, | |
207 | .grid_delete { |
|
211 | .grid_delete { | |
208 | display: inline-block; |
|
212 | display: inline-block; | |
209 | margin: 0 @padding/3 0 0; |
|
213 | margin: 0 @padding/3 0 0; | |
210 | font-family: @text-light; |
|
214 | font-family: @text-light; | |
211 |
|
215 | |||
212 | i { |
|
216 | i { | |
213 | display: none; |
|
217 | display: none; | |
214 | } |
|
218 | } | |
215 | } |
|
219 | } | |
216 |
|
220 | |||
217 | .grid_edit + .grid_delete { |
|
221 | .grid_edit + .grid_delete { | |
218 | border-left: @border-thickness solid @grey5; |
|
222 | border-left: @border-thickness solid @grey5; | |
219 | padding-left: @padding/2; |
|
223 | padding-left: @padding/2; | |
220 | } |
|
224 | } | |
221 |
|
225 | |||
222 | &.td-compare { |
|
226 | &.td-compare { | |
223 |
|
227 | |||
224 | input { |
|
228 | input { | |
225 | margin-right: 1em; |
|
229 | margin-right: 1em; | |
226 | } |
|
230 | } | |
227 |
|
231 | |||
228 | .compare-radio-button { |
|
232 | .compare-radio-button { | |
229 | margin: 0 1em 0 0; |
|
233 | margin: 0 1em 0 0; | |
230 | } |
|
234 | } | |
231 |
|
235 | |||
232 |
|
236 | |||
233 | } |
|
237 | } | |
234 |
|
238 | |||
235 | &.td-tags { |
|
239 | &.td-tags { | |
236 | padding: .5em 1em .5em 0; |
|
240 | padding: .5em 1em .5em 0; | |
237 | width: 140px; |
|
241 | width: 140px; | |
238 |
|
242 | |||
239 | .tag { |
|
243 | .tag { | |
240 | margin: 1px; |
|
244 | margin: 1px; | |
241 | float: left; |
|
245 | float: left; | |
242 | } |
|
246 | } | |
243 | } |
|
247 | } | |
244 |
|
248 | |||
245 | .icon-svn, .icon-hg, .icon-git { |
|
249 | .icon-svn, .icon-hg, .icon-git { | |
246 | font-size: 1.4em; |
|
250 | font-size: 1.4em; | |
247 | } |
|
251 | } | |
248 |
|
252 | |||
249 | &.collapse_commit, |
|
253 | &.collapse_commit, | |
250 | &.expand_commit { |
|
254 | &.expand_commit { | |
251 | padding-right: 0; |
|
255 | padding-right: 0; | |
252 | padding-left: 1em; |
|
256 | padding-left: 1em; | |
253 | cursor: pointer; |
|
257 | cursor: pointer; | |
254 | width: 20px; |
|
258 | width: 20px; | |
255 | } |
|
259 | } | |
256 | } |
|
260 | } | |
257 |
|
261 | |||
258 | .perm_admin_row { |
|
262 | .perm_admin_row { | |
259 | color: @grey4; |
|
263 | color: @grey4; | |
260 | background-color: @grey6; |
|
264 | background-color: @grey6; | |
261 | } |
|
265 | } | |
262 |
|
266 | |||
263 | .noborder { |
|
267 | .noborder { | |
264 | border: none; |
|
268 | border: none; | |
265 |
|
269 | |||
266 | td { |
|
270 | td { | |
267 | border: none; |
|
271 | border: none; | |
268 | } |
|
272 | } | |
269 | } |
|
273 | } | |
270 | } |
|
274 | } | |
271 | .rctable.audit-log { |
|
275 | .rctable.audit-log { | |
272 | td { |
|
276 | td { | |
273 | vertical-align: top; |
|
277 | vertical-align: top; | |
274 | } |
|
278 | } | |
275 | } |
|
279 | } | |
276 |
|
280 | |||
277 | // TRUNCATING |
|
281 | // TRUNCATING | |
278 | // TODO: lisaq: should this possibly be moved out of tables.less? |
|
282 | // TODO: lisaq: should this possibly be moved out of tables.less? | |
279 | // for truncated text |
|
283 | // for truncated text | |
280 | // used inside of table cells and in code block headers |
|
284 | // used inside of table cells and in code block headers | |
281 | .truncate-wrap { |
|
285 | .truncate-wrap { | |
282 | white-space: nowrap !important; |
|
286 | white-space: nowrap !important; | |
283 |
|
287 | |||
284 | //truncated text |
|
288 | //truncated text | |
285 | .truncate { |
|
289 | .truncate { | |
286 | max-width: 450px; |
|
290 | max-width: 450px; | |
287 | width: 300px; |
|
291 | width: 300px; | |
288 | overflow: hidden; |
|
292 | overflow: hidden; | |
289 | text-overflow: ellipsis; |
|
293 | text-overflow: ellipsis; | |
290 | -o-text-overflow: ellipsis; |
|
294 | -o-text-overflow: ellipsis; | |
291 | -ms-text-overflow: ellipsis; |
|
295 | -ms-text-overflow: ellipsis; | |
292 |
|
296 | |||
293 | &.autoexpand { |
|
297 | &.autoexpand { | |
294 | width: 120px; |
|
298 | width: 120px; | |
295 | margin-right: 200px; |
|
299 | margin-right: 200px; | |
296 | } |
|
300 | } | |
297 | } |
|
301 | } | |
298 | &:hover .truncate.autoexpand { |
|
302 | &:hover .truncate.autoexpand { | |
299 | overflow: visible; |
|
303 | overflow: visible; | |
300 | } |
|
304 | } | |
301 |
|
305 | |||
302 | .tags-truncate { |
|
306 | .tags-truncate { | |
303 | width: 150px; |
|
307 | width: 150px; | |
304 | height: 22px; |
|
308 | height: 22px; | |
305 | overflow: hidden; |
|
309 | overflow: hidden; | |
306 |
|
310 | |||
307 | .tag { |
|
311 | .tag { | |
308 | display: inline-block; |
|
312 | display: inline-block; | |
309 | } |
|
313 | } | |
310 |
|
314 | |||
311 | &.truncate { |
|
315 | &.truncate { | |
312 | height: 22px; |
|
316 | height: 22px; | |
313 | max-height:2em; |
|
317 | max-height:2em; | |
314 | width: 140px; |
|
318 | width: 140px; | |
315 | } |
|
319 | } | |
316 | } |
|
320 | } | |
317 | } |
|
321 | } | |
318 |
|
322 | |||
319 | .apikeys_wrap { |
|
323 | .apikeys_wrap { | |
320 | margin-bottom: @padding; |
|
324 | margin-bottom: @padding; | |
321 |
|
325 | |||
322 | table.rctable td:first-child { |
|
326 | table.rctable td:first-child { | |
323 | width: 340px; |
|
327 | width: 340px; | |
324 | } |
|
328 | } | |
325 | } |
|
329 | } | |
326 |
|
330 | |||
327 |
|
331 | |||
328 |
|
332 | |||
329 | // SPECIAL CASES |
|
333 | // SPECIAL CASES | |
330 |
|
334 | |||
331 | // Repository Followers |
|
335 | // Repository Followers | |
332 | table.rctable.followers_data { |
|
336 | table.rctable.followers_data { | |
333 | width: 75%; |
|
337 | width: 75%; | |
334 | margin: 0; |
|
338 | margin: 0; | |
335 | } |
|
339 | } | |
336 |
|
340 | |||
337 | // Repository List |
|
341 | // Repository List | |
338 | // Group Members List |
|
342 | // Group Members List | |
339 | table.rctable.group_members, |
|
343 | table.rctable.group_members, | |
340 | table#repo_list_table { |
|
344 | table#repo_list_table { | |
341 | min-width: 600px; |
|
345 | min-width: 600px; | |
342 | } |
|
346 | } | |
343 |
|
347 | |||
344 | // Keyboard mappings |
|
348 | // Keyboard mappings | |
345 | table.keyboard-mappings { |
|
349 | table.keyboard-mappings { | |
346 | th { |
|
350 | th { | |
347 | text-align: left; |
|
351 | text-align: left; | |
348 | font-weight: @text-semibold-weight; |
|
352 | font-weight: @text-semibold-weight; | |
349 | font-family: @text-semibold; |
|
353 | font-family: @text-semibold; | |
350 | } |
|
354 | } | |
351 | } |
|
355 | } | |
352 |
|
356 | |||
353 | // Branches, Tags, and Bookmarks |
|
357 | // Branches, Tags, and Bookmarks | |
354 | #obj_list_table.dataTable { |
|
358 | #obj_list_table.dataTable { | |
355 | td.td-time { |
|
359 | td.td-time { | |
356 | padding-right: 1em; |
|
360 | padding-right: 1em; | |
357 | } |
|
361 | } | |
358 | } |
|
362 | } | |
359 |
|
363 | |||
360 | // User Admin |
|
364 | // User Admin | |
361 | .rctable.useremails, |
|
365 | .rctable.useremails, | |
362 | .rctable.account_emails { |
|
366 | .rctable.account_emails { | |
363 | .tag, |
|
367 | .tag, | |
364 | .btn { |
|
368 | .btn { | |
365 | float: right; |
|
369 | float: right; | |
366 | } |
|
370 | } | |
367 | .btn { //to line up with tags |
|
371 | .btn { //to line up with tags | |
368 | margin-right: 1.65em; |
|
372 | margin-right: 1.65em; | |
369 | } |
|
373 | } | |
370 | } |
|
374 | } | |
371 |
|
375 | |||
372 | // User List |
|
376 | // User List | |
373 | #user_list_table { |
|
377 | #user_list_table { | |
374 |
|
378 | |||
375 | td.td-user { |
|
379 | td.td-user { | |
376 | min-width: 100px; |
|
380 | min-width: 100px; | |
377 | } |
|
381 | } | |
378 | } |
|
382 | } | |
379 |
|
383 | |||
380 | // Pull Request List Table |
|
384 | // Pull Request List Table | |
381 | #pull_request_list_table.dataTable { |
|
385 | #pull_request_list_table.dataTable { | |
382 |
|
386 | |||
383 | //TODO: lisa: This needs to be removed once the description is adjusted |
|
387 | //TODO: lisa: This needs to be removed once the description is adjusted | |
384 | // for using an expand_commit button (see issue 765) |
|
388 | // for using an expand_commit button (see issue 765) | |
385 | td { |
|
389 | td { | |
386 | vertical-align: middle; |
|
390 | vertical-align: middle; | |
387 | } |
|
391 | } | |
388 | } |
|
392 | } | |
389 |
|
393 | |||
390 | // Settings (no border) |
|
394 | // Settings (no border) | |
391 | table.rctable.dl-settings { |
|
395 | table.rctable.dl-settings { | |
392 | td { |
|
396 | td { | |
393 | border: none; |
|
397 | border: none; | |
394 | vertical-align: baseline; |
|
398 | vertical-align: baseline; | |
395 | } |
|
399 | } | |
396 | } |
|
400 | } | |
397 |
|
401 | |||
398 |
|
402 | |||
399 | // Statistics |
|
403 | // Statistics | |
400 | table.trending_language_tbl { |
|
404 | table.trending_language_tbl { | |
401 | width: 100%; |
|
405 | width: 100%; | |
402 | line-height: 1em; |
|
406 | line-height: 1em; | |
403 |
|
407 | |||
404 | td div { |
|
408 | td div { | |
405 | overflow: visible; |
|
409 | overflow: visible; | |
406 | } |
|
410 | } | |
407 | } |
|
411 | } | |
408 |
|
412 | |||
409 | .trending_language_tbl, .trending_language_tbl td { |
|
413 | .trending_language_tbl, .trending_language_tbl td { | |
410 | border: 0; |
|
414 | border: 0; | |
411 | margin: 0; |
|
415 | margin: 0; | |
412 | padding: 0; |
|
416 | padding: 0; | |
413 | background: transparent; |
|
417 | background: transparent; | |
414 | } |
|
418 | } | |
415 |
|
419 | |||
416 | .trending_language_tbl, .trending_language_tbl tr { |
|
420 | .trending_language_tbl, .trending_language_tbl tr { | |
417 | border-spacing: 0 3px; |
|
421 | border-spacing: 0 3px; | |
418 | } |
|
422 | } | |
419 |
|
423 | |||
420 | .trending_language { |
|
424 | .trending_language { | |
421 | position: relative; |
|
425 | position: relative; | |
422 | overflow: hidden; |
|
426 | overflow: hidden; | |
423 | color: @text-color; |
|
427 | color: @text-color; | |
424 | width: 400px; |
|
428 | width: 400px; | |
425 |
|
429 | |||
426 | .lang-bar { |
|
430 | .lang-bar { | |
427 | z-index: 1; |
|
431 | z-index: 1; | |
428 | overflow: hidden; |
|
432 | overflow: hidden; | |
429 | background-color: @rcblue; |
|
433 | background-color: @rcblue; | |
430 | color: #FFF; |
|
434 | color: #FFF; | |
431 | text-decoration: none; |
|
435 | text-decoration: none; | |
432 | } |
|
436 | } | |
433 |
|
437 | |||
434 | } |
|
438 | } | |
435 |
|
439 | |||
436 | // Changesets |
|
440 | // Changesets | |
437 | #changesets.rctable { |
|
441 | #changesets.rctable { | |
438 | th { |
|
442 | th { | |
439 | padding: 0 1em 0.65em 0; |
|
443 | padding: 0 1em 0.65em 0; | |
440 | } |
|
444 | } | |
441 |
|
445 | |||
442 | // td must be fixed height for graph |
|
446 | // td must be fixed height for graph | |
443 | td { |
|
447 | td { | |
444 | height: 32px; |
|
448 | height: 32px; | |
445 | padding: 0 1em 0 0; |
|
449 | padding: 0 1em 0 0; | |
446 | vertical-align: middle; |
|
450 | vertical-align: middle; | |
447 | white-space: nowrap; |
|
451 | white-space: nowrap; | |
448 |
|
452 | |||
449 | &.td-description { |
|
453 | &.td-description { | |
450 | white-space: normal; |
|
454 | white-space: normal; | |
451 | } |
|
455 | } | |
452 |
|
456 | |||
453 | &.expand_commit { |
|
457 | &.expand_commit { | |
454 | padding-right: 0; |
|
458 | padding-right: 0; | |
455 | cursor: pointer; |
|
459 | cursor: pointer; | |
456 | width: 20px; |
|
460 | width: 20px; | |
457 | } |
|
461 | } | |
458 | } |
|
462 | } | |
459 | } |
|
463 | } | |
460 |
|
464 | |||
461 | // Compare |
|
465 | // Compare | |
462 | table.compare_view_commits { |
|
466 | table.compare_view_commits { | |
463 | margin-top: @space; |
|
467 | margin-top: @space; | |
464 |
|
468 | |||
465 | td.td-time { |
|
469 | td.td-time { | |
466 | padding-left: .5em; |
|
470 | padding-left: .5em; | |
467 | } |
|
471 | } | |
468 |
|
472 | |||
469 | // special case to not show hover actions on hidden indicator |
|
473 | // special case to not show hover actions on hidden indicator | |
470 | tr.compare_select_hidden:hover { |
|
474 | tr.compare_select_hidden:hover { | |
471 | cursor: inherit; |
|
475 | cursor: inherit; | |
472 |
|
476 | |||
473 | td { |
|
477 | td { | |
474 | background-color: inherit; |
|
478 | background-color: inherit; | |
475 | } |
|
479 | } | |
476 | } |
|
480 | } | |
477 |
|
481 | |||
478 | tr:hover { |
|
482 | tr:hover { | |
479 | cursor: pointer; |
|
483 | cursor: pointer; | |
480 |
|
484 | |||
481 | td { |
|
485 | td { | |
482 | background-color: lighten(@alert4,25%); |
|
486 | background-color: lighten(@alert4,25%); | |
483 | } |
|
487 | } | |
484 | } |
|
488 | } | |
485 |
|
489 | |||
486 |
|
490 | |||
487 | } |
|
491 | } | |
488 |
|
492 | |||
489 | .file_history { |
|
493 | .file_history { | |
490 | td.td-actions { |
|
494 | td.td-actions { | |
491 | text-align: right; |
|
495 | text-align: right; | |
492 | } |
|
496 | } | |
493 | } |
|
497 | } | |
494 |
|
498 | |||
495 |
|
499 | |||
496 | // Gist List |
|
500 | // Gist List | |
497 | #gist_list_table { |
|
501 | #gist_list_table { | |
498 | td { |
|
502 | td { | |
499 | vertical-align: middle; |
|
503 | vertical-align: middle; | |
500 |
|
504 | |||
501 | div{ |
|
505 | div{ | |
502 | display: inline-block; |
|
506 | display: inline-block; | |
503 | vertical-align: middle; |
|
507 | vertical-align: middle; | |
504 | } |
|
508 | } | |
505 |
|
509 | |||
506 | img{ |
|
510 | img{ | |
507 | vertical-align: middle; |
|
511 | vertical-align: middle; | |
508 | } |
|
512 | } | |
509 | } |
|
513 | } | |
510 | } |
|
514 | } |
@@ -1,380 +1,381 b'' | |||||
1 |
|
1 | |||
2 | /****************************************************************************** |
|
2 | /****************************************************************************** | |
3 | * * |
|
3 | * * | |
4 | * DO NOT CHANGE THIS FILE MANUALLY * |
|
4 | * DO NOT CHANGE THIS FILE MANUALLY * | |
5 | * * |
|
5 | * * | |
6 | * * |
|
6 | * * | |
7 | * This file is automatically generated when the app starts up with * |
|
7 | * This file is automatically generated when the app starts up with * | |
8 | * generate_js_files = true * |
|
8 | * generate_js_files = true * | |
9 | * * |
|
9 | * * | |
10 | * To add a route here pass jsroute=True to the route definition in the app * |
|
10 | * To add a route here pass jsroute=True to the route definition in the app * | |
11 | * * |
|
11 | * * | |
12 | ******************************************************************************/ |
|
12 | ******************************************************************************/ | |
13 | function registerRCRoutes() { |
|
13 | function registerRCRoutes() { | |
14 | // routes registration |
|
14 | // routes registration | |
15 | pyroutes.register('favicon', '/favicon.ico', []); |
|
15 | pyroutes.register('favicon', '/favicon.ico', []); | |
16 | pyroutes.register('robots', '/robots.txt', []); |
|
16 | pyroutes.register('robots', '/robots.txt', []); | |
17 | pyroutes.register('auth_home', '/_admin/auth*traverse', []); |
|
17 | pyroutes.register('auth_home', '/_admin/auth*traverse', []); | |
18 | pyroutes.register('global_integrations_new', '/_admin/integrations/new', []); |
|
18 | pyroutes.register('global_integrations_new', '/_admin/integrations/new', []); | |
19 | pyroutes.register('global_integrations_home', '/_admin/integrations', []); |
|
19 | pyroutes.register('global_integrations_home', '/_admin/integrations', []); | |
20 | pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']); |
|
20 | pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']); | |
21 | pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']); |
|
21 | pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']); | |
22 | pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']); |
|
22 | pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']); | |
23 | pyroutes.register('repo_group_integrations_home', '/%(repo_group_name)s/_settings/integrations', ['repo_group_name']); |
|
23 | pyroutes.register('repo_group_integrations_home', '/%(repo_group_name)s/_settings/integrations', ['repo_group_name']); | |
24 | pyroutes.register('repo_group_integrations_new', '/%(repo_group_name)s/_settings/integrations/new', ['repo_group_name']); |
|
24 | pyroutes.register('repo_group_integrations_new', '/%(repo_group_name)s/_settings/integrations/new', ['repo_group_name']); | |
25 | pyroutes.register('repo_group_integrations_list', '/%(repo_group_name)s/_settings/integrations/%(integration)s', ['repo_group_name', 'integration']); |
|
25 | pyroutes.register('repo_group_integrations_list', '/%(repo_group_name)s/_settings/integrations/%(integration)s', ['repo_group_name', 'integration']); | |
26 | pyroutes.register('repo_group_integrations_create', '/%(repo_group_name)s/_settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']); |
|
26 | pyroutes.register('repo_group_integrations_create', '/%(repo_group_name)s/_settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']); | |
27 | pyroutes.register('repo_group_integrations_edit', '/%(repo_group_name)s/_settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']); |
|
27 | pyroutes.register('repo_group_integrations_edit', '/%(repo_group_name)s/_settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']); | |
28 | pyroutes.register('repo_integrations_home', '/%(repo_name)s/settings/integrations', ['repo_name']); |
|
28 | pyroutes.register('repo_integrations_home', '/%(repo_name)s/settings/integrations', ['repo_name']); | |
29 | pyroutes.register('repo_integrations_new', '/%(repo_name)s/settings/integrations/new', ['repo_name']); |
|
29 | pyroutes.register('repo_integrations_new', '/%(repo_name)s/settings/integrations/new', ['repo_name']); | |
30 | pyroutes.register('repo_integrations_list', '/%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']); |
|
30 | pyroutes.register('repo_integrations_list', '/%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']); | |
31 | pyroutes.register('repo_integrations_create', '/%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']); |
|
31 | pyroutes.register('repo_integrations_create', '/%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']); | |
32 | pyroutes.register('repo_integrations_edit', '/%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']); |
|
32 | pyroutes.register('repo_integrations_edit', '/%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']); | |
33 | pyroutes.register('ops_ping', '/_admin/ops/ping', []); |
|
33 | pyroutes.register('ops_ping', '/_admin/ops/ping', []); | |
34 | pyroutes.register('ops_error_test', '/_admin/ops/error', []); |
|
34 | pyroutes.register('ops_error_test', '/_admin/ops/error', []); | |
35 | pyroutes.register('ops_redirect_test', '/_admin/ops/redirect', []); |
|
35 | pyroutes.register('ops_redirect_test', '/_admin/ops/redirect', []); | |
36 | pyroutes.register('ops_ping_legacy', '/_admin/ping', []); |
|
36 | pyroutes.register('ops_ping_legacy', '/_admin/ping', []); | |
37 | pyroutes.register('ops_error_test_legacy', '/_admin/error_test', []); |
|
37 | pyroutes.register('ops_error_test_legacy', '/_admin/error_test', []); | |
38 | pyroutes.register('admin_home', '/_admin', []); |
|
38 | pyroutes.register('admin_home', '/_admin', []); | |
39 | pyroutes.register('admin_audit_logs', '/_admin/audit_logs', []); |
|
39 | pyroutes.register('admin_audit_logs', '/_admin/audit_logs', []); | |
40 | pyroutes.register('admin_audit_log_entry', '/_admin/audit_logs/%(audit_log_id)s', ['audit_log_id']); |
|
40 | pyroutes.register('admin_audit_log_entry', '/_admin/audit_logs/%(audit_log_id)s', ['audit_log_id']); | |
41 | pyroutes.register('pull_requests_global_0', '/_admin/pull_requests/%(pull_request_id)s', ['pull_request_id']); |
|
41 | pyroutes.register('pull_requests_global_0', '/_admin/pull_requests/%(pull_request_id)s', ['pull_request_id']); | |
42 | pyroutes.register('pull_requests_global_1', '/_admin/pull-requests/%(pull_request_id)s', ['pull_request_id']); |
|
42 | pyroutes.register('pull_requests_global_1', '/_admin/pull-requests/%(pull_request_id)s', ['pull_request_id']); | |
43 | pyroutes.register('pull_requests_global', '/_admin/pull-request/%(pull_request_id)s', ['pull_request_id']); |
|
43 | pyroutes.register('pull_requests_global', '/_admin/pull-request/%(pull_request_id)s', ['pull_request_id']); | |
44 | pyroutes.register('admin_settings_open_source', '/_admin/settings/open_source', []); |
|
44 | pyroutes.register('admin_settings_open_source', '/_admin/settings/open_source', []); | |
45 | pyroutes.register('admin_settings_vcs_svn_generate_cfg', '/_admin/settings/vcs/svn_generate_cfg', []); |
|
45 | pyroutes.register('admin_settings_vcs_svn_generate_cfg', '/_admin/settings/vcs/svn_generate_cfg', []); | |
46 | pyroutes.register('admin_settings_system', '/_admin/settings/system', []); |
|
46 | pyroutes.register('admin_settings_system', '/_admin/settings/system', []); | |
47 | pyroutes.register('admin_settings_system_update', '/_admin/settings/system/updates', []); |
|
47 | pyroutes.register('admin_settings_system_update', '/_admin/settings/system/updates', []); | |
48 | pyroutes.register('admin_settings_exception_tracker', '/_admin/settings/exceptions', []); |
|
48 | pyroutes.register('admin_settings_exception_tracker', '/_admin/settings/exceptions', []); | |
49 | pyroutes.register('admin_settings_exception_tracker_delete_all', '/_admin/settings/exceptions/delete', []); |
|
49 | pyroutes.register('admin_settings_exception_tracker_delete_all', '/_admin/settings/exceptions/delete', []); | |
50 | pyroutes.register('admin_settings_exception_tracker_show', '/_admin/settings/exceptions/%(exception_id)s', ['exception_id']); |
|
50 | pyroutes.register('admin_settings_exception_tracker_show', '/_admin/settings/exceptions/%(exception_id)s', ['exception_id']); | |
51 | pyroutes.register('admin_settings_exception_tracker_delete', '/_admin/settings/exceptions/%(exception_id)s/delete', ['exception_id']); |
|
51 | pyroutes.register('admin_settings_exception_tracker_delete', '/_admin/settings/exceptions/%(exception_id)s/delete', ['exception_id']); | |
52 | pyroutes.register('admin_settings_sessions', '/_admin/settings/sessions', []); |
|
52 | pyroutes.register('admin_settings_sessions', '/_admin/settings/sessions', []); | |
53 | pyroutes.register('admin_settings_sessions_cleanup', '/_admin/settings/sessions/cleanup', []); |
|
53 | pyroutes.register('admin_settings_sessions_cleanup', '/_admin/settings/sessions/cleanup', []); | |
54 | pyroutes.register('admin_settings_process_management', '/_admin/settings/process_management', []); |
|
54 | pyroutes.register('admin_settings_process_management', '/_admin/settings/process_management', []); | |
55 | pyroutes.register('admin_settings_process_management_data', '/_admin/settings/process_management/data', []); |
|
55 | pyroutes.register('admin_settings_process_management_data', '/_admin/settings/process_management/data', []); | |
56 | pyroutes.register('admin_settings_process_management_signal', '/_admin/settings/process_management/signal', []); |
|
56 | pyroutes.register('admin_settings_process_management_signal', '/_admin/settings/process_management/signal', []); | |
57 | pyroutes.register('admin_settings_process_management_master_signal', '/_admin/settings/process_management/master_signal', []); |
|
57 | pyroutes.register('admin_settings_process_management_master_signal', '/_admin/settings/process_management/master_signal', []); | |
58 | pyroutes.register('admin_defaults_repositories', '/_admin/defaults/repositories', []); |
|
58 | pyroutes.register('admin_defaults_repositories', '/_admin/defaults/repositories', []); | |
59 | pyroutes.register('admin_defaults_repositories_update', '/_admin/defaults/repositories/update', []); |
|
59 | pyroutes.register('admin_defaults_repositories_update', '/_admin/defaults/repositories/update', []); | |
60 | pyroutes.register('admin_settings', '/_admin/settings', []); |
|
60 | pyroutes.register('admin_settings', '/_admin/settings', []); | |
61 | pyroutes.register('admin_settings_update', '/_admin/settings/update', []); |
|
61 | pyroutes.register('admin_settings_update', '/_admin/settings/update', []); | |
62 | pyroutes.register('admin_settings_global', '/_admin/settings/global', []); |
|
62 | pyroutes.register('admin_settings_global', '/_admin/settings/global', []); | |
63 | pyroutes.register('admin_settings_global_update', '/_admin/settings/global/update', []); |
|
63 | pyroutes.register('admin_settings_global_update', '/_admin/settings/global/update', []); | |
64 | pyroutes.register('admin_settings_vcs', '/_admin/settings/vcs', []); |
|
64 | pyroutes.register('admin_settings_vcs', '/_admin/settings/vcs', []); | |
65 | pyroutes.register('admin_settings_vcs_update', '/_admin/settings/vcs/update', []); |
|
65 | pyroutes.register('admin_settings_vcs_update', '/_admin/settings/vcs/update', []); | |
66 | pyroutes.register('admin_settings_vcs_svn_pattern_delete', '/_admin/settings/vcs/svn_pattern_delete', []); |
|
66 | pyroutes.register('admin_settings_vcs_svn_pattern_delete', '/_admin/settings/vcs/svn_pattern_delete', []); | |
67 | pyroutes.register('admin_settings_mapping', '/_admin/settings/mapping', []); |
|
67 | pyroutes.register('admin_settings_mapping', '/_admin/settings/mapping', []); | |
68 | pyroutes.register('admin_settings_mapping_update', '/_admin/settings/mapping/update', []); |
|
68 | pyroutes.register('admin_settings_mapping_update', '/_admin/settings/mapping/update', []); | |
69 | pyroutes.register('admin_settings_visual', '/_admin/settings/visual', []); |
|
69 | pyroutes.register('admin_settings_visual', '/_admin/settings/visual', []); | |
70 | pyroutes.register('admin_settings_visual_update', '/_admin/settings/visual/update', []); |
|
70 | pyroutes.register('admin_settings_visual_update', '/_admin/settings/visual/update', []); | |
71 | pyroutes.register('admin_settings_issuetracker', '/_admin/settings/issue-tracker', []); |
|
71 | pyroutes.register('admin_settings_issuetracker', '/_admin/settings/issue-tracker', []); | |
72 | pyroutes.register('admin_settings_issuetracker_update', '/_admin/settings/issue-tracker/update', []); |
|
72 | pyroutes.register('admin_settings_issuetracker_update', '/_admin/settings/issue-tracker/update', []); | |
73 | pyroutes.register('admin_settings_issuetracker_test', '/_admin/settings/issue-tracker/test', []); |
|
73 | pyroutes.register('admin_settings_issuetracker_test', '/_admin/settings/issue-tracker/test', []); | |
74 | pyroutes.register('admin_settings_issuetracker_delete', '/_admin/settings/issue-tracker/delete', []); |
|
74 | pyroutes.register('admin_settings_issuetracker_delete', '/_admin/settings/issue-tracker/delete', []); | |
75 | pyroutes.register('admin_settings_email', '/_admin/settings/email', []); |
|
75 | pyroutes.register('admin_settings_email', '/_admin/settings/email', []); | |
76 | pyroutes.register('admin_settings_email_update', '/_admin/settings/email/update', []); |
|
76 | pyroutes.register('admin_settings_email_update', '/_admin/settings/email/update', []); | |
77 | pyroutes.register('admin_settings_hooks', '/_admin/settings/hooks', []); |
|
77 | pyroutes.register('admin_settings_hooks', '/_admin/settings/hooks', []); | |
78 | pyroutes.register('admin_settings_hooks_update', '/_admin/settings/hooks/update', []); |
|
78 | pyroutes.register('admin_settings_hooks_update', '/_admin/settings/hooks/update', []); | |
79 | pyroutes.register('admin_settings_hooks_delete', '/_admin/settings/hooks/delete', []); |
|
79 | pyroutes.register('admin_settings_hooks_delete', '/_admin/settings/hooks/delete', []); | |
80 | pyroutes.register('admin_settings_search', '/_admin/settings/search', []); |
|
80 | pyroutes.register('admin_settings_search', '/_admin/settings/search', []); | |
81 | pyroutes.register('admin_settings_labs', '/_admin/settings/labs', []); |
|
81 | pyroutes.register('admin_settings_labs', '/_admin/settings/labs', []); | |
82 | pyroutes.register('admin_settings_labs_update', '/_admin/settings/labs/update', []); |
|
82 | pyroutes.register('admin_settings_labs_update', '/_admin/settings/labs/update', []); | |
83 | pyroutes.register('admin_permissions_application', '/_admin/permissions/application', []); |
|
83 | pyroutes.register('admin_permissions_application', '/_admin/permissions/application', []); | |
84 | pyroutes.register('admin_permissions_application_update', '/_admin/permissions/application/update', []); |
|
84 | pyroutes.register('admin_permissions_application_update', '/_admin/permissions/application/update', []); | |
85 | pyroutes.register('admin_permissions_global', '/_admin/permissions/global', []); |
|
85 | pyroutes.register('admin_permissions_global', '/_admin/permissions/global', []); | |
86 | pyroutes.register('admin_permissions_global_update', '/_admin/permissions/global/update', []); |
|
86 | pyroutes.register('admin_permissions_global_update', '/_admin/permissions/global/update', []); | |
87 | pyroutes.register('admin_permissions_object', '/_admin/permissions/object', []); |
|
87 | pyroutes.register('admin_permissions_object', '/_admin/permissions/object', []); | |
88 | pyroutes.register('admin_permissions_object_update', '/_admin/permissions/object/update', []); |
|
88 | pyroutes.register('admin_permissions_object_update', '/_admin/permissions/object/update', []); | |
89 | pyroutes.register('admin_permissions_ips', '/_admin/permissions/ips', []); |
|
89 | pyroutes.register('admin_permissions_ips', '/_admin/permissions/ips', []); | |
90 | pyroutes.register('admin_permissions_overview', '/_admin/permissions/overview', []); |
|
90 | pyroutes.register('admin_permissions_overview', '/_admin/permissions/overview', []); | |
91 | pyroutes.register('admin_permissions_auth_token_access', '/_admin/permissions/auth_token_access', []); |
|
91 | pyroutes.register('admin_permissions_auth_token_access', '/_admin/permissions/auth_token_access', []); | |
92 | pyroutes.register('admin_permissions_ssh_keys', '/_admin/permissions/ssh_keys', []); |
|
92 | pyroutes.register('admin_permissions_ssh_keys', '/_admin/permissions/ssh_keys', []); | |
93 | pyroutes.register('admin_permissions_ssh_keys_data', '/_admin/permissions/ssh_keys/data', []); |
|
93 | pyroutes.register('admin_permissions_ssh_keys_data', '/_admin/permissions/ssh_keys/data', []); | |
94 | pyroutes.register('admin_permissions_ssh_keys_update', '/_admin/permissions/ssh_keys/update', []); |
|
94 | pyroutes.register('admin_permissions_ssh_keys_update', '/_admin/permissions/ssh_keys/update', []); | |
95 | pyroutes.register('users', '/_admin/users', []); |
|
95 | pyroutes.register('users', '/_admin/users', []); | |
96 | pyroutes.register('users_data', '/_admin/users_data', []); |
|
96 | pyroutes.register('users_data', '/_admin/users_data', []); | |
97 | pyroutes.register('users_create', '/_admin/users/create', []); |
|
97 | pyroutes.register('users_create', '/_admin/users/create', []); | |
98 | pyroutes.register('users_new', '/_admin/users/new', []); |
|
98 | pyroutes.register('users_new', '/_admin/users/new', []); | |
99 | pyroutes.register('user_edit', '/_admin/users/%(user_id)s/edit', ['user_id']); |
|
99 | pyroutes.register('user_edit', '/_admin/users/%(user_id)s/edit', ['user_id']); | |
100 | pyroutes.register('user_edit_advanced', '/_admin/users/%(user_id)s/edit/advanced', ['user_id']); |
|
100 | pyroutes.register('user_edit_advanced', '/_admin/users/%(user_id)s/edit/advanced', ['user_id']); | |
101 | pyroutes.register('user_edit_global_perms', '/_admin/users/%(user_id)s/edit/global_permissions', ['user_id']); |
|
101 | pyroutes.register('user_edit_global_perms', '/_admin/users/%(user_id)s/edit/global_permissions', ['user_id']); | |
102 | pyroutes.register('user_edit_global_perms_update', '/_admin/users/%(user_id)s/edit/global_permissions/update', ['user_id']); |
|
102 | pyroutes.register('user_edit_global_perms_update', '/_admin/users/%(user_id)s/edit/global_permissions/update', ['user_id']); | |
103 | pyroutes.register('user_update', '/_admin/users/%(user_id)s/update', ['user_id']); |
|
103 | pyroutes.register('user_update', '/_admin/users/%(user_id)s/update', ['user_id']); | |
104 | pyroutes.register('user_delete', '/_admin/users/%(user_id)s/delete', ['user_id']); |
|
104 | pyroutes.register('user_delete', '/_admin/users/%(user_id)s/delete', ['user_id']); | |
105 | pyroutes.register('user_enable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_enable', ['user_id']); |
|
105 | pyroutes.register('user_enable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_enable', ['user_id']); | |
106 | pyroutes.register('user_disable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_disable', ['user_id']); |
|
106 | pyroutes.register('user_disable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_disable', ['user_id']); | |
107 | pyroutes.register('user_create_personal_repo_group', '/_admin/users/%(user_id)s/create_repo_group', ['user_id']); |
|
107 | pyroutes.register('user_create_personal_repo_group', '/_admin/users/%(user_id)s/create_repo_group', ['user_id']); | |
108 | pyroutes.register('edit_user_auth_tokens_delete', '/_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']); |
|
108 | pyroutes.register('edit_user_auth_tokens_delete', '/_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']); | |
109 | pyroutes.register('edit_user_ssh_keys', '/_admin/users/%(user_id)s/edit/ssh_keys', ['user_id']); |
|
109 | pyroutes.register('edit_user_ssh_keys', '/_admin/users/%(user_id)s/edit/ssh_keys', ['user_id']); | |
110 | pyroutes.register('edit_user_ssh_keys_generate_keypair', '/_admin/users/%(user_id)s/edit/ssh_keys/generate', ['user_id']); |
|
110 | pyroutes.register('edit_user_ssh_keys_generate_keypair', '/_admin/users/%(user_id)s/edit/ssh_keys/generate', ['user_id']); | |
111 | pyroutes.register('edit_user_ssh_keys_add', '/_admin/users/%(user_id)s/edit/ssh_keys/new', ['user_id']); |
|
111 | pyroutes.register('edit_user_ssh_keys_add', '/_admin/users/%(user_id)s/edit/ssh_keys/new', ['user_id']); | |
112 | pyroutes.register('edit_user_ssh_keys_delete', '/_admin/users/%(user_id)s/edit/ssh_keys/delete', ['user_id']); |
|
112 | pyroutes.register('edit_user_ssh_keys_delete', '/_admin/users/%(user_id)s/edit/ssh_keys/delete', ['user_id']); | |
113 | pyroutes.register('edit_user_emails', '/_admin/users/%(user_id)s/edit/emails', ['user_id']); |
|
113 | pyroutes.register('edit_user_emails', '/_admin/users/%(user_id)s/edit/emails', ['user_id']); | |
114 | pyroutes.register('edit_user_emails_add', '/_admin/users/%(user_id)s/edit/emails/new', ['user_id']); |
|
114 | pyroutes.register('edit_user_emails_add', '/_admin/users/%(user_id)s/edit/emails/new', ['user_id']); | |
115 | pyroutes.register('edit_user_emails_delete', '/_admin/users/%(user_id)s/edit/emails/delete', ['user_id']); |
|
115 | pyroutes.register('edit_user_emails_delete', '/_admin/users/%(user_id)s/edit/emails/delete', ['user_id']); | |
116 | pyroutes.register('edit_user_ips', '/_admin/users/%(user_id)s/edit/ips', ['user_id']); |
|
116 | pyroutes.register('edit_user_ips', '/_admin/users/%(user_id)s/edit/ips', ['user_id']); | |
117 | pyroutes.register('edit_user_ips_add', '/_admin/users/%(user_id)s/edit/ips/new', ['user_id']); |
|
117 | pyroutes.register('edit_user_ips_add', '/_admin/users/%(user_id)s/edit/ips/new', ['user_id']); | |
118 | pyroutes.register('edit_user_ips_delete', '/_admin/users/%(user_id)s/edit/ips/delete', ['user_id']); |
|
118 | pyroutes.register('edit_user_ips_delete', '/_admin/users/%(user_id)s/edit/ips/delete', ['user_id']); | |
119 | pyroutes.register('edit_user_perms_summary', '/_admin/users/%(user_id)s/edit/permissions_summary', ['user_id']); |
|
119 | pyroutes.register('edit_user_perms_summary', '/_admin/users/%(user_id)s/edit/permissions_summary', ['user_id']); | |
120 | pyroutes.register('edit_user_perms_summary_json', '/_admin/users/%(user_id)s/edit/permissions_summary/json', ['user_id']); |
|
120 | pyroutes.register('edit_user_perms_summary_json', '/_admin/users/%(user_id)s/edit/permissions_summary/json', ['user_id']); | |
121 | pyroutes.register('edit_user_groups_management', '/_admin/users/%(user_id)s/edit/groups_management', ['user_id']); |
|
121 | pyroutes.register('edit_user_groups_management', '/_admin/users/%(user_id)s/edit/groups_management', ['user_id']); | |
122 | pyroutes.register('edit_user_groups_management_updates', '/_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']); |
|
122 | pyroutes.register('edit_user_groups_management_updates', '/_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']); | |
123 | pyroutes.register('edit_user_audit_logs', '/_admin/users/%(user_id)s/edit/audit', ['user_id']); |
|
123 | pyroutes.register('edit_user_audit_logs', '/_admin/users/%(user_id)s/edit/audit', ['user_id']); | |
124 | pyroutes.register('edit_user_audit_logs_download', '/_admin/users/%(user_id)s/edit/audit/download', ['user_id']); |
|
124 | pyroutes.register('edit_user_audit_logs_download', '/_admin/users/%(user_id)s/edit/audit/download', ['user_id']); | |
125 | pyroutes.register('edit_user_caches', '/_admin/users/%(user_id)s/edit/caches', ['user_id']); |
|
125 | pyroutes.register('edit_user_caches', '/_admin/users/%(user_id)s/edit/caches', ['user_id']); | |
126 | pyroutes.register('edit_user_caches_update', '/_admin/users/%(user_id)s/edit/caches/update', ['user_id']); |
|
126 | pyroutes.register('edit_user_caches_update', '/_admin/users/%(user_id)s/edit/caches/update', ['user_id']); | |
127 | pyroutes.register('user_groups', '/_admin/user_groups', []); |
|
127 | pyroutes.register('user_groups', '/_admin/user_groups', []); | |
128 | pyroutes.register('user_groups_data', '/_admin/user_groups_data', []); |
|
128 | pyroutes.register('user_groups_data', '/_admin/user_groups_data', []); | |
129 | pyroutes.register('user_groups_new', '/_admin/user_groups/new', []); |
|
129 | pyroutes.register('user_groups_new', '/_admin/user_groups/new', []); | |
130 | pyroutes.register('user_groups_create', '/_admin/user_groups/create', []); |
|
130 | pyroutes.register('user_groups_create', '/_admin/user_groups/create', []); | |
131 | pyroutes.register('repos', '/_admin/repos', []); |
|
131 | pyroutes.register('repos', '/_admin/repos', []); | |
132 | pyroutes.register('repo_new', '/_admin/repos/new', []); |
|
132 | pyroutes.register('repo_new', '/_admin/repos/new', []); | |
133 | pyroutes.register('repo_create', '/_admin/repos/create', []); |
|
133 | pyroutes.register('repo_create', '/_admin/repos/create', []); | |
134 | pyroutes.register('repo_groups', '/_admin/repo_groups', []); |
|
134 | pyroutes.register('repo_groups', '/_admin/repo_groups', []); | |
135 | pyroutes.register('repo_groups_data', '/_admin/repo_groups_data', []); |
|
135 | pyroutes.register('repo_groups_data', '/_admin/repo_groups_data', []); | |
136 | pyroutes.register('repo_group_new', '/_admin/repo_group/new', []); |
|
136 | pyroutes.register('repo_group_new', '/_admin/repo_group/new', []); | |
137 | pyroutes.register('repo_group_create', '/_admin/repo_group/create', []); |
|
137 | pyroutes.register('repo_group_create', '/_admin/repo_group/create', []); | |
138 | pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []); |
|
138 | pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []); | |
139 | pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []); |
|
139 | pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []); | |
140 | pyroutes.register('channelstream_proxy', '/_channelstream', []); |
|
140 | pyroutes.register('channelstream_proxy', '/_channelstream', []); | |
141 | pyroutes.register('upload_file', '/_file_store/upload', []); |
|
141 | pyroutes.register('upload_file', '/_file_store/upload', []); | |
142 | pyroutes.register('download_file', '/_file_store/download/%(fid)s', ['fid']); |
|
142 | pyroutes.register('download_file', '/_file_store/download/%(fid)s', ['fid']); | |
143 | pyroutes.register('logout', '/_admin/logout', []); |
|
143 | pyroutes.register('logout', '/_admin/logout', []); | |
144 | pyroutes.register('reset_password', '/_admin/password_reset', []); |
|
144 | pyroutes.register('reset_password', '/_admin/password_reset', []); | |
145 | pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []); |
|
145 | pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []); | |
146 | pyroutes.register('home', '/', []); |
|
146 | pyroutes.register('home', '/', []); | |
147 | pyroutes.register('user_autocomplete_data', '/_users', []); |
|
147 | pyroutes.register('user_autocomplete_data', '/_users', []); | |
148 | pyroutes.register('user_group_autocomplete_data', '/_user_groups', []); |
|
148 | pyroutes.register('user_group_autocomplete_data', '/_user_groups', []); | |
149 | pyroutes.register('repo_list_data', '/_repos', []); |
|
149 | pyroutes.register('repo_list_data', '/_repos', []); | |
150 | pyroutes.register('repo_group_list_data', '/_repo_groups', []); |
|
150 | pyroutes.register('repo_group_list_data', '/_repo_groups', []); | |
151 | pyroutes.register('goto_switcher_data', '/_goto_data', []); |
|
151 | pyroutes.register('goto_switcher_data', '/_goto_data', []); | |
152 | pyroutes.register('markup_preview', '/_markup_preview', []); |
|
152 | pyroutes.register('markup_preview', '/_markup_preview', []); | |
153 | pyroutes.register('file_preview', '/_file_preview', []); |
|
153 | pyroutes.register('file_preview', '/_file_preview', []); | |
154 | pyroutes.register('store_user_session_value', '/_store_session_attr', []); |
|
154 | pyroutes.register('store_user_session_value', '/_store_session_attr', []); | |
155 | pyroutes.register('journal', '/_admin/journal', []); |
|
155 | pyroutes.register('journal', '/_admin/journal', []); | |
156 | pyroutes.register('journal_rss', '/_admin/journal/rss', []); |
|
156 | pyroutes.register('journal_rss', '/_admin/journal/rss', []); | |
157 | pyroutes.register('journal_atom', '/_admin/journal/atom', []); |
|
157 | pyroutes.register('journal_atom', '/_admin/journal/atom', []); | |
158 | pyroutes.register('journal_public', '/_admin/public_journal', []); |
|
158 | pyroutes.register('journal_public', '/_admin/public_journal', []); | |
159 | pyroutes.register('journal_public_atom', '/_admin/public_journal/atom', []); |
|
159 | pyroutes.register('journal_public_atom', '/_admin/public_journal/atom', []); | |
160 | pyroutes.register('journal_public_atom_old', '/_admin/public_journal_atom', []); |
|
160 | pyroutes.register('journal_public_atom_old', '/_admin/public_journal_atom', []); | |
161 | pyroutes.register('journal_public_rss', '/_admin/public_journal/rss', []); |
|
161 | pyroutes.register('journal_public_rss', '/_admin/public_journal/rss', []); | |
162 | pyroutes.register('journal_public_rss_old', '/_admin/public_journal_rss', []); |
|
162 | pyroutes.register('journal_public_rss_old', '/_admin/public_journal_rss', []); | |
163 | pyroutes.register('toggle_following', '/_admin/toggle_following', []); |
|
163 | pyroutes.register('toggle_following', '/_admin/toggle_following', []); | |
164 | pyroutes.register('repo_creating', '/%(repo_name)s/repo_creating', ['repo_name']); |
|
164 | pyroutes.register('repo_creating', '/%(repo_name)s/repo_creating', ['repo_name']); | |
165 | pyroutes.register('repo_creating_check', '/%(repo_name)s/repo_creating_check', ['repo_name']); |
|
165 | pyroutes.register('repo_creating_check', '/%(repo_name)s/repo_creating_check', ['repo_name']); | |
166 | pyroutes.register('repo_summary_explicit', '/%(repo_name)s/summary', ['repo_name']); |
|
166 | pyroutes.register('repo_summary_explicit', '/%(repo_name)s/summary', ['repo_name']); | |
167 | pyroutes.register('repo_summary_commits', '/%(repo_name)s/summary-commits', ['repo_name']); |
|
167 | pyroutes.register('repo_summary_commits', '/%(repo_name)s/summary-commits', ['repo_name']); | |
168 | pyroutes.register('repo_commit', '/%(repo_name)s/changeset/%(commit_id)s', ['repo_name', 'commit_id']); |
|
168 | pyroutes.register('repo_commit', '/%(repo_name)s/changeset/%(commit_id)s', ['repo_name', 'commit_id']); | |
169 | pyroutes.register('repo_commit_children', '/%(repo_name)s/changeset_children/%(commit_id)s', ['repo_name', 'commit_id']); |
|
169 | pyroutes.register('repo_commit_children', '/%(repo_name)s/changeset_children/%(commit_id)s', ['repo_name', 'commit_id']); | |
170 | pyroutes.register('repo_commit_parents', '/%(repo_name)s/changeset_parents/%(commit_id)s', ['repo_name', 'commit_id']); |
|
170 | pyroutes.register('repo_commit_parents', '/%(repo_name)s/changeset_parents/%(commit_id)s', ['repo_name', 'commit_id']); | |
171 | pyroutes.register('repo_commit_raw', '/%(repo_name)s/changeset-diff/%(commit_id)s', ['repo_name', 'commit_id']); |
|
171 | pyroutes.register('repo_commit_raw', '/%(repo_name)s/changeset-diff/%(commit_id)s', ['repo_name', 'commit_id']); | |
172 | pyroutes.register('repo_commit_patch', '/%(repo_name)s/changeset-patch/%(commit_id)s', ['repo_name', 'commit_id']); |
|
172 | pyroutes.register('repo_commit_patch', '/%(repo_name)s/changeset-patch/%(commit_id)s', ['repo_name', 'commit_id']); | |
173 | pyroutes.register('repo_commit_download', '/%(repo_name)s/changeset-download/%(commit_id)s', ['repo_name', 'commit_id']); |
|
173 | pyroutes.register('repo_commit_download', '/%(repo_name)s/changeset-download/%(commit_id)s', ['repo_name', 'commit_id']); | |
174 | pyroutes.register('repo_commit_data', '/%(repo_name)s/changeset-data/%(commit_id)s', ['repo_name', 'commit_id']); |
|
174 | pyroutes.register('repo_commit_data', '/%(repo_name)s/changeset-data/%(commit_id)s', ['repo_name', 'commit_id']); | |
175 | pyroutes.register('repo_commit_comment_create', '/%(repo_name)s/changeset/%(commit_id)s/comment/create', ['repo_name', 'commit_id']); |
|
175 | pyroutes.register('repo_commit_comment_create', '/%(repo_name)s/changeset/%(commit_id)s/comment/create', ['repo_name', 'commit_id']); | |
176 | pyroutes.register('repo_commit_comment_preview', '/%(repo_name)s/changeset/%(commit_id)s/comment/preview', ['repo_name', 'commit_id']); |
|
176 | pyroutes.register('repo_commit_comment_preview', '/%(repo_name)s/changeset/%(commit_id)s/comment/preview', ['repo_name', 'commit_id']); | |
|
177 | pyroutes.register('repo_commit_comment_attachment_upload', '/%(repo_name)s/changeset/%(commit_id)s/comment/attachment_upload', ['repo_name', 'commit_id']); | |||
177 | pyroutes.register('repo_commit_comment_delete', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/delete', ['repo_name', 'commit_id', 'comment_id']); |
|
178 | pyroutes.register('repo_commit_comment_delete', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/delete', ['repo_name', 'commit_id', 'comment_id']); | |
178 | pyroutes.register('repo_commit_raw_deprecated', '/%(repo_name)s/raw-changeset/%(commit_id)s', ['repo_name', 'commit_id']); |
|
179 | pyroutes.register('repo_commit_raw_deprecated', '/%(repo_name)s/raw-changeset/%(commit_id)s', ['repo_name', 'commit_id']); | |
179 | pyroutes.register('repo_archivefile', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']); |
|
180 | pyroutes.register('repo_archivefile', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']); | |
180 | pyroutes.register('repo_files_diff', '/%(repo_name)s/diff/%(f_path)s', ['repo_name', 'f_path']); |
|
181 | pyroutes.register('repo_files_diff', '/%(repo_name)s/diff/%(f_path)s', ['repo_name', 'f_path']); | |
181 | pyroutes.register('repo_files_diff_2way_redirect', '/%(repo_name)s/diff-2way/%(f_path)s', ['repo_name', 'f_path']); |
|
182 | pyroutes.register('repo_files_diff_2way_redirect', '/%(repo_name)s/diff-2way/%(f_path)s', ['repo_name', 'f_path']); | |
182 | pyroutes.register('repo_files', '/%(repo_name)s/files/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
183 | pyroutes.register('repo_files', '/%(repo_name)s/files/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
183 | pyroutes.register('repo_files:default_path', '/%(repo_name)s/files/%(commit_id)s/', ['repo_name', 'commit_id']); |
|
184 | pyroutes.register('repo_files:default_path', '/%(repo_name)s/files/%(commit_id)s/', ['repo_name', 'commit_id']); | |
184 | pyroutes.register('repo_files:default_commit', '/%(repo_name)s/files', ['repo_name']); |
|
185 | pyroutes.register('repo_files:default_commit', '/%(repo_name)s/files', ['repo_name']); | |
185 | pyroutes.register('repo_files:rendered', '/%(repo_name)s/render/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
186 | pyroutes.register('repo_files:rendered', '/%(repo_name)s/render/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
186 | pyroutes.register('repo_files:annotated', '/%(repo_name)s/annotate/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
187 | pyroutes.register('repo_files:annotated', '/%(repo_name)s/annotate/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
187 | pyroutes.register('repo_files:annotated_previous', '/%(repo_name)s/annotate-previous/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
188 | pyroutes.register('repo_files:annotated_previous', '/%(repo_name)s/annotate-previous/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
188 | pyroutes.register('repo_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
189 | pyroutes.register('repo_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
189 | pyroutes.register('repo_nodetree_full:default_path', '/%(repo_name)s/nodetree_full/%(commit_id)s/', ['repo_name', 'commit_id']); |
|
190 | pyroutes.register('repo_nodetree_full:default_path', '/%(repo_name)s/nodetree_full/%(commit_id)s/', ['repo_name', 'commit_id']); | |
190 | pyroutes.register('repo_files_nodelist', '/%(repo_name)s/nodelist/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
191 | pyroutes.register('repo_files_nodelist', '/%(repo_name)s/nodelist/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
191 | pyroutes.register('repo_file_raw', '/%(repo_name)s/raw/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
192 | pyroutes.register('repo_file_raw', '/%(repo_name)s/raw/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
192 | pyroutes.register('repo_file_download', '/%(repo_name)s/download/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
193 | pyroutes.register('repo_file_download', '/%(repo_name)s/download/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
193 | pyroutes.register('repo_file_download:legacy', '/%(repo_name)s/rawfile/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
194 | pyroutes.register('repo_file_download:legacy', '/%(repo_name)s/rawfile/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
194 | pyroutes.register('repo_file_history', '/%(repo_name)s/history/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
195 | pyroutes.register('repo_file_history', '/%(repo_name)s/history/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
195 | pyroutes.register('repo_file_authors', '/%(repo_name)s/authors/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
196 | pyroutes.register('repo_file_authors', '/%(repo_name)s/authors/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
196 | pyroutes.register('repo_files_remove_file', '/%(repo_name)s/remove_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
197 | pyroutes.register('repo_files_remove_file', '/%(repo_name)s/remove_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
197 | pyroutes.register('repo_files_delete_file', '/%(repo_name)s/delete_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
198 | pyroutes.register('repo_files_delete_file', '/%(repo_name)s/delete_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
198 | pyroutes.register('repo_files_edit_file', '/%(repo_name)s/edit_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
199 | pyroutes.register('repo_files_edit_file', '/%(repo_name)s/edit_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
199 | pyroutes.register('repo_files_update_file', '/%(repo_name)s/update_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
200 | pyroutes.register('repo_files_update_file', '/%(repo_name)s/update_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
200 | pyroutes.register('repo_files_add_file', '/%(repo_name)s/add_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
201 | pyroutes.register('repo_files_add_file', '/%(repo_name)s/add_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
201 | pyroutes.register('repo_files_upload_file', '/%(repo_name)s/upload_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
202 | pyroutes.register('repo_files_upload_file', '/%(repo_name)s/upload_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
202 | pyroutes.register('repo_files_create_file', '/%(repo_name)s/create_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
203 | pyroutes.register('repo_files_create_file', '/%(repo_name)s/create_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
203 | pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']); |
|
204 | pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']); | |
204 | pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']); |
|
205 | pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']); | |
205 | pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']); |
|
206 | pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']); | |
206 | pyroutes.register('repo_commits', '/%(repo_name)s/commits', ['repo_name']); |
|
207 | pyroutes.register('repo_commits', '/%(repo_name)s/commits', ['repo_name']); | |
207 | pyroutes.register('repo_commits_file', '/%(repo_name)s/commits/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
208 | pyroutes.register('repo_commits_file', '/%(repo_name)s/commits/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
208 | pyroutes.register('repo_commits_elements', '/%(repo_name)s/commits_elements', ['repo_name']); |
|
209 | pyroutes.register('repo_commits_elements', '/%(repo_name)s/commits_elements', ['repo_name']); | |
209 | pyroutes.register('repo_commits_elements_file', '/%(repo_name)s/commits_elements/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
210 | pyroutes.register('repo_commits_elements_file', '/%(repo_name)s/commits_elements/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
210 | pyroutes.register('repo_changelog', '/%(repo_name)s/changelog', ['repo_name']); |
|
211 | pyroutes.register('repo_changelog', '/%(repo_name)s/changelog', ['repo_name']); | |
211 | pyroutes.register('repo_changelog_file', '/%(repo_name)s/changelog/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); |
|
212 | pyroutes.register('repo_changelog_file', '/%(repo_name)s/changelog/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']); | |
212 | pyroutes.register('repo_compare_select', '/%(repo_name)s/compare', ['repo_name']); |
|
213 | pyroutes.register('repo_compare_select', '/%(repo_name)s/compare', ['repo_name']); | |
213 | pyroutes.register('repo_compare', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']); |
|
214 | pyroutes.register('repo_compare', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']); | |
214 | pyroutes.register('tags_home', '/%(repo_name)s/tags', ['repo_name']); |
|
215 | pyroutes.register('tags_home', '/%(repo_name)s/tags', ['repo_name']); | |
215 | pyroutes.register('branches_home', '/%(repo_name)s/branches', ['repo_name']); |
|
216 | pyroutes.register('branches_home', '/%(repo_name)s/branches', ['repo_name']); | |
216 | pyroutes.register('bookmarks_home', '/%(repo_name)s/bookmarks', ['repo_name']); |
|
217 | pyroutes.register('bookmarks_home', '/%(repo_name)s/bookmarks', ['repo_name']); | |
217 | pyroutes.register('repo_fork_new', '/%(repo_name)s/fork', ['repo_name']); |
|
218 | pyroutes.register('repo_fork_new', '/%(repo_name)s/fork', ['repo_name']); | |
218 | pyroutes.register('repo_fork_create', '/%(repo_name)s/fork/create', ['repo_name']); |
|
219 | pyroutes.register('repo_fork_create', '/%(repo_name)s/fork/create', ['repo_name']); | |
219 | pyroutes.register('repo_forks_show_all', '/%(repo_name)s/forks', ['repo_name']); |
|
220 | pyroutes.register('repo_forks_show_all', '/%(repo_name)s/forks', ['repo_name']); | |
220 | pyroutes.register('repo_forks_data', '/%(repo_name)s/forks/data', ['repo_name']); |
|
221 | pyroutes.register('repo_forks_data', '/%(repo_name)s/forks/data', ['repo_name']); | |
221 | pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']); |
|
222 | pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']); | |
222 | pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']); |
|
223 | pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']); | |
223 | pyroutes.register('pullrequest_show_all_data', '/%(repo_name)s/pull-request-data', ['repo_name']); |
|
224 | pyroutes.register('pullrequest_show_all_data', '/%(repo_name)s/pull-request-data', ['repo_name']); | |
224 | pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']); |
|
225 | pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']); | |
225 | pyroutes.register('pullrequest_repo_targets', '/%(repo_name)s/pull-request/repo-targets', ['repo_name']); |
|
226 | pyroutes.register('pullrequest_repo_targets', '/%(repo_name)s/pull-request/repo-targets', ['repo_name']); | |
226 | pyroutes.register('pullrequest_new', '/%(repo_name)s/pull-request/new', ['repo_name']); |
|
227 | pyroutes.register('pullrequest_new', '/%(repo_name)s/pull-request/new', ['repo_name']); | |
227 | pyroutes.register('pullrequest_create', '/%(repo_name)s/pull-request/create', ['repo_name']); |
|
228 | pyroutes.register('pullrequest_create', '/%(repo_name)s/pull-request/create', ['repo_name']); | |
228 | pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s/update', ['repo_name', 'pull_request_id']); |
|
229 | pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s/update', ['repo_name', 'pull_request_id']); | |
229 | pyroutes.register('pullrequest_merge', '/%(repo_name)s/pull-request/%(pull_request_id)s/merge', ['repo_name', 'pull_request_id']); |
|
230 | pyroutes.register('pullrequest_merge', '/%(repo_name)s/pull-request/%(pull_request_id)s/merge', ['repo_name', 'pull_request_id']); | |
230 | pyroutes.register('pullrequest_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/delete', ['repo_name', 'pull_request_id']); |
|
231 | pyroutes.register('pullrequest_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/delete', ['repo_name', 'pull_request_id']); | |
231 | pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']); |
|
232 | pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']); | |
232 | pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/delete', ['repo_name', 'pull_request_id', 'comment_id']); |
|
233 | pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/delete', ['repo_name', 'pull_request_id', 'comment_id']); | |
233 | pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']); |
|
234 | pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']); | |
234 | pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']); |
|
235 | pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']); | |
235 | pyroutes.register('edit_repo_advanced_archive', '/%(repo_name)s/settings/advanced/archive', ['repo_name']); |
|
236 | pyroutes.register('edit_repo_advanced_archive', '/%(repo_name)s/settings/advanced/archive', ['repo_name']); | |
236 | pyroutes.register('edit_repo_advanced_delete', '/%(repo_name)s/settings/advanced/delete', ['repo_name']); |
|
237 | pyroutes.register('edit_repo_advanced_delete', '/%(repo_name)s/settings/advanced/delete', ['repo_name']); | |
237 | pyroutes.register('edit_repo_advanced_locking', '/%(repo_name)s/settings/advanced/locking', ['repo_name']); |
|
238 | pyroutes.register('edit_repo_advanced_locking', '/%(repo_name)s/settings/advanced/locking', ['repo_name']); | |
238 | pyroutes.register('edit_repo_advanced_journal', '/%(repo_name)s/settings/advanced/journal', ['repo_name']); |
|
239 | pyroutes.register('edit_repo_advanced_journal', '/%(repo_name)s/settings/advanced/journal', ['repo_name']); | |
239 | pyroutes.register('edit_repo_advanced_fork', '/%(repo_name)s/settings/advanced/fork', ['repo_name']); |
|
240 | pyroutes.register('edit_repo_advanced_fork', '/%(repo_name)s/settings/advanced/fork', ['repo_name']); | |
240 | pyroutes.register('edit_repo_advanced_hooks', '/%(repo_name)s/settings/advanced/hooks', ['repo_name']); |
|
241 | pyroutes.register('edit_repo_advanced_hooks', '/%(repo_name)s/settings/advanced/hooks', ['repo_name']); | |
241 | pyroutes.register('edit_repo_caches', '/%(repo_name)s/settings/caches', ['repo_name']); |
|
242 | pyroutes.register('edit_repo_caches', '/%(repo_name)s/settings/caches', ['repo_name']); | |
242 | pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']); |
|
243 | pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']); | |
243 | pyroutes.register('edit_repo_perms_set_private', '/%(repo_name)s/settings/permissions/set_private', ['repo_name']); |
|
244 | pyroutes.register('edit_repo_perms_set_private', '/%(repo_name)s/settings/permissions/set_private', ['repo_name']); | |
244 | pyroutes.register('edit_repo_maintenance', '/%(repo_name)s/settings/maintenance', ['repo_name']); |
|
245 | pyroutes.register('edit_repo_maintenance', '/%(repo_name)s/settings/maintenance', ['repo_name']); | |
245 | pyroutes.register('edit_repo_maintenance_execute', '/%(repo_name)s/settings/maintenance/execute', ['repo_name']); |
|
246 | pyroutes.register('edit_repo_maintenance_execute', '/%(repo_name)s/settings/maintenance/execute', ['repo_name']); | |
246 | pyroutes.register('edit_repo_fields', '/%(repo_name)s/settings/fields', ['repo_name']); |
|
247 | pyroutes.register('edit_repo_fields', '/%(repo_name)s/settings/fields', ['repo_name']); | |
247 | pyroutes.register('edit_repo_fields_create', '/%(repo_name)s/settings/fields/create', ['repo_name']); |
|
248 | pyroutes.register('edit_repo_fields_create', '/%(repo_name)s/settings/fields/create', ['repo_name']); | |
248 | pyroutes.register('edit_repo_fields_delete', '/%(repo_name)s/settings/fields/%(field_id)s/delete', ['repo_name', 'field_id']); |
|
249 | pyroutes.register('edit_repo_fields_delete', '/%(repo_name)s/settings/fields/%(field_id)s/delete', ['repo_name', 'field_id']); | |
249 | pyroutes.register('repo_edit_toggle_locking', '/%(repo_name)s/settings/toggle_locking', ['repo_name']); |
|
250 | pyroutes.register('repo_edit_toggle_locking', '/%(repo_name)s/settings/toggle_locking', ['repo_name']); | |
250 | pyroutes.register('edit_repo_remote', '/%(repo_name)s/settings/remote', ['repo_name']); |
|
251 | pyroutes.register('edit_repo_remote', '/%(repo_name)s/settings/remote', ['repo_name']); | |
251 | pyroutes.register('edit_repo_remote_pull', '/%(repo_name)s/settings/remote/pull', ['repo_name']); |
|
252 | pyroutes.register('edit_repo_remote_pull', '/%(repo_name)s/settings/remote/pull', ['repo_name']); | |
252 | pyroutes.register('edit_repo_statistics', '/%(repo_name)s/settings/statistics', ['repo_name']); |
|
253 | pyroutes.register('edit_repo_statistics', '/%(repo_name)s/settings/statistics', ['repo_name']); | |
253 | pyroutes.register('edit_repo_statistics_reset', '/%(repo_name)s/settings/statistics/update', ['repo_name']); |
|
254 | pyroutes.register('edit_repo_statistics_reset', '/%(repo_name)s/settings/statistics/update', ['repo_name']); | |
254 | pyroutes.register('edit_repo_issuetracker', '/%(repo_name)s/settings/issue_trackers', ['repo_name']); |
|
255 | pyroutes.register('edit_repo_issuetracker', '/%(repo_name)s/settings/issue_trackers', ['repo_name']); | |
255 | pyroutes.register('edit_repo_issuetracker_test', '/%(repo_name)s/settings/issue_trackers/test', ['repo_name']); |
|
256 | pyroutes.register('edit_repo_issuetracker_test', '/%(repo_name)s/settings/issue_trackers/test', ['repo_name']); | |
256 | pyroutes.register('edit_repo_issuetracker_delete', '/%(repo_name)s/settings/issue_trackers/delete', ['repo_name']); |
|
257 | pyroutes.register('edit_repo_issuetracker_delete', '/%(repo_name)s/settings/issue_trackers/delete', ['repo_name']); | |
257 | pyroutes.register('edit_repo_issuetracker_update', '/%(repo_name)s/settings/issue_trackers/update', ['repo_name']); |
|
258 | pyroutes.register('edit_repo_issuetracker_update', '/%(repo_name)s/settings/issue_trackers/update', ['repo_name']); | |
258 | pyroutes.register('edit_repo_vcs', '/%(repo_name)s/settings/vcs', ['repo_name']); |
|
259 | pyroutes.register('edit_repo_vcs', '/%(repo_name)s/settings/vcs', ['repo_name']); | |
259 | pyroutes.register('edit_repo_vcs_update', '/%(repo_name)s/settings/vcs/update', ['repo_name']); |
|
260 | pyroutes.register('edit_repo_vcs_update', '/%(repo_name)s/settings/vcs/update', ['repo_name']); | |
260 | pyroutes.register('edit_repo_vcs_svn_pattern_delete', '/%(repo_name)s/settings/vcs/svn_pattern/delete', ['repo_name']); |
|
261 | pyroutes.register('edit_repo_vcs_svn_pattern_delete', '/%(repo_name)s/settings/vcs/svn_pattern/delete', ['repo_name']); | |
261 | pyroutes.register('repo_reviewers', '/%(repo_name)s/settings/review/rules', ['repo_name']); |
|
262 | pyroutes.register('repo_reviewers', '/%(repo_name)s/settings/review/rules', ['repo_name']); | |
262 | pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/settings/review/default-reviewers', ['repo_name']); |
|
263 | pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/settings/review/default-reviewers', ['repo_name']); | |
263 | pyroutes.register('edit_repo_strip', '/%(repo_name)s/settings/strip', ['repo_name']); |
|
264 | pyroutes.register('edit_repo_strip', '/%(repo_name)s/settings/strip', ['repo_name']); | |
264 | pyroutes.register('strip_check', '/%(repo_name)s/settings/strip_check', ['repo_name']); |
|
265 | pyroutes.register('strip_check', '/%(repo_name)s/settings/strip_check', ['repo_name']); | |
265 | pyroutes.register('strip_execute', '/%(repo_name)s/settings/strip_execute', ['repo_name']); |
|
266 | pyroutes.register('strip_execute', '/%(repo_name)s/settings/strip_execute', ['repo_name']); | |
266 | pyroutes.register('edit_repo_audit_logs', '/%(repo_name)s/settings/audit_logs', ['repo_name']); |
|
267 | pyroutes.register('edit_repo_audit_logs', '/%(repo_name)s/settings/audit_logs', ['repo_name']); | |
267 | pyroutes.register('rss_feed_home', '/%(repo_name)s/feed-rss', ['repo_name']); |
|
268 | pyroutes.register('rss_feed_home', '/%(repo_name)s/feed-rss', ['repo_name']); | |
268 | pyroutes.register('atom_feed_home', '/%(repo_name)s/feed-atom', ['repo_name']); |
|
269 | pyroutes.register('atom_feed_home', '/%(repo_name)s/feed-atom', ['repo_name']); | |
269 | pyroutes.register('rss_feed_home_old', '/%(repo_name)s/feed/rss', ['repo_name']); |
|
270 | pyroutes.register('rss_feed_home_old', '/%(repo_name)s/feed/rss', ['repo_name']); | |
270 | pyroutes.register('atom_feed_home_old', '/%(repo_name)s/feed/atom', ['repo_name']); |
|
271 | pyroutes.register('atom_feed_home_old', '/%(repo_name)s/feed/atom', ['repo_name']); | |
271 | pyroutes.register('repo_summary', '/%(repo_name)s', ['repo_name']); |
|
272 | pyroutes.register('repo_summary', '/%(repo_name)s', ['repo_name']); | |
272 | pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_name']); |
|
273 | pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_name']); | |
273 | pyroutes.register('edit_repo_group', '/%(repo_group_name)s/_edit', ['repo_group_name']); |
|
274 | pyroutes.register('edit_repo_group', '/%(repo_group_name)s/_edit', ['repo_group_name']); | |
274 | pyroutes.register('edit_repo_group_advanced', '/%(repo_group_name)s/_settings/advanced', ['repo_group_name']); |
|
275 | pyroutes.register('edit_repo_group_advanced', '/%(repo_group_name)s/_settings/advanced', ['repo_group_name']); | |
275 | pyroutes.register('edit_repo_group_advanced_delete', '/%(repo_group_name)s/_settings/advanced/delete', ['repo_group_name']); |
|
276 | pyroutes.register('edit_repo_group_advanced_delete', '/%(repo_group_name)s/_settings/advanced/delete', ['repo_group_name']); | |
276 | pyroutes.register('edit_repo_group_perms', '/%(repo_group_name)s/_settings/permissions', ['repo_group_name']); |
|
277 | pyroutes.register('edit_repo_group_perms', '/%(repo_group_name)s/_settings/permissions', ['repo_group_name']); | |
277 | pyroutes.register('edit_repo_group_perms_update', '/%(repo_group_name)s/_settings/permissions/update', ['repo_group_name']); |
|
278 | pyroutes.register('edit_repo_group_perms_update', '/%(repo_group_name)s/_settings/permissions/update', ['repo_group_name']); | |
278 | pyroutes.register('repo_group_home', '/%(repo_group_name)s', ['repo_group_name']); |
|
279 | pyroutes.register('repo_group_home', '/%(repo_group_name)s', ['repo_group_name']); | |
279 | pyroutes.register('repo_group_home_slash', '/%(repo_group_name)s/', ['repo_group_name']); |
|
280 | pyroutes.register('repo_group_home_slash', '/%(repo_group_name)s/', ['repo_group_name']); | |
280 | pyroutes.register('user_group_members_data', '/_admin/user_groups/%(user_group_id)s/members', ['user_group_id']); |
|
281 | pyroutes.register('user_group_members_data', '/_admin/user_groups/%(user_group_id)s/members', ['user_group_id']); | |
281 | pyroutes.register('edit_user_group_perms_summary', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary', ['user_group_id']); |
|
282 | pyroutes.register('edit_user_group_perms_summary', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary', ['user_group_id']); | |
282 | pyroutes.register('edit_user_group_perms_summary_json', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary/json', ['user_group_id']); |
|
283 | pyroutes.register('edit_user_group_perms_summary_json', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary/json', ['user_group_id']); | |
283 | pyroutes.register('edit_user_group', '/_admin/user_groups/%(user_group_id)s/edit', ['user_group_id']); |
|
284 | pyroutes.register('edit_user_group', '/_admin/user_groups/%(user_group_id)s/edit', ['user_group_id']); | |
284 | pyroutes.register('user_groups_update', '/_admin/user_groups/%(user_group_id)s/update', ['user_group_id']); |
|
285 | pyroutes.register('user_groups_update', '/_admin/user_groups/%(user_group_id)s/update', ['user_group_id']); | |
285 | pyroutes.register('edit_user_group_global_perms', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions', ['user_group_id']); |
|
286 | pyroutes.register('edit_user_group_global_perms', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions', ['user_group_id']); | |
286 | pyroutes.register('edit_user_group_global_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions/update', ['user_group_id']); |
|
287 | pyroutes.register('edit_user_group_global_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions/update', ['user_group_id']); | |
287 | pyroutes.register('edit_user_group_perms', '/_admin/user_groups/%(user_group_id)s/edit/permissions', ['user_group_id']); |
|
288 | pyroutes.register('edit_user_group_perms', '/_admin/user_groups/%(user_group_id)s/edit/permissions', ['user_group_id']); | |
288 | pyroutes.register('edit_user_group_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/permissions/update', ['user_group_id']); |
|
289 | pyroutes.register('edit_user_group_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/permissions/update', ['user_group_id']); | |
289 | pyroutes.register('edit_user_group_advanced', '/_admin/user_groups/%(user_group_id)s/edit/advanced', ['user_group_id']); |
|
290 | pyroutes.register('edit_user_group_advanced', '/_admin/user_groups/%(user_group_id)s/edit/advanced', ['user_group_id']); | |
290 | pyroutes.register('edit_user_group_advanced_sync', '/_admin/user_groups/%(user_group_id)s/edit/advanced/sync', ['user_group_id']); |
|
291 | pyroutes.register('edit_user_group_advanced_sync', '/_admin/user_groups/%(user_group_id)s/edit/advanced/sync', ['user_group_id']); | |
291 | pyroutes.register('user_groups_delete', '/_admin/user_groups/%(user_group_id)s/delete', ['user_group_id']); |
|
292 | pyroutes.register('user_groups_delete', '/_admin/user_groups/%(user_group_id)s/delete', ['user_group_id']); | |
292 | pyroutes.register('search', '/_admin/search', []); |
|
293 | pyroutes.register('search', '/_admin/search', []); | |
293 | pyroutes.register('search_repo', '/%(repo_name)s/_search', ['repo_name']); |
|
294 | pyroutes.register('search_repo', '/%(repo_name)s/_search', ['repo_name']); | |
294 | pyroutes.register('search_repo_alt', '/%(repo_name)s/search', ['repo_name']); |
|
295 | pyroutes.register('search_repo_alt', '/%(repo_name)s/search', ['repo_name']); | |
295 | pyroutes.register('search_repo_group', '/%(repo_group_name)s/_search', ['repo_group_name']); |
|
296 | pyroutes.register('search_repo_group', '/%(repo_group_name)s/_search', ['repo_group_name']); | |
296 | pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']); |
|
297 | pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']); | |
297 | pyroutes.register('user_group_profile', '/_profile_user_group/%(user_group_name)s', ['user_group_name']); |
|
298 | pyroutes.register('user_group_profile', '/_profile_user_group/%(user_group_name)s', ['user_group_name']); | |
298 | pyroutes.register('my_account_profile', '/_admin/my_account/profile', []); |
|
299 | pyroutes.register('my_account_profile', '/_admin/my_account/profile', []); | |
299 | pyroutes.register('my_account_edit', '/_admin/my_account/edit', []); |
|
300 | pyroutes.register('my_account_edit', '/_admin/my_account/edit', []); | |
300 | pyroutes.register('my_account_update', '/_admin/my_account/update', []); |
|
301 | pyroutes.register('my_account_update', '/_admin/my_account/update', []); | |
301 | pyroutes.register('my_account_password', '/_admin/my_account/password', []); |
|
302 | pyroutes.register('my_account_password', '/_admin/my_account/password', []); | |
302 | pyroutes.register('my_account_password_update', '/_admin/my_account/password/update', []); |
|
303 | pyroutes.register('my_account_password_update', '/_admin/my_account/password/update', []); | |
303 | pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []); |
|
304 | pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []); | |
304 | pyroutes.register('my_account_ssh_keys', '/_admin/my_account/ssh_keys', []); |
|
305 | pyroutes.register('my_account_ssh_keys', '/_admin/my_account/ssh_keys', []); | |
305 | pyroutes.register('my_account_ssh_keys_generate', '/_admin/my_account/ssh_keys/generate', []); |
|
306 | pyroutes.register('my_account_ssh_keys_generate', '/_admin/my_account/ssh_keys/generate', []); | |
306 | pyroutes.register('my_account_ssh_keys_add', '/_admin/my_account/ssh_keys/new', []); |
|
307 | pyroutes.register('my_account_ssh_keys_add', '/_admin/my_account/ssh_keys/new', []); | |
307 | pyroutes.register('my_account_ssh_keys_delete', '/_admin/my_account/ssh_keys/delete', []); |
|
308 | pyroutes.register('my_account_ssh_keys_delete', '/_admin/my_account/ssh_keys/delete', []); | |
308 | pyroutes.register('my_account_user_group_membership', '/_admin/my_account/user_group_membership', []); |
|
309 | pyroutes.register('my_account_user_group_membership', '/_admin/my_account/user_group_membership', []); | |
309 | pyroutes.register('my_account_emails', '/_admin/my_account/emails', []); |
|
310 | pyroutes.register('my_account_emails', '/_admin/my_account/emails', []); | |
310 | pyroutes.register('my_account_emails_add', '/_admin/my_account/emails/new', []); |
|
311 | pyroutes.register('my_account_emails_add', '/_admin/my_account/emails/new', []); | |
311 | pyroutes.register('my_account_emails_delete', '/_admin/my_account/emails/delete', []); |
|
312 | pyroutes.register('my_account_emails_delete', '/_admin/my_account/emails/delete', []); | |
312 | pyroutes.register('my_account_repos', '/_admin/my_account/repos', []); |
|
313 | pyroutes.register('my_account_repos', '/_admin/my_account/repos', []); | |
313 | pyroutes.register('my_account_watched', '/_admin/my_account/watched', []); |
|
314 | pyroutes.register('my_account_watched', '/_admin/my_account/watched', []); | |
314 | pyroutes.register('my_account_bookmarks', '/_admin/my_account/bookmarks', []); |
|
315 | pyroutes.register('my_account_bookmarks', '/_admin/my_account/bookmarks', []); | |
315 | pyroutes.register('my_account_bookmarks_update', '/_admin/my_account/bookmarks/update', []); |
|
316 | pyroutes.register('my_account_bookmarks_update', '/_admin/my_account/bookmarks/update', []); | |
316 | pyroutes.register('my_account_goto_bookmark', '/_admin/my_account/bookmark/%(bookmark_id)s', ['bookmark_id']); |
|
317 | pyroutes.register('my_account_goto_bookmark', '/_admin/my_account/bookmark/%(bookmark_id)s', ['bookmark_id']); | |
317 | pyroutes.register('my_account_perms', '/_admin/my_account/perms', []); |
|
318 | pyroutes.register('my_account_perms', '/_admin/my_account/perms', []); | |
318 | pyroutes.register('my_account_notifications', '/_admin/my_account/notifications', []); |
|
319 | pyroutes.register('my_account_notifications', '/_admin/my_account/notifications', []); | |
319 | pyroutes.register('my_account_notifications_toggle_visibility', '/_admin/my_account/toggle_visibility', []); |
|
320 | pyroutes.register('my_account_notifications_toggle_visibility', '/_admin/my_account/toggle_visibility', []); | |
320 | pyroutes.register('my_account_pullrequests', '/_admin/my_account/pull_requests', []); |
|
321 | pyroutes.register('my_account_pullrequests', '/_admin/my_account/pull_requests', []); | |
321 | pyroutes.register('my_account_pullrequests_data', '/_admin/my_account/pull_requests/data', []); |
|
322 | pyroutes.register('my_account_pullrequests_data', '/_admin/my_account/pull_requests/data', []); | |
322 | pyroutes.register('notifications_show_all', '/_admin/notifications', []); |
|
323 | pyroutes.register('notifications_show_all', '/_admin/notifications', []); | |
323 | pyroutes.register('notifications_mark_all_read', '/_admin/notifications/mark_all_read', []); |
|
324 | pyroutes.register('notifications_mark_all_read', '/_admin/notifications/mark_all_read', []); | |
324 | pyroutes.register('notifications_show', '/_admin/notifications/%(notification_id)s', ['notification_id']); |
|
325 | pyroutes.register('notifications_show', '/_admin/notifications/%(notification_id)s', ['notification_id']); | |
325 | pyroutes.register('notifications_update', '/_admin/notifications/%(notification_id)s/update', ['notification_id']); |
|
326 | pyroutes.register('notifications_update', '/_admin/notifications/%(notification_id)s/update', ['notification_id']); | |
326 | pyroutes.register('notifications_delete', '/_admin/notifications/%(notification_id)s/delete', ['notification_id']); |
|
327 | pyroutes.register('notifications_delete', '/_admin/notifications/%(notification_id)s/delete', ['notification_id']); | |
327 | pyroutes.register('my_account_notifications_test_channelstream', '/_admin/my_account/test_channelstream', []); |
|
328 | pyroutes.register('my_account_notifications_test_channelstream', '/_admin/my_account/test_channelstream', []); | |
328 | pyroutes.register('gists_show', '/_admin/gists', []); |
|
329 | pyroutes.register('gists_show', '/_admin/gists', []); | |
329 | pyroutes.register('gists_new', '/_admin/gists/new', []); |
|
330 | pyroutes.register('gists_new', '/_admin/gists/new', []); | |
330 | pyroutes.register('gists_create', '/_admin/gists/create', []); |
|
331 | pyroutes.register('gists_create', '/_admin/gists/create', []); | |
331 | pyroutes.register('gist_show', '/_admin/gists/%(gist_id)s', ['gist_id']); |
|
332 | pyroutes.register('gist_show', '/_admin/gists/%(gist_id)s', ['gist_id']); | |
332 | pyroutes.register('gist_delete', '/_admin/gists/%(gist_id)s/delete', ['gist_id']); |
|
333 | pyroutes.register('gist_delete', '/_admin/gists/%(gist_id)s/delete', ['gist_id']); | |
333 | pyroutes.register('gist_edit', '/_admin/gists/%(gist_id)s/edit', ['gist_id']); |
|
334 | pyroutes.register('gist_edit', '/_admin/gists/%(gist_id)s/edit', ['gist_id']); | |
334 | pyroutes.register('gist_edit_check_revision', '/_admin/gists/%(gist_id)s/edit/check_revision', ['gist_id']); |
|
335 | pyroutes.register('gist_edit_check_revision', '/_admin/gists/%(gist_id)s/edit/check_revision', ['gist_id']); | |
335 | pyroutes.register('gist_update', '/_admin/gists/%(gist_id)s/update', ['gist_id']); |
|
336 | pyroutes.register('gist_update', '/_admin/gists/%(gist_id)s/update', ['gist_id']); | |
336 | pyroutes.register('gist_show_rev', '/_admin/gists/%(gist_id)s/%(revision)s', ['gist_id', 'revision']); |
|
337 | pyroutes.register('gist_show_rev', '/_admin/gists/%(gist_id)s/%(revision)s', ['gist_id', 'revision']); | |
337 | pyroutes.register('gist_show_formatted', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s', ['gist_id', 'revision', 'format']); |
|
338 | pyroutes.register('gist_show_formatted', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s', ['gist_id', 'revision', 'format']); | |
338 | pyroutes.register('gist_show_formatted_path', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s/%(f_path)s', ['gist_id', 'revision', 'format', 'f_path']); |
|
339 | pyroutes.register('gist_show_formatted_path', '/_admin/gists/%(gist_id)s/%(revision)s/%(format)s/%(f_path)s', ['gist_id', 'revision', 'format', 'f_path']); | |
339 | pyroutes.register('debug_style_home', '/_admin/debug_style', []); |
|
340 | pyroutes.register('debug_style_home', '/_admin/debug_style', []); | |
340 | pyroutes.register('debug_style_template', '/_admin/debug_style/t/%(t_path)s', ['t_path']); |
|
341 | pyroutes.register('debug_style_template', '/_admin/debug_style/t/%(t_path)s', ['t_path']); | |
341 | pyroutes.register('apiv2', '/_admin/api', []); |
|
342 | pyroutes.register('apiv2', '/_admin/api', []); | |
342 | pyroutes.register('admin_settings_license', '/_admin/settings/license', []); |
|
343 | pyroutes.register('admin_settings_license', '/_admin/settings/license', []); | |
343 | pyroutes.register('admin_settings_license_unlock', '/_admin/settings/license_unlock', []); |
|
344 | pyroutes.register('admin_settings_license_unlock', '/_admin/settings/license_unlock', []); | |
344 | pyroutes.register('login', '/_admin/login', []); |
|
345 | pyroutes.register('login', '/_admin/login', []); | |
345 | pyroutes.register('register', '/_admin/register', []); |
|
346 | pyroutes.register('register', '/_admin/register', []); | |
346 | pyroutes.register('repo_reviewers_review_rule_new', '/%(repo_name)s/settings/review/rules/new', ['repo_name']); |
|
347 | pyroutes.register('repo_reviewers_review_rule_new', '/%(repo_name)s/settings/review/rules/new', ['repo_name']); | |
347 | pyroutes.register('repo_reviewers_review_rule_edit', '/%(repo_name)s/settings/review/rules/%(rule_id)s', ['repo_name', 'rule_id']); |
|
348 | pyroutes.register('repo_reviewers_review_rule_edit', '/%(repo_name)s/settings/review/rules/%(rule_id)s', ['repo_name', 'rule_id']); | |
348 | pyroutes.register('repo_reviewers_review_rule_delete', '/%(repo_name)s/settings/review/rules/%(rule_id)s/delete', ['repo_name', 'rule_id']); |
|
349 | pyroutes.register('repo_reviewers_review_rule_delete', '/%(repo_name)s/settings/review/rules/%(rule_id)s/delete', ['repo_name', 'rule_id']); | |
349 | pyroutes.register('plugin_admin_chat', '/_admin/plugin_admin_chat/%(action)s', ['action']); |
|
350 | pyroutes.register('plugin_admin_chat', '/_admin/plugin_admin_chat/%(action)s', ['action']); | |
350 | pyroutes.register('edit_user_auth_tokens', '/_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']); |
|
351 | pyroutes.register('edit_user_auth_tokens', '/_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']); | |
351 | pyroutes.register('edit_user_auth_tokens_add', '/_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']); |
|
352 | pyroutes.register('edit_user_auth_tokens_add', '/_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']); | |
352 | pyroutes.register('admin_settings_scheduler_show_tasks', '/_admin/settings/scheduler/_tasks', []); |
|
353 | pyroutes.register('admin_settings_scheduler_show_tasks', '/_admin/settings/scheduler/_tasks', []); | |
353 | pyroutes.register('admin_settings_scheduler_show_all', '/_admin/settings/scheduler', []); |
|
354 | pyroutes.register('admin_settings_scheduler_show_all', '/_admin/settings/scheduler', []); | |
354 | pyroutes.register('admin_settings_scheduler_new', '/_admin/settings/scheduler/new', []); |
|
355 | pyroutes.register('admin_settings_scheduler_new', '/_admin/settings/scheduler/new', []); | |
355 | pyroutes.register('admin_settings_scheduler_create', '/_admin/settings/scheduler/create', []); |
|
356 | pyroutes.register('admin_settings_scheduler_create', '/_admin/settings/scheduler/create', []); | |
356 | pyroutes.register('admin_settings_scheduler_edit', '/_admin/settings/scheduler/%(schedule_id)s', ['schedule_id']); |
|
357 | pyroutes.register('admin_settings_scheduler_edit', '/_admin/settings/scheduler/%(schedule_id)s', ['schedule_id']); | |
357 | pyroutes.register('admin_settings_scheduler_update', '/_admin/settings/scheduler/%(schedule_id)s/update', ['schedule_id']); |
|
358 | pyroutes.register('admin_settings_scheduler_update', '/_admin/settings/scheduler/%(schedule_id)s/update', ['schedule_id']); | |
358 | pyroutes.register('admin_settings_scheduler_delete', '/_admin/settings/scheduler/%(schedule_id)s/delete', ['schedule_id']); |
|
359 | pyroutes.register('admin_settings_scheduler_delete', '/_admin/settings/scheduler/%(schedule_id)s/delete', ['schedule_id']); | |
359 | pyroutes.register('admin_settings_scheduler_execute', '/_admin/settings/scheduler/%(schedule_id)s/execute', ['schedule_id']); |
|
360 | pyroutes.register('admin_settings_scheduler_execute', '/_admin/settings/scheduler/%(schedule_id)s/execute', ['schedule_id']); | |
360 | pyroutes.register('admin_settings_automation', '/_admin/settings/automation', []); |
|
361 | pyroutes.register('admin_settings_automation', '/_admin/settings/automation', []); | |
361 | pyroutes.register('admin_settings_automation_update', '/_admin/settings/automation/%(entry_id)s/update', ['entry_id']); |
|
362 | pyroutes.register('admin_settings_automation_update', '/_admin/settings/automation/%(entry_id)s/update', ['entry_id']); | |
362 | pyroutes.register('admin_permissions_branch', '/_admin/permissions/branch', []); |
|
363 | pyroutes.register('admin_permissions_branch', '/_admin/permissions/branch', []); | |
363 | pyroutes.register('admin_permissions_branch_update', '/_admin/permissions/branch/update', []); |
|
364 | pyroutes.register('admin_permissions_branch_update', '/_admin/permissions/branch/update', []); | |
364 | pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []); |
|
365 | pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []); | |
365 | pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []); |
|
366 | pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []); | |
366 | pyroutes.register('my_account_external_identity', '/_admin/my_account/external-identity', []); |
|
367 | pyroutes.register('my_account_external_identity', '/_admin/my_account/external-identity', []); | |
367 | pyroutes.register('my_account_external_identity_delete', '/_admin/my_account/external-identity/delete', []); |
|
368 | pyroutes.register('my_account_external_identity_delete', '/_admin/my_account/external-identity/delete', []); | |
368 | pyroutes.register('repo_artifacts_list', '/%(repo_name)s/artifacts', ['repo_name']); |
|
369 | pyroutes.register('repo_artifacts_list', '/%(repo_name)s/artifacts', ['repo_name']); | |
369 | pyroutes.register('repo_artifacts_data', '/%(repo_name)s/artifacts_data', ['repo_name']); |
|
370 | pyroutes.register('repo_artifacts_data', '/%(repo_name)s/artifacts_data', ['repo_name']); | |
370 | pyroutes.register('repo_artifacts_new', '/%(repo_name)s/artifacts/new', ['repo_name']); |
|
371 | pyroutes.register('repo_artifacts_new', '/%(repo_name)s/artifacts/new', ['repo_name']); | |
371 | pyroutes.register('repo_artifacts_get', '/%(repo_name)s/artifacts/download/%(uid)s', ['repo_name', 'uid']); |
|
372 | pyroutes.register('repo_artifacts_get', '/%(repo_name)s/artifacts/download/%(uid)s', ['repo_name', 'uid']); | |
372 | pyroutes.register('repo_artifacts_store', '/%(repo_name)s/artifacts/store', ['repo_name']); |
|
373 | pyroutes.register('repo_artifacts_store', '/%(repo_name)s/artifacts/store', ['repo_name']); | |
373 | pyroutes.register('repo_artifacts_info', '/%(repo_name)s/artifacts/info/%(uid)s', ['repo_name', 'uid']); |
|
374 | pyroutes.register('repo_artifacts_info', '/%(repo_name)s/artifacts/info/%(uid)s', ['repo_name', 'uid']); | |
374 | pyroutes.register('repo_artifacts_delete', '/%(repo_name)s/artifacts/delete/%(uid)s', ['repo_name', 'uid']); |
|
375 | pyroutes.register('repo_artifacts_delete', '/%(repo_name)s/artifacts/delete/%(uid)s', ['repo_name', 'uid']); | |
375 | pyroutes.register('repo_automation', '/%(repo_name)s/settings/automation', ['repo_name']); |
|
376 | pyroutes.register('repo_automation', '/%(repo_name)s/settings/automation', ['repo_name']); | |
376 | pyroutes.register('repo_automation_update', '/%(repo_name)s/settings/automation/%(entry_id)s/update', ['repo_name', 'entry_id']); |
|
377 | pyroutes.register('repo_automation_update', '/%(repo_name)s/settings/automation/%(entry_id)s/update', ['repo_name', 'entry_id']); | |
377 | pyroutes.register('edit_repo_remote_push', '/%(repo_name)s/settings/remote/push', ['repo_name']); |
|
378 | pyroutes.register('edit_repo_remote_push', '/%(repo_name)s/settings/remote/push', ['repo_name']); | |
378 | pyroutes.register('edit_repo_perms_branch', '/%(repo_name)s/settings/branch_permissions', ['repo_name']); |
|
379 | pyroutes.register('edit_repo_perms_branch', '/%(repo_name)s/settings/branch_permissions', ['repo_name']); | |
379 | pyroutes.register('edit_repo_perms_branch_delete', '/%(repo_name)s/settings/branch_permissions/%(rule_id)s/delete', ['repo_name', 'rule_id']); |
|
380 | pyroutes.register('edit_repo_perms_branch_delete', '/%(repo_name)s/settings/branch_permissions/%(rule_id)s/delete', ['repo_name', 'rule_id']); | |
380 | } |
|
381 | } |
@@ -1,838 +1,927 b'' | |||||
1 | // # Copyright (C) 2010-2019 RhodeCode GmbH |
|
1 | // # Copyright (C) 2010-2019 RhodeCode GmbH | |
2 | // # |
|
2 | // # | |
3 | // # This program is free software: you can redistribute it and/or modify |
|
3 | // # This program is free software: you can redistribute it and/or modify | |
4 | // # it under the terms of the GNU Affero General Public License, version 3 |
|
4 | // # it under the terms of the GNU Affero General Public License, version 3 | |
5 | // # (only), as published by the Free Software Foundation. |
|
5 | // # (only), as published by the Free Software Foundation. | |
6 | // # |
|
6 | // # | |
7 | // # This program is distributed in the hope that it will be useful, |
|
7 | // # This program is distributed in the hope that it will be useful, | |
8 | // # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
8 | // # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
9 | // # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
9 | // # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
10 | // # GNU General Public License for more details. |
|
10 | // # GNU General Public License for more details. | |
11 | // # |
|
11 | // # | |
12 | // # You should have received a copy of the GNU Affero General Public License |
|
12 | // # You should have received a copy of the GNU Affero General Public License | |
13 | // # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
13 | // # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
14 | // # |
|
14 | // # | |
15 | // # This program is dual-licensed. If you wish to learn more about the |
|
15 | // # This program is dual-licensed. If you wish to learn more about the | |
16 | // # RhodeCode Enterprise Edition, including its added features, Support services, |
|
16 | // # RhodeCode Enterprise Edition, including its added features, Support services, | |
17 | // # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
17 | // # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
18 |
|
18 | |||
19 | var firefoxAnchorFix = function() { |
|
19 | var firefoxAnchorFix = function() { | |
20 | // hack to make anchor links behave properly on firefox, in our inline |
|
20 | // hack to make anchor links behave properly on firefox, in our inline | |
21 | // comments generation when comments are injected firefox is misbehaving |
|
21 | // comments generation when comments are injected firefox is misbehaving | |
22 | // when jumping to anchor links |
|
22 | // when jumping to anchor links | |
23 | if (location.href.indexOf('#') > -1) { |
|
23 | if (location.href.indexOf('#') > -1) { | |
24 | location.href += ''; |
|
24 | location.href += ''; | |
25 | } |
|
25 | } | |
26 | }; |
|
26 | }; | |
27 |
|
27 | |||
28 | var linkifyComments = function(comments) { |
|
28 | var linkifyComments = function(comments) { | |
29 | var firstCommentId = null; |
|
29 | var firstCommentId = null; | |
30 | if (comments) { |
|
30 | if (comments) { | |
31 | firstCommentId = $(comments[0]).data('comment-id'); |
|
31 | firstCommentId = $(comments[0]).data('comment-id'); | |
32 | } |
|
32 | } | |
33 |
|
33 | |||
34 | if (firstCommentId){ |
|
34 | if (firstCommentId){ | |
35 | $('#inline-comments-counter').attr('href', '#comment-' + firstCommentId); |
|
35 | $('#inline-comments-counter').attr('href', '#comment-' + firstCommentId); | |
36 | } |
|
36 | } | |
37 | }; |
|
37 | }; | |
38 |
|
38 | |||
39 | var bindToggleButtons = function() { |
|
39 | var bindToggleButtons = function() { | |
40 | $('.comment-toggle').on('click', function() { |
|
40 | $('.comment-toggle').on('click', function() { | |
41 | $(this).parent().nextUntil('tr.line').toggle('inline-comments'); |
|
41 | $(this).parent().nextUntil('tr.line').toggle('inline-comments'); | |
42 | }); |
|
42 | }); | |
43 | }; |
|
43 | }; | |
44 |
|
44 | |||
45 |
|
45 | |||
46 |
|
46 | |||
47 | var _submitAjaxPOST = function(url, postData, successHandler, failHandler) { |
|
47 | var _submitAjaxPOST = function(url, postData, successHandler, failHandler) { | |
48 | failHandler = failHandler || function() {}; |
|
48 | failHandler = failHandler || function() {}; | |
49 | postData = toQueryString(postData); |
|
49 | postData = toQueryString(postData); | |
50 | var request = $.ajax({ |
|
50 | var request = $.ajax({ | |
51 | url: url, |
|
51 | url: url, | |
52 | type: 'POST', |
|
52 | type: 'POST', | |
53 | data: postData, |
|
53 | data: postData, | |
54 | headers: {'X-PARTIAL-XHR': true} |
|
54 | headers: {'X-PARTIAL-XHR': true} | |
55 | }) |
|
55 | }) | |
56 | .done(function (data) { |
|
56 | .done(function (data) { | |
57 | successHandler(data); |
|
57 | successHandler(data); | |
58 | }) |
|
58 | }) | |
59 | .fail(function (data, textStatus, errorThrown) { |
|
59 | .fail(function (data, textStatus, errorThrown) { | |
60 | failHandler(data, textStatus, errorThrown) |
|
60 | failHandler(data, textStatus, errorThrown) | |
61 | }); |
|
61 | }); | |
62 | return request; |
|
62 | return request; | |
63 | }; |
|
63 | }; | |
64 |
|
64 | |||
65 |
|
65 | |||
66 |
|
66 | |||
67 |
|
67 | |||
68 | /* Comment form for main and inline comments */ |
|
68 | /* Comment form for main and inline comments */ | |
69 | (function(mod) { |
|
69 | (function(mod) { | |
70 |
|
70 | |||
71 | if (typeof exports == "object" && typeof module == "object") { |
|
71 | if (typeof exports == "object" && typeof module == "object") { | |
72 | // CommonJS |
|
72 | // CommonJS | |
73 | module.exports = mod(); |
|
73 | module.exports = mod(); | |
74 | } |
|
74 | } | |
75 | else { |
|
75 | else { | |
76 | // Plain browser env |
|
76 | // Plain browser env | |
77 | (this || window).CommentForm = mod(); |
|
77 | (this || window).CommentForm = mod(); | |
78 | } |
|
78 | } | |
79 |
|
79 | |||
80 | })(function() { |
|
80 | })(function() { | |
81 | "use strict"; |
|
81 | "use strict"; | |
82 |
|
82 | |||
83 | function CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId) { |
|
83 | function CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId) { | |
84 | if (!(this instanceof CommentForm)) { |
|
84 | if (!(this instanceof CommentForm)) { | |
85 | return new CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId); |
|
85 | return new CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId); | |
86 | } |
|
86 | } | |
87 |
|
87 | |||
88 | // bind the element instance to our Form |
|
88 | // bind the element instance to our Form | |
89 | $(formElement).get(0).CommentForm = this; |
|
89 | $(formElement).get(0).CommentForm = this; | |
90 |
|
90 | |||
91 | this.withLineNo = function(selector) { |
|
91 | this.withLineNo = function(selector) { | |
92 | var lineNo = this.lineNo; |
|
92 | var lineNo = this.lineNo; | |
93 | if (lineNo === undefined) { |
|
93 | if (lineNo === undefined) { | |
94 | return selector |
|
94 | return selector | |
95 | } else { |
|
95 | } else { | |
96 | return selector + '_' + lineNo; |
|
96 | return selector + '_' + lineNo; | |
97 | } |
|
97 | } | |
98 | }; |
|
98 | }; | |
99 |
|
99 | |||
100 | this.commitId = commitId; |
|
100 | this.commitId = commitId; | |
101 | this.pullRequestId = pullRequestId; |
|
101 | this.pullRequestId = pullRequestId; | |
102 | this.lineNo = lineNo; |
|
102 | this.lineNo = lineNo; | |
103 | this.initAutocompleteActions = initAutocompleteActions; |
|
103 | this.initAutocompleteActions = initAutocompleteActions; | |
104 |
|
104 | |||
105 | this.previewButton = this.withLineNo('#preview-btn'); |
|
105 | this.previewButton = this.withLineNo('#preview-btn'); | |
106 | this.previewContainer = this.withLineNo('#preview-container'); |
|
106 | this.previewContainer = this.withLineNo('#preview-container'); | |
107 |
|
107 | |||
108 | this.previewBoxSelector = this.withLineNo('#preview-box'); |
|
108 | this.previewBoxSelector = this.withLineNo('#preview-box'); | |
109 |
|
109 | |||
110 | this.editButton = this.withLineNo('#edit-btn'); |
|
110 | this.editButton = this.withLineNo('#edit-btn'); | |
111 | this.editContainer = this.withLineNo('#edit-container'); |
|
111 | this.editContainer = this.withLineNo('#edit-container'); | |
112 | this.cancelButton = this.withLineNo('#cancel-btn'); |
|
112 | this.cancelButton = this.withLineNo('#cancel-btn'); | |
113 | this.commentType = this.withLineNo('#comment_type'); |
|
113 | this.commentType = this.withLineNo('#comment_type'); | |
114 |
|
114 | |||
115 | this.resolvesId = null; |
|
115 | this.resolvesId = null; | |
116 | this.resolvesActionId = null; |
|
116 | this.resolvesActionId = null; | |
117 |
|
117 | |||
118 | this.closesPr = '#close_pull_request'; |
|
118 | this.closesPr = '#close_pull_request'; | |
119 |
|
119 | |||
120 | this.cmBox = this.withLineNo('#text'); |
|
120 | this.cmBox = this.withLineNo('#text'); | |
121 | this.cm = initCommentBoxCodeMirror(this, this.cmBox, this.initAutocompleteActions); |
|
121 | this.cm = initCommentBoxCodeMirror(this, this.cmBox, this.initAutocompleteActions); | |
122 |
|
122 | |||
123 | this.statusChange = this.withLineNo('#change_status'); |
|
123 | this.statusChange = this.withLineNo('#change_status'); | |
124 |
|
124 | |||
125 | this.submitForm = formElement; |
|
125 | this.submitForm = formElement; | |
126 | this.submitButton = $(this.submitForm).find('input[type="submit"]'); |
|
126 | this.submitButton = $(this.submitForm).find('input[type="submit"]'); | |
127 | this.submitButtonText = this.submitButton.val(); |
|
127 | this.submitButtonText = this.submitButton.val(); | |
128 |
|
128 | |||
129 | this.previewUrl = pyroutes.url('repo_commit_comment_preview', |
|
129 | this.previewUrl = pyroutes.url('repo_commit_comment_preview', | |
130 | {'repo_name': templateContext.repo_name, |
|
130 | {'repo_name': templateContext.repo_name, | |
131 | 'commit_id': templateContext.commit_data.commit_id}); |
|
131 | 'commit_id': templateContext.commit_data.commit_id}); | |
132 |
|
132 | |||
133 | if (resolvesCommentId){ |
|
133 | if (resolvesCommentId){ | |
134 | this.resolvesId = '#resolve_comment_{0}'.format(resolvesCommentId); |
|
134 | this.resolvesId = '#resolve_comment_{0}'.format(resolvesCommentId); | |
135 | this.resolvesActionId = '#resolve_comment_action_{0}'.format(resolvesCommentId); |
|
135 | this.resolvesActionId = '#resolve_comment_action_{0}'.format(resolvesCommentId); | |
136 | $(this.commentType).prop('disabled', true); |
|
136 | $(this.commentType).prop('disabled', true); | |
137 | $(this.commentType).addClass('disabled'); |
|
137 | $(this.commentType).addClass('disabled'); | |
138 |
|
138 | |||
139 | // disable select |
|
139 | // disable select | |
140 | setTimeout(function() { |
|
140 | setTimeout(function() { | |
141 | $(self.statusChange).select2('readonly', true); |
|
141 | $(self.statusChange).select2('readonly', true); | |
142 | }, 10); |
|
142 | }, 10); | |
143 |
|
143 | |||
144 | var resolvedInfo = ( |
|
144 | var resolvedInfo = ( | |
145 | '<li class="resolve-action">' + |
|
145 | '<li class="resolve-action">' + | |
146 | '<input type="hidden" id="resolve_comment_{0}" name="resolve_comment_{0}" value="{0}">' + |
|
146 | '<input type="hidden" id="resolve_comment_{0}" name="resolve_comment_{0}" value="{0}">' + | |
147 | '<button id="resolve_comment_action_{0}" class="resolve-text btn btn-sm" onclick="return Rhodecode.comments.submitResolution({0})">{1} #{0}</button>' + |
|
147 | '<button id="resolve_comment_action_{0}" class="resolve-text btn btn-sm" onclick="return Rhodecode.comments.submitResolution({0})">{1} #{0}</button>' + | |
148 | '</li>' |
|
148 | '</li>' | |
149 | ).format(resolvesCommentId, _gettext('resolve comment')); |
|
149 | ).format(resolvesCommentId, _gettext('resolve comment')); | |
150 | $(resolvedInfo).insertAfter($(this.commentType).parent()); |
|
150 | $(resolvedInfo).insertAfter($(this.commentType).parent()); | |
151 | } |
|
151 | } | |
152 |
|
152 | |||
153 | // based on commitId, or pullRequestId decide where do we submit |
|
153 | // based on commitId, or pullRequestId decide where do we submit | |
154 | // out data |
|
154 | // out data | |
155 | if (this.commitId){ |
|
155 | if (this.commitId){ | |
156 | this.submitUrl = pyroutes.url('repo_commit_comment_create', |
|
156 | this.submitUrl = pyroutes.url('repo_commit_comment_create', | |
157 | {'repo_name': templateContext.repo_name, |
|
157 | {'repo_name': templateContext.repo_name, | |
158 | 'commit_id': this.commitId}); |
|
158 | 'commit_id': this.commitId}); | |
159 | this.selfUrl = pyroutes.url('repo_commit', |
|
159 | this.selfUrl = pyroutes.url('repo_commit', | |
160 | {'repo_name': templateContext.repo_name, |
|
160 | {'repo_name': templateContext.repo_name, | |
161 | 'commit_id': this.commitId}); |
|
161 | 'commit_id': this.commitId}); | |
162 |
|
162 | |||
163 | } else if (this.pullRequestId) { |
|
163 | } else if (this.pullRequestId) { | |
164 | this.submitUrl = pyroutes.url('pullrequest_comment_create', |
|
164 | this.submitUrl = pyroutes.url('pullrequest_comment_create', | |
165 | {'repo_name': templateContext.repo_name, |
|
165 | {'repo_name': templateContext.repo_name, | |
166 | 'pull_request_id': this.pullRequestId}); |
|
166 | 'pull_request_id': this.pullRequestId}); | |
167 | this.selfUrl = pyroutes.url('pullrequest_show', |
|
167 | this.selfUrl = pyroutes.url('pullrequest_show', | |
168 | {'repo_name': templateContext.repo_name, |
|
168 | {'repo_name': templateContext.repo_name, | |
169 | 'pull_request_id': this.pullRequestId}); |
|
169 | 'pull_request_id': this.pullRequestId}); | |
170 |
|
170 | |||
171 | } else { |
|
171 | } else { | |
172 | throw new Error( |
|
172 | throw new Error( | |
173 | 'CommentForm requires pullRequestId, or commitId to be specified.') |
|
173 | 'CommentForm requires pullRequestId, or commitId to be specified.') | |
174 | } |
|
174 | } | |
175 |
|
175 | |||
176 | // FUNCTIONS and helpers |
|
176 | // FUNCTIONS and helpers | |
177 | var self = this; |
|
177 | var self = this; | |
178 |
|
178 | |||
179 | this.isInline = function(){ |
|
179 | this.isInline = function(){ | |
180 | return this.lineNo && this.lineNo != 'general'; |
|
180 | return this.lineNo && this.lineNo != 'general'; | |
181 | }; |
|
181 | }; | |
182 |
|
182 | |||
183 | this.getCmInstance = function(){ |
|
183 | this.getCmInstance = function(){ | |
184 | return this.cm |
|
184 | return this.cm | |
185 | }; |
|
185 | }; | |
186 |
|
186 | |||
187 | this.setPlaceholder = function(placeholder) { |
|
187 | this.setPlaceholder = function(placeholder) { | |
188 | var cm = this.getCmInstance(); |
|
188 | var cm = this.getCmInstance(); | |
189 | if (cm){ |
|
189 | if (cm){ | |
190 | cm.setOption('placeholder', placeholder); |
|
190 | cm.setOption('placeholder', placeholder); | |
191 | } |
|
191 | } | |
192 | }; |
|
192 | }; | |
193 |
|
193 | |||
194 | this.getCommentStatus = function() { |
|
194 | this.getCommentStatus = function() { | |
195 | return $(this.submitForm).find(this.statusChange).val(); |
|
195 | return $(this.submitForm).find(this.statusChange).val(); | |
196 | }; |
|
196 | }; | |
197 | this.getCommentType = function() { |
|
197 | this.getCommentType = function() { | |
198 | return $(this.submitForm).find(this.commentType).val(); |
|
198 | return $(this.submitForm).find(this.commentType).val(); | |
199 | }; |
|
199 | }; | |
200 |
|
200 | |||
201 | this.getResolvesId = function() { |
|
201 | this.getResolvesId = function() { | |
202 | return $(this.submitForm).find(this.resolvesId).val() || null; |
|
202 | return $(this.submitForm).find(this.resolvesId).val() || null; | |
203 | }; |
|
203 | }; | |
204 |
|
204 | |||
205 | this.getClosePr = function() { |
|
205 | this.getClosePr = function() { | |
206 | return $(this.submitForm).find(this.closesPr).val() || null; |
|
206 | return $(this.submitForm).find(this.closesPr).val() || null; | |
207 | }; |
|
207 | }; | |
208 |
|
208 | |||
209 | this.markCommentResolved = function(resolvedCommentId){ |
|
209 | this.markCommentResolved = function(resolvedCommentId){ | |
210 | $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolved').show(); |
|
210 | $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolved').show(); | |
211 | $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolve').hide(); |
|
211 | $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolve').hide(); | |
212 | }; |
|
212 | }; | |
213 |
|
213 | |||
214 | this.isAllowedToSubmit = function() { |
|
214 | this.isAllowedToSubmit = function() { | |
215 | return !$(this.submitButton).prop('disabled'); |
|
215 | return !$(this.submitButton).prop('disabled'); | |
216 | }; |
|
216 | }; | |
217 |
|
217 | |||
218 | this.initStatusChangeSelector = function(){ |
|
218 | this.initStatusChangeSelector = function(){ | |
219 | var formatChangeStatus = function(state, escapeMarkup) { |
|
219 | var formatChangeStatus = function(state, escapeMarkup) { | |
220 | var originalOption = state.element; |
|
220 | var originalOption = state.element; | |
221 | var tmpl = '<i class="icon-circle review-status-{0}"></i><span>{1}</span>'.format($(originalOption).data('status'), escapeMarkup(state.text)); |
|
221 | var tmpl = '<i class="icon-circle review-status-{0}"></i><span>{1}</span>'.format($(originalOption).data('status'), escapeMarkup(state.text)); | |
222 | return tmpl |
|
222 | return tmpl | |
223 | }; |
|
223 | }; | |
224 | var formatResult = function(result, container, query, escapeMarkup) { |
|
224 | var formatResult = function(result, container, query, escapeMarkup) { | |
225 | return formatChangeStatus(result, escapeMarkup); |
|
225 | return formatChangeStatus(result, escapeMarkup); | |
226 | }; |
|
226 | }; | |
227 |
|
227 | |||
228 | var formatSelection = function(data, container, escapeMarkup) { |
|
228 | var formatSelection = function(data, container, escapeMarkup) { | |
229 | return formatChangeStatus(data, escapeMarkup); |
|
229 | return formatChangeStatus(data, escapeMarkup); | |
230 | }; |
|
230 | }; | |
231 |
|
231 | |||
232 | $(this.submitForm).find(this.statusChange).select2({ |
|
232 | $(this.submitForm).find(this.statusChange).select2({ | |
233 | placeholder: _gettext('Status Review'), |
|
233 | placeholder: _gettext('Status Review'), | |
234 | formatResult: formatResult, |
|
234 | formatResult: formatResult, | |
235 | formatSelection: formatSelection, |
|
235 | formatSelection: formatSelection, | |
236 | containerCssClass: "drop-menu status_box_menu", |
|
236 | containerCssClass: "drop-menu status_box_menu", | |
237 | dropdownCssClass: "drop-menu-dropdown", |
|
237 | dropdownCssClass: "drop-menu-dropdown", | |
238 | dropdownAutoWidth: true, |
|
238 | dropdownAutoWidth: true, | |
239 | minimumResultsForSearch: -1 |
|
239 | minimumResultsForSearch: -1 | |
240 | }); |
|
240 | }); | |
241 | $(this.submitForm).find(this.statusChange).on('change', function() { |
|
241 | $(this.submitForm).find(this.statusChange).on('change', function() { | |
242 | var status = self.getCommentStatus(); |
|
242 | var status = self.getCommentStatus(); | |
243 |
|
243 | |||
244 | if (status && !self.isInline()) { |
|
244 | if (status && !self.isInline()) { | |
245 | $(self.submitButton).prop('disabled', false); |
|
245 | $(self.submitButton).prop('disabled', false); | |
246 | } |
|
246 | } | |
247 |
|
247 | |||
248 | var placeholderText = _gettext('Comment text will be set automatically based on currently selected status ({0}) ...').format(status); |
|
248 | var placeholderText = _gettext('Comment text will be set automatically based on currently selected status ({0}) ...').format(status); | |
249 | self.setPlaceholder(placeholderText) |
|
249 | self.setPlaceholder(placeholderText) | |
250 | }) |
|
250 | }) | |
251 | }; |
|
251 | }; | |
252 |
|
252 | |||
253 | // reset the comment form into it's original state |
|
253 | // reset the comment form into it's original state | |
254 | this.resetCommentFormState = function(content) { |
|
254 | this.resetCommentFormState = function(content) { | |
255 | content = content || ''; |
|
255 | content = content || ''; | |
256 |
|
256 | |||
257 | $(this.editContainer).show(); |
|
257 | $(this.editContainer).show(); | |
258 | $(this.editButton).parent().addClass('active'); |
|
258 | $(this.editButton).parent().addClass('active'); | |
259 |
|
259 | |||
260 | $(this.previewContainer).hide(); |
|
260 | $(this.previewContainer).hide(); | |
261 | $(this.previewButton).parent().removeClass('active'); |
|
261 | $(this.previewButton).parent().removeClass('active'); | |
262 |
|
262 | |||
263 | this.setActionButtonsDisabled(true); |
|
263 | this.setActionButtonsDisabled(true); | |
264 | self.cm.setValue(content); |
|
264 | self.cm.setValue(content); | |
265 | self.cm.setOption("readOnly", false); |
|
265 | self.cm.setOption("readOnly", false); | |
266 |
|
266 | |||
267 | if (this.resolvesId) { |
|
267 | if (this.resolvesId) { | |
268 | // destroy the resolve action |
|
268 | // destroy the resolve action | |
269 | $(this.resolvesId).parent().remove(); |
|
269 | $(this.resolvesId).parent().remove(); | |
270 | } |
|
270 | } | |
271 | // reset closingPR flag |
|
271 | // reset closingPR flag | |
272 | $('.close-pr-input').remove(); |
|
272 | $('.close-pr-input').remove(); | |
273 |
|
273 | |||
274 | $(this.statusChange).select2('readonly', false); |
|
274 | $(this.statusChange).select2('readonly', false); | |
275 | }; |
|
275 | }; | |
276 |
|
276 | |||
277 | this.globalSubmitSuccessCallback = function(){ |
|
277 | this.globalSubmitSuccessCallback = function(){ | |
278 | // default behaviour is to call GLOBAL hook, if it's registered. |
|
278 | // default behaviour is to call GLOBAL hook, if it's registered. | |
279 | if (window.commentFormGlobalSubmitSuccessCallback !== undefined){ |
|
279 | if (window.commentFormGlobalSubmitSuccessCallback !== undefined){ | |
280 | commentFormGlobalSubmitSuccessCallback() |
|
280 | commentFormGlobalSubmitSuccessCallback() | |
281 | } |
|
281 | } | |
282 | }; |
|
282 | }; | |
283 |
|
283 | |||
284 | this.submitAjaxPOST = function(url, postData, successHandler, failHandler) { |
|
284 | this.submitAjaxPOST = function(url, postData, successHandler, failHandler) { | |
285 | return _submitAjaxPOST(url, postData, successHandler, failHandler); |
|
285 | return _submitAjaxPOST(url, postData, successHandler, failHandler); | |
286 | }; |
|
286 | }; | |
287 |
|
287 | |||
288 | // overwrite a submitHandler, we need to do it for inline comments |
|
288 | // overwrite a submitHandler, we need to do it for inline comments | |
289 | this.setHandleFormSubmit = function(callback) { |
|
289 | this.setHandleFormSubmit = function(callback) { | |
290 | this.handleFormSubmit = callback; |
|
290 | this.handleFormSubmit = callback; | |
291 | }; |
|
291 | }; | |
292 |
|
292 | |||
293 | // overwrite a submitSuccessHandler |
|
293 | // overwrite a submitSuccessHandler | |
294 | this.setGlobalSubmitSuccessCallback = function(callback) { |
|
294 | this.setGlobalSubmitSuccessCallback = function(callback) { | |
295 | this.globalSubmitSuccessCallback = callback; |
|
295 | this.globalSubmitSuccessCallback = callback; | |
296 | }; |
|
296 | }; | |
297 |
|
297 | |||
298 | // default handler for for submit for main comments |
|
298 | // default handler for for submit for main comments | |
299 | this.handleFormSubmit = function() { |
|
299 | this.handleFormSubmit = function() { | |
300 | var text = self.cm.getValue(); |
|
300 | var text = self.cm.getValue(); | |
301 | var status = self.getCommentStatus(); |
|
301 | var status = self.getCommentStatus(); | |
302 | var commentType = self.getCommentType(); |
|
302 | var commentType = self.getCommentType(); | |
303 | var resolvesCommentId = self.getResolvesId(); |
|
303 | var resolvesCommentId = self.getResolvesId(); | |
304 | var closePullRequest = self.getClosePr(); |
|
304 | var closePullRequest = self.getClosePr(); | |
305 |
|
305 | |||
306 | if (text === "" && !status) { |
|
306 | if (text === "" && !status) { | |
307 | return; |
|
307 | return; | |
308 | } |
|
308 | } | |
309 |
|
309 | |||
310 | var excludeCancelBtn = false; |
|
310 | var excludeCancelBtn = false; | |
311 | var submitEvent = true; |
|
311 | var submitEvent = true; | |
312 | self.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent); |
|
312 | self.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent); | |
313 | self.cm.setOption("readOnly", true); |
|
313 | self.cm.setOption("readOnly", true); | |
314 |
|
314 | |||
315 | var postData = { |
|
315 | var postData = { | |
316 | 'text': text, |
|
316 | 'text': text, | |
317 | 'changeset_status': status, |
|
317 | 'changeset_status': status, | |
318 | 'comment_type': commentType, |
|
318 | 'comment_type': commentType, | |
319 | 'csrf_token': CSRF_TOKEN |
|
319 | 'csrf_token': CSRF_TOKEN | |
320 | }; |
|
320 | }; | |
321 |
|
321 | |||
322 | if (resolvesCommentId) { |
|
322 | if (resolvesCommentId) { | |
323 | postData['resolves_comment_id'] = resolvesCommentId; |
|
323 | postData['resolves_comment_id'] = resolvesCommentId; | |
324 | } |
|
324 | } | |
325 |
|
325 | |||
326 | if (closePullRequest) { |
|
326 | if (closePullRequest) { | |
327 | postData['close_pull_request'] = true; |
|
327 | postData['close_pull_request'] = true; | |
328 | } |
|
328 | } | |
329 |
|
329 | |||
330 | var submitSuccessCallback = function(o) { |
|
330 | var submitSuccessCallback = function(o) { | |
331 | // reload page if we change status for single commit. |
|
331 | // reload page if we change status for single commit. | |
332 | if (status && self.commitId) { |
|
332 | if (status && self.commitId) { | |
333 | location.reload(true); |
|
333 | location.reload(true); | |
334 | } else { |
|
334 | } else { | |
335 | $('#injected_page_comments').append(o.rendered_text); |
|
335 | $('#injected_page_comments').append(o.rendered_text); | |
336 | self.resetCommentFormState(); |
|
336 | self.resetCommentFormState(); | |
337 | timeagoActivate(); |
|
337 | timeagoActivate(); | |
338 |
|
338 | |||
339 | // mark visually which comment was resolved |
|
339 | // mark visually which comment was resolved | |
340 | if (resolvesCommentId) { |
|
340 | if (resolvesCommentId) { | |
341 | self.markCommentResolved(resolvesCommentId); |
|
341 | self.markCommentResolved(resolvesCommentId); | |
342 | } |
|
342 | } | |
343 | } |
|
343 | } | |
344 |
|
344 | |||
345 | // run global callback on submit |
|
345 | // run global callback on submit | |
346 | self.globalSubmitSuccessCallback(); |
|
346 | self.globalSubmitSuccessCallback(); | |
347 |
|
347 | |||
348 | }; |
|
348 | }; | |
349 | var submitFailCallback = function(data) { |
|
349 | var submitFailCallback = function(data) { | |
350 | alert( |
|
350 | alert( | |
351 | "Error while submitting comment.\n" + |
|
351 | "Error while submitting comment.\n" + | |
352 | "Error code {0} ({1}).".format(data.status, data.statusText) |
|
352 | "Error code {0} ({1}).".format(data.status, data.statusText) | |
353 | ); |
|
353 | ); | |
354 | self.resetCommentFormState(text); |
|
354 | self.resetCommentFormState(text); | |
355 | }; |
|
355 | }; | |
356 | self.submitAjaxPOST( |
|
356 | self.submitAjaxPOST( | |
357 | self.submitUrl, postData, submitSuccessCallback, submitFailCallback); |
|
357 | self.submitUrl, postData, submitSuccessCallback, submitFailCallback); | |
358 | }; |
|
358 | }; | |
359 |
|
359 | |||
360 | this.previewSuccessCallback = function(o) { |
|
360 | this.previewSuccessCallback = function(o) { | |
361 | $(self.previewBoxSelector).html(o); |
|
361 | $(self.previewBoxSelector).html(o); | |
362 | $(self.previewBoxSelector).removeClass('unloaded'); |
|
362 | $(self.previewBoxSelector).removeClass('unloaded'); | |
363 |
|
363 | |||
364 | // swap buttons, making preview active |
|
364 | // swap buttons, making preview active | |
365 | $(self.previewButton).parent().addClass('active'); |
|
365 | $(self.previewButton).parent().addClass('active'); | |
366 | $(self.editButton).parent().removeClass('active'); |
|
366 | $(self.editButton).parent().removeClass('active'); | |
367 |
|
367 | |||
368 | // unlock buttons |
|
368 | // unlock buttons | |
369 | self.setActionButtonsDisabled(false); |
|
369 | self.setActionButtonsDisabled(false); | |
370 | }; |
|
370 | }; | |
371 |
|
371 | |||
372 | this.setActionButtonsDisabled = function(state, excludeCancelBtn, submitEvent) { |
|
372 | this.setActionButtonsDisabled = function(state, excludeCancelBtn, submitEvent) { | |
373 | excludeCancelBtn = excludeCancelBtn || false; |
|
373 | excludeCancelBtn = excludeCancelBtn || false; | |
374 | submitEvent = submitEvent || false; |
|
374 | submitEvent = submitEvent || false; | |
375 |
|
375 | |||
376 | $(this.editButton).prop('disabled', state); |
|
376 | $(this.editButton).prop('disabled', state); | |
377 | $(this.previewButton).prop('disabled', state); |
|
377 | $(this.previewButton).prop('disabled', state); | |
378 |
|
378 | |||
379 | if (!excludeCancelBtn) { |
|
379 | if (!excludeCancelBtn) { | |
380 | $(this.cancelButton).prop('disabled', state); |
|
380 | $(this.cancelButton).prop('disabled', state); | |
381 | } |
|
381 | } | |
382 |
|
382 | |||
383 | var submitState = state; |
|
383 | var submitState = state; | |
384 | if (!submitEvent && this.getCommentStatus() && !self.isInline()) { |
|
384 | if (!submitEvent && this.getCommentStatus() && !self.isInline()) { | |
385 | // if the value of commit review status is set, we allow |
|
385 | // if the value of commit review status is set, we allow | |
386 | // submit button, but only on Main form, isInline means inline |
|
386 | // submit button, but only on Main form, isInline means inline | |
387 | submitState = false |
|
387 | submitState = false | |
388 | } |
|
388 | } | |
389 |
|
389 | |||
390 | $(this.submitButton).prop('disabled', submitState); |
|
390 | $(this.submitButton).prop('disabled', submitState); | |
391 | if (submitEvent) { |
|
391 | if (submitEvent) { | |
392 | $(this.submitButton).val(_gettext('Submitting...')); |
|
392 | $(this.submitButton).val(_gettext('Submitting...')); | |
393 | } else { |
|
393 | } else { | |
394 | $(this.submitButton).val(this.submitButtonText); |
|
394 | $(this.submitButton).val(this.submitButtonText); | |
395 | } |
|
395 | } | |
396 |
|
396 | |||
397 | }; |
|
397 | }; | |
398 |
|
398 | |||
399 | // lock preview/edit/submit buttons on load, but exclude cancel button |
|
399 | // lock preview/edit/submit buttons on load, but exclude cancel button | |
400 | var excludeCancelBtn = true; |
|
400 | var excludeCancelBtn = true; | |
401 | this.setActionButtonsDisabled(true, excludeCancelBtn); |
|
401 | this.setActionButtonsDisabled(true, excludeCancelBtn); | |
402 |
|
402 | |||
403 | // anonymous users don't have access to initialized CM instance |
|
403 | // anonymous users don't have access to initialized CM instance | |
404 | if (this.cm !== undefined){ |
|
404 | if (this.cm !== undefined){ | |
405 | this.cm.on('change', function(cMirror) { |
|
405 | this.cm.on('change', function(cMirror) { | |
406 | if (cMirror.getValue() === "") { |
|
406 | if (cMirror.getValue() === "") { | |
407 | self.setActionButtonsDisabled(true, excludeCancelBtn) |
|
407 | self.setActionButtonsDisabled(true, excludeCancelBtn) | |
408 | } else { |
|
408 | } else { | |
409 | self.setActionButtonsDisabled(false, excludeCancelBtn) |
|
409 | self.setActionButtonsDisabled(false, excludeCancelBtn) | |
410 | } |
|
410 | } | |
411 | }); |
|
411 | }); | |
412 | } |
|
412 | } | |
413 |
|
413 | |||
414 | $(this.editButton).on('click', function(e) { |
|
414 | $(this.editButton).on('click', function(e) { | |
415 | e.preventDefault(); |
|
415 | e.preventDefault(); | |
416 |
|
416 | |||
417 | $(self.previewButton).parent().removeClass('active'); |
|
417 | $(self.previewButton).parent().removeClass('active'); | |
418 | $(self.previewContainer).hide(); |
|
418 | $(self.previewContainer).hide(); | |
419 |
|
419 | |||
420 | $(self.editButton).parent().addClass('active'); |
|
420 | $(self.editButton).parent().addClass('active'); | |
421 | $(self.editContainer).show(); |
|
421 | $(self.editContainer).show(); | |
422 |
|
422 | |||
423 | }); |
|
423 | }); | |
424 |
|
424 | |||
425 | $(this.previewButton).on('click', function(e) { |
|
425 | $(this.previewButton).on('click', function(e) { | |
426 | e.preventDefault(); |
|
426 | e.preventDefault(); | |
427 | var text = self.cm.getValue(); |
|
427 | var text = self.cm.getValue(); | |
428 |
|
428 | |||
429 | if (text === "") { |
|
429 | if (text === "") { | |
430 | return; |
|
430 | return; | |
431 | } |
|
431 | } | |
432 |
|
432 | |||
433 | var postData = { |
|
433 | var postData = { | |
434 | 'text': text, |
|
434 | 'text': text, | |
435 | 'renderer': templateContext.visual.default_renderer, |
|
435 | 'renderer': templateContext.visual.default_renderer, | |
436 | 'csrf_token': CSRF_TOKEN |
|
436 | 'csrf_token': CSRF_TOKEN | |
437 | }; |
|
437 | }; | |
438 |
|
438 | |||
439 | // lock ALL buttons on preview |
|
439 | // lock ALL buttons on preview | |
440 | self.setActionButtonsDisabled(true); |
|
440 | self.setActionButtonsDisabled(true); | |
441 |
|
441 | |||
442 | $(self.previewBoxSelector).addClass('unloaded'); |
|
442 | $(self.previewBoxSelector).addClass('unloaded'); | |
443 | $(self.previewBoxSelector).html(_gettext('Loading ...')); |
|
443 | $(self.previewBoxSelector).html(_gettext('Loading ...')); | |
444 |
|
444 | |||
445 | $(self.editContainer).hide(); |
|
445 | $(self.editContainer).hide(); | |
446 | $(self.previewContainer).show(); |
|
446 | $(self.previewContainer).show(); | |
447 |
|
447 | |||
448 | // by default we reset state of comment preserving the text |
|
448 | // by default we reset state of comment preserving the text | |
449 | var previewFailCallback = function(data){ |
|
449 | var previewFailCallback = function(data){ | |
450 | alert( |
|
450 | alert( | |
451 | "Error while preview of comment.\n" + |
|
451 | "Error while preview of comment.\n" + | |
452 | "Error code {0} ({1}).".format(data.status, data.statusText) |
|
452 | "Error code {0} ({1}).".format(data.status, data.statusText) | |
453 | ); |
|
453 | ); | |
454 | self.resetCommentFormState(text) |
|
454 | self.resetCommentFormState(text) | |
455 | }; |
|
455 | }; | |
456 | self.submitAjaxPOST( |
|
456 | self.submitAjaxPOST( | |
457 | self.previewUrl, postData, self.previewSuccessCallback, |
|
457 | self.previewUrl, postData, self.previewSuccessCallback, | |
458 | previewFailCallback); |
|
458 | previewFailCallback); | |
459 |
|
459 | |||
460 | $(self.previewButton).parent().addClass('active'); |
|
460 | $(self.previewButton).parent().addClass('active'); | |
461 | $(self.editButton).parent().removeClass('active'); |
|
461 | $(self.editButton).parent().removeClass('active'); | |
462 | }); |
|
462 | }); | |
463 |
|
463 | |||
464 | $(this.submitForm).submit(function(e) { |
|
464 | $(this.submitForm).submit(function(e) { | |
465 | e.preventDefault(); |
|
465 | e.preventDefault(); | |
466 | var allowedToSubmit = self.isAllowedToSubmit(); |
|
466 | var allowedToSubmit = self.isAllowedToSubmit(); | |
467 | if (!allowedToSubmit){ |
|
467 | if (!allowedToSubmit){ | |
468 | return false; |
|
468 | return false; | |
469 | } |
|
469 | } | |
470 | self.handleFormSubmit(); |
|
470 | self.handleFormSubmit(); | |
471 | }); |
|
471 | }); | |
472 |
|
472 | |||
473 | } |
|
473 | } | |
474 |
|
474 | |||
475 | return CommentForm; |
|
475 | return CommentForm; | |
476 | }); |
|
476 | }); | |
477 |
|
477 | |||
478 | /* comments controller */ |
|
478 | /* comments controller */ | |
479 | var CommentsController = function() { |
|
479 | var CommentsController = function() { | |
480 | var mainComment = '#text'; |
|
480 | var mainComment = '#text'; | |
481 | var self = this; |
|
481 | var self = this; | |
482 |
|
482 | |||
483 | this.cancelComment = function(node) { |
|
483 | this.cancelComment = function(node) { | |
484 | var $node = $(node); |
|
484 | var $node = $(node); | |
485 | var $td = $node.closest('td'); |
|
485 | var $td = $node.closest('td'); | |
486 | $node.closest('.comment-inline-form').remove(); |
|
486 | $node.closest('.comment-inline-form').remove(); | |
487 | return false; |
|
487 | return false; | |
488 | }; |
|
488 | }; | |
489 |
|
489 | |||
490 | this.getLineNumber = function(node) { |
|
490 | this.getLineNumber = function(node) { | |
491 | var $node = $(node); |
|
491 | var $node = $(node); | |
492 | var lineNo = $node.closest('td').attr('data-line-no'); |
|
492 | var lineNo = $node.closest('td').attr('data-line-no'); | |
493 | if (lineNo === undefined && $node.data('commentInline')){ |
|
493 | if (lineNo === undefined && $node.data('commentInline')){ | |
494 | lineNo = $node.data('commentLineNo') |
|
494 | lineNo = $node.data('commentLineNo') | |
495 | } |
|
495 | } | |
496 |
|
496 | |||
497 | return lineNo |
|
497 | return lineNo | |
498 | }; |
|
498 | }; | |
499 |
|
499 | |||
500 | this.scrollToComment = function(node, offset, outdated) { |
|
500 | this.scrollToComment = function(node, offset, outdated) { | |
501 | if (offset === undefined) { |
|
501 | if (offset === undefined) { | |
502 | offset = 0; |
|
502 | offset = 0; | |
503 | } |
|
503 | } | |
504 | var outdated = outdated || false; |
|
504 | var outdated = outdated || false; | |
505 | var klass = outdated ? 'div.comment-outdated' : 'div.comment-current'; |
|
505 | var klass = outdated ? 'div.comment-outdated' : 'div.comment-current'; | |
506 |
|
506 | |||
507 | if (!node) { |
|
507 | if (!node) { | |
508 | node = $('.comment-selected'); |
|
508 | node = $('.comment-selected'); | |
509 | if (!node.length) { |
|
509 | if (!node.length) { | |
510 | node = $('comment-current') |
|
510 | node = $('comment-current') | |
511 | } |
|
511 | } | |
512 | } |
|
512 | } | |
513 | $wrapper = $(node).closest('div.comment'); |
|
513 | $wrapper = $(node).closest('div.comment'); | |
514 | $comment = $(node).closest(klass); |
|
514 | $comment = $(node).closest(klass); | |
515 | $comments = $(klass); |
|
515 | $comments = $(klass); | |
516 |
|
516 | |||
517 | // show hidden comment when referenced. |
|
517 | // show hidden comment when referenced. | |
518 | if (!$wrapper.is(':visible')){ |
|
518 | if (!$wrapper.is(':visible')){ | |
519 | $wrapper.show(); |
|
519 | $wrapper.show(); | |
520 | } |
|
520 | } | |
521 |
|
521 | |||
522 | $('.comment-selected').removeClass('comment-selected'); |
|
522 | $('.comment-selected').removeClass('comment-selected'); | |
523 |
|
523 | |||
524 | var nextIdx = $(klass).index($comment) + offset; |
|
524 | var nextIdx = $(klass).index($comment) + offset; | |
525 | if (nextIdx >= $comments.length) { |
|
525 | if (nextIdx >= $comments.length) { | |
526 | nextIdx = 0; |
|
526 | nextIdx = 0; | |
527 | } |
|
527 | } | |
528 | var $next = $(klass).eq(nextIdx); |
|
528 | var $next = $(klass).eq(nextIdx); | |
529 |
|
529 | |||
530 | var $cb = $next.closest('.cb'); |
|
530 | var $cb = $next.closest('.cb'); | |
531 | $cb.removeClass('cb-collapsed'); |
|
531 | $cb.removeClass('cb-collapsed'); | |
532 |
|
532 | |||
533 | var $filediffCollapseState = $cb.closest('.filediff').prev(); |
|
533 | var $filediffCollapseState = $cb.closest('.filediff').prev(); | |
534 | $filediffCollapseState.prop('checked', false); |
|
534 | $filediffCollapseState.prop('checked', false); | |
535 | $next.addClass('comment-selected'); |
|
535 | $next.addClass('comment-selected'); | |
536 | scrollToElement($next); |
|
536 | scrollToElement($next); | |
537 | return false; |
|
537 | return false; | |
538 | }; |
|
538 | }; | |
539 |
|
539 | |||
540 | this.nextComment = function(node) { |
|
540 | this.nextComment = function(node) { | |
541 | return self.scrollToComment(node, 1); |
|
541 | return self.scrollToComment(node, 1); | |
542 | }; |
|
542 | }; | |
543 |
|
543 | |||
544 | this.prevComment = function(node) { |
|
544 | this.prevComment = function(node) { | |
545 | return self.scrollToComment(node, -1); |
|
545 | return self.scrollToComment(node, -1); | |
546 | }; |
|
546 | }; | |
547 |
|
547 | |||
548 | this.nextOutdatedComment = function(node) { |
|
548 | this.nextOutdatedComment = function(node) { | |
549 | return self.scrollToComment(node, 1, true); |
|
549 | return self.scrollToComment(node, 1, true); | |
550 | }; |
|
550 | }; | |
551 |
|
551 | |||
552 | this.prevOutdatedComment = function(node) { |
|
552 | this.prevOutdatedComment = function(node) { | |
553 | return self.scrollToComment(node, -1, true); |
|
553 | return self.scrollToComment(node, -1, true); | |
554 | }; |
|
554 | }; | |
555 |
|
555 | |||
556 | this.deleteComment = function(node) { |
|
556 | this.deleteComment = function(node) { | |
557 | if (!confirm(_gettext('Delete this comment?'))) { |
|
557 | if (!confirm(_gettext('Delete this comment?'))) { | |
558 | return false; |
|
558 | return false; | |
559 | } |
|
559 | } | |
560 | var $node = $(node); |
|
560 | var $node = $(node); | |
561 | var $td = $node.closest('td'); |
|
561 | var $td = $node.closest('td'); | |
562 | var $comment = $node.closest('.comment'); |
|
562 | var $comment = $node.closest('.comment'); | |
563 | var comment_id = $comment.attr('data-comment-id'); |
|
563 | var comment_id = $comment.attr('data-comment-id'); | |
564 | var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id); |
|
564 | var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id); | |
565 | var postData = { |
|
565 | var postData = { | |
566 | 'csrf_token': CSRF_TOKEN |
|
566 | 'csrf_token': CSRF_TOKEN | |
567 | }; |
|
567 | }; | |
568 |
|
568 | |||
569 | $comment.addClass('comment-deleting'); |
|
569 | $comment.addClass('comment-deleting'); | |
570 | $comment.hide('fast'); |
|
570 | $comment.hide('fast'); | |
571 |
|
571 | |||
572 | var success = function(response) { |
|
572 | var success = function(response) { | |
573 | $comment.remove(); |
|
573 | $comment.remove(); | |
574 | return false; |
|
574 | return false; | |
575 | }; |
|
575 | }; | |
576 | var failure = function(data, textStatus, xhr) { |
|
576 | var failure = function(data, textStatus, xhr) { | |
577 | alert("error processing request: " + textStatus); |
|
577 | alert("error processing request: " + textStatus); | |
578 | $comment.show('fast'); |
|
578 | $comment.show('fast'); | |
579 | $comment.removeClass('comment-deleting'); |
|
579 | $comment.removeClass('comment-deleting'); | |
580 | return false; |
|
580 | return false; | |
581 | }; |
|
581 | }; | |
582 | ajaxPOST(url, postData, success, failure); |
|
582 | ajaxPOST(url, postData, success, failure); | |
583 | }; |
|
583 | }; | |
584 |
|
584 | |||
585 | this.toggleWideMode = function (node) { |
|
585 | this.toggleWideMode = function (node) { | |
586 | if ($('#content').hasClass('wrapper')) { |
|
586 | if ($('#content').hasClass('wrapper')) { | |
587 | $('#content').removeClass("wrapper"); |
|
587 | $('#content').removeClass("wrapper"); | |
588 | $('#content').addClass("wide-mode-wrapper"); |
|
588 | $('#content').addClass("wide-mode-wrapper"); | |
589 | $(node).addClass('btn-success'); |
|
589 | $(node).addClass('btn-success'); | |
590 | return true |
|
590 | return true | |
591 | } else { |
|
591 | } else { | |
592 | $('#content').removeClass("wide-mode-wrapper"); |
|
592 | $('#content').removeClass("wide-mode-wrapper"); | |
593 | $('#content').addClass("wrapper"); |
|
593 | $('#content').addClass("wrapper"); | |
594 | $(node).removeClass('btn-success'); |
|
594 | $(node).removeClass('btn-success'); | |
595 | return false |
|
595 | return false | |
596 | } |
|
596 | } | |
597 |
|
597 | |||
598 | }; |
|
598 | }; | |
599 |
|
599 | |||
600 | this.toggleComments = function(node, show) { |
|
600 | this.toggleComments = function(node, show) { | |
601 | var $filediff = $(node).closest('.filediff'); |
|
601 | var $filediff = $(node).closest('.filediff'); | |
602 | if (show === true) { |
|
602 | if (show === true) { | |
603 | $filediff.removeClass('hide-comments'); |
|
603 | $filediff.removeClass('hide-comments'); | |
604 | } else if (show === false) { |
|
604 | } else if (show === false) { | |
605 | $filediff.find('.hide-line-comments').removeClass('hide-line-comments'); |
|
605 | $filediff.find('.hide-line-comments').removeClass('hide-line-comments'); | |
606 | $filediff.addClass('hide-comments'); |
|
606 | $filediff.addClass('hide-comments'); | |
607 | } else { |
|
607 | } else { | |
608 | $filediff.find('.hide-line-comments').removeClass('hide-line-comments'); |
|
608 | $filediff.find('.hide-line-comments').removeClass('hide-line-comments'); | |
609 | $filediff.toggleClass('hide-comments'); |
|
609 | $filediff.toggleClass('hide-comments'); | |
610 | } |
|
610 | } | |
611 | return false; |
|
611 | return false; | |
612 | }; |
|
612 | }; | |
613 |
|
613 | |||
614 | this.toggleLineComments = function(node) { |
|
614 | this.toggleLineComments = function(node) { | |
615 | self.toggleComments(node, true); |
|
615 | self.toggleComments(node, true); | |
616 | var $node = $(node); |
|
616 | var $node = $(node); | |
617 | // mark outdated comments as visible before the toggle; |
|
617 | // mark outdated comments as visible before the toggle; | |
618 | $(node.closest('tr')).find('.comment-outdated').show(); |
|
618 | $(node.closest('tr')).find('.comment-outdated').show(); | |
619 | $node.closest('tr').toggleClass('hide-line-comments'); |
|
619 | $node.closest('tr').toggleClass('hide-line-comments'); | |
620 | }; |
|
620 | }; | |
621 |
|
621 | |||
622 | this.createCommentForm = function(formElement, lineno, placeholderText, initAutocompleteActions, resolvesCommentId){ |
|
622 | this.createCommentForm = function(formElement, lineno, placeholderText, initAutocompleteActions, resolvesCommentId){ | |
623 | var pullRequestId = templateContext.pull_request_data.pull_request_id; |
|
623 | var pullRequestId = templateContext.pull_request_data.pull_request_id; | |
624 | var commitId = templateContext.commit_data.commit_id; |
|
624 | var commitId = templateContext.commit_data.commit_id; | |
625 |
|
625 | |||
626 | var commentForm = new CommentForm( |
|
626 | var commentForm = new CommentForm( | |
627 | formElement, commitId, pullRequestId, lineno, initAutocompleteActions, resolvesCommentId); |
|
627 | formElement, commitId, pullRequestId, lineno, initAutocompleteActions, resolvesCommentId); | |
628 | var cm = commentForm.getCmInstance(); |
|
628 | var cm = commentForm.getCmInstance(); | |
629 |
|
629 | |||
630 | if (resolvesCommentId){ |
|
630 | if (resolvesCommentId){ | |
631 | var placeholderText = _gettext('Leave a comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId); |
|
631 | var placeholderText = _gettext('Leave a comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId); | |
632 | } |
|
632 | } | |
633 |
|
633 | |||
634 | setTimeout(function() { |
|
634 | setTimeout(function() { | |
635 | // callbacks |
|
635 | // callbacks | |
636 | if (cm !== undefined) { |
|
636 | if (cm !== undefined) { | |
637 | commentForm.setPlaceholder(placeholderText); |
|
637 | commentForm.setPlaceholder(placeholderText); | |
638 | if (commentForm.isInline()) { |
|
638 | if (commentForm.isInline()) { | |
639 | cm.focus(); |
|
639 | cm.focus(); | |
640 | cm.refresh(); |
|
640 | cm.refresh(); | |
641 | } |
|
641 | } | |
642 | } |
|
642 | } | |
643 | }, 10); |
|
643 | }, 10); | |
644 |
|
644 | |||
645 | // trigger scrolldown to the resolve comment, since it might be away |
|
645 | // trigger scrolldown to the resolve comment, since it might be away | |
646 | // from the clicked |
|
646 | // from the clicked | |
647 | if (resolvesCommentId){ |
|
647 | if (resolvesCommentId){ | |
648 | var actionNode = $(commentForm.resolvesActionId).offset(); |
|
648 | var actionNode = $(commentForm.resolvesActionId).offset(); | |
649 |
|
649 | |||
650 | setTimeout(function() { |
|
650 | setTimeout(function() { | |
651 | if (actionNode) { |
|
651 | if (actionNode) { | |
652 | $('body, html').animate({scrollTop: actionNode.top}, 10); |
|
652 | $('body, html').animate({scrollTop: actionNode.top}, 10); | |
653 | } |
|
653 | } | |
654 | }, 100); |
|
654 | }, 100); | |
655 | } |
|
655 | } | |
656 |
|
656 | |||
|
657 | // add dropzone support | |||
|
658 | var insertAttachmentText = function (cm, attachmentName, attachmentStoreUrl, isRendered) { | |||
|
659 | var renderer = templateContext.visual.default_renderer; | |||
|
660 | if (renderer == 'rst') { | |||
|
661 | var attachmentUrl = '`#{0} <{1}>`_'.format(attachmentName, attachmentStoreUrl); | |||
|
662 | if (isRendered){ | |||
|
663 | attachmentUrl = '\n.. image:: {0}'.format(attachmentStoreUrl); | |||
|
664 | } | |||
|
665 | } else if (renderer == 'markdown') { | |||
|
666 | var attachmentUrl = '[{0}]({1})'.format(attachmentName, attachmentStoreUrl); | |||
|
667 | if (isRendered){ | |||
|
668 | attachmentUrl = '!' + attachmentUrl; | |||
|
669 | } | |||
|
670 | } else { | |||
|
671 | var attachmentUrl = '{}'.format(attachmentStoreUrl); | |||
|
672 | } | |||
|
673 | cm.replaceRange(attachmentUrl+'\n', CodeMirror.Pos(cm.lastLine())); | |||
|
674 | ||||
|
675 | return false; | |||
|
676 | }; | |||
|
677 | ||||
|
678 | //see: https://www.dropzonejs.com/#configuration | |||
|
679 | var storeUrl = pyroutes.url('repo_commit_comment_attachment_upload', | |||
|
680 | {'repo_name': templateContext.repo_name, | |||
|
681 | 'commit_id': templateContext.commit_data.commit_id}) | |||
|
682 | ||||
|
683 | var previewTmpl = $(formElement).find('.comment-attachment-uploader-template').get(0).innerHTML; | |||
|
684 | var selectLink = $(formElement).find('.pick-attachment').get(0); | |||
|
685 | $(formElement).find('.comment-attachment-uploader').dropzone({ | |||
|
686 | url: storeUrl, | |||
|
687 | headers: {"X-CSRF-Token": CSRF_TOKEN}, | |||
|
688 | paramName: function () { | |||
|
689 | return "attachment" | |||
|
690 | }, // The name that will be used to transfer the file | |||
|
691 | clickable: selectLink, | |||
|
692 | parallelUploads: 1, | |||
|
693 | maxFiles: 10, | |||
|
694 | maxFilesize: templateContext.attachment_store.max_file_size_mb, | |||
|
695 | uploadMultiple: false, | |||
|
696 | autoProcessQueue: true, // if false queue will not be processed automatically. | |||
|
697 | createImageThumbnails: false, | |||
|
698 | previewTemplate: previewTmpl, | |||
|
699 | ||||
|
700 | accept: function (file, done) { | |||
|
701 | done(); | |||
|
702 | }, | |||
|
703 | init: function () { | |||
|
704 | ||||
|
705 | this.on("sending", function (file, xhr, formData) { | |||
|
706 | $(formElement).find('.comment-attachment-uploader').find('.dropzone-text').hide(); | |||
|
707 | $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').show(); | |||
|
708 | }); | |||
|
709 | ||||
|
710 | this.on("success", function (file, response) { | |||
|
711 | $(formElement).find('.comment-attachment-uploader').find('.dropzone-text').show(); | |||
|
712 | $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').hide(); | |||
|
713 | ||||
|
714 | var isRendered = false; | |||
|
715 | var ext = file.name.split('.').pop(); | |||
|
716 | var imageExts = templateContext.attachment_store.image_ext; | |||
|
717 | if (imageExts.indexOf(ext) !== -1){ | |||
|
718 | isRendered = true; | |||
|
719 | } | |||
|
720 | ||||
|
721 | insertAttachmentText(cm, file.name, response.repo_fqn_access_path, isRendered) | |||
|
722 | }); | |||
|
723 | ||||
|
724 | this.on("error", function (file, errorMessage, xhr) { | |||
|
725 | $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').hide(); | |||
|
726 | ||||
|
727 | var error = null; | |||
|
728 | ||||
|
729 | if (xhr !== undefined){ | |||
|
730 | var httpStatus = xhr.status + " " + xhr.statusText; | |||
|
731 | if (xhr.status >= 500) { | |||
|
732 | error = httpStatus; | |||
|
733 | } | |||
|
734 | } | |||
|
735 | ||||
|
736 | if (error === null) { | |||
|
737 | error = errorMessage.error || errorMessage || httpStatus; | |||
|
738 | } | |||
|
739 | $(file.previewElement).find('.dz-error-message').html('ERROR: {0}'.format(error)); | |||
|
740 | ||||
|
741 | }); | |||
|
742 | } | |||
|
743 | }); | |||
|
744 | ||||
|
745 | ||||
657 | return commentForm; |
|
746 | return commentForm; | |
658 | }; |
|
747 | }; | |
659 |
|
748 | |||
660 | this.createGeneralComment = function (lineNo, placeholderText, resolvesCommentId) { |
|
749 | this.createGeneralComment = function (lineNo, placeholderText, resolvesCommentId) { | |
661 |
|
750 | |||
662 | var tmpl = $('#cb-comment-general-form-template').html(); |
|
751 | var tmpl = $('#cb-comment-general-form-template').html(); | |
663 | tmpl = tmpl.format(null, 'general'); |
|
752 | tmpl = tmpl.format(null, 'general'); | |
664 | var $form = $(tmpl); |
|
753 | var $form = $(tmpl); | |
665 |
|
754 | |||
666 | var $formPlaceholder = $('#cb-comment-general-form-placeholder'); |
|
755 | var $formPlaceholder = $('#cb-comment-general-form-placeholder'); | |
667 | var curForm = $formPlaceholder.find('form'); |
|
756 | var curForm = $formPlaceholder.find('form'); | |
668 | if (curForm){ |
|
757 | if (curForm){ | |
669 | curForm.remove(); |
|
758 | curForm.remove(); | |
670 | } |
|
759 | } | |
671 | $formPlaceholder.append($form); |
|
760 | $formPlaceholder.append($form); | |
672 |
|
761 | |||
673 | var _form = $($form[0]); |
|
762 | var _form = $($form[0]); | |
674 | var autocompleteActions = ['approve', 'reject', 'as_note', 'as_todo']; |
|
763 | var autocompleteActions = ['approve', 'reject', 'as_note', 'as_todo']; | |
675 | var commentForm = this.createCommentForm( |
|
764 | var commentForm = this.createCommentForm( | |
676 | _form, lineNo, placeholderText, autocompleteActions, resolvesCommentId); |
|
765 | _form, lineNo, placeholderText, autocompleteActions, resolvesCommentId); | |
677 | commentForm.initStatusChangeSelector(); |
|
766 | commentForm.initStatusChangeSelector(); | |
678 |
|
767 | |||
679 | return commentForm; |
|
768 | return commentForm; | |
680 | }; |
|
769 | }; | |
681 |
|
770 | |||
682 | this.createComment = function(node, resolutionComment) { |
|
771 | this.createComment = function(node, resolutionComment) { | |
683 | var resolvesCommentId = resolutionComment || null; |
|
772 | var resolvesCommentId = resolutionComment || null; | |
684 | var $node = $(node); |
|
773 | var $node = $(node); | |
685 | var $td = $node.closest('td'); |
|
774 | var $td = $node.closest('td'); | |
686 | var $form = $td.find('.comment-inline-form'); |
|
775 | var $form = $td.find('.comment-inline-form'); | |
687 |
|
776 | |||
688 | if (!$form.length) { |
|
777 | if (!$form.length) { | |
689 |
|
778 | |||
690 | var $filediff = $node.closest('.filediff'); |
|
779 | var $filediff = $node.closest('.filediff'); | |
691 | $filediff.removeClass('hide-comments'); |
|
780 | $filediff.removeClass('hide-comments'); | |
692 | var f_path = $filediff.attr('data-f-path'); |
|
781 | var f_path = $filediff.attr('data-f-path'); | |
693 | var lineno = self.getLineNumber(node); |
|
782 | var lineno = self.getLineNumber(node); | |
694 | // create a new HTML from template |
|
783 | // create a new HTML from template | |
695 | var tmpl = $('#cb-comment-inline-form-template').html(); |
|
784 | var tmpl = $('#cb-comment-inline-form-template').html(); | |
696 | tmpl = tmpl.format(escapeHtml(f_path), lineno); |
|
785 | tmpl = tmpl.format(escapeHtml(f_path), lineno); | |
697 | $form = $(tmpl); |
|
786 | $form = $(tmpl); | |
698 |
|
787 | |||
699 | var $comments = $td.find('.inline-comments'); |
|
788 | var $comments = $td.find('.inline-comments'); | |
700 | if (!$comments.length) { |
|
789 | if (!$comments.length) { | |
701 | $comments = $( |
|
790 | $comments = $( | |
702 | $('#cb-comments-inline-container-template').html()); |
|
791 | $('#cb-comments-inline-container-template').html()); | |
703 | $td.append($comments); |
|
792 | $td.append($comments); | |
704 | } |
|
793 | } | |
705 |
|
794 | |||
706 | $td.find('.cb-comment-add-button').before($form); |
|
795 | $td.find('.cb-comment-add-button').before($form); | |
707 |
|
796 | |||
708 | var placeholderText = _gettext('Leave a comment on line {0}.').format(lineno); |
|
797 | var placeholderText = _gettext('Leave a comment on line {0}.').format(lineno); | |
709 | var _form = $($form[0]).find('form'); |
|
798 | var _form = $($form[0]).find('form'); | |
710 | var autocompleteActions = ['as_note', 'as_todo']; |
|
799 | var autocompleteActions = ['as_note', 'as_todo']; | |
711 | var commentForm = this.createCommentForm( |
|
800 | var commentForm = this.createCommentForm( | |
712 | _form, lineno, placeholderText, autocompleteActions, resolvesCommentId); |
|
801 | _form, lineno, placeholderText, autocompleteActions, resolvesCommentId); | |
713 |
|
802 | |||
714 | $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({ |
|
803 | $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({ | |
715 | form: _form, |
|
804 | form: _form, | |
716 | parent: $td[0], |
|
805 | parent: $td[0], | |
717 | lineno: lineno, |
|
806 | lineno: lineno, | |
718 | f_path: f_path} |
|
807 | f_path: f_path} | |
719 | ); |
|
808 | ); | |
720 |
|
809 | |||
721 | // set a CUSTOM submit handler for inline comments. |
|
810 | // set a CUSTOM submit handler for inline comments. | |
722 | commentForm.setHandleFormSubmit(function(o) { |
|
811 | commentForm.setHandleFormSubmit(function(o) { | |
723 | var text = commentForm.cm.getValue(); |
|
812 | var text = commentForm.cm.getValue(); | |
724 | var commentType = commentForm.getCommentType(); |
|
813 | var commentType = commentForm.getCommentType(); | |
725 | var resolvesCommentId = commentForm.getResolvesId(); |
|
814 | var resolvesCommentId = commentForm.getResolvesId(); | |
726 |
|
815 | |||
727 | if (text === "") { |
|
816 | if (text === "") { | |
728 | return; |
|
817 | return; | |
729 | } |
|
818 | } | |
730 |
|
819 | |||
731 | if (lineno === undefined) { |
|
820 | if (lineno === undefined) { | |
732 | alert('missing line !'); |
|
821 | alert('missing line !'); | |
733 | return; |
|
822 | return; | |
734 | } |
|
823 | } | |
735 | if (f_path === undefined) { |
|
824 | if (f_path === undefined) { | |
736 | alert('missing file path !'); |
|
825 | alert('missing file path !'); | |
737 | return; |
|
826 | return; | |
738 | } |
|
827 | } | |
739 |
|
828 | |||
740 | var excludeCancelBtn = false; |
|
829 | var excludeCancelBtn = false; | |
741 | var submitEvent = true; |
|
830 | var submitEvent = true; | |
742 | commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent); |
|
831 | commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent); | |
743 | commentForm.cm.setOption("readOnly", true); |
|
832 | commentForm.cm.setOption("readOnly", true); | |
744 | var postData = { |
|
833 | var postData = { | |
745 | 'text': text, |
|
834 | 'text': text, | |
746 | 'f_path': f_path, |
|
835 | 'f_path': f_path, | |
747 | 'line': lineno, |
|
836 | 'line': lineno, | |
748 | 'comment_type': commentType, |
|
837 | 'comment_type': commentType, | |
749 | 'csrf_token': CSRF_TOKEN |
|
838 | 'csrf_token': CSRF_TOKEN | |
750 | }; |
|
839 | }; | |
751 | if (resolvesCommentId){ |
|
840 | if (resolvesCommentId){ | |
752 | postData['resolves_comment_id'] = resolvesCommentId; |
|
841 | postData['resolves_comment_id'] = resolvesCommentId; | |
753 | } |
|
842 | } | |
754 |
|
843 | |||
755 | var submitSuccessCallback = function(json_data) { |
|
844 | var submitSuccessCallback = function(json_data) { | |
756 | $form.remove(); |
|
845 | $form.remove(); | |
757 | try { |
|
846 | try { | |
758 | var html = json_data.rendered_text; |
|
847 | var html = json_data.rendered_text; | |
759 | var lineno = json_data.line_no; |
|
848 | var lineno = json_data.line_no; | |
760 | var target_id = json_data.target_id; |
|
849 | var target_id = json_data.target_id; | |
761 |
|
850 | |||
762 | $comments.find('.cb-comment-add-button').before(html); |
|
851 | $comments.find('.cb-comment-add-button').before(html); | |
763 |
|
852 | |||
764 | //mark visually which comment was resolved |
|
853 | //mark visually which comment was resolved | |
765 | if (resolvesCommentId) { |
|
854 | if (resolvesCommentId) { | |
766 | commentForm.markCommentResolved(resolvesCommentId); |
|
855 | commentForm.markCommentResolved(resolvesCommentId); | |
767 | } |
|
856 | } | |
768 |
|
857 | |||
769 | // run global callback on submit |
|
858 | // run global callback on submit | |
770 | commentForm.globalSubmitSuccessCallback(); |
|
859 | commentForm.globalSubmitSuccessCallback(); | |
771 |
|
860 | |||
772 | } catch (e) { |
|
861 | } catch (e) { | |
773 | console.error(e); |
|
862 | console.error(e); | |
774 | } |
|
863 | } | |
775 |
|
864 | |||
776 | // re trigger the linkification of next/prev navigation |
|
865 | // re trigger the linkification of next/prev navigation | |
777 | linkifyComments($('.inline-comment-injected')); |
|
866 | linkifyComments($('.inline-comment-injected')); | |
778 | timeagoActivate(); |
|
867 | timeagoActivate(); | |
779 |
|
868 | |||
780 | if (window.updateSticky !== undefined) { |
|
869 | if (window.updateSticky !== undefined) { | |
781 | // potentially our comments change the active window size, so we |
|
870 | // potentially our comments change the active window size, so we | |
782 | // notify sticky elements |
|
871 | // notify sticky elements | |
783 | updateSticky() |
|
872 | updateSticky() | |
784 | } |
|
873 | } | |
785 |
|
874 | |||
786 | commentForm.setActionButtonsDisabled(false); |
|
875 | commentForm.setActionButtonsDisabled(false); | |
787 |
|
876 | |||
788 | }; |
|
877 | }; | |
789 | var submitFailCallback = function(data){ |
|
878 | var submitFailCallback = function(data){ | |
790 | alert( |
|
879 | alert( | |
791 | "Error while submitting comment.\n" + |
|
880 | "Error while submitting comment.\n" + | |
792 | "Error code {0} ({1}).".format(data.status, data.statusText) |
|
881 | "Error code {0} ({1}).".format(data.status, data.statusText) | |
793 | ); |
|
882 | ); | |
794 | commentForm.resetCommentFormState(text) |
|
883 | commentForm.resetCommentFormState(text) | |
795 | }; |
|
884 | }; | |
796 | commentForm.submitAjaxPOST( |
|
885 | commentForm.submitAjaxPOST( | |
797 | commentForm.submitUrl, postData, submitSuccessCallback, submitFailCallback); |
|
886 | commentForm.submitUrl, postData, submitSuccessCallback, submitFailCallback); | |
798 | }); |
|
887 | }); | |
799 | } |
|
888 | } | |
800 |
|
889 | |||
801 | $form.addClass('comment-inline-form-open'); |
|
890 | $form.addClass('comment-inline-form-open'); | |
802 | }; |
|
891 | }; | |
803 |
|
892 | |||
804 | this.createResolutionComment = function(commentId){ |
|
893 | this.createResolutionComment = function(commentId){ | |
805 | // hide the trigger text |
|
894 | // hide the trigger text | |
806 | $('#resolve-comment-{0}'.format(commentId)).hide(); |
|
895 | $('#resolve-comment-{0}'.format(commentId)).hide(); | |
807 |
|
896 | |||
808 | var comment = $('#comment-'+commentId); |
|
897 | var comment = $('#comment-'+commentId); | |
809 | var commentData = comment.data(); |
|
898 | var commentData = comment.data(); | |
810 | if (commentData.commentInline) { |
|
899 | if (commentData.commentInline) { | |
811 | this.createComment(comment, commentId) |
|
900 | this.createComment(comment, commentId) | |
812 | } else { |
|
901 | } else { | |
813 | Rhodecode.comments.createGeneralComment('general', "$placeholder", commentId) |
|
902 | Rhodecode.comments.createGeneralComment('general', "$placeholder", commentId) | |
814 | } |
|
903 | } | |
815 |
|
904 | |||
816 | return false; |
|
905 | return false; | |
817 | }; |
|
906 | }; | |
818 |
|
907 | |||
819 | this.submitResolution = function(commentId){ |
|
908 | this.submitResolution = function(commentId){ | |
820 | var form = $('#resolve_comment_{0}'.format(commentId)).closest('form'); |
|
909 | var form = $('#resolve_comment_{0}'.format(commentId)).closest('form'); | |
821 | var commentForm = form.get(0).CommentForm; |
|
910 | var commentForm = form.get(0).CommentForm; | |
822 |
|
911 | |||
823 | var cm = commentForm.getCmInstance(); |
|
912 | var cm = commentForm.getCmInstance(); | |
824 | var renderer = templateContext.visual.default_renderer; |
|
913 | var renderer = templateContext.visual.default_renderer; | |
825 | if (renderer == 'rst'){ |
|
914 | if (renderer == 'rst'){ | |
826 | var commentUrl = '`#{0} <{1}#comment-{0}>`_'.format(commentId, commentForm.selfUrl); |
|
915 | var commentUrl = '`#{0} <{1}#comment-{0}>`_'.format(commentId, commentForm.selfUrl); | |
827 | } else if (renderer == 'markdown') { |
|
916 | } else if (renderer == 'markdown') { | |
828 | var commentUrl = '[#{0}]({1}#comment-{0})'.format(commentId, commentForm.selfUrl); |
|
917 | var commentUrl = '[#{0}]({1}#comment-{0})'.format(commentId, commentForm.selfUrl); | |
829 | } else { |
|
918 | } else { | |
830 | var commentUrl = '{1}#comment-{0}'.format(commentId, commentForm.selfUrl); |
|
919 | var commentUrl = '{1}#comment-{0}'.format(commentId, commentForm.selfUrl); | |
831 | } |
|
920 | } | |
832 |
|
921 | |||
833 | cm.setValue(_gettext('TODO from comment {0} was fixed.').format(commentUrl)); |
|
922 | cm.setValue(_gettext('TODO from comment {0} was fixed.').format(commentUrl)); | |
834 | form.submit(); |
|
923 | form.submit(); | |
835 | return false; |
|
924 | return false; | |
836 | }; |
|
925 | }; | |
837 |
|
926 | |||
838 | }; |
|
927 | }; |
@@ -1,159 +1,164 b'' | |||||
1 | ## -*- coding: utf-8 -*- |
|
1 | ## -*- coding: utf-8 -*- | |
2 | <!DOCTYPE html> |
|
2 | <!DOCTYPE html> | |
3 |
|
3 | |||
4 | <% |
|
4 | <% | |
5 | c.template_context['repo_name'] = getattr(c, 'repo_name', '') |
|
5 | c.template_context['repo_name'] = getattr(c, 'repo_name', '') | |
6 | go_import_header = '' |
|
6 | go_import_header = '' | |
7 | if hasattr(c, 'rhodecode_db_repo'): |
|
7 | if hasattr(c, 'rhodecode_db_repo'): | |
8 | c.template_context['repo_type'] = c.rhodecode_db_repo.repo_type |
|
8 | c.template_context['repo_type'] = c.rhodecode_db_repo.repo_type | |
9 | c.template_context['repo_landing_commit'] = c.rhodecode_db_repo.landing_rev[1] |
|
9 | c.template_context['repo_landing_commit'] = c.rhodecode_db_repo.landing_rev[1] | |
10 | c.template_context['repo_id'] = c.rhodecode_db_repo.repo_id |
|
10 | c.template_context['repo_id'] = c.rhodecode_db_repo.repo_id | |
11 | c.template_context['repo_view_type'] = h.get_repo_view_type(request) |
|
11 | c.template_context['repo_view_type'] = h.get_repo_view_type(request) | |
12 |
|
12 | |||
13 | if getattr(c, 'repo_group', None): |
|
13 | if getattr(c, 'repo_group', None): | |
14 | c.template_context['repo_group_id'] = c.repo_group.group_id |
|
14 | c.template_context['repo_group_id'] = c.repo_group.group_id | |
15 | c.template_context['repo_group_name'] = c.repo_group.group_name |
|
15 | c.template_context['repo_group_name'] = c.repo_group.group_name | |
16 |
|
16 | |||
17 | if getattr(c, 'rhodecode_user', None) and c.rhodecode_user.user_id: |
|
17 | if getattr(c, 'rhodecode_user', None) and c.rhodecode_user.user_id: | |
18 | c.template_context['rhodecode_user']['username'] = c.rhodecode_user.username |
|
18 | c.template_context['rhodecode_user']['username'] = c.rhodecode_user.username | |
19 | c.template_context['rhodecode_user']['email'] = c.rhodecode_user.email |
|
19 | c.template_context['rhodecode_user']['email'] = c.rhodecode_user.email | |
20 | c.template_context['rhodecode_user']['notification_status'] = c.rhodecode_user.get_instance().user_data.get('notification_status', True) |
|
20 | c.template_context['rhodecode_user']['notification_status'] = c.rhodecode_user.get_instance().user_data.get('notification_status', True) | |
21 | c.template_context['rhodecode_user']['first_name'] = c.rhodecode_user.first_name |
|
21 | c.template_context['rhodecode_user']['first_name'] = c.rhodecode_user.first_name | |
22 | c.template_context['rhodecode_user']['last_name'] = c.rhodecode_user.last_name |
|
22 | c.template_context['rhodecode_user']['last_name'] = c.rhodecode_user.last_name | |
23 |
|
23 | |||
24 | c.template_context['visual']['default_renderer'] = h.get_visual_attr(c, 'default_renderer') |
|
24 | c.template_context['visual']['default_renderer'] = h.get_visual_attr(c, 'default_renderer') | |
25 | c.template_context['default_user'] = { |
|
25 | c.template_context['default_user'] = { | |
26 | 'username': h.DEFAULT_USER, |
|
26 | 'username': h.DEFAULT_USER, | |
27 | 'user_id': 1 |
|
27 | 'user_id': 1 | |
28 | } |
|
28 | } | |
29 | c.template_context['search_context'] = { |
|
29 | c.template_context['search_context'] = { | |
30 | 'repo_group_id': c.template_context.get('repo_group_id'), |
|
30 | 'repo_group_id': c.template_context.get('repo_group_id'), | |
31 | 'repo_group_name': c.template_context.get('repo_group_name'), |
|
31 | 'repo_group_name': c.template_context.get('repo_group_name'), | |
32 | 'repo_id': c.template_context.get('repo_id'), |
|
32 | 'repo_id': c.template_context.get('repo_id'), | |
33 | 'repo_name': c.template_context.get('repo_name'), |
|
33 | 'repo_name': c.template_context.get('repo_name'), | |
34 | 'repo_view_type': c.template_context.get('repo_view_type'), |
|
34 | 'repo_view_type': c.template_context.get('repo_view_type'), | |
35 | } |
|
35 | } | |
36 |
|
36 | |||
|
37 | c.template_context['attachment_store'] = { | |||
|
38 | 'max_file_size_mb': 10, | |||
|
39 | 'image_ext': ["png", "jpg", "gif", "jpeg"] | |||
|
40 | } | |||
|
41 | ||||
37 | %> |
|
42 | %> | |
38 | <html xmlns="http://www.w3.org/1999/xhtml"> |
|
43 | <html xmlns="http://www.w3.org/1999/xhtml"> | |
39 | <head> |
|
44 | <head> | |
40 | <title>${self.title()}</title> |
|
45 | <title>${self.title()}</title> | |
41 | <meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> |
|
46 | <meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> | |
42 |
|
47 | |||
43 | ${h.go_import_header(request, getattr(c, 'rhodecode_db_repo', None))} |
|
48 | ${h.go_import_header(request, getattr(c, 'rhodecode_db_repo', None))} | |
44 |
|
49 | |||
45 | % if 'safari' in (request.user_agent or '').lower(): |
|
50 | % if 'safari' in (request.user_agent or '').lower(): | |
46 | <meta name="referrer" content="origin"> |
|
51 | <meta name="referrer" content="origin"> | |
47 | % else: |
|
52 | % else: | |
48 | <meta name="referrer" content="origin-when-cross-origin"> |
|
53 | <meta name="referrer" content="origin-when-cross-origin"> | |
49 | % endif |
|
54 | % endif | |
50 |
|
55 | |||
51 | <%def name="robots()"> |
|
56 | <%def name="robots()"> | |
52 | <meta name="robots" content="index, nofollow"/> |
|
57 | <meta name="robots" content="index, nofollow"/> | |
53 | </%def> |
|
58 | </%def> | |
54 | ${self.robots()} |
|
59 | ${self.robots()} | |
55 | <link rel="icon" href="${h.asset('images/favicon.ico', ver=c.rhodecode_version_hash)}" sizes="16x16 32x32" type="image/png" /> |
|
60 | <link rel="icon" href="${h.asset('images/favicon.ico', ver=c.rhodecode_version_hash)}" sizes="16x16 32x32" type="image/png" /> | |
56 | <script src="${h.asset('js/vendors/webcomponentsjs/custom-elements-es5-adapter.js', ver=c.rhodecode_version_hash)}"></script> |
|
61 | <script src="${h.asset('js/vendors/webcomponentsjs/custom-elements-es5-adapter.js', ver=c.rhodecode_version_hash)}"></script> | |
57 | <script src="${h.asset('js/vendors/webcomponentsjs/webcomponents-bundle.js', ver=c.rhodecode_version_hash)}"></script> |
|
62 | <script src="${h.asset('js/vendors/webcomponentsjs/webcomponents-bundle.js', ver=c.rhodecode_version_hash)}"></script> | |
58 |
|
63 | |||
59 | ## CSS definitions |
|
64 | ## CSS definitions | |
60 | <%def name="css()"> |
|
65 | <%def name="css()"> | |
61 | <link rel="stylesheet" type="text/css" href="${h.asset('css/style.css', ver=c.rhodecode_version_hash)}" media="screen"/> |
|
66 | <link rel="stylesheet" type="text/css" href="${h.asset('css/style.css', ver=c.rhodecode_version_hash)}" media="screen"/> | |
62 | ## EXTRA FOR CSS |
|
67 | ## EXTRA FOR CSS | |
63 | ${self.css_extra()} |
|
68 | ${self.css_extra()} | |
64 | </%def> |
|
69 | </%def> | |
65 | ## CSS EXTRA - optionally inject some extra CSS stuff needed for specific websites |
|
70 | ## CSS EXTRA - optionally inject some extra CSS stuff needed for specific websites | |
66 | <%def name="css_extra()"> |
|
71 | <%def name="css_extra()"> | |
67 | </%def> |
|
72 | </%def> | |
68 |
|
73 | |||
69 | ${self.css()} |
|
74 | ${self.css()} | |
70 |
|
75 | |||
71 | ## JAVASCRIPT |
|
76 | ## JAVASCRIPT | |
72 | <%def name="js()"> |
|
77 | <%def name="js()"> | |
73 |
|
78 | |||
74 | <script src="${h.asset('js/rhodecode/i18n/%s.js' % c.language, ver=c.rhodecode_version_hash)}"></script> |
|
79 | <script src="${h.asset('js/rhodecode/i18n/%s.js' % c.language, ver=c.rhodecode_version_hash)}"></script> | |
75 | <script type="text/javascript"> |
|
80 | <script type="text/javascript"> | |
76 | // register templateContext to pass template variables to JS |
|
81 | // register templateContext to pass template variables to JS | |
77 | var templateContext = ${h.json.dumps(c.template_context)|n}; |
|
82 | var templateContext = ${h.json.dumps(c.template_context)|n}; | |
78 |
|
83 | |||
79 | var APPLICATION_URL = "${h.route_path('home').rstrip('/')}"; |
|
84 | var APPLICATION_URL = "${h.route_path('home').rstrip('/')}"; | |
80 | var APPLICATION_PLUGINS = []; |
|
85 | var APPLICATION_PLUGINS = []; | |
81 | var ASSET_URL = "${h.asset('')}"; |
|
86 | var ASSET_URL = "${h.asset('')}"; | |
82 | var DEFAULT_RENDERER = "${h.get_visual_attr(c, 'default_renderer')}"; |
|
87 | var DEFAULT_RENDERER = "${h.get_visual_attr(c, 'default_renderer')}"; | |
83 | var CSRF_TOKEN = "${getattr(c, 'csrf_token', '')}"; |
|
88 | var CSRF_TOKEN = "${getattr(c, 'csrf_token', '')}"; | |
84 |
|
89 | |||
85 | var APPENLIGHT = { |
|
90 | var APPENLIGHT = { | |
86 | enabled: ${'true' if getattr(c, 'appenlight_enabled', False) else 'false'}, |
|
91 | enabled: ${'true' if getattr(c, 'appenlight_enabled', False) else 'false'}, | |
87 | key: '${getattr(c, "appenlight_api_public_key", "")}', |
|
92 | key: '${getattr(c, "appenlight_api_public_key", "")}', | |
88 | % if getattr(c, 'appenlight_server_url', None): |
|
93 | % if getattr(c, 'appenlight_server_url', None): | |
89 | serverUrl: '${getattr(c, "appenlight_server_url", "")}', |
|
94 | serverUrl: '${getattr(c, "appenlight_server_url", "")}', | |
90 | % endif |
|
95 | % endif | |
91 | requestInfo: { |
|
96 | requestInfo: { | |
92 | % if getattr(c, 'rhodecode_user', None): |
|
97 | % if getattr(c, 'rhodecode_user', None): | |
93 | ip: '${c.rhodecode_user.ip_addr}', |
|
98 | ip: '${c.rhodecode_user.ip_addr}', | |
94 | username: '${c.rhodecode_user.username}' |
|
99 | username: '${c.rhodecode_user.username}' | |
95 | % endif |
|
100 | % endif | |
96 | }, |
|
101 | }, | |
97 | tags: { |
|
102 | tags: { | |
98 | rhodecode_version: '${c.rhodecode_version}', |
|
103 | rhodecode_version: '${c.rhodecode_version}', | |
99 | rhodecode_edition: '${c.rhodecode_edition}' |
|
104 | rhodecode_edition: '${c.rhodecode_edition}' | |
100 | } |
|
105 | } | |
101 | }; |
|
106 | }; | |
102 |
|
107 | |||
103 | </script> |
|
108 | </script> | |
104 | <%include file="/base/plugins_base.mako"/> |
|
109 | <%include file="/base/plugins_base.mako"/> | |
105 | <!--[if lt IE 9]> |
|
110 | <!--[if lt IE 9]> | |
106 | <script language="javascript" type="text/javascript" src="${h.asset('js/src/excanvas.min.js')}"></script> |
|
111 | <script language="javascript" type="text/javascript" src="${h.asset('js/src/excanvas.min.js')}"></script> | |
107 | <![endif]--> |
|
112 | <![endif]--> | |
108 | <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode/routes.js', ver=c.rhodecode_version_hash)}"></script> |
|
113 | <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode/routes.js', ver=c.rhodecode_version_hash)}"></script> | |
109 | <script> var alertMessagePayloads = ${h.flash.json_alerts(request=request)|n}; </script> |
|
114 | <script> var alertMessagePayloads = ${h.flash.json_alerts(request=request)|n}; </script> | |
110 | ## avoide escaping the %N |
|
115 | ## avoide escaping the %N | |
111 | <script language="javascript" type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script> |
|
116 | <script language="javascript" type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script> | |
112 | <script>CodeMirror.modeURL = "${h.asset('') + 'js/mode/%N/%N.js?ver='+c.rhodecode_version_hash}";</script> |
|
117 | <script>CodeMirror.modeURL = "${h.asset('') + 'js/mode/%N/%N.js?ver='+c.rhodecode_version_hash}";</script> | |
113 |
|
118 | |||
114 |
|
119 | |||
115 | ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates |
|
120 | ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates | |
116 | ${self.js_extra()} |
|
121 | ${self.js_extra()} | |
117 |
|
122 | |||
118 | <script type="text/javascript"> |
|
123 | <script type="text/javascript"> | |
119 | Rhodecode = (function() { |
|
124 | Rhodecode = (function() { | |
120 | function _Rhodecode() { |
|
125 | function _Rhodecode() { | |
121 | this.comments = new CommentsController(); |
|
126 | this.comments = new CommentsController(); | |
122 | } |
|
127 | } | |
123 | return new _Rhodecode(); |
|
128 | return new _Rhodecode(); | |
124 | })(); |
|
129 | })(); | |
125 |
|
130 | |||
126 | $(document).ready(function(){ |
|
131 | $(document).ready(function(){ | |
127 | show_more_event(); |
|
132 | show_more_event(); | |
128 | timeagoActivate(); |
|
133 | timeagoActivate(); | |
129 | clipboardActivate(); |
|
134 | clipboardActivate(); | |
130 | }) |
|
135 | }) | |
131 | </script> |
|
136 | </script> | |
132 |
|
137 | |||
133 | </%def> |
|
138 | </%def> | |
134 |
|
139 | |||
135 | ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates |
|
140 | ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates | |
136 | <%def name="js_extra()"></%def> |
|
141 | <%def name="js_extra()"></%def> | |
137 | ${self.js()} |
|
142 | ${self.js()} | |
138 |
|
143 | |||
139 | <%def name="head_extra()"></%def> |
|
144 | <%def name="head_extra()"></%def> | |
140 | ${self.head_extra()} |
|
145 | ${self.head_extra()} | |
141 | ## extra stuff |
|
146 | ## extra stuff | |
142 | %if c.pre_code: |
|
147 | %if c.pre_code: | |
143 | ${c.pre_code|n} |
|
148 | ${c.pre_code|n} | |
144 | %endif |
|
149 | %endif | |
145 | </head> |
|
150 | </head> | |
146 | <body id="body"> |
|
151 | <body id="body"> | |
147 | <noscript> |
|
152 | <noscript> | |
148 | <div class="noscript-error"> |
|
153 | <div class="noscript-error"> | |
149 | ${_('Please enable JavaScript to use RhodeCode Enterprise')} |
|
154 | ${_('Please enable JavaScript to use RhodeCode Enterprise')} | |
150 | </div> |
|
155 | </div> | |
151 | </noscript> |
|
156 | </noscript> | |
152 |
|
157 | |||
153 | ${next.body()} |
|
158 | ${next.body()} | |
154 | %if c.post_code: |
|
159 | %if c.post_code: | |
155 | ${c.post_code|n} |
|
160 | ${c.post_code|n} | |
156 | %endif |
|
161 | %endif | |
157 | <rhodecode-app></rhodecode-app> |
|
162 | <rhodecode-app></rhodecode-app> | |
158 | </body> |
|
163 | </body> | |
159 | </html> |
|
164 | </html> |
@@ -1,404 +1,420 b'' | |||||
1 | ## -*- coding: utf-8 -*- |
|
1 | ## -*- coding: utf-8 -*- | |
2 | ## usage: |
|
2 | ## usage: | |
3 | ## <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/> |
|
3 | ## <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/> | |
4 | ## ${comment.comment_block(comment)} |
|
4 | ## ${comment.comment_block(comment)} | |
5 | ## |
|
5 | ## | |
6 | <%namespace name="base" file="/base/base.mako"/> |
|
6 | <%namespace name="base" file="/base/base.mako"/> | |
7 |
|
7 | |||
8 | <%def name="comment_block(comment, inline=False)"> |
|
8 | <%def name="comment_block(comment, inline=False)"> | |
9 | <% pr_index_ver = comment.get_index_version(getattr(c, 'versions', [])) %> |
|
9 | <% pr_index_ver = comment.get_index_version(getattr(c, 'versions', [])) %> | |
10 | <% latest_ver = len(getattr(c, 'versions', [])) %> |
|
10 | <% latest_ver = len(getattr(c, 'versions', [])) %> | |
11 | % if inline: |
|
11 | % if inline: | |
12 | <% outdated_at_ver = comment.outdated_at_version(getattr(c, 'at_version_num', None)) %> |
|
12 | <% outdated_at_ver = comment.outdated_at_version(getattr(c, 'at_version_num', None)) %> | |
13 | % else: |
|
13 | % else: | |
14 | <% outdated_at_ver = comment.older_than_version(getattr(c, 'at_version_num', None)) %> |
|
14 | <% outdated_at_ver = comment.older_than_version(getattr(c, 'at_version_num', None)) %> | |
15 | % endif |
|
15 | % endif | |
16 |
|
16 | |||
17 |
|
17 | |||
18 | <div class="comment |
|
18 | <div class="comment | |
19 | ${'comment-inline' if inline else 'comment-general'} |
|
19 | ${'comment-inline' if inline else 'comment-general'} | |
20 | ${'comment-outdated' if outdated_at_ver else 'comment-current'}" |
|
20 | ${'comment-outdated' if outdated_at_ver else 'comment-current'}" | |
21 | id="comment-${comment.comment_id}" |
|
21 | id="comment-${comment.comment_id}" | |
22 | line="${comment.line_no}" |
|
22 | line="${comment.line_no}" | |
23 | data-comment-id="${comment.comment_id}" |
|
23 | data-comment-id="${comment.comment_id}" | |
24 | data-comment-type="${comment.comment_type}" |
|
24 | data-comment-type="${comment.comment_type}" | |
25 | data-comment-line-no="${comment.line_no}" |
|
25 | data-comment-line-no="${comment.line_no}" | |
26 | data-comment-inline=${h.json.dumps(inline)} |
|
26 | data-comment-inline=${h.json.dumps(inline)} | |
27 | style="${'display: none;' if outdated_at_ver else ''}"> |
|
27 | style="${'display: none;' if outdated_at_ver else ''}"> | |
28 |
|
28 | |||
29 | <div class="meta"> |
|
29 | <div class="meta"> | |
30 | <div class="comment-type-label"> |
|
30 | <div class="comment-type-label"> | |
31 | <div class="comment-label ${comment.comment_type or 'note'}" id="comment-label-${comment.comment_id}" title="line: ${comment.line_no}"> |
|
31 | <div class="comment-label ${comment.comment_type or 'note'}" id="comment-label-${comment.comment_id}" title="line: ${comment.line_no}"> | |
32 | % if comment.comment_type == 'todo': |
|
32 | % if comment.comment_type == 'todo': | |
33 | % if comment.resolved: |
|
33 | % if comment.resolved: | |
34 | <div class="resolved tooltip" title="${_('Resolved by comment #{}').format(comment.resolved.comment_id)}"> |
|
34 | <div class="resolved tooltip" title="${_('Resolved by comment #{}').format(comment.resolved.comment_id)}"> | |
35 | <a href="#comment-${comment.resolved.comment_id}">${comment.comment_type}</a> |
|
35 | <a href="#comment-${comment.resolved.comment_id}">${comment.comment_type}</a> | |
36 | </div> |
|
36 | </div> | |
37 | % else: |
|
37 | % else: | |
38 | <div class="resolved tooltip" style="display: none"> |
|
38 | <div class="resolved tooltip" style="display: none"> | |
39 | <span>${comment.comment_type}</span> |
|
39 | <span>${comment.comment_type}</span> | |
40 | </div> |
|
40 | </div> | |
41 | <div class="resolve tooltip" onclick="return Rhodecode.comments.createResolutionComment(${comment.comment_id});" title="${_('Click to resolve this comment')}"> |
|
41 | <div class="resolve tooltip" onclick="return Rhodecode.comments.createResolutionComment(${comment.comment_id});" title="${_('Click to resolve this comment')}"> | |
42 | ${comment.comment_type} |
|
42 | ${comment.comment_type} | |
43 | </div> |
|
43 | </div> | |
44 | % endif |
|
44 | % endif | |
45 | % else: |
|
45 | % else: | |
46 | % if comment.resolved_comment: |
|
46 | % if comment.resolved_comment: | |
47 | fix |
|
47 | fix | |
48 | <a href="#comment-${comment.resolved_comment.comment_id}" onclick="Rhodecode.comments.scrollToComment($('#comment-${comment.resolved_comment.comment_id}'), 0, ${h.json.dumps(comment.resolved_comment.outdated)})"> |
|
48 | <a href="#comment-${comment.resolved_comment.comment_id}" onclick="Rhodecode.comments.scrollToComment($('#comment-${comment.resolved_comment.comment_id}'), 0, ${h.json.dumps(comment.resolved_comment.outdated)})"> | |
49 | <span style="text-decoration: line-through">#${comment.resolved_comment.comment_id}</span> |
|
49 | <span style="text-decoration: line-through">#${comment.resolved_comment.comment_id}</span> | |
50 | </a> |
|
50 | </a> | |
51 | % else: |
|
51 | % else: | |
52 | ${comment.comment_type or 'note'} |
|
52 | ${comment.comment_type or 'note'} | |
53 | % endif |
|
53 | % endif | |
54 | % endif |
|
54 | % endif | |
55 | </div> |
|
55 | </div> | |
56 | </div> |
|
56 | </div> | |
57 |
|
57 | |||
58 | <div class="author ${'author-inline' if inline else 'author-general'}"> |
|
58 | <div class="author ${'author-inline' if inline else 'author-general'}"> | |
59 | ${base.gravatar_with_user(comment.author.email, 16)} |
|
59 | ${base.gravatar_with_user(comment.author.email, 16)} | |
60 | </div> |
|
60 | </div> | |
61 | <div class="date"> |
|
61 | <div class="date"> | |
62 | ${h.age_component(comment.modified_at, time_is_local=True)} |
|
62 | ${h.age_component(comment.modified_at, time_is_local=True)} | |
63 | </div> |
|
63 | </div> | |
64 | % if inline: |
|
64 | % if inline: | |
65 | <span></span> |
|
65 | <span></span> | |
66 | % else: |
|
66 | % else: | |
67 | <div class="status-change"> |
|
67 | <div class="status-change"> | |
68 | % if comment.pull_request: |
|
68 | % if comment.pull_request: | |
69 | <a href="${h.route_path('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id)}"> |
|
69 | <a href="${h.route_path('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id)}"> | |
70 | % if comment.status_change: |
|
70 | % if comment.status_change: | |
71 | ${_('pull request #%s') % comment.pull_request.pull_request_id}: |
|
71 | ${_('pull request #%s') % comment.pull_request.pull_request_id}: | |
72 | % else: |
|
72 | % else: | |
73 | ${_('pull request #%s') % comment.pull_request.pull_request_id} |
|
73 | ${_('pull request #%s') % comment.pull_request.pull_request_id} | |
74 | % endif |
|
74 | % endif | |
75 | </a> |
|
75 | </a> | |
76 | % else: |
|
76 | % else: | |
77 | % if comment.status_change: |
|
77 | % if comment.status_change: | |
78 | ${_('Status change on commit')}: |
|
78 | ${_('Status change on commit')}: | |
79 | % endif |
|
79 | % endif | |
80 | % endif |
|
80 | % endif | |
81 | </div> |
|
81 | </div> | |
82 | % endif |
|
82 | % endif | |
83 |
|
83 | |||
84 | % if comment.status_change: |
|
84 | % if comment.status_change: | |
85 | <i class="icon-circle review-status-${comment.status_change[0].status}"></i> |
|
85 | <i class="icon-circle review-status-${comment.status_change[0].status}"></i> | |
86 | <div title="${_('Commit status')}" class="changeset-status-lbl"> |
|
86 | <div title="${_('Commit status')}" class="changeset-status-lbl"> | |
87 | ${comment.status_change[0].status_lbl} |
|
87 | ${comment.status_change[0].status_lbl} | |
88 | </div> |
|
88 | </div> | |
89 | % endif |
|
89 | % endif | |
90 |
|
90 | |||
91 | <a class="permalink" href="#comment-${comment.comment_id}"> ¶</a> |
|
91 | <a class="permalink" href="#comment-${comment.comment_id}"> ¶</a> | |
92 |
|
92 | |||
93 | <div class="comment-links-block"> |
|
93 | <div class="comment-links-block"> | |
94 | % if comment.pull_request and comment.pull_request.author.user_id == comment.author.user_id: |
|
94 | % if comment.pull_request and comment.pull_request.author.user_id == comment.author.user_id: | |
95 | <span class="tag authortag tooltip" title="${_('Pull request author')}"> |
|
95 | <span class="tag authortag tooltip" title="${_('Pull request author')}"> | |
96 | ${_('author')} |
|
96 | ${_('author')} | |
97 | </span> |
|
97 | </span> | |
98 | | |
|
98 | | | |
99 | % endif |
|
99 | % endif | |
100 | % if inline: |
|
100 | % if inline: | |
101 | <div class="pr-version-inline"> |
|
101 | <div class="pr-version-inline"> | |
102 | <a href="${request.current_route_path(_query=dict(version=comment.pull_request_version_id), _anchor='comment-{}'.format(comment.comment_id))}"> |
|
102 | <a href="${request.current_route_path(_query=dict(version=comment.pull_request_version_id), _anchor='comment-{}'.format(comment.comment_id))}"> | |
103 | % if outdated_at_ver: |
|
103 | % if outdated_at_ver: | |
104 | <code class="pr-version-num" title="${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> |
|
104 | <code class="pr-version-num" title="${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> | |
105 | outdated ${'v{}'.format(pr_index_ver)} | |
|
105 | outdated ${'v{}'.format(pr_index_ver)} | | |
106 | </code> |
|
106 | </code> | |
107 | % elif pr_index_ver: |
|
107 | % elif pr_index_ver: | |
108 | <code class="pr-version-num" title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> |
|
108 | <code class="pr-version-num" title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> | |
109 | ${'v{}'.format(pr_index_ver)} | |
|
109 | ${'v{}'.format(pr_index_ver)} | | |
110 | </code> |
|
110 | </code> | |
111 | % endif |
|
111 | % endif | |
112 | </a> |
|
112 | </a> | |
113 | </div> |
|
113 | </div> | |
114 | % else: |
|
114 | % else: | |
115 | % if comment.pull_request_version_id and pr_index_ver: |
|
115 | % if comment.pull_request_version_id and pr_index_ver: | |
116 | | |
|
116 | | | |
117 | <div class="pr-version"> |
|
117 | <div class="pr-version"> | |
118 | % if comment.outdated: |
|
118 | % if comment.outdated: | |
119 | <a href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}"> |
|
119 | <a href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}"> | |
120 | ${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)} |
|
120 | ${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)} | |
121 | </a> |
|
121 | </a> | |
122 | % else: |
|
122 | % else: | |
123 | <div title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> |
|
123 | <div title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"> | |
124 | <a href="${h.route_path('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id, version=comment.pull_request_version_id)}"> |
|
124 | <a href="${h.route_path('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id, version=comment.pull_request_version_id)}"> | |
125 | <code class="pr-version-num"> |
|
125 | <code class="pr-version-num"> | |
126 | ${'v{}'.format(pr_index_ver)} |
|
126 | ${'v{}'.format(pr_index_ver)} | |
127 | </code> |
|
127 | </code> | |
128 | </a> |
|
128 | </a> | |
129 | </div> |
|
129 | </div> | |
130 | % endif |
|
130 | % endif | |
131 | </div> |
|
131 | </div> | |
132 | % endif |
|
132 | % endif | |
133 | % endif |
|
133 | % endif | |
134 |
|
134 | |||
135 | ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed |
|
135 | ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed | |
136 | ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated |
|
136 | ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated | |
137 | %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())): |
|
137 | %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())): | |
138 | ## permissions to delete |
|
138 | ## permissions to delete | |
139 | %if c.is_super_admin or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id: |
|
139 | %if c.is_super_admin or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id: | |
140 | ## TODO: dan: add edit comment here |
|
140 | ## TODO: dan: add edit comment here | |
141 | <a onclick="return Rhodecode.comments.deleteComment(this);" class="delete-comment"> ${_('Delete')}</a> |
|
141 | <a onclick="return Rhodecode.comments.deleteComment(this);" class="delete-comment"> ${_('Delete')}</a> | |
142 | %else: |
|
142 | %else: | |
143 | <button class="btn-link" disabled="disabled"> ${_('Delete')}</button> |
|
143 | <button class="btn-link" disabled="disabled"> ${_('Delete')}</button> | |
144 | %endif |
|
144 | %endif | |
145 | %else: |
|
145 | %else: | |
146 | <button class="btn-link" disabled="disabled"> ${_('Delete')}</button> |
|
146 | <button class="btn-link" disabled="disabled"> ${_('Delete')}</button> | |
147 | %endif |
|
147 | %endif | |
148 |
|
148 | |||
149 | % if outdated_at_ver: |
|
149 | % if outdated_at_ver: | |
150 | | <a onclick="return Rhodecode.comments.prevOutdatedComment(this);" class="prev-comment"> ${_('Prev')}</a> |
|
150 | | <a onclick="return Rhodecode.comments.prevOutdatedComment(this);" class="prev-comment"> ${_('Prev')}</a> | |
151 | | <a onclick="return Rhodecode.comments.nextOutdatedComment(this);" class="next-comment"> ${_('Next')}</a> |
|
151 | | <a onclick="return Rhodecode.comments.nextOutdatedComment(this);" class="next-comment"> ${_('Next')}</a> | |
152 | % else: |
|
152 | % else: | |
153 | | <a onclick="return Rhodecode.comments.prevComment(this);" class="prev-comment"> ${_('Prev')}</a> |
|
153 | | <a onclick="return Rhodecode.comments.prevComment(this);" class="prev-comment"> ${_('Prev')}</a> | |
154 | | <a onclick="return Rhodecode.comments.nextComment(this);" class="next-comment"> ${_('Next')}</a> |
|
154 | | <a onclick="return Rhodecode.comments.nextComment(this);" class="next-comment"> ${_('Next')}</a> | |
155 | % endif |
|
155 | % endif | |
156 |
|
156 | |||
157 | </div> |
|
157 | </div> | |
158 | </div> |
|
158 | </div> | |
159 | <div class="text"> |
|
159 | <div class="text"> | |
160 | ${h.render(comment.text, renderer=comment.renderer, mentions=True)} |
|
160 | ${h.render(comment.text, renderer=comment.renderer, mentions=True)} | |
161 | </div> |
|
161 | </div> | |
162 |
|
162 | |||
163 | </div> |
|
163 | </div> | |
164 | </%def> |
|
164 | </%def> | |
165 |
|
165 | |||
166 | ## generate main comments |
|
166 | ## generate main comments | |
167 | <%def name="generate_comments(comments, include_pull_request=False, is_pull_request=False)"> |
|
167 | <%def name="generate_comments(comments, include_pull_request=False, is_pull_request=False)"> | |
168 | <div class="general-comments" id="comments"> |
|
168 | <div class="general-comments" id="comments"> | |
169 | %for comment in comments: |
|
169 | %for comment in comments: | |
170 | <div id="comment-tr-${comment.comment_id}"> |
|
170 | <div id="comment-tr-${comment.comment_id}"> | |
171 | ## only render comments that are not from pull request, or from |
|
171 | ## only render comments that are not from pull request, or from | |
172 | ## pull request and a status change |
|
172 | ## pull request and a status change | |
173 | %if not comment.pull_request or (comment.pull_request and comment.status_change) or include_pull_request: |
|
173 | %if not comment.pull_request or (comment.pull_request and comment.status_change) or include_pull_request: | |
174 | ${comment_block(comment)} |
|
174 | ${comment_block(comment)} | |
175 | %endif |
|
175 | %endif | |
176 | </div> |
|
176 | </div> | |
177 | %endfor |
|
177 | %endfor | |
178 | ## to anchor ajax comments |
|
178 | ## to anchor ajax comments | |
179 | <div id="injected_page_comments"></div> |
|
179 | <div id="injected_page_comments"></div> | |
180 | </div> |
|
180 | </div> | |
181 | </%def> |
|
181 | </%def> | |
182 |
|
182 | |||
183 |
|
183 | |||
184 | <%def name="comments(post_url, cur_status, is_pull_request=False, is_compare=False, change_status=True, form_extras=None)"> |
|
184 | <%def name="comments(post_url, cur_status, is_pull_request=False, is_compare=False, change_status=True, form_extras=None)"> | |
185 |
|
185 | |||
186 | <div class="comments"> |
|
186 | <div class="comments"> | |
187 | <% |
|
187 | <% | |
188 | if is_pull_request: |
|
188 | if is_pull_request: | |
189 | placeholder = _('Leave a comment on this Pull Request.') |
|
189 | placeholder = _('Leave a comment on this Pull Request.') | |
190 | elif is_compare: |
|
190 | elif is_compare: | |
191 | placeholder = _('Leave a comment on {} commits in this range.').format(len(form_extras)) |
|
191 | placeholder = _('Leave a comment on {} commits in this range.').format(len(form_extras)) | |
192 | else: |
|
192 | else: | |
193 | placeholder = _('Leave a comment on this Commit.') |
|
193 | placeholder = _('Leave a comment on this Commit.') | |
194 | %> |
|
194 | %> | |
195 |
|
195 | |||
196 | % if c.rhodecode_user.username != h.DEFAULT_USER: |
|
196 | % if c.rhodecode_user.username != h.DEFAULT_USER: | |
197 | <div class="js-template" id="cb-comment-general-form-template"> |
|
197 | <div class="js-template" id="cb-comment-general-form-template"> | |
198 | ## template generated for injection |
|
198 | ## template generated for injection | |
199 | ${comment_form(form_type='general', review_statuses=c.commit_statuses, form_extras=form_extras)} |
|
199 | ${comment_form(form_type='general', review_statuses=c.commit_statuses, form_extras=form_extras)} | |
200 | </div> |
|
200 | </div> | |
201 |
|
201 | |||
202 | <div id="cb-comment-general-form-placeholder" class="comment-form ac"> |
|
202 | <div id="cb-comment-general-form-placeholder" class="comment-form ac"> | |
203 | ## inject form here |
|
203 | ## inject form here | |
204 | </div> |
|
204 | </div> | |
205 | <script type="text/javascript"> |
|
205 | <script type="text/javascript"> | |
206 | var lineNo = 'general'; |
|
206 | var lineNo = 'general'; | |
207 | var resolvesCommentId = null; |
|
207 | var resolvesCommentId = null; | |
208 | var generalCommentForm = Rhodecode.comments.createGeneralComment( |
|
208 | var generalCommentForm = Rhodecode.comments.createGeneralComment( | |
209 | lineNo, "${placeholder}", resolvesCommentId); |
|
209 | lineNo, "${placeholder}", resolvesCommentId); | |
210 |
|
210 | |||
211 | // set custom success callback on rangeCommit |
|
211 | // set custom success callback on rangeCommit | |
212 | % if is_compare: |
|
212 | % if is_compare: | |
213 | generalCommentForm.setHandleFormSubmit(function(o) { |
|
213 | generalCommentForm.setHandleFormSubmit(function(o) { | |
214 | var self = generalCommentForm; |
|
214 | var self = generalCommentForm; | |
215 |
|
215 | |||
216 | var text = self.cm.getValue(); |
|
216 | var text = self.cm.getValue(); | |
217 | var status = self.getCommentStatus(); |
|
217 | var status = self.getCommentStatus(); | |
218 | var commentType = self.getCommentType(); |
|
218 | var commentType = self.getCommentType(); | |
219 |
|
219 | |||
220 | if (text === "" && !status) { |
|
220 | if (text === "" && !status) { | |
221 | return; |
|
221 | return; | |
222 | } |
|
222 | } | |
223 |
|
223 | |||
224 | // we can pick which commits we want to make the comment by |
|
224 | // we can pick which commits we want to make the comment by | |
225 | // selecting them via click on preview pane, this will alter the hidden inputs |
|
225 | // selecting them via click on preview pane, this will alter the hidden inputs | |
226 | var cherryPicked = $('#changeset_compare_view_content .compare_select.hl').length > 0; |
|
226 | var cherryPicked = $('#changeset_compare_view_content .compare_select.hl').length > 0; | |
227 |
|
227 | |||
228 | var commitIds = []; |
|
228 | var commitIds = []; | |
229 | $('#changeset_compare_view_content .compare_select').each(function(el) { |
|
229 | $('#changeset_compare_view_content .compare_select').each(function(el) { | |
230 | var commitId = this.id.replace('row-', ''); |
|
230 | var commitId = this.id.replace('row-', ''); | |
231 | if ($(this).hasClass('hl') || !cherryPicked) { |
|
231 | if ($(this).hasClass('hl') || !cherryPicked) { | |
232 | $("input[data-commit-id='{0}']".format(commitId)).val(commitId); |
|
232 | $("input[data-commit-id='{0}']".format(commitId)).val(commitId); | |
233 | commitIds.push(commitId); |
|
233 | commitIds.push(commitId); | |
234 | } else { |
|
234 | } else { | |
235 | $("input[data-commit-id='{0}']".format(commitId)).val('') |
|
235 | $("input[data-commit-id='{0}']".format(commitId)).val('') | |
236 | } |
|
236 | } | |
237 | }); |
|
237 | }); | |
238 |
|
238 | |||
239 | self.setActionButtonsDisabled(true); |
|
239 | self.setActionButtonsDisabled(true); | |
240 | self.cm.setOption("readOnly", true); |
|
240 | self.cm.setOption("readOnly", true); | |
241 | var postData = { |
|
241 | var postData = { | |
242 | 'text': text, |
|
242 | 'text': text, | |
243 | 'changeset_status': status, |
|
243 | 'changeset_status': status, | |
244 | 'comment_type': commentType, |
|
244 | 'comment_type': commentType, | |
245 | 'commit_ids': commitIds, |
|
245 | 'commit_ids': commitIds, | |
246 | 'csrf_token': CSRF_TOKEN |
|
246 | 'csrf_token': CSRF_TOKEN | |
247 | }; |
|
247 | }; | |
248 |
|
248 | |||
249 | var submitSuccessCallback = function(o) { |
|
249 | var submitSuccessCallback = function(o) { | |
250 | location.reload(true); |
|
250 | location.reload(true); | |
251 | }; |
|
251 | }; | |
252 | var submitFailCallback = function(){ |
|
252 | var submitFailCallback = function(){ | |
253 | self.resetCommentFormState(text) |
|
253 | self.resetCommentFormState(text) | |
254 | }; |
|
254 | }; | |
255 | self.submitAjaxPOST( |
|
255 | self.submitAjaxPOST( | |
256 | self.submitUrl, postData, submitSuccessCallback, submitFailCallback); |
|
256 | self.submitUrl, postData, submitSuccessCallback, submitFailCallback); | |
257 | }); |
|
257 | }); | |
258 | % endif |
|
258 | % endif | |
259 |
|
259 | |||
260 |
|
||||
261 | </script> |
|
260 | </script> | |
262 | % else: |
|
261 | % else: | |
263 | ## form state when not logged in |
|
262 | ## form state when not logged in | |
264 | <div class="comment-form ac"> |
|
263 | <div class="comment-form ac"> | |
265 |
|
264 | |||
266 | <div class="comment-area"> |
|
265 | <div class="comment-area"> | |
267 | <div class="comment-area-header"> |
|
266 | <div class="comment-area-header"> | |
268 | <ul class="nav-links clearfix"> |
|
267 | <ul class="nav-links clearfix"> | |
269 | <li class="active"> |
|
268 | <li class="active"> | |
270 | <a class="disabled" href="#edit-btn" disabled="disabled" onclick="return false">${_('Write')}</a> |
|
269 | <a class="disabled" href="#edit-btn" disabled="disabled" onclick="return false">${_('Write')}</a> | |
271 | </li> |
|
270 | </li> | |
272 | <li class=""> |
|
271 | <li class=""> | |
273 | <a class="disabled" href="#preview-btn" disabled="disabled" onclick="return false">${_('Preview')}</a> |
|
272 | <a class="disabled" href="#preview-btn" disabled="disabled" onclick="return false">${_('Preview')}</a> | |
274 | </li> |
|
273 | </li> | |
275 | </ul> |
|
274 | </ul> | |
276 | </div> |
|
275 | </div> | |
277 |
|
276 | |||
278 | <div class="comment-area-write" style="display: block;"> |
|
277 | <div class="comment-area-write" style="display: block;"> | |
279 | <div id="edit-container"> |
|
278 | <div id="edit-container"> | |
280 | <div style="padding: 40px 0"> |
|
279 | <div style="padding: 40px 0"> | |
281 | ${_('You need to be logged in to leave comments.')} |
|
280 | ${_('You need to be logged in to leave comments.')} | |
282 | <a href="${h.route_path('login', _query={'came_from': h.current_route_path(request)})}">${_('Login now')}</a> |
|
281 | <a href="${h.route_path('login', _query={'came_from': h.current_route_path(request)})}">${_('Login now')}</a> | |
283 | </div> |
|
282 | </div> | |
284 | </div> |
|
283 | </div> | |
285 | <div id="preview-container" class="clearfix" style="display: none;"> |
|
284 | <div id="preview-container" class="clearfix" style="display: none;"> | |
286 | <div id="preview-box" class="preview-box"></div> |
|
285 | <div id="preview-box" class="preview-box"></div> | |
287 | </div> |
|
286 | </div> | |
288 | </div> |
|
287 | </div> | |
289 |
|
288 | |||
290 | <div class="comment-area-footer"> |
|
289 | <div class="comment-area-footer"> | |
291 | <div class="toolbar"> |
|
290 | <div class="toolbar"> | |
292 | <div class="toolbar-text"> |
|
291 | <div class="toolbar-text"> | |
293 | </div> |
|
292 | </div> | |
294 | </div> |
|
293 | </div> | |
295 | </div> |
|
294 | </div> | |
296 | </div> |
|
295 | </div> | |
297 |
|
296 | |||
298 | <div class="comment-footer"> |
|
297 | <div class="comment-footer"> | |
299 | </div> |
|
298 | </div> | |
300 |
|
299 | |||
301 | </div> |
|
300 | </div> | |
302 | % endif |
|
301 | % endif | |
303 |
|
302 | |||
304 | <script type="text/javascript"> |
|
303 | <script type="text/javascript"> | |
305 | bindToggleButtons(); |
|
304 | bindToggleButtons(); | |
306 | </script> |
|
305 | </script> | |
307 | </div> |
|
306 | </div> | |
308 | </%def> |
|
307 | </%def> | |
309 |
|
308 | |||
310 |
|
309 | |||
311 | <%def name="comment_form(form_type, form_id='', lineno_id='{1}', review_statuses=None, form_extras=None)"> |
|
310 | <%def name="comment_form(form_type, form_id='', lineno_id='{1}', review_statuses=None, form_extras=None)"> | |
|
311 | ||||
312 | ## comment injected based on assumption that user is logged in |
|
312 | ## comment injected based on assumption that user is logged in | |
313 |
|
||||
314 | <form ${'id="{}"'.format(form_id) if form_id else '' |n} action="#" method="GET"> |
|
313 | <form ${'id="{}"'.format(form_id) if form_id else '' |n} action="#" method="GET"> | |
315 |
|
314 | |||
316 | <div class="comment-area"> |
|
315 | <div class="comment-area"> | |
317 | <div class="comment-area-header"> |
|
316 | <div class="comment-area-header"> | |
318 | <ul class="nav-links clearfix"> |
|
317 | <ul class="nav-links clearfix"> | |
319 | <li class="active"> |
|
318 | <li class="active"> | |
320 | <a href="#edit-btn" tabindex="-1" id="edit-btn_${lineno_id}">${_('Write')}</a> |
|
319 | <a href="#edit-btn" tabindex="-1" id="edit-btn_${lineno_id}">${_('Write')}</a> | |
321 | </li> |
|
320 | </li> | |
322 | <li class=""> |
|
321 | <li class=""> | |
323 | <a href="#preview-btn" tabindex="-1" id="preview-btn_${lineno_id}">${_('Preview')}</a> |
|
322 | <a href="#preview-btn" tabindex="-1" id="preview-btn_${lineno_id}">${_('Preview')}</a> | |
324 | </li> |
|
323 | </li> | |
325 | <li class="pull-right"> |
|
324 | <li class="pull-right"> | |
326 | <select class="comment-type" id="comment_type_${lineno_id}" name="comment_type"> |
|
325 | <select class="comment-type" id="comment_type_${lineno_id}" name="comment_type"> | |
327 | % for val in c.visual.comment_types: |
|
326 | % for val in c.visual.comment_types: | |
328 | <option value="${val}">${val.upper()}</option> |
|
327 | <option value="${val}">${val.upper()}</option> | |
329 | % endfor |
|
328 | % endfor | |
330 | </select> |
|
329 | </select> | |
331 | </li> |
|
330 | </li> | |
332 | </ul> |
|
331 | </ul> | |
333 | </div> |
|
332 | </div> | |
334 |
|
333 | |||
335 | <div class="comment-area-write" style="display: block;"> |
|
334 | <div class="comment-area-write" style="display: block;"> | |
336 | <div id="edit-container_${lineno_id}"> |
|
335 | <div id="edit-container_${lineno_id}"> | |
337 | <textarea id="text_${lineno_id}" name="text" class="comment-block-ta ac-input"></textarea> |
|
336 | <textarea id="text_${lineno_id}" name="text" class="comment-block-ta ac-input"></textarea> | |
338 | </div> |
|
337 | </div> | |
339 | <div id="preview-container_${lineno_id}" class="clearfix" style="display: none;"> |
|
338 | <div id="preview-container_${lineno_id}" class="clearfix" style="display: none;"> | |
340 | <div id="preview-box_${lineno_id}" class="preview-box"></div> |
|
339 | <div id="preview-box_${lineno_id}" class="preview-box"></div> | |
341 | </div> |
|
340 | </div> | |
342 | </div> |
|
341 | </div> | |
343 |
|
342 | |||
344 | <div class="comment-area-footer"> |
|
343 | <div class="comment-area-footer comment-attachment-uploader"> | |
345 | <div class="toolbar"> |
|
344 | <div class="toolbar"> | |
346 | <div class="toolbar-text"> |
|
345 | <div class="toolbar-text"> | |
347 | ${(_('Comments parsed using %s syntax with %s, and %s actions support.') % ( |
|
346 | ${(_('Comments parsed using %s syntax with %s, and %s actions support.') % ( | |
348 | ('<a href="%s">%s</a>' % (h.route_url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())), |
|
347 | ('<a href="%s">%s</a>' % (h.route_url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())), | |
349 | ('<span class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user')), |
|
348 | ('<span class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user')), | |
350 | ('<span class="tooltip" title="%s">`/`</span>' % _('Start typing with / for certain actions to be triggered via text box.')) |
|
349 | ('<span class="tooltip" title="%s">`/`</span>' % _('Start typing with / for certain actions to be triggered via text box.')) | |
351 | ) |
|
350 | ) | |
352 | )|n} |
|
351 | )|n} | |
353 | </div> |
|
352 | </div> | |
|
353 | ||||
|
354 | <div class="comment-attachment-text"> | |||
|
355 | <div class="dropzone-text"> | |||
|
356 | ${_("Drag'n Drop files here or")} <span class="link pick-attachment">${_('Choose your files')}</span>.<br> | |||
|
357 | </div> | |||
|
358 | <div class="dropzone-upload" style="display:none"> | |||
|
359 | <i class="icon-spin animate-spin"></i> ${_('uploading...')} | |||
|
360 | </div> | |||
|
361 | </div> | |||
|
362 | ||||
|
363 | ## comments dropzone template, empty on purpose | |||
|
364 | <div style="display: none" class="comment-attachment-uploader-template"> | |||
|
365 | <div class="dz-file-preview" style="margin: 0"> | |||
|
366 | <div class="dz-error-message"></div> | |||
|
367 | </div> | |||
|
368 | </div> | |||
|
369 | ||||
354 | </div> |
|
370 | </div> | |
355 | </div> |
|
371 | </div> | |
356 | </div> |
|
372 | </div> | |
357 |
|
373 | |||
358 | <div class="comment-footer"> |
|
374 | <div class="comment-footer"> | |
359 |
|
375 | |||
360 | % if review_statuses: |
|
376 | % if review_statuses: | |
361 | <div class="status_box"> |
|
377 | <div class="status_box"> | |
362 | <select id="change_status_${lineno_id}" name="changeset_status"> |
|
378 | <select id="change_status_${lineno_id}" name="changeset_status"> | |
363 | <option></option> ## Placeholder |
|
379 | <option></option> ## Placeholder | |
364 | % for status, lbl in review_statuses: |
|
380 | % for status, lbl in review_statuses: | |
365 | <option value="${status}" data-status="${status}">${lbl}</option> |
|
381 | <option value="${status}" data-status="${status}">${lbl}</option> | |
366 | %if is_pull_request and change_status and status in ('approved', 'rejected'): |
|
382 | %if is_pull_request and change_status and status in ('approved', 'rejected'): | |
367 | <option value="${status}_closed" data-status="${status}">${lbl} & ${_('Closed')}</option> |
|
383 | <option value="${status}_closed" data-status="${status}">${lbl} & ${_('Closed')}</option> | |
368 | %endif |
|
384 | %endif | |
369 | % endfor |
|
385 | % endfor | |
370 | </select> |
|
386 | </select> | |
371 | </div> |
|
387 | </div> | |
372 | % endif |
|
388 | % endif | |
373 |
|
389 | |||
374 | ## inject extra inputs into the form |
|
390 | ## inject extra inputs into the form | |
375 | % if form_extras and isinstance(form_extras, (list, tuple)): |
|
391 | % if form_extras and isinstance(form_extras, (list, tuple)): | |
376 | <div id="comment_form_extras"> |
|
392 | <div id="comment_form_extras"> | |
377 | % for form_ex_el in form_extras: |
|
393 | % for form_ex_el in form_extras: | |
378 | ${form_ex_el|n} |
|
394 | ${form_ex_el|n} | |
379 | % endfor |
|
395 | % endfor | |
380 | </div> |
|
396 | </div> | |
381 | % endif |
|
397 | % endif | |
382 |
|
398 | |||
383 | <div class="action-buttons"> |
|
399 | <div class="action-buttons"> | |
384 | ## inline for has a file, and line-number together with cancel hide button. |
|
400 | ## inline for has a file, and line-number together with cancel hide button. | |
385 | % if form_type == 'inline': |
|
401 | % if form_type == 'inline': | |
386 | <input type="hidden" name="f_path" value="{0}"> |
|
402 | <input type="hidden" name="f_path" value="{0}"> | |
387 | <input type="hidden" name="line" value="${lineno_id}"> |
|
403 | <input type="hidden" name="line" value="${lineno_id}"> | |
388 | <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);"> |
|
404 | <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);"> | |
389 | ${_('Cancel')} |
|
405 | ${_('Cancel')} | |
390 | </button> |
|
406 | </button> | |
391 | % endif |
|
407 | % endif | |
392 |
|
408 | |||
393 | % if form_type != 'inline': |
|
409 | % if form_type != 'inline': | |
394 | <div class="action-buttons-extra"></div> |
|
410 | <div class="action-buttons-extra"></div> | |
395 | % endif |
|
411 | % endif | |
396 |
|
412 | |||
397 | ${h.submit('save', _('Comment'), class_='btn btn-success comment-button-input')} |
|
413 | ${h.submit('save', _('Comment'), class_='btn btn-success comment-button-input')} | |
398 |
|
414 | |||
399 | </div> |
|
415 | </div> | |
400 | </div> |
|
416 | </div> | |
401 |
|
417 | |||
402 | </form> |
|
418 | </form> | |
403 |
|
419 | |||
404 | </%def> No newline at end of file |
|
420 | </%def> |
General Comments 0
You need to be logged in to leave comments.
Login now