##// END OF EJS Templates
release: Merge default into stable for release preparation
marcink -
r4491:f919670e merge stable
parent child Browse files
Show More
@@ -0,0 +1,18 b''
1 diff -rup Beaker-1.9.1-orig/beaker/session.py Beaker-1.9.1/beaker/session.py
2 --- Beaker-1.9.1-orig/beaker/session.py 2020-04-10 10:23:04.000000000 +0200
3 +++ Beaker-1.9.1/beaker/session.py 2020-04-10 10:23:34.000000000 +0200
4 @@ -156,6 +156,14 @@ def __init__(self, request, id=None, invalidate_corrupt=False,
5 if timeout and not save_accessed_time:
6 raise BeakerException("timeout requires save_accessed_time")
7 self.timeout = timeout
8 + # We want to pass timeout param to redis backend to support expiration of keys
9 + # In future, I believe, we can use this param for memcached and mongo as well
10 + if self.timeout is not None and self.type == 'ext:redis':
11 + # The backend expiration should always be a bit longer (I decied to use 2 minutes) than the
12 + # session expiration itself to prevent the case where the backend data expires while
13 + # the session is being read (PR#153)
14 + self.namespace_args['timeout'] = self.timeout + 60 * 2
15 +
16 self.save_atime = save_accessed_time
17 self.use_cookies = use_cookies
18 self.cookie_expires = cookie_expires No newline at end of file
@@ -0,0 +1,26 b''
1 diff -rup Beaker-1.9.1-orig/beaker/ext/redisnm.py Beaker-1.9.1/beaker/ext/redisnm.py
2 --- Beaker-1.9.1-orig/beaker/ext/redisnm.py 2018-04-10 10:23:04.000000000 +0200
3 +++ Beaker-1.9.1/beaker/ext/redisnm.py 2018-04-10 10:23:34.000000000 +0200
4 @@ -30,9 +30,10 @@ class RedisNamespaceManager(NamespaceManager):
5
6 clients = SyncDict()
7
8 - def __init__(self, namespace, url, **kw):
9 + def __init__(self, namespace, url, timeout=None, **kw):
10 super(RedisNamespaceManager, self).__init__(namespace)
11 self.lock_dir = None # Redis uses redis itself for locking.
12 + self.timeout = timeout
13
14 if redis is None:
15 raise RuntimeError('redis is not available')
16 @@ -68,6 +69,8 @@ def has_key(self, key):
17
18 def set_value(self, key, value, expiretime=None):
19 value = pickle.dumps(value)
20 + if expiretime is None and self.timeout is not None:
21 + expiretime = self.timeout
22 if expiretime is not None:
23 self.client.setex(self._format_key(key), int(expiretime), value)
24 else:
25
26
This diff has been collapsed as it changes many lines, (5689 lines changed) Show them Hide them
@@ -0,0 +1,5689 b''
1 # -*- coding: utf-8 -*-
2
3 # Copyright (C) 2010-2020 RhodeCode GmbH
4 #
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
7 # (only), as published by the Free Software Foundation.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
13 #
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/>.
16 #
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
21 """
22 Database Models for RhodeCode Enterprise
23 """
24
25 import re
26 import os
27 import time
28 import string
29 import hashlib
30 import logging
31 import datetime
32 import uuid
33 import warnings
34 import ipaddress
35 import functools
36 import traceback
37 import collections
38
39 from sqlalchemy import (
40 or_, and_, not_, func, cast, TypeDecorator, event,
41 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
42 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
43 Text, Float, PickleType, BigInteger)
44 from sqlalchemy.sql.expression import true, false, case
45 from sqlalchemy.sql.functions import coalesce, count # pragma: no cover
46 from sqlalchemy.orm import (
47 relationship, joinedload, class_mapper, validates, aliased)
48 from sqlalchemy.ext.declarative import declared_attr
49 from sqlalchemy.ext.hybrid import hybrid_property
50 from sqlalchemy.exc import IntegrityError # pragma: no cover
51 from sqlalchemy.dialects.mysql import LONGTEXT
52 from zope.cachedescriptors.property import Lazy as LazyProperty
53 from pyramid import compat
54 from pyramid.threadlocal import get_current_request
55 from webhelpers2.text import remove_formatting
56
57 from rhodecode.translation import _
58 from rhodecode.lib.vcs import get_vcs_instance, VCSError
59 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
60 from rhodecode.lib.utils2 import (
61 str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe,
62 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
63 glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time, OrderedDefaultDict)
64 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
65 JsonRaw
66 from rhodecode.lib.ext_json import json
67 from rhodecode.lib.caching_query import FromCache
68 from rhodecode.lib.encrypt import AESCipher, validate_and_get_enc_data
69 from rhodecode.lib.encrypt2 import Encryptor
70 from rhodecode.lib.exceptions import (
71 ArtifactMetadataDuplicate, ArtifactMetadataBadValueType)
72 from rhodecode.model.meta import Base, Session
73
74 URL_SEP = '/'
75 log = logging.getLogger(__name__)
76
77 # =============================================================================
78 # BASE CLASSES
79 # =============================================================================
80
81 # this is propagated from .ini file rhodecode.encrypted_values.secret or
82 # beaker.session.secret if first is not set.
83 # and initialized at environment.py
84 ENCRYPTION_KEY = None
85
86 # used to sort permissions by types, '#' used here is not allowed to be in
87 # usernames, and it's very early in sorted string.printable table.
88 PERMISSION_TYPE_SORT = {
89 'admin': '####',
90 'write': '###',
91 'read': '##',
92 'none': '#',
93 }
94
95
96 def display_user_sort(obj):
97 """
98 Sort function used to sort permissions in .permissions() function of
99 Repository, RepoGroup, UserGroup. Also it put the default user in front
100 of all other resources
101 """
102
103 if obj.username == User.DEFAULT_USER:
104 return '#####'
105 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
106 extra_sort_num = '1' # default
107
108 # NOTE(dan): inactive duplicates goes last
109 if getattr(obj, 'duplicate_perm', None):
110 extra_sort_num = '9'
111 return prefix + extra_sort_num + obj.username
112
113
114 def display_user_group_sort(obj):
115 """
116 Sort function used to sort permissions in .permissions() function of
117 Repository, RepoGroup, UserGroup. Also it put the default user in front
118 of all other resources
119 """
120
121 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
122 return prefix + obj.users_group_name
123
124
125 def _hash_key(k):
126 return sha1_safe(k)
127
128
129 def in_filter_generator(qry, items, limit=500):
130 """
131 Splits IN() into multiple with OR
132 e.g.::
133 cnt = Repository.query().filter(
134 or_(
135 *in_filter_generator(Repository.repo_id, range(100000))
136 )).count()
137 """
138 if not items:
139 # empty list will cause empty query which might cause security issues
140 # this can lead to hidden unpleasant results
141 items = [-1]
142
143 parts = []
144 for chunk in xrange(0, len(items), limit):
145 parts.append(
146 qry.in_(items[chunk: chunk + limit])
147 )
148
149 return parts
150
151
152 base_table_args = {
153 'extend_existing': True,
154 'mysql_engine': 'InnoDB',
155 'mysql_charset': 'utf8',
156 'sqlite_autoincrement': True
157 }
158
159
160 class EncryptedTextValue(TypeDecorator):
161 """
162 Special column for encrypted long text data, use like::
163
164 value = Column("encrypted_value", EncryptedValue(), nullable=False)
165
166 This column is intelligent so if value is in unencrypted form it return
167 unencrypted form, but on save it always encrypts
168 """
169 impl = Text
170
171 def process_bind_param(self, value, dialect):
172 """
173 Setter for storing value
174 """
175 import rhodecode
176 if not value:
177 return value
178
179 # protect against double encrypting if values is already encrypted
180 if value.startswith('enc$aes$') \
181 or value.startswith('enc$aes_hmac$') \
182 or value.startswith('enc2$'):
183 raise ValueError('value needs to be in unencrypted format, '
184 'ie. not starting with enc$ or enc2$')
185
186 algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
187 if algo == 'aes':
188 return 'enc$aes_hmac$%s' % AESCipher(ENCRYPTION_KEY, hmac=True).encrypt(value)
189 elif algo == 'fernet':
190 return Encryptor(ENCRYPTION_KEY).encrypt(value)
191 else:
192 ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
193
194 def process_result_value(self, value, dialect):
195 """
196 Getter for retrieving value
197 """
198
199 import rhodecode
200 if not value:
201 return value
202
203 algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
204 enc_strict_mode = str2bool(rhodecode.CONFIG.get('rhodecode.encrypted_values.strict') or True)
205 if algo == 'aes':
206 decrypted_data = validate_and_get_enc_data(value, ENCRYPTION_KEY, enc_strict_mode)
207 elif algo == 'fernet':
208 return Encryptor(ENCRYPTION_KEY).decrypt(value)
209 else:
210 ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
211 return decrypted_data
212
213
214 class BaseModel(object):
215 """
216 Base Model for all classes
217 """
218
219 @classmethod
220 def _get_keys(cls):
221 """return column names for this model """
222 return class_mapper(cls).c.keys()
223
224 def get_dict(self):
225 """
226 return dict with keys and values corresponding
227 to this model data """
228
229 d = {}
230 for k in self._get_keys():
231 d[k] = getattr(self, k)
232
233 # also use __json__() if present to get additional fields
234 _json_attr = getattr(self, '__json__', None)
235 if _json_attr:
236 # update with attributes from __json__
237 if callable(_json_attr):
238 _json_attr = _json_attr()
239 for k, val in _json_attr.iteritems():
240 d[k] = val
241 return d
242
243 def get_appstruct(self):
244 """return list with keys and values tuples corresponding
245 to this model data """
246
247 lst = []
248 for k in self._get_keys():
249 lst.append((k, getattr(self, k),))
250 return lst
251
252 def populate_obj(self, populate_dict):
253 """populate model with data from given populate_dict"""
254
255 for k in self._get_keys():
256 if k in populate_dict:
257 setattr(self, k, populate_dict[k])
258
259 @classmethod
260 def query(cls):
261 return Session().query(cls)
262
263 @classmethod
264 def get(cls, id_):
265 if id_:
266 return cls.query().get(id_)
267
268 @classmethod
269 def get_or_404(cls, id_):
270 from pyramid.httpexceptions import HTTPNotFound
271
272 try:
273 id_ = int(id_)
274 except (TypeError, ValueError):
275 raise HTTPNotFound()
276
277 res = cls.query().get(id_)
278 if not res:
279 raise HTTPNotFound()
280 return res
281
282 @classmethod
283 def getAll(cls):
284 # deprecated and left for backward compatibility
285 return cls.get_all()
286
287 @classmethod
288 def get_all(cls):
289 return cls.query().all()
290
291 @classmethod
292 def delete(cls, id_):
293 obj = cls.query().get(id_)
294 Session().delete(obj)
295
296 @classmethod
297 def identity_cache(cls, session, attr_name, value):
298 exist_in_session = []
299 for (item_cls, pkey), instance in session.identity_map.items():
300 if cls == item_cls and getattr(instance, attr_name) == value:
301 exist_in_session.append(instance)
302 if exist_in_session:
303 if len(exist_in_session) == 1:
304 return exist_in_session[0]
305 log.exception(
306 'multiple objects with attr %s and '
307 'value %s found with same name: %r',
308 attr_name, value, exist_in_session)
309
310 def __repr__(self):
311 if hasattr(self, '__unicode__'):
312 # python repr needs to return str
313 try:
314 return safe_str(self.__unicode__())
315 except UnicodeDecodeError:
316 pass
317 return '<DB:%s>' % (self.__class__.__name__)
318
319
320 class RhodeCodeSetting(Base, BaseModel):
321 __tablename__ = 'rhodecode_settings'
322 __table_args__ = (
323 UniqueConstraint('app_settings_name'),
324 base_table_args
325 )
326
327 SETTINGS_TYPES = {
328 'str': safe_str,
329 'int': safe_int,
330 'unicode': safe_unicode,
331 'bool': str2bool,
332 'list': functools.partial(aslist, sep=',')
333 }
334 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
335 GLOBAL_CONF_KEY = 'app_settings'
336
337 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
338 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
339 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
340 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
341
342 def __init__(self, key='', val='', type='unicode'):
343 self.app_settings_name = key
344 self.app_settings_type = type
345 self.app_settings_value = val
346
347 @validates('_app_settings_value')
348 def validate_settings_value(self, key, val):
349 assert type(val) == unicode
350 return val
351
352 @hybrid_property
353 def app_settings_value(self):
354 v = self._app_settings_value
355 _type = self.app_settings_type
356 if _type:
357 _type = self.app_settings_type.split('.')[0]
358 # decode the encrypted value
359 if 'encrypted' in self.app_settings_type:
360 cipher = EncryptedTextValue()
361 v = safe_unicode(cipher.process_result_value(v, None))
362
363 converter = self.SETTINGS_TYPES.get(_type) or \
364 self.SETTINGS_TYPES['unicode']
365 return converter(v)
366
367 @app_settings_value.setter
368 def app_settings_value(self, val):
369 """
370 Setter that will always make sure we use unicode in app_settings_value
371
372 :param val:
373 """
374 val = safe_unicode(val)
375 # encode the encrypted value
376 if 'encrypted' in self.app_settings_type:
377 cipher = EncryptedTextValue()
378 val = safe_unicode(cipher.process_bind_param(val, None))
379 self._app_settings_value = val
380
381 @hybrid_property
382 def app_settings_type(self):
383 return self._app_settings_type
384
385 @app_settings_type.setter
386 def app_settings_type(self, val):
387 if val.split('.')[0] not in self.SETTINGS_TYPES:
388 raise Exception('type must be one of %s got %s'
389 % (self.SETTINGS_TYPES.keys(), val))
390 self._app_settings_type = val
391
392 @classmethod
393 def get_by_prefix(cls, prefix):
394 return RhodeCodeSetting.query()\
395 .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\
396 .all()
397
398 def __unicode__(self):
399 return u"<%s('%s:%s[%s]')>" % (
400 self.__class__.__name__,
401 self.app_settings_name, self.app_settings_value,
402 self.app_settings_type
403 )
404
405
406 class RhodeCodeUi(Base, BaseModel):
407 __tablename__ = 'rhodecode_ui'
408 __table_args__ = (
409 UniqueConstraint('ui_key'),
410 base_table_args
411 )
412
413 HOOK_REPO_SIZE = 'changegroup.repo_size'
414 # HG
415 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
416 HOOK_PULL = 'outgoing.pull_logger'
417 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
418 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
419 HOOK_PUSH = 'changegroup.push_logger'
420 HOOK_PUSH_KEY = 'pushkey.key_push'
421
422 HOOKS_BUILTIN = [
423 HOOK_PRE_PULL,
424 HOOK_PULL,
425 HOOK_PRE_PUSH,
426 HOOK_PRETX_PUSH,
427 HOOK_PUSH,
428 HOOK_PUSH_KEY,
429 ]
430
431 # TODO: johbo: Unify way how hooks are configured for git and hg,
432 # git part is currently hardcoded.
433
434 # SVN PATTERNS
435 SVN_BRANCH_ID = 'vcs_svn_branch'
436 SVN_TAG_ID = 'vcs_svn_tag'
437
438 ui_id = Column(
439 "ui_id", Integer(), nullable=False, unique=True, default=None,
440 primary_key=True)
441 ui_section = Column(
442 "ui_section", String(255), nullable=True, unique=None, default=None)
443 ui_key = Column(
444 "ui_key", String(255), nullable=True, unique=None, default=None)
445 ui_value = Column(
446 "ui_value", String(255), nullable=True, unique=None, default=None)
447 ui_active = Column(
448 "ui_active", Boolean(), nullable=True, unique=None, default=True)
449
450 def __repr__(self):
451 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
452 self.ui_key, self.ui_value)
453
454
455 class RepoRhodeCodeSetting(Base, BaseModel):
456 __tablename__ = 'repo_rhodecode_settings'
457 __table_args__ = (
458 UniqueConstraint(
459 'app_settings_name', 'repository_id',
460 name='uq_repo_rhodecode_setting_name_repo_id'),
461 base_table_args
462 )
463
464 repository_id = Column(
465 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
466 nullable=False)
467 app_settings_id = Column(
468 "app_settings_id", Integer(), nullable=False, unique=True,
469 default=None, primary_key=True)
470 app_settings_name = Column(
471 "app_settings_name", String(255), nullable=True, unique=None,
472 default=None)
473 _app_settings_value = Column(
474 "app_settings_value", String(4096), nullable=True, unique=None,
475 default=None)
476 _app_settings_type = Column(
477 "app_settings_type", String(255), nullable=True, unique=None,
478 default=None)
479
480 repository = relationship('Repository')
481
482 def __init__(self, repository_id, key='', val='', type='unicode'):
483 self.repository_id = repository_id
484 self.app_settings_name = key
485 self.app_settings_type = type
486 self.app_settings_value = val
487
488 @validates('_app_settings_value')
489 def validate_settings_value(self, key, val):
490 assert type(val) == unicode
491 return val
492
493 @hybrid_property
494 def app_settings_value(self):
495 v = self._app_settings_value
496 type_ = self.app_settings_type
497 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
498 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
499 return converter(v)
500
501 @app_settings_value.setter
502 def app_settings_value(self, val):
503 """
504 Setter that will always make sure we use unicode in app_settings_value
505
506 :param val:
507 """
508 self._app_settings_value = safe_unicode(val)
509
510 @hybrid_property
511 def app_settings_type(self):
512 return self._app_settings_type
513
514 @app_settings_type.setter
515 def app_settings_type(self, val):
516 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
517 if val not in SETTINGS_TYPES:
518 raise Exception('type must be one of %s got %s'
519 % (SETTINGS_TYPES.keys(), val))
520 self._app_settings_type = val
521
522 def __unicode__(self):
523 return u"<%s('%s:%s:%s[%s]')>" % (
524 self.__class__.__name__, self.repository.repo_name,
525 self.app_settings_name, self.app_settings_value,
526 self.app_settings_type
527 )
528
529
530 class RepoRhodeCodeUi(Base, BaseModel):
531 __tablename__ = 'repo_rhodecode_ui'
532 __table_args__ = (
533 UniqueConstraint(
534 'repository_id', 'ui_section', 'ui_key',
535 name='uq_repo_rhodecode_ui_repository_id_section_key'),
536 base_table_args
537 )
538
539 repository_id = Column(
540 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
541 nullable=False)
542 ui_id = Column(
543 "ui_id", Integer(), nullable=False, unique=True, default=None,
544 primary_key=True)
545 ui_section = Column(
546 "ui_section", String(255), nullable=True, unique=None, default=None)
547 ui_key = Column(
548 "ui_key", String(255), nullable=True, unique=None, default=None)
549 ui_value = Column(
550 "ui_value", String(255), nullable=True, unique=None, default=None)
551 ui_active = Column(
552 "ui_active", Boolean(), nullable=True, unique=None, default=True)
553
554 repository = relationship('Repository')
555
556 def __repr__(self):
557 return '<%s[%s:%s]%s=>%s]>' % (
558 self.__class__.__name__, self.repository.repo_name,
559 self.ui_section, self.ui_key, self.ui_value)
560
561
562 class User(Base, BaseModel):
563 __tablename__ = 'users'
564 __table_args__ = (
565 UniqueConstraint('username'), UniqueConstraint('email'),
566 Index('u_username_idx', 'username'),
567 Index('u_email_idx', 'email'),
568 base_table_args
569 )
570
571 DEFAULT_USER = 'default'
572 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
573 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
574
575 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
576 username = Column("username", String(255), nullable=True, unique=None, default=None)
577 password = Column("password", String(255), nullable=True, unique=None, default=None)
578 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
579 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
580 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
581 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
582 _email = Column("email", String(255), nullable=True, unique=None, default=None)
583 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
584 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
585 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
586
587 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
588 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
589 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
590 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
591 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
592 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
593
594 user_log = relationship('UserLog')
595 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan')
596
597 repositories = relationship('Repository')
598 repository_groups = relationship('RepoGroup')
599 user_groups = relationship('UserGroup')
600
601 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
602 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
603
604 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan')
605 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
606 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
607
608 group_member = relationship('UserGroupMember', cascade='all')
609
610 notifications = relationship('UserNotification', cascade='all')
611 # notifications assigned to this user
612 user_created_notifications = relationship('Notification', cascade='all')
613 # comments created by this user
614 user_comments = relationship('ChangesetComment', cascade='all')
615 # user profile extra info
616 user_emails = relationship('UserEmailMap', cascade='all')
617 user_ip_map = relationship('UserIpMap', cascade='all')
618 user_auth_tokens = relationship('UserApiKeys', cascade='all')
619 user_ssh_keys = relationship('UserSshKeys', cascade='all')
620
621 # gists
622 user_gists = relationship('Gist', cascade='all')
623 # user pull requests
624 user_pull_requests = relationship('PullRequest', cascade='all')
625
626 # external identities
627 external_identities = relationship(
628 'ExternalIdentity',
629 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
630 cascade='all')
631 # review rules
632 user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
633
634 # artifacts owned
635 artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id')
636
637 # no cascade, set NULL
638 scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id')
639
640 def __unicode__(self):
641 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
642 self.user_id, self.username)
643
644 @hybrid_property
645 def email(self):
646 return self._email
647
648 @email.setter
649 def email(self, val):
650 self._email = val.lower() if val else None
651
652 @hybrid_property
653 def first_name(self):
654 from rhodecode.lib import helpers as h
655 if self.name:
656 return h.escape(self.name)
657 return self.name
658
659 @hybrid_property
660 def last_name(self):
661 from rhodecode.lib import helpers as h
662 if self.lastname:
663 return h.escape(self.lastname)
664 return self.lastname
665
666 @hybrid_property
667 def api_key(self):
668 """
669 Fetch if exist an auth-token with role ALL connected to this user
670 """
671 user_auth_token = UserApiKeys.query()\
672 .filter(UserApiKeys.user_id == self.user_id)\
673 .filter(or_(UserApiKeys.expires == -1,
674 UserApiKeys.expires >= time.time()))\
675 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
676 if user_auth_token:
677 user_auth_token = user_auth_token.api_key
678
679 return user_auth_token
680
681 @api_key.setter
682 def api_key(self, val):
683 # don't allow to set API key this is deprecated for now
684 self._api_key = None
685
686 @property
687 def reviewer_pull_requests(self):
688 return PullRequestReviewers.query() \
689 .options(joinedload(PullRequestReviewers.pull_request)) \
690 .filter(PullRequestReviewers.user_id == self.user_id) \
691 .all()
692
693 @property
694 def firstname(self):
695 # alias for future
696 return self.name
697
698 @property
699 def emails(self):
700 other = UserEmailMap.query()\
701 .filter(UserEmailMap.user == self) \
702 .order_by(UserEmailMap.email_id.asc()) \
703 .all()
704 return [self.email] + [x.email for x in other]
705
706 def emails_cached(self):
707 emails = UserEmailMap.query()\
708 .filter(UserEmailMap.user == self) \
709 .order_by(UserEmailMap.email_id.asc())
710
711 emails = emails.options(
712 FromCache("sql_cache_short", "get_user_{}_emails".format(self.user_id))
713 )
714
715 return [self.email] + [x.email for x in emails]
716
717 @property
718 def auth_tokens(self):
719 auth_tokens = self.get_auth_tokens()
720 return [x.api_key for x in auth_tokens]
721
722 def get_auth_tokens(self):
723 return UserApiKeys.query()\
724 .filter(UserApiKeys.user == self)\
725 .order_by(UserApiKeys.user_api_key_id.asc())\
726 .all()
727
728 @LazyProperty
729 def feed_token(self):
730 return self.get_feed_token()
731
732 def get_feed_token(self, cache=True):
733 feed_tokens = UserApiKeys.query()\
734 .filter(UserApiKeys.user == self)\
735 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
736 if cache:
737 feed_tokens = feed_tokens.options(
738 FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id))
739
740 feed_tokens = feed_tokens.all()
741 if feed_tokens:
742 return feed_tokens[0].api_key
743 return 'NO_FEED_TOKEN_AVAILABLE'
744
745 @LazyProperty
746 def artifact_token(self):
747 return self.get_artifact_token()
748
749 def get_artifact_token(self, cache=True):
750 artifacts_tokens = UserApiKeys.query()\
751 .filter(UserApiKeys.user == self)\
752 .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
753 if cache:
754 artifacts_tokens = artifacts_tokens.options(
755 FromCache("sql_cache_short", "get_user_artifact_token_%s" % self.user_id))
756
757 artifacts_tokens = artifacts_tokens.all()
758 if artifacts_tokens:
759 return artifacts_tokens[0].api_key
760 return 'NO_ARTIFACT_TOKEN_AVAILABLE'
761
762 @classmethod
763 def get(cls, user_id, cache=False):
764 if not user_id:
765 return
766
767 user = cls.query()
768 if cache:
769 user = user.options(
770 FromCache("sql_cache_short", "get_users_%s" % user_id))
771 return user.get(user_id)
772
773 @classmethod
774 def extra_valid_auth_tokens(cls, user, role=None):
775 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
776 .filter(or_(UserApiKeys.expires == -1,
777 UserApiKeys.expires >= time.time()))
778 if role:
779 tokens = tokens.filter(or_(UserApiKeys.role == role,
780 UserApiKeys.role == UserApiKeys.ROLE_ALL))
781 return tokens.all()
782
783 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
784 from rhodecode.lib import auth
785
786 log.debug('Trying to authenticate user: %s via auth-token, '
787 'and roles: %s', self, roles)
788
789 if not auth_token:
790 return False
791
792 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
793 tokens_q = UserApiKeys.query()\
794 .filter(UserApiKeys.user_id == self.user_id)\
795 .filter(or_(UserApiKeys.expires == -1,
796 UserApiKeys.expires >= time.time()))
797
798 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
799
800 crypto_backend = auth.crypto_backend()
801 enc_token_map = {}
802 plain_token_map = {}
803 for token in tokens_q:
804 if token.api_key.startswith(crypto_backend.ENC_PREF):
805 enc_token_map[token.api_key] = token
806 else:
807 plain_token_map[token.api_key] = token
808 log.debug(
809 'Found %s plain and %s encrypted tokens to check for authentication for this user',
810 len(plain_token_map), len(enc_token_map))
811
812 # plain token match comes first
813 match = plain_token_map.get(auth_token)
814
815 # check encrypted tokens now
816 if not match:
817 for token_hash, token in enc_token_map.items():
818 # NOTE(marcink): this is expensive to calculate, but most secure
819 if crypto_backend.hash_check(auth_token, token_hash):
820 match = token
821 break
822
823 if match:
824 log.debug('Found matching token %s', match)
825 if match.repo_id:
826 log.debug('Found scope, checking for scope match of token %s', match)
827 if match.repo_id == scope_repo_id:
828 return True
829 else:
830 log.debug(
831 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, '
832 'and calling scope is:%s, skipping further checks',
833 match.repo, scope_repo_id)
834 return False
835 else:
836 return True
837
838 return False
839
840 @property
841 def ip_addresses(self):
842 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
843 return [x.ip_addr for x in ret]
844
845 @property
846 def username_and_name(self):
847 return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
848
849 @property
850 def username_or_name_or_email(self):
851 full_name = self.full_name if self.full_name is not ' ' else None
852 return self.username or full_name or self.email
853
854 @property
855 def full_name(self):
856 return '%s %s' % (self.first_name, self.last_name)
857
858 @property
859 def full_name_or_username(self):
860 return ('%s %s' % (self.first_name, self.last_name)
861 if (self.first_name and self.last_name) else self.username)
862
863 @property
864 def full_contact(self):
865 return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
866
867 @property
868 def short_contact(self):
869 return '%s %s' % (self.first_name, self.last_name)
870
871 @property
872 def is_admin(self):
873 return self.admin
874
875 @property
876 def language(self):
877 return self.user_data.get('language')
878
879 def AuthUser(self, **kwargs):
880 """
881 Returns instance of AuthUser for this user
882 """
883 from rhodecode.lib.auth import AuthUser
884 return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
885
886 @hybrid_property
887 def user_data(self):
888 if not self._user_data:
889 return {}
890
891 try:
892 return json.loads(self._user_data)
893 except TypeError:
894 return {}
895
896 @user_data.setter
897 def user_data(self, val):
898 if not isinstance(val, dict):
899 raise Exception('user_data must be dict, got %s' % type(val))
900 try:
901 self._user_data = json.dumps(val)
902 except Exception:
903 log.error(traceback.format_exc())
904
905 @classmethod
906 def get_by_username(cls, username, case_insensitive=False,
907 cache=False, identity_cache=False):
908 session = Session()
909
910 if case_insensitive:
911 q = cls.query().filter(
912 func.lower(cls.username) == func.lower(username))
913 else:
914 q = cls.query().filter(cls.username == username)
915
916 if cache:
917 if identity_cache:
918 val = cls.identity_cache(session, 'username', username)
919 if val:
920 return val
921 else:
922 cache_key = "get_user_by_name_%s" % _hash_key(username)
923 q = q.options(
924 FromCache("sql_cache_short", cache_key))
925
926 return q.scalar()
927
928 @classmethod
929 def get_by_auth_token(cls, auth_token, cache=False):
930 q = UserApiKeys.query()\
931 .filter(UserApiKeys.api_key == auth_token)\
932 .filter(or_(UserApiKeys.expires == -1,
933 UserApiKeys.expires >= time.time()))
934 if cache:
935 q = q.options(
936 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
937
938 match = q.first()
939 if match:
940 return match.user
941
942 @classmethod
943 def get_by_email(cls, email, case_insensitive=False, cache=False):
944
945 if case_insensitive:
946 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
947
948 else:
949 q = cls.query().filter(cls.email == email)
950
951 email_key = _hash_key(email)
952 if cache:
953 q = q.options(
954 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
955
956 ret = q.scalar()
957 if ret is None:
958 q = UserEmailMap.query()
959 # try fetching in alternate email map
960 if case_insensitive:
961 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
962 else:
963 q = q.filter(UserEmailMap.email == email)
964 q = q.options(joinedload(UserEmailMap.user))
965 if cache:
966 q = q.options(
967 FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
968 ret = getattr(q.scalar(), 'user', None)
969
970 return ret
971
972 @classmethod
973 def get_from_cs_author(cls, author):
974 """
975 Tries to get User objects out of commit author string
976
977 :param author:
978 """
979 from rhodecode.lib.helpers import email, author_name
980 # Valid email in the attribute passed, see if they're in the system
981 _email = email(author)
982 if _email:
983 user = cls.get_by_email(_email, case_insensitive=True)
984 if user:
985 return user
986 # Maybe we can match by username?
987 _author = author_name(author)
988 user = cls.get_by_username(_author, case_insensitive=True)
989 if user:
990 return user
991
992 def update_userdata(self, **kwargs):
993 usr = self
994 old = usr.user_data
995 old.update(**kwargs)
996 usr.user_data = old
997 Session().add(usr)
998 log.debug('updated userdata with %s', kwargs)
999
1000 def update_lastlogin(self):
1001 """Update user lastlogin"""
1002 self.last_login = datetime.datetime.now()
1003 Session().add(self)
1004 log.debug('updated user %s lastlogin', self.username)
1005
1006 def update_password(self, new_password):
1007 from rhodecode.lib.auth import get_crypt_password
1008
1009 self.password = get_crypt_password(new_password)
1010 Session().add(self)
1011
1012 @classmethod
1013 def get_first_super_admin(cls):
1014 user = User.query()\
1015 .filter(User.admin == true()) \
1016 .order_by(User.user_id.asc()) \
1017 .first()
1018
1019 if user is None:
1020 raise Exception('FATAL: Missing administrative account!')
1021 return user
1022
1023 @classmethod
1024 def get_all_super_admins(cls, only_active=False):
1025 """
1026 Returns all admin accounts sorted by username
1027 """
1028 qry = User.query().filter(User.admin == true()).order_by(User.username.asc())
1029 if only_active:
1030 qry = qry.filter(User.active == true())
1031 return qry.all()
1032
1033 @classmethod
1034 def get_all_user_ids(cls, only_active=True):
1035 """
1036 Returns all users IDs
1037 """
1038 qry = Session().query(User.user_id)
1039
1040 if only_active:
1041 qry = qry.filter(User.active == true())
1042 return [x.user_id for x in qry]
1043
1044 @classmethod
1045 def get_default_user(cls, cache=False, refresh=False):
1046 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
1047 if user is None:
1048 raise Exception('FATAL: Missing default account!')
1049 if refresh:
1050 # The default user might be based on outdated state which
1051 # has been loaded from the cache.
1052 # A call to refresh() ensures that the
1053 # latest state from the database is used.
1054 Session().refresh(user)
1055 return user
1056
1057 @classmethod
1058 def get_default_user_id(cls):
1059 import rhodecode
1060 return rhodecode.CONFIG['default_user_id']
1061
1062 def _get_default_perms(self, user, suffix=''):
1063 from rhodecode.model.permission import PermissionModel
1064 return PermissionModel().get_default_perms(user.user_perms, suffix)
1065
1066 def get_default_perms(self, suffix=''):
1067 return self._get_default_perms(self, suffix)
1068
1069 def get_api_data(self, include_secrets=False, details='full'):
1070 """
1071 Common function for generating user related data for API
1072
1073 :param include_secrets: By default secrets in the API data will be replaced
1074 by a placeholder value to prevent exposing this data by accident. In case
1075 this data shall be exposed, set this flag to ``True``.
1076
1077 :param details: details can be 'basic|full' basic gives only a subset of
1078 the available user information that includes user_id, name and emails.
1079 """
1080 user = self
1081 user_data = self.user_data
1082 data = {
1083 'user_id': user.user_id,
1084 'username': user.username,
1085 'firstname': user.name,
1086 'lastname': user.lastname,
1087 'description': user.description,
1088 'email': user.email,
1089 'emails': user.emails,
1090 }
1091 if details == 'basic':
1092 return data
1093
1094 auth_token_length = 40
1095 auth_token_replacement = '*' * auth_token_length
1096
1097 extras = {
1098 'auth_tokens': [auth_token_replacement],
1099 'active': user.active,
1100 'admin': user.admin,
1101 'extern_type': user.extern_type,
1102 'extern_name': user.extern_name,
1103 'last_login': user.last_login,
1104 'last_activity': user.last_activity,
1105 'ip_addresses': user.ip_addresses,
1106 'language': user_data.get('language')
1107 }
1108 data.update(extras)
1109
1110 if include_secrets:
1111 data['auth_tokens'] = user.auth_tokens
1112 return data
1113
1114 def __json__(self):
1115 data = {
1116 'full_name': self.full_name,
1117 'full_name_or_username': self.full_name_or_username,
1118 'short_contact': self.short_contact,
1119 'full_contact': self.full_contact,
1120 }
1121 data.update(self.get_api_data())
1122 return data
1123
1124
1125 class UserApiKeys(Base, BaseModel):
1126 __tablename__ = 'user_api_keys'
1127 __table_args__ = (
1128 Index('uak_api_key_idx', 'api_key'),
1129 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
1130 base_table_args
1131 )
1132 __mapper_args__ = {}
1133
1134 # ApiKey role
1135 ROLE_ALL = 'token_role_all'
1136 ROLE_VCS = 'token_role_vcs'
1137 ROLE_API = 'token_role_api'
1138 ROLE_HTTP = 'token_role_http'
1139 ROLE_FEED = 'token_role_feed'
1140 ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download'
1141 # The last one is ignored in the list as we only
1142 # use it for one action, and cannot be created by users
1143 ROLE_PASSWORD_RESET = 'token_password_reset'
1144
1145 ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD]
1146
1147 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1148 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1149 api_key = Column("api_key", String(255), nullable=False, unique=True)
1150 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1151 expires = Column('expires', Float(53), nullable=False)
1152 role = Column('role', String(255), nullable=True)
1153 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1154
1155 # scope columns
1156 repo_id = Column(
1157 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
1158 nullable=True, unique=None, default=None)
1159 repo = relationship('Repository', lazy='joined')
1160
1161 repo_group_id = Column(
1162 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
1163 nullable=True, unique=None, default=None)
1164 repo_group = relationship('RepoGroup', lazy='joined')
1165
1166 user = relationship('User', lazy='joined')
1167
1168 def __unicode__(self):
1169 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
1170
1171 def __json__(self):
1172 data = {
1173 'auth_token': self.api_key,
1174 'role': self.role,
1175 'scope': self.scope_humanized,
1176 'expired': self.expired
1177 }
1178 return data
1179
1180 def get_api_data(self, include_secrets=False):
1181 data = self.__json__()
1182 if include_secrets:
1183 return data
1184 else:
1185 data['auth_token'] = self.token_obfuscated
1186 return data
1187
1188 @hybrid_property
1189 def description_safe(self):
1190 from rhodecode.lib import helpers as h
1191 return h.escape(self.description)
1192
1193 @property
1194 def expired(self):
1195 if self.expires == -1:
1196 return False
1197 return time.time() > self.expires
1198
1199 @classmethod
1200 def _get_role_name(cls, role):
1201 return {
1202 cls.ROLE_ALL: _('all'),
1203 cls.ROLE_HTTP: _('http/web interface'),
1204 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1205 cls.ROLE_API: _('api calls'),
1206 cls.ROLE_FEED: _('feed access'),
1207 cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'),
1208 }.get(role, role)
1209
1210 @classmethod
1211 def _get_role_description(cls, role):
1212 return {
1213 cls.ROLE_ALL: _('Token for all actions.'),
1214 cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without '
1215 'login using `api_access_controllers_whitelist` functionality.'),
1216 cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. '
1217 'Requires auth_token authentication plugin to be active. <br/>'
1218 'Such Token should be used then instead of a password to '
1219 'interact with a repository, and additionally can be '
1220 'limited to single repository using repo scope.'),
1221 cls.ROLE_API: _('Token limited to api calls.'),
1222 cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'),
1223 cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'),
1224 }.get(role, role)
1225
1226 @property
1227 def role_humanized(self):
1228 return self._get_role_name(self.role)
1229
1230 def _get_scope(self):
1231 if self.repo:
1232 return 'Repository: {}'.format(self.repo.repo_name)
1233 if self.repo_group:
1234 return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name)
1235 return 'Global'
1236
1237 @property
1238 def scope_humanized(self):
1239 return self._get_scope()
1240
1241 @property
1242 def token_obfuscated(self):
1243 if self.api_key:
1244 return self.api_key[:4] + "****"
1245
1246
1247 class UserEmailMap(Base, BaseModel):
1248 __tablename__ = 'user_email_map'
1249 __table_args__ = (
1250 Index('uem_email_idx', 'email'),
1251 UniqueConstraint('email'),
1252 base_table_args
1253 )
1254 __mapper_args__ = {}
1255
1256 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1257 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1258 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1259 user = relationship('User', lazy='joined')
1260
1261 @validates('_email')
1262 def validate_email(self, key, email):
1263 # check if this email is not main one
1264 main_email = Session().query(User).filter(User.email == email).scalar()
1265 if main_email is not None:
1266 raise AttributeError('email %s is present is user table' % email)
1267 return email
1268
1269 @hybrid_property
1270 def email(self):
1271 return self._email
1272
1273 @email.setter
1274 def email(self, val):
1275 self._email = val.lower() if val else None
1276
1277
1278 class UserIpMap(Base, BaseModel):
1279 __tablename__ = 'user_ip_map'
1280 __table_args__ = (
1281 UniqueConstraint('user_id', 'ip_addr'),
1282 base_table_args
1283 )
1284 __mapper_args__ = {}
1285
1286 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1287 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1288 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1289 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1290 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1291 user = relationship('User', lazy='joined')
1292
1293 @hybrid_property
1294 def description_safe(self):
1295 from rhodecode.lib import helpers as h
1296 return h.escape(self.description)
1297
1298 @classmethod
1299 def _get_ip_range(cls, ip_addr):
1300 net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
1301 return [str(net.network_address), str(net.broadcast_address)]
1302
1303 def __json__(self):
1304 return {
1305 'ip_addr': self.ip_addr,
1306 'ip_range': self._get_ip_range(self.ip_addr),
1307 }
1308
1309 def __unicode__(self):
1310 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1311 self.user_id, self.ip_addr)
1312
1313
1314 class UserSshKeys(Base, BaseModel):
1315 __tablename__ = 'user_ssh_keys'
1316 __table_args__ = (
1317 Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
1318
1319 UniqueConstraint('ssh_key_fingerprint'),
1320
1321 base_table_args
1322 )
1323 __mapper_args__ = {}
1324
1325 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
1326 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
1327 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
1328
1329 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1330
1331 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1332 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
1333 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1334
1335 user = relationship('User', lazy='joined')
1336
1337 def __json__(self):
1338 data = {
1339 'ssh_fingerprint': self.ssh_key_fingerprint,
1340 'description': self.description,
1341 'created_on': self.created_on
1342 }
1343 return data
1344
1345 def get_api_data(self):
1346 data = self.__json__()
1347 return data
1348
1349
1350 class UserLog(Base, BaseModel):
1351 __tablename__ = 'user_logs'
1352 __table_args__ = (
1353 base_table_args,
1354 )
1355
1356 VERSION_1 = 'v1'
1357 VERSION_2 = 'v2'
1358 VERSIONS = [VERSION_1, VERSION_2]
1359
1360 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1361 user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
1362 username = Column("username", String(255), nullable=True, unique=None, default=None)
1363 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
1364 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1365 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1366 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1367 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1368
1369 version = Column("version", String(255), nullable=True, default=VERSION_1)
1370 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1371 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1372
1373 def __unicode__(self):
1374 return u"<%s('id:%s:%s')>" % (
1375 self.__class__.__name__, self.repository_name, self.action)
1376
1377 def __json__(self):
1378 return {
1379 'user_id': self.user_id,
1380 'username': self.username,
1381 'repository_id': self.repository_id,
1382 'repository_name': self.repository_name,
1383 'user_ip': self.user_ip,
1384 'action_date': self.action_date,
1385 'action': self.action,
1386 }
1387
1388 @hybrid_property
1389 def entry_id(self):
1390 return self.user_log_id
1391
1392 @property
1393 def action_as_day(self):
1394 return datetime.date(*self.action_date.timetuple()[:3])
1395
1396 user = relationship('User')
1397 repository = relationship('Repository', cascade='')
1398
1399
1400 class UserGroup(Base, BaseModel):
1401 __tablename__ = 'users_groups'
1402 __table_args__ = (
1403 base_table_args,
1404 )
1405
1406 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1407 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1408 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1409 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1410 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1411 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1412 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1413 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1414
1415 members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined")
1416 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1417 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1418 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1419 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1420 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1421
1422 user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
1423 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
1424
1425 @classmethod
1426 def _load_group_data(cls, column):
1427 if not column:
1428 return {}
1429
1430 try:
1431 return json.loads(column) or {}
1432 except TypeError:
1433 return {}
1434
1435 @hybrid_property
1436 def description_safe(self):
1437 from rhodecode.lib import helpers as h
1438 return h.escape(self.user_group_description)
1439
1440 @hybrid_property
1441 def group_data(self):
1442 return self._load_group_data(self._group_data)
1443
1444 @group_data.expression
1445 def group_data(self, **kwargs):
1446 return self._group_data
1447
1448 @group_data.setter
1449 def group_data(self, val):
1450 try:
1451 self._group_data = json.dumps(val)
1452 except Exception:
1453 log.error(traceback.format_exc())
1454
1455 @classmethod
1456 def _load_sync(cls, group_data):
1457 if group_data:
1458 return group_data.get('extern_type')
1459
1460 @property
1461 def sync(self):
1462 return self._load_sync(self.group_data)
1463
1464 def __unicode__(self):
1465 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1466 self.users_group_id,
1467 self.users_group_name)
1468
1469 @classmethod
1470 def get_by_group_name(cls, group_name, cache=False,
1471 case_insensitive=False):
1472 if case_insensitive:
1473 q = cls.query().filter(func.lower(cls.users_group_name) ==
1474 func.lower(group_name))
1475
1476 else:
1477 q = cls.query().filter(cls.users_group_name == group_name)
1478 if cache:
1479 q = q.options(
1480 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
1481 return q.scalar()
1482
1483 @classmethod
1484 def get(cls, user_group_id, cache=False):
1485 if not user_group_id:
1486 return
1487
1488 user_group = cls.query()
1489 if cache:
1490 user_group = user_group.options(
1491 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
1492 return user_group.get(user_group_id)
1493
1494 def permissions(self, with_admins=True, with_owner=True,
1495 expand_from_user_groups=False):
1496 """
1497 Permissions for user groups
1498 """
1499 _admin_perm = 'usergroup.admin'
1500
1501 owner_row = []
1502 if with_owner:
1503 usr = AttributeDict(self.user.get_dict())
1504 usr.owner_row = True
1505 usr.permission = _admin_perm
1506 owner_row.append(usr)
1507
1508 super_admin_ids = []
1509 super_admin_rows = []
1510 if with_admins:
1511 for usr in User.get_all_super_admins():
1512 super_admin_ids.append(usr.user_id)
1513 # if this admin is also owner, don't double the record
1514 if usr.user_id == owner_row[0].user_id:
1515 owner_row[0].admin_row = True
1516 else:
1517 usr = AttributeDict(usr.get_dict())
1518 usr.admin_row = True
1519 usr.permission = _admin_perm
1520 super_admin_rows.append(usr)
1521
1522 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1523 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1524 joinedload(UserUserGroupToPerm.user),
1525 joinedload(UserUserGroupToPerm.permission),)
1526
1527 # get owners and admins and permissions. We do a trick of re-writing
1528 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1529 # has a global reference and changing one object propagates to all
1530 # others. This means if admin is also an owner admin_row that change
1531 # would propagate to both objects
1532 perm_rows = []
1533 for _usr in q.all():
1534 usr = AttributeDict(_usr.user.get_dict())
1535 # if this user is also owner/admin, mark as duplicate record
1536 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
1537 usr.duplicate_perm = True
1538 usr.permission = _usr.permission.permission_name
1539 perm_rows.append(usr)
1540
1541 # filter the perm rows by 'default' first and then sort them by
1542 # admin,write,read,none permissions sorted again alphabetically in
1543 # each group
1544 perm_rows = sorted(perm_rows, key=display_user_sort)
1545
1546 user_groups_rows = []
1547 if expand_from_user_groups:
1548 for ug in self.permission_user_groups(with_members=True):
1549 for user_data in ug.members:
1550 user_groups_rows.append(user_data)
1551
1552 return super_admin_rows + owner_row + perm_rows + user_groups_rows
1553
1554 def permission_user_groups(self, with_members=False):
1555 q = UserGroupUserGroupToPerm.query()\
1556 .filter(UserGroupUserGroupToPerm.target_user_group == self)
1557 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1558 joinedload(UserGroupUserGroupToPerm.target_user_group),
1559 joinedload(UserGroupUserGroupToPerm.permission),)
1560
1561 perm_rows = []
1562 for _user_group in q.all():
1563 entry = AttributeDict(_user_group.user_group.get_dict())
1564 entry.permission = _user_group.permission.permission_name
1565 if with_members:
1566 entry.members = [x.user.get_dict()
1567 for x in _user_group.user_group.members]
1568 perm_rows.append(entry)
1569
1570 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1571 return perm_rows
1572
1573 def _get_default_perms(self, user_group, suffix=''):
1574 from rhodecode.model.permission import PermissionModel
1575 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1576
1577 def get_default_perms(self, suffix=''):
1578 return self._get_default_perms(self, suffix)
1579
1580 def get_api_data(self, with_group_members=True, include_secrets=False):
1581 """
1582 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1583 basically forwarded.
1584
1585 """
1586 user_group = self
1587 data = {
1588 'users_group_id': user_group.users_group_id,
1589 'group_name': user_group.users_group_name,
1590 'group_description': user_group.user_group_description,
1591 'active': user_group.users_group_active,
1592 'owner': user_group.user.username,
1593 'sync': user_group.sync,
1594 'owner_email': user_group.user.email,
1595 }
1596
1597 if with_group_members:
1598 users = []
1599 for user in user_group.members:
1600 user = user.user
1601 users.append(user.get_api_data(include_secrets=include_secrets))
1602 data['users'] = users
1603
1604 return data
1605
1606
1607 class UserGroupMember(Base, BaseModel):
1608 __tablename__ = 'users_groups_members'
1609 __table_args__ = (
1610 base_table_args,
1611 )
1612
1613 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1614 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1615 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1616
1617 user = relationship('User', lazy='joined')
1618 users_group = relationship('UserGroup')
1619
1620 def __init__(self, gr_id='', u_id=''):
1621 self.users_group_id = gr_id
1622 self.user_id = u_id
1623
1624
1625 class RepositoryField(Base, BaseModel):
1626 __tablename__ = 'repositories_fields'
1627 __table_args__ = (
1628 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1629 base_table_args,
1630 )
1631
1632 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1633
1634 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1635 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1636 field_key = Column("field_key", String(250))
1637 field_label = Column("field_label", String(1024), nullable=False)
1638 field_value = Column("field_value", String(10000), nullable=False)
1639 field_desc = Column("field_desc", String(1024), nullable=False)
1640 field_type = Column("field_type", String(255), nullable=False, unique=None)
1641 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1642
1643 repository = relationship('Repository')
1644
1645 @property
1646 def field_key_prefixed(self):
1647 return 'ex_%s' % self.field_key
1648
1649 @classmethod
1650 def un_prefix_key(cls, key):
1651 if key.startswith(cls.PREFIX):
1652 return key[len(cls.PREFIX):]
1653 return key
1654
1655 @classmethod
1656 def get_by_key_name(cls, key, repo):
1657 row = cls.query()\
1658 .filter(cls.repository == repo)\
1659 .filter(cls.field_key == key).scalar()
1660 return row
1661
1662
1663 class Repository(Base, BaseModel):
1664 __tablename__ = 'repositories'
1665 __table_args__ = (
1666 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1667 base_table_args,
1668 )
1669 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1670 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1671 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
1672
1673 STATE_CREATED = 'repo_state_created'
1674 STATE_PENDING = 'repo_state_pending'
1675 STATE_ERROR = 'repo_state_error'
1676
1677 LOCK_AUTOMATIC = 'lock_auto'
1678 LOCK_API = 'lock_api'
1679 LOCK_WEB = 'lock_web'
1680 LOCK_PULL = 'lock_pull'
1681
1682 NAME_SEP = URL_SEP
1683
1684 repo_id = Column(
1685 "repo_id", Integer(), nullable=False, unique=True, default=None,
1686 primary_key=True)
1687 _repo_name = Column(
1688 "repo_name", Text(), nullable=False, default=None)
1689 repo_name_hash = Column(
1690 "repo_name_hash", String(255), nullable=False, unique=True)
1691 repo_state = Column("repo_state", String(255), nullable=True)
1692
1693 clone_uri = Column(
1694 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1695 default=None)
1696 push_uri = Column(
1697 "push_uri", EncryptedTextValue(), nullable=True, unique=False,
1698 default=None)
1699 repo_type = Column(
1700 "repo_type", String(255), nullable=False, unique=False, default=None)
1701 user_id = Column(
1702 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1703 unique=False, default=None)
1704 private = Column(
1705 "private", Boolean(), nullable=True, unique=None, default=None)
1706 archived = Column(
1707 "archived", Boolean(), nullable=True, unique=None, default=None)
1708 enable_statistics = Column(
1709 "statistics", Boolean(), nullable=True, unique=None, default=True)
1710 enable_downloads = Column(
1711 "downloads", Boolean(), nullable=True, unique=None, default=True)
1712 description = Column(
1713 "description", String(10000), nullable=True, unique=None, default=None)
1714 created_on = Column(
1715 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1716 default=datetime.datetime.now)
1717 updated_on = Column(
1718 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1719 default=datetime.datetime.now)
1720 _landing_revision = Column(
1721 "landing_revision", String(255), nullable=False, unique=False,
1722 default=None)
1723 enable_locking = Column(
1724 "enable_locking", Boolean(), nullable=False, unique=None,
1725 default=False)
1726 _locked = Column(
1727 "locked", String(255), nullable=True, unique=False, default=None)
1728 _changeset_cache = Column(
1729 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1730
1731 fork_id = Column(
1732 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1733 nullable=True, unique=False, default=None)
1734 group_id = Column(
1735 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1736 unique=False, default=None)
1737
1738 user = relationship('User', lazy='joined')
1739 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1740 group = relationship('RepoGroup', lazy='joined')
1741 repo_to_perm = relationship(
1742 'UserRepoToPerm', cascade='all',
1743 order_by='UserRepoToPerm.repo_to_perm_id')
1744 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1745 stats = relationship('Statistics', cascade='all', uselist=False)
1746
1747 followers = relationship(
1748 'UserFollowing',
1749 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1750 cascade='all')
1751 extra_fields = relationship(
1752 'RepositoryField', cascade="all, delete-orphan")
1753 logs = relationship('UserLog')
1754 comments = relationship(
1755 'ChangesetComment', cascade="all, delete-orphan")
1756 pull_requests_source = relationship(
1757 'PullRequest',
1758 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1759 cascade="all, delete-orphan")
1760 pull_requests_target = relationship(
1761 'PullRequest',
1762 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1763 cascade="all, delete-orphan")
1764 ui = relationship('RepoRhodeCodeUi', cascade="all")
1765 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1766 integrations = relationship('Integration', cascade="all, delete-orphan")
1767
1768 scoped_tokens = relationship('UserApiKeys', cascade="all")
1769
1770 # no cascade, set NULL
1771 artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id')
1772
1773 def __unicode__(self):
1774 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1775 safe_unicode(self.repo_name))
1776
1777 @hybrid_property
1778 def description_safe(self):
1779 from rhodecode.lib import helpers as h
1780 return h.escape(self.description)
1781
1782 @hybrid_property
1783 def landing_rev(self):
1784 # always should return [rev_type, rev], e.g ['branch', 'master']
1785 if self._landing_revision:
1786 _rev_info = self._landing_revision.split(':')
1787 if len(_rev_info) < 2:
1788 _rev_info.insert(0, 'rev')
1789 return [_rev_info[0], _rev_info[1]]
1790 return [None, None]
1791
1792 @property
1793 def landing_ref_type(self):
1794 return self.landing_rev[0]
1795
1796 @property
1797 def landing_ref_name(self):
1798 return self.landing_rev[1]
1799
1800 @landing_rev.setter
1801 def landing_rev(self, val):
1802 if ':' not in val:
1803 raise ValueError('value must be delimited with `:` and consist '
1804 'of <rev_type>:<rev>, got %s instead' % val)
1805 self._landing_revision = val
1806
1807 @hybrid_property
1808 def locked(self):
1809 if self._locked:
1810 user_id, timelocked, reason = self._locked.split(':')
1811 lock_values = int(user_id), timelocked, reason
1812 else:
1813 lock_values = [None, None, None]
1814 return lock_values
1815
1816 @locked.setter
1817 def locked(self, val):
1818 if val and isinstance(val, (list, tuple)):
1819 self._locked = ':'.join(map(str, val))
1820 else:
1821 self._locked = None
1822
1823 @classmethod
1824 def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
1825 from rhodecode.lib.vcs.backends.base import EmptyCommit
1826 dummy = EmptyCommit().__json__()
1827 if not changeset_cache_raw:
1828 dummy['source_repo_id'] = repo_id
1829 return json.loads(json.dumps(dummy))
1830
1831 try:
1832 return json.loads(changeset_cache_raw)
1833 except TypeError:
1834 return dummy
1835 except Exception:
1836 log.error(traceback.format_exc())
1837 return dummy
1838
1839 @hybrid_property
1840 def changeset_cache(self):
1841 return self._load_changeset_cache(self.repo_id, self._changeset_cache)
1842
1843 @changeset_cache.setter
1844 def changeset_cache(self, val):
1845 try:
1846 self._changeset_cache = json.dumps(val)
1847 except Exception:
1848 log.error(traceback.format_exc())
1849
1850 @hybrid_property
1851 def repo_name(self):
1852 return self._repo_name
1853
1854 @repo_name.setter
1855 def repo_name(self, value):
1856 self._repo_name = value
1857 self.repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1858
1859 @classmethod
1860 def normalize_repo_name(cls, repo_name):
1861 """
1862 Normalizes os specific repo_name to the format internally stored inside
1863 database using URL_SEP
1864
1865 :param cls:
1866 :param repo_name:
1867 """
1868 return cls.NAME_SEP.join(repo_name.split(os.sep))
1869
1870 @classmethod
1871 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1872 session = Session()
1873 q = session.query(cls).filter(cls.repo_name == repo_name)
1874
1875 if cache:
1876 if identity_cache:
1877 val = cls.identity_cache(session, 'repo_name', repo_name)
1878 if val:
1879 return val
1880 else:
1881 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
1882 q = q.options(
1883 FromCache("sql_cache_short", cache_key))
1884
1885 return q.scalar()
1886
1887 @classmethod
1888 def get_by_id_or_repo_name(cls, repoid):
1889 if isinstance(repoid, (int, long)):
1890 try:
1891 repo = cls.get(repoid)
1892 except ValueError:
1893 repo = None
1894 else:
1895 repo = cls.get_by_repo_name(repoid)
1896 return repo
1897
1898 @classmethod
1899 def get_by_full_path(cls, repo_full_path):
1900 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1901 repo_name = cls.normalize_repo_name(repo_name)
1902 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1903
1904 @classmethod
1905 def get_repo_forks(cls, repo_id):
1906 return cls.query().filter(Repository.fork_id == repo_id)
1907
1908 @classmethod
1909 def base_path(cls):
1910 """
1911 Returns base path when all repos are stored
1912
1913 :param cls:
1914 """
1915 q = Session().query(RhodeCodeUi)\
1916 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1917 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1918 return q.one().ui_value
1919
1920 @classmethod
1921 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1922 case_insensitive=True, archived=False):
1923 q = Repository.query()
1924
1925 if not archived:
1926 q = q.filter(Repository.archived.isnot(true()))
1927
1928 if not isinstance(user_id, Optional):
1929 q = q.filter(Repository.user_id == user_id)
1930
1931 if not isinstance(group_id, Optional):
1932 q = q.filter(Repository.group_id == group_id)
1933
1934 if case_insensitive:
1935 q = q.order_by(func.lower(Repository.repo_name))
1936 else:
1937 q = q.order_by(Repository.repo_name)
1938
1939 return q.all()
1940
1941 @property
1942 def repo_uid(self):
1943 return '_{}'.format(self.repo_id)
1944
1945 @property
1946 def forks(self):
1947 """
1948 Return forks of this repo
1949 """
1950 return Repository.get_repo_forks(self.repo_id)
1951
1952 @property
1953 def parent(self):
1954 """
1955 Returns fork parent
1956 """
1957 return self.fork
1958
1959 @property
1960 def just_name(self):
1961 return self.repo_name.split(self.NAME_SEP)[-1]
1962
1963 @property
1964 def groups_with_parents(self):
1965 groups = []
1966 if self.group is None:
1967 return groups
1968
1969 cur_gr = self.group
1970 groups.insert(0, cur_gr)
1971 while 1:
1972 gr = getattr(cur_gr, 'parent_group', None)
1973 cur_gr = cur_gr.parent_group
1974 if gr is None:
1975 break
1976 groups.insert(0, gr)
1977
1978 return groups
1979
1980 @property
1981 def groups_and_repo(self):
1982 return self.groups_with_parents, self
1983
1984 @LazyProperty
1985 def repo_path(self):
1986 """
1987 Returns base full path for that repository means where it actually
1988 exists on a filesystem
1989 """
1990 q = Session().query(RhodeCodeUi).filter(
1991 RhodeCodeUi.ui_key == self.NAME_SEP)
1992 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1993 return q.one().ui_value
1994
1995 @property
1996 def repo_full_path(self):
1997 p = [self.repo_path]
1998 # we need to split the name by / since this is how we store the
1999 # names in the database, but that eventually needs to be converted
2000 # into a valid system path
2001 p += self.repo_name.split(self.NAME_SEP)
2002 return os.path.join(*map(safe_unicode, p))
2003
2004 @property
2005 def cache_keys(self):
2006 """
2007 Returns associated cache keys for that repo
2008 """
2009 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
2010 repo_id=self.repo_id)
2011 return CacheKey.query()\
2012 .filter(CacheKey.cache_args == invalidation_namespace)\
2013 .order_by(CacheKey.cache_key)\
2014 .all()
2015
2016 @property
2017 def cached_diffs_relative_dir(self):
2018 """
2019 Return a relative to the repository store path of cached diffs
2020 used for safe display for users, who shouldn't know the absolute store
2021 path
2022 """
2023 return os.path.join(
2024 os.path.dirname(self.repo_name),
2025 self.cached_diffs_dir.split(os.path.sep)[-1])
2026
2027 @property
2028 def cached_diffs_dir(self):
2029 path = self.repo_full_path
2030 return os.path.join(
2031 os.path.dirname(path),
2032 '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
2033
2034 def cached_diffs(self):
2035 diff_cache_dir = self.cached_diffs_dir
2036 if os.path.isdir(diff_cache_dir):
2037 return os.listdir(diff_cache_dir)
2038 return []
2039
2040 def shadow_repos(self):
2041 shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id)
2042 return [
2043 x for x in os.listdir(os.path.dirname(self.repo_full_path))
2044 if x.startswith(shadow_repos_pattern)]
2045
2046 def get_new_name(self, repo_name):
2047 """
2048 returns new full repository name based on assigned group and new new
2049
2050 :param group_name:
2051 """
2052 path_prefix = self.group.full_path_splitted if self.group else []
2053 return self.NAME_SEP.join(path_prefix + [repo_name])
2054
2055 @property
2056 def _config(self):
2057 """
2058 Returns db based config object.
2059 """
2060 from rhodecode.lib.utils import make_db_config
2061 return make_db_config(clear_session=False, repo=self)
2062
2063 def permissions(self, with_admins=True, with_owner=True,
2064 expand_from_user_groups=False):
2065 """
2066 Permissions for repositories
2067 """
2068 _admin_perm = 'repository.admin'
2069
2070 owner_row = []
2071 if with_owner:
2072 usr = AttributeDict(self.user.get_dict())
2073 usr.owner_row = True
2074 usr.permission = _admin_perm
2075 usr.permission_id = None
2076 owner_row.append(usr)
2077
2078 super_admin_ids = []
2079 super_admin_rows = []
2080 if with_admins:
2081 for usr in User.get_all_super_admins():
2082 super_admin_ids.append(usr.user_id)
2083 # if this admin is also owner, don't double the record
2084 if usr.user_id == owner_row[0].user_id:
2085 owner_row[0].admin_row = True
2086 else:
2087 usr = AttributeDict(usr.get_dict())
2088 usr.admin_row = True
2089 usr.permission = _admin_perm
2090 usr.permission_id = None
2091 super_admin_rows.append(usr)
2092
2093 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
2094 q = q.options(joinedload(UserRepoToPerm.repository),
2095 joinedload(UserRepoToPerm.user),
2096 joinedload(UserRepoToPerm.permission),)
2097
2098 # get owners and admins and permissions. We do a trick of re-writing
2099 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2100 # has a global reference and changing one object propagates to all
2101 # others. This means if admin is also an owner admin_row that change
2102 # would propagate to both objects
2103 perm_rows = []
2104 for _usr in q.all():
2105 usr = AttributeDict(_usr.user.get_dict())
2106 # if this user is also owner/admin, mark as duplicate record
2107 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
2108 usr.duplicate_perm = True
2109 # also check if this permission is maybe used by branch_permissions
2110 if _usr.branch_perm_entry:
2111 usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry]
2112
2113 usr.permission = _usr.permission.permission_name
2114 usr.permission_id = _usr.repo_to_perm_id
2115 perm_rows.append(usr)
2116
2117 # filter the perm rows by 'default' first and then sort them by
2118 # admin,write,read,none permissions sorted again alphabetically in
2119 # each group
2120 perm_rows = sorted(perm_rows, key=display_user_sort)
2121
2122 user_groups_rows = []
2123 if expand_from_user_groups:
2124 for ug in self.permission_user_groups(with_members=True):
2125 for user_data in ug.members:
2126 user_groups_rows.append(user_data)
2127
2128 return super_admin_rows + owner_row + perm_rows + user_groups_rows
2129
2130 def permission_user_groups(self, with_members=True):
2131 q = UserGroupRepoToPerm.query()\
2132 .filter(UserGroupRepoToPerm.repository == self)
2133 q = q.options(joinedload(UserGroupRepoToPerm.repository),
2134 joinedload(UserGroupRepoToPerm.users_group),
2135 joinedload(UserGroupRepoToPerm.permission),)
2136
2137 perm_rows = []
2138 for _user_group in q.all():
2139 entry = AttributeDict(_user_group.users_group.get_dict())
2140 entry.permission = _user_group.permission.permission_name
2141 if with_members:
2142 entry.members = [x.user.get_dict()
2143 for x in _user_group.users_group.members]
2144 perm_rows.append(entry)
2145
2146 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2147 return perm_rows
2148
2149 def get_api_data(self, include_secrets=False):
2150 """
2151 Common function for generating repo api data
2152
2153 :param include_secrets: See :meth:`User.get_api_data`.
2154
2155 """
2156 # TODO: mikhail: Here there is an anti-pattern, we probably need to
2157 # move this methods on models level.
2158 from rhodecode.model.settings import SettingsModel
2159 from rhodecode.model.repo import RepoModel
2160
2161 repo = self
2162 _user_id, _time, _reason = self.locked
2163
2164 data = {
2165 'repo_id': repo.repo_id,
2166 'repo_name': repo.repo_name,
2167 'repo_type': repo.repo_type,
2168 'clone_uri': repo.clone_uri or '',
2169 'push_uri': repo.push_uri or '',
2170 'url': RepoModel().get_url(self),
2171 'private': repo.private,
2172 'created_on': repo.created_on,
2173 'description': repo.description_safe,
2174 'landing_rev': repo.landing_rev,
2175 'owner': repo.user.username,
2176 'fork_of': repo.fork.repo_name if repo.fork else None,
2177 'fork_of_id': repo.fork.repo_id if repo.fork else None,
2178 'enable_statistics': repo.enable_statistics,
2179 'enable_locking': repo.enable_locking,
2180 'enable_downloads': repo.enable_downloads,
2181 'last_changeset': repo.changeset_cache,
2182 'locked_by': User.get(_user_id).get_api_data(
2183 include_secrets=include_secrets) if _user_id else None,
2184 'locked_date': time_to_datetime(_time) if _time else None,
2185 'lock_reason': _reason if _reason else None,
2186 }
2187
2188 # TODO: mikhail: should be per-repo settings here
2189 rc_config = SettingsModel().get_all_settings()
2190 repository_fields = str2bool(
2191 rc_config.get('rhodecode_repository_fields'))
2192 if repository_fields:
2193 for f in self.extra_fields:
2194 data[f.field_key_prefixed] = f.field_value
2195
2196 return data
2197
2198 @classmethod
2199 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
2200 if not lock_time:
2201 lock_time = time.time()
2202 if not lock_reason:
2203 lock_reason = cls.LOCK_AUTOMATIC
2204 repo.locked = [user_id, lock_time, lock_reason]
2205 Session().add(repo)
2206 Session().commit()
2207
2208 @classmethod
2209 def unlock(cls, repo):
2210 repo.locked = None
2211 Session().add(repo)
2212 Session().commit()
2213
2214 @classmethod
2215 def getlock(cls, repo):
2216 return repo.locked
2217
2218 def is_user_lock(self, user_id):
2219 if self.lock[0]:
2220 lock_user_id = safe_int(self.lock[0])
2221 user_id = safe_int(user_id)
2222 # both are ints, and they are equal
2223 return all([lock_user_id, user_id]) and lock_user_id == user_id
2224
2225 return False
2226
2227 def get_locking_state(self, action, user_id, only_when_enabled=True):
2228 """
2229 Checks locking on this repository, if locking is enabled and lock is
2230 present returns a tuple of make_lock, locked, locked_by.
2231 make_lock can have 3 states None (do nothing) True, make lock
2232 False release lock, This value is later propagated to hooks, which
2233 do the locking. Think about this as signals passed to hooks what to do.
2234
2235 """
2236 # TODO: johbo: This is part of the business logic and should be moved
2237 # into the RepositoryModel.
2238
2239 if action not in ('push', 'pull'):
2240 raise ValueError("Invalid action value: %s" % repr(action))
2241
2242 # defines if locked error should be thrown to user
2243 currently_locked = False
2244 # defines if new lock should be made, tri-state
2245 make_lock = None
2246 repo = self
2247 user = User.get(user_id)
2248
2249 lock_info = repo.locked
2250
2251 if repo and (repo.enable_locking or not only_when_enabled):
2252 if action == 'push':
2253 # check if it's already locked !, if it is compare users
2254 locked_by_user_id = lock_info[0]
2255 if user.user_id == locked_by_user_id:
2256 log.debug(
2257 'Got `push` action from user %s, now unlocking', user)
2258 # unlock if we have push from user who locked
2259 make_lock = False
2260 else:
2261 # we're not the same user who locked, ban with
2262 # code defined in settings (default is 423 HTTP Locked) !
2263 log.debug('Repo %s is currently locked by %s', repo, user)
2264 currently_locked = True
2265 elif action == 'pull':
2266 # [0] user [1] date
2267 if lock_info[0] and lock_info[1]:
2268 log.debug('Repo %s is currently locked by %s', repo, user)
2269 currently_locked = True
2270 else:
2271 log.debug('Setting lock on repo %s by %s', repo, user)
2272 make_lock = True
2273
2274 else:
2275 log.debug('Repository %s do not have locking enabled', repo)
2276
2277 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
2278 make_lock, currently_locked, lock_info)
2279
2280 from rhodecode.lib.auth import HasRepoPermissionAny
2281 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
2282 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
2283 # if we don't have at least write permission we cannot make a lock
2284 log.debug('lock state reset back to FALSE due to lack '
2285 'of at least read permission')
2286 make_lock = False
2287
2288 return make_lock, currently_locked, lock_info
2289
2290 @property
2291 def last_commit_cache_update_diff(self):
2292 return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
2293
2294 @classmethod
2295 def _load_commit_change(cls, last_commit_cache):
2296 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2297 empty_date = datetime.datetime.fromtimestamp(0)
2298 date_latest = last_commit_cache.get('date', empty_date)
2299 try:
2300 return parse_datetime(date_latest)
2301 except Exception:
2302 return empty_date
2303
2304 @property
2305 def last_commit_change(self):
2306 return self._load_commit_change(self.changeset_cache)
2307
2308 @property
2309 def last_db_change(self):
2310 return self.updated_on
2311
2312 @property
2313 def clone_uri_hidden(self):
2314 clone_uri = self.clone_uri
2315 if clone_uri:
2316 import urlobject
2317 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
2318 if url_obj.password:
2319 clone_uri = url_obj.with_password('*****')
2320 return clone_uri
2321
2322 @property
2323 def push_uri_hidden(self):
2324 push_uri = self.push_uri
2325 if push_uri:
2326 import urlobject
2327 url_obj = urlobject.URLObject(cleaned_uri(push_uri))
2328 if url_obj.password:
2329 push_uri = url_obj.with_password('*****')
2330 return push_uri
2331
2332 def clone_url(self, **override):
2333 from rhodecode.model.settings import SettingsModel
2334
2335 uri_tmpl = None
2336 if 'with_id' in override:
2337 uri_tmpl = self.DEFAULT_CLONE_URI_ID
2338 del override['with_id']
2339
2340 if 'uri_tmpl' in override:
2341 uri_tmpl = override['uri_tmpl']
2342 del override['uri_tmpl']
2343
2344 ssh = False
2345 if 'ssh' in override:
2346 ssh = True
2347 del override['ssh']
2348
2349 # we didn't override our tmpl from **overrides
2350 request = get_current_request()
2351 if not uri_tmpl:
2352 if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'):
2353 rc_config = request.call_context.rc_config
2354 else:
2355 rc_config = SettingsModel().get_all_settings(cache=True)
2356
2357 if ssh:
2358 uri_tmpl = rc_config.get(
2359 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
2360
2361 else:
2362 uri_tmpl = rc_config.get(
2363 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
2364
2365 return get_clone_url(request=request,
2366 uri_tmpl=uri_tmpl,
2367 repo_name=self.repo_name,
2368 repo_id=self.repo_id,
2369 repo_type=self.repo_type,
2370 **override)
2371
2372 def set_state(self, state):
2373 self.repo_state = state
2374 Session().add(self)
2375 #==========================================================================
2376 # SCM PROPERTIES
2377 #==========================================================================
2378
2379 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False):
2380 return get_commit_safe(
2381 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load,
2382 maybe_unreachable=maybe_unreachable)
2383
2384 def get_changeset(self, rev=None, pre_load=None):
2385 warnings.warn("Use get_commit", DeprecationWarning)
2386 commit_id = None
2387 commit_idx = None
2388 if isinstance(rev, compat.string_types):
2389 commit_id = rev
2390 else:
2391 commit_idx = rev
2392 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
2393 pre_load=pre_load)
2394
2395 def get_landing_commit(self):
2396 """
2397 Returns landing commit, or if that doesn't exist returns the tip
2398 """
2399 _rev_type, _rev = self.landing_rev
2400 commit = self.get_commit(_rev)
2401 if isinstance(commit, EmptyCommit):
2402 return self.get_commit()
2403 return commit
2404
2405 def flush_commit_cache(self):
2406 self.update_commit_cache(cs_cache={'raw_id':'0'})
2407 self.update_commit_cache()
2408
2409 def update_commit_cache(self, cs_cache=None, config=None):
2410 """
2411 Update cache of last commit for repository
2412 cache_keys should be::
2413
2414 source_repo_id
2415 short_id
2416 raw_id
2417 revision
2418 parents
2419 message
2420 date
2421 author
2422 updated_on
2423
2424 """
2425 from rhodecode.lib.vcs.backends.base import BaseChangeset
2426 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2427 empty_date = datetime.datetime.fromtimestamp(0)
2428
2429 if cs_cache is None:
2430 # use no-cache version here
2431 try:
2432 scm_repo = self.scm_instance(cache=False, config=config)
2433 except VCSError:
2434 scm_repo = None
2435 empty = scm_repo is None or scm_repo.is_empty()
2436
2437 if not empty:
2438 cs_cache = scm_repo.get_commit(
2439 pre_load=["author", "date", "message", "parents", "branch"])
2440 else:
2441 cs_cache = EmptyCommit()
2442
2443 if isinstance(cs_cache, BaseChangeset):
2444 cs_cache = cs_cache.__json__()
2445
2446 def is_outdated(new_cs_cache):
2447 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
2448 new_cs_cache['revision'] != self.changeset_cache['revision']):
2449 return True
2450 return False
2451
2452 # check if we have maybe already latest cached revision
2453 if is_outdated(cs_cache) or not self.changeset_cache:
2454 _current_datetime = datetime.datetime.utcnow()
2455 last_change = cs_cache.get('date') or _current_datetime
2456 # we check if last update is newer than the new value
2457 # if yes, we use the current timestamp instead. Imagine you get
2458 # old commit pushed 1y ago, we'd set last update 1y to ago.
2459 last_change_timestamp = datetime_to_time(last_change)
2460 current_timestamp = datetime_to_time(last_change)
2461 if last_change_timestamp > current_timestamp and not empty:
2462 cs_cache['date'] = _current_datetime
2463
2464 _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
2465 cs_cache['updated_on'] = time.time()
2466 self.changeset_cache = cs_cache
2467 self.updated_on = last_change
2468 Session().add(self)
2469 Session().commit()
2470
2471 else:
2472 if empty:
2473 cs_cache = EmptyCommit().__json__()
2474 else:
2475 cs_cache = self.changeset_cache
2476
2477 _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
2478
2479 cs_cache['updated_on'] = time.time()
2480 self.changeset_cache = cs_cache
2481 self.updated_on = _date_latest
2482 Session().add(self)
2483 Session().commit()
2484
2485 log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s',
2486 self.repo_name, cs_cache, _date_latest)
2487
2488 @property
2489 def tip(self):
2490 return self.get_commit('tip')
2491
2492 @property
2493 def author(self):
2494 return self.tip.author
2495
2496 @property
2497 def last_change(self):
2498 return self.scm_instance().last_change
2499
2500 def get_comments(self, revisions=None):
2501 """
2502 Returns comments for this repository grouped by revisions
2503
2504 :param revisions: filter query by revisions only
2505 """
2506 cmts = ChangesetComment.query()\
2507 .filter(ChangesetComment.repo == self)
2508 if revisions:
2509 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2510 grouped = collections.defaultdict(list)
2511 for cmt in cmts.all():
2512 grouped[cmt.revision].append(cmt)
2513 return grouped
2514
2515 def statuses(self, revisions=None):
2516 """
2517 Returns statuses for this repository
2518
2519 :param revisions: list of revisions to get statuses for
2520 """
2521 statuses = ChangesetStatus.query()\
2522 .filter(ChangesetStatus.repo == self)\
2523 .filter(ChangesetStatus.version == 0)
2524
2525 if revisions:
2526 # Try doing the filtering in chunks to avoid hitting limits
2527 size = 500
2528 status_results = []
2529 for chunk in xrange(0, len(revisions), size):
2530 status_results += statuses.filter(
2531 ChangesetStatus.revision.in_(
2532 revisions[chunk: chunk+size])
2533 ).all()
2534 else:
2535 status_results = statuses.all()
2536
2537 grouped = {}
2538
2539 # maybe we have open new pullrequest without a status?
2540 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2541 status_lbl = ChangesetStatus.get_status_lbl(stat)
2542 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2543 for rev in pr.revisions:
2544 pr_id = pr.pull_request_id
2545 pr_repo = pr.target_repo.repo_name
2546 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2547
2548 for stat in status_results:
2549 pr_id = pr_repo = None
2550 if stat.pull_request:
2551 pr_id = stat.pull_request.pull_request_id
2552 pr_repo = stat.pull_request.target_repo.repo_name
2553 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2554 pr_id, pr_repo]
2555 return grouped
2556
2557 # ==========================================================================
2558 # SCM CACHE INSTANCE
2559 # ==========================================================================
2560
2561 def scm_instance(self, **kwargs):
2562 import rhodecode
2563
2564 # Passing a config will not hit the cache currently only used
2565 # for repo2dbmapper
2566 config = kwargs.pop('config', None)
2567 cache = kwargs.pop('cache', None)
2568 vcs_full_cache = kwargs.pop('vcs_full_cache', None)
2569 if vcs_full_cache is not None:
2570 # allows override global config
2571 full_cache = vcs_full_cache
2572 else:
2573 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2574 # if cache is NOT defined use default global, else we have a full
2575 # control over cache behaviour
2576 if cache is None and full_cache and not config:
2577 log.debug('Initializing pure cached instance for %s', self.repo_path)
2578 return self._get_instance_cached()
2579
2580 # cache here is sent to the "vcs server"
2581 return self._get_instance(cache=bool(cache), config=config)
2582
2583 def _get_instance_cached(self):
2584 from rhodecode.lib import rc_cache
2585
2586 cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id)
2587 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
2588 repo_id=self.repo_id)
2589 region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
2590
2591 @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
2592 def get_instance_cached(repo_id, context_id, _cache_state_uid):
2593 return self._get_instance(repo_state_uid=_cache_state_uid)
2594
2595 # we must use thread scoped cache here,
2596 # because each thread of gevent needs it's own not shared connection and cache
2597 # we also alter `args` so the cache key is individual for every green thread.
2598 inv_context_manager = rc_cache.InvalidationContext(
2599 uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace,
2600 thread_scoped=True)
2601 with inv_context_manager as invalidation_context:
2602 cache_state_uid = invalidation_context.cache_data['cache_state_uid']
2603 args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid)
2604
2605 # re-compute and store cache if we get invalidate signal
2606 if invalidation_context.should_invalidate():
2607 instance = get_instance_cached.refresh(*args)
2608 else:
2609 instance = get_instance_cached(*args)
2610
2611 log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time)
2612 return instance
2613
2614 def _get_instance(self, cache=True, config=None, repo_state_uid=None):
2615 log.debug('Initializing %s instance `%s` with cache flag set to: %s',
2616 self.repo_type, self.repo_path, cache)
2617 config = config or self._config
2618 custom_wire = {
2619 'cache': cache, # controls the vcs.remote cache
2620 'repo_state_uid': repo_state_uid
2621 }
2622 repo = get_vcs_instance(
2623 repo_path=safe_str(self.repo_full_path),
2624 config=config,
2625 with_wire=custom_wire,
2626 create=False,
2627 _vcs_alias=self.repo_type)
2628 if repo is not None:
2629 repo.count() # cache rebuild
2630 return repo
2631
2632 def get_shadow_repository_path(self, workspace_id):
2633 from rhodecode.lib.vcs.backends.base import BaseRepository
2634 shadow_repo_path = BaseRepository._get_shadow_repository_path(
2635 self.repo_full_path, self.repo_id, workspace_id)
2636 return shadow_repo_path
2637
2638 def __json__(self):
2639 return {'landing_rev': self.landing_rev}
2640
2641 def get_dict(self):
2642
2643 # Since we transformed `repo_name` to a hybrid property, we need to
2644 # keep compatibility with the code which uses `repo_name` field.
2645
2646 result = super(Repository, self).get_dict()
2647 result['repo_name'] = result.pop('_repo_name', None)
2648 return result
2649
2650
2651 class RepoGroup(Base, BaseModel):
2652 __tablename__ = 'groups'
2653 __table_args__ = (
2654 UniqueConstraint('group_name', 'group_parent_id'),
2655 base_table_args,
2656 )
2657 __mapper_args__ = {'order_by': 'group_name'}
2658
2659 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2660
2661 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2662 _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2663 group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False)
2664 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2665 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2666 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2667 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2668 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2669 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2670 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2671 _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data
2672
2673 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2674 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2675 parent_group = relationship('RepoGroup', remote_side=group_id)
2676 user = relationship('User')
2677 integrations = relationship('Integration', cascade="all, delete-orphan")
2678
2679 # no cascade, set NULL
2680 scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id')
2681
2682 def __init__(self, group_name='', parent_group=None):
2683 self.group_name = group_name
2684 self.parent_group = parent_group
2685
2686 def __unicode__(self):
2687 return u"<%s('id:%s:%s')>" % (
2688 self.__class__.__name__, self.group_id, self.group_name)
2689
2690 @hybrid_property
2691 def group_name(self):
2692 return self._group_name
2693
2694 @group_name.setter
2695 def group_name(self, value):
2696 self._group_name = value
2697 self.group_name_hash = self.hash_repo_group_name(value)
2698
2699 @classmethod
2700 def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
2701 from rhodecode.lib.vcs.backends.base import EmptyCommit
2702 dummy = EmptyCommit().__json__()
2703 if not changeset_cache_raw:
2704 dummy['source_repo_id'] = repo_id
2705 return json.loads(json.dumps(dummy))
2706
2707 try:
2708 return json.loads(changeset_cache_raw)
2709 except TypeError:
2710 return dummy
2711 except Exception:
2712 log.error(traceback.format_exc())
2713 return dummy
2714
2715 @hybrid_property
2716 def changeset_cache(self):
2717 return self._load_changeset_cache('', self._changeset_cache)
2718
2719 @changeset_cache.setter
2720 def changeset_cache(self, val):
2721 try:
2722 self._changeset_cache = json.dumps(val)
2723 except Exception:
2724 log.error(traceback.format_exc())
2725
2726 @validates('group_parent_id')
2727 def validate_group_parent_id(self, key, val):
2728 """
2729 Check cycle references for a parent group to self
2730 """
2731 if self.group_id and val:
2732 assert val != self.group_id
2733
2734 return val
2735
2736 @hybrid_property
2737 def description_safe(self):
2738 from rhodecode.lib import helpers as h
2739 return h.escape(self.group_description)
2740
2741 @classmethod
2742 def hash_repo_group_name(cls, repo_group_name):
2743 val = remove_formatting(repo_group_name)
2744 val = safe_str(val).lower()
2745 chars = []
2746 for c in val:
2747 if c not in string.ascii_letters:
2748 c = str(ord(c))
2749 chars.append(c)
2750
2751 return ''.join(chars)
2752
2753 @classmethod
2754 def _generate_choice(cls, repo_group):
2755 from webhelpers2.html import literal as _literal
2756 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2757 return repo_group.group_id, _name(repo_group.full_path_splitted)
2758
2759 @classmethod
2760 def groups_choices(cls, groups=None, show_empty_group=True):
2761 if not groups:
2762 groups = cls.query().all()
2763
2764 repo_groups = []
2765 if show_empty_group:
2766 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2767
2768 repo_groups.extend([cls._generate_choice(x) for x in groups])
2769
2770 repo_groups = sorted(
2771 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2772 return repo_groups
2773
2774 @classmethod
2775 def url_sep(cls):
2776 return URL_SEP
2777
2778 @classmethod
2779 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2780 if case_insensitive:
2781 gr = cls.query().filter(func.lower(cls.group_name)
2782 == func.lower(group_name))
2783 else:
2784 gr = cls.query().filter(cls.group_name == group_name)
2785 if cache:
2786 name_key = _hash_key(group_name)
2787 gr = gr.options(
2788 FromCache("sql_cache_short", "get_group_%s" % name_key))
2789 return gr.scalar()
2790
2791 @classmethod
2792 def get_user_personal_repo_group(cls, user_id):
2793 user = User.get(user_id)
2794 if user.username == User.DEFAULT_USER:
2795 return None
2796
2797 return cls.query()\
2798 .filter(cls.personal == true()) \
2799 .filter(cls.user == user) \
2800 .order_by(cls.group_id.asc()) \
2801 .first()
2802
2803 @classmethod
2804 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2805 case_insensitive=True):
2806 q = RepoGroup.query()
2807
2808 if not isinstance(user_id, Optional):
2809 q = q.filter(RepoGroup.user_id == user_id)
2810
2811 if not isinstance(group_id, Optional):
2812 q = q.filter(RepoGroup.group_parent_id == group_id)
2813
2814 if case_insensitive:
2815 q = q.order_by(func.lower(RepoGroup.group_name))
2816 else:
2817 q = q.order_by(RepoGroup.group_name)
2818 return q.all()
2819
2820 @property
2821 def parents(self, parents_recursion_limit=10):
2822 groups = []
2823 if self.parent_group is None:
2824 return groups
2825 cur_gr = self.parent_group
2826 groups.insert(0, cur_gr)
2827 cnt = 0
2828 while 1:
2829 cnt += 1
2830 gr = getattr(cur_gr, 'parent_group', None)
2831 cur_gr = cur_gr.parent_group
2832 if gr is None:
2833 break
2834 if cnt == parents_recursion_limit:
2835 # this will prevent accidental infinit loops
2836 log.error('more than %s parents found for group %s, stopping '
2837 'recursive parent fetching', parents_recursion_limit, self)
2838 break
2839
2840 groups.insert(0, gr)
2841 return groups
2842
2843 @property
2844 def last_commit_cache_update_diff(self):
2845 return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
2846
2847 @classmethod
2848 def _load_commit_change(cls, last_commit_cache):
2849 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2850 empty_date = datetime.datetime.fromtimestamp(0)
2851 date_latest = last_commit_cache.get('date', empty_date)
2852 try:
2853 return parse_datetime(date_latest)
2854 except Exception:
2855 return empty_date
2856
2857 @property
2858 def last_commit_change(self):
2859 return self._load_commit_change(self.changeset_cache)
2860
2861 @property
2862 def last_db_change(self):
2863 return self.updated_on
2864
2865 @property
2866 def children(self):
2867 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2868
2869 @property
2870 def name(self):
2871 return self.group_name.split(RepoGroup.url_sep())[-1]
2872
2873 @property
2874 def full_path(self):
2875 return self.group_name
2876
2877 @property
2878 def full_path_splitted(self):
2879 return self.group_name.split(RepoGroup.url_sep())
2880
2881 @property
2882 def repositories(self):
2883 return Repository.query()\
2884 .filter(Repository.group == self)\
2885 .order_by(Repository.repo_name)
2886
2887 @property
2888 def repositories_recursive_count(self):
2889 cnt = self.repositories.count()
2890
2891 def children_count(group):
2892 cnt = 0
2893 for child in group.children:
2894 cnt += child.repositories.count()
2895 cnt += children_count(child)
2896 return cnt
2897
2898 return cnt + children_count(self)
2899
2900 def _recursive_objects(self, include_repos=True, include_groups=True):
2901 all_ = []
2902
2903 def _get_members(root_gr):
2904 if include_repos:
2905 for r in root_gr.repositories:
2906 all_.append(r)
2907 childs = root_gr.children.all()
2908 if childs:
2909 for gr in childs:
2910 if include_groups:
2911 all_.append(gr)
2912 _get_members(gr)
2913
2914 root_group = []
2915 if include_groups:
2916 root_group = [self]
2917
2918 _get_members(self)
2919 return root_group + all_
2920
2921 def recursive_groups_and_repos(self):
2922 """
2923 Recursive return all groups, with repositories in those groups
2924 """
2925 return self._recursive_objects()
2926
2927 def recursive_groups(self):
2928 """
2929 Returns all children groups for this group including children of children
2930 """
2931 return self._recursive_objects(include_repos=False)
2932
2933 def recursive_repos(self):
2934 """
2935 Returns all children repositories for this group
2936 """
2937 return self._recursive_objects(include_groups=False)
2938
2939 def get_new_name(self, group_name):
2940 """
2941 returns new full group name based on parent and new name
2942
2943 :param group_name:
2944 """
2945 path_prefix = (self.parent_group.full_path_splitted if
2946 self.parent_group else [])
2947 return RepoGroup.url_sep().join(path_prefix + [group_name])
2948
2949 def update_commit_cache(self, config=None):
2950 """
2951 Update cache of last commit for newest repository inside this repository group.
2952 cache_keys should be::
2953
2954 source_repo_id
2955 short_id
2956 raw_id
2957 revision
2958 parents
2959 message
2960 date
2961 author
2962
2963 """
2964 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2965 empty_date = datetime.datetime.fromtimestamp(0)
2966
2967 def repo_groups_and_repos(root_gr):
2968 for _repo in root_gr.repositories:
2969 yield _repo
2970 for child_group in root_gr.children.all():
2971 yield child_group
2972
2973 latest_repo_cs_cache = {}
2974 for obj in repo_groups_and_repos(self):
2975 repo_cs_cache = obj.changeset_cache
2976 date_latest = latest_repo_cs_cache.get('date', empty_date)
2977 date_current = repo_cs_cache.get('date', empty_date)
2978 current_timestamp = datetime_to_time(parse_datetime(date_latest))
2979 if current_timestamp < datetime_to_time(parse_datetime(date_current)):
2980 latest_repo_cs_cache = repo_cs_cache
2981 if hasattr(obj, 'repo_id'):
2982 latest_repo_cs_cache['source_repo_id'] = obj.repo_id
2983 else:
2984 latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id')
2985
2986 _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date)
2987
2988 latest_repo_cs_cache['updated_on'] = time.time()
2989 self.changeset_cache = latest_repo_cs_cache
2990 self.updated_on = _date_latest
2991 Session().add(self)
2992 Session().commit()
2993
2994 log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s',
2995 self.group_name, latest_repo_cs_cache, _date_latest)
2996
2997 def permissions(self, with_admins=True, with_owner=True,
2998 expand_from_user_groups=False):
2999 """
3000 Permissions for repository groups
3001 """
3002 _admin_perm = 'group.admin'
3003
3004 owner_row = []
3005 if with_owner:
3006 usr = AttributeDict(self.user.get_dict())
3007 usr.owner_row = True
3008 usr.permission = _admin_perm
3009 owner_row.append(usr)
3010
3011 super_admin_ids = []
3012 super_admin_rows = []
3013 if with_admins:
3014 for usr in User.get_all_super_admins():
3015 super_admin_ids.append(usr.user_id)
3016 # if this admin is also owner, don't double the record
3017 if usr.user_id == owner_row[0].user_id:
3018 owner_row[0].admin_row = True
3019 else:
3020 usr = AttributeDict(usr.get_dict())
3021 usr.admin_row = True
3022 usr.permission = _admin_perm
3023 super_admin_rows.append(usr)
3024
3025 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
3026 q = q.options(joinedload(UserRepoGroupToPerm.group),
3027 joinedload(UserRepoGroupToPerm.user),
3028 joinedload(UserRepoGroupToPerm.permission),)
3029
3030 # get owners and admins and permissions. We do a trick of re-writing
3031 # objects from sqlalchemy to named-tuples due to sqlalchemy session
3032 # has a global reference and changing one object propagates to all
3033 # others. This means if admin is also an owner admin_row that change
3034 # would propagate to both objects
3035 perm_rows = []
3036 for _usr in q.all():
3037 usr = AttributeDict(_usr.user.get_dict())
3038 # if this user is also owner/admin, mark as duplicate record
3039 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
3040 usr.duplicate_perm = True
3041 usr.permission = _usr.permission.permission_name
3042 perm_rows.append(usr)
3043
3044 # filter the perm rows by 'default' first and then sort them by
3045 # admin,write,read,none permissions sorted again alphabetically in
3046 # each group
3047 perm_rows = sorted(perm_rows, key=display_user_sort)
3048
3049 user_groups_rows = []
3050 if expand_from_user_groups:
3051 for ug in self.permission_user_groups(with_members=True):
3052 for user_data in ug.members:
3053 user_groups_rows.append(user_data)
3054
3055 return super_admin_rows + owner_row + perm_rows + user_groups_rows
3056
3057 def permission_user_groups(self, with_members=False):
3058 q = UserGroupRepoGroupToPerm.query()\
3059 .filter(UserGroupRepoGroupToPerm.group == self)
3060 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
3061 joinedload(UserGroupRepoGroupToPerm.users_group),
3062 joinedload(UserGroupRepoGroupToPerm.permission),)
3063
3064 perm_rows = []
3065 for _user_group in q.all():
3066 entry = AttributeDict(_user_group.users_group.get_dict())
3067 entry.permission = _user_group.permission.permission_name
3068 if with_members:
3069 entry.members = [x.user.get_dict()
3070 for x in _user_group.users_group.members]
3071 perm_rows.append(entry)
3072
3073 perm_rows = sorted(perm_rows, key=display_user_group_sort)
3074 return perm_rows
3075
3076 def get_api_data(self):
3077 """
3078 Common function for generating api data
3079
3080 """
3081 group = self
3082 data = {
3083 'group_id': group.group_id,
3084 'group_name': group.group_name,
3085 'group_description': group.description_safe,
3086 'parent_group': group.parent_group.group_name if group.parent_group else None,
3087 'repositories': [x.repo_name for x in group.repositories],
3088 'owner': group.user.username,
3089 }
3090 return data
3091
3092 def get_dict(self):
3093 # Since we transformed `group_name` to a hybrid property, we need to
3094 # keep compatibility with the code which uses `group_name` field.
3095 result = super(RepoGroup, self).get_dict()
3096 result['group_name'] = result.pop('_group_name', None)
3097 return result
3098
3099
3100 class Permission(Base, BaseModel):
3101 __tablename__ = 'permissions'
3102 __table_args__ = (
3103 Index('p_perm_name_idx', 'permission_name'),
3104 base_table_args,
3105 )
3106
3107 PERMS = [
3108 ('hg.admin', _('RhodeCode Super Administrator')),
3109
3110 ('repository.none', _('Repository no access')),
3111 ('repository.read', _('Repository read access')),
3112 ('repository.write', _('Repository write access')),
3113 ('repository.admin', _('Repository admin access')),
3114
3115 ('group.none', _('Repository group no access')),
3116 ('group.read', _('Repository group read access')),
3117 ('group.write', _('Repository group write access')),
3118 ('group.admin', _('Repository group admin access')),
3119
3120 ('usergroup.none', _('User group no access')),
3121 ('usergroup.read', _('User group read access')),
3122 ('usergroup.write', _('User group write access')),
3123 ('usergroup.admin', _('User group admin access')),
3124
3125 ('branch.none', _('Branch no permissions')),
3126 ('branch.merge', _('Branch access by web merge')),
3127 ('branch.push', _('Branch access by push')),
3128 ('branch.push_force', _('Branch access by push with force')),
3129
3130 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
3131 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
3132
3133 ('hg.usergroup.create.false', _('User Group creation disabled')),
3134 ('hg.usergroup.create.true', _('User Group creation enabled')),
3135
3136 ('hg.create.none', _('Repository creation disabled')),
3137 ('hg.create.repository', _('Repository creation enabled')),
3138 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
3139 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
3140
3141 ('hg.fork.none', _('Repository forking disabled')),
3142 ('hg.fork.repository', _('Repository forking enabled')),
3143
3144 ('hg.register.none', _('Registration disabled')),
3145 ('hg.register.manual_activate', _('User Registration with manual account activation')),
3146 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
3147
3148 ('hg.password_reset.enabled', _('Password reset enabled')),
3149 ('hg.password_reset.hidden', _('Password reset hidden')),
3150 ('hg.password_reset.disabled', _('Password reset disabled')),
3151
3152 ('hg.extern_activate.manual', _('Manual activation of external account')),
3153 ('hg.extern_activate.auto', _('Automatic activation of external account')),
3154
3155 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
3156 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
3157 ]
3158
3159 # definition of system default permissions for DEFAULT user, created on
3160 # system setup
3161 DEFAULT_USER_PERMISSIONS = [
3162 # object perms
3163 'repository.read',
3164 'group.read',
3165 'usergroup.read',
3166 # branch, for backward compat we need same value as before so forced pushed
3167 'branch.push_force',
3168 # global
3169 'hg.create.repository',
3170 'hg.repogroup.create.false',
3171 'hg.usergroup.create.false',
3172 'hg.create.write_on_repogroup.true',
3173 'hg.fork.repository',
3174 'hg.register.manual_activate',
3175 'hg.password_reset.enabled',
3176 'hg.extern_activate.auto',
3177 'hg.inherit_default_perms.true',
3178 ]
3179
3180 # defines which permissions are more important higher the more important
3181 # Weight defines which permissions are more important.
3182 # The higher number the more important.
3183 PERM_WEIGHTS = {
3184 'repository.none': 0,
3185 'repository.read': 1,
3186 'repository.write': 3,
3187 'repository.admin': 4,
3188
3189 'group.none': 0,
3190 'group.read': 1,
3191 'group.write': 3,
3192 'group.admin': 4,
3193
3194 'usergroup.none': 0,
3195 'usergroup.read': 1,
3196 'usergroup.write': 3,
3197 'usergroup.admin': 4,
3198
3199 'branch.none': 0,
3200 'branch.merge': 1,
3201 'branch.push': 3,
3202 'branch.push_force': 4,
3203
3204 'hg.repogroup.create.false': 0,
3205 'hg.repogroup.create.true': 1,
3206
3207 'hg.usergroup.create.false': 0,
3208 'hg.usergroup.create.true': 1,
3209
3210 'hg.fork.none': 0,
3211 'hg.fork.repository': 1,
3212 'hg.create.none': 0,
3213 'hg.create.repository': 1
3214 }
3215
3216 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3217 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
3218 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
3219
3220 def __unicode__(self):
3221 return u"<%s('%s:%s')>" % (
3222 self.__class__.__name__, self.permission_id, self.permission_name
3223 )
3224
3225 @classmethod
3226 def get_by_key(cls, key):
3227 return cls.query().filter(cls.permission_name == key).scalar()
3228
3229 @classmethod
3230 def get_default_repo_perms(cls, user_id, repo_id=None):
3231 q = Session().query(UserRepoToPerm, Repository, Permission)\
3232 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
3233 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
3234 .filter(UserRepoToPerm.user_id == user_id)
3235 if repo_id:
3236 q = q.filter(UserRepoToPerm.repository_id == repo_id)
3237 return q.all()
3238
3239 @classmethod
3240 def get_default_repo_branch_perms(cls, user_id, repo_id=None):
3241 q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \
3242 .join(
3243 Permission,
3244 UserToRepoBranchPermission.permission_id == Permission.permission_id) \
3245 .join(
3246 UserRepoToPerm,
3247 UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \
3248 .filter(UserRepoToPerm.user_id == user_id)
3249
3250 if repo_id:
3251 q = q.filter(UserToRepoBranchPermission.repository_id == repo_id)
3252 return q.order_by(UserToRepoBranchPermission.rule_order).all()
3253
3254 @classmethod
3255 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
3256 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
3257 .join(
3258 Permission,
3259 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
3260 .join(
3261 Repository,
3262 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
3263 .join(
3264 UserGroup,
3265 UserGroupRepoToPerm.users_group_id ==
3266 UserGroup.users_group_id)\
3267 .join(
3268 UserGroupMember,
3269 UserGroupRepoToPerm.users_group_id ==
3270 UserGroupMember.users_group_id)\
3271 .filter(
3272 UserGroupMember.user_id == user_id,
3273 UserGroup.users_group_active == true())
3274 if repo_id:
3275 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
3276 return q.all()
3277
3278 @classmethod
3279 def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None):
3280 q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \
3281 .join(
3282 Permission,
3283 UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \
3284 .join(
3285 UserGroupRepoToPerm,
3286 UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \
3287 .join(
3288 UserGroup,
3289 UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \
3290 .join(
3291 UserGroupMember,
3292 UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \
3293 .filter(
3294 UserGroupMember.user_id == user_id,
3295 UserGroup.users_group_active == true())
3296
3297 if repo_id:
3298 q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id)
3299 return q.order_by(UserGroupToRepoBranchPermission.rule_order).all()
3300
3301 @classmethod
3302 def get_default_group_perms(cls, user_id, repo_group_id=None):
3303 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
3304 .join(
3305 Permission,
3306 UserRepoGroupToPerm.permission_id == Permission.permission_id)\
3307 .join(
3308 RepoGroup,
3309 UserRepoGroupToPerm.group_id == RepoGroup.group_id)\
3310 .filter(UserRepoGroupToPerm.user_id == user_id)
3311 if repo_group_id:
3312 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
3313 return q.all()
3314
3315 @classmethod
3316 def get_default_group_perms_from_user_group(
3317 cls, user_id, repo_group_id=None):
3318 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
3319 .join(
3320 Permission,
3321 UserGroupRepoGroupToPerm.permission_id ==
3322 Permission.permission_id)\
3323 .join(
3324 RepoGroup,
3325 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
3326 .join(
3327 UserGroup,
3328 UserGroupRepoGroupToPerm.users_group_id ==
3329 UserGroup.users_group_id)\
3330 .join(
3331 UserGroupMember,
3332 UserGroupRepoGroupToPerm.users_group_id ==
3333 UserGroupMember.users_group_id)\
3334 .filter(
3335 UserGroupMember.user_id == user_id,
3336 UserGroup.users_group_active == true())
3337 if repo_group_id:
3338 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
3339 return q.all()
3340
3341 @classmethod
3342 def get_default_user_group_perms(cls, user_id, user_group_id=None):
3343 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
3344 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
3345 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
3346 .filter(UserUserGroupToPerm.user_id == user_id)
3347 if user_group_id:
3348 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
3349 return q.all()
3350
3351 @classmethod
3352 def get_default_user_group_perms_from_user_group(
3353 cls, user_id, user_group_id=None):
3354 TargetUserGroup = aliased(UserGroup, name='target_user_group')
3355 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
3356 .join(
3357 Permission,
3358 UserGroupUserGroupToPerm.permission_id ==
3359 Permission.permission_id)\
3360 .join(
3361 TargetUserGroup,
3362 UserGroupUserGroupToPerm.target_user_group_id ==
3363 TargetUserGroup.users_group_id)\
3364 .join(
3365 UserGroup,
3366 UserGroupUserGroupToPerm.user_group_id ==
3367 UserGroup.users_group_id)\
3368 .join(
3369 UserGroupMember,
3370 UserGroupUserGroupToPerm.user_group_id ==
3371 UserGroupMember.users_group_id)\
3372 .filter(
3373 UserGroupMember.user_id == user_id,
3374 UserGroup.users_group_active == true())
3375 if user_group_id:
3376 q = q.filter(
3377 UserGroupUserGroupToPerm.user_group_id == user_group_id)
3378
3379 return q.all()
3380
3381
3382 class UserRepoToPerm(Base, BaseModel):
3383 __tablename__ = 'repo_to_perm'
3384 __table_args__ = (
3385 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
3386 base_table_args
3387 )
3388
3389 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3390 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3391 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3392 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3393
3394 user = relationship('User')
3395 repository = relationship('Repository')
3396 permission = relationship('Permission')
3397
3398 branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined')
3399
3400 @classmethod
3401 def create(cls, user, repository, permission):
3402 n = cls()
3403 n.user = user
3404 n.repository = repository
3405 n.permission = permission
3406 Session().add(n)
3407 return n
3408
3409 def __unicode__(self):
3410 return u'<%s => %s >' % (self.user, self.repository)
3411
3412
3413 class UserUserGroupToPerm(Base, BaseModel):
3414 __tablename__ = 'user_user_group_to_perm'
3415 __table_args__ = (
3416 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
3417 base_table_args
3418 )
3419
3420 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3421 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3422 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3423 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3424
3425 user = relationship('User')
3426 user_group = relationship('UserGroup')
3427 permission = relationship('Permission')
3428
3429 @classmethod
3430 def create(cls, user, user_group, permission):
3431 n = cls()
3432 n.user = user
3433 n.user_group = user_group
3434 n.permission = permission
3435 Session().add(n)
3436 return n
3437
3438 def __unicode__(self):
3439 return u'<%s => %s >' % (self.user, self.user_group)
3440
3441
3442 class UserToPerm(Base, BaseModel):
3443 __tablename__ = 'user_to_perm'
3444 __table_args__ = (
3445 UniqueConstraint('user_id', 'permission_id'),
3446 base_table_args
3447 )
3448
3449 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3450 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3451 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3452
3453 user = relationship('User')
3454 permission = relationship('Permission', lazy='joined')
3455
3456 def __unicode__(self):
3457 return u'<%s => %s >' % (self.user, self.permission)
3458
3459
3460 class UserGroupRepoToPerm(Base, BaseModel):
3461 __tablename__ = 'users_group_repo_to_perm'
3462 __table_args__ = (
3463 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
3464 base_table_args
3465 )
3466
3467 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3468 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3469 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3470 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3471
3472 users_group = relationship('UserGroup')
3473 permission = relationship('Permission')
3474 repository = relationship('Repository')
3475 user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all')
3476
3477 @classmethod
3478 def create(cls, users_group, repository, permission):
3479 n = cls()
3480 n.users_group = users_group
3481 n.repository = repository
3482 n.permission = permission
3483 Session().add(n)
3484 return n
3485
3486 def __unicode__(self):
3487 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
3488
3489
3490 class UserGroupUserGroupToPerm(Base, BaseModel):
3491 __tablename__ = 'user_group_user_group_to_perm'
3492 __table_args__ = (
3493 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
3494 CheckConstraint('target_user_group_id != user_group_id'),
3495 base_table_args
3496 )
3497
3498 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)
3499 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3500 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3501 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3502
3503 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
3504 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
3505 permission = relationship('Permission')
3506
3507 @classmethod
3508 def create(cls, target_user_group, user_group, permission):
3509 n = cls()
3510 n.target_user_group = target_user_group
3511 n.user_group = user_group
3512 n.permission = permission
3513 Session().add(n)
3514 return n
3515
3516 def __unicode__(self):
3517 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
3518
3519
3520 class UserGroupToPerm(Base, BaseModel):
3521 __tablename__ = 'users_group_to_perm'
3522 __table_args__ = (
3523 UniqueConstraint('users_group_id', 'permission_id',),
3524 base_table_args
3525 )
3526
3527 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3528 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3529 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3530
3531 users_group = relationship('UserGroup')
3532 permission = relationship('Permission')
3533
3534
3535 class UserRepoGroupToPerm(Base, BaseModel):
3536 __tablename__ = 'user_repo_group_to_perm'
3537 __table_args__ = (
3538 UniqueConstraint('user_id', 'group_id', 'permission_id'),
3539 base_table_args
3540 )
3541
3542 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3543 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3544 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3545 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3546
3547 user = relationship('User')
3548 group = relationship('RepoGroup')
3549 permission = relationship('Permission')
3550
3551 @classmethod
3552 def create(cls, user, repository_group, permission):
3553 n = cls()
3554 n.user = user
3555 n.group = repository_group
3556 n.permission = permission
3557 Session().add(n)
3558 return n
3559
3560
3561 class UserGroupRepoGroupToPerm(Base, BaseModel):
3562 __tablename__ = 'users_group_repo_group_to_perm'
3563 __table_args__ = (
3564 UniqueConstraint('users_group_id', 'group_id'),
3565 base_table_args
3566 )
3567
3568 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)
3569 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3570 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3571 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3572
3573 users_group = relationship('UserGroup')
3574 permission = relationship('Permission')
3575 group = relationship('RepoGroup')
3576
3577 @classmethod
3578 def create(cls, user_group, repository_group, permission):
3579 n = cls()
3580 n.users_group = user_group
3581 n.group = repository_group
3582 n.permission = permission
3583 Session().add(n)
3584 return n
3585
3586 def __unicode__(self):
3587 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
3588
3589
3590 class Statistics(Base, BaseModel):
3591 __tablename__ = 'statistics'
3592 __table_args__ = (
3593 base_table_args
3594 )
3595
3596 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3597 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
3598 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
3599 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
3600 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
3601 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
3602
3603 repository = relationship('Repository', single_parent=True)
3604
3605
3606 class UserFollowing(Base, BaseModel):
3607 __tablename__ = 'user_followings'
3608 __table_args__ = (
3609 UniqueConstraint('user_id', 'follows_repository_id'),
3610 UniqueConstraint('user_id', 'follows_user_id'),
3611 base_table_args
3612 )
3613
3614 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3615 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3616 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
3617 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
3618 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
3619
3620 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
3621
3622 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
3623 follows_repository = relationship('Repository', order_by='Repository.repo_name')
3624
3625 @classmethod
3626 def get_repo_followers(cls, repo_id):
3627 return cls.query().filter(cls.follows_repo_id == repo_id)
3628
3629
3630 class CacheKey(Base, BaseModel):
3631 __tablename__ = 'cache_invalidation'
3632 __table_args__ = (
3633 UniqueConstraint('cache_key'),
3634 Index('key_idx', 'cache_key'),
3635 base_table_args,
3636 )
3637
3638 CACHE_TYPE_FEED = 'FEED'
3639
3640 # namespaces used to register process/thread aware caches
3641 REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}'
3642 SETTINGS_INVALIDATION_NAMESPACE = 'system_settings'
3643
3644 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3645 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
3646 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
3647 cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None)
3648 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
3649
3650 def __init__(self, cache_key, cache_args='', cache_state_uid=None):
3651 self.cache_key = cache_key
3652 self.cache_args = cache_args
3653 self.cache_active = False
3654 # first key should be same for all entries, since all workers should share it
3655 self.cache_state_uid = cache_state_uid or self.generate_new_state_uid()
3656
3657 def __unicode__(self):
3658 return u"<%s('%s:%s[%s]')>" % (
3659 self.__class__.__name__,
3660 self.cache_id, self.cache_key, self.cache_active)
3661
3662 def _cache_key_partition(self):
3663 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
3664 return prefix, repo_name, suffix
3665
3666 def get_prefix(self):
3667 """
3668 Try to extract prefix from existing cache key. The key could consist
3669 of prefix, repo_name, suffix
3670 """
3671 # this returns prefix, repo_name, suffix
3672 return self._cache_key_partition()[0]
3673
3674 def get_suffix(self):
3675 """
3676 get suffix that might have been used in _get_cache_key to
3677 generate self.cache_key. Only used for informational purposes
3678 in repo_edit.mako.
3679 """
3680 # prefix, repo_name, suffix
3681 return self._cache_key_partition()[2]
3682
3683 @classmethod
3684 def generate_new_state_uid(cls, based_on=None):
3685 if based_on:
3686 return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on)))
3687 else:
3688 return str(uuid.uuid4())
3689
3690 @classmethod
3691 def delete_all_cache(cls):
3692 """
3693 Delete all cache keys from database.
3694 Should only be run when all instances are down and all entries
3695 thus stale.
3696 """
3697 cls.query().delete()
3698 Session().commit()
3699
3700 @classmethod
3701 def set_invalidate(cls, cache_uid, delete=False):
3702 """
3703 Mark all caches of a repo as invalid in the database.
3704 """
3705
3706 try:
3707 qry = Session().query(cls).filter(cls.cache_args == cache_uid)
3708 if delete:
3709 qry.delete()
3710 log.debug('cache objects deleted for cache args %s',
3711 safe_str(cache_uid))
3712 else:
3713 qry.update({"cache_active": False,
3714 "cache_state_uid": cls.generate_new_state_uid()})
3715 log.debug('cache objects marked as invalid for cache args %s',
3716 safe_str(cache_uid))
3717
3718 Session().commit()
3719 except Exception:
3720 log.exception(
3721 'Cache key invalidation failed for cache args %s',
3722 safe_str(cache_uid))
3723 Session().rollback()
3724
3725 @classmethod
3726 def get_active_cache(cls, cache_key):
3727 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
3728 if inv_obj:
3729 return inv_obj
3730 return None
3731
3732 @classmethod
3733 def get_namespace_map(cls, namespace):
3734 return {
3735 x.cache_key: x
3736 for x in cls.query().filter(cls.cache_args == namespace)}
3737
3738
3739 class ChangesetComment(Base, BaseModel):
3740 __tablename__ = 'changeset_comments'
3741 __table_args__ = (
3742 Index('cc_revision_idx', 'revision'),
3743 base_table_args,
3744 )
3745
3746 COMMENT_OUTDATED = u'comment_outdated'
3747 COMMENT_TYPE_NOTE = u'note'
3748 COMMENT_TYPE_TODO = u'todo'
3749 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3750
3751 OP_IMMUTABLE = u'immutable'
3752 OP_CHANGEABLE = u'changeable'
3753
3754 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3755 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3756 revision = Column('revision', String(40), nullable=True)
3757 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3758 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3759 line_no = Column('line_no', Unicode(10), nullable=True)
3760 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3761 f_path = Column('f_path', Unicode(1000), nullable=True)
3762 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3763 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3764 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3765 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3766 renderer = Column('renderer', Unicode(64), nullable=True)
3767 display_state = Column('display_state', Unicode(128), nullable=True)
3768 immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE)
3769
3770 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3771 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3772
3773 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by')
3774 resolved_by = relationship('ChangesetComment', back_populates='resolved_comment')
3775
3776 author = relationship('User', lazy='joined')
3777 repo = relationship('Repository')
3778 status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='joined')
3779 pull_request = relationship('PullRequest', lazy='joined')
3780 pull_request_version = relationship('PullRequestVersion')
3781 history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='joined', order_by='ChangesetCommentHistory.version')
3782
3783 @classmethod
3784 def get_users(cls, revision=None, pull_request_id=None):
3785 """
3786 Returns user associated with this ChangesetComment. ie those
3787 who actually commented
3788
3789 :param cls:
3790 :param revision:
3791 """
3792 q = Session().query(User)\
3793 .join(ChangesetComment.author)
3794 if revision:
3795 q = q.filter(cls.revision == revision)
3796 elif pull_request_id:
3797 q = q.filter(cls.pull_request_id == pull_request_id)
3798 return q.all()
3799
3800 @classmethod
3801 def get_index_from_version(cls, pr_version, versions):
3802 num_versions = [x.pull_request_version_id for x in versions]
3803 try:
3804 return num_versions.index(pr_version) + 1
3805 except (IndexError, ValueError):
3806 return
3807
3808 @property
3809 def outdated(self):
3810 return self.display_state == self.COMMENT_OUTDATED
3811
3812 @property
3813 def immutable(self):
3814 return self.immutable_state == self.OP_IMMUTABLE
3815
3816 def outdated_at_version(self, version):
3817 """
3818 Checks if comment is outdated for given pull request version
3819 """
3820 return self.outdated and self.pull_request_version_id != version
3821
3822 def older_than_version(self, version):
3823 """
3824 Checks if comment is made from previous version than given
3825 """
3826 if version is None:
3827 return self.pull_request_version_id is not None
3828
3829 return self.pull_request_version_id < version
3830
3831 @property
3832 def commit_id(self):
3833 """New style naming to stop using .revision"""
3834 return self.revision
3835
3836 @property
3837 def resolved(self):
3838 return self.resolved_by[0] if self.resolved_by else None
3839
3840 @property
3841 def is_todo(self):
3842 return self.comment_type == self.COMMENT_TYPE_TODO
3843
3844 @property
3845 def is_inline(self):
3846 return self.line_no and self.f_path
3847
3848 @property
3849 def last_version(self):
3850 version = 0
3851 if self.history:
3852 version = self.history[-1].version
3853 return version
3854
3855 def get_index_version(self, versions):
3856 return self.get_index_from_version(
3857 self.pull_request_version_id, versions)
3858
3859 def __repr__(self):
3860 if self.comment_id:
3861 return '<DB:Comment #%s>' % self.comment_id
3862 else:
3863 return '<DB:Comment at %#x>' % id(self)
3864
3865 def get_api_data(self):
3866 comment = self
3867
3868 data = {
3869 'comment_id': comment.comment_id,
3870 'comment_type': comment.comment_type,
3871 'comment_text': comment.text,
3872 'comment_status': comment.status_change,
3873 'comment_f_path': comment.f_path,
3874 'comment_lineno': comment.line_no,
3875 'comment_author': comment.author,
3876 'comment_created_on': comment.created_on,
3877 'comment_resolved_by': self.resolved,
3878 'comment_commit_id': comment.revision,
3879 'comment_pull_request_id': comment.pull_request_id,
3880 'comment_last_version': self.last_version
3881 }
3882 return data
3883
3884 def __json__(self):
3885 data = dict()
3886 data.update(self.get_api_data())
3887 return data
3888
3889
3890 class ChangesetCommentHistory(Base, BaseModel):
3891 __tablename__ = 'changeset_comments_history'
3892 __table_args__ = (
3893 Index('cch_comment_id_idx', 'comment_id'),
3894 base_table_args,
3895 )
3896
3897 comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True)
3898 comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)
3899 version = Column("version", Integer(), nullable=False, default=0)
3900 created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3901 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3902 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3903 deleted = Column('deleted', Boolean(), default=False)
3904
3905 author = relationship('User', lazy='joined')
3906 comment = relationship('ChangesetComment', cascade="all, delete")
3907
3908 @classmethod
3909 def get_version(cls, comment_id):
3910 q = Session().query(ChangesetCommentHistory).filter(
3911 ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc())
3912 if q.count() == 0:
3913 return 1
3914 elif q.count() >= q[0].version:
3915 return q.count() + 1
3916 else:
3917 return q[0].version + 1
3918
3919
3920 class ChangesetStatus(Base, BaseModel):
3921 __tablename__ = 'changeset_statuses'
3922 __table_args__ = (
3923 Index('cs_revision_idx', 'revision'),
3924 Index('cs_version_idx', 'version'),
3925 UniqueConstraint('repo_id', 'revision', 'version'),
3926 base_table_args
3927 )
3928
3929 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3930 STATUS_APPROVED = 'approved'
3931 STATUS_REJECTED = 'rejected'
3932 STATUS_UNDER_REVIEW = 'under_review'
3933
3934 STATUSES = [
3935 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3936 (STATUS_APPROVED, _("Approved")),
3937 (STATUS_REJECTED, _("Rejected")),
3938 (STATUS_UNDER_REVIEW, _("Under Review")),
3939 ]
3940
3941 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3942 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3943 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3944 revision = Column('revision', String(40), nullable=False)
3945 status = Column('status', String(128), nullable=False, default=DEFAULT)
3946 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3947 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3948 version = Column('version', Integer(), nullable=False, default=0)
3949 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3950
3951 author = relationship('User', lazy='joined')
3952 repo = relationship('Repository')
3953 comment = relationship('ChangesetComment', lazy='joined')
3954 pull_request = relationship('PullRequest', lazy='joined')
3955
3956 def __unicode__(self):
3957 return u"<%s('%s[v%s]:%s')>" % (
3958 self.__class__.__name__,
3959 self.status, self.version, self.author
3960 )
3961
3962 @classmethod
3963 def get_status_lbl(cls, value):
3964 return dict(cls.STATUSES).get(value)
3965
3966 @property
3967 def status_lbl(self):
3968 return ChangesetStatus.get_status_lbl(self.status)
3969
3970 def get_api_data(self):
3971 status = self
3972 data = {
3973 'status_id': status.changeset_status_id,
3974 'status': status.status,
3975 }
3976 return data
3977
3978 def __json__(self):
3979 data = dict()
3980 data.update(self.get_api_data())
3981 return data
3982
3983
3984 class _SetState(object):
3985 """
3986 Context processor allowing changing state for sensitive operation such as
3987 pull request update or merge
3988 """
3989
3990 def __init__(self, pull_request, pr_state, back_state=None):
3991 self._pr = pull_request
3992 self._org_state = back_state or pull_request.pull_request_state
3993 self._pr_state = pr_state
3994 self._current_state = None
3995
3996 def __enter__(self):
3997 log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`',
3998 self._pr, self._pr_state)
3999 self.set_pr_state(self._pr_state)
4000 return self
4001
4002 def __exit__(self, exc_type, exc_val, exc_tb):
4003 if exc_val is not None:
4004 log.error(traceback.format_exc(exc_tb))
4005 return None
4006
4007 self.set_pr_state(self._org_state)
4008 log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`',
4009 self._pr, self._org_state)
4010
4011 @property
4012 def state(self):
4013 return self._current_state
4014
4015 def set_pr_state(self, pr_state):
4016 try:
4017 self._pr.pull_request_state = pr_state
4018 Session().add(self._pr)
4019 Session().commit()
4020 self._current_state = pr_state
4021 except Exception:
4022 log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state)
4023 raise
4024
4025
4026 class _PullRequestBase(BaseModel):
4027 """
4028 Common attributes of pull request and version entries.
4029 """
4030
4031 # .status values
4032 STATUS_NEW = u'new'
4033 STATUS_OPEN = u'open'
4034 STATUS_CLOSED = u'closed'
4035
4036 # available states
4037 STATE_CREATING = u'creating'
4038 STATE_UPDATING = u'updating'
4039 STATE_MERGING = u'merging'
4040 STATE_CREATED = u'created'
4041
4042 title = Column('title', Unicode(255), nullable=True)
4043 description = Column(
4044 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
4045 nullable=True)
4046 description_renderer = Column('description_renderer', Unicode(64), nullable=True)
4047
4048 # new/open/closed status of pull request (not approve/reject/etc)
4049 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
4050 created_on = Column(
4051 'created_on', DateTime(timezone=False), nullable=False,
4052 default=datetime.datetime.now)
4053 updated_on = Column(
4054 'updated_on', DateTime(timezone=False), nullable=False,
4055 default=datetime.datetime.now)
4056
4057 pull_request_state = Column("pull_request_state", String(255), nullable=True)
4058
4059 @declared_attr
4060 def user_id(cls):
4061 return Column(
4062 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
4063 unique=None)
4064
4065 # 500 revisions max
4066 _revisions = Column(
4067 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
4068
4069 common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True)
4070
4071 @declared_attr
4072 def source_repo_id(cls):
4073 # TODO: dan: rename column to source_repo_id
4074 return Column(
4075 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
4076 nullable=False)
4077
4078 _source_ref = Column('org_ref', Unicode(255), nullable=False)
4079
4080 @hybrid_property
4081 def source_ref(self):
4082 return self._source_ref
4083
4084 @source_ref.setter
4085 def source_ref(self, val):
4086 parts = (val or '').split(':')
4087 if len(parts) != 3:
4088 raise ValueError(
4089 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
4090 self._source_ref = safe_unicode(val)
4091
4092 _target_ref = Column('other_ref', Unicode(255), nullable=False)
4093
4094 @hybrid_property
4095 def target_ref(self):
4096 return self._target_ref
4097
4098 @target_ref.setter
4099 def target_ref(self, val):
4100 parts = (val or '').split(':')
4101 if len(parts) != 3:
4102 raise ValueError(
4103 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
4104 self._target_ref = safe_unicode(val)
4105
4106 @declared_attr
4107 def target_repo_id(cls):
4108 # TODO: dan: rename column to target_repo_id
4109 return Column(
4110 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
4111 nullable=False)
4112
4113 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
4114
4115 # TODO: dan: rename column to last_merge_source_rev
4116 _last_merge_source_rev = Column(
4117 'last_merge_org_rev', String(40), nullable=True)
4118 # TODO: dan: rename column to last_merge_target_rev
4119 _last_merge_target_rev = Column(
4120 'last_merge_other_rev', String(40), nullable=True)
4121 _last_merge_status = Column('merge_status', Integer(), nullable=True)
4122 last_merge_metadata = Column(
4123 'last_merge_metadata', MutationObj.as_mutable(
4124 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4125
4126 merge_rev = Column('merge_rev', String(40), nullable=True)
4127
4128 reviewer_data = Column(
4129 'reviewer_data_json', MutationObj.as_mutable(
4130 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4131
4132 @property
4133 def reviewer_data_json(self):
4134 return json.dumps(self.reviewer_data)
4135
4136 @property
4137 def last_merge_metadata_parsed(self):
4138 metadata = {}
4139 if not self.last_merge_metadata:
4140 return metadata
4141
4142 if hasattr(self.last_merge_metadata, 'de_coerce'):
4143 for k, v in self.last_merge_metadata.de_coerce().items():
4144 if k in ['target_ref', 'source_ref']:
4145 metadata[k] = Reference(v['type'], v['name'], v['commit_id'])
4146 else:
4147 if hasattr(v, 'de_coerce'):
4148 metadata[k] = v.de_coerce()
4149 else:
4150 metadata[k] = v
4151 return metadata
4152
4153 @property
4154 def work_in_progress(self):
4155 """checks if pull request is work in progress by checking the title"""
4156 title = self.title.upper()
4157 if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title):
4158 return True
4159 return False
4160
4161 @hybrid_property
4162 def description_safe(self):
4163 from rhodecode.lib import helpers as h
4164 return h.escape(self.description)
4165
4166 @hybrid_property
4167 def revisions(self):
4168 return self._revisions.split(':') if self._revisions else []
4169
4170 @revisions.setter
4171 def revisions(self, val):
4172 self._revisions = u':'.join(val)
4173
4174 @hybrid_property
4175 def last_merge_status(self):
4176 return safe_int(self._last_merge_status)
4177
4178 @last_merge_status.setter
4179 def last_merge_status(self, val):
4180 self._last_merge_status = val
4181
4182 @declared_attr
4183 def author(cls):
4184 return relationship('User', lazy='joined')
4185
4186 @declared_attr
4187 def source_repo(cls):
4188 return relationship(
4189 'Repository',
4190 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
4191
4192 @property
4193 def source_ref_parts(self):
4194 return self.unicode_to_reference(self.source_ref)
4195
4196 @declared_attr
4197 def target_repo(cls):
4198 return relationship(
4199 'Repository',
4200 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
4201
4202 @property
4203 def target_ref_parts(self):
4204 return self.unicode_to_reference(self.target_ref)
4205
4206 @property
4207 def shadow_merge_ref(self):
4208 return self.unicode_to_reference(self._shadow_merge_ref)
4209
4210 @shadow_merge_ref.setter
4211 def shadow_merge_ref(self, ref):
4212 self._shadow_merge_ref = self.reference_to_unicode(ref)
4213
4214 @staticmethod
4215 def unicode_to_reference(raw):
4216 """
4217 Convert a unicode (or string) to a reference object.
4218 If unicode evaluates to False it returns None.
4219 """
4220 if raw:
4221 refs = raw.split(':')
4222 return Reference(*refs)
4223 else:
4224 return None
4225
4226 @staticmethod
4227 def reference_to_unicode(ref):
4228 """
4229 Convert a reference object to unicode.
4230 If reference is None it returns None.
4231 """
4232 if ref:
4233 return u':'.join(ref)
4234 else:
4235 return None
4236
4237 def get_api_data(self, with_merge_state=True):
4238 from rhodecode.model.pull_request import PullRequestModel
4239
4240 pull_request = self
4241 if with_merge_state:
4242 merge_response, merge_status, msg = \
4243 PullRequestModel().merge_status(pull_request)
4244 merge_state = {
4245 'status': merge_status,
4246 'message': safe_unicode(msg),
4247 }
4248 else:
4249 merge_state = {'status': 'not_available',
4250 'message': 'not_available'}
4251
4252 merge_data = {
4253 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
4254 'reference': (
4255 pull_request.shadow_merge_ref._asdict()
4256 if pull_request.shadow_merge_ref else None),
4257 }
4258
4259 data = {
4260 'pull_request_id': pull_request.pull_request_id,
4261 'url': PullRequestModel().get_url(pull_request),
4262 'title': pull_request.title,
4263 'description': pull_request.description,
4264 'status': pull_request.status,
4265 'state': pull_request.pull_request_state,
4266 'created_on': pull_request.created_on,
4267 'updated_on': pull_request.updated_on,
4268 'commit_ids': pull_request.revisions,
4269 'review_status': pull_request.calculated_review_status(),
4270 'mergeable': merge_state,
4271 'source': {
4272 'clone_url': pull_request.source_repo.clone_url(),
4273 'repository': pull_request.source_repo.repo_name,
4274 'reference': {
4275 'name': pull_request.source_ref_parts.name,
4276 'type': pull_request.source_ref_parts.type,
4277 'commit_id': pull_request.source_ref_parts.commit_id,
4278 },
4279 },
4280 'target': {
4281 'clone_url': pull_request.target_repo.clone_url(),
4282 'repository': pull_request.target_repo.repo_name,
4283 'reference': {
4284 'name': pull_request.target_ref_parts.name,
4285 'type': pull_request.target_ref_parts.type,
4286 'commit_id': pull_request.target_ref_parts.commit_id,
4287 },
4288 },
4289 'merge': merge_data,
4290 'author': pull_request.author.get_api_data(include_secrets=False,
4291 details='basic'),
4292 'reviewers': [
4293 {
4294 'user': reviewer.get_api_data(include_secrets=False,
4295 details='basic'),
4296 'reasons': reasons,
4297 'review_status': st[0][1].status if st else 'not_reviewed',
4298 }
4299 for obj, reviewer, reasons, mandatory, st in
4300 pull_request.reviewers_statuses()
4301 ]
4302 }
4303
4304 return data
4305
4306 def set_state(self, pull_request_state, final_state=None):
4307 """
4308 # goes from initial state to updating to initial state.
4309 # initial state can be changed by specifying back_state=
4310 with pull_request_obj.set_state(PullRequest.STATE_UPDATING):
4311 pull_request.merge()
4312
4313 :param pull_request_state:
4314 :param final_state:
4315
4316 """
4317
4318 return _SetState(self, pull_request_state, back_state=final_state)
4319
4320
4321 class PullRequest(Base, _PullRequestBase):
4322 __tablename__ = 'pull_requests'
4323 __table_args__ = (
4324 base_table_args,
4325 )
4326
4327 pull_request_id = Column(
4328 'pull_request_id', Integer(), nullable=False, primary_key=True)
4329
4330 def __repr__(self):
4331 if self.pull_request_id:
4332 return '<DB:PullRequest #%s>' % self.pull_request_id
4333 else:
4334 return '<DB:PullRequest at %#x>' % id(self)
4335
4336 reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan")
4337 statuses = relationship('ChangesetStatus', cascade="all, delete-orphan")
4338 comments = relationship('ChangesetComment', cascade="all, delete-orphan")
4339 versions = relationship('PullRequestVersion', cascade="all, delete-orphan",
4340 lazy='dynamic')
4341
4342 @classmethod
4343 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
4344 internal_methods=None):
4345
4346 class PullRequestDisplay(object):
4347 """
4348 Special object wrapper for showing PullRequest data via Versions
4349 It mimics PR object as close as possible. This is read only object
4350 just for display
4351 """
4352
4353 def __init__(self, attrs, internal=None):
4354 self.attrs = attrs
4355 # internal have priority over the given ones via attrs
4356 self.internal = internal or ['versions']
4357
4358 def __getattr__(self, item):
4359 if item in self.internal:
4360 return getattr(self, item)
4361 try:
4362 return self.attrs[item]
4363 except KeyError:
4364 raise AttributeError(
4365 '%s object has no attribute %s' % (self, item))
4366
4367 def __repr__(self):
4368 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
4369
4370 def versions(self):
4371 return pull_request_obj.versions.order_by(
4372 PullRequestVersion.pull_request_version_id).all()
4373
4374 def is_closed(self):
4375 return pull_request_obj.is_closed()
4376
4377 def is_state_changing(self):
4378 return pull_request_obj.is_state_changing()
4379
4380 @property
4381 def pull_request_version_id(self):
4382 return getattr(pull_request_obj, 'pull_request_version_id', None)
4383
4384 attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False))
4385
4386 attrs.author = StrictAttributeDict(
4387 pull_request_obj.author.get_api_data())
4388 if pull_request_obj.target_repo:
4389 attrs.target_repo = StrictAttributeDict(
4390 pull_request_obj.target_repo.get_api_data())
4391 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
4392
4393 if pull_request_obj.source_repo:
4394 attrs.source_repo = StrictAttributeDict(
4395 pull_request_obj.source_repo.get_api_data())
4396 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
4397
4398 attrs.source_ref_parts = pull_request_obj.source_ref_parts
4399 attrs.target_ref_parts = pull_request_obj.target_ref_parts
4400 attrs.revisions = pull_request_obj.revisions
4401 attrs.common_ancestor_id = pull_request_obj.common_ancestor_id
4402 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
4403 attrs.reviewer_data = org_pull_request_obj.reviewer_data
4404 attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
4405
4406 return PullRequestDisplay(attrs, internal=internal_methods)
4407
4408 def is_closed(self):
4409 return self.status == self.STATUS_CLOSED
4410
4411 def is_state_changing(self):
4412 return self.pull_request_state != PullRequest.STATE_CREATED
4413
4414 def __json__(self):
4415 return {
4416 'revisions': self.revisions,
4417 'versions': self.versions_count
4418 }
4419
4420 def calculated_review_status(self):
4421 from rhodecode.model.changeset_status import ChangesetStatusModel
4422 return ChangesetStatusModel().calculated_review_status(self)
4423
4424 def reviewers_statuses(self):
4425 from rhodecode.model.changeset_status import ChangesetStatusModel
4426 return ChangesetStatusModel().reviewers_statuses(self)
4427
4428 @property
4429 def workspace_id(self):
4430 from rhodecode.model.pull_request import PullRequestModel
4431 return PullRequestModel()._workspace_id(self)
4432
4433 def get_shadow_repo(self):
4434 workspace_id = self.workspace_id
4435 shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id)
4436 if os.path.isdir(shadow_repository_path):
4437 vcs_obj = self.target_repo.scm_instance()
4438 return vcs_obj.get_shadow_instance(shadow_repository_path)
4439
4440 @property
4441 def versions_count(self):
4442 """
4443 return number of versions this PR have, e.g a PR that once been
4444 updated will have 2 versions
4445 """
4446 return self.versions.count() + 1
4447
4448
4449 class PullRequestVersion(Base, _PullRequestBase):
4450 __tablename__ = 'pull_request_versions'
4451 __table_args__ = (
4452 base_table_args,
4453 )
4454
4455 pull_request_version_id = Column(
4456 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
4457 pull_request_id = Column(
4458 'pull_request_id', Integer(),
4459 ForeignKey('pull_requests.pull_request_id'), nullable=False)
4460 pull_request = relationship('PullRequest')
4461
4462 def __repr__(self):
4463 if self.pull_request_version_id:
4464 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
4465 else:
4466 return '<DB:PullRequestVersion at %#x>' % id(self)
4467
4468 @property
4469 def reviewers(self):
4470 return self.pull_request.reviewers
4471
4472 @property
4473 def versions(self):
4474 return self.pull_request.versions
4475
4476 def is_closed(self):
4477 # calculate from original
4478 return self.pull_request.status == self.STATUS_CLOSED
4479
4480 def is_state_changing(self):
4481 return self.pull_request.pull_request_state != PullRequest.STATE_CREATED
4482
4483 def calculated_review_status(self):
4484 return self.pull_request.calculated_review_status()
4485
4486 def reviewers_statuses(self):
4487 return self.pull_request.reviewers_statuses()
4488
4489
4490 class PullRequestReviewers(Base, BaseModel):
4491 __tablename__ = 'pull_request_reviewers'
4492 __table_args__ = (
4493 base_table_args,
4494 )
4495
4496 @hybrid_property
4497 def reasons(self):
4498 if not self._reasons:
4499 return []
4500 return self._reasons
4501
4502 @reasons.setter
4503 def reasons(self, val):
4504 val = val or []
4505 if any(not isinstance(x, compat.string_types) for x in val):
4506 raise Exception('invalid reasons type, must be list of strings')
4507 self._reasons = val
4508
4509 pull_requests_reviewers_id = Column(
4510 'pull_requests_reviewers_id', Integer(), nullable=False,
4511 primary_key=True)
4512 pull_request_id = Column(
4513 "pull_request_id", Integer(),
4514 ForeignKey('pull_requests.pull_request_id'), nullable=False)
4515 user_id = Column(
4516 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
4517 _reasons = Column(
4518 'reason', MutationList.as_mutable(
4519 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
4520
4521 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4522 user = relationship('User')
4523 pull_request = relationship('PullRequest')
4524
4525 rule_data = Column(
4526 'rule_data_json',
4527 JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
4528
4529 def rule_user_group_data(self):
4530 """
4531 Returns the voting user group rule data for this reviewer
4532 """
4533
4534 if self.rule_data and 'vote_rule' in self.rule_data:
4535 user_group_data = {}
4536 if 'rule_user_group_entry_id' in self.rule_data:
4537 # means a group with voting rules !
4538 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
4539 user_group_data['name'] = self.rule_data['rule_name']
4540 user_group_data['vote_rule'] = self.rule_data['vote_rule']
4541
4542 return user_group_data
4543
4544 def __unicode__(self):
4545 return u"<%s('id:%s')>" % (self.__class__.__name__,
4546 self.pull_requests_reviewers_id)
4547
4548
4549 class Notification(Base, BaseModel):
4550 __tablename__ = 'notifications'
4551 __table_args__ = (
4552 Index('notification_type_idx', 'type'),
4553 base_table_args,
4554 )
4555
4556 TYPE_CHANGESET_COMMENT = u'cs_comment'
4557 TYPE_MESSAGE = u'message'
4558 TYPE_MENTION = u'mention'
4559 TYPE_REGISTRATION = u'registration'
4560 TYPE_PULL_REQUEST = u'pull_request'
4561 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
4562 TYPE_PULL_REQUEST_UPDATE = u'pull_request_update'
4563
4564 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
4565 subject = Column('subject', Unicode(512), nullable=True)
4566 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
4567 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
4568 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4569 type_ = Column('type', Unicode(255))
4570
4571 created_by_user = relationship('User')
4572 notifications_to_users = relationship('UserNotification', lazy='joined',
4573 cascade="all, delete-orphan")
4574
4575 @property
4576 def recipients(self):
4577 return [x.user for x in UserNotification.query()\
4578 .filter(UserNotification.notification == self)\
4579 .order_by(UserNotification.user_id.asc()).all()]
4580
4581 @classmethod
4582 def create(cls, created_by, subject, body, recipients, type_=None):
4583 if type_ is None:
4584 type_ = Notification.TYPE_MESSAGE
4585
4586 notification = cls()
4587 notification.created_by_user = created_by
4588 notification.subject = subject
4589 notification.body = body
4590 notification.type_ = type_
4591 notification.created_on = datetime.datetime.now()
4592
4593 # For each recipient link the created notification to his account
4594 for u in recipients:
4595 assoc = UserNotification()
4596 assoc.user_id = u.user_id
4597 assoc.notification = notification
4598
4599 # if created_by is inside recipients mark his notification
4600 # as read
4601 if u.user_id == created_by.user_id:
4602 assoc.read = True
4603 Session().add(assoc)
4604
4605 Session().add(notification)
4606
4607 return notification
4608
4609
4610 class UserNotification(Base, BaseModel):
4611 __tablename__ = 'user_to_notification'
4612 __table_args__ = (
4613 UniqueConstraint('user_id', 'notification_id'),
4614 base_table_args
4615 )
4616
4617 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4618 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
4619 read = Column('read', Boolean, default=False)
4620 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
4621
4622 user = relationship('User', lazy="joined")
4623 notification = relationship('Notification', lazy="joined",
4624 order_by=lambda: Notification.created_on.desc(),)
4625
4626 def mark_as_read(self):
4627 self.read = True
4628 Session().add(self)
4629
4630
4631 class UserNotice(Base, BaseModel):
4632 __tablename__ = 'user_notices'
4633 __table_args__ = (
4634 base_table_args
4635 )
4636
4637 NOTIFICATION_TYPE_MESSAGE = 'message'
4638 NOTIFICATION_TYPE_NOTICE = 'notice'
4639
4640 NOTIFICATION_LEVEL_INFO = 'info'
4641 NOTIFICATION_LEVEL_WARNING = 'warning'
4642 NOTIFICATION_LEVEL_ERROR = 'error'
4643
4644 user_notice_id = Column('gist_id', Integer(), primary_key=True)
4645
4646 notice_subject = Column('notice_subject', Unicode(512), nullable=True)
4647 notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
4648
4649 notice_read = Column('notice_read', Boolean, default=False)
4650
4651 notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO)
4652 notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE)
4653
4654 notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True)
4655 notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4656
4657 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'))
4658 user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id')
4659
4660 @classmethod
4661 def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False):
4662
4663 if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR,
4664 cls.NOTIFICATION_LEVEL_WARNING,
4665 cls.NOTIFICATION_LEVEL_INFO]:
4666 return
4667
4668 from rhodecode.model.user import UserModel
4669 user = UserModel().get_user(user)
4670
4671 new_notice = UserNotice()
4672 if not allow_duplicate:
4673 existing_msg = UserNotice().query() \
4674 .filter(UserNotice.user == user) \
4675 .filter(UserNotice.notice_body == body) \
4676 .filter(UserNotice.notice_read == false()) \
4677 .scalar()
4678 if existing_msg:
4679 log.warning('Ignoring duplicate notice for user %s', user)
4680 return
4681
4682 new_notice.user = user
4683 new_notice.notice_subject = subject
4684 new_notice.notice_body = body
4685 new_notice.notification_level = notice_level
4686 Session().add(new_notice)
4687 Session().commit()
4688
4689
4690 class Gist(Base, BaseModel):
4691 __tablename__ = 'gists'
4692 __table_args__ = (
4693 Index('g_gist_access_id_idx', 'gist_access_id'),
4694 Index('g_created_on_idx', 'created_on'),
4695 base_table_args
4696 )
4697
4698 GIST_PUBLIC = u'public'
4699 GIST_PRIVATE = u'private'
4700 DEFAULT_FILENAME = u'gistfile1.txt'
4701
4702 ACL_LEVEL_PUBLIC = u'acl_public'
4703 ACL_LEVEL_PRIVATE = u'acl_private'
4704
4705 gist_id = Column('gist_id', Integer(), primary_key=True)
4706 gist_access_id = Column('gist_access_id', Unicode(250))
4707 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
4708 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
4709 gist_expires = Column('gist_expires', Float(53), nullable=False)
4710 gist_type = Column('gist_type', Unicode(128), nullable=False)
4711 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4712 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4713 acl_level = Column('acl_level', Unicode(128), nullable=True)
4714
4715 owner = relationship('User')
4716
4717 def __repr__(self):
4718 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
4719
4720 @hybrid_property
4721 def description_safe(self):
4722 from rhodecode.lib import helpers as h
4723 return h.escape(self.gist_description)
4724
4725 @classmethod
4726 def get_or_404(cls, id_):
4727 from pyramid.httpexceptions import HTTPNotFound
4728
4729 res = cls.query().filter(cls.gist_access_id == id_).scalar()
4730 if not res:
4731 raise HTTPNotFound()
4732 return res
4733
4734 @classmethod
4735 def get_by_access_id(cls, gist_access_id):
4736 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
4737
4738 def gist_url(self):
4739 from rhodecode.model.gist import GistModel
4740 return GistModel().get_url(self)
4741
4742 @classmethod
4743 def base_path(cls):
4744 """
4745 Returns base path when all gists are stored
4746
4747 :param cls:
4748 """
4749 from rhodecode.model.gist import GIST_STORE_LOC
4750 q = Session().query(RhodeCodeUi)\
4751 .filter(RhodeCodeUi.ui_key == URL_SEP)
4752 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
4753 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
4754
4755 def get_api_data(self):
4756 """
4757 Common function for generating gist related data for API
4758 """
4759 gist = self
4760 data = {
4761 'gist_id': gist.gist_id,
4762 'type': gist.gist_type,
4763 'access_id': gist.gist_access_id,
4764 'description': gist.gist_description,
4765 'url': gist.gist_url(),
4766 'expires': gist.gist_expires,
4767 'created_on': gist.created_on,
4768 'modified_at': gist.modified_at,
4769 'content': None,
4770 'acl_level': gist.acl_level,
4771 }
4772 return data
4773
4774 def __json__(self):
4775 data = dict(
4776 )
4777 data.update(self.get_api_data())
4778 return data
4779 # SCM functions
4780
4781 def scm_instance(self, **kwargs):
4782 """
4783 Get an instance of VCS Repository
4784
4785 :param kwargs:
4786 """
4787 from rhodecode.model.gist import GistModel
4788 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
4789 return get_vcs_instance(
4790 repo_path=safe_str(full_repo_path), create=False,
4791 _vcs_alias=GistModel.vcs_backend)
4792
4793
4794 class ExternalIdentity(Base, BaseModel):
4795 __tablename__ = 'external_identities'
4796 __table_args__ = (
4797 Index('local_user_id_idx', 'local_user_id'),
4798 Index('external_id_idx', 'external_id'),
4799 base_table_args
4800 )
4801
4802 external_id = Column('external_id', Unicode(255), default=u'', primary_key=True)
4803 external_username = Column('external_username', Unicode(1024), default=u'')
4804 local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4805 provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True)
4806 access_token = Column('access_token', String(1024), default=u'')
4807 alt_token = Column('alt_token', String(1024), default=u'')
4808 token_secret = Column('token_secret', String(1024), default=u'')
4809
4810 @classmethod
4811 def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None):
4812 """
4813 Returns ExternalIdentity instance based on search params
4814
4815 :param external_id:
4816 :param provider_name:
4817 :return: ExternalIdentity
4818 """
4819 query = cls.query()
4820 query = query.filter(cls.external_id == external_id)
4821 query = query.filter(cls.provider_name == provider_name)
4822 if local_user_id:
4823 query = query.filter(cls.local_user_id == local_user_id)
4824 return query.first()
4825
4826 @classmethod
4827 def user_by_external_id_and_provider(cls, external_id, provider_name):
4828 """
4829 Returns User instance based on search params
4830
4831 :param external_id:
4832 :param provider_name:
4833 :return: User
4834 """
4835 query = User.query()
4836 query = query.filter(cls.external_id == external_id)
4837 query = query.filter(cls.provider_name == provider_name)
4838 query = query.filter(User.user_id == cls.local_user_id)
4839 return query.first()
4840
4841 @classmethod
4842 def by_local_user_id(cls, local_user_id):
4843 """
4844 Returns all tokens for user
4845
4846 :param local_user_id:
4847 :return: ExternalIdentity
4848 """
4849 query = cls.query()
4850 query = query.filter(cls.local_user_id == local_user_id)
4851 return query
4852
4853 @classmethod
4854 def load_provider_plugin(cls, plugin_id):
4855 from rhodecode.authentication.base import loadplugin
4856 _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id)
4857 auth_plugin = loadplugin(_plugin_id)
4858 return auth_plugin
4859
4860
4861 class Integration(Base, BaseModel):
4862 __tablename__ = 'integrations'
4863 __table_args__ = (
4864 base_table_args
4865 )
4866
4867 integration_id = Column('integration_id', Integer(), primary_key=True)
4868 integration_type = Column('integration_type', String(255))
4869 enabled = Column('enabled', Boolean(), nullable=False)
4870 name = Column('name', String(255), nullable=False)
4871 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
4872 default=False)
4873
4874 settings = Column(
4875 'settings_json', MutationObj.as_mutable(
4876 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4877 repo_id = Column(
4878 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
4879 nullable=True, unique=None, default=None)
4880 repo = relationship('Repository', lazy='joined')
4881
4882 repo_group_id = Column(
4883 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
4884 nullable=True, unique=None, default=None)
4885 repo_group = relationship('RepoGroup', lazy='joined')
4886
4887 @property
4888 def scope(self):
4889 if self.repo:
4890 return repr(self.repo)
4891 if self.repo_group:
4892 if self.child_repos_only:
4893 return repr(self.repo_group) + ' (child repos only)'
4894 else:
4895 return repr(self.repo_group) + ' (recursive)'
4896 if self.child_repos_only:
4897 return 'root_repos'
4898 return 'global'
4899
4900 def __repr__(self):
4901 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
4902
4903
4904 class RepoReviewRuleUser(Base, BaseModel):
4905 __tablename__ = 'repo_review_rules_users'
4906 __table_args__ = (
4907 base_table_args
4908 )
4909
4910 repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
4911 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4912 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
4913 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4914 user = relationship('User')
4915
4916 def rule_data(self):
4917 return {
4918 'mandatory': self.mandatory
4919 }
4920
4921
4922 class RepoReviewRuleUserGroup(Base, BaseModel):
4923 __tablename__ = 'repo_review_rules_users_groups'
4924 __table_args__ = (
4925 base_table_args
4926 )
4927
4928 VOTE_RULE_ALL = -1
4929
4930 repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
4931 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4932 users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
4933 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4934 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
4935 users_group = relationship('UserGroup')
4936
4937 def rule_data(self):
4938 return {
4939 'mandatory': self.mandatory,
4940 'vote_rule': self.vote_rule
4941 }
4942
4943 @property
4944 def vote_rule_label(self):
4945 if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
4946 return 'all must vote'
4947 else:
4948 return 'min. vote {}'.format(self.vote_rule)
4949
4950
4951 class RepoReviewRule(Base, BaseModel):
4952 __tablename__ = 'repo_review_rules'
4953 __table_args__ = (
4954 base_table_args
4955 )
4956
4957 repo_review_rule_id = Column(
4958 'repo_review_rule_id', Integer(), primary_key=True)
4959 repo_id = Column(
4960 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
4961 repo = relationship('Repository', backref='review_rules')
4962
4963 review_rule_name = Column('review_rule_name', String(255))
4964 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4965 _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4966 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4967
4968 use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
4969 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
4970 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
4971 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
4972
4973 rule_users = relationship('RepoReviewRuleUser')
4974 rule_user_groups = relationship('RepoReviewRuleUserGroup')
4975
4976 def _validate_pattern(self, value):
4977 re.compile('^' + glob2re(value) + '$')
4978
4979 @hybrid_property
4980 def source_branch_pattern(self):
4981 return self._branch_pattern or '*'
4982
4983 @source_branch_pattern.setter
4984 def source_branch_pattern(self, value):
4985 self._validate_pattern(value)
4986 self._branch_pattern = value or '*'
4987
4988 @hybrid_property
4989 def target_branch_pattern(self):
4990 return self._target_branch_pattern or '*'
4991
4992 @target_branch_pattern.setter
4993 def target_branch_pattern(self, value):
4994 self._validate_pattern(value)
4995 self._target_branch_pattern = value or '*'
4996
4997 @hybrid_property
4998 def file_pattern(self):
4999 return self._file_pattern or '*'
5000
5001 @file_pattern.setter
5002 def file_pattern(self, value):
5003 self._validate_pattern(value)
5004 self._file_pattern = value or '*'
5005
5006 def matches(self, source_branch, target_branch, files_changed):
5007 """
5008 Check if this review rule matches a branch/files in a pull request
5009
5010 :param source_branch: source branch name for the commit
5011 :param target_branch: target branch name for the commit
5012 :param files_changed: list of file paths changed in the pull request
5013 """
5014
5015 source_branch = source_branch or ''
5016 target_branch = target_branch or ''
5017 files_changed = files_changed or []
5018
5019 branch_matches = True
5020 if source_branch or target_branch:
5021 if self.source_branch_pattern == '*':
5022 source_branch_match = True
5023 else:
5024 if self.source_branch_pattern.startswith('re:'):
5025 source_pattern = self.source_branch_pattern[3:]
5026 else:
5027 source_pattern = '^' + glob2re(self.source_branch_pattern) + '$'
5028 source_branch_regex = re.compile(source_pattern)
5029 source_branch_match = bool(source_branch_regex.search(source_branch))
5030 if self.target_branch_pattern == '*':
5031 target_branch_match = True
5032 else:
5033 if self.target_branch_pattern.startswith('re:'):
5034 target_pattern = self.target_branch_pattern[3:]
5035 else:
5036 target_pattern = '^' + glob2re(self.target_branch_pattern) + '$'
5037 target_branch_regex = re.compile(target_pattern)
5038 target_branch_match = bool(target_branch_regex.search(target_branch))
5039
5040 branch_matches = source_branch_match and target_branch_match
5041
5042 files_matches = True
5043 if self.file_pattern != '*':
5044 files_matches = False
5045 if self.file_pattern.startswith('re:'):
5046 file_pattern = self.file_pattern[3:]
5047 else:
5048 file_pattern = glob2re(self.file_pattern)
5049 file_regex = re.compile(file_pattern)
5050 for file_data in files_changed:
5051 filename = file_data.get('filename')
5052
5053 if file_regex.search(filename):
5054 files_matches = True
5055 break
5056
5057 return branch_matches and files_matches
5058
5059 @property
5060 def review_users(self):
5061 """ Returns the users which this rule applies to """
5062
5063 users = collections.OrderedDict()
5064
5065 for rule_user in self.rule_users:
5066 if rule_user.user.active:
5067 if rule_user.user not in users:
5068 users[rule_user.user.username] = {
5069 'user': rule_user.user,
5070 'source': 'user',
5071 'source_data': {},
5072 'data': rule_user.rule_data()
5073 }
5074
5075 for rule_user_group in self.rule_user_groups:
5076 source_data = {
5077 'user_group_id': rule_user_group.users_group.users_group_id,
5078 'name': rule_user_group.users_group.users_group_name,
5079 'members': len(rule_user_group.users_group.members)
5080 }
5081 for member in rule_user_group.users_group.members:
5082 if member.user.active:
5083 key = member.user.username
5084 if key in users:
5085 # skip this member as we have him already
5086 # this prevents from override the "first" matched
5087 # users with duplicates in multiple groups
5088 continue
5089
5090 users[key] = {
5091 'user': member.user,
5092 'source': 'user_group',
5093 'source_data': source_data,
5094 'data': rule_user_group.rule_data()
5095 }
5096
5097 return users
5098
5099 def user_group_vote_rule(self, user_id):
5100
5101 rules = []
5102 if not self.rule_user_groups:
5103 return rules
5104
5105 for user_group in self.rule_user_groups:
5106 user_group_members = [x.user_id for x in user_group.users_group.members]
5107 if user_id in user_group_members:
5108 rules.append(user_group)
5109 return rules
5110
5111 def __repr__(self):
5112 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
5113 self.repo_review_rule_id, self.repo)
5114
5115
5116 class ScheduleEntry(Base, BaseModel):
5117 __tablename__ = 'schedule_entries'
5118 __table_args__ = (
5119 UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
5120 UniqueConstraint('task_uid', name='s_task_uid_idx'),
5121 base_table_args,
5122 )
5123
5124 schedule_types = ['crontab', 'timedelta', 'integer']
5125 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
5126
5127 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
5128 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
5129 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
5130
5131 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
5132 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
5133
5134 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
5135 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
5136
5137 # task
5138 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
5139 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
5140 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
5141 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
5142
5143 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5144 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
5145
5146 @hybrid_property
5147 def schedule_type(self):
5148 return self._schedule_type
5149
5150 @schedule_type.setter
5151 def schedule_type(self, val):
5152 if val not in self.schedule_types:
5153 raise ValueError('Value must be on of `{}` and got `{}`'.format(
5154 val, self.schedule_type))
5155
5156 self._schedule_type = val
5157
5158 @classmethod
5159 def get_uid(cls, obj):
5160 args = obj.task_args
5161 kwargs = obj.task_kwargs
5162 if isinstance(args, JsonRaw):
5163 try:
5164 args = json.loads(args)
5165 except ValueError:
5166 args = tuple()
5167
5168 if isinstance(kwargs, JsonRaw):
5169 try:
5170 kwargs = json.loads(kwargs)
5171 except ValueError:
5172 kwargs = dict()
5173
5174 dot_notation = obj.task_dot_notation
5175 val = '.'.join(map(safe_str, [
5176 sorted(dot_notation), args, sorted(kwargs.items())]))
5177 return hashlib.sha1(val).hexdigest()
5178
5179 @classmethod
5180 def get_by_schedule_name(cls, schedule_name):
5181 return cls.query().filter(cls.schedule_name == schedule_name).scalar()
5182
5183 @classmethod
5184 def get_by_schedule_id(cls, schedule_id):
5185 return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
5186
5187 @property
5188 def task(self):
5189 return self.task_dot_notation
5190
5191 @property
5192 def schedule(self):
5193 from rhodecode.lib.celerylib.utils import raw_2_schedule
5194 schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
5195 return schedule
5196
5197 @property
5198 def args(self):
5199 try:
5200 return list(self.task_args or [])
5201 except ValueError:
5202 return list()
5203
5204 @property
5205 def kwargs(self):
5206 try:
5207 return dict(self.task_kwargs or {})
5208 except ValueError:
5209 return dict()
5210
5211 def _as_raw(self, val):
5212 if hasattr(val, 'de_coerce'):
5213 val = val.de_coerce()
5214 if val:
5215 val = json.dumps(val)
5216
5217 return val
5218
5219 @property
5220 def schedule_definition_raw(self):
5221 return self._as_raw(self.schedule_definition)
5222
5223 @property
5224 def args_raw(self):
5225 return self._as_raw(self.task_args)
5226
5227 @property
5228 def kwargs_raw(self):
5229 return self._as_raw(self.task_kwargs)
5230
5231 def __repr__(self):
5232 return '<DB:ScheduleEntry({}:{})>'.format(
5233 self.schedule_entry_id, self.schedule_name)
5234
5235
5236 @event.listens_for(ScheduleEntry, 'before_update')
5237 def update_task_uid(mapper, connection, target):
5238 target.task_uid = ScheduleEntry.get_uid(target)
5239
5240
5241 @event.listens_for(ScheduleEntry, 'before_insert')
5242 def set_task_uid(mapper, connection, target):
5243 target.task_uid = ScheduleEntry.get_uid(target)
5244
5245
5246 class _BaseBranchPerms(BaseModel):
5247 @classmethod
5248 def compute_hash(cls, value):
5249 return sha1_safe(value)
5250
5251 @hybrid_property
5252 def branch_pattern(self):
5253 return self._branch_pattern or '*'
5254
5255 @hybrid_property
5256 def branch_hash(self):
5257 return self._branch_hash
5258
5259 def _validate_glob(self, value):
5260 re.compile('^' + glob2re(value) + '$')
5261
5262 @branch_pattern.setter
5263 def branch_pattern(self, value):
5264 self._validate_glob(value)
5265 self._branch_pattern = value or '*'
5266 # set the Hash when setting the branch pattern
5267 self._branch_hash = self.compute_hash(self._branch_pattern)
5268
5269 def matches(self, branch):
5270 """
5271 Check if this the branch matches entry
5272
5273 :param branch: branch name for the commit
5274 """
5275
5276 branch = branch or ''
5277
5278 branch_matches = True
5279 if branch:
5280 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
5281 branch_matches = bool(branch_regex.search(branch))
5282
5283 return branch_matches
5284
5285
5286 class UserToRepoBranchPermission(Base, _BaseBranchPerms):
5287 __tablename__ = 'user_to_repo_branch_permissions'
5288 __table_args__ = (
5289 base_table_args
5290 )
5291
5292 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
5293
5294 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
5295 repo = relationship('Repository', backref='user_branch_perms')
5296
5297 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
5298 permission = relationship('Permission')
5299
5300 rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None)
5301 user_repo_to_perm = relationship('UserRepoToPerm')
5302
5303 rule_order = Column('rule_order', Integer(), nullable=False)
5304 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
5305 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
5306
5307 def __unicode__(self):
5308 return u'<UserBranchPermission(%s => %r)>' % (
5309 self.user_repo_to_perm, self.branch_pattern)
5310
5311
5312 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
5313 __tablename__ = 'user_group_to_repo_branch_permissions'
5314 __table_args__ = (
5315 base_table_args
5316 )
5317
5318 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
5319
5320 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
5321 repo = relationship('Repository', backref='user_group_branch_perms')
5322
5323 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
5324 permission = relationship('Permission')
5325
5326 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)
5327 user_group_repo_to_perm = relationship('UserGroupRepoToPerm')
5328
5329 rule_order = Column('rule_order', Integer(), nullable=False)
5330 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
5331 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
5332
5333 def __unicode__(self):
5334 return u'<UserBranchPermission(%s => %r)>' % (
5335 self.user_group_repo_to_perm, self.branch_pattern)
5336
5337
5338 class UserBookmark(Base, BaseModel):
5339 __tablename__ = 'user_bookmarks'
5340 __table_args__ = (
5341 UniqueConstraint('user_id', 'bookmark_repo_id'),
5342 UniqueConstraint('user_id', 'bookmark_repo_group_id'),
5343 UniqueConstraint('user_id', 'bookmark_position'),
5344 base_table_args
5345 )
5346
5347 user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
5348 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
5349 position = Column("bookmark_position", Integer(), nullable=False)
5350 title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None)
5351 redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None)
5352 created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5353
5354 bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None)
5355 bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None)
5356
5357 user = relationship("User")
5358
5359 repository = relationship("Repository")
5360 repository_group = relationship("RepoGroup")
5361
5362 @classmethod
5363 def get_by_position_for_user(cls, position, user_id):
5364 return cls.query() \
5365 .filter(UserBookmark.user_id == user_id) \
5366 .filter(UserBookmark.position == position).scalar()
5367
5368 @classmethod
5369 def get_bookmarks_for_user(cls, user_id, cache=True):
5370 bookmarks = cls.query() \
5371 .filter(UserBookmark.user_id == user_id) \
5372 .options(joinedload(UserBookmark.repository)) \
5373 .options(joinedload(UserBookmark.repository_group)) \
5374 .order_by(UserBookmark.position.asc())
5375
5376 if cache:
5377 bookmarks = bookmarks.options(
5378 FromCache("sql_cache_short", "get_user_{}_bookmarks".format(user_id))
5379 )
5380
5381 return bookmarks.all()
5382
5383 def __unicode__(self):
5384 return u'<UserBookmark(%s @ %r)>' % (self.position, self.redirect_url)
5385
5386
5387 class FileStore(Base, BaseModel):
5388 __tablename__ = 'file_store'
5389 __table_args__ = (
5390 base_table_args
5391 )
5392
5393 file_store_id = Column('file_store_id', Integer(), primary_key=True)
5394 file_uid = Column('file_uid', String(1024), nullable=False)
5395 file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True)
5396 file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True)
5397 file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False)
5398
5399 # sha256 hash
5400 file_hash = Column('file_hash', String(512), nullable=False)
5401 file_size = Column('file_size', BigInteger(), nullable=False)
5402
5403 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5404 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True)
5405 accessed_count = Column('accessed_count', Integer(), default=0)
5406
5407 enabled = Column('enabled', Boolean(), nullable=False, default=True)
5408
5409 # if repo/repo_group reference is set, check for permissions
5410 check_acl = Column('check_acl', Boolean(), nullable=False, default=True)
5411
5412 # hidden defines an attachment that should be hidden from showing in artifact listing
5413 hidden = Column('hidden', Boolean(), nullable=False, default=False)
5414
5415 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
5416 upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id')
5417
5418 file_metadata = relationship('FileStoreMetadata', lazy='joined')
5419
5420 # scope limited to user, which requester have access to
5421 scope_user_id = Column(
5422 'scope_user_id', Integer(), ForeignKey('users.user_id'),
5423 nullable=True, unique=None, default=None)
5424 user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id')
5425
5426 # scope limited to user group, which requester have access to
5427 scope_user_group_id = Column(
5428 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'),
5429 nullable=True, unique=None, default=None)
5430 user_group = relationship('UserGroup', lazy='joined')
5431
5432 # scope limited to repo, which requester have access to
5433 scope_repo_id = Column(
5434 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'),
5435 nullable=True, unique=None, default=None)
5436 repo = relationship('Repository', lazy='joined')
5437
5438 # scope limited to repo group, which requester have access to
5439 scope_repo_group_id = Column(
5440 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'),
5441 nullable=True, unique=None, default=None)
5442 repo_group = relationship('RepoGroup', lazy='joined')
5443
5444 @classmethod
5445 def get_by_store_uid(cls, file_store_uid):
5446 return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
5447
5448 @classmethod
5449 def create(cls, file_uid, filename, file_hash, file_size, file_display_name='',
5450 file_description='', enabled=True, hidden=False, check_acl=True,
5451 user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None):
5452
5453 store_entry = FileStore()
5454 store_entry.file_uid = file_uid
5455 store_entry.file_display_name = file_display_name
5456 store_entry.file_org_name = filename
5457 store_entry.file_size = file_size
5458 store_entry.file_hash = file_hash
5459 store_entry.file_description = file_description
5460
5461 store_entry.check_acl = check_acl
5462 store_entry.enabled = enabled
5463 store_entry.hidden = hidden
5464
5465 store_entry.user_id = user_id
5466 store_entry.scope_user_id = scope_user_id
5467 store_entry.scope_repo_id = scope_repo_id
5468 store_entry.scope_repo_group_id = scope_repo_group_id
5469
5470 return store_entry
5471
5472 @classmethod
5473 def store_metadata(cls, file_store_id, args, commit=True):
5474 file_store = FileStore.get(file_store_id)
5475 if file_store is None:
5476 return
5477
5478 for section, key, value, value_type in args:
5479 has_key = FileStoreMetadata().query() \
5480 .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \
5481 .filter(FileStoreMetadata.file_store_meta_section == section) \
5482 .filter(FileStoreMetadata.file_store_meta_key == key) \
5483 .scalar()
5484 if has_key:
5485 msg = 'key `{}` already defined under section `{}` for this file.'\
5486 .format(key, section)
5487 raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key)
5488
5489 # NOTE(marcink): raises ArtifactMetadataBadValueType
5490 FileStoreMetadata.valid_value_type(value_type)
5491
5492 meta_entry = FileStoreMetadata()
5493 meta_entry.file_store = file_store
5494 meta_entry.file_store_meta_section = section
5495 meta_entry.file_store_meta_key = key
5496 meta_entry.file_store_meta_value_type = value_type
5497 meta_entry.file_store_meta_value = value
5498
5499 Session().add(meta_entry)
5500
5501 try:
5502 if commit:
5503 Session().commit()
5504 except IntegrityError:
5505 Session().rollback()
5506 raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.')
5507
5508 @classmethod
5509 def bump_access_counter(cls, file_uid, commit=True):
5510 FileStore().query()\
5511 .filter(FileStore.file_uid == file_uid)\
5512 .update({FileStore.accessed_count: (FileStore.accessed_count + 1),
5513 FileStore.accessed_on: datetime.datetime.now()})
5514 if commit:
5515 Session().commit()
5516
5517 def __json__(self):
5518 data = {
5519 'filename': self.file_display_name,
5520 'filename_org': self.file_org_name,
5521 'file_uid': self.file_uid,
5522 'description': self.file_description,
5523 'hidden': self.hidden,
5524 'size': self.file_size,
5525 'created_on': self.created_on,
5526 'uploaded_by': self.upload_user.get_api_data(details='basic'),
5527 'downloaded_times': self.accessed_count,
5528 'sha256': self.file_hash,
5529 'metadata': self.file_metadata,
5530 }
5531
5532 return data
5533
5534 def __repr__(self):
5535 return '<FileStore({})>'.format(self.file_store_id)
5536
5537
5538 class FileStoreMetadata(Base, BaseModel):
5539 __tablename__ = 'file_store_metadata'
5540 __table_args__ = (
5541 UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'),
5542 Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255),
5543 Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255),
5544 base_table_args
5545 )
5546 SETTINGS_TYPES = {
5547 'str': safe_str,
5548 'int': safe_int,
5549 'unicode': safe_unicode,
5550 'bool': str2bool,
5551 'list': functools.partial(aslist, sep=',')
5552 }
5553
5554 file_store_meta_id = Column(
5555 "file_store_meta_id", Integer(), nullable=False, unique=True, default=None,
5556 primary_key=True)
5557 _file_store_meta_section = Column(
5558 "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
5559 nullable=True, unique=None, default=None)
5560 _file_store_meta_section_hash = Column(
5561 "file_store_meta_section_hash", String(255),
5562 nullable=True, unique=None, default=None)
5563 _file_store_meta_key = Column(
5564 "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
5565 nullable=True, unique=None, default=None)
5566 _file_store_meta_key_hash = Column(
5567 "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None)
5568 _file_store_meta_value = Column(
5569 "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'),
5570 nullable=True, unique=None, default=None)
5571 _file_store_meta_value_type = Column(
5572 "file_store_meta_value_type", String(255), nullable=True, unique=None,
5573 default='unicode')
5574
5575 file_store_id = Column(
5576 'file_store_id', Integer(), ForeignKey('file_store.file_store_id'),
5577 nullable=True, unique=None, default=None)
5578
5579 file_store = relationship('FileStore', lazy='joined')
5580
5581 @classmethod
5582 def valid_value_type(cls, value):
5583 if value.split('.')[0] not in cls.SETTINGS_TYPES:
5584 raise ArtifactMetadataBadValueType(
5585 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value))
5586
5587 @hybrid_property
5588 def file_store_meta_section(self):
5589 return self._file_store_meta_section
5590
5591 @file_store_meta_section.setter
5592 def file_store_meta_section(self, value):
5593 self._file_store_meta_section = value
5594 self._file_store_meta_section_hash = _hash_key(value)
5595
5596 @hybrid_property
5597 def file_store_meta_key(self):
5598 return self._file_store_meta_key
5599
5600 @file_store_meta_key.setter
5601 def file_store_meta_key(self, value):
5602 self._file_store_meta_key = value
5603 self._file_store_meta_key_hash = _hash_key(value)
5604
5605 @hybrid_property
5606 def file_store_meta_value(self):
5607 val = self._file_store_meta_value
5608
5609 if self._file_store_meta_value_type:
5610 # e.g unicode.encrypted == unicode
5611 _type = self._file_store_meta_value_type.split('.')[0]
5612 # decode the encrypted value if it's encrypted field type
5613 if '.encrypted' in self._file_store_meta_value_type:
5614 cipher = EncryptedTextValue()
5615 val = safe_unicode(cipher.process_result_value(val, None))
5616 # do final type conversion
5617 converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']
5618 val = converter(val)
5619
5620 return val
5621
5622 @file_store_meta_value.setter
5623 def file_store_meta_value(self, val):
5624 val = safe_unicode(val)
5625 # encode the encrypted value
5626 if '.encrypted' in self.file_store_meta_value_type:
5627 cipher = EncryptedTextValue()
5628 val = safe_unicode(cipher.process_bind_param(val, None))
5629 self._file_store_meta_value = val
5630
5631 @hybrid_property
5632 def file_store_meta_value_type(self):
5633 return self._file_store_meta_value_type
5634
5635 @file_store_meta_value_type.setter
5636 def file_store_meta_value_type(self, val):
5637 # e.g unicode.encrypted
5638 self.valid_value_type(val)
5639 self._file_store_meta_value_type = val
5640
5641 def __json__(self):
5642 data = {
5643 'artifact': self.file_store.file_uid,
5644 'section': self.file_store_meta_section,
5645 'key': self.file_store_meta_key,
5646 'value': self.file_store_meta_value,
5647 }
5648
5649 return data
5650
5651 def __repr__(self):
5652 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.file_store_meta_section,
5653 self.file_store_meta_key, self.file_store_meta_value)
5654
5655
5656 class DbMigrateVersion(Base, BaseModel):
5657 __tablename__ = 'db_migrate_version'
5658 __table_args__ = (
5659 base_table_args,
5660 )
5661
5662 repository_id = Column('repository_id', String(250), primary_key=True)
5663 repository_path = Column('repository_path', Text)
5664 version = Column('version', Integer)
5665
5666 @classmethod
5667 def set_version(cls, version):
5668 """
5669 Helper for forcing a different version, usually for debugging purposes via ishell.
5670 """
5671 ver = DbMigrateVersion.query().first()
5672 ver.version = version
5673 Session().commit()
5674
5675
5676 class DbSession(Base, BaseModel):
5677 __tablename__ = 'db_session'
5678 __table_args__ = (
5679 base_table_args,
5680 )
5681
5682 def __repr__(self):
5683 return '<DB:DbSession({})>'.format(self.id)
5684
5685 id = Column('id', Integer())
5686 namespace = Column('namespace', String(255), primary_key=True)
5687 accessed = Column('accessed', DateTime, nullable=False)
5688 created = Column('created', DateTime, nullable=False)
5689 data = Column('data', PickleType, nullable=False)
@@ -0,0 +1,52 b''
1 # -*- coding: utf-8 -*-
2
3 import logging
4 from sqlalchemy import *
5
6 from alembic.migration import MigrationContext
7 from alembic.operations import Operations
8
9 from rhodecode.lib.dbmigrate.versions import _reset_base
10 from rhodecode.model import meta, init_model_encryption
11
12
13 log = logging.getLogger(__name__)
14
15
16 def upgrade(migrate_engine):
17 """
18 Upgrade operations go here.
19 Don't create your own engine; bind migrate_engine to your metadata
20 """
21 _reset_base(migrate_engine)
22 from rhodecode.lib.dbmigrate.schema import db_4_20_0_0 as db
23
24 init_model_encryption(db)
25
26 context = MigrationContext.configure(migrate_engine.connect())
27 op = Operations(context)
28
29 table = db.PullRequestReviewers.__table__
30 with op.batch_alter_table(table.name) as batch_op:
31 new_column = Column('role', Unicode(255), nullable=True)
32 batch_op.add_column(new_column)
33
34 _fill_reviewers_role(db, op, meta.Session)
35
36
37 def downgrade(migrate_engine):
38 meta = MetaData()
39 meta.bind = migrate_engine
40
41
42 def fixups(models, _SESSION):
43 pass
44
45
46 def _fill_reviewers_role(models, op, session):
47 params = {'role': 'reviewer'}
48 query = text(
49 'UPDATE pull_request_reviewers SET role = :role'
50 ).bindparams(**params)
51 op.execute(query)
52 session().commit()
@@ -0,0 +1,142 b''
1 ## snippet for sidebar elements
2 ## usage:
3 ## <%namespace name="sidebar" file="/base/sidebar.mako"/>
4 ## ${sidebar.comments_table()}
5 <%namespace name="base" file="/base/base.mako"/>
6
7 <%def name="comments_table(comments, counter_num, todo_comments=False, existing_ids=None, is_pr=True)">
8 <%
9 if todo_comments:
10 cls_ = 'todos-content-table'
11 def sorter(entry):
12 user_id = entry.author.user_id
13 resolved = '1' if entry.resolved else '0'
14 if user_id == c.rhodecode_user.user_id:
15 # own comments first
16 user_id = 0
17 return '{}'.format(str(entry.comment_id).zfill(10000))
18 else:
19 cls_ = 'comments-content-table'
20 def sorter(entry):
21 user_id = entry.author.user_id
22 return '{}'.format(str(entry.comment_id).zfill(10000))
23
24 existing_ids = existing_ids or []
25
26 %>
27
28 <table class="todo-table ${cls_}" data-total-count="${len(comments)}" data-counter="${counter_num}">
29
30 % for loop_obj, comment_obj in h.looper(reversed(sorted(comments, key=sorter))):
31 <%
32 display = ''
33 _cls = ''
34 %>
35
36 <%
37 comment_ver_index = comment_obj.get_index_version(getattr(c, 'versions', []))
38 prev_comment_ver_index = 0
39 if loop_obj.previous:
40 prev_comment_ver_index = loop_obj.previous.get_index_version(getattr(c, 'versions', []))
41
42 ver_info = None
43 if getattr(c, 'versions', []):
44 ver_info = c.versions[comment_ver_index-1] if comment_ver_index else None
45 %>
46 <% hidden_at_ver = comment_obj.outdated_at_version_js(c.at_version_num) %>
47 <% is_from_old_ver = comment_obj.older_than_version_js(c.at_version_num) %>
48 <%
49 if (prev_comment_ver_index > comment_ver_index):
50 comments_ver_divider = comment_ver_index
51 else:
52 comments_ver_divider = None
53 %>
54
55 % if todo_comments:
56 % if comment_obj.resolved:
57 <% _cls = 'resolved-todo' %>
58 <% display = 'none' %>
59 % endif
60 % else:
61 ## SKIP TODOs we display them in other area
62 % if comment_obj.is_todo:
63 <% display = 'none' %>
64 % endif
65 ## Skip outdated comments
66 % if comment_obj.outdated:
67 <% display = 'none' %>
68 <% _cls = 'hidden-comment' %>
69 % endif
70 % endif
71
72 % if not todo_comments and comments_ver_divider:
73 <tr class="old-comments-marker">
74 <td colspan="3">
75 % if ver_info:
76 <code>v${comments_ver_divider} ${h.age_component(ver_info.created_on, time_is_local=True, tooltip=False)}</code>
77 % else:
78 <code>v${comments_ver_divider}</code>
79 % endif
80 </td>
81 </tr>
82
83 % endif
84
85 <tr class="${_cls}" style="display: ${display};" data-sidebar-comment-id="${comment_obj.comment_id}">
86 <td class="td-todo-number">
87 <%
88 version_info = ''
89 if is_pr:
90 version_info = (' made in older version (v{})'.format(comment_ver_index) if is_from_old_ver == 'true' else ' made in this version')
91 %>
92
93 <script type="text/javascript">
94 // closure function helper
95 var sidebarComment${comment_obj.comment_id} = function() {
96 return renderTemplate('sideBarCommentHovercard', {
97 version_info: "${version_info}",
98 file_name: "${comment_obj.f_path}",
99 line_no: "${comment_obj.line_no}",
100 outdated: ${h.json.dumps(comment_obj.outdated)},
101 inline: ${h.json.dumps(comment_obj.is_inline)},
102 is_todo: ${h.json.dumps(comment_obj.is_todo)},
103 created_on: "${h.format_date(comment_obj.created_on)}",
104 datetime: "${comment_obj.created_on}${h.get_timezone(comment_obj.created_on, time_is_local=True)}",
105 review_status: "${(comment_obj.review_status or '')}"
106 })
107 }
108 </script>
109
110 % if comment_obj.outdated:
111 <i class="icon-comment-toggle tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
112 % elif comment_obj.is_inline:
113 <i class="icon-code tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
114 % else:
115 <i class="icon-comment tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
116 % endif
117
118 ## NEW, since refresh
119 % if existing_ids and comment_obj.comment_id not in existing_ids:
120 <span class="tag">NEW</span>
121 % endif
122 </td>
123
124 <td class="td-todo-gravatar">
125 ${base.gravatar(comment_obj.author.email, 16, user=comment_obj.author, tooltip=True, extra_class=['no-margin'])}
126 </td>
127 <td class="todo-comment-text-wrapper">
128 <div class="todo-comment-text ${('todo-resolved' if comment_obj.resolved else '')}">
129 <a class="${('todo-resolved' if comment_obj.resolved else '')} permalink"
130 href="#comment-${comment_obj.comment_id}"
131 onclick="return Rhodecode.comments.scrollToComment($('#comment-${comment_obj.comment_id}'), 0, ${hidden_at_ver})">
132
133 ${h.chop_at_smart(comment_obj.text, '\n', suffix_if_chopped='...')}
134 </a>
135 </div>
136 </td>
137 </tr>
138 % endfor
139
140 </table>
141
142 </%def> No newline at end of file
@@ -1,6 +1,5 b''
1 1 [bumpversion]
2 current_version = 4.20.1
2 current_version = 4.21.0
3 3 message = release: Bump version {current_version} to {new_version}
4 4
5 5 [bumpversion:file:rhodecode/VERSION]
6
@@ -5,25 +5,20 b' done = false'
5 5 done = true
6 6
7 7 [task:rc_tools_pinned]
8 done = true
9 8
10 9 [task:fixes_on_stable]
11 done = true
12 10
13 11 [task:pip2nix_generated]
14 done = true
15 12
16 13 [task:changelog_updated]
17 done = true
18 14
19 15 [task:generate_api_docs]
20 done = true
16
17 [task:updated_translation]
21 18
22 19 [release]
23 state = prepared
24 version = 4.20.1
25
26 [task:updated_translation]
20 state = in_progress
21 version = 4.21.0
27 22
28 23 [task:generate_js_routes]
29 24
@@ -147,12 +147,13 b' Use the following example to configure N'
147 147
148 148 ## Special Cache for file store, make sure you enable this intentionally as
149 149 ## it could bypass upload files permissions
150 # location /_file_store/download {
150 # location /_file_store/download/gravatars {
151 151 #
152 152 # proxy_cache cache_zone;
153 153 # # ignore Set-Cookie
154 154 # proxy_ignore_headers Set-Cookie;
155 # proxy_ignore_headers Cookie;
155 # # ignore cache-control
156 # proxy_ignore_headers Cache-Control;
156 157 #
157 158 # proxy_cache_key $host$uri$is_args$args;
158 159 # proxy_cache_methods GET;
@@ -32,6 +32,8 b' self: super: {'
32 32 patches = [
33 33 ./patches/beaker/patch-beaker-lock-func-debug.diff
34 34 ./patches/beaker/patch-beaker-metadata-reuse.diff
35 ./patches/beaker/patch-beaker-improved-redis.diff
36 ./patches/beaker/patch-beaker-improved-redis-2.diff
35 37 ];
36 38 });
37 39
@@ -35,6 +35,20 b' self: super: {'
35 35 license = [ pkgs.lib.licenses.bsdOriginal ];
36 36 };
37 37 };
38 "apispec" = super.buildPythonPackage {
39 name = "apispec-1.0.0";
40 doCheck = false;
41 propagatedBuildInputs = [
42 self."PyYAML"
43 ];
44 src = fetchurl {
45 url = "https://files.pythonhosted.org/packages/67/15/346c04988dd67d36007e28145504c520491930c878b1f484a97b27a8f497/apispec-1.0.0.tar.gz";
46 sha256 = "1712w1anvqrvadjjpvai84vbaygaxabd3zz5lxihdzwzs4gvi9sp";
47 };
48 meta = {
49 license = [ pkgs.lib.licenses.mit ];
50 };
51 };
38 52 "appenlight-client" = super.buildPythonPackage {
39 53 name = "appenlight-client-0.6.26";
40 54 doCheck = false;
@@ -236,20 +250,23 b' self: super: {'
236 250 };
237 251 };
238 252 "channelstream" = super.buildPythonPackage {
239 name = "channelstream-0.5.2";
253 name = "channelstream-0.6.14";
240 254 doCheck = false;
241 255 propagatedBuildInputs = [
242 256 self."gevent"
243 257 self."ws4py"
258 self."marshmallow"
259 self."python-dateutil"
244 260 self."pyramid"
245 261 self."pyramid-jinja2"
262 self."pyramid-apispec"
246 263 self."itsdangerous"
247 264 self."requests"
248 265 self."six"
249 266 ];
250 267 src = fetchurl {
251 url = "https://files.pythonhosted.org/packages/2b/31/29a8e085cf5bf97fa88e7b947adabfc581a18a3463adf77fb6dada34a65f/channelstream-0.5.2.tar.gz";
252 sha256 = "1qbm4xdl5hfkja683x546bncg3rqq8qv79w1m1a1wd48cqqzb6rm";
268 url = "https://files.pythonhosted.org/packages/d4/2d/86d6757ccd06ce673ee224123471da3d45251d061da7c580bfc259bad853/channelstream-0.6.14.tar.gz";
269 sha256 = "0qgy5j3rj6c8cslzidh32glhkrhbbdxjc008y69v8a0y3zyaz2d3";
253 270 };
254 271 meta = {
255 272 license = [ pkgs.lib.licenses.bsdOriginal ];
@@ -862,11 +879,11 b' self: super: {'
862 879 };
863 880 };
864 881 "itsdangerous" = super.buildPythonPackage {
865 name = "itsdangerous-0.24";
882 name = "itsdangerous-1.1.0";
866 883 doCheck = false;
867 884 src = fetchurl {
868 url = "https://files.pythonhosted.org/packages/dc/b4/a60bcdba945c00f6d608d8975131ab3f25b22f2bcfe1dab221165194b2d4/itsdangerous-0.24.tar.gz";
869 sha256 = "06856q6x675ly542ig0plbqcyab6ksfzijlyf1hzhgg3sgwgrcyb";
885 url = "https://files.pythonhosted.org/packages/68/1a/f27de07a8a304ad5fa817bbe383d1238ac4396da447fa11ed937039fa04b/itsdangerous-1.1.0.tar.gz";
886 sha256 = "068zpbksq5q2z4dckh2k1zbcq43ay74ylqn77rni797j0wyh66rj";
870 887 };
871 888 meta = {
872 889 license = [ pkgs.lib.licenses.bsdOriginal ];
@@ -993,6 +1010,17 b' self: super: {'
993 1010 license = [ pkgs.lib.licenses.bsdOriginal pkgs.lib.licenses.bsd3 ];
994 1011 };
995 1012 };
1013 "marshmallow" = super.buildPythonPackage {
1014 name = "marshmallow-2.18.0";
1015 doCheck = false;
1016 src = fetchurl {
1017 url = "https://files.pythonhosted.org/packages/ad/0b/5799965d1c6d5f608d684e2c0dce8a828e0309a3bfe8327d9418a89f591c/marshmallow-2.18.0.tar.gz";
1018 sha256 = "1g0aafpjn7yaxq06yndy8c7rs9n42adxkqq1ayhlr869pr06d3lm";
1019 };
1020 meta = {
1021 license = [ pkgs.lib.licenses.mit ];
1022 };
1023 };
996 1024 "mistune" = super.buildPythonPackage {
997 1025 name = "mistune-0.8.4";
998 1026 doCheck = false;
@@ -1522,6 +1550,20 b' self: super: {'
1522 1550 license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
1523 1551 };
1524 1552 };
1553 "pyramid-apispec" = super.buildPythonPackage {
1554 name = "pyramid-apispec-0.3.2";
1555 doCheck = false;
1556 propagatedBuildInputs = [
1557 self."apispec"
1558 ];
1559 src = fetchurl {
1560 url = "https://files.pythonhosted.org/packages/2a/30/1dea5d81ea635449572ba60ec3148310d75ae4530c3c695f54b0991bb8c7/pyramid_apispec-0.3.2.tar.gz";
1561 sha256 = "0ffrcqp9dkykivhfcq0v9lgy6w0qhwl6x78925vfjmayly9r8da0";
1562 };
1563 meta = {
1564 license = [ pkgs.lib.licenses.bsdOriginal ];
1565 };
1566 };
1525 1567 "pyramid-mailer" = super.buildPythonPackage {
1526 1568 name = "pyramid-mailer-0.15.1";
1527 1569 doCheck = false;
@@ -1763,6 +1805,17 b' self: super: {'
1763 1805 license = [ pkgs.lib.licenses.bsdOriginal { fullName = "LGPL+BSD"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
1764 1806 };
1765 1807 };
1808 "PyYAML" = super.buildPythonPackage {
1809 name = "PyYAML-5.3.1";
1810 doCheck = false;
1811 src = fetchurl {
1812 url = "https://files.pythonhosted.org/packages/64/c2/b80047c7ac2478f9501676c988a5411ed5572f35d1beff9cae07d321512c/PyYAML-5.3.1.tar.gz";
1813 sha256 = "0pb4zvkfxfijkpgd1b86xjsqql97ssf1knbd1v53wkg1qm9cgsmq";
1814 };
1815 meta = {
1816 license = [ pkgs.lib.licenses.mit ];
1817 };
1818 };
1766 1819 "redis" = super.buildPythonPackage {
1767 1820 name = "redis-3.4.1";
1768 1821 doCheck = false;
@@ -1819,7 +1872,7 b' self: super: {'
1819 1872 };
1820 1873 };
1821 1874 "rhodecode-enterprise-ce" = super.buildPythonPackage {
1822 name = "rhodecode-enterprise-ce-4.20.1";
1875 name = "rhodecode-enterprise-ce-4.20.0";
1823 1876 buildInputs = [
1824 1877 self."pytest"
1825 1878 self."py"
@@ -5,7 +5,7 b' babel==1.3'
5 5 beaker==1.9.1
6 6 bleach==3.1.3
7 7 celery==4.3.0
8 channelstream==0.5.2
8 channelstream==0.6.14
9 9 click==7.0
10 10 colander==1.7.0
11 11 # our custom configobj
@@ -22,7 +22,7 b' future==0.14.3'
22 22 futures==3.0.2
23 23 infrae.cache==1.0.1
24 24 iso8601==0.1.12
25 itsdangerous==0.24
25 itsdangerous==1.1.0
26 26 kombu==4.6.6
27 27 lxml==4.2.5
28 28 mako==1.1.0
@@ -18,10 +18,11 b' jsonschema==2.6.0'
18 18 pluggy==0.13.1
19 19 pyasn1-modules==0.2.6
20 20 pyramid-jinja2==2.7
21 pyramid-apispec==0.3.2
21 22 scandir==1.10.0
22 23 setproctitle==1.1.10
23 24 tempita==0.5.2
24 25 testpath==0.4.4
25 26 transaction==2.4.0
26 27 vine==1.3.0
27 wcwidth==0.1.9
28 wcwidth==0.1.9 No newline at end of file
@@ -1,1 +1,1 b''
1 4.20.1 No newline at end of file
1 4.21.0 No newline at end of file
@@ -48,7 +48,7 b' PYRAMID_SETTINGS = {}'
48 48 EXTENSIONS = {}
49 49
50 50 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
51 __dbversion__ = 108 # defines current db version for migrations
51 __dbversion__ = 109 # defines current db version for migrations
52 52 __platform__ = platform.system()
53 53 __license__ = 'AGPLv3, and Commercial License'
54 54 __author__ = 'RhodeCode GmbH'
@@ -170,8 +170,7 b' def validate_repo_permissions(apiuser, r'
170 170 """
171 171 if not HasRepoPermissionAnyApi(*perms)(
172 172 user=apiuser, repo_name=repo.repo_name):
173 raise JSONRPCError(
174 'repository `%s` does not exist' % repoid)
173 raise JSONRPCError('repository `%s` does not exist' % repoid)
175 174
176 175 return True
177 176
@@ -307,8 +307,7 b' def get_repo_changeset(request, apiuser,'
307 307 """
308 308 repo = get_repo_or_error(repoid)
309 309 if not has_superadmin_permission(apiuser):
310 _perms = (
311 'repository.admin', 'repository.write', 'repository.read',)
310 _perms = ('repository.admin', 'repository.write', 'repository.read',)
312 311 validate_repo_permissions(apiuser, repoid, repo, _perms)
313 312
314 313 changes_details = Optional.extract(details)
@@ -366,8 +365,7 b' def get_repo_changesets(request, apiuser'
366 365 """
367 366 repo = get_repo_or_error(repoid)
368 367 if not has_superadmin_permission(apiuser):
369 _perms = (
370 'repository.admin', 'repository.write', 'repository.read',)
368 _perms = ('repository.admin', 'repository.write', 'repository.read',)
371 369 validate_repo_permissions(apiuser, repoid, repo, _perms)
372 370
373 371 changes_details = Optional.extract(details)
@@ -1021,7 +1019,8 b' def update_repo('
1021 1019
1022 1020 include_secrets = False
1023 1021 if not has_superadmin_permission(apiuser):
1024 validate_repo_permissions(apiuser, repoid, repo, ('repository.admin',))
1022 _perms = ('repository.admin',)
1023 validate_repo_permissions(apiuser, repoid, repo, _perms)
1025 1024 else:
1026 1025 include_secrets = True
1027 1026
@@ -1208,8 +1207,7 b' def fork_repo(request, apiuser, repoid, '
1208 1207 if not has_superadmin_permission(apiuser):
1209 1208 # check if we have at least read permission for
1210 1209 # this repo that we fork !
1211 _perms = (
1212 'repository.admin', 'repository.write', 'repository.read')
1210 _perms = ('repository.admin', 'repository.write', 'repository.read')
1213 1211 validate_repo_permissions(apiuser, repoid, repo, _perms)
1214 1212
1215 1213 # check if the regular user has at least fork permissions as well
@@ -2370,12 +2368,13 b' def get_repo_settings(request, apiuser, '
2370 2368 }
2371 2369 """
2372 2370
2373 # Restrict access to this api method to admins only.
2371 # Restrict access to this api method to super-admins, and repo admins only.
2372 repo = get_repo_or_error(repoid)
2374 2373 if not has_superadmin_permission(apiuser):
2375 raise JSONRPCForbidden()
2374 _perms = ('repository.admin',)
2375 validate_repo_permissions(apiuser, repoid, repo, _perms)
2376 2376
2377 2377 try:
2378 repo = get_repo_or_error(repoid)
2379 2378 settings_model = VcsSettingsModel(repo=repo)
2380 2379 settings = settings_model.get_global_settings()
2381 2380 settings.update(settings_model.get_repo_settings())
@@ -2414,9 +2413,11 b' def set_repo_settings(request, apiuser, '
2414 2413 "result": true
2415 2414 }
2416 2415 """
2417 # Restrict access to this api method to admins only.
2416 # Restrict access to this api method to super-admins, and repo admins only.
2417 repo = get_repo_or_error(repoid)
2418 2418 if not has_superadmin_permission(apiuser):
2419 raise JSONRPCForbidden()
2419 _perms = ('repository.admin',)
2420 validate_repo_permissions(apiuser, repoid, repo, _perms)
2420 2421
2421 2422 if type(settings) is not dict:
2422 2423 raise JSONRPCError('Settings have to be a JSON Object.')
@@ -34,7 +34,7 b' from rhodecode.lib.channelstream import '
34 34 get_user_data,
35 35 parse_channels_info,
36 36 update_history_from_logs,
37 STATE_PUBLIC_KEYS)
37 USER_STATE_PUBLIC_KEYS)
38 38
39 39 from rhodecode.lib.auth import NotAnonymous
40 40
@@ -86,14 +86,16 b' class ChannelstreamView(BaseAppView):'
86 86 'display_name': None,
87 87 'display_link': None,
88 88 }
89 user_data['permissions'] = self._rhodecode_user.permissions_safe
89
90 #user_data['permissions'] = self._rhodecode_user.permissions_safe
91
90 92 payload = {
91 93 'username': user.username,
92 94 'user_state': user_data,
93 95 'conn_id': str(uuid.uuid4()),
94 96 'channels': channels,
95 97 'channel_configs': {},
96 'state_public_keys': STATE_PUBLIC_KEYS,
98 'state_public_keys': USER_STATE_PUBLIC_KEYS,
97 99 'info': {
98 100 'exclude_channels': ['broadcast']
99 101 }
@@ -118,10 +120,13 b' class ChannelstreamView(BaseAppView):'
118 120 'Channelstream service at {} is down'.format(channelstream_url))
119 121 return HTTPBadGateway()
120 122
123 channel_info = connect_result.get('channels_info')
124 if not channel_info:
125 raise HTTPBadRequest()
126
121 127 connect_result['channels'] = channels
122 128 connect_result['channels_info'] = parse_channels_info(
123 connect_result['channels_info'],
124 include_channel_info=filtered_channels)
129 channel_info, include_channel_info=filtered_channels)
125 130 update_history_from_logs(self.channelstream_config,
126 131 filtered_channels, connect_result)
127 132 return connect_result
@@ -167,10 +172,15 b' class ChannelstreamView(BaseAppView):'
167 172 log.exception(
168 173 'Channelstream service at {} is down'.format(channelstream_url))
169 174 return HTTPBadGateway()
175
176 channel_info = connect_result.get('channels_info')
177 if not channel_info:
178 raise HTTPBadRequest()
179
170 180 # include_channel_info will limit history only to new channel
171 181 # to not overwrite histories on other channels in client
172 182 connect_result['channels_info'] = parse_channels_info(
173 connect_result['channels_info'],
183 channel_info,
174 184 include_channel_info=filtered_channels)
175 185 update_history_from_logs(
176 186 self.channelstream_config, filtered_channels, connect_result)
@@ -43,10 +43,10 b' def includeme(config):'
43 43 pattern='/_file_store/upload')
44 44 config.add_route(
45 45 name='download_file',
46 pattern='/_file_store/download/{fid}')
46 pattern='/_file_store/download/{fid:.*}')
47 47 config.add_route(
48 48 name='download_file_by_token',
49 pattern='/_file_store/token-download/{_auth_token}/{fid}')
49 pattern='/_file_store/token-download/{_auth_token}/{fid:.*}')
50 50
51 51 # Scan module for configuration decorators.
52 52 config.scan('.views', ignore='.tests')
@@ -20,6 +20,7 b''
20 20
21 21 import os
22 22 import time
23 import errno
23 24 import shutil
24 25 import hashlib
25 26
@@ -32,9 +33,24 b' from rhodecode.apps.file_store.exception'
32 33 METADATA_VER = 'v1'
33 34
34 35
36 def safe_make_dirs(dir_path):
37 if not os.path.exists(dir_path):
38 try:
39 os.makedirs(dir_path)
40 except OSError as e:
41 if e.errno != errno.EEXIST:
42 raise
43 return
44
45
35 46 class LocalFileStorage(object):
36 47
37 48 @classmethod
49 def apply_counter(cls, counter, filename):
50 name_counted = '%d-%s' % (counter, filename)
51 return name_counted
52
53 @classmethod
38 54 def resolve_name(cls, name, directory):
39 55 """
40 56 Resolves a unique name and the correct path. If a filename
@@ -47,17 +63,16 b' class LocalFileStorage(object):'
47 63
48 64 counter = 0
49 65 while True:
50 name = '%d-%s' % (counter, name)
66 name_counted = cls.apply_counter(counter, name)
51 67
52 68 # sub_store prefix to optimize disk usage, e.g some_path/ab/final_file
53 sub_store = cls._sub_store_from_filename(name)
69 sub_store = cls._sub_store_from_filename(name_counted)
54 70 sub_store_path = os.path.join(directory, sub_store)
55 if not os.path.exists(sub_store_path):
56 os.makedirs(sub_store_path)
71 safe_make_dirs(sub_store_path)
57 72
58 path = os.path.join(sub_store_path, name)
73 path = os.path.join(sub_store_path, name_counted)
59 74 if not os.path.exists(path):
60 return name, path
75 return name_counted, path
61 76 counter += 1
62 77
63 78 @classmethod
@@ -102,8 +117,13 b' class LocalFileStorage(object):'
102 117
103 118 :param filename: base name of file
104 119 """
105 sub_store = self._sub_store_from_filename(filename)
106 return os.path.join(self.base_path, sub_store, filename)
120 prefix_dir = ''
121 if '/' in filename:
122 prefix_dir, filename = filename.split('/')
123 sub_store = self._sub_store_from_filename(filename)
124 else:
125 sub_store = self._sub_store_from_filename(filename)
126 return os.path.join(self.base_path, prefix_dir, sub_store, filename)
107 127
108 128 def delete(self, filename):
109 129 """
@@ -123,7 +143,7 b' class LocalFileStorage(object):'
123 143 Checks if file exists. Resolves filename's absolute
124 144 path based on base_path.
125 145
126 :param filename: base name of file
146 :param filename: file_uid name of file, e.g 0-f62b2b2d-9708-4079-a071-ec3f958448d4.svg
127 147 """
128 148 return os.path.exists(self.store_path(filename))
129 149
@@ -158,7 +178,7 b' class LocalFileStorage(object):'
158 178 return ext in [normalize_ext(x) for x in extensions]
159 179
160 180 def save_file(self, file_obj, filename, directory=None, extensions=None,
161 extra_metadata=None, max_filesize=None, **kwargs):
181 extra_metadata=None, max_filesize=None, randomized_name=True, **kwargs):
162 182 """
163 183 Saves a file object to the uploads location.
164 184 Returns the resolved filename, i.e. the directory +
@@ -169,6 +189,7 b' class LocalFileStorage(object):'
169 189 :param directory: relative path of sub-directory
170 190 :param extensions: iterable of allowed extensions, if not default
171 191 :param max_filesize: maximum size of file that should be allowed
192 :param randomized_name: generate random generated UID or fixed based on the filename
172 193 :param extra_metadata: extra JSON metadata to store next to the file with .meta suffix
173 194
174 195 """
@@ -183,13 +204,12 b' class LocalFileStorage(object):'
183 204 else:
184 205 dest_directory = self.base_path
185 206
186 if not os.path.exists(dest_directory):
187 os.makedirs(dest_directory)
207 safe_make_dirs(dest_directory)
188 208
189 filename = utils.uid_filename(filename)
209 uid_filename = utils.uid_filename(filename, randomized=randomized_name)
190 210
191 211 # resolve also produces special sub-dir for file optimized store
192 filename, path = self.resolve_name(filename, dest_directory)
212 filename, path = self.resolve_name(uid_filename, dest_directory)
193 213 stored_file_dir = os.path.dirname(path)
194 214
195 215 file_obj.seek(0)
@@ -210,12 +230,13 b' class LocalFileStorage(object):'
210 230
211 231 file_hash = self.calculate_path_hash(path)
212 232
213 metadata.update(
214 {"filename": filename,
233 metadata.update({
234 "filename": filename,
215 235 "size": size,
216 236 "time": time.time(),
217 237 "sha256": file_hash,
218 "meta_ver": METADATA_VER})
238 "meta_ver": METADATA_VER
239 })
219 240
220 241 filename_meta = filename + '.meta'
221 242 with open(os.path.join(stored_file_dir, filename_meta), "wb") as dest_meta:
@@ -20,7 +20,7 b''
20 20
21 21
22 22 import uuid
23
23 import StringIO
24 24 import pathlib2
25 25
26 26
@@ -52,3 +52,7 b' def uid_filename(filename, randomized=Tr'
52 52 hash_key = '{}.{}'.format(filename, 'store')
53 53 uid = uuid.uuid5(uuid.NAMESPACE_URL, hash_key)
54 54 return str(uid) + ext.lower()
55
56
57 def bytes_to_file_obj(bytes_data):
58 return StringIO.StringIO(bytes_data)
@@ -64,7 +64,7 b' class FileStoreView(BaseAppView):'
64 64 file_uid, store_path)
65 65 raise HTTPNotFound()
66 66
67 db_obj = FileStore().query().filter(FileStore.file_uid == file_uid).scalar()
67 db_obj = FileStore.get_by_store_uid(file_uid, safe=True)
68 68 if not db_obj:
69 69 raise HTTPNotFound()
70 70
@@ -345,6 +345,16 b' def includeme(config):'
345 345 pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comment/{comment_id}/delete',
346 346 repo_route=True, repo_accepted_types=['hg', 'git'])
347 347
348 config.add_route(
349 name='pullrequest_comments',
350 pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/comments',
351 repo_route=True)
352
353 config.add_route(
354 name='pullrequest_todos',
355 pattern='/{repo_name:.*?[^/]}/pull-request/{pull_request_id:\d+}/todos',
356 repo_route=True)
357
348 358 # Artifacts, (EE feature)
349 359 config.add_route(
350 360 name='repo_artifacts_list',
@@ -485,23 +485,10 b' class TestRepoCommitCommentsView(TestCon'
485 485
486 486
487 487 def assert_comment_links(response, comments, inline_comments):
488 if comments == 1:
489 comments_text = "%d General" % comments
490 else:
491 comments_text = "%d General" % comments
492
493 if inline_comments == 1:
494 inline_comments_text = "%d Inline" % inline_comments
495 else:
496 inline_comments_text = "%d Inline" % inline_comments
488 response.mustcontain(
489 '<span class="display-none" id="general-comments-count">{}</span>'.format(comments))
490 response.mustcontain(
491 '<span class="display-none" id="inline-comments-count">{}</span>'.format(inline_comments))
497 492
498 if comments:
499 response.mustcontain('<a href="#comments">%s</a>,' % comments_text)
500 else:
501 response.mustcontain(comments_text)
502 493
503 if inline_comments:
504 response.mustcontain(
505 'id="inline-comments-counter">%s' % inline_comments_text)
506 else:
507 response.mustcontain(inline_comments_text)
494
@@ -619,7 +619,12 b' class ComparePage(AssertResponse):'
619 619 self.contains_one_anchor(file_id)
620 620 diffblock = doc.cssselect('[data-f-path="%s"]' % filename)
621 621 assert len(diffblock) == 2
622 assert len(diffblock[0].cssselect('a[href="#%s"]' % file_id)) == 1
622 for lnk in diffblock[0].cssselect('a'):
623 if 'permalink' in lnk.text:
624 assert '#{}'.format(file_id) in lnk.attrib['href']
625 break
626 else:
627 pytest.fail('Unable to find permalink')
623 628
624 629 def contains_change_summary(self, files_changed, inserted, deleted):
625 630 template = (
@@ -150,9 +150,9 b' class TestPullrequestsView(object):'
150 150 response = self.app.post(
151 151 route_path('pullrequest_create', repo_name=source.repo_name),
152 152 [
153 ('source_repo', source.repo_name),
153 ('source_repo', source_repo_name),
154 154 ('source_ref', source_ref),
155 ('target_repo', target.repo_name),
155 ('target_repo', target_repo_name),
156 156 ('target_ref', target_ref),
157 157 ('common_ancestor', commit_ids['initial-commit']),
158 158 ('pullrequest_title', 'Title'),
@@ -1110,16 +1110,17 b' class TestPullrequestsView(object):'
1110 1110
1111 1111 # source has ancestor - change - change-2
1112 1112 backend.pull_heads(source, heads=['change-2'])
1113 target_repo_name = target.repo_name
1113 1114
1114 1115 # update PR
1115 1116 self.app.post(
1116 1117 route_path('pullrequest_update',
1117 repo_name=target.repo_name, pull_request_id=pull_request_id),
1118 repo_name=target_repo_name, pull_request_id=pull_request_id),
1118 1119 params={'update_commits': 'true', 'csrf_token': csrf_token})
1119 1120
1120 1121 response = self.app.get(
1121 1122 route_path('pullrequest_show',
1122 repo_name=target.repo_name,
1123 repo_name=target_repo_name,
1123 1124 pull_request_id=pull_request.pull_request_id))
1124 1125
1125 1126 assert response.status_int == 200
@@ -1166,10 +1167,11 b' class TestPullrequestsView(object):'
1166 1167 # source has ancestor - ancestor-new - change-rebased
1167 1168 backend.pull_heads(target, heads=['ancestor-new'])
1168 1169 backend.pull_heads(source, heads=['change-rebased'])
1170 target_repo_name = target.repo_name
1169 1171
1170 1172 # update PR
1171 1173 url = route_path('pullrequest_update',
1172 repo_name=target.repo_name,
1174 repo_name=target_repo_name,
1173 1175 pull_request_id=pull_request_id)
1174 1176 self.app.post(url,
1175 1177 params={'update_commits': 'true', 'csrf_token': csrf_token},
@@ -1183,7 +1185,7 b' class TestPullrequestsView(object):'
1183 1185
1184 1186 response = self.app.get(
1185 1187 route_path('pullrequest_show',
1186 repo_name=target.repo_name,
1188 repo_name=target_repo_name,
1187 1189 pull_request_id=pull_request.pull_request_id))
1188 1190 assert response.status_int == 200
1189 1191 response.mustcontain('Pull request updated to')
@@ -1232,16 +1234,17 b' class TestPullrequestsView(object):'
1232 1234 vcsrepo = target.scm_instance()
1233 1235 vcsrepo.config.clear_section('hooks')
1234 1236 vcsrepo.run_git_command(['reset', '--soft', 'HEAD~2'])
1237 target_repo_name = target.repo_name
1235 1238
1236 1239 # update PR
1237 1240 url = route_path('pullrequest_update',
1238 repo_name=target.repo_name,
1241 repo_name=target_repo_name,
1239 1242 pull_request_id=pull_request_id)
1240 1243 self.app.post(url,
1241 1244 params={'update_commits': 'true', 'csrf_token': csrf_token},
1242 1245 status=200)
1243 1246
1244 response = self.app.get(route_path('pullrequest_new', repo_name=target.repo_name))
1247 response = self.app.get(route_path('pullrequest_new', repo_name=target_repo_name))
1245 1248 assert response.status_int == 200
1246 1249 response.mustcontain('Pull request updated to')
1247 1250 response.mustcontain('with 0 added, 0 removed commits.')
@@ -1280,11 +1283,12 b' class TestPullrequestsView(object):'
1280 1283 # source has ancestor - ancestor-new - change-rebased
1281 1284 backend.pull_heads(target, heads=['ancestor-new'])
1282 1285 backend.pull_heads(source, heads=['change-rebased'])
1286 target_repo_name = target.repo_name
1283 1287
1284 1288 # update PR
1285 1289 self.app.post(
1286 1290 route_path('pullrequest_update',
1287 repo_name=target.repo_name, pull_request_id=pull_request_id),
1291 repo_name=target_repo_name, pull_request_id=pull_request_id),
1288 1292 params={'update_commits': 'true', 'csrf_token': csrf_token},
1289 1293 status=200)
1290 1294
@@ -1389,6 +1393,8 b' class TestPullrequestsView(object):'
1389 1393 pull_request = pr_util.create_pull_request(
1390 1394 commits, target_head='old-feature', source_head='new-feature',
1391 1395 revisions=['new-feature'], mergeable=True)
1396 pr_id = pull_request.pull_request_id
1397 target_repo_name = pull_request.target_repo.repo_name
1392 1398
1393 1399 vcs = pr_util.source_repository.scm_instance()
1394 1400 if backend.alias == 'git':
@@ -1397,8 +1403,8 b' class TestPullrequestsView(object):'
1397 1403 vcs.strip(pr_util.commit_ids['new-feature'])
1398 1404
1399 1405 url = route_path('pullrequest_update',
1400 repo_name=pull_request.target_repo.repo_name,
1401 pull_request_id=pull_request.pull_request_id)
1406 repo_name=target_repo_name,
1407 pull_request_id=pr_id)
1402 1408 response = self.app.post(url,
1403 1409 params={'update_commits': 'true',
1404 1410 'csrf_token': csrf_token})
@@ -1409,8 +1415,8 b' class TestPullrequestsView(object):'
1409 1415 # Make sure that after update, it won't raise 500 errors
1410 1416 response = self.app.get(route_path(
1411 1417 'pullrequest_show',
1412 repo_name=pr_util.target_repository.repo_name,
1413 pull_request_id=pull_request.pull_request_id))
1418 repo_name=target_repo_name,
1419 pull_request_id=pr_id))
1414 1420
1415 1421 assert response.status_int == 200
1416 1422 response.assert_response().element_contains(
@@ -18,8 +18,8 b''
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21
22 21 import logging
22 import collections
23 23
24 24 from pyramid.httpexceptions import (
25 25 HTTPNotFound, HTTPBadRequest, HTTPFound, HTTPForbidden, HTTPConflict)
@@ -34,14 +34,14 b' from rhodecode.apps.file_store.exception'
34 34 from rhodecode.lib import diffs, codeblocks
35 35 from rhodecode.lib.auth import (
36 36 LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, CSRFRequired)
37
37 from rhodecode.lib.ext_json import json
38 38 from rhodecode.lib.compat import OrderedDict
39 39 from rhodecode.lib.diffs import (
40 40 cache_diff, load_cached_diff, diff_cache_exist, get_diff_context,
41 41 get_diff_whitespace_flag)
42 42 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError, CommentVersionMismatch
43 43 import rhodecode.lib.helpers as h
44 from rhodecode.lib.utils2 import safe_unicode, str2bool
44 from rhodecode.lib.utils2 import safe_unicode, str2bool, StrictAttributeDict
45 45 from rhodecode.lib.vcs.backends.base import EmptyCommit
46 46 from rhodecode.lib.vcs.exceptions import (
47 47 RepositoryError, CommitDoesNotExistError)
@@ -115,6 +115,7 b' class RepoCommitsView(RepoAppView):'
115 115 except Exception:
116 116 log.exception("General failure")
117 117 raise HTTPNotFound()
118 single_commit = len(c.commit_ranges) == 1
118 119
119 120 c.changes = OrderedDict()
120 121 c.lines_added = 0
@@ -128,23 +129,48 b' class RepoCommitsView(RepoAppView):'
128 129 c.inline_comments = []
129 130 c.files = []
130 131
131 c.statuses = []
132 132 c.comments = []
133 133 c.unresolved_comments = []
134 134 c.resolved_comments = []
135 if len(c.commit_ranges) == 1:
135
136 # Single commit
137 if single_commit:
136 138 commit = c.commit_ranges[0]
137 139 c.comments = CommentsModel().get_comments(
138 140 self.db_repo.repo_id,
139 141 revision=commit.raw_id)
140 c.statuses.append(ChangesetStatusModel().get_status(
141 self.db_repo.repo_id, commit.raw_id))
142
142 143 # comments from PR
143 144 statuses = ChangesetStatusModel().get_statuses(
144 145 self.db_repo.repo_id, commit.raw_id,
145 146 with_revisions=True)
146 prs = set(st.pull_request for st in statuses
147 if st.pull_request is not None)
147
148 prs = set()
149 reviewers = list()
150 reviewers_duplicates = set() # to not have duplicates from multiple votes
151 for c_status in statuses:
152
153 # extract associated pull-requests from votes
154 if c_status.pull_request:
155 prs.add(c_status.pull_request)
156
157 # extract reviewers
158 _user_id = c_status.author.user_id
159 if _user_id not in reviewers_duplicates:
160 reviewers.append(
161 StrictAttributeDict({
162 'user': c_status.author,
163
164 # fake attributed for commit, page that we don't have
165 # but we share the display with PR page
166 'mandatory': False,
167 'reasons': [],
168 'rule_user_group_data': lambda: None
169 })
170 )
171 reviewers_duplicates.add(_user_id)
172
173 c.allowed_reviewers = reviewers
148 174 # from associated statuses, check the pull requests, and
149 175 # show comments from them
150 176 for pr in prs:
@@ -155,6 +181,37 b' class RepoCommitsView(RepoAppView):'
155 181 c.resolved_comments = CommentsModel()\
156 182 .get_commit_resolved_todos(commit.raw_id)
157 183
184 c.inline_comments_flat = CommentsModel()\
185 .get_commit_inline_comments(commit.raw_id)
186
187 review_statuses = ChangesetStatusModel().aggregate_votes_by_user(
188 statuses, reviewers)
189
190 c.commit_review_status = ChangesetStatus.STATUS_NOT_REVIEWED
191
192 c.commit_set_reviewers_data_json = collections.OrderedDict({'reviewers': []})
193
194 for review_obj, member, reasons, mandatory, status in review_statuses:
195 member_reviewer = h.reviewer_as_json(
196 member, reasons=reasons, mandatory=mandatory,
197 user_group=None
198 )
199
200 current_review_status = status[0][1].status if status else ChangesetStatus.STATUS_NOT_REVIEWED
201 member_reviewer['review_status'] = current_review_status
202 member_reviewer['review_status_label'] = h.commit_status_lbl(current_review_status)
203 member_reviewer['allowed_to_update'] = False
204 c.commit_set_reviewers_data_json['reviewers'].append(member_reviewer)
205
206 c.commit_set_reviewers_data_json = json.dumps(c.commit_set_reviewers_data_json)
207
208 # NOTE(marcink): this uses the same voting logic as in pull-requests
209 c.commit_review_status = ChangesetStatusModel().calculate_status(review_statuses)
210 c.commit_broadcast_channel = u'/repo${}$/commit/{}'.format(
211 c.repo_name,
212 commit.raw_id
213 )
214
158 215 diff = None
159 216 # Iterate over ranges (default commit view is always one commit)
160 217 for commit in c.commit_ranges:
@@ -166,8 +223,8 b' class RepoCommitsView(RepoAppView):'
166 223 if method == 'show':
167 224 inline_comments = CommentsModel().get_inline_comments(
168 225 self.db_repo.repo_id, revision=commit.raw_id)
169 c.inline_cnt = CommentsModel().get_inline_comments_count(
170 inline_comments)
226 c.inline_cnt = len(CommentsModel().get_inline_comments_as_list(
227 inline_comments))
171 228 c.inline_comments = inline_comments
172 229
173 230 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
@@ -226,6 +283,7 b' class RepoCommitsView(RepoAppView):'
226 283
227 284 # sort comments by how they were generated
228 285 c.comments = sorted(c.comments, key=lambda x: x.comment_id)
286 c.at_version_num = None
229 287
230 288 if len(c.commit_ranges) == 1:
231 289 c.commit = c.commit_ranges[0]
@@ -395,6 +453,7 b' class RepoCommitsView(RepoAppView):'
395 453 }
396 454 if comment:
397 455 c.co = comment
456 c.at_version_num = 0
398 457 rendered_comment = render(
399 458 'rhodecode:templates/changeset/changeset_comment_block.mako',
400 459 self._get_template_context(c), self.request)
@@ -427,7 +486,6 b' class RepoCommitsView(RepoAppView):'
427 486 return ''
428 487
429 488 @LoginRequired()
430 @NotAnonymous()
431 489 @HasRepoPermissionAnyDecorator(
432 490 'repository.read', 'repository.write', 'repository.admin')
433 491 @CSRFRequired()
@@ -39,7 +39,7 b' from rhodecode.lib.ext_json import json'
39 39 from rhodecode.lib.auth import (
40 40 LoginRequired, HasRepoPermissionAny, HasRepoPermissionAnyDecorator,
41 41 NotAnonymous, CSRFRequired)
42 from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode
42 from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode, safe_int
43 43 from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
44 44 from rhodecode.lib.vcs.exceptions import (
45 45 CommitDoesNotExistError, RepositoryRequirementError, EmptyRepositoryError)
@@ -265,6 +265,36 b' class RepoPullRequestsView(RepoAppView, '
265 265
266 266 return diffset
267 267
268 def register_comments_vars(self, c, pull_request, versions):
269 comments_model = CommentsModel()
270
271 # GENERAL COMMENTS with versions #
272 q = comments_model._all_general_comments_of_pull_request(pull_request)
273 q = q.order_by(ChangesetComment.comment_id.asc())
274 general_comments = q
275
276 # pick comments we want to render at current version
277 c.comment_versions = comments_model.aggregate_comments(
278 general_comments, versions, c.at_version_num)
279
280 # INLINE COMMENTS with versions #
281 q = comments_model._all_inline_comments_of_pull_request(pull_request)
282 q = q.order_by(ChangesetComment.comment_id.asc())
283 inline_comments = q
284
285 c.inline_versions = comments_model.aggregate_comments(
286 inline_comments, versions, c.at_version_num, inline=True)
287
288 # Comments inline+general
289 if c.at_version:
290 c.inline_comments_flat = c.inline_versions[c.at_version_num]['display']
291 c.comments = c.comment_versions[c.at_version_num]['display']
292 else:
293 c.inline_comments_flat = c.inline_versions[c.at_version_num]['until']
294 c.comments = c.comment_versions[c.at_version_num]['until']
295
296 return general_comments, inline_comments
297
268 298 @LoginRequired()
269 299 @HasRepoPermissionAnyDecorator(
270 300 'repository.read', 'repository.write', 'repository.admin')
@@ -280,6 +310,8 b' class RepoPullRequestsView(RepoAppView, '
280 310 pull_request_id = pull_request.pull_request_id
281 311
282 312 c.state_progressing = pull_request.is_state_changing()
313 c.pr_broadcast_channel = '/repo${}$/pr/{}'.format(
314 pull_request.target_repo.repo_name, pull_request.pull_request_id)
283 315
284 316 _new_state = {
285 317 'created': PullRequest.STATE_CREATED,
@@ -300,22 +332,23 b' class RepoPullRequestsView(RepoAppView, '
300 332 from_version = self.request.GET.get('from_version') or version
301 333 merge_checks = self.request.GET.get('merge_checks')
302 334 c.fulldiff = str2bool(self.request.GET.get('fulldiff'))
335 force_refresh = str2bool(self.request.GET.get('force_refresh'))
336 c.range_diff_on = self.request.GET.get('range-diff') == "1"
303 337
304 338 # fetch global flags of ignore ws or context lines
305 339 diff_context = diffs.get_diff_context(self.request)
306 340 hide_whitespace_changes = diffs.get_diff_whitespace_flag(self.request)
307 341
308 force_refresh = str2bool(self.request.GET.get('force_refresh'))
309
310 342 (pull_request_latest,
311 343 pull_request_at_ver,
312 344 pull_request_display_obj,
313 345 at_version) = PullRequestModel().get_pr_version(
314 346 pull_request_id, version=version)
347
315 348 pr_closed = pull_request_latest.is_closed()
316 349
317 350 if pr_closed and (version or from_version):
318 # not allow to browse versions
351 # not allow to browse versions for closed PR
319 352 raise HTTPFound(h.route_path(
320 353 'pullrequest_show', repo_name=self.db_repo_name,
321 354 pull_request_id=pull_request_id))
@@ -323,13 +356,13 b' class RepoPullRequestsView(RepoAppView, '
323 356 versions = pull_request_display_obj.versions()
324 357 # used to store per-commit range diffs
325 358 c.changes = collections.OrderedDict()
326 c.range_diff_on = self.request.GET.get('range-diff') == "1"
327 359
328 360 c.at_version = at_version
329 361 c.at_version_num = (at_version
330 if at_version and at_version != 'latest'
362 if at_version and at_version != PullRequest.LATEST_VER
331 363 else None)
332 c.at_version_pos = ChangesetComment.get_index_from_version(
364
365 c.at_version_index = ChangesetComment.get_index_from_version(
333 366 c.at_version_num, versions)
334 367
335 368 (prev_pull_request_latest,
@@ -340,9 +373,9 b' class RepoPullRequestsView(RepoAppView, '
340 373
341 374 c.from_version = prev_at_version
342 375 c.from_version_num = (prev_at_version
343 if prev_at_version and prev_at_version != 'latest'
376 if prev_at_version and prev_at_version != PullRequest.LATEST_VER
344 377 else None)
345 c.from_version_pos = ChangesetComment.get_index_from_version(
378 c.from_version_index = ChangesetComment.get_index_from_version(
346 379 c.from_version_num, versions)
347 380
348 381 # define if we're in COMPARE mode or VIEW at version mode
@@ -351,16 +384,21 b' class RepoPullRequestsView(RepoAppView, '
351 384 # pull_requests repo_name we opened it against
352 385 # ie. target_repo must match
353 386 if self.db_repo_name != pull_request_at_ver.target_repo.repo_name:
387 log.warning('Mismatch between the current repo: %s, and target %s',
388 self.db_repo_name, pull_request_at_ver.target_repo.repo_name)
354 389 raise HTTPNotFound()
355 390
356 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
357 pull_request_at_ver)
391 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(pull_request_at_ver)
358 392
359 393 c.pull_request = pull_request_display_obj
360 394 c.renderer = pull_request_at_ver.description_renderer or c.renderer
361 395 c.pull_request_latest = pull_request_latest
362 396
363 if compare or (at_version and not at_version == 'latest'):
397 # inject latest version
398 latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
399 c.versions = versions + [latest_ver]
400
401 if compare or (at_version and not at_version == PullRequest.LATEST_VER):
364 402 c.allowed_to_change_status = False
365 403 c.allowed_to_update = False
366 404 c.allowed_to_merge = False
@@ -389,12 +427,9 b' class RepoPullRequestsView(RepoAppView, '
389 427 'rules' in pull_request_latest.reviewer_data:
390 428 rules = pull_request_latest.reviewer_data['rules'] or {}
391 429 try:
392 c.forbid_adding_reviewers = rules.get(
393 'forbid_adding_reviewers')
394 c.forbid_author_to_review = rules.get(
395 'forbid_author_to_review')
396 c.forbid_commit_author_to_review = rules.get(
397 'forbid_commit_author_to_review')
430 c.forbid_adding_reviewers = rules.get('forbid_adding_reviewers')
431 c.forbid_author_to_review = rules.get('forbid_author_to_review')
432 c.forbid_commit_author_to_review = rules.get('forbid_commit_author_to_review')
398 433 except Exception:
399 434 pass
400 435
@@ -419,41 +454,34 b' class RepoPullRequestsView(RepoAppView, '
419 454 'rhodecode:templates/pullrequests/pullrequest_merge_checks.mako'
420 455 return self._get_template_context(c)
421 456
422 comments_model = CommentsModel()
457 c.allowed_reviewers = [obj.user_id for obj in pull_request.reviewers if obj.user]
423 458
424 459 # reviewers and statuses
425 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
426 allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
460 c.pull_request_default_reviewers_data_json = json.dumps(pull_request.reviewer_data)
461 c.pull_request_set_reviewers_data_json = collections.OrderedDict({'reviewers': []})
427 462
428 # GENERAL COMMENTS with versions #
429 q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
430 q = q.order_by(ChangesetComment.comment_id.asc())
431 general_comments = q
463 for review_obj, member, reasons, mandatory, status in pull_request_at_ver.reviewers_statuses():
464 member_reviewer = h.reviewer_as_json(
465 member, reasons=reasons, mandatory=mandatory,
466 user_group=review_obj.rule_user_group_data()
467 )
432 468
433 # pick comments we want to render at current version
434 c.comment_versions = comments_model.aggregate_comments(
435 general_comments, versions, c.at_version_num)
436 c.comments = c.comment_versions[c.at_version_num]['until']
469 current_review_status = status[0][1].status if status else ChangesetStatus.STATUS_NOT_REVIEWED
470 member_reviewer['review_status'] = current_review_status
471 member_reviewer['review_status_label'] = h.commit_status_lbl(current_review_status)
472 member_reviewer['allowed_to_update'] = c.allowed_to_update
473 c.pull_request_set_reviewers_data_json['reviewers'].append(member_reviewer)
437 474
438 # INLINE COMMENTS with versions #
439 q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
440 q = q.order_by(ChangesetComment.comment_id.asc())
441 inline_comments = q
475 c.pull_request_set_reviewers_data_json = json.dumps(c.pull_request_set_reviewers_data_json)
442 476
443 c.inline_versions = comments_model.aggregate_comments(
444 inline_comments, versions, c.at_version_num, inline=True)
477 general_comments, inline_comments = \
478 self.register_comments_vars(c, pull_request_latest, versions)
445 479
446 480 # TODOs
447 481 c.unresolved_comments = CommentsModel() \
448 .get_pull_request_unresolved_todos(pull_request)
482 .get_pull_request_unresolved_todos(pull_request_latest)
449 483 c.resolved_comments = CommentsModel() \
450 .get_pull_request_resolved_todos(pull_request)
451
452 # inject latest version
453 latest_ver = PullRequest.get_pr_display_object(
454 pull_request_latest, pull_request_latest)
455
456 c.versions = versions + [latest_ver]
484 .get_pull_request_resolved_todos(pull_request_latest)
457 485
458 486 # if we use version, then do not show later comments
459 487 # than current version
@@ -520,8 +548,8 b' class RepoPullRequestsView(RepoAppView, '
520 548
521 549 # empty version means latest, so we keep this to prevent
522 550 # double caching
523 version_normalized = version or 'latest'
524 from_version_normalized = from_version or 'latest'
551 version_normalized = version or PullRequest.LATEST_VER
552 from_version_normalized = from_version or PullRequest.LATEST_VER
525 553
526 554 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(target_repo)
527 555 cache_file_path = diff_cache_exist(
@@ -613,7 +641,7 b' class RepoPullRequestsView(RepoAppView, '
613 641 diff_limit, file_limit, c.fulldiff,
614 642 hide_whitespace_changes, diff_context,
615 643 use_ancestor=use_ancestor
616 )
644 )
617 645
618 646 # save cached diff
619 647 if caching_enabled:
@@ -717,7 +745,7 b' class RepoPullRequestsView(RepoAppView, '
717 745
718 746 # current user review statuses for each version
719 747 c.review_versions = {}
720 if self._rhodecode_user.user_id in allowed_reviewers:
748 if self._rhodecode_user.user_id in c.allowed_reviewers:
721 749 for co in general_comments:
722 750 if co.author.user_id == self._rhodecode_user.user_id:
723 751 status = co.status_change
@@ -937,6 +965,90 b' class RepoPullRequestsView(RepoAppView, '
937 965 @NotAnonymous()
938 966 @HasRepoPermissionAnyDecorator(
939 967 'repository.read', 'repository.write', 'repository.admin')
968 @view_config(
969 route_name='pullrequest_comments', request_method='POST',
970 renderer='string', xhr=True)
971 def pullrequest_comments(self):
972 self.load_default_context()
973
974 pull_request = PullRequest.get_or_404(
975 self.request.matchdict['pull_request_id'])
976 pull_request_id = pull_request.pull_request_id
977 version = self.request.GET.get('version')
978
979 _render = self.request.get_partial_renderer(
980 'rhodecode:templates/base/sidebar.mako')
981 c = _render.get_call_context()
982
983 (pull_request_latest,
984 pull_request_at_ver,
985 pull_request_display_obj,
986 at_version) = PullRequestModel().get_pr_version(
987 pull_request_id, version=version)
988 versions = pull_request_display_obj.versions()
989 latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
990 c.versions = versions + [latest_ver]
991
992 c.at_version = at_version
993 c.at_version_num = (at_version
994 if at_version and at_version != PullRequest.LATEST_VER
995 else None)
996
997 self.register_comments_vars(c, pull_request_latest, versions)
998 all_comments = c.inline_comments_flat + c.comments
999
1000 existing_ids = filter(
1001 lambda e: e, map(safe_int, self.request.POST.getall('comments[]')))
1002 return _render('comments_table', all_comments, len(all_comments),
1003 existing_ids=existing_ids)
1004
1005 @LoginRequired()
1006 @NotAnonymous()
1007 @HasRepoPermissionAnyDecorator(
1008 'repository.read', 'repository.write', 'repository.admin')
1009 @view_config(
1010 route_name='pullrequest_todos', request_method='POST',
1011 renderer='string', xhr=True)
1012 def pullrequest_todos(self):
1013 self.load_default_context()
1014
1015 pull_request = PullRequest.get_or_404(
1016 self.request.matchdict['pull_request_id'])
1017 pull_request_id = pull_request.pull_request_id
1018 version = self.request.GET.get('version')
1019
1020 _render = self.request.get_partial_renderer(
1021 'rhodecode:templates/base/sidebar.mako')
1022 c = _render.get_call_context()
1023 (pull_request_latest,
1024 pull_request_at_ver,
1025 pull_request_display_obj,
1026 at_version) = PullRequestModel().get_pr_version(
1027 pull_request_id, version=version)
1028 versions = pull_request_display_obj.versions()
1029 latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
1030 c.versions = versions + [latest_ver]
1031
1032 c.at_version = at_version
1033 c.at_version_num = (at_version
1034 if at_version and at_version != PullRequest.LATEST_VER
1035 else None)
1036
1037 c.unresolved_comments = CommentsModel() \
1038 .get_pull_request_unresolved_todos(pull_request)
1039 c.resolved_comments = CommentsModel() \
1040 .get_pull_request_resolved_todos(pull_request)
1041
1042 all_comments = c.unresolved_comments + c.resolved_comments
1043 existing_ids = filter(
1044 lambda e: e, map(safe_int, self.request.POST.getall('comments[]')))
1045 return _render('comments_table', all_comments, len(c.unresolved_comments),
1046 todo_comments=True, existing_ids=existing_ids)
1047
1048 @LoginRequired()
1049 @NotAnonymous()
1050 @HasRepoPermissionAnyDecorator(
1051 'repository.read', 'repository.write', 'repository.admin')
940 1052 @CSRFRequired()
941 1053 @view_config(
942 1054 route_name='pullrequest_create', request_method='POST',
@@ -1098,7 +1210,7 b' class RepoPullRequestsView(RepoAppView, '
1098 1210 self.request.matchdict['pull_request_id'])
1099 1211 _ = self.request.translate
1100 1212
1101 self.load_default_context()
1213 c = self.load_default_context()
1102 1214 redirect_url = None
1103 1215
1104 1216 if pull_request.is_closed():
@@ -1109,6 +1221,8 b' class RepoPullRequestsView(RepoAppView, '
1109 1221 'redirect_url': redirect_url}
1110 1222
1111 1223 is_state_changing = pull_request.is_state_changing()
1224 c.pr_broadcast_channel = '/repo${}$/pr/{}'.format(
1225 pull_request.target_repo.repo_name, pull_request.pull_request_id)
1112 1226
1113 1227 # only owner or admin can update it
1114 1228 allowed_to_update = PullRequestModel().check_user_update(
@@ -1132,7 +1246,7 b' class RepoPullRequestsView(RepoAppView, '
1132 1246 return {'response': True,
1133 1247 'redirect_url': redirect_url}
1134 1248
1135 self._update_commits(pull_request)
1249 self._update_commits(c, pull_request)
1136 1250 if force_refresh:
1137 1251 redirect_url = h.route_path(
1138 1252 'pullrequest_show', repo_name=self.db_repo_name,
@@ -1168,7 +1282,7 b' class RepoPullRequestsView(RepoAppView, '
1168 1282 h.flash(msg, category='success')
1169 1283 return
1170 1284
1171 def _update_commits(self, pull_request):
1285 def _update_commits(self, c, pull_request):
1172 1286 _ = self.request.translate
1173 1287
1174 1288 with pull_request.set_state(PullRequest.STATE_UPDATING):
@@ -1196,13 +1310,18 b' class RepoPullRequestsView(RepoAppView, '
1196 1310 change_source=changed)
1197 1311 h.flash(msg, category='success')
1198 1312
1199 channel = '/repo${}$/pr/{}'.format(
1200 pull_request.target_repo.repo_name, pull_request.pull_request_id)
1201 1313 message = msg + (
1202 1314 ' - <a onclick="window.location.reload()">'
1203 1315 '<strong>{}</strong></a>'.format(_('Reload page')))
1316
1317 message_obj = {
1318 'message': message,
1319 'level': 'success',
1320 'topic': '/notifications'
1321 }
1322
1204 1323 channelstream.post_message(
1205 channel, message, self._rhodecode_user.username,
1324 c.pr_broadcast_channel, message_obj, self._rhodecode_user.username,
1206 1325 registry=self.request.registry)
1207 1326 else:
1208 1327 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
@@ -1472,6 +1591,7 b' class RepoPullRequestsView(RepoAppView, '
1472 1591 }
1473 1592 if comment:
1474 1593 c.co = comment
1594 c.at_version_num = None
1475 1595 rendered_comment = render(
1476 1596 'rhodecode:templates/changeset/changeset_comment_block.mako',
1477 1597 self._get_template_context(c), self.request)
@@ -1890,7 +1890,7 b''
1890 1890 "url": "http://spdx.org/licenses/BSD-4-Clause.html"
1891 1891 }
1892 1892 ],
1893 "name": "python2.7-channelstream-0.5.2"
1893 "name": "python2.7-channelstream-0.6.14"
1894 1894 },
1895 1895 {
1896 1896 "license": [
@@ -53,7 +53,7 b' from rhodecode.lib.utils2 import aslist '
53 53 from rhodecode.lib.exc_tracking import store_exception
54 54 from rhodecode.subscribers import (
55 55 scan_repositories_if_enabled, write_js_routes_if_enabled,
56 write_metadata_if_needed, inject_app_settings)
56 write_metadata_if_needed, write_usage_data, inject_app_settings)
57 57
58 58
59 59 log = logging.getLogger(__name__)
@@ -316,6 +316,8 b' def includeme(config):'
316 316 pyramid.events.ApplicationCreated)
317 317 config.add_subscriber(write_metadata_if_needed,
318 318 pyramid.events.ApplicationCreated)
319 config.add_subscriber(write_usage_data,
320 pyramid.events.ApplicationCreated)
319 321 config.add_subscriber(write_js_routes_if_enabled,
320 322 pyramid.events.ApplicationCreated)
321 323
@@ -145,7 +145,7 b' class PullRequestCommentEvent(PullReques'
145 145
146 146 status = None
147 147 if self.comment.status_change:
148 status = self.comment.status_change[0].status
148 status = self.comment.review_status
149 149
150 150 data.update({
151 151 'comment': {
@@ -184,7 +184,7 b' class PullRequestCommentEditEvent(PullRe'
184 184
185 185 status = None
186 186 if self.comment.status_change:
187 status = self.comment.status_change[0].status
187 status = self.comment.review_status
188 188
189 189 data.update({
190 190 'comment': {
@@ -37,8 +37,9 b' log = logging.getLogger(__name__)'
37 37
38 38 LOCK = ReadWriteMutex()
39 39
40 STATE_PUBLIC_KEYS = ['id', 'username', 'first_name', 'last_name',
41 'icon_link', 'display_name', 'display_link']
40 USER_STATE_PUBLIC_KEYS = [
41 'id', 'username', 'first_name', 'last_name',
42 'icon_link', 'display_name', 'display_link']
42 43
43 44
44 45 class ChannelstreamException(Exception):
@@ -64,6 +65,8 b' def channelstream_request(config, payloa'
64 65 'x-channelstream-endpoint': endpoint,
65 66 'Content-Type': 'application/json'}
66 67 req_url = get_channelstream_server_url(config, endpoint)
68
69 log.debug('Sending a channelstream request to endpoint: `%s`', req_url)
67 70 response = None
68 71 try:
69 72 response = requests.post(req_url, data=json.dumps(payload),
@@ -76,6 +79,7 b' def channelstream_request(config, payloa'
76 79 log.exception('Exception related to Channelstream happened')
77 80 if raise_exc:
78 81 raise ChannelstreamConnectionException()
82 log.debug('Got channelstream response: %s', response)
79 83 return response
80 84
81 85
@@ -154,7 +158,7 b' def parse_channels_info(info_result, inc'
154 158 for userinfo in info_result['users']:
155 159 user_state_dict[userinfo['user']] = {
156 160 k: v for k, v in userinfo['state'].items()
157 if k in STATE_PUBLIC_KEYS
161 if k in USER_STATE_PUBLIC_KEYS
158 162 }
159 163
160 164 channels_info = {}
@@ -163,10 +167,10 b' def parse_channels_info(info_result, inc'
163 167 if c_name not in include_channel_info:
164 168 continue
165 169 connected_list = []
166 for userinfo in c_info['users']:
170 for username in c_info['users']:
167 171 connected_list.append({
168 'user': userinfo['user'],
169 'state': user_state_dict[userinfo['user']]
172 'user': username,
173 'state': user_state_dict[username]
170 174 })
171 175 channels_info[c_name] = {'users': connected_list,
172 176 'history': c_info['history']}
@@ -230,6 +234,14 b' def get_connection_validators(registry):'
230 234
231 235 def post_message(channel, message, username, registry=None):
232 236
237 message_obj = message
238 if isinstance(message, basestring):
239 message_obj = {
240 'message': message,
241 'level': 'success',
242 'topic': '/notifications'
243 }
244
233 245 if not registry:
234 246 registry = get_current_registry()
235 247
@@ -243,11 +255,7 b' def post_message(channel, message, usern'
243 255 'user': 'system',
244 256 'exclude_users': [username],
245 257 'channel': channel,
246 'message': {
247 'message': message,
248 'level': 'success',
249 'topic': '/notifications'
250 }
258 'message': message_obj
251 259 }
252 260
253 261 try:
@@ -90,7 +90,7 b' from rhodecode.lib.vcs.conf.settings imp'
90 90 from rhodecode.lib.index.search_utils import get_matching_line_offsets
91 91 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
92 92 from rhodecode.model.changeset_status import ChangesetStatusModel
93 from rhodecode.model.db import Permission, User, Repository, UserApiKeys
93 from rhodecode.model.db import Permission, User, Repository, UserApiKeys, FileStore
94 94 from rhodecode.model.repo_group import RepoGroupModel
95 95 from rhodecode.model.settings import IssueTrackerSettingsModel
96 96
@@ -810,8 +810,7 b' import tzlocal'
810 810 local_timezone = tzlocal.get_localzone()
811 811
812 812
813 def age_component(datetime_iso, value=None, time_is_local=False, tooltip=True):
814 title = value or format_date(datetime_iso)
813 def get_timezone(datetime_iso, time_is_local=False):
815 814 tzinfo = '+00:00'
816 815
817 816 # detect if we have a timezone info, otherwise, add it
@@ -822,6 +821,12 b' def age_component(datetime_iso, value=No'
822 821 timezone = force_timezone or local_timezone
823 822 offset = timezone.localize(datetime_iso).strftime('%z')
824 823 tzinfo = '{}:{}'.format(offset[:-2], offset[-2:])
824 return tzinfo
825
826
827 def age_component(datetime_iso, value=None, time_is_local=False, tooltip=True):
828 title = value or format_date(datetime_iso)
829 tzinfo = get_timezone(datetime_iso, time_is_local=time_is_local)
825 830
826 831 return literal(
827 832 '<time class="timeago {cls}" title="{tt_title}" datetime="{dt}{tzinfo}">{title}</time>'.format(
@@ -1357,20 +1362,76 b' class InitialsGravatar(object):'
1357 1362 return "data:image/svg+xml;base64,%s" % base64.b64encode(img_data)
1358 1363
1359 1364
1360 def initials_gravatar(email_address, first_name, last_name, size=30):
1365 def initials_gravatar(request, email_address, first_name, last_name, size=30, store_on_disk=False):
1366
1361 1367 svg_type = None
1362 1368 if email_address == User.DEFAULT_USER_EMAIL:
1363 1369 svg_type = 'default_user'
1370
1364 1371 klass = InitialsGravatar(email_address, first_name, last_name, size)
1365 return klass.generate_svg(svg_type=svg_type)
1372
1373 if store_on_disk:
1374 from rhodecode.apps.file_store import utils as store_utils
1375 from rhodecode.apps.file_store.exceptions import FileNotAllowedException, \
1376 FileOverSizeException
1377 from rhodecode.model.db import Session
1378
1379 image_key = md5_safe(email_address.lower()
1380 + first_name.lower() + last_name.lower())
1381
1382 storage = store_utils.get_file_storage(request.registry.settings)
1383 filename = '{}.svg'.format(image_key)
1384 subdir = 'gravatars'
1385 # since final name has a counter, we apply the 0
1386 uid = storage.apply_counter(0, store_utils.uid_filename(filename, randomized=False))
1387 store_uid = os.path.join(subdir, uid)
1388
1389 db_entry = FileStore.get_by_store_uid(store_uid)
1390 if db_entry:
1391 return request.route_path('download_file', fid=store_uid)
1392
1393 img_data = klass.get_img_data(svg_type=svg_type)
1394 img_file = store_utils.bytes_to_file_obj(img_data)
1395
1396 try:
1397 store_uid, metadata = storage.save_file(
1398 img_file, filename, directory=subdir,
1399 extensions=['.svg'], randomized_name=False)
1400 except (FileNotAllowedException, FileOverSizeException):
1401 raise
1402
1403 try:
1404 entry = FileStore.create(
1405 file_uid=store_uid, filename=metadata["filename"],
1406 file_hash=metadata["sha256"], file_size=metadata["size"],
1407 file_display_name=filename,
1408 file_description=u'user gravatar `{}`'.format(safe_unicode(filename)),
1409 hidden=True, check_acl=False, user_id=1
1410 )
1411 Session().add(entry)
1412 Session().commit()
1413 log.debug('Stored upload in DB as %s', entry)
1414 except Exception:
1415 raise
1416
1417 return request.route_path('download_file', fid=store_uid)
1418
1419 else:
1420 return klass.generate_svg(svg_type=svg_type)
1421
1422
1423 def gravatar_external(request, gravatar_url_tmpl, email_address, size=30):
1424 return safe_str(gravatar_url_tmpl)\
1425 .replace('{email}', email_address) \
1426 .replace('{md5email}', md5_safe(email_address.lower())) \
1427 .replace('{netloc}', request.host) \
1428 .replace('{scheme}', request.scheme) \
1429 .replace('{size}', safe_str(size))
1366 1430
1367 1431
1368 1432 def gravatar_url(email_address, size=30, request=None):
1369 request = get_current_request()
1433 request = request or get_current_request()
1370 1434 _use_gravatar = request.call_context.visual.use_gravatar
1371 _gravatar_url = request.call_context.visual.gravatar_url
1372
1373 _gravatar_url = _gravatar_url or User.DEFAULT_GRAVATAR_URL
1374 1435
1375 1436 email_address = email_address or User.DEFAULT_USER_EMAIL
1376 1437 if isinstance(email_address, unicode):
@@ -1379,21 +1440,15 b' def gravatar_url(email_address, size=30,'
1379 1440
1380 1441 # empty email or default user
1381 1442 if not email_address or email_address == User.DEFAULT_USER_EMAIL:
1382 return initials_gravatar(User.DEFAULT_USER_EMAIL, '', '', size=size)
1443 return initials_gravatar(request, User.DEFAULT_USER_EMAIL, '', '', size=size)
1383 1444
1384 1445 if _use_gravatar:
1385 # TODO: Disuse pyramid thread locals. Think about another solution to
1386 # get the host and schema here.
1387 request = get_current_request()
1388 tmpl = safe_str(_gravatar_url)
1389 tmpl = tmpl.replace('{email}', email_address)\
1390 .replace('{md5email}', md5_safe(email_address.lower())) \
1391 .replace('{netloc}', request.host)\
1392 .replace('{scheme}', request.scheme)\
1393 .replace('{size}', safe_str(size))
1394 return tmpl
1446 gravatar_url_tmpl = request.call_context.visual.gravatar_url \
1447 or User.DEFAULT_GRAVATAR_URL
1448 return gravatar_external(request, gravatar_url_tmpl, email_address, size=size)
1449
1395 1450 else:
1396 return initials_gravatar(email_address, '', '', size=size)
1451 return initials_gravatar(request, email_address, '', '', size=size)
1397 1452
1398 1453
1399 1454 def breadcrumb_repo_link(repo):
@@ -1560,7 +1615,7 b' def _process_url_func(match_obj, repo_na'
1560 1615 # named regex variables
1561 1616 named_vars.update(match_obj.groupdict())
1562 1617 _url = string.Template(entry['url']).safe_substitute(**named_vars)
1563 desc = string.Template(entry['desc']).safe_substitute(**named_vars)
1618 desc = string.Template(escape(entry['desc'])).safe_substitute(**named_vars)
1564 1619 hovercard_url = string.Template(entry.get('hovercard_url', '')).safe_substitute(**named_vars)
1565 1620
1566 1621 def quote_cleaner(input_str):
@@ -1600,17 +1655,18 b' def get_active_pattern_entries(repo_name'
1600 1655
1601 1656 pr_pattern_re = re.compile(r'(?:(?:^!)|(?: !))(\d+)')
1602 1657
1658 allowed_link_formats = [
1659 'html', 'rst', 'markdown', 'html+hovercard', 'rst+hovercard', 'markdown+hovercard']
1660
1603 1661
1604 1662 def process_patterns(text_string, repo_name, link_format='html', active_entries=None):
1605 1663
1606 allowed_formats = ['html', 'rst', 'markdown',
1607 'html+hovercard', 'rst+hovercard', 'markdown+hovercard']
1608 if link_format not in allowed_formats:
1664 if link_format not in allowed_link_formats:
1609 1665 raise ValueError('Link format can be only one of:{} got {}'.format(
1610 allowed_formats, link_format))
1666 allowed_link_formats, link_format))
1611 1667
1612 1668 if active_entries is None:
1613 log.debug('Fetch active patterns for repo: %s', repo_name)
1669 log.debug('Fetch active issue tracker patterns for repo: %s', repo_name)
1614 1670 active_entries = get_active_pattern_entries(repo_name)
1615 1671
1616 1672 issues_data = []
@@ -1668,7 +1724,8 b' def process_patterns(text_string, repo_n'
1668 1724 return new_text, issues_data
1669 1725
1670 1726
1671 def urlify_commit_message(commit_text, repository=None, active_pattern_entries=None):
1727 def urlify_commit_message(commit_text, repository=None, active_pattern_entries=None,
1728 issues_container=None):
1672 1729 """
1673 1730 Parses given text message and makes proper links.
1674 1731 issues are linked to given issue-server, and rest is a commit link
@@ -1691,6 +1748,9 b' def urlify_commit_message(commit_text, r'
1691 1748 new_text, issues = process_patterns(new_text, repository or '',
1692 1749 active_entries=active_pattern_entries)
1693 1750
1751 if issues_container is not None:
1752 issues_container.extend(issues)
1753
1694 1754 return literal(new_text)
1695 1755
1696 1756
@@ -1731,7 +1791,7 b' def renderer_from_filename(filename, exc'
1731 1791
1732 1792
1733 1793 def render(source, renderer='rst', mentions=False, relative_urls=None,
1734 repo_name=None, active_pattern_entries=None):
1794 repo_name=None, active_pattern_entries=None, issues_container=None):
1735 1795
1736 1796 def maybe_convert_relative_links(html_source):
1737 1797 if relative_urls:
@@ -1748,6 +1808,8 b" def render(source, renderer='rst', menti"
1748 1808 source, issues = process_patterns(
1749 1809 source, repo_name, link_format='rst',
1750 1810 active_entries=active_pattern_entries)
1811 if issues_container is not None:
1812 issues_container.extend(issues)
1751 1813
1752 1814 return literal(
1753 1815 '<div class="rst-block">%s</div>' %
@@ -1760,6 +1822,8 b" def render(source, renderer='rst', menti"
1760 1822 source, issues = process_patterns(
1761 1823 source, repo_name, link_format='markdown',
1762 1824 active_entries=active_pattern_entries)
1825 if issues_container is not None:
1826 issues_container.extend(issues)
1763 1827
1764 1828 return literal(
1765 1829 '<div class="markdown-block">%s</div>' %
@@ -139,6 +139,18 b' def is_vcs_call(environ):'
139 139 return False
140 140
141 141
142 def get_path_elem(route_path):
143 if not route_path:
144 return None
145
146 cleaned_route_path = route_path.lstrip('/')
147 if cleaned_route_path:
148 cleaned_route_path_elems = cleaned_route_path.split('/')
149 if cleaned_route_path_elems:
150 return cleaned_route_path_elems[0]
151 return None
152
153
142 154 def detect_vcs_request(environ, backends):
143 155 checks = {
144 156 'hg': (is_hg, SimpleHg),
@@ -146,6 +158,17 b' def detect_vcs_request(environ, backends'
146 158 'svn': (is_svn, SimpleSvn),
147 159 }
148 160 handler = None
161 # List of path views first chunk we don't do any checks
162 white_list = [
163 # e.g /_file_store/download
164 '_file_store'
165 ]
166
167 path_info = environ['PATH_INFO']
168
169 if get_path_elem(path_info) in white_list:
170 log.debug('path `%s` in whitelist, skipping...', path_info)
171 return handler
149 172
150 173 if VCS_TYPE_KEY in environ:
151 174 raw_type = environ[VCS_TYPE_KEY]
@@ -224,7 +224,10 b' class RedisAuthSessions(BaseAuthSessions'
224 224 data = client.get(key)
225 225 if data:
226 226 json_data = pickle.loads(data)
227 accessed_time = json_data['_accessed_time']
227 try:
228 accessed_time = json_data['_accessed_time']
229 except KeyError:
230 accessed_time = 0
228 231 if accessed_time < expiry_time:
229 232 client.delete(key)
230 233 deleted_keys += 1
@@ -212,10 +212,10 b' class ChangesetStatusModel(BaseModel):'
212 212 # TODO(marcink): with group voting, how does rejected work,
213 213 # do we ever get rejected state ?
214 214
215 if approved_votes_count == reviewers_number:
215 if approved_votes_count and (approved_votes_count == reviewers_number):
216 216 return ChangesetStatus.STATUS_APPROVED
217 217
218 if rejected_votes_count == reviewers_number:
218 if rejected_votes_count and (rejected_votes_count == reviewers_number):
219 219 return ChangesetStatus.STATUS_REJECTED
220 220
221 221 return ChangesetStatus.STATUS_UNDER_REVIEW
@@ -354,34 +354,37 b' class ChangesetStatusModel(BaseModel):'
354 354 Session().add(new_status)
355 355 return new_statuses
356 356
357 def aggregate_votes_by_user(self, commit_statuses, reviewers_data):
358
359 commit_statuses_map = collections.defaultdict(list)
360 for st in commit_statuses:
361 commit_statuses_map[st.author.username] += [st]
362
363 reviewers = []
364
365 def version(commit_status):
366 return commit_status.version
367
368 for obj in reviewers_data:
369 if not obj.user:
370 continue
371 statuses = commit_statuses_map.get(obj.user.username, None)
372 if statuses:
373 status_groups = itertools.groupby(
374 sorted(statuses, key=version), version)
375 statuses = [(x, list(y)[0]) for x, y in status_groups]
376
377 reviewers.append((obj, obj.user, obj.reasons, obj.mandatory, statuses))
378
379 return reviewers
380
357 381 def reviewers_statuses(self, pull_request):
358 382 _commit_statuses = self.get_statuses(
359 383 pull_request.source_repo,
360 384 pull_request=pull_request,
361 385 with_revisions=True)
362 386
363 commit_statuses = collections.defaultdict(list)
364 for st in _commit_statuses:
365 commit_statuses[st.author.username] += [st]
366
367 pull_request_reviewers = []
368
369 def version(commit_status):
370 return commit_status.version
371
372 for obj in pull_request.reviewers:
373 if not obj.user:
374 continue
375 statuses = commit_statuses.get(obj.user.username, None)
376 if statuses:
377 status_groups = itertools.groupby(
378 sorted(statuses, key=version), version)
379 statuses = [(x, list(y)[0]) for x, y in status_groups]
380
381 pull_request_reviewers.append(
382 (obj, obj.user, obj.reasons, obj.mandatory, statuses))
383
384 return pull_request_reviewers
387 return self.aggregate_votes_by_user(_commit_statuses, pull_request.reviewers)
385 388
386 389 def calculated_review_status(self, pull_request, reviewers_statuses=None):
387 390 """
@@ -91,8 +91,7 b' class CommentsModel(BaseModel):'
91 91 # group by versions, and count until, and display objects
92 92
93 93 comment_groups = collections.defaultdict(list)
94 [comment_groups[
95 _co.pull_request_version_id].append(_co) for _co in comments]
94 [comment_groups[_co.pull_request_version_id].append(_co) for _co in comments]
96 95
97 96 def yield_comments(pos):
98 97 for co in comment_groups[pos]:
@@ -229,6 +228,14 b' class CommentsModel(BaseModel):'
229 228
230 229 return todos
231 230
231 def get_commit_inline_comments(self, commit_id):
232 inline_comments = Session().query(ChangesetComment) \
233 .filter(ChangesetComment.line_no != None) \
234 .filter(ChangesetComment.f_path != None) \
235 .filter(ChangesetComment.revision == commit_id)
236 inline_comments = inline_comments.all()
237 return inline_comments
238
232 239 def _log_audit_action(self, action, action_data, auth_user, comment):
233 240 audit_logger.store(
234 241 action=action,
@@ -456,38 +463,54 b' class CommentsModel(BaseModel):'
456 463 else:
457 464 action = 'repo.commit.comment.create'
458 465
466 comment_id = comment.comment_id
459 467 comment_data = comment.get_api_data()
468
460 469 self._log_audit_action(
461 470 action, {'data': comment_data}, auth_user, comment)
462 471
463 msg_url = ''
464 472 channel = None
465 473 if commit_obj:
466 msg_url = commit_comment_url
467 474 repo_name = repo.repo_name
468 475 channel = u'/repo${}$/commit/{}'.format(
469 476 repo_name,
470 477 commit_obj.raw_id
471 478 )
472 479 elif pull_request_obj:
473 msg_url = pr_comment_url
474 480 repo_name = pr_target_repo.repo_name
475 481 channel = u'/repo${}$/pr/{}'.format(
476 482 repo_name,
477 pull_request_id
483 pull_request_obj.pull_request_id
478 484 )
479 485
480 message = '<strong>{}</strong> {} - ' \
481 '<a onclick="window.location=\'{}\';' \
482 'window.location.reload()">' \
483 '<strong>{}</strong></a>'
484 message = message.format(
485 user.username, _('made a comment'), msg_url,
486 _('Show it now'))
486 if channel:
487 username = user.username
488 message = '<strong>{}</strong> {} #{}, {}'
489 message = message.format(
490 username,
491 _('posted a new comment'),
492 comment_id,
493 _('Refresh the page to see new comments.'))
487 494
488 channelstream.post_message(
489 channel, message, user.username,
490 registry=get_current_registry())
495 message_obj = {
496 'message': message,
497 'level': 'success',
498 'topic': '/notifications'
499 }
500
501 channelstream.post_message(
502 channel, message_obj, user.username,
503 registry=get_current_registry())
504
505 message_obj = {
506 'message': None,
507 'user': username,
508 'comment_id': comment_id,
509 'topic': '/comment'
510 }
511 channelstream.post_message(
512 channel, message_obj, user.username,
513 registry=get_current_registry())
491 514
492 515 return comment
493 516
@@ -641,16 +664,16 b' class CommentsModel(BaseModel):'
641 664 q = self._get_inline_comments_query(repo_id, revision, pull_request)
642 665 return self._group_comments_by_path_and_line_number(q)
643 666
644 def get_inline_comments_count(self, inline_comments, skip_outdated=True,
645 version=None):
646 inline_cnt = 0
667 def get_inline_comments_as_list(self, inline_comments, skip_outdated=True,
668 version=None):
669 inline_comms = []
647 670 for fname, per_line_comments in inline_comments.iteritems():
648 671 for lno, comments in per_line_comments.iteritems():
649 672 for comm in comments:
650 673 if not comm.outdated_at_version(version) and skip_outdated:
651 inline_cnt += 1
674 inline_comms.append(comm)
652 675
653 return inline_cnt
676 return inline_comms
654 677
655 678 def get_outdated_comments(self, repo_id, pull_request):
656 679 # TODO: johbo: Remove `repo_id`, it is not needed to find the comments
@@ -3810,6 +3810,10 b' class ChangesetComment(Base, BaseModel):'
3810 3810 return self.display_state == self.COMMENT_OUTDATED
3811 3811
3812 3812 @property
3813 def outdated_js(self):
3814 return json.dumps(self.display_state == self.COMMENT_OUTDATED)
3815
3816 @property
3813 3817 def immutable(self):
3814 3818 return self.immutable_state == self.OP_IMMUTABLE
3815 3819
@@ -3817,16 +3821,35 b' class ChangesetComment(Base, BaseModel):'
3817 3821 """
3818 3822 Checks if comment is outdated for given pull request version
3819 3823 """
3820 return self.outdated and self.pull_request_version_id != version
3824 def version_check():
3825 return self.pull_request_version_id and self.pull_request_version_id != version
3826
3827 if self.is_inline:
3828 return self.outdated and version_check()
3829 else:
3830 # general comments don't have .outdated set, also latest don't have a version
3831 return version_check()
3832
3833 def outdated_at_version_js(self, version):
3834 """
3835 Checks if comment is outdated for given pull request version
3836 """
3837 return json.dumps(self.outdated_at_version(version))
3821 3838
3822 3839 def older_than_version(self, version):
3823 3840 """
3824 3841 Checks if comment is made from previous version than given
3825 3842 """
3826 3843 if version is None:
3827 return self.pull_request_version_id is not None
3828
3829 return self.pull_request_version_id < version
3844 return self.pull_request_version != version
3845
3846 return self.pull_request_version < version
3847
3848 def older_than_version_js(self, version):
3849 """
3850 Checks if comment is made from previous version than given
3851 """
3852 return json.dumps(self.older_than_version(version))
3830 3853
3831 3854 @property
3832 3855 def commit_id(self):
@@ -3843,7 +3866,9 b' class ChangesetComment(Base, BaseModel):'
3843 3866
3844 3867 @property
3845 3868 def is_inline(self):
3846 return self.line_no and self.f_path
3869 if self.line_no and self.f_path:
3870 return True
3871 return False
3847 3872
3848 3873 @property
3849 3874 def last_version(self):
@@ -3856,6 +3881,16 b' class ChangesetComment(Base, BaseModel):'
3856 3881 return self.get_index_from_version(
3857 3882 self.pull_request_version_id, versions)
3858 3883
3884 @property
3885 def review_status(self):
3886 if self.status_change:
3887 return self.status_change[0].status
3888
3889 @property
3890 def review_status_lbl(self):
3891 if self.status_change:
3892 return self.status_change[0].status_lbl
3893
3859 3894 def __repr__(self):
3860 3895 if self.comment_id:
3861 3896 return '<DB:Comment #%s>' % self.comment_id
@@ -4134,6 +4169,23 b' class _PullRequestBase(BaseModel):'
4134 4169 return json.dumps(self.reviewer_data)
4135 4170
4136 4171 @property
4172 def last_merge_metadata_parsed(self):
4173 metadata = {}
4174 if not self.last_merge_metadata:
4175 return metadata
4176
4177 if hasattr(self.last_merge_metadata, 'de_coerce'):
4178 for k, v in self.last_merge_metadata.de_coerce().items():
4179 if k in ['target_ref', 'source_ref']:
4180 metadata[k] = Reference(v['type'], v['name'], v['commit_id'])
4181 else:
4182 if hasattr(v, 'de_coerce'):
4183 metadata[k] = v.de_coerce()
4184 else:
4185 metadata[k] = v
4186 return metadata
4187
4188 @property
4137 4189 def work_in_progress(self):
4138 4190 """checks if pull request is work in progress by checking the title"""
4139 4191 title = self.title.upper()
@@ -4306,6 +4358,7 b' class PullRequest(Base, _PullRequestBase'
4306 4358 __table_args__ = (
4307 4359 base_table_args,
4308 4360 )
4361 LATEST_VER = 'latest'
4309 4362
4310 4363 pull_request_id = Column(
4311 4364 'pull_request_id', Integer(), nullable=False, primary_key=True)
@@ -4364,6 +4417,10 b' class PullRequest(Base, _PullRequestBase'
4364 4417 def pull_request_version_id(self):
4365 4418 return getattr(pull_request_obj, 'pull_request_version_id', None)
4366 4419
4420 @property
4421 def pull_request_last_version(self):
4422 return pull_request_obj.pull_request_last_version
4423
4367 4424 attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False))
4368 4425
4369 4426 attrs.author = StrictAttributeDict(
@@ -4428,6 +4485,10 b' class PullRequest(Base, _PullRequestBase'
4428 4485 """
4429 4486 return self.versions.count() + 1
4430 4487
4488 @property
4489 def pull_request_last_version(self):
4490 return self.versions_count
4491
4431 4492
4432 4493 class PullRequestVersion(Base, _PullRequestBase):
4433 4494 __tablename__ = 'pull_request_versions'
@@ -4475,6 +4536,8 b' class PullRequestReviewers(Base, BaseMod'
4475 4536 __table_args__ = (
4476 4537 base_table_args,
4477 4538 )
4539 ROLE_REVIEWER = u'reviewer'
4540 ROLE_OBSERVER = u'observer'
4478 4541
4479 4542 @hybrid_property
4480 4543 def reasons(self):
@@ -4502,6 +4565,8 b' class PullRequestReviewers(Base, BaseMod'
4502 4565 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
4503 4566
4504 4567 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4568 role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
4569
4505 4570 user = relationship('User')
4506 4571 pull_request = relationship('PullRequest')
4507 4572
@@ -5425,8 +5490,11 b' class FileStore(Base, BaseModel):'
5425 5490 repo_group = relationship('RepoGroup', lazy='joined')
5426 5491
5427 5492 @classmethod
5428 def get_by_store_uid(cls, file_store_uid):
5429 return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
5493 def get_by_store_uid(cls, file_store_uid, safe=False):
5494 if safe:
5495 return FileStore.query().filter(FileStore.file_uid == file_store_uid).first()
5496 else:
5497 return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
5430 5498
5431 5499 @classmethod
5432 5500 def create(cls, file_uid, filename, file_hash, file_size, file_display_name='',
@@ -1600,7 +1600,7 b' class PullRequestModel(BaseModel):'
1600 1600 'source_ref': pull_request.source_ref_parts,
1601 1601 }
1602 1602 if pull_request.last_merge_metadata:
1603 metadata.update(pull_request.last_merge_metadata)
1603 metadata.update(pull_request.last_merge_metadata_parsed)
1604 1604
1605 1605 if not possible and target_ref.type == 'branch':
1606 1606 # NOTE(marcink): case for mercurial multiple heads on branch
@@ -55,3 +55,16 b''
55 55 margin: 0 auto 35px auto;
56 56 }
57 57 }
58
59 .alert-text-success {
60 color: @alert1;
61
62 }
63
64 .alert-text-error {
65 color: @alert2;
66 }
67
68 .alert-text-warning {
69 color: @alert3;
70 }
@@ -254,7 +254,7 b' input[type="button"] {'
254 254
255 255 .btn-group-actions {
256 256 position: relative;
257 z-index: 100;
257 z-index: 50;
258 258
259 259 &:not(.open) .btn-action-switcher-container {
260 260 display: none;
@@ -1078,10 +1078,16 b' input.filediff-collapse-state {'
1078 1078 background: @color5;
1079 1079 color: white;
1080 1080 }
1081
1081 1082 &[op="comments"] { /* comments on file */
1082 1083 background: @grey4;
1083 1084 color: white;
1084 1085 }
1086
1087 &[op="options"] { /* context menu */
1088 background: @grey6;
1089 color: black;
1090 }
1085 1091 }
1086 1092 }
1087 1093
@@ -31,6 +31,10 b' a { cursor: pointer; }'
31 31 clear: both;
32 32 }
33 33
34 .display-none {
35 display: none;
36 }
37
34 38 .pull-right {
35 39 float: right !important;
36 40 }
@@ -240,14 +240,14 b' div.markdown-block ol {'
240 240 div.markdown-block ul.checkbox li,
241 241 div.markdown-block ol.checkbox li {
242 242 list-style: none !important;
243 margin: 6px !important;
243 margin: 0px !important;
244 244 padding: 0 !important;
245 245 }
246 246
247 247 div.markdown-block ul li,
248 248 div.markdown-block ol li {
249 249 list-style: disc !important;
250 margin: 6px !important;
250 margin: 0px !important;
251 251 padding: 0 !important;
252 252 }
253 253
@@ -83,6 +83,11 b' body {'
83 83 }
84 84 }
85 85
86 .flex-container {
87 display: flex;
88 justify-content: space-between;
89 }
90
86 91 .action-link{
87 92 margin-left: @padding;
88 93 padding-left: @padding;
@@ -482,10 +487,15 b' ul.auth_plugins {'
482 487 text-align: left;
483 488 overflow: hidden;
484 489 white-space: pre-line;
485 }
486
487 .pr-details-title {
488 height: 16px
490 padding-top: 5px
491 }
492
493 #add_reviewer {
494 padding-top: 10px;
495 }
496
497 #add_reviewer_input {
498 padding-top: 10px
489 499 }
490 500
491 501 .pr-details-title-author-pref {
@@ -1173,9 +1183,12 b' label {'
1173 1183 a {
1174 1184 color: @grey5
1175 1185 }
1176 @media screen and (max-width: 1200px) {
1186
1187 // 1024px or smaller
1188 @media screen and (max-width: 1180px) {
1177 1189 display: none;
1178 1190 }
1191
1179 1192 }
1180 1193
1181 1194 img {
@@ -1492,26 +1505,17 b' table.integrations {'
1492 1505
1493 1506 // Pull Requests
1494 1507 .summary-details {
1495 width: 72%;
1508 width: 100%;
1496 1509 }
1497 1510 .pr-summary {
1498 1511 border-bottom: @border-thickness solid @grey5;
1499 1512 margin-bottom: @space;
1500 1513 }
1501 1514
1502 .reviewers-title {
1503 width: 25%;
1504 min-width: 200px;
1505
1506 &.first-panel {
1507 margin-top: 34px;
1508 }
1509 }
1510
1511 1515 .reviewers {
1512 width: 25%;
1513 min-width: 200px;
1514 }
1516 width: 98%;
1517 }
1518
1515 1519 .reviewers ul li {
1516 1520 position: relative;
1517 1521 width: 100%;
@@ -1523,18 +1527,14 b' table.integrations {'
1523 1527 min-height: 55px;
1524 1528 }
1525 1529
1526 .reviewers_member {
1527 width: 100%;
1528 overflow: auto;
1529 }
1530 1530 .reviewer_reason {
1531 1531 padding-left: 20px;
1532 1532 line-height: 1.5em;
1533 1533 }
1534 1534 .reviewer_status {
1535 1535 display: inline-block;
1536 width: 25px;
1537 min-width: 25px;
1536 width: 20px;
1537 min-width: 20px;
1538 1538 height: 1.2em;
1539 1539 line-height: 1em;
1540 1540 }
@@ -1557,25 +1557,20 b' table.integrations {'
1557 1557 }
1558 1558
1559 1559 .reviewer_member_mandatory {
1560 position: absolute;
1561 left: 15px;
1562 top: 8px;
1563 1560 width: 16px;
1564 1561 font-size: 11px;
1565 1562 margin: 0;
1566 1563 padding: 0;
1567 1564 color: black;
1565 opacity: 0.4;
1568 1566 }
1569 1567
1570 1568 .reviewer_member_mandatory_remove,
1571 1569 .reviewer_member_remove {
1572 position: absolute;
1573 right: 0;
1574 top: 0;
1575 1570 width: 16px;
1576 margin-bottom: 10px;
1577 1571 padding: 0;
1578 1572 color: black;
1573 cursor: pointer;
1579 1574 }
1580 1575
1581 1576 .reviewer_member_mandatory_remove {
@@ -1593,6 +1588,9 b' table.integrations {'
1593 1588 cursor: pointer;
1594 1589 }
1595 1590 .pr-details-title {
1591 height: 20px;
1592 line-height: 20px;
1593
1596 1594 padding-bottom: 8px;
1597 1595 border-bottom: @border-thickness solid @grey5;
1598 1596
@@ -1617,7 +1615,7 b' table.integrations {'
1617 1615 text-decoration: line-through;
1618 1616 }
1619 1617
1620 .todo-table {
1618 .todo-table, .comments-table {
1621 1619 width: 100%;
1622 1620
1623 1621 td {
@@ -1627,7 +1625,8 b' table.integrations {'
1627 1625 .td-todo-number {
1628 1626 text-align: left;
1629 1627 white-space: nowrap;
1630 width: 15%;
1628 width: 1%;
1629 padding-right: 2px;
1631 1630 }
1632 1631
1633 1632 .td-todo-gravatar {
@@ -1651,10 +1650,13 b' table.integrations {'
1651 1650 text-overflow: ellipsis;
1652 1651 }
1653 1652
1653 table.group_members {
1654 width: 100%
1655 }
1656
1654 1657 .group_members {
1655 1658 margin-top: 0;
1656 1659 padding: 0;
1657 list-style: outside none none;
1658 1660
1659 1661 img {
1660 1662 height: @gravatar-size;
@@ -1698,7 +1700,7 b' table.integrations {'
1698 1700 }
1699 1701
1700 1702 .reviewer_ac .ac-input {
1701 width: 92%;
1703 width: 100%;
1702 1704 margin-bottom: 1em;
1703 1705 }
1704 1706
@@ -2772,7 +2774,7 b' table.rctable td.td-search-results div {'
2772 2774 }
2773 2775
2774 2776 #help_kb .modal-content{
2775 max-width: 750px;
2777 max-width: 800px;
2776 2778 margin: 10% auto;
2777 2779
2778 2780 table{
@@ -3069,4 +3071,141 b' form.markup-form {'
3069 3071
3070 3072 .pr-hovercard-title {
3071 3073 padding-top: 5px;
3072 } No newline at end of file
3074 }
3075
3076 .action-divider {
3077 opacity: 0.5;
3078 }
3079
3080 .details-inline-block {
3081 display: inline-block;
3082 position: relative;
3083 }
3084
3085 .details-inline-block summary {
3086 list-style: none;
3087 }
3088
3089 details:not([open]) > :not(summary) {
3090 display: none !important;
3091 }
3092
3093 .details-reset > summary {
3094 list-style: none;
3095 }
3096
3097 .details-reset > summary::-webkit-details-marker {
3098 display: none;
3099 }
3100
3101 .details-dropdown {
3102 position: absolute;
3103 top: 100%;
3104 width: 185px;
3105 list-style: none;
3106 background-color: #fff;
3107 background-clip: padding-box;
3108 border: 1px solid @grey5;
3109 box-shadow: 0 8px 24px rgba(149, 157, 165, .2);
3110 left: -150px;
3111 text-align: left;
3112 z-index: 90;
3113 }
3114
3115 .dropdown-divider {
3116 display: block;
3117 height: 0;
3118 margin: 8px 0;
3119 border-top: 1px solid @grey5;
3120 }
3121
3122 .dropdown-item {
3123 display: block;
3124 padding: 4px 8px 4px 16px;
3125 overflow: hidden;
3126 text-overflow: ellipsis;
3127 white-space: nowrap;
3128 font-weight: normal;
3129 }
3130
3131 .right-sidebar {
3132 position: fixed;
3133 top: 0px;
3134 bottom: 0;
3135 right: 0;
3136
3137 background: #fafafa;
3138 z-index: 50;
3139 }
3140
3141 .right-sidebar {
3142 border-left: 1px solid @grey5;
3143 }
3144
3145 .right-sidebar.right-sidebar-expanded {
3146 width: 300px;
3147 overflow: scroll;
3148 }
3149
3150 .right-sidebar.right-sidebar-collapsed {
3151 width: 40px;
3152 padding: 0;
3153 display: block;
3154 overflow: hidden;
3155 }
3156
3157 .sidenav {
3158 float: right;
3159 will-change: min-height;
3160 background: #fafafa;
3161 width: 100%;
3162 }
3163
3164 .sidebar-toggle {
3165 height: 30px;
3166 text-align: center;
3167 margin: 15px 0px 0 0;
3168 }
3169
3170 .sidebar-toggle a {
3171
3172 }
3173
3174 .sidebar-content {
3175 margin-left: 15px;
3176 margin-right: 15px;
3177 }
3178
3179 .sidebar-heading {
3180 font-size: 1.2em;
3181 font-weight: 700;
3182 margin-top: 10px;
3183 }
3184
3185 .sidebar-element {
3186 margin-top: 20px;
3187 }
3188
3189 .right-sidebar-collapsed-state {
3190 display: flex;
3191 flex-direction: column;
3192 justify-content: center;
3193 align-items: center;
3194 padding: 0 10px;
3195 cursor: pointer;
3196 font-size: 1.3em;
3197 margin: 0 -15px;
3198 }
3199
3200 .right-sidebar-collapsed-state:hover {
3201 background-color: @grey5;
3202 }
3203
3204 .old-comments-marker {
3205 text-align: left;
3206 }
3207
3208 .old-comments-marker td {
3209 padding-top: 15px;
3210 border-bottom: 1px solid @grey5;
3211 }
@@ -790,7 +790,7 b' input {'
790 790
791 791 &.main_filter_input {
792 792 padding: 5px 10px;
793 min-width: 340px;
793
794 794 color: @grey7;
795 795 background: @black;
796 796 min-height: 18px;
@@ -800,11 +800,34 b' input {'
800 800 color: @grey2 !important;
801 801 background: white !important;
802 802 }
803
803 804 &:focus {
804 805 color: @grey2 !important;
805 806 background: white !important;
806 807 }
808
809 min-width: 360px;
810
811 @media screen and (max-width: 1600px) {
812 min-width: 300px;
813 }
814 @media screen and (max-width: 1500px) {
815 min-width: 280px;
816 }
817 @media screen and (max-width: 1400px) {
818 min-width: 260px;
819 }
820 @media screen and (max-width: 1300px) {
821 min-width: 240px;
822 }
823 @media screen and (max-width: 1200px) {
824 min-width: 220px;
825 }
826 @media screen and (max-width: 720px) {
827 min-width: 140px;
828 }
807 829 }
830
808 831 }
809 832
810 833
@@ -168,6 +168,7 b''
168 168 .icon-remove:before { content: '\e810'; } /* '' */
169 169 .icon-fork:before { content: '\e811'; } /* 'ξ ‘' */
170 170 .icon-more:before { content: '\e812'; } /* 'ξ ’' */
171 .icon-options:before { content: '\e812'; } /* 'ξ ’' */
171 172 .icon-search:before { content: '\e813'; } /* 'ξ “' */
172 173 .icon-scissors:before { content: '\e814'; } /* 'ξ ”' */
173 174 .icon-download:before { content: '\e815'; } /* 'ξ •' */
@@ -251,6 +252,7 b''
251 252 // TRANSFORM
252 253 .icon-merge:before {transform: rotate(180deg);}
253 254 .icon-wide-mode:before {transform: rotate(90deg);}
255 .icon-options:before {transform: rotate(90deg);}
254 256
255 257 // -- END ICON CLASSES -- //
256 258
@@ -131,6 +131,11 b' function setRCMouseBindings(repoName, re'
131 131 window.location = pyroutes.url(
132 132 'edit_repo_perms', {'repo_name': repoName});
133 133 });
134 Mousetrap.bind(['t s'], function(e) {
135 if (window.toggleSidebar !== undefined) {
136 window.toggleSidebar();
137 }
138 });
134 139 }
135 140 }
136 141
@@ -246,6 +246,8 b' function registerRCRoutes() {'
246 246 pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']);
247 247 pyroutes.register('pullrequest_comment_edit', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/edit', ['repo_name', 'pull_request_id', 'comment_id']);
248 248 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']);
249 pyroutes.register('pullrequest_comments', '/%(repo_name)s/pull-request/%(pull_request_id)s/comments', ['repo_name', 'pull_request_id']);
250 pyroutes.register('pullrequest_todos', '/%(repo_name)s/pull-request/%(pull_request_id)s/todos', ['repo_name', 'pull_request_id']);
249 251 pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
250 252 pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']);
251 253 pyroutes.register('edit_repo_advanced_archive', '/%(repo_name)s/settings/advanced/archive', ['repo_name']);
@@ -28,9 +28,12 b' export class RhodecodeApp extends Polyme'
28 28 super.connectedCallback();
29 29 ccLog.debug('rhodeCodeApp created');
30 30 $.Topic('/notifications').subscribe(this.handleNotifications.bind(this));
31 $.Topic('/comment').subscribe(this.handleComment.bind(this));
31 32 $.Topic('/favicon/update').subscribe(this.faviconUpdate.bind(this));
32 33 $.Topic('/connection_controller/subscribe').subscribe(
33 this.subscribeToChannelTopic.bind(this));
34 this.subscribeToChannelTopic.bind(this)
35 );
36
34 37 // this event can be used to coordinate plugins to do their
35 38 // initialization before channelstream is kicked off
36 39 $.Topic('/__MAIN_APP__').publish({});
@@ -71,6 +74,14 b' export class RhodecodeApp extends Polyme'
71 74
72 75 }
73 76
77 handleComment(data) {
78 if (data.message.comment_id) {
79 if (window.refreshAllComments !== undefined) {
80 refreshAllComments()
81 }
82 }
83 }
84
74 85 faviconUpdate(data) {
75 86 this.shadowRoot.querySelector('rhodecode-favicon').counter = data.count;
76 87 }
@@ -95,6 +106,7 b' export class RhodecodeApp extends Polyme'
95 106 }
96 107 // append any additional channels registered in other plugins
97 108 $.Topic('/connection_controller/subscribe').processPrepared();
109
98 110 channelstreamConnection.connect();
99 111 }
100 112 }
@@ -157,8 +169,7 b' export class RhodecodeApp extends Polyme'
157 169
158 170 handleConnected(event) {
159 171 var channelstreamConnection = this.getChannelStreamConnection();
160 channelstreamConnection.set('channelsState',
161 event.detail.channels_info);
172 channelstreamConnection.set('channelsState', event.detail.channels_info);
162 173 channelstreamConnection.set('userState', event.detail.state);
163 174 channelstreamConnection.set('channels', event.detail.channels);
164 175 this.propagageChannelsState();
@@ -296,16 +296,25 b' var tooltipActivate = function () {'
296 296 // we set a variable so the data is only loaded once via Ajax, not every time the tooltip opens
297 297 if ($origin.data('loaded') !== true) {
298 298 var hovercardUrl = $origin.data('hovercardUrl');
299 var altHovercard =$origin.data('hovercardAlt');
299 var altHovercard = $origin.data('hovercardAlt');
300 300
301 301 if (hovercardUrl !== undefined && hovercardUrl !== "") {
302 if (hovercardUrl.substr(0,12) === 'pyroutes.url'){
302 var urlLoad = true;
303 if (hovercardUrl.substr(0, 12) === 'pyroutes.url') {
303 304 hovercardUrl = eval(hovercardUrl)
305 } else if (hovercardUrl.substr(0, 11) === 'javascript:') {
306 var jsFunc = hovercardUrl.substr(11);
307 urlLoad = false;
308 loaded = true;
309 instance.content(eval(jsFunc))
304 310 }
305 311
306 var loaded = loadHoverCard(hovercardUrl, altHovercard, function (data) {
307 instance.content(data);
308 })
312 if (urlLoad) {
313 var loaded = loadHoverCard(hovercardUrl, altHovercard, function (data) {
314 instance.content(data);
315 })
316 }
317
309 318 } else {
310 319 if ($origin.data('hovercardAltHtml')) {
311 320 var data = atob($origin.data('hovercardAltHtml'));
@@ -677,7 +686,9 b' var feedLifetimeOptions = function(query'
677 686 query.callback(data);
678 687 };
679 688
680
689 /*
690 * Retrievew via templateContext.session_attrs.key
691 * */
681 692 var storeUserSessionAttr = function (key, val) {
682 693
683 694 var postData = {
@@ -558,7 +558,7 b' var CommentsController = function() {'
558 558 return false;
559 559 };
560 560
561 this.showVersion = function (comment_id, comment_history_id) {
561 this.showVersion = function (comment_id, comment_history_id) {
562 562
563 563 var historyViewUrl = pyroutes.url(
564 564 'repo_commit_comment_history_view',
@@ -585,7 +585,7 b' var CommentsController = function() {'
585 585 successRenderCommit,
586 586 failRenderCommit
587 587 );
588 };
588 };
589 589
590 590 this.getLineNumber = function(node) {
591 591 var $node = $(node);
@@ -670,8 +670,20 b' var CommentsController = function() {'
670 670
671 671 var success = function(response) {
672 672 $comment.remove();
673
674 if (window.updateSticky !== undefined) {
675 // potentially our comments change the active window size, so we
676 // notify sticky elements
677 updateSticky()
678 }
679
680 if (window.refreshAllComments !== undefined) {
681 // if we have this handler, run it, and refresh all comments boxes
682 refreshAllComments()
683 }
673 684 return false;
674 685 };
686
675 687 var failure = function(jqXHR, textStatus, errorThrown) {
676 688 var prefix = "Error while deleting this comment.\n"
677 689 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
@@ -682,6 +694,9 b' var CommentsController = function() {'
682 694 return false;
683 695 };
684 696 ajaxPOST(url, postData, success, failure);
697
698
699
685 700 }
686 701
687 702 this.deleteComment = function(node) {
@@ -727,6 +742,15 b' var CommentsController = function() {'
727 742 $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
728 743 $filediff.toggleClass('hide-comments');
729 744 }
745
746 // since we change the height of the diff container that has anchor points for upper
747 // sticky header, we need to tell it to re-calculate those
748 if (window.updateSticky !== undefined) {
749 // potentially our comments change the active window size, so we
750 // notify sticky elements
751 updateSticky()
752 }
753
730 754 return false;
731 755 };
732 756
@@ -747,7 +771,7 b' var CommentsController = function() {'
747 771 var cm = commentForm.getCmInstance();
748 772
749 773 if (resolvesCommentId){
750 var placeholderText = _gettext('Leave a resolution comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId);
774 placeholderText = _gettext('Leave a resolution comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId);
751 775 }
752 776
753 777 setTimeout(function() {
@@ -1077,9 +1101,15 b' var CommentsController = function() {'
1077 1101 updateSticky()
1078 1102 }
1079 1103
1104 if (window.refreshAllComments !== undefined) {
1105 // if we have this handler, run it, and refresh all comments boxes
1106 refreshAllComments()
1107 }
1108
1080 1109 commentForm.setActionButtonsDisabled(false);
1081 1110
1082 1111 };
1112
1083 1113 var submitFailCallback = function(jqXHR, textStatus, errorThrown) {
1084 1114 var prefix = "Error while editing comment.\n"
1085 1115 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
@@ -1209,6 +1239,11 b' var CommentsController = function() {'
1209 1239 updateSticky()
1210 1240 }
1211 1241
1242 if (window.refreshAllComments !== undefined) {
1243 // if we have this handler, run it, and refresh all comments boxes
1244 refreshAllComments()
1245 }
1246
1212 1247 commentForm.setActionButtonsDisabled(false);
1213 1248
1214 1249 };
@@ -35,4 +35,75 b' var quick_repo_menu = function() {'
35 35 }, function() {
36 36 hide_quick_repo_menus();
37 37 });
38 }; No newline at end of file
38 };
39
40
41 window.toggleElement = function (elem, target) {
42 var $elem = $(elem);
43 var $target = $(target);
44
45 if ($target.is(':visible') || $target.length === 0) {
46 $target.hide();
47 $elem.html($elem.data('toggleOn'))
48 } else {
49 $target.show();
50 $elem.html($elem.data('toggleOff'))
51 }
52
53 return false
54 }
55
56 var marginExpVal = '300' // needs a sync with `.right-sidebar.right-sidebar-expanded` value
57 var marginColVal = '40' // needs a sync with `.right-sidebar.right-sidebar-collapsed` value
58
59 var marginExpanded = {'margin': '0 {0}px 0 0'.format(marginExpVal)};
60 var marginCollapsed = {'margin': '0 {0}px 0 0'.format(marginColVal)};
61
62 var updateStickyHeader = function () {
63 if (window.updateSticky !== undefined) {
64 // potentially our comments change the active window size, so we
65 // notify sticky elements
66 updateSticky()
67 }
68 }
69
70 var expandSidebar = function () {
71 var $sideBar = $('.right-sidebar');
72 $('.outerwrapper').css(marginExpanded);
73 $('.sidebar-toggle a').html('<i class="icon-right" style="margin-right: -10px"></i><i class="icon-right"></i>');
74 $('.right-sidebar-collapsed-state').hide();
75 $('.right-sidebar-expanded-state').show();
76 $('.branding').addClass('display-none');
77 $sideBar.addClass('right-sidebar-expanded')
78 $sideBar.removeClass('right-sidebar-collapsed')
79 }
80
81 var collapseSidebar = function () {
82 var $sideBar = $('.right-sidebar');
83 $('.outerwrapper').css(marginCollapsed);
84 $('.sidebar-toggle a').html('<i class="icon-left" style="margin-right: -10px"></i><i class="icon-left"></i>');
85 $('.right-sidebar-collapsed-state').show();
86 $('.right-sidebar-expanded-state').hide();
87 $('.branding').removeClass('display-none');
88 $sideBar.removeClass('right-sidebar-expanded')
89 $sideBar.addClass('right-sidebar-collapsed')
90 }
91
92 window.toggleSidebar = function () {
93 var $sideBar = $('.right-sidebar');
94
95 if ($sideBar.hasClass('right-sidebar-expanded')) {
96 // expanded -> collapsed transition
97 collapseSidebar();
98 var sidebarState = 'collapsed';
99
100 } else {
101 // collapsed -> expanded
102 expandSidebar();
103 var sidebarState = 'expanded';
104 }
105
106 // update our other sticky header in same context
107 updateStickyHeader();
108 storeUserSessionAttr('rc_user_session_attr.sidebarState', sidebarState);
109 }
@@ -98,10 +98,13 b' ReviewersController = function () {'
98 98 var self = this;
99 99 this.$reviewRulesContainer = $('#review_rules');
100 100 this.$rulesList = this.$reviewRulesContainer.find('.pr-reviewer-rules');
101 this.$userRule = $('.pr-user-rule-container');
101 102 this.forbidReviewUsers = undefined;
102 103 this.$reviewMembers = $('#review_members');
103 104 this.currentRequest = null;
104 105 this.diffData = null;
106 this.enabledRules = [];
107
105 108 //dummy handler, we might register our own later
106 109 this.diffDataHandler = function(data){};
107 110
@@ -116,14 +119,17 b' ReviewersController = function () {'
116 119
117 120 this.hideReviewRules = function () {
118 121 self.$reviewRulesContainer.hide();
122 $(self.$userRule.selector).hide();
119 123 };
120 124
121 125 this.showReviewRules = function () {
122 126 self.$reviewRulesContainer.show();
127 $(self.$userRule.selector).show();
123 128 };
124 129
125 130 this.addRule = function (ruleText) {
126 131 self.showReviewRules();
132 self.enabledRules.push(ruleText);
127 133 return '<div>- {0}</div>'.format(ruleText)
128 134 };
129 135
@@ -179,6 +185,7 b' ReviewersController = function () {'
179 185 _gettext('Reviewers picked from source code changes.'))
180 186 )
181 187 }
188
182 189 if (data.rules.forbid_adding_reviewers) {
183 190 $('#add_reviewer_input').remove();
184 191 self.$rulesList.append(
@@ -186,6 +193,7 b' ReviewersController = function () {'
186 193 _gettext('Adding new reviewers is forbidden.'))
187 194 )
188 195 }
196
189 197 if (data.rules.forbid_author_to_review) {
190 198 self.forbidReviewUsers.push(data.rules_data.pr_author);
191 199 self.$rulesList.append(
@@ -193,6 +201,7 b' ReviewersController = function () {'
193 201 _gettext('Author is not allowed to be a reviewer.'))
194 202 )
195 203 }
204
196 205 if (data.rules.forbid_commit_author_to_review) {
197 206
198 207 if (data.rules_data.forbidden_users) {
@@ -208,6 +217,12 b' ReviewersController = function () {'
208 217 )
209 218 }
210 219
220 // we don't have any rules set, so we inform users about it
221 if (self.enabledRules.length === 0) {
222 self.addRule(
223 _gettext('No review rules set.'))
224 }
225
211 226 return self.forbidReviewUsers
212 227 };
213 228
@@ -264,8 +279,11 b' ReviewersController = function () {'
264 279 $('#user').show(); // show user autocomplete after load
265 280
266 281 var commitElements = data["diff_info"]['commits'];
282
267 283 if (commitElements.length === 0) {
268 prButtonLock(true, _gettext('no commits'), 'all');
284 var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
285 _gettext('There are no commits to merge.'));
286 prButtonLock(true, noCommitsMsg, 'all');
269 287
270 288 } else {
271 289 // un-lock PR button, so we cannot send PR before it's calculated
@@ -309,7 +327,6 b' ReviewersController = function () {'
309 327 };
310 328
311 329 this.addReviewMember = function (reviewer_obj, reasons, mandatory) {
312 var members = self.$reviewMembers.get(0);
313 330 var id = reviewer_obj.user_id;
314 331 var username = reviewer_obj.username;
315 332
@@ -318,10 +335,10 b' ReviewersController = function () {'
318 335
319 336 // register IDS to check if we don't have this ID already in
320 337 var currentIds = [];
321 var _els = self.$reviewMembers.find('li').toArray();
322 for (el in _els) {
323 currentIds.push(_els[el].id)
324 }
338
339 $.each(self.$reviewMembers.find('.reviewer_entry'), function (index, value) {
340 currentIds.push($(value).data('reviewerUserId'))
341 })
325 342
326 343 var userAllowedReview = function (userId) {
327 344 var allowed = true;
@@ -339,20 +356,23 b' ReviewersController = function () {'
339 356 alert(_gettext('User `{0}` not allowed to be a reviewer').format(username));
340 357 } else {
341 358 // only add if it's not there
342 var alreadyReviewer = currentIds.indexOf('reviewer_' + id) != -1;
359 var alreadyReviewer = currentIds.indexOf(id) != -1;
343 360
344 361 if (alreadyReviewer) {
345 362 alert(_gettext('User `{0}` already in reviewers').format(username));
346 363 } else {
347 members.innerHTML += renderTemplate('reviewMemberEntry', {
364 var reviewerEntry = renderTemplate('reviewMemberEntry', {
348 365 'member': reviewer_obj,
349 366 'mandatory': mandatory,
367 'reasons': reasons,
350 368 'allowed_to_update': true,
351 369 'review_status': 'not_reviewed',
352 370 'review_status_label': _gettext('Not Reviewed'),
353 'reasons': reasons,
354 'create': true
355 });
371 'user_group': reviewer_obj.user_group,
372 'create': true,
373 'rule_show': true,
374 })
375 $(self.$reviewMembers.selector).append(reviewerEntry);
356 376 tooltipActivate();
357 377 }
358 378 }
@@ -476,7 +496,7 b' var ReviewerAutoComplete = function(inpu'
476 496 };
477 497
478 498
479 VersionController = function () {
499 window.VersionController = function () {
480 500 var self = this;
481 501 this.$verSource = $('input[name=ver_source]');
482 502 this.$verTarget = $('input[name=ver_target]');
@@ -596,25 +616,10 b' VersionController = function () {'
596 616 return false
597 617 };
598 618
599 this.toggleElement = function (elem, target) {
600 var $elem = $(elem);
601 var $target = $(target);
602
603 if ($target.is(':visible')) {
604 $target.hide();
605 $elem.html($elem.data('toggleOn'))
606 } else {
607 $target.show();
608 $elem.html($elem.data('toggleOff'))
609 }
610
611 return false
612 }
613
614 619 };
615 620
616 621
617 UpdatePrController = function () {
622 window.UpdatePrController = function () {
618 623 var self = this;
619 624 this.$updateCommits = $('#update_commits');
620 625 this.$updateCommitsSwitcher = $('#update_commits_switcher');
@@ -656,4 +661,230 b' UpdatePrController = function () {'
656 661 templateContext.repo_name,
657 662 templateContext.pull_request_data.pull_request_id, force);
658 663 };
659 }; No newline at end of file
664 };
665
666 /**
667 * Reviewer display panel
668 */
669 window.ReviewersPanel = {
670 editButton: null,
671 closeButton: null,
672 addButton: null,
673 removeButtons: null,
674 reviewRules: null,
675 setReviewers: null,
676
677 setSelectors: function () {
678 var self = this;
679 self.editButton = $('#open_edit_reviewers');
680 self.closeButton =$('#close_edit_reviewers');
681 self.addButton = $('#add_reviewer');
682 self.removeButtons = $('.reviewer_member_remove,.reviewer_member_mandatory_remove');
683 },
684
685 init: function (reviewRules, setReviewers) {
686 var self = this;
687 self.setSelectors();
688
689 this.reviewRules = reviewRules;
690 this.setReviewers = setReviewers;
691
692 this.editButton.on('click', function (e) {
693 self.edit();
694 });
695 this.closeButton.on('click', function (e) {
696 self.close();
697 self.renderReviewers();
698 });
699
700 self.renderReviewers();
701
702 },
703
704 renderReviewers: function () {
705
706 $('#review_members').html('')
707 $.each(this.setReviewers.reviewers, function (key, val) {
708 var member = val;
709
710 var entry = renderTemplate('reviewMemberEntry', {
711 'member': member,
712 'mandatory': member.mandatory,
713 'reasons': member.reasons,
714 'allowed_to_update': member.allowed_to_update,
715 'review_status': member.review_status,
716 'review_status_label': member.review_status_label,
717 'user_group': member.user_group,
718 'create': false
719 });
720
721 $('#review_members').append(entry)
722 });
723 tooltipActivate();
724
725 },
726
727 edit: function (event) {
728 this.editButton.hide();
729 this.closeButton.show();
730 this.addButton.show();
731 $(this.removeButtons.selector).css('visibility', 'visible');
732 // review rules
733 reviewersController.loadReviewRules(this.reviewRules);
734 },
735
736 close: function (event) {
737 this.editButton.show();
738 this.closeButton.hide();
739 this.addButton.hide();
740 $(this.removeButtons.selector).css('visibility', 'hidden');
741 // hide review rules
742 reviewersController.hideReviewRules()
743 }
744 };
745
746
747 /**
748 * OnLine presence using channelstream
749 */
750 window.ReviewerPresenceController = function (channel) {
751 var self = this;
752 this.channel = channel;
753 this.users = {};
754
755 this.storeUsers = function (users) {
756 self.users = {}
757 $.each(users, function (index, value) {
758 var userId = value.state.id;
759 self.users[userId] = value.state;
760 })
761 }
762
763 this.render = function () {
764 $.each($('.reviewer_entry'), function (index, value) {
765 var userData = $(value).data();
766 if (self.users[userData.reviewerUserId] !== undefined) {
767 $(value).find('.presence-state').show();
768 } else {
769 $(value).find('.presence-state').hide();
770 }
771 })
772 };
773
774 this.handlePresence = function (data) {
775 if (data.type == 'presence' && data.channel === self.channel) {
776 this.storeUsers(data.users);
777 this.render()
778 }
779 };
780
781 this.handleChannelUpdate = function (data) {
782 if (data.channel === this.channel) {
783 this.storeUsers(data.state.users);
784 this.render()
785 }
786
787 };
788
789 /* subscribe to the current presence */
790 $.Topic('/connection_controller/presence').subscribe(this.handlePresence.bind(this));
791 /* subscribe to updates e.g connect/disconnect */
792 $.Topic('/connection_controller/channel_update').subscribe(this.handleChannelUpdate.bind(this));
793
794 };
795
796 window.refreshComments = function (version) {
797 version = version || templateContext.pull_request_data.pull_request_version || '';
798
799 // Pull request case
800 if (templateContext.pull_request_data.pull_request_id !== null) {
801 var params = {
802 'pull_request_id': templateContext.pull_request_data.pull_request_id,
803 'repo_name': templateContext.repo_name,
804 'version': version,
805 };
806 var loadUrl = pyroutes.url('pullrequest_comments', params);
807 } // commit case
808 else {
809 return
810 }
811
812 var currentIDs = []
813 $.each($('.comment'), function (idx, element) {
814 currentIDs.push($(element).data('commentId'));
815 });
816 var data = {"comments[]": currentIDs};
817
818 var $targetElem = $('.comments-content-table');
819 $targetElem.css('opacity', 0.3);
820 $targetElem.load(
821 loadUrl, data, function (responseText, textStatus, jqXHR) {
822 if (jqXHR.status !== 200) {
823 return false;
824 }
825 var $counterElem = $('#comments-count');
826 var newCount = $(responseText).data('counter');
827 if (newCount !== undefined) {
828 var callback = function () {
829 $counterElem.animate({'opacity': 1.00}, 200)
830 $counterElem.html(newCount);
831 };
832 $counterElem.animate({'opacity': 0.15}, 200, callback);
833 }
834
835 $targetElem.css('opacity', 1);
836 tooltipActivate();
837 }
838 );
839 }
840
841 window.refreshTODOs = function (version) {
842 version = version || templateContext.pull_request_data.pull_request_version || '';
843 // Pull request case
844 if (templateContext.pull_request_data.pull_request_id !== null) {
845 var params = {
846 'pull_request_id': templateContext.pull_request_data.pull_request_id,
847 'repo_name': templateContext.repo_name,
848 'version': version,
849 };
850 var loadUrl = pyroutes.url('pullrequest_comments', params);
851 } // commit case
852 else {
853 return
854 }
855
856 var currentIDs = []
857 $.each($('.comment'), function (idx, element) {
858 currentIDs.push($(element).data('commentId'));
859 });
860
861 var data = {"comments[]": currentIDs};
862 var $targetElem = $('.todos-content-table');
863 $targetElem.css('opacity', 0.3);
864 $targetElem.load(
865 loadUrl, data, function (responseText, textStatus, jqXHR) {
866 if (jqXHR.status !== 200) {
867 return false;
868 }
869 var $counterElem = $('#todos-count')
870 var newCount = $(responseText).data('counter');
871 if (newCount !== undefined) {
872 var callback = function () {
873 $counterElem.animate({'opacity': 1.00}, 200)
874 $counterElem.html(newCount);
875 };
876 $counterElem.animate({'opacity': 0.15}, 200, callback);
877 }
878
879 $targetElem.css('opacity', 1);
880 tooltipActivate();
881 }
882 );
883 }
884
885 window.refreshAllComments = function (version) {
886 version = version || templateContext.pull_request_data.pull_request_version || '';
887
888 refreshComments(version);
889 refreshTODOs(version);
890 };
@@ -18,6 +18,7 b''
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20 import io
21 import math
21 22 import re
22 23 import os
23 24 import datetime
@@ -196,6 +197,72 b' def write_metadata_if_needed(event):'
196 197 pass
197 198
198 199
200 def write_usage_data(event):
201 import rhodecode
202 from rhodecode.lib import system_info
203 from rhodecode.lib import ext_json
204
205 settings = event.app.registry.settings
206 instance_tag = settings.get('metadata.write_usage_tag')
207 if not settings.get('metadata.write_usage'):
208 return
209
210 def get_update_age(dest_file):
211 now = datetime.datetime.utcnow()
212
213 with open(dest_file, 'rb') as f:
214 data = ext_json.json.loads(f.read())
215 if 'created_on' in data:
216 update_date = parse(data['created_on'])
217 diff = now - update_date
218 return math.ceil(diff.total_seconds() / 60.0)
219
220 return 0
221
222 utc_date = datetime.datetime.utcnow()
223 hour_quarter = int(math.ceil((utc_date.hour + utc_date.minute/60.0) / 6.))
224 fname = '.rc_usage_{date.year}{date.month:02d}{date.day:02d}_{hour}.json'.format(
225 date=utc_date, hour=hour_quarter)
226 ini_loc = os.path.dirname(rhodecode.CONFIG.get('__file__'))
227
228 usage_dir = os.path.join(ini_loc, '.rcusage')
229 if not os.path.isdir(usage_dir):
230 os.makedirs(usage_dir)
231 usage_metadata_destination = os.path.join(usage_dir, fname)
232
233 try:
234 age_in_min = get_update_age(usage_metadata_destination)
235 except Exception:
236 age_in_min = 0
237
238 # write every 6th hour
239 if age_in_min and age_in_min < 60 * 6:
240 log.debug('Usage file created %s minutes ago, skipping (threashold: %s)...',
241 age_in_min, 60 * 6)
242 return
243
244 def write(dest_file):
245 configuration = system_info.SysInfo(system_info.rhodecode_config)()['value']
246 license_token = configuration['config']['license_token']
247
248 metadata = dict(
249 desc='Usage data',
250 instance_tag=instance_tag,
251 license_token=license_token,
252 created_on=datetime.datetime.utcnow().isoformat(),
253 usage=system_info.SysInfo(system_info.usage_info)()['value'],
254 )
255
256 with open(dest_file, 'wb') as f:
257 f.write(ext_json.json.dumps(metadata, indent=2, sort_keys=True))
258
259 try:
260 log.debug('Writing usage file at: %s', usage_metadata_destination)
261 write(usage_metadata_destination)
262 except Exception:
263 pass
264
265
199 266 def write_js_routes_if_enabled(event):
200 267 registry = event.app.registry
201 268
@@ -38,10 +38,12 b''
38 38 <div class="main">
39 39 ${next.main()}
40 40 </div>
41
41 42 </div>
42 43 <!-- END CONTENT -->
43 44
44 45 </div>
46
45 47 <!-- FOOTER -->
46 48 <div id="footer">
47 49 <div id="footer-inner" class="title wrapper">
@@ -699,9 +701,6 b''
699 701 notice_messages, notice_level = c.rhodecode_user.get_notice_messages()
700 702 notice_display = 'none' if len(notice_messages) == 0 else ''
701 703 %>
702 <style>
703
704 </style>
705 704
706 705 <ul id="quick" class="main_nav navigation horizontal-list">
707 706 ## notice box for important system messages
@@ -1200,6 +1199,7 b''
1200 1199 ('g p', 'Goto pull requests page'),
1201 1200 ('g o', 'Goto repository settings'),
1202 1201 ('g O', 'Goto repository access permissions settings'),
1202 ('t s', 'Toggle sidebar on some pages'),
1203 1203 ]
1204 1204 %>
1205 1205 %for key, desc in elems:
@@ -1219,3 +1219,36 b''
1219 1219 </div><!-- /.modal-content -->
1220 1220 </div><!-- /.modal-dialog -->
1221 1221 </div><!-- /.modal -->
1222
1223
1224 <script type="text/javascript">
1225 (function () {
1226 "use sctrict";
1227
1228 var $sideBar = $('.right-sidebar');
1229 var expanded = $sideBar.hasClass('right-sidebar-expanded');
1230 var sidebarState = templateContext.session_attrs.sidebarState;
1231 var sidebarEnabled = $('aside.right-sidebar').get(0);
1232
1233 if (sidebarState === 'expanded') {
1234 expanded = true
1235 } else if (sidebarState === 'collapsed') {
1236 expanded = false
1237 }
1238 if (sidebarEnabled) {
1239 // show sidebar since it's hidden on load
1240 $('.right-sidebar').show();
1241
1242 // init based on set initial class, or if defined user session attrs
1243 if (expanded) {
1244 window.expandSidebar();
1245 window.updateStickyHeader();
1246
1247 } else {
1248 window.collapseSidebar();
1249 window.updateStickyHeader();
1250 }
1251 }
1252 })()
1253
1254 </script>
@@ -4,6 +4,8 b''
4 4 <%namespace name="base" file="/base/base.mako"/>
5 5 <%namespace name="diff_block" file="/changeset/diff_block.mako"/>
6 6 <%namespace name="file_base" file="/files/base.mako"/>
7 <%namespace name="sidebar" file="/base/sidebar.mako"/>
8
7 9
8 10 <%def name="title()">
9 11 ${_('{} Commit').format(c.repo_name)} - ${h.show_id(c.commit)}
@@ -100,22 +102,6 b''
100 102 % endif
101 103 </div>
102 104
103 %if c.statuses:
104 <div class="tag status-tag-${c.statuses[0]} pull-right">
105 <i class="icon-circle review-status-${c.statuses[0]}"></i>
106 <div class="pull-right">${h.commit_status_lbl(c.statuses[0])}</div>
107 </div>
108 %endif
109
110 </div>
111
112 </div>
113 </div>
114
115 <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
116 <div class="left-label-summary">
117 <p>${_('Commit navigation')}:</p>
118 <div class="right-label-summary">
119 105 <span id="parent_link" class="tag tagtag">
120 106 <a href="#parentCommit" title="${_('Parent Commit')}"><i class="icon-left icon-no-margin"></i>${_('parent')}</a>
121 107 </span>
@@ -123,7 +109,9 b''
123 109 <span id="child_link" class="tag tagtag">
124 110 <a href="#childCommit" title="${_('Child Commit')}">${_('child')}<i class="icon-right icon-no-margin"></i></a>
125 111 </span>
112
126 113 </div>
114
127 115 </div>
128 116 </div>
129 117
@@ -160,7 +148,9 b''
160 148 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
161 149 ${cbdiffs.render_diffset_menu(c.changes[c.commit.raw_id], commit=c.commit)}
162 150 ${cbdiffs.render_diffset(
163 c.changes[c.commit.raw_id], commit=c.commit, use_comments=True,inline_comments=c.inline_comments )}
151 c.changes[c.commit.raw_id], commit=c.commit, use_comments=True,
152 inline_comments=c.inline_comments,
153 show_todos=False)}
164 154 </div>
165 155
166 156 ## template for inline comment form
@@ -169,7 +159,7 b''
169 159 ## comments heading with count
170 160 <div class="comments-heading">
171 161 <i class="icon-comment"></i>
172 ${_('Comments')} ${len(c.comments)}
162 ${_('General Comments')} ${len(c.comments)}
173 163 </div>
174 164
175 165 ## render comments
@@ -180,123 +170,262 b''
180 170 h.commit_status(c.rhodecode_db_repo, c.commit.raw_id))}
181 171 </div>
182 172
183 ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
184 <script type="text/javascript">
173 ### NAV SIDEBAR
174 <aside class="right-sidebar right-sidebar-expanded" id="commit-nav-sticky" style="display: none">
175 <div class="sidenav navbar__inner" >
176 ## TOGGLE
177 <div class="sidebar-toggle" onclick="toggleSidebar(); return false">
178 <a href="#toggleSidebar" class="grey-link-action">
179
180 </a>
181 </div>
182
183 ## CONTENT
184 <div class="sidebar-content">
185 185
186 $(document).ready(function() {
186 ## RULES SUMMARY/RULES
187 <div class="sidebar-element clear-both">
188 <% vote_title = _ungettext(
189 'Status calculated based on votes from {} reviewer',
190 'Status calculated based on votes from {} reviewers', len(c.allowed_reviewers)).format(len(c.allowed_reviewers))
191 %>
192
193 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${vote_title}">
194 <i class="icon-circle review-status-${c.commit_review_status}"></i>
195 ${len(c.allowed_reviewers)}
196 </div>
197 </div>
187 198
188 var boxmax = parseInt($('#trimmed_message_box').css('max-height'), 10);
189 if($('#trimmed_message_box').height() === boxmax){
190 $('#message_expand').show();
191 }
199 ## REVIEWERS
200 <div class="right-sidebar-expanded-state pr-details-title">
201 <span class="tooltip sidebar-heading" title="${vote_title}">
202 <i class="icon-circle review-status-${c.commit_review_status}"></i>
203 ${_('Reviewers')}
204 </span>
205 </div>
206
207 <div id="reviewers" class="right-sidebar-expanded-state pr-details-content reviewers">
208
209 <table id="review_members" class="group_members">
210 ## This content is loaded via JS and ReviewersPanel
211 </table>
212
213 </div>
214
215 ## TODOs
216 <div class="sidebar-element clear-both">
217 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="TODOs">
218 <i class="icon-flag-filled"></i>
219 <span id="todos-count">${len(c.unresolved_comments)}</span>
220 </div>
221
222 <div class="right-sidebar-expanded-state pr-details-title">
223 ## Only show unresolved, that is only what matters
224 <span class="sidebar-heading noselect" onclick="refreshTODOs(); return false">
225 <i class="icon-flag-filled"></i>
226 TODOs
227 </span>
228
229 % if c.resolved_comments:
230 <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return toggleElement(this, '.resolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
231 % else:
232 <span class="block-right last-item noselect">Show resolved</span>
233 % endif
234
235 </div>
192 236
193 $('#message_expand').on('click', function(e){
194 $('#trimmed_message_box').css('max-height', 'none');
195 $(this).hide();
196 });
237 <div class="right-sidebar-expanded-state pr-details-content">
238 % if c.unresolved_comments + c.resolved_comments:
239 ${sidebar.comments_table(c.unresolved_comments + c.resolved_comments, len(c.unresolved_comments), todo_comments=True, is_pr=False)}
240 % else:
241 <table>
242 <tr>
243 <td>
244 ${_('No TODOs yet')}
245 </td>
246 </tr>
247 </table>
248 % endif
249 </div>
250 </div>
251
252 ## COMMENTS
253 <div class="sidebar-element clear-both">
254 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Comments')}">
255 <i class="icon-comment" style="color: #949494"></i>
256 <span id="comments-count">${len(c.inline_comments_flat+c.comments)}</span>
257 <span class="display-none" id="general-comments-count">${len(c.comments)}</span>
258 <span class="display-none" id="inline-comments-count">${len(c.inline_comments_flat)}</span>
259 </div>
260
261 <div class="right-sidebar-expanded-state pr-details-title">
262 <span class="sidebar-heading noselect" onclick="refreshComments(); return false">
263 <i class="icon-comment" style="color: #949494"></i>
264 ${_('Comments')}
265 </span>
266
267 </div>
197 268
198 $('.show-inline-comments').on('click', function(e){
199 var boxid = $(this).attr('data-comment-id');
200 var button = $(this);
269 <div class="right-sidebar-expanded-state pr-details-content">
270 % if c.inline_comments_flat + c.comments:
271 ${sidebar.comments_table(c.inline_comments_flat + c.comments, len(c.inline_comments_flat+c.comments), is_pr=False)}
272 % else:
273 <table>
274 <tr>
275 <td>
276 ${_('No Comments yet')}
277 </td>
278 </tr>
279 </table>
280 % endif
281 </div>
282
283 </div>
284
285 </div>
286
287 </div>
288 </aside>
201 289
202 if(button.hasClass("comments-visible")) {
203 $('#{0} .inline-comments'.format(boxid)).each(function(index){
204 $(this).hide();
290 ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
291 <script type="text/javascript">
292 window.setReviewersData = ${c.commit_set_reviewers_data_json | n};
293
294 $(document).ready(function () {
295 var boxmax = parseInt($('#trimmed_message_box').css('max-height'), 10);
296
297 if ($('#trimmed_message_box').height() === boxmax) {
298 $('#message_expand').show();
299 }
300
301 $('#message_expand').on('click', function (e) {
302 $('#trimmed_message_box').css('max-height', 'none');
303 $(this).hide();
304 });
305
306 $('.show-inline-comments').on('click', function (e) {
307 var boxid = $(this).attr('data-comment-id');
308 var button = $(this);
309
310 if (button.hasClass("comments-visible")) {
311 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
312 $(this).hide();
205 313 });
206 314 button.removeClass("comments-visible");
207 } else {
208 $('#{0} .inline-comments'.format(boxid)).each(function(index){
209 $(this).show();
315 } else {
316 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
317 $(this).show();
210 318 });
211 319 button.addClass("comments-visible");
212 }
213 });
320 }
321 });
214 322
215 // next links
216 $('#child_link').on('click', function(e){
217 // fetch via ajax what is going to be the next link, if we have
218 // >1 links show them to user to choose
219 if(!$('#child_link').hasClass('disabled')){
220 $.ajax({
323 // next links
324 $('#child_link').on('click', function (e) {
325 // fetch via ajax what is going to be the next link, if we have
326 // >1 links show them to user to choose
327 if (!$('#child_link').hasClass('disabled')) {
328 $.ajax({
221 329 url: '${h.route_path('repo_commit_children',repo_name=c.repo_name, commit_id=c.commit.raw_id)}',
222 success: function(data) {
223 if(data.results.length === 0){
224 $('#child_link').html("${_('No Child Commits')}").addClass('disabled');
225 }
226 if(data.results.length === 1){
227 var commit = data.results[0];
228 window.location = pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': commit.raw_id});
229 }
230 else if(data.results.length === 2){
231 $('#child_link').addClass('disabled');
232 $('#child_link').addClass('double');
330 success: function (data) {
331 if (data.results.length === 0) {
332 $('#child_link').html("${_('No Child Commits')}").addClass('disabled');
333 }
334 if (data.results.length === 1) {
335 var commit = data.results[0];
336 window.location = pyroutes.url('repo_commit', {
337 'repo_name': '${c.repo_name}',
338 'commit_id': commit.raw_id
339 });
340 } else if (data.results.length === 2) {
341 $('#child_link').addClass('disabled');
342 $('#child_link').addClass('double');
233 343
234 var _html = '';
235 _html +='<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
236 .replace('__branch__', data.results[0].branch)
237 .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))
238 .replace('__title__', data.results[0].message)
239 .replace('__url__', pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': data.results[0].raw_id}));
240 _html +=' | ';
241 _html +='<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
242 .replace('__branch__', data.results[1].branch)
243 .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))
244 .replace('__title__', data.results[1].message)
245 .replace('__url__', pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': data.results[1].raw_id}));
246 $('#child_link').html(_html);
247 }
344 var _html = '';
345 _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
346 .replace('__branch__', data.results[0].branch)
347 .replace('__rev__', 'r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0, 6)))
348 .replace('__title__', data.results[0].message)
349 .replace('__url__', pyroutes.url('repo_commit', {
350 'repo_name': '${c.repo_name}',
351 'commit_id': data.results[0].raw_id
352 }));
353 _html += ' | ';
354 _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
355 .replace('__branch__', data.results[1].branch)
356 .replace('__rev__', 'r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0, 6)))
357 .replace('__title__', data.results[1].message)
358 .replace('__url__', pyroutes.url('repo_commit', {
359 'repo_name': '${c.repo_name}',
360 'commit_id': data.results[1].raw_id
361 }));
362 $('#child_link').html(_html);
363 }
248 364 }
249 });
250 e.preventDefault();
251 }
252 });
365 });
366 e.preventDefault();
367 }
368 });
253 369
254 // prev links
255 $('#parent_link').on('click', function(e){
256 // fetch via ajax what is going to be the next link, if we have
257 // >1 links show them to user to choose
258 if(!$('#parent_link').hasClass('disabled')){
259 $.ajax({
370 // prev links
371 $('#parent_link').on('click', function (e) {
372 // fetch via ajax what is going to be the next link, if we have
373 // >1 links show them to user to choose
374 if (!$('#parent_link').hasClass('disabled')) {
375 $.ajax({
260 376 url: '${h.route_path("repo_commit_parents",repo_name=c.repo_name, commit_id=c.commit.raw_id)}',
261 success: function(data) {
262 if(data.results.length === 0){
263 $('#parent_link').html('${_('No Parent Commits')}').addClass('disabled');
264 }
265 if(data.results.length === 1){
266 var commit = data.results[0];
267 window.location = pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': commit.raw_id});
268 }
269 else if(data.results.length === 2){
270 $('#parent_link').addClass('disabled');
271 $('#parent_link').addClass('double');
377 success: function (data) {
378 if (data.results.length === 0) {
379 $('#parent_link').html('${_('No Parent Commits')}').addClass('disabled');
380 }
381 if (data.results.length === 1) {
382 var commit = data.results[0];
383 window.location = pyroutes.url('repo_commit', {
384 'repo_name': '${c.repo_name}',
385 'commit_id': commit.raw_id
386 });
387 } else if (data.results.length === 2) {
388 $('#parent_link').addClass('disabled');
389 $('#parent_link').addClass('double');
272 390
273 var _html = '';
274 _html +='<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
275 .replace('__branch__', data.results[0].branch)
276 .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))
277 .replace('__title__', data.results[0].message)
278 .replace('__url__', pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': data.results[0].raw_id}));
279 _html +=' | ';
280 _html +='<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
281 .replace('__branch__', data.results[1].branch)
282 .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))
283 .replace('__title__', data.results[1].message)
284 .replace('__url__', pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}','commit_id': data.results[1].raw_id}));
285 $('#parent_link').html(_html);
286 }
391 var _html = '';
392 _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
393 .replace('__branch__', data.results[0].branch)
394 .replace('__rev__', 'r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0, 6)))
395 .replace('__title__', data.results[0].message)
396 .replace('__url__', pyroutes.url('repo_commit', {
397 'repo_name': '${c.repo_name}',
398 'commit_id': data.results[0].raw_id
399 }));
400 _html += ' | ';
401 _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
402 .replace('__branch__', data.results[1].branch)
403 .replace('__rev__', 'r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0, 6)))
404 .replace('__title__', data.results[1].message)
405 .replace('__url__', pyroutes.url('repo_commit', {
406 'repo_name': '${c.repo_name}',
407 'commit_id': data.results[1].raw_id
408 }));
409 $('#parent_link').html(_html);
410 }
287 411 }
288 });
289 e.preventDefault();
290 }
291 });
412 });
413 e.preventDefault();
414 }
415 });
292 416
293 // browse tree @ revision
294 $('#files_link').on('click', function(e){
295 window.location = '${h.route_path('repo_files:default_path',repo_name=c.repo_name, commit_id=c.commit.raw_id)}';
296 e.preventDefault();
297 });
417 // browse tree @ revision
418 $('#files_link').on('click', function (e) {
419 window.location = '${h.route_path('repo_files:default_path',repo_name=c.repo_name, commit_id=c.commit.raw_id)}';
420 e.preventDefault();
421 });
298 422
299 })
300 </script>
423 ReviewersPanel.init(null, setReviewersData);
424
425 var channel = '${c.commit_broadcast_channel}';
426 new ReviewerPresenceController(channel)
427
428 })
429 </script>
301 430
302 431 </%def>
@@ -10,12 +10,18 b''
10 10
11 11 <%namespace name="base" file="/base/base.mako"/>
12 12 <%def name="comment_block(comment, inline=False, active_pattern_entries=None)">
13 <% pr_index_ver = comment.get_index_version(getattr(c, 'versions', [])) %>
13
14 <%
15 from rhodecode.model.comment import CommentsModel
16 comment_model = CommentsModel()
17 %>
18 <% comment_ver = comment.get_index_version(getattr(c, 'versions', [])) %>
14 19 <% latest_ver = len(getattr(c, 'versions', [])) %>
20
15 21 % if inline:
16 <% outdated_at_ver = comment.outdated_at_version(getattr(c, 'at_version_num', None)) %>
22 <% outdated_at_ver = comment.outdated_at_version(c.at_version_num) %>
17 23 % else:
18 <% outdated_at_ver = comment.older_than_version(getattr(c, 'at_version_num', None)) %>
24 <% outdated_at_ver = comment.older_than_version(c.at_version_num) %>
19 25 % endif
20 26
21 27 <div class="comment
@@ -70,9 +76,9 b''
70 76 status_change_title = 'Status of review for commit {}'.format(h.short_id(comment.commit_id))
71 77 %>
72 78
73 <i class="icon-circle review-status-${comment.status_change[0].status}"></i>
79 <i class="icon-circle review-status-${comment.review_status}"></i>
74 80 <div class="changeset-status-lbl tooltip" title="${status_change_title}">
75 ${comment.status_change[0].status_lbl}
81 ${comment.review_status_lbl}
76 82 </div>
77 83 % else:
78 84 <div>
@@ -153,69 +159,90 b''
153 159 </div>
154 160 %endif
155 161
156 <a class="permalink" href="#comment-${comment.comment_id}"> &para;</a>
157
158 162 <div class="comment-links-block">
159 163
160 164 % if inline:
161 165 <a class="pr-version-inline" href="${request.current_route_path(_query=dict(version=comment.pull_request_version_id), _anchor='comment-{}'.format(comment.comment_id))}">
162 166 % if outdated_at_ver:
163 <code class="tooltip pr-version-num" title="${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}">
164 outdated ${'v{}'.format(pr_index_ver)} |
165 </code>
166 % elif pr_index_ver:
167 <code class="tooltip pr-version-num" title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}">
168 ${'v{}'.format(pr_index_ver)} |
169 </code>
167 <code class="tooltip pr-version-num" title="${_('Outdated comment from pull request version v{0}, latest v{1}').format(comment_ver, latest_ver)}">outdated ${'v{}'.format(comment_ver)}</code>
168 <code class="action-divider">|</code>
169 % elif comment_ver:
170 <code class="tooltip pr-version-num" title="${_('Comment from pull request version v{0}, latest v{1}').format(comment_ver, latest_ver)}">${'v{}'.format(comment_ver)}</code>
171 <code class="action-divider">|</code>
170 172 % endif
171 173 </a>
172 174 % else:
173 % if pr_index_ver:
175 % if comment_ver:
174 176
175 177 % if comment.outdated:
176 178 <a class="pr-version"
177 179 href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}"
178 180 >
179 ${_('Outdated comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}
180 </a> |
181 ${_('Outdated comment from pull request version v{0}, latest v{1}').format(comment_ver, latest_ver)}
182 </a>
183 <code class="action-divider">|</code>
181 184 % else:
182 185 <a class="tooltip pr-version"
183 title="${_('Comment from pull request version v{0}, latest v{1}').format(pr_index_ver, latest_ver)}"
186 title="${_('Comment from pull request version v{0}, latest v{1}').format(comment_ver, latest_ver)}"
184 187 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)}"
185 188 >
186 <code class="pr-version-num">
187 ${'v{}'.format(pr_index_ver)}
188 </code>
189 </a> |
189 <code class="pr-version-num">${'v{}'.format(comment_ver)}</code>
190 </a>
191 <code class="action-divider">|</code>
190 192 % endif
191 193
192 194 % endif
193 195 % endif
194 196
195 ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed
196 ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated
197 %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())):
198 ## permissions to delete
199 %if comment.immutable is False and (c.is_super_admin or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id):
200 <a onclick="return Rhodecode.comments.editComment(this);"
201 class="edit-comment">${_('Edit')}</a>
202 | <a onclick="return Rhodecode.comments.deleteComment(this);"
203 class="delete-comment">${_('Delete')}</a>
204 %else:
205 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Edit')}</a>
206 | <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Delete')}</a>
207 %endif
208 %else:
209 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Edit')}</a>
210 | <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Delete')}</a>
211 %endif
197 <details class="details-reset details-inline-block">
198 <summary class="noselect"><i class="icon-options cursor-pointer"></i></summary>
199 <details-menu class="details-dropdown">
200
201 <div class="dropdown-item">
202 ${_('Comment')} #${comment.comment_id}
203 <span class="pull-right icon-clipboard clipboard-action" data-clipboard-text="${comment_model.get_url(comment,request, permalink=True, anchor='comment-{}'.format(comment.comment_id))}" title="${_('Copy permalink')}"></span>
204 </div>
212 205
206 ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed
207 ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated
208 %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())):
209 ## permissions to delete
210 %if comment.immutable is False and (c.is_super_admin or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id):
211 <div class="dropdown-divider"></div>
212 <div class="dropdown-item">
213 <a onclick="return Rhodecode.comments.editComment(this);" class="btn btn-link btn-sm edit-comment">${_('Edit')}</a>
214 </div>
215 <div class="dropdown-item">
216 <a onclick="return Rhodecode.comments.deleteComment(this);" class="btn btn-link btn-sm btn-danger delete-comment">${_('Delete')}</a>
217 </div>
218 %else:
219 <div class="dropdown-divider"></div>
220 <div class="dropdown-item">
221 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Edit')}</a>
222 </div>
223 <div class="dropdown-item">
224 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Delete')}</a>
225 </div>
226 %endif
227 %else:
228 <div class="dropdown-divider"></div>
229 <div class="dropdown-item">
230 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Edit')}</a>
231 </div>
232 <div class="dropdown-item">
233 <a class="tooltip edit-comment link-disabled" disabled="disabled" title="${_('Action unavailable')}">${_('Delete')}</a>
234 </div>
235 %endif
236 </details-menu>
237 </details>
238
239 <code class="action-divider">|</code>
213 240 % if outdated_at_ver:
214 | <a onclick="return Rhodecode.comments.prevOutdatedComment(this);" class="tooltip prev-comment" title="${_('Jump to the previous outdated comment')}"> <i class="icon-angle-left"></i> </a>
215 | <a onclick="return Rhodecode.comments.nextOutdatedComment(this);" class="tooltip next-comment" title="${_('Jump to the next outdated comment')}"> <i class="icon-angle-right"></i></a>
241 <a onclick="return Rhodecode.comments.prevOutdatedComment(this);" class="tooltip prev-comment" title="${_('Jump to the previous outdated comment')}"> <i class="icon-angle-left"></i> </a>
242 <a onclick="return Rhodecode.comments.nextOutdatedComment(this);" class="tooltip next-comment" title="${_('Jump to the next outdated comment')}"> <i class="icon-angle-right"></i></a>
216 243 % else:
217 | <a onclick="return Rhodecode.comments.prevComment(this);" class="tooltip prev-comment" title="${_('Jump to the previous comment')}"> <i class="icon-angle-left"></i></a>
218 | <a onclick="return Rhodecode.comments.nextComment(this);" class="tooltip next-comment" title="${_('Jump to the next comment')}"> <i class="icon-angle-right"></i></a>
244 <a onclick="return Rhodecode.comments.prevComment(this);" class="tooltip prev-comment" title="${_('Jump to the previous comment')}"> <i class="icon-angle-left"></i></a>
245 <a onclick="return Rhodecode.comments.nextComment(this);" class="tooltip next-comment" title="${_('Jump to the next comment')}"> <i class="icon-angle-right"></i></a>
219 246 % endif
220 247
221 248 </div>
@@ -102,6 +102,11 b''
102 102 <%namespace name="diff_block" file="/changeset/diff_block.mako"/>
103 103
104 104 %for commit in c.commit_ranges:
105 ## commit range header for each individual diff
106 <h3>
107 <a class="tooltip revision" title="${h.tooltip(commit.message)}" href="${h.route_path('repo_commit',repo_name=c.repo_name,commit_id=commit.raw_id)}">${('r%s:%s' % (commit.idx,h.short_id(commit.raw_id)))}</a>
108 </h3>
109
105 110 ${cbdiffs.render_diffset_menu(c.changes[commit.raw_id])}
106 111 ${cbdiffs.render_diffset(
107 112 diffset=c.changes[commit.raw_id],
@@ -61,6 +61,8 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
61 61 diffset_container_id = h.md5(diffset.target_ref)
62 62 collapse_all = len(diffset.files) > collapse_when_files_over
63 63 active_pattern_entries = h.get_active_pattern_entries(getattr(c, 'repo_name', None))
64 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
65 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE, COPIED_FILENODE
64 66 %>
65 67
66 68 %if use_comments:
@@ -159,45 +161,45 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
159 161 </div>
160 162 % endif
161 163
162 ## comments
163 <div class="pull-right">
164 <div class="comments-number" style="padding-left: 10px">
165 % if hasattr(c, 'comments') and hasattr(c, 'inline_cnt'):
166 <i class="icon-comment" style="color: #949494">COMMENTS:</i>
167 % if c.comments:
168 <a href="#comments">${_ungettext("{} General", "{} General", len(c.comments)).format(len(c.comments))}</a>,
169 % else:
170 ${_('0 General')}
171 % endif
172
173 % if c.inline_cnt:
174 <a href="#" onclick="return Rhodecode.comments.nextComment();"
175 id="inline-comments-counter">${_ungettext("{} Inline", "{} Inline", c.inline_cnt).format(c.inline_cnt)}
176 </a>
177 % else:
178 ${_('0 Inline')}
179 % endif
180 % endif
181
182 % if pull_request_menu:
183 <%
184 outdated_comm_count_ver = pull_request_menu['outdated_comm_count_ver']
185 %>
186
187 % if outdated_comm_count_ver:
188 <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
189 (${_("{} Outdated").format(outdated_comm_count_ver)})
190 </a>
191 <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
192 <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
193 % else:
194 (${_("{} Outdated").format(outdated_comm_count_ver)})
195 % endif
196
197 % endif
198
199 </div>
200 </div>
164 ## ## comments
165 ## <div class="pull-right">
166 ## <div class="comments-number" style="padding-left: 10px">
167 ## % if hasattr(c, 'comments') and hasattr(c, 'inline_cnt'):
168 ## <i class="icon-comment" style="color: #949494">COMMENTS:</i>
169 ## % if c.comments:
170 ## <a href="#comments">${_ungettext("{} General", "{} General", len(c.comments)).format(len(c.comments))}</a>,
171 ## % else:
172 ## ${_('0 General')}
173 ## % endif
174 ##
175 ## % if c.inline_cnt:
176 ## <a href="#" onclick="return Rhodecode.comments.nextComment();"
177 ## id="inline-comments-counter">${_ungettext("{} Inline", "{} Inline", c.inline_cnt).format(c.inline_cnt)}
178 ## </a>
179 ## % else:
180 ## ${_('0 Inline')}
181 ## % endif
182 ## % endif
183 ##
184 ## % if pull_request_menu:
185 ## <%
186 ## outdated_comm_count_ver = pull_request_menu['outdated_comm_count_ver']
187 ## %>
188 ##
189 ## % if outdated_comm_count_ver:
190 ## <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
191 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
192 ## </a>
193 ## <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
194 ## <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
195 ## % else:
196 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
197 ## % endif
198 ##
199 ## % endif
200 ##
201 ## </div>
202 ## </div>
201 203
202 204 </div>
203 205
@@ -208,13 +210,6 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
208 210 <a href="${h.current_route_path(request, fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
209 211 </h2>
210 212 </div>
211 ## commit range header for each individual diff
212 % elif commit and hasattr(c, 'commit_ranges') and len(c.commit_ranges) > 1:
213 <div class="diffset-heading ${(diffset.limited_diff and 'diffset-heading-warning' or '')}">
214 <div class="clearinner">
215 <a class="tooltip revision" title="${h.tooltip(commit.message)}" href="${h.route_path('repo_commit',repo_name=diffset.repo_name,commit_id=commit.raw_id)}">${('r%s:%s' % (commit.idx,h.short_id(commit.raw_id)))}</a>
216 </div>
217 </div>
218 213 % endif
219 214
220 215 <div id="todo-box">
@@ -239,6 +234,43 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
239 234 <% over_lines_changed_limit = False %>
240 235 %for i, filediff in enumerate(diffset.files):
241 236
237 %if filediff.source_file_path and filediff.target_file_path:
238 %if filediff.source_file_path != filediff.target_file_path:
239 ## file was renamed, or copied
240 %if RENAMED_FILENODE in filediff.patch['stats']['ops']:
241 <%
242 final_file_name = h.literal(u'{} <i class="icon-angle-left"></i> <del>{}</del>'.format(filediff.target_file_path, filediff.source_file_path))
243 final_path = filediff.target_file_path
244 %>
245 %elif COPIED_FILENODE in filediff.patch['stats']['ops']:
246 <%
247 final_file_name = h.literal(u'{} <i class="icon-angle-left"></i> {}'.format(filediff.target_file_path, filediff.source_file_path))
248 final_path = filediff.target_file_path
249 %>
250 %endif
251 %else:
252 ## file was modified
253 <%
254 final_file_name = filediff.source_file_path
255 final_path = final_file_name
256 %>
257 %endif
258 %else:
259 %if filediff.source_file_path:
260 ## file was deleted
261 <%
262 final_file_name = filediff.source_file_path
263 final_path = final_file_name
264 %>
265 %else:
266 ## file was added
267 <%
268 final_file_name = filediff.target_file_path
269 final_path = final_file_name
270 %>
271 %endif
272 %endif
273
242 274 <%
243 275 lines_changed = filediff.patch['stats']['added'] + filediff.patch['stats']['deleted']
244 276 over_lines_changed_limit = lines_changed > lines_changed_limit
@@ -258,13 +290,39 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
258 290 total_file_comments = [_c for _c in h.itertools.chain.from_iterable(file_comments) if not _c.outdated]
259 291 %>
260 292 <div class="filediff-collapse-indicator icon-"></div>
261 <span class="pill-group pull-right" >
293
294 ## Comments/Options PILL
295 <span class="pill-group pull-right">
262 296 <span class="pill" op="comments">
263
264 297 <i class="icon-comment"></i> ${len(total_file_comments)}
265 298 </span>
299
300 <details class="details-reset details-inline-block">
301 <summary class="noselect">
302 <i class="pill icon-options cursor-pointer" op="options"></i>
303 </summary>
304 <details-menu class="details-dropdown">
305
306 <div class="dropdown-item">
307 <span>${final_path}</span>
308 <span class="pull-right icon-clipboard clipboard-action" data-clipboard-text="${final_path}" title="Copy file path"></span>
309 </div>
310
311 <div class="dropdown-divider"></div>
312
313 <div class="dropdown-item">
314 <% permalink = request.current_route_url(_anchor='a_{}'.format(h.FID(filediff.raw_id, filediff.patch['filename']))) %>
315 <a href="${permalink}">ΒΆ permalink</a>
316 <span class="pull-right icon-clipboard clipboard-action" data-clipboard-text="${permalink}" title="Copy permalink"></span>
317 </div>
318
319
320 </details-menu>
321 </details>
322
266 323 </span>
267 ${diff_ops(filediff)}
324
325 ${diff_ops(final_file_name, filediff)}
268 326
269 327 </label>
270 328
@@ -463,43 +521,15 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
463 521 </div>
464 522 </%def>
465 523
466 <%def name="diff_ops(filediff)">
467 <%
468 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
469 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE, COPIED_FILENODE
470 %>
524 <%def name="diff_ops(file_name, filediff)">
525 <%
526 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
527 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE, COPIED_FILENODE
528 %>
471 529 <span class="pill">
472 530 <i class="icon-file-text"></i>
473 %if filediff.source_file_path and filediff.target_file_path:
474 %if filediff.source_file_path != filediff.target_file_path:
475 ## file was renamed, or copied
476 %if RENAMED_FILENODE in filediff.patch['stats']['ops']:
477 ${filediff.target_file_path} β¬… <del>${filediff.source_file_path}</del>
478 <% final_path = filediff.target_file_path %>
479 %elif COPIED_FILENODE in filediff.patch['stats']['ops']:
480 ${filediff.target_file_path} β¬… ${filediff.source_file_path}
481 <% final_path = filediff.target_file_path %>
482 %endif
483 %else:
484 ## file was modified
485 ${filediff.source_file_path}
486 <% final_path = filediff.source_file_path %>
487 %endif
488 %else:
489 %if filediff.source_file_path:
490 ## file was deleted
491 ${filediff.source_file_path}
492 <% final_path = filediff.source_file_path %>
493 %else:
494 ## file was added
495 ${filediff.target_file_path}
496 <% final_path = filediff.target_file_path %>
497 %endif
498 %endif
499 <i style="color: #aaa" class="on-hover-icon icon-clipboard clipboard-action" data-clipboard-text="${final_path}" title="${_('Copy file path')}" onclick="return false;"></i>
531 ${file_name}
500 532 </span>
501 ## anchor link
502 <a class="pill filediff-anchor" href="#a_${h.FID(filediff.raw_id, filediff.patch['filename'])}">ΒΆ</a>
503 533
504 534 <span class="pill-group pull-right">
505 535
@@ -934,7 +964,7 b' def get_comments_for(diff_type, comments'
934 964 </span>
935 965 %endif
936 966 % if commit or pull_request_menu:
937 <span id="diff_nav">Loading diff...:</span>
967 <span class="tooltip" title="Navigate to previous or next change inside files." id="diff_nav">Loading diff...:</span>
938 968 <span class="cursor-pointer" onclick="scrollToPrevChunk(); return false">
939 969 <i class="icon-angle-up"></i>
940 970 </span>
@@ -21,8 +21,9 b''
21 21 ## to speed up lookups cache some functions before the loop
22 22 <%
23 23 active_patterns = h.get_active_pattern_entries(c.repo_name)
24 urlify_commit_message = h.partial(h.urlify_commit_message, active_pattern_entries=active_patterns)
24 urlify_commit_message = h.partial(h.urlify_commit_message, active_pattern_entries=active_patterns, issues_container=getattr(c, 'referenced_commit_issues', None))
25 25 %>
26
26 27 %for commit in c.commit_ranges:
27 28 <tr id="row-${commit.raw_id}"
28 29 commit_id="${commit.raw_id}"
@@ -1,6 +1,10 b''
1 1 <%text>
2 2 <div style="display: none">
3 3
4 <script>
5 var CG = new ColorGenerator();
6 </script>
7
4 8 <script id="ejs_gravatarWithUser" type="text/template" class="ejsTemplate">
5 9
6 10 <%
@@ -34,38 +38,41 b" var data_hovercard_url = pyroutes.url('h"
34 38
35 39 </script>
36 40
37 <script>
38 var CG = new ColorGenerator();
39 </script>
40
41 41 <script id="ejs_reviewMemberEntry" type="text/template" class="ejsTemplate">
42 <%
43 if (create) {
44 var edit_visibility = 'visible';
45 } else {
46 var edit_visibility = 'hidden';
47 }
42 48
43 <li id="reviewer_<%= member.user_id %>" class="reviewer_entry">
44 <%
45 if (create) {
46 var edit_visibility = 'visible';
47 } else {
48 var edit_visibility = 'hidden';
49 }
49 if (member.user_group && member.user_group.vote_rule) {
50 var reviewGroup = '<i class="icon-user-group"></i>';
51 var reviewGroupColor = CG.asRGB(CG.getColor(member.user_group.vote_rule));
52 } else {
53 var reviewGroup = null;
54 var reviewGroupColor = 'transparent';
55 }
56 var rule_show = rule_show || false;
50 57
51 if (member.user_group && member.user_group.vote_rule) {
52 var groupStyle = 'border-left: 1px solid '+CG.asRGB(CG.getColor(member.user_group.vote_rule));
53 } else {
54 var groupStyle = 'border-left: 1px solid white';
55 }
56 %>
58 if (rule_show) {
59 var rule_visibility = 'table-cell';
60 } else {
61 var rule_visibility = 'none';
62 }
57 63
58 <div class="reviewers_member" style="<%= groupStyle%>" >
64 %>
65
66 <tr id="reviewer_<%= member.user_id %>" class="reviewer_entry" tooltip="Review Group" data-reviewer-user-id="<%= member.user_id %>">
67
68 <td style="width: 20px">
59 69 <div class="reviewer_status tooltip" title="<%= review_status_label %>">
60 70 <i class="icon-circle review-status-<%= review_status %>"></i>
61 71 </div>
72 </td>
73
74 <td>
62 75 <div id="reviewer_<%= member.user_id %>_name" class="reviewer_name">
63 <% if (mandatory) { %>
64 <div class="reviewer_member_mandatory tooltip" title="Mandatory reviewer">
65 <i class="icon-lock"></i>
66 </div>
67 <% } %>
68
69 76 <%-
70 77 renderTemplate('gravatarWithUser', {
71 78 'size': 16,
@@ -77,12 +84,44 b' var CG = new ColorGenerator();'
77 84 'gravatar_url': member.gravatar_link
78 85 })
79 86 %>
87 <span class="tooltip presence-state" style="display: none" title="This users is currently at this page">
88 <i class="icon-eye" style="color: #0ac878"></i>
89 </span>
80 90 </div>
91 </td>
81 92
93 <td style="width: 10px">
94 <% if (reviewGroup !== null) { %>
95 <span class="tooltip" title="Member of review group from rule: `<%= member.user_group.name %>`" style="color: <%= reviewGroupColor %>">
96 <%- reviewGroup %>
97 </span>
98 <% } %>
99 </td>
100
101 <% if (mandatory) { %>
102 <td style="text-align: right;width: 10px;">
103 <div class="reviewer_member_mandatory tooltip" title="Mandatory reviewer">
104 <i class="icon-lock"></i>
105 </div>
106 </td>
107
108 <% } else { %>
109 <td style="text-align: right;width: 10px;">
110 <% if (allowed_to_update) { %>
111 <div class="reviewer_member_remove" onclick="reviewersController.removeReviewMember(<%= member.user_id %>, true)" style="visibility: <%= edit_visibility %>;">
112 <i class="icon-remove"></i>
113 </div>
114 <% } %>
115 </td>
116 <% } %>
117
118 </tr>
119
120 <tr>
121 <td colspan="4" style="display: <%= rule_visibility %>" class="pr-user-rule-container">
82 122 <input type="hidden" name="__start__" value="reviewer:mapping">
83 123
84
85 <%if (member.user_group && member.user_group.vote_rule) {%>
124 <%if (member.user_group && member.user_group.vote_rule) { %>
86 125 <div class="reviewer_reason">
87 126
88 127 <%if (member.user_group.vote_rule == -1) {%>
@@ -91,7 +130,7 b' var CG = new ColorGenerator();'
91 130 - group votes required: <%= member.user_group.vote_rule %>
92 131 <%}%>
93 132 </div>
94 <%}%>
133 <%} %>
95 134
96 135 <input type="hidden" name="__start__" value="reasons:sequence">
97 136 <% for (var i = 0; i < reasons.length; i++) { %>
@@ -99,37 +138,24 b' var CG = new ColorGenerator();'
99 138 <div class="reviewer_reason">- <%= reason %></div>
100 139 <input type="hidden" name="reason" value="<%= reason %>">
101 140 <% } %>
102 <input type="hidden" name="__end__" value="reasons:sequence">
141 <input type="hidden" name="__end__" value="reasons:sequence">
103 142
104 <input type="hidden" name="__start__" value="rules:sequence">
143 <input type="hidden" name="__start__" value="rules:sequence">
105 144 <% for (var i = 0; i < member.rules.length; i++) { %>
106 145 <% var rule = member.rules[i] %>
107 146 <input type="hidden" name="rule_id" value="<%= rule %>">
108 147 <% } %>
109 <input type="hidden" name="__end__" value="rules:sequence">
148 <input type="hidden" name="__end__" value="rules:sequence">
110 149
111 <input id="reviewer_<%= member.user_id %>_input" type="hidden" value="<%= member.user_id %>" name="user_id" />
112 <input type="hidden" name="mandatory" value="<%= mandatory %>"/>
150 <input id="reviewer_<%= member.user_id %>_input" type="hidden" value="<%= member.user_id %>" name="user_id" />
151 <input type="hidden" name="mandatory" value="<%= mandatory %>"/>
113 152
114 153 <input type="hidden" name="__end__" value="reviewer:mapping">
115
116 <% if (mandatory) { %>
117 <div class="reviewer_member_mandatory_remove" style="visibility: <%= edit_visibility %>;">
118 <i class="icon-remove"></i>
119 </div>
120 <% } else { %>
121 <% if (allowed_to_update) { %>
122 <div class="reviewer_member_remove action_button" onclick="reviewersController.removeReviewMember(<%= member.user_id %>, true)" style="visibility: <%= edit_visibility %>;">
123 <i class="icon-remove" ></i>
124 </div>
125 <% } %>
126 <% } %>
127 </div>
128 </li>
154 </td>
155 </tr>
129 156
130 157 </script>
131 158
132
133 159 <script id="ejs_commentVersion" type="text/template" class="ejsTemplate">
134 160
135 161 <%
@@ -158,8 +184,56 b' if (show_disabled) {'
158 184 </script>
159 185
160 186
187 <script id="ejs_sideBarCommentHovercard" type="text/template" class="ejsTemplate">
188
189 <div>
190 <% if (is_todo) { %>
191 <% if (inline) { %>
192 <strong>Inline</strong> TODO on line: <%= line_no %>
193 <% if (version_info) { %>
194 <%= version_info %>
195 <% } %>
196 <br/>
197 File: <code><%- file_name -%></code>
198 <% } else { %>
199 <% if (review_status) { %>
200 <i class="icon-circle review-status-<%= review_status %>"></i>
201 <% } %>
202 <strong>General</strong> TODO
203 <% if (version_info) { %>
204 <%= version_info %>
205 <% } %>
206 <% } %>
207 <% } else { %>
208 <% if (inline) { %>
209 <strong>Inline</strong> comment on line: <%= line_no %>
210 <% if (version_info) { %>
211 <%= version_info %>
212 <% } %>
213 <br/>
214 File: <code><%- file_name -%></code>
215 <% } else { %>
216 <% if (review_status) { %>
217 <i class="icon-circle review-status-<%= review_status %>"></i>
218 <% } %>
219 <strong>General</strong> comment
220 <% if (version_info) { %>
221 <%= version_info %>
222 <% } %>
223 <% } %>
224 <% } %>
225 <br/>
226 Created:
227 <time class="timeago" title="<%= created_on %>" datetime="<%= datetime %>"><%= $.timeago(datetime) %></time>
228
161 229 </div>
162 230
231 </script>
232
233 ##// END OF EJS Templates
234 </div>
235
236
163 237 <script>
164 238 // registers the templates into global cache
165 239 registerTemplates();
@@ -360,13 +360,13 b' text_monospace = "\'Menlo\', \'Liberation M'
360 360
361 361 div.markdown-block ul.checkbox li, div.markdown-block ol.checkbox li {
362 362 list-style: none !important;
363 margin: 6px !important;
363 margin: 0px !important;
364 364 padding: 0 !important
365 365 }
366 366
367 367 div.markdown-block ul li, div.markdown-block ol li {
368 368 list-style: disc !important;
369 margin: 6px !important;
369 margin: 0px !important;
370 370 padding: 0 !important
371 371 }
372 372
@@ -19,21 +19,74 b''
19 19 <div class="box">
20 20 ${h.secure_form(h.route_path('pullrequest_create', repo_name=c.repo_name, _query=request.GET.mixed()), id='pull_request_form', request=request)}
21 21
22 <div class="box pr-summary">
22 <div class="box">
23 23
24 24 <div class="summary-details block-left">
25 25
26
27 <div class="pr-details-title">
28 ${_('New pull request')}
29 </div>
30
31 26 <div class="form" style="padding-top: 10px">
32 <!-- fields -->
33 27
34 28 <div class="fields" >
35 29
36 <div class="field">
30 ## COMMIT FLOW
31 <div class="field">
32 <div class="label label-textarea">
33 <label for="commit_flow">${_('Commit flow')}:</label>
34 </div>
35
36 <div class="content">
37 <div class="flex-container">
38 <div style="width: 45%;">
39 <div class="panel panel-default source-panel">
40 <div class="panel-heading">
41 <h3 class="panel-title">${_('Source repository')}</h3>
42 </div>
43 <div class="panel-body">
44 <div style="display:none">${c.rhodecode_db_repo.description}</div>
45 ${h.hidden('source_repo')}
46 ${h.hidden('source_ref')}
47
48 <div id="pr_open_message"></div>
49 </div>
50 </div>
51 </div>
52
53 <div style="width: 90px; text-align: center; padding-top: 30px">
54 <div>
55 <i class="icon-right" style="font-size: 2.2em"></i>
56 </div>
57 <div style="position: relative; top: 10px">
58 <span class="tag tag">
59 <span id="switch_base"></span>
60 </span>
61 </div>
62
63 </div>
64
65 <div style="width: 45%;">
66
67 <div class="panel panel-default target-panel">
68 <div class="panel-heading">
69 <h3 class="panel-title">${_('Target repository')}</h3>
70 </div>
71 <div class="panel-body">
72 <div style="display:none" id="target_repo_desc"></div>
73 ${h.hidden('target_repo')}
74 ${h.hidden('target_ref')}
75 <span id="target_ref_loading" style="display: none">
76 ${_('Loading refs...')}
77 </span>
78 </div>
79 </div>
80
81 </div>
82 </div>
83
84 </div>
85
86 </div>
87
88 ## TITLE
89 <div class="field">
37 90 <div class="label">
38 91 <label for="pullrequest_title">${_('Title')}:</label>
39 92 </div>
@@ -43,8 +96,9 b''
43 96 <p class="help-block">
44 97 Start the title with WIP: to prevent accidental merge of Work In Progress pull request before it's ready.
45 98 </p>
46 </div>
99 </div>
47 100
101 ## DESC
48 102 <div class="field">
49 103 <div class="label label-textarea">
50 104 <label for="pullrequest_desc">${_('Description')}:</label>
@@ -55,39 +109,49 b''
55 109 </div>
56 110 </div>
57 111
112 ## REVIEWERS
58 113 <div class="field">
59 114 <div class="label label-textarea">
60 <label for="commit_flow">${_('Commit flow')}:</label>
61 </div>
62
63 ## TODO: johbo: Abusing the "content" class here to get the
64 ## desired effect. Should be replaced by a proper solution.
65
66 ##ORG
67 <div class="content">
68 <strong>${_('Source repository')}:</strong>
69 ${c.rhodecode_db_repo.description}
115 <label for="pullrequest_reviewers">${_('Reviewers')}:</label>
70 116 </div>
71 117 <div class="content">
72 ${h.hidden('source_repo')}
73 ${h.hidden('source_ref')}
74 </div>
118 ## REVIEW RULES
119 <div id="review_rules" style="display: none" class="reviewers-title">
120 <div class="pr-details-title">
121 ${_('Reviewer rules')}
122 </div>
123 <div class="pr-reviewer-rules">
124 ## review rules will be appended here, by default reviewers logic
125 </div>
126 </div>
75 127
76 ##OTHER, most Probably the PARENT OF THIS FORK
77 <div class="content">
78 ## filled with JS
79 <div id="target_repo_desc"></div>
80 </div>
128 ## REVIEWERS
129 <div class="reviewers-title">
130 <div class="pr-details-title">
131 ${_('Pull request reviewers')}
132 <span class="calculate-reviewers"> - ${_('loading...')}</span>
133 </div>
134 </div>
135 <div id="reviewers" class="pr-details-content reviewers">
136 ## members goes here, filled via JS based on initial selection !
137 <input type="hidden" name="__start__" value="review_members:sequence">
138 <table id="review_members" class="group_members">
139 ## This content is loaded via JS and ReviewersPanel
140 </table>
141 <input type="hidden" name="__end__" value="review_members:sequence">
81 142
82 <div class="content">
83 ${h.hidden('target_repo')}
84 ${h.hidden('target_ref')}
85 <span id="target_ref_loading" style="display: none">
86 ${_('Loading refs...')}
87 </span>
143 <div id="add_reviewer_input" class='ac'>
144 <div class="reviewer_ac">
145 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
146 <div id="reviewers_container"></div>
147 </div>
148 </div>
149
150 </div>
88 151 </div>
89 152 </div>
90 153
154 ## SUBMIT
91 155 <div class="field">
92 156 <div class="label label-textarea">
93 157 <label for="pullrequest_submit"></label>
@@ -96,66 +160,14 b''
96 160 <div class="pr-submit-button">
97 161 <input id="pr_submit" class="btn" name="save" type="submit" value="${_('Submit Pull Request')}">
98 162 </div>
99 <div id="pr_open_message"></div>
100 163 </div>
101 164 </div>
102
103 <div class="pr-spacing-container"></div>
104 </div>
105 </div>
106 </div>
107 <div>
108 ## AUTHOR
109 <div class="reviewers-title block-right">
110 <div class="pr-details-title">
111 ${_('Author of this pull request')}
112 </div>
113 </div>
114 <div class="block-right pr-details-content reviewers">
115 <ul class="group_members">
116 <li>
117 ${self.gravatar_with_user(c.rhodecode_user.email, 16, tooltip=True)}
118 </li>
119 </ul>
120 </div>
121
122 ## REVIEW RULES
123 <div id="review_rules" style="display: none" class="reviewers-title block-right">
124 <div class="pr-details-title">
125 ${_('Reviewer rules')}
126 </div>
127 <div class="pr-reviewer-rules">
128 ## review rules will be appended here, by default reviewers logic
129 </div>
130 </div>
131
132 ## REVIEWERS
133 <div class="reviewers-title block-right">
134 <div class="pr-details-title">
135 ${_('Pull request reviewers')}
136 <span class="calculate-reviewers"> - ${_('loading...')}</span>
137 </div>
138 </div>
139 <div id="reviewers" class="block-right pr-details-content reviewers">
140 ## members goes here, filled via JS based on initial selection !
141 <input type="hidden" name="__start__" value="review_members:sequence">
142 <ul id="review_members" class="group_members"></ul>
143 <input type="hidden" name="__end__" value="review_members:sequence">
144 <div id="add_reviewer_input" class='ac'>
145 <div class="reviewer_ac">
146 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
147 <div id="reviewers_container"></div>
148 </div>
149 165 </div>
150 166 </div>
151 167 </div>
168
152 169 </div>
153 <div class="box">
154 <div>
155 ## overview pulled by ajax
156 <div id="pull_request_overview"></div>
157 </div>
158 </div>
170
159 171 ${h.end_form()}
160 172 </div>
161 173
@@ -243,8 +255,6 b''
243 255
244 256 var diffDataHandler = function(data) {
245 257
246 $('#pull_request_overview').html(data);
247
248 258 var commitElements = data['commits'];
249 259 var files = data['files'];
250 260 var added = data['stats'][0]
@@ -303,27 +313,33 b''
303 313
304 314 msg += '<input type="hidden" name="__end__" value="revisions:sequence">'
305 315 msg += _ngettext(
306 'This pull requests will consist of <strong>{0} commit</strong>.',
307 'This pull requests will consist of <strong>{0} commits</strong>.',
316 'Compare summary: <strong>{0} commit</strong>',
317 'Compare summary: <strong>{0} commits</strong>',
308 318 commitElements.length).format(commitElements.length)
309 319
310 msg += '\n';
320 msg += '';
311 321 msg += _ngettext(
312 '<strong>{0} file</strong> changed, ',
313 '<strong>{0} files</strong> changed, ',
322 '<strong>, and {0} file</strong> changed.',
323 '<strong>, and {0} files</strong> changed.',
314 324 files.length).format(files.length)
315 msg += '<span class="op-added">{0} lines inserted</span>, <span class="op-deleted">{1} lines deleted</span>.'.format(added, deleted)
316 325
317 msg += '\n\n <a class="" id="pull_request_overview_url" href="{0}" target="_blank">${_('Show detailed compare.')}</a>'.format(url);
326 msg += '\n Diff: <span class="op-added">{0} lines inserted</span>, <span class="op-deleted">{1} lines deleted </span>.'.format(added, deleted)
327
328 msg += '\n <a class="" id="pull_request_overview_url" href="{0}" target="_blank">${_('Show detailed compare.')}</a>'.format(url);
318 329
319 330 if (commitElements.length) {
320 331 var commitsLink = '<a href="#pull_request_overview"><strong>{0}</strong></a>'.format(commitElements.length);
321 332 prButtonLock(false, msg.replace('__COMMITS__', commitsLink), 'compare');
322 333 }
323 334 else {
324 prButtonLock(true, "${_('There are no commits to merge.')}", 'compare');
335 var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
336 _gettext('There are no commits to merge.'));
337 prButtonLock(true, noCommitsMsg, 'compare');
325 338 }
326 339
340 //make both panels equal
341 $('.target-panel').height($('.source-panel').height())
342
327 343 };
328 344
329 345 reviewersController = new ReviewersController();
@@ -429,10 +445,12 b''
429 445
430 446 var targetRepoChanged = function(repoData) {
431 447 // generate new DESC of target repo displayed next to select
448
449 $('#target_repo_desc').html(repoData['description']);
450
432 451 var prLink = pyroutes.url('pullrequest_new', {'repo_name': repoData['name']});
433 $('#target_repo_desc').html(
434 "<strong>${_('Target repository')}</strong>: {0}. <a href=\"{1}\">Switch base, and use as source.</a>".format(repoData['description'], prLink)
435 );
452 var title = _gettext('Switch target repository with the source.')
453 $('#switch_base').html("<a class=\"tooltip\" title=\"{0}\" href=\"{1}\">Switch sides</a>".format(title, prLink))
436 454
437 455 // generate dynamic select2 for refs.
438 456 initTargetRefs(repoData['refs']['select2_refs'],
This diff has been collapsed as it changes many lines, (808 lines changed) Show them Hide them
@@ -1,6 +1,8 b''
1 1 <%inherit file="/base/base.mako"/>
2 2 <%namespace name="base" file="/base/base.mako"/>
3 3 <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
4 <%namespace name="sidebar" file="/base/sidebar.mako"/>
5
4 6
5 7 <%def name="title()">
6 8 ${_('{} Pull Request !{}').format(c.repo_name, c.pull_request.pull_request_id)}
@@ -21,12 +23,19 b''
21 23 ${self.repo_menu(active='showpullrequest')}
22 24 </%def>
23 25
26
24 27 <%def name="main()">
28 ## Container to gather extracted Tickets
29 <%
30 c.referenced_commit_issues = []
31 c.referenced_desc_issues = []
32 %>
25 33
26 34 <script type="text/javascript">
27 35 // TODO: marcink switch this to pyroutes
28 36 AJAX_COMMENT_DELETE_URL = "${h.route_path('pullrequest_comment_delete',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id,comment_id='__COMMENT_ID__')}";
29 37 templateContext.pull_request_data.pull_request_id = ${c.pull_request.pull_request_id};
38 templateContext.pull_request_data.pull_request_version = '${request.GET.get('version', '')}';
30 39 </script>
31 40
32 41 <div class="box">
@@ -79,7 +88,7 b''
79 88 </div>
80 89
81 90 <div id="pr-desc" class="input" title="${_('Rendered using {} renderer').format(c.renderer)}">
82 ${h.render(c.pull_request.description, renderer=c.renderer, repo_name=c.repo_name)}
91 ${h.render(c.pull_request.description, renderer=c.renderer, repo_name=c.repo_name, issues_container=c.referenced_desc_issues)}
83 92 </div>
84 93
85 94 <div id="pr-desc-edit" class="input textarea" style="display: none;">
@@ -89,29 +98,6 b''
89 98
90 99 <div id="summary" class="fields pr-details-content">
91 100
92 ## review
93 <div class="field">
94 <div class="label-pr-detail">
95 <label>${_('Review status')}:</label>
96 </div>
97 <div class="input">
98 %if c.pull_request_review_status:
99 <div class="tag status-tag-${c.pull_request_review_status}">
100 <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
101 <span class="changeset-status-lbl">
102 %if c.pull_request.is_closed():
103 ${_('Closed')},
104 %endif
105
106 ${h.commit_status_lbl(c.pull_request_review_status)}
107
108 </span>
109 </div>
110 - ${_ungettext('calculated based on {} reviewer vote', 'calculated based on {} reviewers votes', len(c.pull_request_reviewers)).format(len(c.pull_request_reviewers))}
111 %endif
112 </div>
113 </div>
114
115 101 ## source
116 102 <div class="field">
117 103 <div class="label-pr-detail">
@@ -136,7 +122,7 b''
136 122
137 123 ${_('of')} <a href="${h.route_path('repo_summary', repo_name=c.pull_request.target_repo.repo_name)}">${c.pull_request.target_repo.repo_name}</a>
138 124
139 <a class="source-details-action" href="#expand-source-details" onclick="return versionController.toggleElement(this, '.source-details')" data-toggle-on='<i class="icon-angle-down">more details</i>' data-toggle-off='<i class="icon-angle-up">less details</i>'>
125 <a class="source-details-action" href="#expand-source-details" onclick="return toggleElement(this, '.source-details')" data-toggle-on='<i class="icon-angle-down">more details</i>' data-toggle-off='<i class="icon-angle-up">less details</i>'>
140 126 <i class="icon-angle-down">more details</i>
141 127 </a>
142 128
@@ -231,7 +217,7 b''
231 217 </code>
232 218 </td>
233 219 <td>
234 <input ${('checked="checked"' if c.from_version_num == ver_pr else '')} class="compare-radio-button" type="radio" name="ver_source" value="${ver_pr or 'latest'}" data-ver-pos="${ver_pos}"/>
220 <input ${('checked="checked"' if c.from_version_index == ver_pr else '')} class="compare-radio-button" type="radio" name="ver_source" value="${ver_pr or 'latest'}" data-ver-pos="${ver_pos}"/>
235 221 <input ${('checked="checked"' if c.at_version_num == ver_pr else '')} class="compare-radio-button" type="radio" name="ver_target" value="${ver_pr or 'latest'}" data-ver-pos="${ver_pos}"/>
236 222 </td>
237 223 <td>
@@ -280,159 +266,12 b''
280 266
281 267 </div>
282 268
283 ## REVIEW RULES
284 <div id="review_rules" style="display: none" class="reviewers-title block-right">
285 <div class="pr-details-title">
286 ${_('Reviewer rules')}
287 %if c.allowed_to_update:
288 <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
289 %endif
290 </div>
291 <div class="pr-reviewer-rules">
292 ## review rules will be appended here, by default reviewers logic
293 </div>
294 <input id="review_data" type="hidden" name="review_data" value="">
295 </div>
296
297 ## REVIEWERS
298 <div class="reviewers-title first-panel block-right">
299 <div class="pr-details-title">
300 ${_('Pull request reviewers')}
301 %if c.allowed_to_update:
302 <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Edit')}</span>
303 %endif
304 </div>
305 </div>
306 <div id="reviewers" class="block-right pr-details-content reviewers">
307
308 ## members redering block
309 <input type="hidden" name="__start__" value="review_members:sequence">
310 <ul id="review_members" class="group_members">
311
312 % for review_obj, member, reasons, mandatory, status in c.pull_request_reviewers:
313 <script>
314 var member = ${h.json.dumps(h.reviewer_as_json(member, reasons=reasons, mandatory=mandatory, user_group=review_obj.rule_user_group_data()))|n};
315 var status = "${(status[0][1].status if status else 'not_reviewed')}";
316 var status_lbl = "${h.commit_status_lbl(status[0][1].status if status else 'not_reviewed')}";
317 var allowed_to_update = ${h.json.dumps(c.allowed_to_update)};
318
319 var entry = renderTemplate('reviewMemberEntry', {
320 'member': member,
321 'mandatory': member.mandatory,
322 'reasons': member.reasons,
323 'allowed_to_update': allowed_to_update,
324 'review_status': status,
325 'review_status_label': status_lbl,
326 'user_group': member.user_group,
327 'create': false
328 });
329 $('#review_members').append(entry)
330 </script>
331
332 % endfor
333
334 </ul>
335
336 <input type="hidden" name="__end__" value="review_members:sequence">
337 ## end members redering block
338
339 %if not c.pull_request.is_closed():
340 <div id="add_reviewer" class="ac" style="display: none;">
341 %if c.allowed_to_update:
342 % if not c.forbid_adding_reviewers:
343 <div id="add_reviewer_input" class="reviewer_ac">
344 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
345 <div id="reviewers_container"></div>
346 </div>
347 % endif
348 <div class="pull-right">
349 <button id="update_pull_request" class="btn btn-small no-margin">${_('Save Changes')}</button>
350 </div>
351 %endif
352 </div>
353 %endif
354 </div>
355
356 ## TODOs will be listed here
357 <div class="reviewers-title block-right">
358 <div class="pr-details-title">
359 ## Only show unresolved, that is only what matters
360 TODO Comments - ${len(c.unresolved_comments)} / ${(len(c.unresolved_comments) + len(c.resolved_comments))}
361
362 % if not c.at_version:
363 % if c.resolved_comments:
364 <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return versionController.toggleElement(this, '.unresolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
365 % else:
366 <span class="block-right last-item noselect">Show resolved</span>
367 % endif
368 % endif
369 </div>
370 </div>
371 <div class="block-right pr-details-content reviewers">
372
373 <table class="todo-table">
374 <%
375 def sorter(entry):
376 user_id = entry.author.user_id
377 resolved = '1' if entry.resolved else '0'
378 if user_id == c.rhodecode_user.user_id:
379 # own comments first
380 user_id = 0
381 return '{}_{}_{}'.format(resolved, user_id, str(entry.comment_id).zfill(100))
382 %>
383
384 % if c.at_version:
385 <tr>
386 <td class="unresolved-todo-text">${_('unresolved TODOs unavailable in this view')}.</td>
387 </tr>
388 % else:
389 % for todo_comment in sorted(c.unresolved_comments + c.resolved_comments, key=sorter):
390 <% resolved = todo_comment.resolved %>
391 % if inline:
392 <% outdated_at_ver = todo_comment.outdated_at_version(getattr(c, 'at_version_num', None)) %>
393 % else:
394 <% outdated_at_ver = todo_comment.older_than_version(getattr(c, 'at_version_num', None)) %>
395 % endif
396
397 <tr ${('class="unresolved-todo" style="display: none"' if resolved else '') |n}>
398
399 <td class="td-todo-number">
400 % if resolved:
401 <a class="permalink todo-resolved tooltip" title="${_('Resolved by comment #{}').format(todo_comment.resolved.comment_id)}" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
402 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
403 % else:
404 <a class="permalink" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
405 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
406 % endif
407 </td>
408 <td class="td-todo-gravatar">
409 ${base.gravatar(todo_comment.author.email, 16, user=todo_comment.author, tooltip=True, extra_class=['no-margin'])}
410 </td>
411 <td class="todo-comment-text-wrapper">
412 <div class="todo-comment-text">
413 <code>${h.chop_at_smart(todo_comment.text, '\n', suffix_if_chopped='...')}</code>
414 </div>
415 </td>
416
417 </tr>
418 % endfor
419
420 % if len(c.unresolved_comments) == 0:
421 <tr>
422 <td class="unresolved-todo-text">${_('No unresolved TODOs')}.</td>
423 </tr>
424 % endif
425
426 % endif
427
428 </table>
429
430 </div>
431 </div>
432 269
433 270 </div>
434 271
435 <div class="box">
272 </div>
273
274 <div class="box">
436 275
437 276 % if c.state_progressing:
438 277
@@ -484,9 +323,9 b''
484 323 <div class="compare_view_commits_title">
485 324 % if not c.compare_mode:
486 325
487 % if c.at_version_pos:
326 % if c.at_version_index:
488 327 <h4>
489 ${_('Showing changes at v%d, commenting is disabled.') % c.at_version_pos}
328 ${_('Showing changes at v{}, commenting is disabled.').format(c.at_version_index)}
490 329 </h4>
491 330 % endif
492 331
@@ -539,10 +378,11 b''
539 378 </div>
540 379
541 380 % if not c.missing_commits:
381 ## COMPARE RANGE DIFF MODE
542 382 % if c.compare_mode:
543 383 % if c.at_version:
544 384 <h4>
545 ${_('Commits and changes between v{ver_from} and {ver_to} of this pull request, commenting is disabled').format(ver_from=c.from_version_pos, ver_to=c.at_version_pos if c.at_version_pos else 'latest')}:
385 ${_('Commits and changes between v{ver_from} and {ver_to} of this pull request, commenting is disabled').format(ver_from=c.from_version_index, ver_to=c.at_version_index if c.at_version_index else 'latest')}:
546 386 </h4>
547 387
548 388 <div class="subtitle-compare">
@@ -597,7 +437,7 b''
597 437 </td>
598 438 <td class="mid td-description">
599 439 <div class="log-container truncate-wrap">
600 <div class="message truncate" id="c-${commit.raw_id}" data-message-raw="${commit.message}">${h.urlify_commit_message(commit.message, c.repo_name)}</div>
440 <div class="message truncate" id="c-${commit.raw_id}" data-message-raw="${commit.message}">${h.urlify_commit_message(commit.message, c.repo_name, issues_container=c.referenced_commit_issues)}</div>
601 441 </div>
602 442 </td>
603 443 </tr>
@@ -608,19 +448,13 b''
608 448
609 449 % endif
610 450
451 ## Regular DIFF
611 452 % else:
612 453 <%include file="/compare/compare_commits.mako" />
613 454 % endif
614 455
615 456 <div class="cs_files">
616 457 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
617 % if c.at_version:
618 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['display']) %>
619 <% c.comments = c.comment_versions[c.at_version_num]['display'] %>
620 % else:
621 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['until']) %>
622 <% c.comments = c.comment_versions[c.at_version_num]['until'] %>
623 % endif
624 458
625 459 <%
626 460 pr_menu_data = {
@@ -667,7 +501,7 b''
667 501 ## comments heading with count
668 502 <div class="comments-heading">
669 503 <i class="icon-comment"></i>
670 ${_('Comments')} ${len(c.comments)}
504 ${_('General Comments')} ${len(c.comments)}
671 505 </div>
672 506
673 507 ## render general comments
@@ -704,218 +538,456 b''
704 538 % endif
705 539 </div>
706 540
707 <script type="text/javascript">
708
709 versionController = new VersionController();
710 versionController.init();
711 541
712 reviewersController = new ReviewersController();
713 commitsController = new CommitsController();
542 ### NAV SIDEBAR
543 <aside class="right-sidebar right-sidebar-expanded" id="pr-nav-sticky" style="display: none">
544 <div class="sidenav navbar__inner" >
545 ## TOGGLE
546 <div class="sidebar-toggle" onclick="toggleSidebar(); return false">
547 <a href="#toggleSidebar" class="grey-link-action">
714 548
715 updateController = new UpdatePrController();
549 </a>
550 </div>
551
552 ## CONTENT
553 <div class="sidebar-content">
716 554
717 $(function () {
555 ## RULES SUMMARY/RULES
556 <div class="sidebar-element clear-both">
557 <% vote_title = _ungettext(
558 'Status calculated based on votes from {} reviewer',
559 'Status calculated based on votes from {} reviewers', len(c.allowed_reviewers)).format(len(c.allowed_reviewers))
560 %>
718 561
719 // custom code mirror
720 var codeMirrorInstance = $('#pr-description-input').get(0).MarkupForm.cm;
562 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${vote_title}">
563 <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
564 ${len(c.allowed_reviewers)}
565 </div>
721 566
722 var PRDetails = {
723 editButton: $('#open_edit_pullrequest'),
724 closeButton: $('#close_edit_pullrequest'),
725 deleteButton: $('#delete_pullrequest'),
726 viewFields: $('#pr-desc, #pr-title'),
727 editFields: $('#pr-desc-edit, #pr-title-edit, .pr-save'),
567 ## REVIEW RULES
568 <div id="review_rules" style="display: none" class="">
569 <div class="right-sidebar-expanded-state pr-details-title">
570 <span class="sidebar-heading">
571 ${_('Reviewer rules')}
572 </span>
573
574 </div>
575 <div class="pr-reviewer-rules">
576 ## review rules will be appended here, by default reviewers logic
577 </div>
578 <input id="review_data" type="hidden" name="review_data" value="">
579 </div>
728 580
729 init: function () {
730 var that = this;
731 this.editButton.on('click', function (e) {
732 that.edit();
733 });
734 this.closeButton.on('click', function (e) {
735 that.view();
736 });
737 },
581 ## REVIEWERS
582 <div class="right-sidebar-expanded-state pr-details-title">
583 <span class="tooltip sidebar-heading" title="${vote_title}">
584 <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
585 ${_('Reviewers')}
586 </span>
587 %if c.allowed_to_update:
588 <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Edit')}</span>
589 <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
590 %else:
591 <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Show rules')}</span>
592 <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
593 %endif
594 </div>
595
596 <div id="reviewers" class="right-sidebar-expanded-state pr-details-content reviewers">
597
598 ## members redering block
599 <input type="hidden" name="__start__" value="review_members:sequence">
600
601 <table id="review_members" class="group_members">
602 ## This content is loaded via JS and ReviewersPanel
603 </table>
604
605 <input type="hidden" name="__end__" value="review_members:sequence">
606 ## end members redering block
738 607
739 edit: function (event) {
740 this.viewFields.hide();
741 this.editButton.hide();
742 this.deleteButton.hide();
743 this.closeButton.show();
744 this.editFields.show();
745 codeMirrorInstance.refresh();
746 },
608 %if not c.pull_request.is_closed():
609 <div id="add_reviewer" class="ac" style="display: none;">
610 %if c.allowed_to_update:
611 % if not c.forbid_adding_reviewers:
612 <div id="add_reviewer_input" class="reviewer_ac">
613 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
614 <div id="reviewers_container"></div>
615 </div>
616 % endif
617 <div class="pull-right">
618 <button id="update_pull_request" class="btn btn-small no-margin">${_('Save Changes')}</button>
619 </div>
620 %endif
621 </div>
622 %endif
623 </div>
624 </div>
747 625
748 view: function (event) {
749 this.editButton.show();
750 this.deleteButton.show();
751 this.editFields.hide();
752 this.closeButton.hide();
753 this.viewFields.show();
754 }
755 };
626 ## ## OBSERVERS
627 ## <div class="sidebar-element clear-both">
628 ## <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Observers')}">
629 ## <i class="icon-eye"></i>
630 ## 0
631 ## </div>
632 ##
633 ## <div class="right-sidebar-expanded-state pr-details-title">
634 ## <span class="sidebar-heading">
635 ## <i class="icon-eye"></i>
636 ## ${_('Observers')}
637 ## </span>
638 ## </div>
639 ## <div class="right-sidebar-expanded-state pr-details-content">
640 ## No observers
641 ## </div>
642 ## </div>
756 643
757 var ReviewersPanel = {
758 editButton: $('#open_edit_reviewers'),
759 closeButton: $('#close_edit_reviewers'),
760 addButton: $('#add_reviewer'),
761 removeButtons: $('.reviewer_member_remove,.reviewer_member_mandatory_remove'),
644 ## TODOs
645 <div class="sidebar-element clear-both">
646 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="TODOs">
647 <i class="icon-flag-filled"></i>
648 <span id="todos-count">${len(c.unresolved_comments)}</span>
649 </div>
650
651 <div class="right-sidebar-expanded-state pr-details-title">
652 ## Only show unresolved, that is only what matters
653 <span class="sidebar-heading noselect" onclick="refreshTODOs(); return false">
654 <i class="icon-flag-filled"></i>
655 TODOs
656 </span>
657
658 % if not c.at_version:
659 % if c.resolved_comments:
660 <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return toggleElement(this, '.resolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
661 % else:
662 <span class="block-right last-item noselect">Show resolved</span>
663 % endif
664 % endif
665 </div>
666
667 <div class="right-sidebar-expanded-state pr-details-content">
762 668
763 init: function () {
764 var self = this;
765 this.editButton.on('click', function (e) {
766 self.edit();
767 });
768 this.closeButton.on('click', function (e) {
769 self.close();
770 });
771 },
669 % if c.at_version:
670 <table>
671 <tr>
672 <td class="unresolved-todo-text">${_('TODOs unavailable when browsing versions')}.</td>
673 </tr>
674 </table>
675 % else:
676 % if c.unresolved_comments + c.resolved_comments:
677 ${sidebar.comments_table(c.unresolved_comments + c.resolved_comments, len(c.unresolved_comments), todo_comments=True)}
678 % else:
679 <table>
680 <tr>
681 <td>
682 ${_('No TODOs yet')}
683 </td>
684 </tr>
685 </table>
686 % endif
687 % endif
688 </div>
689 </div>
772 690
773 edit: function (event) {
774 this.editButton.hide();
775 this.closeButton.show();
776 this.addButton.show();
777 this.removeButtons.css('visibility', 'visible');
778 // review rules
779 reviewersController.loadReviewRules(
780 ${c.pull_request.reviewer_data_json | n});
781 },
691 ## COMMENTS
692 <div class="sidebar-element clear-both">
693 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Comments')}">
694 <i class="icon-comment" style="color: #949494"></i>
695 <span id="comments-count">${len(c.inline_comments_flat+c.comments)}</span>
696 <span class="display-none" id="general-comments-count">${len(c.comments)}</span>
697 <span class="display-none" id="inline-comments-count">${len(c.inline_comments_flat)}</span>
698 </div>
782 699
783 close: function (event) {
784 this.editButton.show();
785 this.closeButton.hide();
786 this.addButton.hide();
787 this.removeButtons.css('visibility', 'hidden');
788 // hide review rules
789 reviewersController.hideReviewRules()
790 }
791 };
700 <div class="right-sidebar-expanded-state pr-details-title">
701 <span class="sidebar-heading noselect" onclick="refreshComments(); return false">
702 <i class="icon-comment" style="color: #949494"></i>
703 ${_('Comments')}
704
705 ## % if outdated_comm_count_ver:
706 ## <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
707 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
708 ## </a>
709 ## <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
710 ## <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
792 711
793 PRDetails.init();
794 ReviewersPanel.init();
712 ## % else:
713 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
714 ## % endif
715
716 </span>
717
718 % if outdated_comm_count_ver:
719 <span class="block-right action_button last-item noselect" onclick="return toggleElement(this, '.hidden-comment');" data-toggle-on="Show outdated" data-toggle-off="Hide outdated">Show outdated</span>
720 % else:
721 <span class="block-right last-item noselect">Show hidden</span>
722 % endif
723
724 </div>
795 725
796 showOutdated = function (self) {
797 $('.comment-inline.comment-outdated').show();
798 $('.filediff-outdated').show();
799 $('.showOutdatedComments').hide();
800 $('.hideOutdatedComments').show();
801 };
726 <div class="right-sidebar-expanded-state pr-details-content">
727 % if c.inline_comments_flat + c.comments:
728 ${sidebar.comments_table(c.inline_comments_flat + c.comments, len(c.inline_comments_flat+c.comments))}
729 % else:
730 <table>
731 <tr>
732 <td>
733 ${_('No Comments yet')}
734 </td>
735 </tr>
736 </table>
737 % endif
738 </div>
739
740 </div>
802 741
803 hideOutdated = function (self) {
804 $('.comment-inline.comment-outdated').hide();
805 $('.filediff-outdated').hide();
806 $('.hideOutdatedComments').hide();
807 $('.showOutdatedComments').show();
808 };
742 ## Referenced Tickets
743 <div class="sidebar-element clear-both">
744 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Referenced Tickets')}">
745 <i class="icon-info-circled"></i>
746 ${(len(c.referenced_desc_issues) + len(c.referenced_commit_issues))}
747 </div>
748
749 <div class="right-sidebar-expanded-state pr-details-title">
750 <span class="sidebar-heading">
751 <i class="icon-info-circled"></i>
752 ${_('Referenced Tickets')}
753 </span>
754 </div>
755 <div class="right-sidebar-expanded-state pr-details-content">
756 <table>
809 757
810 refreshMergeChecks = function () {
811 var loadUrl = "${request.current_route_path(_query=dict(merge_checks=1))}";
812 $('.pull-request-merge').css('opacity', 0.3);
813 $('.action-buttons-extra').css('opacity', 0.3);
814
815 $('.pull-request-merge').load(
816 loadUrl, function () {
817 $('.pull-request-merge').css('opacity', 1);
758 <tr><td><code>${_('In pull request description')}:</code></td></tr>
759 % if c.referenced_desc_issues:
760 % for ticket_dict in c.referenced_desc_issues:
761 <tr>
762 <td>
763 <a href="${ticket_dict.get('url')}">
764 ${ticket_dict.get('id')}
765 </a>
766 </td>
767 </tr>
768 % endfor
769 % else:
770 <tr>
771 <td>
772 ${_('No Ticket data found.')}
773 </td>
774 </tr>
775 % endif
818 776
819 $('.action-buttons-extra').css('opacity', 1);
820 }
821 );
822 };
777 <tr><td style="padding-top: 10px"><code>${_('In commit messages')}:</code></td></tr>
778 % if c.referenced_commit_issues:
779 % for ticket_dict in c.referenced_commit_issues:
780 <tr>
781 <td>
782 <a href="${ticket_dict.get('url')}">
783 ${ticket_dict.get('id')}
784 </a>
785 </td>
786 </tr>
787 % endfor
788 % else:
789 <tr>
790 <td>
791 ${_('No Ticket data found.')}
792 </td>
793 </tr>
794 % endif
795 </table>
823 796
824 closePullRequest = function (status) {
825 if (!confirm(_gettext('Are you sure to close this pull request without merging?'))) {
826 return false;
827 }
828 // inject closing flag
829 $('.action-buttons-extra').append('<input type="hidden" class="close-pr-input" id="close_pull_request" value="1">');
830 $(generalCommentForm.statusChange).select2("val", status).trigger('change');
831 $(generalCommentForm.submitForm).submit();
832 };
797 </div>
798 </div>
799
800 </div>
801
802 </div>
803 </aside>
804
805 ## This JS needs to be at the end
806 <script type="text/javascript">
807
808 versionController = new VersionController();
809 versionController.init();
810
811 reviewersController = new ReviewersController();
812 commitsController = new CommitsController();
833 813
834 $('#show-outdated-comments').on('click', function (e) {
835 var button = $(this);
836 var outdated = $('.comment-outdated');
814 updateController = new UpdatePrController();
815
816 window.reviewerRulesData = ${c.pull_request_default_reviewers_data_json | n};
817 window.setReviewersData = ${c.pull_request_set_reviewers_data_json | n};
818
819 (function () {
820 "use strict";
821
822 // custom code mirror
823 var codeMirrorInstance = $('#pr-description-input').get(0).MarkupForm.cm;
837 824
838 if (button.html() === "(Show)") {
839 button.html("(Hide)");
840 outdated.show();
841 } else {
842 button.html("(Show)");
843 outdated.hide();
844 }
845 });
825 var PRDetails = {
826 editButton: $('#open_edit_pullrequest'),
827 closeButton: $('#close_edit_pullrequest'),
828 deleteButton: $('#delete_pullrequest'),
829 viewFields: $('#pr-desc, #pr-title'),
830 editFields: $('#pr-desc-edit, #pr-title-edit, .pr-save'),
831
832 init: function () {
833 var that = this;
834 this.editButton.on('click', function (e) {
835 that.edit();
836 });
837 this.closeButton.on('click', function (e) {
838 that.view();
839 });
840 },
846 841
847 $('.show-inline-comments').on('change', function (e) {
848 var show = 'none';
849 var target = e.currentTarget;
850 if (target.checked) {
851 show = ''
852 }
853 var boxid = $(target).attr('id_for');
854 var comments = $('#{0} .inline-comments'.format(boxid));
855 var fn_display = function (idx) {
856 $(this).css('display', show);
857 };
858 $(comments).each(fn_display);
859 var btns = $('#{0} .inline-comments-button'.format(boxid));
860 $(btns).each(fn_display);
861 });
842 edit: function (event) {
843 var cmInstance = $('#pr-description-input').get(0).MarkupForm.cm;
844 this.viewFields.hide();
845 this.editButton.hide();
846 this.deleteButton.hide();
847 this.closeButton.show();
848 this.editFields.show();
849 cmInstance.refresh();
850 },
851
852 view: function (event) {
853 this.editButton.show();
854 this.deleteButton.show();
855 this.editFields.hide();
856 this.closeButton.hide();
857 this.viewFields.show();
858 }
859 };
860
861 PRDetails.init();
862 ReviewersPanel.init(reviewerRulesData, setReviewersData);
863
864 window.showOutdated = function (self) {
865 $('.comment-inline.comment-outdated').show();
866 $('.filediff-outdated').show();
867 $('.showOutdatedComments').hide();
868 $('.hideOutdatedComments').show();
869 };
862 870
863 $('#merge_pull_request_form').submit(function () {
864 if (!$('#merge_pull_request').attr('disabled')) {
865 $('#merge_pull_request').attr('disabled', 'disabled');
866 }
867 return true;
868 });
871 window.hideOutdated = function (self) {
872 $('.comment-inline.comment-outdated').hide();
873 $('.filediff-outdated').hide();
874 $('.hideOutdatedComments').hide();
875 $('.showOutdatedComments').show();
876 };
877
878 window.refreshMergeChecks = function () {
879 var loadUrl = "${request.current_route_path(_query=dict(merge_checks=1))}";
880 $('.pull-request-merge').css('opacity', 0.3);
881 $('.action-buttons-extra').css('opacity', 0.3);
882
883 $('.pull-request-merge').load(
884 loadUrl, function () {
885 $('.pull-request-merge').css('opacity', 1);
886
887 $('.action-buttons-extra').css('opacity', 1);
888 }
889 );
890 };
869 891
870 $('#edit_pull_request').on('click', function (e) {
871 var title = $('#pr-title-input').val();
872 var description = codeMirrorInstance.getValue();
873 var renderer = $('#pr-renderer-input').val();
874 editPullRequest(
875 "${c.repo_name}", "${c.pull_request.pull_request_id}",
876 title, description, renderer);
877 });
892 window.closePullRequest = function (status) {
893 if (!confirm(_gettext('Are you sure to close this pull request without merging?'))) {
894 return false;
895 }
896 // inject closing flag
897 $('.action-buttons-extra').append('<input type="hidden" class="close-pr-input" id="close_pull_request" value="1">');
898 $(generalCommentForm.statusChange).select2("val", status).trigger('change');
899 $(generalCommentForm.submitForm).submit();
900 };
901
902 //TODO this functionality is now missing
903 $('#show-outdated-comments').on('click', function (e) {
904 var button = $(this);
905 var outdated = $('.comment-outdated');
878 906
879 $('#update_pull_request').on('click', function (e) {
880 $(this).attr('disabled', 'disabled');
881 $(this).addClass('disabled');
882 $(this).html(_gettext('Saving...'));
883 reviewersController.updateReviewers(
884 "${c.repo_name}", "${c.pull_request.pull_request_id}");
885 });
907 if (button.html() === "(Show)") {
908 button.html("(Hide)");
909 outdated.show();
910 } else {
911 button.html("(Show)");
912 outdated.hide();
913 }
914 });
886 915
916 $('#merge_pull_request_form').submit(function () {
917 if (!$('#merge_pull_request').attr('disabled')) {
918 $('#merge_pull_request').attr('disabled', 'disabled');
919 }
920 return true;
921 });
887 922
888 // fixing issue with caches on firefox
889 $('#update_commits').removeAttr("disabled");
923 $('#edit_pull_request').on('click', function (e) {
924 var title = $('#pr-title-input').val();
925 var description = codeMirrorInstance.getValue();
926 var renderer = $('#pr-renderer-input').val();
927 editPullRequest(
928 "${c.repo_name}", "${c.pull_request.pull_request_id}",
929 title, description, renderer);
930 });
890 931
891 $('.show-inline-comments').on('click', function (e) {
892 var boxid = $(this).attr('data-comment-id');
893 var button = $(this);
932 $('#update_pull_request').on('click', function (e) {
933 $(this).attr('disabled', 'disabled');
934 $(this).addClass('disabled');
935 $(this).html(_gettext('Saving...'));
936 reviewersController.updateReviewers(
937 "${c.repo_name}", "${c.pull_request.pull_request_id}");
938 });
939
940 // fixing issue with caches on firefox
941 $('#update_commits').removeAttr("disabled");
942
943 $('.show-inline-comments').on('click', function (e) {
944 var boxid = $(this).attr('data-comment-id');
945 var button = $(this);
946
947 if (button.hasClass("comments-visible")) {
948 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
949 $(this).hide();
950 });
951 button.removeClass("comments-visible");
952 } else {
953 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
954 $(this).show();
955 });
956 button.addClass("comments-visible");
957 }
958 });
894 959
895 if (button.hasClass("comments-visible")) {
896 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
897 $(this).hide();
898 });
899 button.removeClass("comments-visible");
900 } else {
901 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
902 $(this).show();
903 });
904 button.addClass("comments-visible");
905 }
906 });
960 $('.show-inline-comments').on('change', function (e) {
961 var show = 'none';
962 var target = e.currentTarget;
963 if (target.checked) {
964 show = ''
965 }
966 var boxid = $(target).attr('id_for');
967 var comments = $('#{0} .inline-comments'.format(boxid));
968 var fn_display = function (idx) {
969 $(this).css('display', show);
970 };
971 $(comments).each(fn_display);
972 var btns = $('#{0} .inline-comments-button'.format(boxid));
973 $(btns).each(fn_display);
974 });
907 975
908 // register submit callback on commentForm form to track TODOs
909 window.commentFormGlobalSubmitSuccessCallback = function () {
910 refreshMergeChecks();
911 };
976 // register submit callback on commentForm form to track TODOs
977 window.commentFormGlobalSubmitSuccessCallback = function () {
978 refreshMergeChecks();
979 };
980
981 ReviewerAutoComplete('#user');
912 982
913 ReviewerAutoComplete('#user');
983 })();
914 984
915 })
985 $(document).ready(function () {
916 986
917 </script>
987 var channel = '${c.pr_broadcast_channel}';
988 new ReviewerPresenceController(channel)
918 989
919 </div>
990 })
991 </script>
920 992
921 993 </%def>
@@ -948,8 +948,8 b' def assert_inline_comments(pull_request,'
948 948 if visible is not None:
949 949 inline_comments = CommentsModel().get_inline_comments(
950 950 pull_request.target_repo.repo_id, pull_request=pull_request)
951 inline_cnt = CommentsModel().get_inline_comments_count(
952 inline_comments)
951 inline_cnt = len(CommentsModel().get_inline_comments_as_list(
952 inline_comments))
953 953 assert inline_cnt == visible
954 954 if outdated is not None:
955 955 outdated_comments = CommentsModel().get_outdated_comments(
General Comments 0
You need to be logged in to leave comments. Login now