rhodecode-enterprise-ce Commit - r893:b7927ff7

1

# -*- coding: utf-8 -*-

1

# -*- coding: utf-8 -*-

2

3

4

#

4

#

5

# This program is free software: you can redistribute it and/or modify

5

# This program is free software: you can redistribute it and/or modify

6

# it under the terms of the GNU Affero General Public License, version 3

6

# it under the terms of the GNU Affero General Public License, version 3

7

# (only), as published by the Free Software Foundation.

7

# (only), as published by the Free Software Foundation.

8

#

8

#

9

# This program is distributed in the hope that it will be useful,

9

# This program is distributed in the hope that it will be useful,

10

# but WITHOUT ANY WARRANTY; without even the implied warranty of

10

# but WITHOUT ANY WARRANTY; without even the implied warranty of

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12

# GNU General Public License for more details.

12

# GNU General Public License for more details.

13

#

13

#

14

# You should have received a copy of the GNU Affero General Public License

14

# You should have received a copy of the GNU Affero General Public License

15

# along with this program. If not, see <http://www.gnu.org/licenses/>.

15

# along with this program. If not, see <http://www.gnu.org/licenses/>.

16

#

16

#

17

# This program is dual-licensed. If you wish to learn more about the

17

# This program is dual-licensed. If you wish to learn more about the

18

# RhodeCode Enterprise Edition, including its added features, Support services,

18

# RhodeCode Enterprise Edition, including its added features, Support services,

19

# and proprietary license terms, please see https://rhodecode.com/licenses/

19

# and proprietary license terms, please see https://rhodecode.com/licenses/

20

21

"""

21

"""

22

Database Models for RhodeCode Enterprise

22

Database Models for RhodeCode Enterprise

23

"""

23

"""

24

25

import re

25

import re

26

import os

26

import os

27

import sys

27

import sys

28

import time

28

import time

29

import hashlib

29

import hashlib

30

import logging

30

import logging

31

import datetime

31

import datetime

32

import warnings

32

import warnings

33

import ipaddress

33

import ipaddress

34

import functools

34

import functools

35

import traceback

35

import traceback

36

import collections

36

import collections

37

38

39

from sqlalchemy import *

39

from sqlalchemy import *

40

from sqlalchemy.exc import IntegrityError

40

from sqlalchemy.exc import IntegrityError

41

from sqlalchemy.ext.declarative import declared_attr

41

from sqlalchemy.ext.declarative import declared_attr

42

from sqlalchemy.ext.hybrid import hybrid_property

42

from sqlalchemy.ext.hybrid import hybrid_property

43

from sqlalchemy.orm import (

43

from sqlalchemy.orm import (

44

relationship, joinedload, class_mapper, validates, aliased)

44

relationship, joinedload, class_mapper, validates, aliased)

45

from sqlalchemy.sql.expression import true

45

from sqlalchemy.sql.expression import true

46

from beaker.cache import cache_region, region_invalidate

46

from beaker.cache import cache_region, region_invalidate

47

from webob.exc import HTTPNotFound

47

from webob.exc import HTTPNotFound

48

from zope.cachedescriptors.property import Lazy as LazyProperty

48

from zope.cachedescriptors.property import Lazy as LazyProperty

49

50

from pylons import url

50

from pylons import url

51

from pylons.i18n.translation import lazy_ugettext as _

51

from pylons.i18n.translation import lazy_ugettext as _

52

53

from rhodecode.lib.vcs import get_backend, get_vcs_instance

53

from rhodecode.lib.vcs import get_backend, get_vcs_instance

54

from rhodecode.lib.vcs.utils.helpers import get_scm

54

from rhodecode.lib.vcs.utils.helpers import get_scm

55

from rhodecode.lib.vcs.exceptions import VCSError

55

from rhodecode.lib.vcs.exceptions import VCSError

56

from rhodecode.lib.vcs.backends.base import (

56

from rhodecode.lib.vcs.backends.base import (

57

EmptyCommit, Reference, MergeFailureReason)

57

EmptyCommit, Reference, MergeFailureReason)

58

from rhodecode.lib.utils2 import (

58

from rhodecode.lib.utils2 import (

59

str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,

59

str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,

60

time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,

60

time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,

61

glob2re)

61

glob2re)

62

from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, JSONDict

62

from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, JSONDict

63

from rhodecode.lib.ext_json import json

63

from rhodecode.lib.ext_json import json

64

from rhodecode.lib.caching_query import FromCache

64

from rhodecode.lib.caching_query import FromCache

65

from rhodecode.lib.encrypt import AESCipher

65

from rhodecode.lib.encrypt import AESCipher

66

67

from rhodecode.model.meta import Base, Session

67

from rhodecode.model.meta import Base, Session

68

69

URL_SEP = '/'

69

URL_SEP = '/'

70

log = logging.getLogger(__name__)

70

log = logging.getLogger(__name__)

71

72

# =============================================================================

72

# =============================================================================

73

# BASE CLASSES

73

# BASE CLASSES

74

# =============================================================================

74

# =============================================================================

75

76

# this is propagated from .ini file rhodecode.encrypted_values.secret or

76

# this is propagated from .ini file rhodecode.encrypted_values.secret or

77

# beaker.session.secret if first is not set.

77

# beaker.session.secret if first is not set.

78

# and initialized at environment.py

78

# and initialized at environment.py

79

ENCRYPTION_KEY = None

79

ENCRYPTION_KEY = None

80

81

# used to sort permissions by types, '#' used here is not allowed to be in

81

# used to sort permissions by types, '#' used here is not allowed to be in

82

# usernames, and it's very early in sorted string.printable table.

82

# usernames, and it's very early in sorted string.printable table.

83

PERMISSION_TYPE_SORT = {

83

PERMISSION_TYPE_SORT = {

84

'admin': '####',

84

'admin': '####',

85

'write': '###',

85

'write': '###',

86

'read': '##',

86

'read': '##',

87

'none': '#',

87

'none': '#',

88

}

88

}

89

90

91

def display_sort(obj):

91

def display_sort(obj):

92

"""

92

"""

93

Sort function used to sort permissions in .permissions() function of

93

Sort function used to sort permissions in .permissions() function of

94

Repository, RepoGroup, UserGroup. Also it put the default user in front

94

Repository, RepoGroup, UserGroup. Also it put the default user in front

95

of all other resources

95

of all other resources

96

"""

96

"""

97

98

if obj.username == User.DEFAULT_USER:

98

if obj.username == User.DEFAULT_USER:

99

return '#####'

99

return '#####'

100

prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')

100

prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')

101

return prefix + obj.username

101

return prefix + obj.username

102

103

104

def _hash_key(k):

104

def _hash_key(k):

105

return md5_safe(k)

105

return md5_safe(k)

106

107

108

class EncryptedTextValue(TypeDecorator):

108

class EncryptedTextValue(TypeDecorator):

109

"""

109

"""

110

Special column for encrypted long text data, use like::

110

Special column for encrypted long text data, use like::

111

112

value = Column("encrypted_value", EncryptedValue(), nullable=False)

112

value = Column("encrypted_value", EncryptedValue(), nullable=False)

113

114

This column is intelligent so if value is in unencrypted form it return

114

This column is intelligent so if value is in unencrypted form it return

115

unencrypted form, but on save it always encrypts

115

unencrypted form, but on save it always encrypts

116

"""

116

"""

117

impl = Text

117

impl = Text

118

119

def process_bind_param(self, value, dialect):

119

def process_bind_param(self, value, dialect):

120

if not value:

120

if not value:

121

return value

121

return value

122

if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):

122

if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):

123

# protect against double encrypting if someone manually starts

123

# protect against double encrypting if someone manually starts

124

# doing

124

# doing

125

raise ValueError('value needs to be in unencrypted format, ie. '

125

raise ValueError('value needs to be in unencrypted format, ie. '

126

'not starting with enc$aes')

126

'not starting with enc$aes')

127

return 'enc$aes_hmac$%s' % AESCipher(

127

return 'enc$aes_hmac$%s' % AESCipher(

128

ENCRYPTION_KEY, hmac=True).encrypt(value)

128

ENCRYPTION_KEY, hmac=True).encrypt(value)

129

130

def process_result_value(self, value, dialect):

130

def process_result_value(self, value, dialect):

131

import rhodecode

131

import rhodecode

132

133

if not value:

133

if not value:

134

return value

134

return value

135

136

parts = value.split('$', 3)

136

parts = value.split('$', 3)

137

if not len(parts) == 3:

137

if not len(parts) == 3:

138

# probably not encrypted values

138

# probably not encrypted values

139

return value

139

return value

140

else:

140

else:

141

if parts[0] != 'enc':

141

if parts[0] != 'enc':

142

# parts ok but without our header ?

142

# parts ok but without our header ?

143

return value

143

return value

144

enc_strict_mode = str2bool(rhodecode.CONFIG.get(

144

enc_strict_mode = str2bool(rhodecode.CONFIG.get(

145

'rhodecode.encrypted_values.strict') or True)

145

'rhodecode.encrypted_values.strict') or True)

146

# at that stage we know it's our encryption

146

# at that stage we know it's our encryption

147

if parts[1] == 'aes':

147

if parts[1] == 'aes':

148

decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])

148

decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])

149

elif parts[1] == 'aes_hmac':

149

elif parts[1] == 'aes_hmac':

150

decrypted_data = AESCipher(

150

decrypted_data = AESCipher(

151

ENCRYPTION_KEY, hmac=True,

151

ENCRYPTION_KEY, hmac=True,

152

strict_verification=enc_strict_mode).decrypt(parts[2])

152

strict_verification=enc_strict_mode).decrypt(parts[2])

153

else:

153

else:

154

raise ValueError(

154

raise ValueError(

155

'Encryption type part is wrong, must be `aes` '

155

'Encryption type part is wrong, must be `aes` '

156

'or `aes_hmac`, got `%s` instead' % (parts[1]))

156

'or `aes_hmac`, got `%s` instead' % (parts[1]))

157

return decrypted_data

157

return decrypted_data

158

159

160

class BaseModel(object):

160

class BaseModel(object):

161

"""

161

"""

162

Base Model for all classes

162

Base Model for all classes

163

"""

163

"""

164

165

@classmethod

165

@classmethod

166

def _get_keys(cls):

166

def _get_keys(cls):

167

"""return column names for this model """

167

"""return column names for this model """

168

return class_mapper(cls).c.keys()

168

return class_mapper(cls).c.keys()

169

170

def get_dict(self):

170

def get_dict(self):

171

"""

171

"""

172

return dict with keys and values corresponding

172

return dict with keys and values corresponding

173

to this model data """

173

to this model data """

174

175

d = {}

175

d = {}

176

for k in self._get_keys():

176

for k in self._get_keys():

177

d[k] = getattr(self, k)

177

d[k] = getattr(self, k)

178

179

# also use __json__() if present to get additional fields

179

# also use __json__() if present to get additional fields

180

_json_attr = getattr(self, '__json__', None)

180

_json_attr = getattr(self, '__json__', None)

181

if _json_attr:

181

if _json_attr:

182

# update with attributes from __json__

182

# update with attributes from __json__

183

if callable(_json_attr):

183

if callable(_json_attr):

184

_json_attr = _json_attr()

184

_json_attr = _json_attr()

185

for k, val in _json_attr.iteritems():

185

for k, val in _json_attr.iteritems():

186

d[k] = val

186

d[k] = val

187

return d

187

return d

188

189

def get_appstruct(self):

189

def get_appstruct(self):

190

"""return list with keys and values tuples corresponding

190

"""return list with keys and values tuples corresponding

191

to this model data """

191

to this model data """

192

193

l = []

193

l = []

194

for k in self._get_keys():

194

for k in self._get_keys():

195

l.append((k, getattr(self, k),))

195

l.append((k, getattr(self, k),))

196

return l

196

return l

197

198

def populate_obj(self, populate_dict):

198

def populate_obj(self, populate_dict):

199

"""populate model with data from given populate_dict"""

199

"""populate model with data from given populate_dict"""

200

201

for k in self._get_keys():

201

for k in self._get_keys():

202

if k in populate_dict:

202

if k in populate_dict:

203

setattr(self, k, populate_dict[k])

203

setattr(self, k, populate_dict[k])

204

205

@classmethod

205

@classmethod

206

def query(cls):

206

def query(cls):

207

return Session().query(cls)

207

return Session().query(cls)

208

209

@classmethod

209

@classmethod

210

def get(cls, id_):

210

def get(cls, id_):

211

if id_:

211

if id_:

212

return cls.query().get(id_)

212

return cls.query().get(id_)

213

214

@classmethod

214

@classmethod

215

def get_or_404(cls, id_):

215

def get_or_404(cls, id_):

216

try:

216

try:

217

id_ = int(id_)

217

id_ = int(id_)

218

except (TypeError, ValueError):

218

except (TypeError, ValueError):

219

raise HTTPNotFound

219

raise HTTPNotFound

220

221

res = cls.query().get(id_)

221

res = cls.query().get(id_)

222

if not res:

222

if not res:

223

raise HTTPNotFound

223

raise HTTPNotFound

224

return res

224

return res

225

226

@classmethod

226

@classmethod

227

def getAll(cls):

227

def getAll(cls):

228

# deprecated and left for backward compatibility

228

# deprecated and left for backward compatibility

229

return cls.get_all()

229

return cls.get_all()

230

231

@classmethod

231

@classmethod

232

def get_all(cls):

232

def get_all(cls):

233

return cls.query().all()

233

return cls.query().all()

234

235

@classmethod

235

@classmethod

236

def delete(cls, id_):

236

def delete(cls, id_):

237

obj = cls.query().get(id_)

237

obj = cls.query().get(id_)

238

Session().delete(obj)

238

Session().delete(obj)

239

240

@classmethod

240

@classmethod

241

def identity_cache(cls, session, attr_name, value):

241

def identity_cache(cls, session, attr_name, value):

242

exist_in_session = []

242

exist_in_session = []

243

for (item_cls, pkey), instance in session.identity_map.items():

243

for (item_cls, pkey), instance in session.identity_map.items():

244

if cls == item_cls and getattr(instance, attr_name) == value:

244

if cls == item_cls and getattr(instance, attr_name) == value:

245

exist_in_session.append(instance)

245

exist_in_session.append(instance)

246

if exist_in_session:

246

if exist_in_session:

247

if len(exist_in_session) == 1:

247

if len(exist_in_session) == 1:

248

return exist_in_session[0]

248

return exist_in_session[0]

249

log.exception(

249

log.exception(

250

'multiple objects with attr %s and '

250

'multiple objects with attr %s and '

251

'value %s found with same name: %r',

251

'value %s found with same name: %r',

252

attr_name, value, exist_in_session)

252

attr_name, value, exist_in_session)

253

254

def __repr__(self):

254

def __repr__(self):

255

if hasattr(self, '__unicode__'):

255

if hasattr(self, '__unicode__'):

256

# python repr needs to return str

256

# python repr needs to return str

257

try:

257

try:

258

return safe_str(self.__unicode__())

258

return safe_str(self.__unicode__())

259

except UnicodeDecodeError:

259

except UnicodeDecodeError:

260

pass

260

pass

261

return '<DB:%s>' % (self.__class__.__name__)

261

return '<DB:%s>' % (self.__class__.__name__)

262

263

264

class RhodeCodeSetting(Base, BaseModel):

264

class RhodeCodeSetting(Base, BaseModel):

265

__tablename__ = 'rhodecode_settings'

265

__tablename__ = 'rhodecode_settings'

266

__table_args__ = (

266

__table_args__ = (

267

UniqueConstraint('app_settings_name'),

267

UniqueConstraint('app_settings_name'),

268

{'extend_existing': True, 'mysql_engine': 'InnoDB',

268

{'extend_existing': True, 'mysql_engine': 'InnoDB',

269

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

269

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

270

)

270

)

271

272

SETTINGS_TYPES = {

272

SETTINGS_TYPES = {

273

'str': safe_str,

273

'str': safe_str,

274

'int': safe_int,

274

'int': safe_int,

275

'unicode': safe_unicode,

275

'unicode': safe_unicode,

276

'bool': str2bool,

276

'bool': str2bool,

277

'list': functools.partial(aslist, sep=',')

277

'list': functools.partial(aslist, sep=',')

278

}

278

}

279

DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'

279

DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'

280

GLOBAL_CONF_KEY = 'app_settings'

280

GLOBAL_CONF_KEY = 'app_settings'

281

282

app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

282

app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

283

app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)

283

app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)

284

_app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)

284

_app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)

285

_app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)

285

_app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)

286

287

def __init__(self, key='', val='', type='unicode'):

287

def __init__(self, key='', val='', type='unicode'):

288

self.app_settings_name = key

288

self.app_settings_name = key

289

self.app_settings_type = type

289

self.app_settings_type = type

290

self.app_settings_value = val

290

self.app_settings_value = val

291

292

@validates('_app_settings_value')

292

@validates('_app_settings_value')

293

def validate_settings_value(self, key, val):

293

def validate_settings_value(self, key, val):

294

assert type(val) == unicode

294

assert type(val) == unicode

295

return val

295

return val

296

297

@hybrid_property

297

@hybrid_property

298

def app_settings_value(self):

298

def app_settings_value(self):

299

v = self._app_settings_value

299

v = self._app_settings_value

300

_type = self.app_settings_type

300

_type = self.app_settings_type

301

if _type:

301

if _type:

302

_type = self.app_settings_type.split('.')[0]

302

_type = self.app_settings_type.split('.')[0]

303

# decode the encrypted value

303

# decode the encrypted value

304

if 'encrypted' in self.app_settings_type:

304

if 'encrypted' in self.app_settings_type:

305

cipher = EncryptedTextValue()

305

cipher = EncryptedTextValue()

306

v = safe_unicode(cipher.process_result_value(v, None))

306

v = safe_unicode(cipher.process_result_value(v, None))

307

308

converter = self.SETTINGS_TYPES.get(_type) or \

308

converter = self.SETTINGS_TYPES.get(_type) or \

309

self.SETTINGS_TYPES['unicode']

309

self.SETTINGS_TYPES['unicode']

310

return converter(v)

310

return converter(v)

311

312

@app_settings_value.setter

312

@app_settings_value.setter

313

def app_settings_value(self, val):

313

def app_settings_value(self, val):

314

"""

314

"""

315

Setter that will always make sure we use unicode in app_settings_value

315

Setter that will always make sure we use unicode in app_settings_value

316

317

:param val:

317

:param val:

318

"""

318

"""

319

val = safe_unicode(val)

319

val = safe_unicode(val)

320

# encode the encrypted value

320

# encode the encrypted value

321

if 'encrypted' in self.app_settings_type:

321

if 'encrypted' in self.app_settings_type:

322

cipher = EncryptedTextValue()

322

cipher = EncryptedTextValue()

323

val = safe_unicode(cipher.process_bind_param(val, None))

323

val = safe_unicode(cipher.process_bind_param(val, None))

324

self._app_settings_value = val

324

self._app_settings_value = val

325

326

@hybrid_property

326

@hybrid_property

327

def app_settings_type(self):

327

def app_settings_type(self):

328

return self._app_settings_type

328

return self._app_settings_type

329

330

@app_settings_type.setter

330

@app_settings_type.setter

331

def app_settings_type(self, val):

331

def app_settings_type(self, val):

332

if val.split('.')[0] not in self.SETTINGS_TYPES:

332

if val.split('.')[0] not in self.SETTINGS_TYPES:

333

raise Exception('type must be one of %s got %s'

333

raise Exception('type must be one of %s got %s'

334

% (self.SETTINGS_TYPES.keys(), val))

334

% (self.SETTINGS_TYPES.keys(), val))

335

self._app_settings_type = val

335

self._app_settings_type = val

336

337

def __unicode__(self):

337

def __unicode__(self):

338

return u"<%s('%s:%s[%s]')>" % (

338

return u"<%s('%s:%s[%s]')>" % (

339

self.__class__.__name__,

339

self.__class__.__name__,

340

self.app_settings_name, self.app_settings_value,

340

self.app_settings_name, self.app_settings_value,

341

self.app_settings_type

341

self.app_settings_type

342

)

342

)

343

344

345

class RhodeCodeUi(Base, BaseModel):

345

class RhodeCodeUi(Base, BaseModel):

346

__tablename__ = 'rhodecode_ui'

346

__tablename__ = 'rhodecode_ui'

347

__table_args__ = (

347

__table_args__ = (

348

UniqueConstraint('ui_key'),

348

UniqueConstraint('ui_key'),

349

{'extend_existing': True, 'mysql_engine': 'InnoDB',

349

{'extend_existing': True, 'mysql_engine': 'InnoDB',

350

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

350

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

351

)

351

)

352

353

HOOK_REPO_SIZE = 'changegroup.repo_size'

353

HOOK_REPO_SIZE = 'changegroup.repo_size'

354

# HG

354

# HG

355

HOOK_PRE_PULL = 'preoutgoing.pre_pull'

355

HOOK_PRE_PULL = 'preoutgoing.pre_pull'

356

HOOK_PULL = 'outgoing.pull_logger'

356

HOOK_PULL = 'outgoing.pull_logger'

357

HOOK_PRE_PUSH = 'prechangegroup.pre_push'

357

HOOK_PRE_PUSH = 'prechangegroup.pre_push'

358

HOOK_PUSH = 'changegroup.push_logger'

358

HOOK_PUSH = 'changegroup.push_logger'

359

360

# TODO: johbo: Unify way how hooks are configured for git and hg,

360

# TODO: johbo: Unify way how hooks are configured for git and hg,

361

# git part is currently hardcoded.

361

# git part is currently hardcoded.

362

363

# SVN PATTERNS

363

# SVN PATTERNS

364

SVN_BRANCH_ID = 'vcs_svn_branch'

364

SVN_BRANCH_ID = 'vcs_svn_branch'

365

SVN_TAG_ID = 'vcs_svn_tag'

365

SVN_TAG_ID = 'vcs_svn_tag'

366

367

ui_id = Column(

367

ui_id = Column(

368

"ui_id", Integer(), nullable=False, unique=True, default=None,

368

"ui_id", Integer(), nullable=False, unique=True, default=None,

369

primary_key=True)

369

primary_key=True)

370

ui_section = Column(

370

ui_section = Column(

371

"ui_section", String(255), nullable=True, unique=None, default=None)

371

"ui_section", String(255), nullable=True, unique=None, default=None)

372

ui_key = Column(

372

ui_key = Column(

373

"ui_key", String(255), nullable=True, unique=None, default=None)

373

"ui_key", String(255), nullable=True, unique=None, default=None)

374

ui_value = Column(

374

ui_value = Column(

375

"ui_value", String(255), nullable=True, unique=None, default=None)

375

"ui_value", String(255), nullable=True, unique=None, default=None)

376

ui_active = Column(

376

ui_active = Column(

377

"ui_active", Boolean(), nullable=True, unique=None, default=True)

377

"ui_active", Boolean(), nullable=True, unique=None, default=True)

378

379

def __repr__(self):

379

def __repr__(self):

380

return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,

380

return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,

381

self.ui_key, self.ui_value)

381

self.ui_key, self.ui_value)

382

383

384

class RepoRhodeCodeSetting(Base, BaseModel):

384

class RepoRhodeCodeSetting(Base, BaseModel):

385

__tablename__ = 'repo_rhodecode_settings'

385

__tablename__ = 'repo_rhodecode_settings'

386

__table_args__ = (

386

__table_args__ = (

387

UniqueConstraint(

387

UniqueConstraint(

388

'app_settings_name', 'repository_id',

388

'app_settings_name', 'repository_id',

389

name='uq_repo_rhodecode_setting_name_repo_id'),

389

name='uq_repo_rhodecode_setting_name_repo_id'),

390

{'extend_existing': True, 'mysql_engine': 'InnoDB',

390

{'extend_existing': True, 'mysql_engine': 'InnoDB',

391

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

391

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

392

)

392

)

393

394

repository_id = Column(

394

repository_id = Column(

395

"repository_id", Integer(), ForeignKey('repositories.repo_id'),

395

"repository_id", Integer(), ForeignKey('repositories.repo_id'),

396

nullable=False)

396

nullable=False)

397

app_settings_id = Column(

397

app_settings_id = Column(

398

"app_settings_id", Integer(), nullable=False, unique=True,

398

"app_settings_id", Integer(), nullable=False, unique=True,

399

default=None, primary_key=True)

399

default=None, primary_key=True)

400

app_settings_name = Column(

400

app_settings_name = Column(

401

"app_settings_name", String(255), nullable=True, unique=None,

401

"app_settings_name", String(255), nullable=True, unique=None,

402

default=None)

402

default=None)

403

_app_settings_value = Column(

403

_app_settings_value = Column(

404

"app_settings_value", String(4096), nullable=True, unique=None,

404

"app_settings_value", String(4096), nullable=True, unique=None,

405

default=None)

405

default=None)

406

_app_settings_type = Column(

406

_app_settings_type = Column(

407

"app_settings_type", String(255), nullable=True, unique=None,

407

"app_settings_type", String(255), nullable=True, unique=None,

408

default=None)

408

default=None)

409

410

repository = relationship('Repository')

410

repository = relationship('Repository')

411

412

def __init__(self, repository_id, key='', val='', type='unicode'):

412

def __init__(self, repository_id, key='', val='', type='unicode'):

413

self.repository_id = repository_id

413

self.repository_id = repository_id

414

self.app_settings_name = key

414

self.app_settings_name = key

415

self.app_settings_type = type

415

self.app_settings_type = type

416

self.app_settings_value = val

416

self.app_settings_value = val

417

418

@validates('_app_settings_value')

418

@validates('_app_settings_value')

419

def validate_settings_value(self, key, val):

419

def validate_settings_value(self, key, val):

420

assert type(val) == unicode

420

assert type(val) == unicode

421

return val

421

return val

422

423

@hybrid_property

423

@hybrid_property

424

def app_settings_value(self):

424

def app_settings_value(self):

425

v = self._app_settings_value

425

v = self._app_settings_value

426

type_ = self.app_settings_type

426

type_ = self.app_settings_type

427

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

427

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

428

converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']

428

converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']

429

return converter(v)

429

return converter(v)

430

431

@app_settings_value.setter

431

@app_settings_value.setter

432

def app_settings_value(self, val):

432

def app_settings_value(self, val):

433

"""

433

"""

434

Setter that will always make sure we use unicode in app_settings_value

434

Setter that will always make sure we use unicode in app_settings_value

435

436

:param val:

436

:param val:

437

"""

437

"""

438

self._app_settings_value = safe_unicode(val)

438

self._app_settings_value = safe_unicode(val)

439

440

@hybrid_property

440

@hybrid_property

441

def app_settings_type(self):

441

def app_settings_type(self):

442

return self._app_settings_type

442

return self._app_settings_type

443

444

@app_settings_type.setter

444

@app_settings_type.setter

445

def app_settings_type(self, val):

445

def app_settings_type(self, val):

446

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

446

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

447

if val not in SETTINGS_TYPES:

447

if val not in SETTINGS_TYPES:

448

raise Exception('type must be one of %s got %s'

448

raise Exception('type must be one of %s got %s'

449

% (SETTINGS_TYPES.keys(), val))

449

% (SETTINGS_TYPES.keys(), val))

450

self._app_settings_type = val

450

self._app_settings_type = val

451

452

def __unicode__(self):

452

def __unicode__(self):

453

return u"<%s('%s:%s:%s[%s]')>" % (

453

return u"<%s('%s:%s:%s[%s]')>" % (

454

self.__class__.__name__, self.repository.repo_name,

454

self.__class__.__name__, self.repository.repo_name,

455

self.app_settings_name, self.app_settings_value,

455

self.app_settings_name, self.app_settings_value,

456

self.app_settings_type

456

self.app_settings_type

457

)

457

)

458

459

460

class RepoRhodeCodeUi(Base, BaseModel):

460

class RepoRhodeCodeUi(Base, BaseModel):

461

__tablename__ = 'repo_rhodecode_ui'

461

__tablename__ = 'repo_rhodecode_ui'

462

__table_args__ = (

462

__table_args__ = (

463

UniqueConstraint(

463

UniqueConstraint(

464

'repository_id', 'ui_section', 'ui_key',

464

'repository_id', 'ui_section', 'ui_key',

465

name='uq_repo_rhodecode_ui_repository_id_section_key'),

465

name='uq_repo_rhodecode_ui_repository_id_section_key'),

466

{'extend_existing': True, 'mysql_engine': 'InnoDB',

466

{'extend_existing': True, 'mysql_engine': 'InnoDB',

467

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

467

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

468

)

468

)

469

470

repository_id = Column(

470

repository_id = Column(

471

"repository_id", Integer(), ForeignKey('repositories.repo_id'),

471

"repository_id", Integer(), ForeignKey('repositories.repo_id'),

472

nullable=False)

472

nullable=False)

473

ui_id = Column(

473

ui_id = Column(

474

"ui_id", Integer(), nullable=False, unique=True, default=None,

474

"ui_id", Integer(), nullable=False, unique=True, default=None,

475

primary_key=True)

475

primary_key=True)

476

ui_section = Column(

476

ui_section = Column(

477

"ui_section", String(255), nullable=True, unique=None, default=None)

477

"ui_section", String(255), nullable=True, unique=None, default=None)

478

ui_key = Column(

478

ui_key = Column(

479

"ui_key", String(255), nullable=True, unique=None, default=None)

479

"ui_key", String(255), nullable=True, unique=None, default=None)

480

ui_value = Column(

480

ui_value = Column(

481

"ui_value", String(255), nullable=True, unique=None, default=None)

481

"ui_value", String(255), nullable=True, unique=None, default=None)

482

ui_active = Column(

482

ui_active = Column(

483

"ui_active", Boolean(), nullable=True, unique=None, default=True)

483

"ui_active", Boolean(), nullable=True, unique=None, default=True)

484

485

repository = relationship('Repository')

485

repository = relationship('Repository')

486

487

def __repr__(self):

487

def __repr__(self):

488

return '<%s[%s:%s]%s=>%s]>' % (

488

return '<%s[%s:%s]%s=>%s]>' % (

489

self.__class__.__name__, self.repository.repo_name,

489

self.__class__.__name__, self.repository.repo_name,

490

self.ui_section, self.ui_key, self.ui_value)

490

self.ui_section, self.ui_key, self.ui_value)

491

492

493

class User(Base, BaseModel):

493

class User(Base, BaseModel):

494

__tablename__ = 'users'

494

__tablename__ = 'users'

495

__table_args__ = (

495

__table_args__ = (

496

UniqueConstraint('username'), UniqueConstraint('email'),

496

UniqueConstraint('username'), UniqueConstraint('email'),

497

Index('u_username_idx', 'username'),

497

Index('u_username_idx', 'username'),

498

Index('u_email_idx', 'email'),

498

Index('u_email_idx', 'email'),

499

{'extend_existing': True, 'mysql_engine': 'InnoDB',

499

{'extend_existing': True, 'mysql_engine': 'InnoDB',

500

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

500

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

501

)

501

)

502

DEFAULT_USER = 'default'

502

DEFAULT_USER = 'default'

503

DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'

503

DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'

504

DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'

504

DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'

505

506

user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

506

user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

507

username = Column("username", String(255), nullable=True, unique=None, default=None)

507

username = Column("username", String(255), nullable=True, unique=None, default=None)

508

password = Column("password", String(255), nullable=True, unique=None, default=None)

508

password = Column("password", String(255), nullable=True, unique=None, default=None)

509

active = Column("active", Boolean(), nullable=True, unique=None, default=True)

509

active = Column("active", Boolean(), nullable=True, unique=None, default=True)

510

admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

510

admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

511

name = Column("firstname", String(255), nullable=True, unique=None, default=None)

511

name = Column("firstname", String(255), nullable=True, unique=None, default=None)

512

lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)

512

lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)

513

_email = Column("email", String(255), nullable=True, unique=None, default=None)

513

_email = Column("email", String(255), nullable=True, unique=None, default=None)

514

last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

514

last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

515

extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)

515

extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)

516

extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)

516

extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)

517

api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)

517

api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)

518

inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)

518

inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)

519

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

519

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

520

_user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data

520

_user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data

521

522

user_log = relationship('UserLog')

522

user_log = relationship('UserLog')

523

user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

523

user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

524

525

repositories = relationship('Repository')

525

repositories = relationship('Repository')

526

repository_groups = relationship('RepoGroup')

526

repository_groups = relationship('RepoGroup')

527

user_groups = relationship('UserGroup')

527

user_groups = relationship('UserGroup')

528

529

user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

529

user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

530

followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')

530

followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')

531

532

repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

532

repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

533

repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')

533

repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')

534

user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')

534

user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')

535

536

group_member = relationship('UserGroupMember', cascade='all')

536

group_member = relationship('UserGroupMember', cascade='all')

537

538

notifications = relationship('UserNotification', cascade='all')

538

notifications = relationship('UserNotification', cascade='all')

539

# notifications assigned to this user

539

# notifications assigned to this user

540

user_created_notifications = relationship('Notification', cascade='all')

540

user_created_notifications = relationship('Notification', cascade='all')

541

# comments created by this user

541

# comments created by this user

542

user_comments = relationship('ChangesetComment', cascade='all')

542

user_comments = relationship('ChangesetComment', cascade='all')

543

# user profile extra info

543

# user profile extra info

544

user_emails = relationship('UserEmailMap', cascade='all')

544

user_emails = relationship('UserEmailMap', cascade='all')

545

user_ip_map = relationship('UserIpMap', cascade='all')

545

user_ip_map = relationship('UserIpMap', cascade='all')

546

user_auth_tokens = relationship('UserApiKeys', cascade='all')

546

user_auth_tokens = relationship('UserApiKeys', cascade='all')

547

# gists

547

# gists

548

user_gists = relationship('Gist', cascade='all')

548

user_gists = relationship('Gist', cascade='all')

549

# user pull requests

549

# user pull requests

550

user_pull_requests = relationship('PullRequest', cascade='all')

550

user_pull_requests = relationship('PullRequest', cascade='all')

551

# external identities

551

# external identities

552

extenal_identities = relationship(

552

extenal_identities = relationship(

553

'ExternalIdentity',

553

'ExternalIdentity',

554

primaryjoin="User.user_id==ExternalIdentity.local_user_id",

554

primaryjoin="User.user_id==ExternalIdentity.local_user_id",

555

cascade='all')

555

cascade='all')

556

557

def __unicode__(self):

557

def __unicode__(self):

558

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

558

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

559

self.user_id, self.username)

559

self.user_id, self.username)

560

561

@hybrid_property

561

@hybrid_property

562

def email(self):

562

def email(self):

563

return self._email

563

return self._email

564

565

@email.setter

565

@email.setter

566

def email(self, val):

566

def email(self, val):

567

self._email = val.lower() if val else None

567

self._email = val.lower() if val else None

568

569

@property

569

@property

570

def firstname(self):

570

def firstname(self):

571

# alias for future

571

# alias for future

572

return self.name

572

return self.name

573

574

@property

574

@property

575

def emails(self):

575

def emails(self):

576

other = UserEmailMap.query().filter(UserEmailMap.user==self).all()

576

other = UserEmailMap.query().filter(UserEmailMap.user==self).all()

577

return [self.email] + [x.email for x in other]

577

return [self.email] + [x.email for x in other]

578

579

@property

579

@property

580

def auth_tokens(self):

580

def auth_tokens(self):

581

return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]

581

return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]

582

583

@property

583

@property

584

def extra_auth_tokens(self):

584

def extra_auth_tokens(self):

585

return UserApiKeys.query().filter(UserApiKeys.user == self).all()

585

return UserApiKeys.query().filter(UserApiKeys.user == self).all()

586

587

@property

587

@property

588

def feed_token(self):

588

def feed_token(self):

589

feed_tokens = UserApiKeys.query()\

589

feed_tokens = UserApiKeys.query()\

590

.filter(UserApiKeys.user == self)\

590

.filter(UserApiKeys.user == self)\

591

.filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\

591

.filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\

592

.all()

592

.all()

593

if feed_tokens:

593

if feed_tokens:

594

return feed_tokens[0].api_key

594

return feed_tokens[0].api_key

595

else:

595

else:

596

# use the main token so we don't end up with nothing...

596

# use the main token so we don't end up with nothing...

597

return self.api_key

597

return self.api_key

598

599

@classmethod

599

@classmethod

600

def extra_valid_auth_tokens(cls, user, role=None):

600

def extra_valid_auth_tokens(cls, user, role=None):

601

tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\

601

tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\

602

.filter(or_(UserApiKeys.expires == -1,

602

.filter(or_(UserApiKeys.expires == -1,

603

UserApiKeys.expires >= time.time()))

603

UserApiKeys.expires >= time.time()))

604

if role:

604

if role:

605

tokens = tokens.filter(or_(UserApiKeys.role == role,

605

tokens = tokens.filter(or_(UserApiKeys.role == role,

606

UserApiKeys.role == UserApiKeys.ROLE_ALL))

606

UserApiKeys.role == UserApiKeys.ROLE_ALL))

607

return tokens.all()

607

return tokens.all()

608

609

@property

609

@property

610

def ip_addresses(self):

610

def ip_addresses(self):

611

ret = UserIpMap.query().filter(UserIpMap.user == self).all()

611

ret = UserIpMap.query().filter(UserIpMap.user == self).all()

612

return [x.ip_addr for x in ret]

612

return [x.ip_addr for x in ret]

613

614

@property

614

@property

615

def username_and_name(self):

615

def username_and_name(self):

616

return '%s (%s %s)' % (self.username, self.firstname, self.lastname)

616

return '%s (%s %s)' % (self.username, self.firstname, self.lastname)

617

618

@property

618

@property

619

def username_or_name_or_email(self):

619

def username_or_name_or_email(self):

620

full_name = self.full_name if self.full_name is not ' ' else None

620

full_name = self.full_name if self.full_name is not ' ' else None

621

return self.username or full_name or self.email

621

return self.username or full_name or self.email

622

623

@property

623

@property

624

def full_name(self):

624

def full_name(self):

625

return '%s %s' % (self.firstname, self.lastname)

625

return '%s %s' % (self.firstname, self.lastname)

626

627

@property

627

@property

628

def full_name_or_username(self):

628

def full_name_or_username(self):

629

return ('%s %s' % (self.firstname, self.lastname)

629

return ('%s %s' % (self.firstname, self.lastname)

630

if (self.firstname and self.lastname) else self.username)

630

if (self.firstname and self.lastname) else self.username)

631

632

@property

632

@property

633

def full_contact(self):

633

def full_contact(self):

634

return '%s %s <%s>' % (self.firstname, self.lastname, self.email)

634

return '%s %s <%s>' % (self.firstname, self.lastname, self.email)

635

636

@property

636

@property

637

def short_contact(self):

637

def short_contact(self):

638

return '%s %s' % (self.firstname, self.lastname)

638

return '%s %s' % (self.firstname, self.lastname)

639

640

@property

640

@property

641

def is_admin(self):

641

def is_admin(self):

642

return self.admin

642

return self.admin

643

644

@property

644

@property

645

def AuthUser(self):

645

def AuthUser(self):

646

"""

646

"""

647

Returns instance of AuthUser for this user

647

Returns instance of AuthUser for this user

648

"""

648

"""

649

from rhodecode.lib.auth import AuthUser

649

from rhodecode.lib.auth import AuthUser

650

return AuthUser(user_id=self.user_id, api_key=self.api_key,

650

return AuthUser(user_id=self.user_id, api_key=self.api_key,

651

username=self.username)

651

username=self.username)

652

653

@hybrid_property

653

@hybrid_property

654

def user_data(self):

654

def user_data(self):

655

if not self._user_data:

655

if not self._user_data:

656

return {}

656

return {}

657

658

try:

658

try:

659

return json.loads(self._user_data)

659

return json.loads(self._user_data)

660

except TypeError:

660

except TypeError:

661

return {}

661

return {}

662

663

@user_data.setter

663

@user_data.setter

664

def user_data(self, val):

664

def user_data(self, val):

665

if not isinstance(val, dict):

665

if not isinstance(val, dict):

666

raise Exception('user_data must be dict, got %s' % type(val))

666

raise Exception('user_data must be dict, got %s' % type(val))

667

try:

667

try:

668

self._user_data = json.dumps(val)

668

self._user_data = json.dumps(val)

669

except Exception:

669

except Exception:

670

log.error(traceback.format_exc())

670

log.error(traceback.format_exc())

671

672

@classmethod

672

@classmethod

673

def get_by_username(cls, username, case_insensitive=False,

673

def get_by_username(cls, username, case_insensitive=False,

674

cache=False, identity_cache=False):

674

cache=False, identity_cache=False):

675

session = Session()

675

session = Session()

676

677

if case_insensitive:

677

if case_insensitive:

678

q = cls.query().filter(

678

q = cls.query().filter(

679

func.lower(cls.username) == func.lower(username))

679

func.lower(cls.username) == func.lower(username))

680

else:

680

else:

681

q = cls.query().filter(cls.username == username)

681

q = cls.query().filter(cls.username == username)

682

683

if cache:

683

if cache:

684

if identity_cache:

684

if identity_cache:

685

val = cls.identity_cache(session, 'username', username)

685

val = cls.identity_cache(session, 'username', username)

686

if val:

686

if val:

687

return val

687

return val

688

else:

688

else:

689

q = q.options(

689

q = q.options(

690

FromCache("sql_cache_short",

690

FromCache("sql_cache_short",

691

"get_user_by_name_%s" % _hash_key(username)))

691

"get_user_by_name_%s" % _hash_key(username)))

692

693

return q.scalar()

693

return q.scalar()

694

695

@classmethod

695

@classmethod

696

def get_by_auth_token(cls, auth_token, cache=False, fallback=True):

696

def get_by_auth_token(cls, auth_token, cache=False, fallback=True):

697

q = cls.query().filter(cls.api_key == auth_token)

697

q = cls.query().filter(cls.api_key == auth_token)

698

699

if cache:

699

if cache:

700

q = q.options(FromCache("sql_cache_short",

700

q = q.options(FromCache("sql_cache_short",

701

"get_auth_token_%s" % auth_token))

701

"get_auth_token_%s" % auth_token))

702

res = q.scalar()

702

res = q.scalar()

703

704

if fallback and not res:

704

if fallback and not res:

705

#fallback to additional keys

705

#fallback to additional keys

706

_res = UserApiKeys.query()\

706

_res = UserApiKeys.query()\

707

.filter(UserApiKeys.api_key == auth_token)\

707

.filter(UserApiKeys.api_key == auth_token)\

708

.filter(or_(UserApiKeys.expires == -1,

708

.filter(or_(UserApiKeys.expires == -1,

709

UserApiKeys.expires >= time.time()))\

709

UserApiKeys.expires >= time.time()))\

710

.first()

710

.first()

711

if _res:

711

if _res:

712

res = _res.user

712

res = _res.user

713

return res

713

return res

714

715

@classmethod

715

@classmethod

716

def get_by_email(cls, email, case_insensitive=False, cache=False):

716

def get_by_email(cls, email, case_insensitive=False, cache=False):

717

718

if case_insensitive:

718

if case_insensitive:

719

q = cls.query().filter(func.lower(cls.email) == func.lower(email))

719

q = cls.query().filter(func.lower(cls.email) == func.lower(email))

720

721

else:

721

else:

722

q = cls.query().filter(cls.email == email)

722

q = cls.query().filter(cls.email == email)

723

724

if cache:

724

if cache:

725

q = q.options(FromCache("sql_cache_short",

725

q = q.options(FromCache("sql_cache_short",

726

"get_email_key_%s" % _hash_key(email)))

726

"get_email_key_%s" % _hash_key(email)))

727

728

ret = q.scalar()

728

ret = q.scalar()

729

if ret is None:

729

if ret is None:

730

q = UserEmailMap.query()

730

q = UserEmailMap.query()

731

# try fetching in alternate email map

731

# try fetching in alternate email map

732

if case_insensitive:

732

if case_insensitive:

733

q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))

733

q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))

734

else:

734

else:

735

q = q.filter(UserEmailMap.email == email)

735

q = q.filter(UserEmailMap.email == email)

736

q = q.options(joinedload(UserEmailMap.user))

736

q = q.options(joinedload(UserEmailMap.user))

737

if cache:

737

if cache:

738

q = q.options(FromCache("sql_cache_short",

738

q = q.options(FromCache("sql_cache_short",

739

"get_email_map_key_%s" % email))

739

"get_email_map_key_%s" % email))

740

ret = getattr(q.scalar(), 'user', None)

740

ret = getattr(q.scalar(), 'user', None)

741

742

return ret

742

return ret

743

744

@classmethod

744

@classmethod

745

def get_from_cs_author(cls, author):

745

def get_from_cs_author(cls, author):

746

"""

746

"""

747

Tries to get User objects out of commit author string

747

Tries to get User objects out of commit author string

748

749

:param author:

749

:param author:

750

"""

750

"""

751

from rhodecode.lib.helpers import email, author_name

751

from rhodecode.lib.helpers import email, author_name

752

# Valid email in the attribute passed, see if they're in the system

752

# Valid email in the attribute passed, see if they're in the system

753

_email = email(author)

753

_email = email(author)

754

if _email:

754

if _email:

755

user = cls.get_by_email(_email, case_insensitive=True)

755

user = cls.get_by_email(_email, case_insensitive=True)

756

if user:

756

if user:

757

return user

757

return user

758

# Maybe we can match by username?

758

# Maybe we can match by username?

759

_author = author_name(author)

759

_author = author_name(author)

760

user = cls.get_by_username(_author, case_insensitive=True)

760

user = cls.get_by_username(_author, case_insensitive=True)

761

if user:

761

if user:

762

return user

762

return user

763

764

def update_userdata(self, **kwargs):

764

def update_userdata(self, **kwargs):

765

usr = self

765

usr = self

766

old = usr.user_data

766

old = usr.user_data

767

old.update(**kwargs)

767

old.update(**kwargs)

768

usr.user_data = old

768

usr.user_data = old

769

Session().add(usr)

769

Session().add(usr)

770

log.debug('updated userdata with ', kwargs)

770

log.debug('updated userdata with ', kwargs)

771

772

def update_lastlogin(self):

772

def update_lastlogin(self):

773

"""Update user lastlogin"""

773

"""Update user lastlogin"""

774

self.last_login = datetime.datetime.now()

774

self.last_login = datetime.datetime.now()

775

Session().add(self)

775

Session().add(self)

776

log.debug('updated user %s lastlogin', self.username)

776

log.debug('updated user %s lastlogin', self.username)

777

778

def update_lastactivity(self):

778

def update_lastactivity(self):

779

"""Update user lastactivity"""

779

"""Update user lastactivity"""

780

usr = self

780

usr = self

781

old = usr.user_data

781

old = usr.user_data

782

old.update({'last_activity': time.time()})

782

old.update({'last_activity': time.time()})

783

usr.user_data = old

783

usr.user_data = old

784

Session().add(usr)

784

Session().add(usr)

785

log.debug('updated user %s lastactivity', usr.username)

785

log.debug('updated user %s lastactivity', usr.username)

786

787

def update_password(self, new_password, change_api_key=False):

787

def update_password(self, new_password, change_api_key=False):

788

from rhodecode.lib.auth import get_crypt_password,generate_auth_token

788

from rhodecode.lib.auth import get_crypt_password,generate_auth_token

789

790

self.password = get_crypt_password(new_password)

790

self.password = get_crypt_password(new_password)

791

if change_api_key:

791

if change_api_key:

792

self.api_key = generate_auth_token(self.username)

792

self.api_key = generate_auth_token(self.username)

793

Session().add(self)

793

Session().add(self)

794

795

@classmethod

795

@classmethod

796

def get_first_super_admin(cls):

796

def get_first_super_admin(cls):

797

user = User.query().filter(User.admin == true()).first()

797

user = User.query().filter(User.admin == true()).first()

798

if user is None:

798

if user is None:

799

raise Exception('FATAL: Missing administrative account!')

799

raise Exception('FATAL: Missing administrative account!')

800

return user

800

return user

801

802

@classmethod

802

@classmethod

803

def get_all_super_admins(cls):

803

def get_all_super_admins(cls):

804

"""

804

"""

805

Returns all admin accounts sorted by username

805

Returns all admin accounts sorted by username

806

"""

806

"""

807

return User.query().filter(User.admin == true())\

807

return User.query().filter(User.admin == true())\

808

.order_by(User.username.asc()).all()

808

.order_by(User.username.asc()).all()

809

810

@classmethod

810

@classmethod

811

def get_default_user(cls, cache=False):

811

def get_default_user(cls, cache=False):

812

user = User.get_by_username(User.DEFAULT_USER, cache=cache)

812

user = User.get_by_username(User.DEFAULT_USER, cache=cache)

813

if user is None:

813

if user is None:

814

raise Exception('FATAL: Missing default account!')

814

raise Exception('FATAL: Missing default account!')

815

return user

815

return user

816

817

def _get_default_perms(self, user, suffix=''):

817

def _get_default_perms(self, user, suffix=''):

818

from rhodecode.model.permission import PermissionModel

818

from rhodecode.model.permission import PermissionModel

819

return PermissionModel().get_default_perms(user.user_perms, suffix)

819

return PermissionModel().get_default_perms(user.user_perms, suffix)

820

821

def get_default_perms(self, suffix=''):

821

def get_default_perms(self, suffix=''):

822

return self._get_default_perms(self, suffix)

822

return self._get_default_perms(self, suffix)

823

824

def get_api_data(self, include_secrets=False, details='full'):

824

def get_api_data(self, include_secrets=False, details='full'):

825

"""

825

"""

826

Common function for generating user related data for API

826

Common function for generating user related data for API

827

828

:param include_secrets: By default secrets in the API data will be replaced

828

:param include_secrets: By default secrets in the API data will be replaced

829

by a placeholder value to prevent exposing this data by accident. In case

829

by a placeholder value to prevent exposing this data by accident. In case

830

this data shall be exposed, set this flag to ``True``.

830

this data shall be exposed, set this flag to ``True``.

831

832

:param details: details can be 'basic|full' basic gives only a subset of

832

:param details: details can be 'basic|full' basic gives only a subset of

833

the available user information that includes user_id, name and emails.

833

the available user information that includes user_id, name and emails.

834

"""

834

"""

835

user = self

835

user = self

836

user_data = self.user_data

836

user_data = self.user_data

837

data = {

837

data = {

838

'user_id': user.user_id,

838

'user_id': user.user_id,

839

'username': user.username,

839

'username': user.username,

840

'firstname': user.name,

840

'firstname': user.name,

841

'lastname': user.lastname,

841

'lastname': user.lastname,

842

'email': user.email,

842

'email': user.email,

843

'emails': user.emails,

843

'emails': user.emails,

844

}

844

}

845

if details == 'basic':

845

if details == 'basic':

846

return data

846

return data

847

848

api_key_length = 40

848

api_key_length = 40

849

api_key_replacement = '*' * api_key_length

849

api_key_replacement = '*' * api_key_length

850

851

extras = {

851

extras = {

852

'api_key': api_key_replacement,

852

'api_key': api_key_replacement,

853

'api_keys': [api_key_replacement],

853

'api_keys': [api_key_replacement],

854

'active': user.active,

854

'active': user.active,

855

'admin': user.admin,

855

'admin': user.admin,

856

'extern_type': user.extern_type,

856

'extern_type': user.extern_type,

857

'extern_name': user.extern_name,

857

'extern_name': user.extern_name,

858

'last_login': user.last_login,

858

'last_login': user.last_login,

859

'ip_addresses': user.ip_addresses,

859

'ip_addresses': user.ip_addresses,

860

'language': user_data.get('language')

860

'language': user_data.get('language')

861

}

861

}

862

data.update(extras)

862

data.update(extras)

863

864

if include_secrets:

864

if include_secrets:

865

data['api_key'] = user.api_key

865

data['api_key'] = user.api_key

866

data['api_keys'] = user.auth_tokens

866

data['api_keys'] = user.auth_tokens

867

return data

867

return data

868

869

def __json__(self):

869

def __json__(self):

870

data = {

870

data = {

871

'full_name': self.full_name,

871

'full_name': self.full_name,

872

'full_name_or_username': self.full_name_or_username,

872

'full_name_or_username': self.full_name_or_username,

873

'short_contact': self.short_contact,

873

'short_contact': self.short_contact,

874

'full_contact': self.full_contact,

874

'full_contact': self.full_contact,

875

}

875

}

876

data.update(self.get_api_data())

876

data.update(self.get_api_data())

877

return data

877

return data

878

879

880

class UserApiKeys(Base, BaseModel):

880

class UserApiKeys(Base, BaseModel):

881

__tablename__ = 'user_api_keys'

881

__tablename__ = 'user_api_keys'

882

__table_args__ = (

882

__table_args__ = (

883

Index('uak_api_key_idx', 'api_key'),

883

Index('uak_api_key_idx', 'api_key'),

884

Index('uak_api_key_expires_idx', 'api_key', 'expires'),

884

Index('uak_api_key_expires_idx', 'api_key', 'expires'),

885

UniqueConstraint('api_key'),

885

UniqueConstraint('api_key'),

886

{'extend_existing': True, 'mysql_engine': 'InnoDB',

886

{'extend_existing': True, 'mysql_engine': 'InnoDB',

887

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

887

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

888

)

888

)

889

__mapper_args__ = {}

889

__mapper_args__ = {}

890

891

# ApiKey role

891

# ApiKey role

892

ROLE_ALL = 'token_role_all'

892

ROLE_ALL = 'token_role_all'

893

ROLE_HTTP = 'token_role_http'

893

ROLE_HTTP = 'token_role_http'

894

ROLE_VCS = 'token_role_vcs'

894

ROLE_VCS = 'token_role_vcs'

895

ROLE_API = 'token_role_api'

895

ROLE_API = 'token_role_api'

896

ROLE_FEED = 'token_role_feed'

896

ROLE_FEED = 'token_role_feed'

897

ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]

897

ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]

898

899

user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

899

user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

900

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

900

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

901

api_key = Column("api_key", String(255), nullable=False, unique=True)

901

api_key = Column("api_key", String(255), nullable=False, unique=True)

902

description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

902

description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

903

expires = Column('expires', Float(53), nullable=False)

903

expires = Column('expires', Float(53), nullable=False)

904

role = Column('role', String(255), nullable=True)

904

role = Column('role', String(255), nullable=True)

905

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

905

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

906

907

user = relationship('User', lazy='joined')

907

user = relationship('User', lazy='joined')

908

909

@classmethod

909

@classmethod

910

def _get_role_name(cls, role):

910

def _get_role_name(cls, role):

911

return {

911

return {

912

cls.ROLE_ALL: _('all'),

912

cls.ROLE_ALL: _('all'),

913

cls.ROLE_HTTP: _('http/web interface'),

913

cls.ROLE_HTTP: _('http/web interface'),

914

cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),

914

cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),

915

cls.ROLE_API: _('api calls'),

915

cls.ROLE_API: _('api calls'),

916

cls.ROLE_FEED: _('feed access'),

916

cls.ROLE_FEED: _('feed access'),

917

}.get(role, role)

917

}.get(role, role)

918

919

@property

919

@property

920

def expired(self):

920

def expired(self):

921

if self.expires == -1:

921

if self.expires == -1:

922

return False

922

return False

923

return time.time() > self.expires

923

return time.time() > self.expires

924

925

@property

925

@property

926

def role_humanized(self):

926

def role_humanized(self):

927

return self._get_role_name(self.role)

927

return self._get_role_name(self.role)

928

929

930

class UserEmailMap(Base, BaseModel):

930

class UserEmailMap(Base, BaseModel):

931

__tablename__ = 'user_email_map'

931

__tablename__ = 'user_email_map'

932

__table_args__ = (

932

__table_args__ = (

933

Index('uem_email_idx', 'email'),

933

Index('uem_email_idx', 'email'),

934

UniqueConstraint('email'),

934

UniqueConstraint('email'),

935

{'extend_existing': True, 'mysql_engine': 'InnoDB',

935

{'extend_existing': True, 'mysql_engine': 'InnoDB',

936

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

936

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

937

)

937

)

938

__mapper_args__ = {}

938

__mapper_args__ = {}

939

940

email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

940

email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

941

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

941

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

942

_email = Column("email", String(255), nullable=True, unique=False, default=None)

942

_email = Column("email", String(255), nullable=True, unique=False, default=None)

943

user = relationship('User', lazy='joined')

943

user = relationship('User', lazy='joined')

944

945

@validates('_email')

945

@validates('_email')

946

def validate_email(self, key, email):

946

def validate_email(self, key, email):

947

# check if this email is not main one

947

# check if this email is not main one

948

main_email = Session().query(User).filter(User.email == email).scalar()

948

main_email = Session().query(User).filter(User.email == email).scalar()

949

if main_email is not None:

949

if main_email is not None:

950

raise AttributeError('email %s is present is user table' % email)

950

raise AttributeError('email %s is present is user table' % email)

951

return email

951

return email

952

953

@hybrid_property

953

@hybrid_property

954

def email(self):

954

def email(self):

955

return self._email

955

return self._email

956

957

@email.setter

957

@email.setter

958

def email(self, val):

958

def email(self, val):

959

self._email = val.lower() if val else None

959

self._email = val.lower() if val else None

960

961

962

class UserIpMap(Base, BaseModel):

962

class UserIpMap(Base, BaseModel):

963

__tablename__ = 'user_ip_map'

963

__tablename__ = 'user_ip_map'

964

__table_args__ = (

964

__table_args__ = (

965

UniqueConstraint('user_id', 'ip_addr'),

965

UniqueConstraint('user_id', 'ip_addr'),

966

{'extend_existing': True, 'mysql_engine': 'InnoDB',

966

{'extend_existing': True, 'mysql_engine': 'InnoDB',

967

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

967

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

968

)

968

)

969

__mapper_args__ = {}

969

__mapper_args__ = {}

970

971

ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

971

ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

972

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

972

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

973

ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)

973

ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)

974

active = Column("active", Boolean(), nullable=True, unique=None, default=True)

974

active = Column("active", Boolean(), nullable=True, unique=None, default=True)

975

description = Column("description", String(10000), nullable=True, unique=None, default=None)

975

description = Column("description", String(10000), nullable=True, unique=None, default=None)

976

user = relationship('User', lazy='joined')

976

user = relationship('User', lazy='joined')

977

978

@classmethod

978

@classmethod

979

def _get_ip_range(cls, ip_addr):

979

def _get_ip_range(cls, ip_addr):

980

net = ipaddress.ip_network(ip_addr, strict=False)

980

net = ipaddress.ip_network(ip_addr, strict=False)

981

return [str(net.network_address), str(net.broadcast_address)]

981

return [str(net.network_address), str(net.broadcast_address)]

982

983

def __json__(self):

983

def __json__(self):

984

return {

984

return {

985

'ip_addr': self.ip_addr,

985

'ip_addr': self.ip_addr,

986

'ip_range': self._get_ip_range(self.ip_addr),

986

'ip_range': self._get_ip_range(self.ip_addr),

987

}

987

}

988

989

def __unicode__(self):

989

def __unicode__(self):

990

return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,

990

return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,

991

self.user_id, self.ip_addr)

991

self.user_id, self.ip_addr)

992

993

class UserLog(Base, BaseModel):

993

class UserLog(Base, BaseModel):

994

__tablename__ = 'user_logs'

994

__tablename__ = 'user_logs'

995

__table_args__ = (

995

__table_args__ = (

996

{'extend_existing': True, 'mysql_engine': 'InnoDB',

996

{'extend_existing': True, 'mysql_engine': 'InnoDB',

997

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

997

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

998

)

998

)

999

user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

999

user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1000

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

1000

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

1001

username = Column("username", String(255), nullable=True, unique=None, default=None)

1001

username = Column("username", String(255), nullable=True, unique=None, default=None)

1002

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

1002

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

1003

repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)

1003

repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)

1004

user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)

1004

user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)

1005

action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)

1005

action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)

1006

action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

1006

action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

1007

1008

def __unicode__(self):

1008

def __unicode__(self):

1009

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

1009

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

1010

self.repository_name,

1010

self.repository_name,

1011

self.action)

1011

self.action)

1012

1013

@property

1013

@property

1014

def action_as_day(self):

1014

def action_as_day(self):

1015

return datetime.date(*self.action_date.timetuple()[:3])

1015

return datetime.date(*self.action_date.timetuple()[:3])

1016

1017

user = relationship('User')

1017

user = relationship('User')

1018

repository = relationship('Repository', cascade='')

1018

repository = relationship('Repository', cascade='')

1019

1020

1021

class UserGroup(Base, BaseModel):

1021

class UserGroup(Base, BaseModel):

1022

__tablename__ = 'users_groups'

1022

__tablename__ = 'users_groups'

1023

__table_args__ = (

1023

__table_args__ = (

1024

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1024

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1025

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1025

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1026

)

1026

)

1027

1028

users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1028

users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1029

users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)

1029

users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)

1030

user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)

1030

user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)

1031

users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)

1031

users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)

1032

inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)

1032

inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)

1033

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

1033

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

1034

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

1034

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

1035

_group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data

1035

_group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data

1036

1037

members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")

1037

members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")

1038

users_group_to_perm = relationship('UserGroupToPerm', cascade='all')

1038

users_group_to_perm = relationship('UserGroupToPerm', cascade='all')

1039

users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

1039

users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

1040

users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

1040

users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

1041

user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')

1041

user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')

1042

user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')

1042

user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')

1043

1044

user = relationship('User')

1044

user = relationship('User')

1045

1046

@hybrid_property

1046

@hybrid_property

1047

def group_data(self):

1047

def group_data(self):

1048

if not self._group_data:

1048

if not self._group_data:

1049

return {}

1049

return {}

1050

1051

try:

1051

try:

1052

return json.loads(self._group_data)

1052

return json.loads(self._group_data)

1053

except TypeError:

1053

except TypeError:

1054

return {}

1054

return {}

1055

1056

@group_data.setter

1056

@group_data.setter

1057

def group_data(self, val):

1057

def group_data(self, val):

1058

try:

1058

try:

1059

self._group_data = json.dumps(val)

1059

self._group_data = json.dumps(val)

1060

except Exception:

1060

except Exception:

1061

log.error(traceback.format_exc())

1061

log.error(traceback.format_exc())

1062

1063

def __unicode__(self):

1063

def __unicode__(self):

1064

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

1064

return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

1065

self.users_group_id,

1065

self.users_group_id,

1066

self.users_group_name)

1066

self.users_group_name)

1067

1068

@classmethod

1068

@classmethod

1069

def get_by_group_name(cls, group_name, cache=False,

1069

def get_by_group_name(cls, group_name, cache=False,

1070

case_insensitive=False):

1070

case_insensitive=False):

1071

if case_insensitive:

1071

if case_insensitive:

1072

q = cls.query().filter(func.lower(cls.users_group_name) ==

1072

q = cls.query().filter(func.lower(cls.users_group_name) ==

1073

func.lower(group_name))

1073

func.lower(group_name))

1074

1075

else:

1075

else:

1076

q = cls.query().filter(cls.users_group_name == group_name)

1076

q = cls.query().filter(cls.users_group_name == group_name)

1077

if cache:

1077

if cache:

1078

q = q.options(FromCache(

1078

q = q.options(FromCache(

1079

"sql_cache_short",

1079

"sql_cache_short",

1080

"get_group_%s" % _hash_key(group_name)))

1080

"get_group_%s" % _hash_key(group_name)))

1081

return q.scalar()

1081

return q.scalar()

1082

1083

@classmethod

1083

@classmethod

1084

def get(cls, user_group_id, cache=False):

1084

def get(cls, user_group_id, cache=False):

1085

user_group = cls.query()

1085

user_group = cls.query()

1086

if cache:

1086

if cache:

1087

user_group = user_group.options(FromCache("sql_cache_short",

1087

user_group = user_group.options(FromCache("sql_cache_short",

1088

"get_users_group_%s" % user_group_id))

1088

"get_users_group_%s" % user_group_id))

1089

return user_group.get(user_group_id)

1089

return user_group.get(user_group_id)

1090

1091

def permissions(self, with_admins=True, with_owner=True):

1091

def permissions(self, with_admins=True, with_owner=True):

1092

q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)

1092

q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)

1093

q = q.options(joinedload(UserUserGroupToPerm.user_group),

1093

q = q.options(joinedload(UserUserGroupToPerm.user_group),

1094

joinedload(UserUserGroupToPerm.user),

1094

joinedload(UserUserGroupToPerm.user),

1095

joinedload(UserUserGroupToPerm.permission),)

1095

joinedload(UserUserGroupToPerm.permission),)

1096

1097

# get owners and admins and permissions. We do a trick of re-writing

1097

# get owners and admins and permissions. We do a trick of re-writing

1098

# objects from sqlalchemy to named-tuples due to sqlalchemy session

1098

# objects from sqlalchemy to named-tuples due to sqlalchemy session

1099

# has a global reference and changing one object propagates to all

1099

# has a global reference and changing one object propagates to all

1100

# others. This means if admin is also an owner admin_row that change

1100

# others. This means if admin is also an owner admin_row that change

1101

# would propagate to both objects

1101

# would propagate to both objects

1102

perm_rows = []

1102

perm_rows = []

1103

for _usr in q.all():

1103

for _usr in q.all():

1104

usr = AttributeDict(_usr.user.get_dict())

1104

usr = AttributeDict(_usr.user.get_dict())

1105

usr.permission = _usr.permission.permission_name

1105

usr.permission = _usr.permission.permission_name

1106

perm_rows.append(usr)

1106

perm_rows.append(usr)

1107

1108

# filter the perm rows by 'default' first and then sort them by

1108

# filter the perm rows by 'default' first and then sort them by

1109

# admin,write,read,none permissions sorted again alphabetically in

1109

# admin,write,read,none permissions sorted again alphabetically in

1110

# each group

1110

# each group

1111

perm_rows = sorted(perm_rows, key=display_sort)

1111

perm_rows = sorted(perm_rows, key=display_sort)

1112

1113

_admin_perm = 'usergroup.admin'

1113

_admin_perm = 'usergroup.admin'

1114

owner_row = []

1114

owner_row = []

1115

if with_owner:

1115

if with_owner:

1116

usr = AttributeDict(self.user.get_dict())

1116

usr = AttributeDict(self.user.get_dict())

1117

usr.owner_row = True

1117

usr.owner_row = True

1118

usr.permission = _admin_perm

1118

usr.permission = _admin_perm

1119

owner_row.append(usr)

1119

owner_row.append(usr)

1120

1121

super_admin_rows = []

1121

super_admin_rows = []

1122

if with_admins:

1122

if with_admins:

1123

for usr in User.get_all_super_admins():

1123

for usr in User.get_all_super_admins():

1124

# if this admin is also owner, don't double the record

1124

# if this admin is also owner, don't double the record

1125

if usr.user_id == owner_row[0].user_id:

1125

if usr.user_id == owner_row[0].user_id:

1126

owner_row[0].admin_row = True

1126

owner_row[0].admin_row = True

1127

else:

1127

else:

1128

usr = AttributeDict(usr.get_dict())

1128

usr = AttributeDict(usr.get_dict())

1129

usr.admin_row = True

1129

usr.admin_row = True

1130

usr.permission = _admin_perm

1130

usr.permission = _admin_perm

1131

super_admin_rows.append(usr)

1131

super_admin_rows.append(usr)

1132

1133

return super_admin_rows + owner_row + perm_rows

1133

return super_admin_rows + owner_row + perm_rows

1134

1135

def permission_user_groups(self):

1135

def permission_user_groups(self):

1136

q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)

1136

q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)

1137

q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),

1137

q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),

1138

joinedload(UserGroupUserGroupToPerm.target_user_group),

1138

joinedload(UserGroupUserGroupToPerm.target_user_group),

1139

joinedload(UserGroupUserGroupToPerm.permission),)

1139

joinedload(UserGroupUserGroupToPerm.permission),)

1140

1141

perm_rows = []

1141

perm_rows = []

1142

for _user_group in q.all():

1142

for _user_group in q.all():

1143

usr = AttributeDict(_user_group.user_group.get_dict())

1143

usr = AttributeDict(_user_group.user_group.get_dict())

1144

usr.permission = _user_group.permission.permission_name

1144

usr.permission = _user_group.permission.permission_name

1145

perm_rows.append(usr)

1145

perm_rows.append(usr)

1146

1147

return perm_rows

1147

return perm_rows

1148

1149

def _get_default_perms(self, user_group, suffix=''):

1149

def _get_default_perms(self, user_group, suffix=''):

1150

from rhodecode.model.permission import PermissionModel

1150

from rhodecode.model.permission import PermissionModel

1151

return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)

1151

return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)

1152

1153

def get_default_perms(self, suffix=''):

1153

def get_default_perms(self, suffix=''):

1154

return self._get_default_perms(self, suffix)

1154

return self._get_default_perms(self, suffix)

1155

1156

def get_api_data(self, with_group_members=True, include_secrets=False):

1156

def get_api_data(self, with_group_members=True, include_secrets=False):

1157

"""

1157

"""

1158

:param include_secrets: See :meth:`User.get_api_data`, this parameter is

1158

:param include_secrets: See :meth:`User.get_api_data`, this parameter is

1159

basically forwarded.

1159

basically forwarded.

1160

1161

"""

1161

"""

1162

user_group = self

1162

user_group = self

1163

1164

data = {

1164

data = {

1165

'users_group_id': user_group.users_group_id,

1165

'users_group_id': user_group.users_group_id,

1166

'group_name': user_group.users_group_name,

1166

'group_name': user_group.users_group_name,

1167

'group_description': user_group.user_group_description,

1167

'group_description': user_group.user_group_description,

1168

'active': user_group.users_group_active,

1168

'active': user_group.users_group_active,

1169

'owner': user_group.user.username,

1169

'owner': user_group.user.username,

1170

}

1170

}

1171

if with_group_members:

1171

if with_group_members:

1172

users = []

1172

users = []

1173

for user in user_group.members:

1173

for user in user_group.members:

1174

user = user.user

1174

user = user.user

1175

users.append(user.get_api_data(include_secrets=include_secrets))

1175

users.append(user.get_api_data(include_secrets=include_secrets))

1176

data['users'] = users

1176

data['users'] = users

1177

1178

return data

1178

return data

1179

1180

1181

class UserGroupMember(Base, BaseModel):

1181

class UserGroupMember(Base, BaseModel):

1182

__tablename__ = 'users_groups_members'

1182

__tablename__ = 'users_groups_members'

1183

__table_args__ = (

1183

__table_args__ = (

1184

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1184

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1185

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1185

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1186

)

1186

)

1187

1188

users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1188

users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1189

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

1189

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

1190

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

1190

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

1191

1192

user = relationship('User', lazy='joined')

1192

user = relationship('User', lazy='joined')

1193

users_group = relationship('UserGroup')

1193

users_group = relationship('UserGroup')

1194

1195

def __init__(self, gr_id='', u_id=''):

1195

def __init__(self, gr_id='', u_id=''):

1196

self.users_group_id = gr_id

1196

self.users_group_id = gr_id

1197

self.user_id = u_id

1197

self.user_id = u_id

1198

1199

1200

class RepositoryField(Base, BaseModel):

1200

class RepositoryField(Base, BaseModel):

1201

__tablename__ = 'repositories_fields'

1201

__tablename__ = 'repositories_fields'

1202

__table_args__ = (

1202

__table_args__ = (

1203

UniqueConstraint('repository_id', 'field_key'), # no-multi field

1203

UniqueConstraint('repository_id', 'field_key'), # no-multi field

1204

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1204

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1205

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1205

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1206

)

1206

)

1207

PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields

1207

PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields

1208

1209

repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1209

repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

1210

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

1210

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

1211

field_key = Column("field_key", String(250))

1211

field_key = Column("field_key", String(250))

1212

field_label = Column("field_label", String(1024), nullable=False)

1212

field_label = Column("field_label", String(1024), nullable=False)

1213

field_value = Column("field_value", String(10000), nullable=False)

1213

field_value = Column("field_value", String(10000), nullable=False)

1214

field_desc = Column("field_desc", String(1024), nullable=False)

1214

field_desc = Column("field_desc", String(1024), nullable=False)

1215

field_type = Column("field_type", String(255), nullable=False, unique=None)

1215

field_type = Column("field_type", String(255), nullable=False, unique=None)

1216

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

1216

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

1217

1218

repository = relationship('Repository')

1218

repository = relationship('Repository')

1219

1220

@property

1220

@property

1221

def field_key_prefixed(self):

1221

def field_key_prefixed(self):

1222

return 'ex_%s' % self.field_key

1222

return 'ex_%s' % self.field_key

1223

1224

@classmethod

1224

@classmethod

1225

def un_prefix_key(cls, key):

1225

def un_prefix_key(cls, key):

1226

if key.startswith(cls.PREFIX):

1226

if key.startswith(cls.PREFIX):

1227

return key[len(cls.PREFIX):]

1227

return key[len(cls.PREFIX):]

1228

return key

1228

return key

1229

1230

@classmethod

1230

@classmethod

1231

def get_by_key_name(cls, key, repo):

1231

def get_by_key_name(cls, key, repo):

1232

row = cls.query()\

1232

row = cls.query()\

1233

.filter(cls.repository == repo)\

1233

.filter(cls.repository == repo)\

1234

.filter(cls.field_key == key).scalar()

1234

.filter(cls.field_key == key).scalar()

1235

return row

1235

return row

1236

1237

1238

class Repository(Base, BaseModel):

1238

class Repository(Base, BaseModel):

1239

__tablename__ = 'repositories'

1239

__tablename__ = 'repositories'

1240

__table_args__ = (

1240

__table_args__ = (

1241

Index('r_repo_name_idx', 'repo_name', mysql_length=255),

1241

Index('r_repo_name_idx', 'repo_name', mysql_length=255),

1242

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1242

{'extend_existing': True, 'mysql_engine': 'InnoDB',

1243

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1243

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

1244

)

1244

)

1245

DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

1245

DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

1246

DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

1246

DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

1247

1248

STATE_CREATED = 'repo_state_created'

1248

STATE_CREATED = 'repo_state_created'

1249

STATE_PENDING = 'repo_state_pending'

1249

STATE_PENDING = 'repo_state_pending'

1250

STATE_ERROR = 'repo_state_error'

1250

STATE_ERROR = 'repo_state_error'

1251

1252

LOCK_AUTOMATIC = 'lock_auto'

1252

LOCK_AUTOMATIC = 'lock_auto'

1253

LOCK_API = 'lock_api'

1253

LOCK_API = 'lock_api'

1254

LOCK_WEB = 'lock_web'

1254

LOCK_WEB = 'lock_web'

1255

LOCK_PULL = 'lock_pull'

1255

LOCK_PULL = 'lock_pull'

1256

1257

NAME_SEP = URL_SEP

1257

NAME_SEP = URL_SEP

1258

1259

repo_id = Column(

1259

repo_id = Column(

1260

"repo_id", Integer(), nullable=False, unique=True, default=None,

1260

"repo_id", Integer(), nullable=False, unique=True, default=None,

1261

primary_key=True)

1261

primary_key=True)

1262

_repo_name = Column(

1262

_repo_name = Column(

1263

"repo_name", Text(), nullable=False, default=None)

1263

"repo_name", Text(), nullable=False, default=None)

1264

_repo_name_hash = Column(

1264

_repo_name_hash = Column(

1265

"repo_name_hash", String(255), nullable=False, unique=True)

1265

"repo_name_hash", String(255), nullable=False, unique=True)

1266

repo_state = Column("repo_state", String(255), nullable=True)

1266

repo_state = Column("repo_state", String(255), nullable=True)

1267

1268

clone_uri = Column(

1268

clone_uri = Column(

1269

"clone_uri", EncryptedTextValue(), nullable=True, unique=False,

1269

"clone_uri", EncryptedTextValue(), nullable=True, unique=False,

1270

default=None)

1270

default=None)

1271

repo_type = Column(

1271

repo_type = Column(

1272

"repo_type", String(255), nullable=False, unique=False, default=None)

1272

"repo_type", String(255), nullable=False, unique=False, default=None)

1273

user_id = Column(

1273

user_id = Column(

1274

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

1274

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

1275

unique=False, default=None)

1275

unique=False, default=None)

1276

private = Column(

1276

private = Column(

1277

"private", Boolean(), nullable=True, unique=None, default=None)

1277

"private", Boolean(), nullable=True, unique=None, default=None)

1278

enable_statistics = Column(

1278

enable_statistics = Column(

1279

"statistics", Boolean(), nullable=True, unique=None, default=True)

1279

"statistics", Boolean(), nullable=True, unique=None, default=True)

1280

enable_downloads = Column(

1280

enable_downloads = Column(

1281

"downloads", Boolean(), nullable=True, unique=None, default=True)

1281

"downloads", Boolean(), nullable=True, unique=None, default=True)

1282

description = Column(

1282

description = Column(

1283

"description", String(10000), nullable=True, unique=None, default=None)

1283

"description", String(10000), nullable=True, unique=None, default=None)

1284

created_on = Column(

1284

created_on = Column(

1285

'created_on', DateTime(timezone=False), nullable=True, unique=None,

1285

'created_on', DateTime(timezone=False), nullable=True, unique=None,

1286

default=datetime.datetime.now)

1286

default=datetime.datetime.now)

1287

updated_on = Column(

1287

updated_on = Column(

1288

'updated_on', DateTime(timezone=False), nullable=True, unique=None,

1288

'updated_on', DateTime(timezone=False), nullable=True, unique=None,

1289

default=datetime.datetime.now)

1289

default=datetime.datetime.now)

1290

_landing_revision = Column(

1290

_landing_revision = Column(

1291

"landing_revision", String(255), nullable=False, unique=False,

1291

"landing_revision", String(255), nullable=False, unique=False,

1292

default=None)

1292

default=None)

1293

enable_locking = Column(

1293

enable_locking = Column(

1294

"enable_locking", Boolean(), nullable=False, unique=None,

1294

"enable_locking", Boolean(), nullable=False, unique=None,

1295

default=False)

1295

default=False)

1296

_locked = Column(

1296

_locked = Column(

1297

"locked", String(255), nullable=True, unique=False, default=None)

1297

"locked", String(255), nullable=True, unique=False, default=None)

1298

_changeset_cache = Column(

1298

_changeset_cache = Column(

1299

"changeset_cache", LargeBinary(), nullable=True) # JSON data

1299

"changeset_cache", LargeBinary(), nullable=True) # JSON data

1300

1301

fork_id = Column(

1301

fork_id = Column(

1302

"fork_id", Integer(), ForeignKey('repositories.repo_id'),

1302

"fork_id", Integer(), ForeignKey('repositories.repo_id'),

1303

nullable=True, unique=False, default=None)

1303

nullable=True, unique=False, default=None)

1304

group_id = Column(

1304

group_id = Column(

1305

"group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,

1305

"group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,

1306

unique=False, default=None)

1306

unique=False, default=None)

1307

1308

user = relationship('User', lazy='joined')

1308

user = relationship('User', lazy='joined')

1309

fork = relationship('Repository', remote_side=repo_id, lazy='joined')

1309

fork = relationship('Repository', remote_side=repo_id, lazy='joined')

1310

group = relationship('RepoGroup', lazy='joined')

1310

group = relationship('RepoGroup', lazy='joined')

1311

repo_to_perm = relationship(

1311

repo_to_perm = relationship(

1312

'UserRepoToPerm', cascade='all',

1312

'UserRepoToPerm', cascade='all',

1313

order_by='UserRepoToPerm.repo_to_perm_id')

1313

order_by='UserRepoToPerm.repo_to_perm_id')

1314

users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

1314

users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

1315

stats = relationship('Statistics', cascade='all', uselist=False)

1315

stats = relationship('Statistics', cascade='all', uselist=False)

1316

1317

followers = relationship(

1317

followers = relationship(

1318

'UserFollowing',

1318

'UserFollowing',

1319

primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',

1319

primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',

1320

cascade='all')

1320

cascade='all')

1321

extra_fields = relationship(

1321

extra_fields = relationship(

1322

'RepositoryField', cascade="all, delete, delete-orphan")

1322

'RepositoryField', cascade="all, delete, delete-orphan")

1323

logs = relationship('UserLog')

1323

logs = relationship('UserLog')

1324

comments = relationship(

1324

comments = relationship(

1325

'ChangesetComment', cascade="all, delete, delete-orphan")

1325

'ChangesetComment', cascade="all, delete, delete-orphan")

1326

pull_requests_source = relationship(

1326

pull_requests_source = relationship(

1327

'PullRequest',

1327

'PullRequest',

1328

primaryjoin='PullRequest.source_repo_id==Repository.repo_id',

1328

primaryjoin='PullRequest.source_repo_id==Repository.repo_id',

1329

cascade="all, delete, delete-orphan")

1329

cascade="all, delete, delete-orphan")

1330

pull_requests_target = relationship(

1330

pull_requests_target = relationship(

1331

'PullRequest',

1331

'PullRequest',

1332

primaryjoin='PullRequest.target_repo_id==Repository.repo_id',

1332

primaryjoin='PullRequest.target_repo_id==Repository.repo_id',

1333

cascade="all, delete, delete-orphan")

1333

cascade="all, delete, delete-orphan")

1334

ui = relationship('RepoRhodeCodeUi', cascade="all")

1334

ui = relationship('RepoRhodeCodeUi', cascade="all")

1335

settings = relationship('RepoRhodeCodeSetting', cascade="all")

1335

settings = relationship('RepoRhodeCodeSetting', cascade="all")

1336

integrations = relationship('Integration',

1336

integrations = relationship('Integration',

1337

cascade="all, delete, delete-orphan")

1337

cascade="all, delete, delete-orphan")

1338

1339

def __unicode__(self):

1339

def __unicode__(self):

1340

return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,

1340

return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,

1341

safe_unicode(self.repo_name))

1341

safe_unicode(self.repo_name))

1342

1343

@hybrid_property

1343

@hybrid_property

1344

def landing_rev(self):

1344

def landing_rev(self):

1345

# always should return [rev_type, rev]

1345

# always should return [rev_type, rev]

1346

if self._landing_revision:

1346

if self._landing_revision:

1347

_rev_info = self._landing_revision.split(':')

1347

_rev_info = self._landing_revision.split(':')

1348

if len(_rev_info) < 2:

1348

if len(_rev_info) < 2:

1349

_rev_info.insert(0, 'rev')

1349

_rev_info.insert(0, 'rev')

1350

return [_rev_info[0], _rev_info[1]]

1350

return [_rev_info[0], _rev_info[1]]

1351

return [None, None]

1351

return [None, None]

1352

1353

@landing_rev.setter

1353

@landing_rev.setter

1354

def landing_rev(self, val):

1354

def landing_rev(self, val):

1355

if ':' not in val:

1355

if ':' not in val:

1356

raise ValueError('value must be delimited with `:` and consist '

1356

raise ValueError('value must be delimited with `:` and consist '

1357

'of <rev_type>:<rev>, got %s instead' % val)

1357

'of <rev_type>:<rev>, got %s instead' % val)

1358

self._landing_revision = val

1358

self._landing_revision = val

1359

1360

@hybrid_property

1360

@hybrid_property

1361

def locked(self):

1361

def locked(self):

1362

if self._locked:

1362

if self._locked:

1363

user_id, timelocked, reason = self._locked.split(':')

1363

user_id, timelocked, reason = self._locked.split(':')

1364

lock_values = int(user_id), timelocked, reason

1364

lock_values = int(user_id), timelocked, reason

1365

else:

1365

else:

1366

lock_values = [None, None, None]

1366

lock_values = [None, None, None]

1367

return lock_values

1367

return lock_values

1368

1369

@locked.setter

1369

@locked.setter

1370

def locked(self, val):

1370

def locked(self, val):

1371

if val and isinstance(val, (list, tuple)):

1371

if val and isinstance(val, (list, tuple)):

1372

self._locked = ':'.join(map(str, val))

1372

self._locked = ':'.join(map(str, val))

1373

else:

1373

else:

1374

self._locked = None

1374

self._locked = None

1375

1376

@hybrid_property

1376

@hybrid_property

1377

def changeset_cache(self):

1377

def changeset_cache(self):

1378

from rhodecode.lib.vcs.backends.base import EmptyCommit

1378

from rhodecode.lib.vcs.backends.base import EmptyCommit

1379

dummy = EmptyCommit().__json__()

1379

dummy = EmptyCommit().__json__()

1380

if not self._changeset_cache:

1380

if not self._changeset_cache:

1381

return dummy

1381

return dummy

1382

try:

1382

try:

1383

return json.loads(self._changeset_cache)

1383

return json.loads(self._changeset_cache)

1384

except TypeError:

1384

except TypeError:

1385

return dummy

1385

return dummy

1386

except Exception:

1386

except Exception:

1387

log.error(traceback.format_exc())

1387

log.error(traceback.format_exc())

1388

return dummy

1388

return dummy

1389

1390

@changeset_cache.setter

1390

@changeset_cache.setter

1391

def changeset_cache(self, val):

1391

def changeset_cache(self, val):

1392

try:

1392

try:

1393

self._changeset_cache = json.dumps(val)

1393

self._changeset_cache = json.dumps(val)

1394

except Exception:

1394

except Exception:

1395

log.error(traceback.format_exc())

1395

log.error(traceback.format_exc())

1396

1397

@hybrid_property

1397

@hybrid_property

1398

def repo_name(self):

1398

def repo_name(self):

1399

return self._repo_name

1399

return self._repo_name

1400

1401

@repo_name.setter

1401

@repo_name.setter

1402

def repo_name(self, value):

1402

def repo_name(self, value):

1403

self._repo_name = value

1403

self._repo_name = value

1404

self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()

1404

self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()

1405

1406

@classmethod

1406

@classmethod

1407

def normalize_repo_name(cls, repo_name):

1407

def normalize_repo_name(cls, repo_name):

1408

"""

1408

"""

1409

Normalizes os specific repo_name to the format internally stored inside

1409

Normalizes os specific repo_name to the format internally stored inside

1410

database using URL_SEP

1410

database using URL_SEP

1411

1412

:param cls:

1412

:param cls:

1413

:param repo_name:

1413

:param repo_name:

1414

"""

1414

"""

1415

return cls.NAME_SEP.join(repo_name.split(os.sep))

1415

return cls.NAME_SEP.join(repo_name.split(os.sep))

1416

1417

@classmethod

1417

@classmethod

1418

def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):

1418

def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):

1419

session = Session()

1419

session = Session()

1420

q = session.query(cls).filter(cls.repo_name == repo_name)

1420

q = session.query(cls).filter(cls.repo_name == repo_name)

1421

1422

if cache:

1422

if cache:

1423

if identity_cache:

1423

if identity_cache:

1424

val = cls.identity_cache(session, 'repo_name', repo_name)

1424

val = cls.identity_cache(session, 'repo_name', repo_name)

1425

if val:

1425

if val:

1426

return val

1426

return val

1427

else:

1427

else:

1428

q = q.options(

1428

q = q.options(

1429

FromCache("sql_cache_short",

1429

FromCache("sql_cache_short",

1430

"get_repo_by_name_%s" % _hash_key(repo_name)))

1430

"get_repo_by_name_%s" % _hash_key(repo_name)))

1431

1432

return q.scalar()

1432

return q.scalar()

1433

1434

@classmethod

1434

@classmethod

1435

def get_by_full_path(cls, repo_full_path):

1435

def get_by_full_path(cls, repo_full_path):

1436

repo_name = repo_full_path.split(cls.base_path(), 1)[-1]

1436

repo_name = repo_full_path.split(cls.base_path(), 1)[-1]

1437

repo_name = cls.normalize_repo_name(repo_name)

1437

repo_name = cls.normalize_repo_name(repo_name)

1438

return cls.get_by_repo_name(repo_name.strip(URL_SEP))

1438

return cls.get_by_repo_name(repo_name.strip(URL_SEP))

1439

1440

@classmethod

1440

@classmethod

1441

def get_repo_forks(cls, repo_id):

1441

def get_repo_forks(cls, repo_id):

1442

return cls.query().filter(Repository.fork_id == repo_id)

1442

return cls.query().filter(Repository.fork_id == repo_id)

1443

1444

@classmethod

1444

@classmethod

1445

def base_path(cls):

1445

def base_path(cls):

1446

"""

1446

"""

1447

Returns base path when all repos are stored

1447

Returns base path when all repos are stored

1448

1449

:param cls:

1449

:param cls:

1450

"""

1450

"""

1451

q = Session().query(RhodeCodeUi)\

1451

q = Session().query(RhodeCodeUi)\

1452

.filter(RhodeCodeUi.ui_key == cls.NAME_SEP)

1452

.filter(RhodeCodeUi.ui_key == cls.NAME_SEP)

1453

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

1453

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

1454

return q.one().ui_value

1454

return q.one().ui_value

1455

1456

@classmethod

1456

@classmethod

1457

def is_valid(cls, repo_name):

1457

def is_valid(cls, repo_name):

1458

"""

1458

"""

1459

returns True if given repo name is a valid filesystem repository

1459

returns True if given repo name is a valid filesystem repository

1460

1461

:param cls:

1461

:param cls:

1462

:param repo_name:

1462

:param repo_name:

1463

"""

1463

"""

1464

from rhodecode.lib.utils import is_valid_repo

1464

from rhodecode.lib.utils import is_valid_repo

1465

1466

return is_valid_repo(repo_name, cls.base_path())

1466

return is_valid_repo(repo_name, cls.base_path())

1467

1468

@classmethod

1468

@classmethod

1469

def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),

1469

def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),

1470

case_insensitive=True):

1470

case_insensitive=True):

1471

q = Repository.query()

1471

q = Repository.query()

1472

1473

if not isinstance(user_id, Optional):

1473

if not isinstance(user_id, Optional):

1474

q = q.filter(Repository.user_id == user_id)

1474

q = q.filter(Repository.user_id == user_id)

1475

1476

if not isinstance(group_id, Optional):

1476

if not isinstance(group_id, Optional):

1477

q = q.filter(Repository.group_id == group_id)

1477

q = q.filter(Repository.group_id == group_id)

1478

1479

if case_insensitive:

1479

if case_insensitive:

1480

q = q.order_by(func.lower(Repository.repo_name))

1480

q = q.order_by(func.lower(Repository.repo_name))

1481

else:

1481

else:

1482

q = q.order_by(Repository.repo_name)

1482

q = q.order_by(Repository.repo_name)

1483

return q.all()

1483

return q.all()

1484

1485

@property

1485

@property

1486

def forks(self):

1486

def forks(self):

1487

"""

1487

"""

1488

Return forks of this repo

1488

Return forks of this repo

1489

"""

1489

"""

1490

return Repository.get_repo_forks(self.repo_id)

1490

return Repository.get_repo_forks(self.repo_id)

1491

1492

@property

1492

@property

1493

def parent(self):

1493

def parent(self):

1494

"""

1494

"""

1495

Returns fork parent

1495

Returns fork parent

1496

"""

1496

"""

1497

return self.fork

1497

return self.fork

1498

1499

@property

1499

@property

1500

def just_name(self):

1500

def just_name(self):

1501

return self.repo_name.split(self.NAME_SEP)[-1]

1501

return self.repo_name.split(self.NAME_SEP)[-1]

1502

1503

@property

1503

@property

1504

def groups_with_parents(self):

1504

def groups_with_parents(self):

1505

groups = []

1505

groups = []

1506

if self.group is None:

1506

if self.group is None:

1507

return groups

1507

return groups

1508

1509

cur_gr = self.group

1509

cur_gr = self.group

1510

groups.insert(0, cur_gr)

1510

groups.insert(0, cur_gr)

1511

while 1:

1511

while 1:

1512

gr = getattr(cur_gr, 'parent_group', None)

1512

gr = getattr(cur_gr, 'parent_group', None)

1513

cur_gr = cur_gr.parent_group

1513

cur_gr = cur_gr.parent_group

1514

if gr is None:

1514

if gr is None:

1515

break

1515

break

1516

groups.insert(0, gr)

1516

groups.insert(0, gr)

1517

1518

return groups

1518

return groups

1519

1520

@property

1520

@property

1521

def groups_and_repo(self):

1521

def groups_and_repo(self):

1522

return self.groups_with_parents, self

1522

return self.groups_with_parents, self

1523

1524

@LazyProperty

1524

@LazyProperty

1525

def repo_path(self):

1525

def repo_path(self):

1526

"""

1526

"""

1527

Returns base full path for that repository means where it actually

1527

Returns base full path for that repository means where it actually

1528

exists on a filesystem

1528

exists on a filesystem

1529

"""

1529

"""

1530

q = Session().query(RhodeCodeUi).filter(

1530

q = Session().query(RhodeCodeUi).filter(

1531

RhodeCodeUi.ui_key == self.NAME_SEP)

1531

RhodeCodeUi.ui_key == self.NAME_SEP)

1532

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

1532

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

1533

return q.one().ui_value

1533

return q.one().ui_value

1534

1535

@property

1535

@property

1536

def repo_full_path(self):

1536

def repo_full_path(self):

1537

p = [self.repo_path]

1537

p = [self.repo_path]

1538

# we need to split the name by / since this is how we store the

1538

# we need to split the name by / since this is how we store the

1539

# names in the database, but that eventually needs to be converted

1539

# names in the database, but that eventually needs to be converted

1540

# into a valid system path

1540

# into a valid system path

1541

p += self.repo_name.split(self.NAME_SEP)

1541

p += self.repo_name.split(self.NAME_SEP)

1542

return os.path.join(*map(safe_unicode, p))

1542

return os.path.join(*map(safe_unicode, p))

1543

1544

@property

1544

@property

1545

def cache_keys(self):

1545

def cache_keys(self):

1546

"""

1546

"""

1547

Returns associated cache keys for that repo

1547

Returns associated cache keys for that repo

1548

"""

1548

"""

1549

return CacheKey.query()\

1549

return CacheKey.query()\

1550

.filter(CacheKey.cache_args == self.repo_name)\

1550

.filter(CacheKey.cache_args == self.repo_name)\

1551

.order_by(CacheKey.cache_key)\

1551

.order_by(CacheKey.cache_key)\

1552

.all()

1552

.all()

1553

1554

def get_new_name(self, repo_name):

1554

def get_new_name(self, repo_name):

1555

"""

1555

"""

1556

returns new full repository name based on assigned group and new new

1556

returns new full repository name based on assigned group and new new

1557

1558

:param group_name:

1558

:param group_name:

1559

"""

1559

"""

1560

path_prefix = self.group.full_path_splitted if self.group else []

1560

path_prefix = self.group.full_path_splitted if self.group else []

1561

return self.NAME_SEP.join(path_prefix + [repo_name])

1561

return self.NAME_SEP.join(path_prefix + [repo_name])

1562

1563

@property

1563

@property

1564

def _config(self):

1564

def _config(self):

1565

"""

1565

"""

1566

Returns db based config object.

1566

Returns db based config object.

1567

"""

1567

"""

1568

from rhodecode.lib.utils import make_db_config

1568

from rhodecode.lib.utils import make_db_config

1569

return make_db_config(clear_session=False, repo=self)

1569

return make_db_config(clear_session=False, repo=self)

1570

1571

def permissions(self, with_admins=True, with_owner=True):

1571

def permissions(self, with_admins=True, with_owner=True):

1572

q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)

1572

q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)

1573

q = q.options(joinedload(UserRepoToPerm.repository),

1573

q = q.options(joinedload(UserRepoToPerm.repository),

1574

joinedload(UserRepoToPerm.user),

1574

joinedload(UserRepoToPerm.user),

1575

joinedload(UserRepoToPerm.permission),)

1575

joinedload(UserRepoToPerm.permission),)

1576

1577

# get owners and admins and permissions. We do a trick of re-writing

1577

# get owners and admins and permissions. We do a trick of re-writing

1578

# objects from sqlalchemy to named-tuples due to sqlalchemy session

1578

# objects from sqlalchemy to named-tuples due to sqlalchemy session

1579

# has a global reference and changing one object propagates to all

1579

# has a global reference and changing one object propagates to all

1580

# others. This means if admin is also an owner admin_row that change

1580

# others. This means if admin is also an owner admin_row that change

1581

# would propagate to both objects

1581

# would propagate to both objects

1582

perm_rows = []

1582

perm_rows = []

1583

for _usr in q.all():

1583

for _usr in q.all():

1584

usr = AttributeDict(_usr.user.get_dict())

1584

usr = AttributeDict(_usr.user.get_dict())

1585

usr.permission = _usr.permission.permission_name

1585

usr.permission = _usr.permission.permission_name

1586

perm_rows.append(usr)

1586

perm_rows.append(usr)

1587

1588

# filter the perm rows by 'default' first and then sort them by

1588

# filter the perm rows by 'default' first and then sort them by

1589

# admin,write,read,none permissions sorted again alphabetically in

1589

# admin,write,read,none permissions sorted again alphabetically in

1590

# each group

1590

# each group

1591

perm_rows = sorted(perm_rows, key=display_sort)

1591

perm_rows = sorted(perm_rows, key=display_sort)

1592

1593

_admin_perm = 'repository.admin'

1593

_admin_perm = 'repository.admin'

1594

owner_row = []

1594

owner_row = []

1595

if with_owner:

1595

if with_owner:

1596

usr = AttributeDict(self.user.get_dict())

1596

usr = AttributeDict(self.user.get_dict())

1597

usr.owner_row = True

1597

usr.owner_row = True

1598

usr.permission = _admin_perm

1598

usr.permission = _admin_perm

1599

owner_row.append(usr)

1599

owner_row.append(usr)

1600

1601

super_admin_rows = []

1601

super_admin_rows = []

1602

if with_admins:

1602

if with_admins:

1603

for usr in User.get_all_super_admins():

1603

for usr in User.get_all_super_admins():

1604

# if this admin is also owner, don't double the record

1604

# if this admin is also owner, don't double the record

1605

if usr.user_id == owner_row[0].user_id:

1605

if usr.user_id == owner_row[0].user_id:

1606

owner_row[0].admin_row = True

1606

owner_row[0].admin_row = True

1607

else:

1607

else:

1608

usr = AttributeDict(usr.get_dict())

1608

usr = AttributeDict(usr.get_dict())

1609

usr.admin_row = True

1609

usr.admin_row = True

1610

usr.permission = _admin_perm

1610

usr.permission = _admin_perm

1611

super_admin_rows.append(usr)

1611

super_admin_rows.append(usr)

1612

1613

return super_admin_rows + owner_row + perm_rows

1613

return super_admin_rows + owner_row + perm_rows

1614

1615

def permission_user_groups(self):

1615

def permission_user_groups(self):

1616

q = UserGroupRepoToPerm.query().filter(

1616

q = UserGroupRepoToPerm.query().filter(

1617

UserGroupRepoToPerm.repository == self)

1617

UserGroupRepoToPerm.repository == self)

1618

q = q.options(joinedload(UserGroupRepoToPerm.repository),

1618

q = q.options(joinedload(UserGroupRepoToPerm.repository),

1619

joinedload(UserGroupRepoToPerm.users_group),

1619

joinedload(UserGroupRepoToPerm.users_group),

1620

joinedload(UserGroupRepoToPerm.permission),)

1620

joinedload(UserGroupRepoToPerm.permission),)

1621

1622

perm_rows = []

1622

perm_rows = []

1623

for _user_group in q.all():

1623

for _user_group in q.all():

1624

usr = AttributeDict(_user_group.users_group.get_dict())

1624

usr = AttributeDict(_user_group.users_group.get_dict())

1625

usr.permission = _user_group.permission.permission_name

1625

usr.permission = _user_group.permission.permission_name

1626

perm_rows.append(usr)

1626

perm_rows.append(usr)

1627

1628

return perm_rows

1628

return perm_rows

1629

1630

def get_api_data(self, include_secrets=False):

1630

def get_api_data(self, include_secrets=False):

1631

"""

1631

"""

1632

Common function for generating repo api data

1632

Common function for generating repo api data

1633

1634

:param include_secrets: See :meth:`User.get_api_data`.

1634

:param include_secrets: See :meth:`User.get_api_data`.

1635

1636

"""

1636

"""

1637

# TODO: mikhail: Here there is an anti-pattern, we probably need to

1637

# TODO: mikhail: Here there is an anti-pattern, we probably need to

1638

# move this methods on models level.

1638

# move this methods on models level.

1639

from rhodecode.model.settings import SettingsModel

1639

from rhodecode.model.settings import SettingsModel

1640

1641

repo = self

1641

repo = self

1642

_user_id, _time, _reason = self.locked

1642

_user_id, _time, _reason = self.locked

1643

1644

data = {

1644

data = {

1645

'repo_id': repo.repo_id,

1645

'repo_id': repo.repo_id,

1646

'repo_name': repo.repo_name,

1646

'repo_name': repo.repo_name,

1647

'repo_type': repo.repo_type,

1647

'repo_type': repo.repo_type,

1648

'clone_uri': repo.clone_uri or '',

1648

'clone_uri': repo.clone_uri or '',

1649

'url': url('summary_home', repo_name=self.repo_name, qualified=True),

1649

'url': url('summary_home', repo_name=self.repo_name, qualified=True),

1650

'private': repo.private,

1650

'private': repo.private,

1651

'created_on': repo.created_on,

1651

'created_on': repo.created_on,

1652

'description': repo.description,

1652

'description': repo.description,

1653

'landing_rev': repo.landing_rev,

1653

'landing_rev': repo.landing_rev,

1654

'owner': repo.user.username,

1654

'owner': repo.user.username,

1655

'fork_of': repo.fork.repo_name if repo.fork else None,

1655

'fork_of': repo.fork.repo_name if repo.fork else None,

1656

'enable_statistics': repo.enable_statistics,

1656

'enable_statistics': repo.enable_statistics,

1657

'enable_locking': repo.enable_locking,

1657

'enable_locking': repo.enable_locking,

1658

'enable_downloads': repo.enable_downloads,

1658

'enable_downloads': repo.enable_downloads,

1659

'last_changeset': repo.changeset_cache,

1659

'last_changeset': repo.changeset_cache,

1660

'locked_by': User.get(_user_id).get_api_data(

1660

'locked_by': User.get(_user_id).get_api_data(

1661

include_secrets=include_secrets) if _user_id else None,

1661

include_secrets=include_secrets) if _user_id else None,

1662

'locked_date': time_to_datetime(_time) if _time else None,

1662

'locked_date': time_to_datetime(_time) if _time else None,

1663

'lock_reason': _reason if _reason else None,

1663

'lock_reason': _reason if _reason else None,

1664

}

1664

}

1665

1666

# TODO: mikhail: should be per-repo settings here

1666

# TODO: mikhail: should be per-repo settings here

1667

rc_config = SettingsModel().get_all_settings()

1667

rc_config = SettingsModel().get_all_settings()

1668

repository_fields = str2bool(

1668

repository_fields = str2bool(

1669

rc_config.get('rhodecode_repository_fields'))

1669

rc_config.get('rhodecode_repository_fields'))

1670

if repository_fields:

1670

if repository_fields:

1671

for f in self.extra_fields:

1671

for f in self.extra_fields:

1672

data[f.field_key_prefixed] = f.field_value

1672

data[f.field_key_prefixed] = f.field_value

1673

1674

return data

1674

return data

1675

1676

@classmethod

1676

@classmethod

1677

def lock(cls, repo, user_id, lock_time=None, lock_reason=None):

1677

def lock(cls, repo, user_id, lock_time=None, lock_reason=None):

1678

if not lock_time:

1678

if not lock_time:

1679

lock_time = time.time()

1679

lock_time = time.time()

1680

if not lock_reason:

1680

if not lock_reason:

1681

lock_reason = cls.LOCK_AUTOMATIC

1681

lock_reason = cls.LOCK_AUTOMATIC

1682

repo.locked = [user_id, lock_time, lock_reason]

1682

repo.locked = [user_id, lock_time, lock_reason]

1683

Session().add(repo)

1683

Session().add(repo)

1684

Session().commit()

1684

Session().commit()

1685

1686

@classmethod

1686

@classmethod

1687

def unlock(cls, repo):

1687

def unlock(cls, repo):

1688

repo.locked = None

1688

repo.locked = None

1689

Session().add(repo)

1689

Session().add(repo)

1690

Session().commit()

1690

Session().commit()

1691

1692

@classmethod

1692

@classmethod

1693

def getlock(cls, repo):

1693

def getlock(cls, repo):

1694

return repo.locked

1694

return repo.locked

1695

1696

def is_user_lock(self, user_id):

1696

def is_user_lock(self, user_id):

1697

if self.lock[0]:

1697

if self.lock[0]:

1698

lock_user_id = safe_int(self.lock[0])

1698

lock_user_id = safe_int(self.lock[0])

1699

user_id = safe_int(user_id)

1699

user_id = safe_int(user_id)

1700

# both are ints, and they are equal

1700

# both are ints, and they are equal

1701

return all([lock_user_id, user_id]) and lock_user_id == user_id

1701

return all([lock_user_id, user_id]) and lock_user_id == user_id

1702

1703

return False

1703

return False

1704

1705

def get_locking_state(self, action, user_id, only_when_enabled=True):

1705

def get_locking_state(self, action, user_id, only_when_enabled=True):

1706

"""

1706

"""

1707

Checks locking on this repository, if locking is enabled and lock is

1707

Checks locking on this repository, if locking is enabled and lock is

1708

present returns a tuple of make_lock, locked, locked_by.

1708

present returns a tuple of make_lock, locked, locked_by.

1709

make_lock can have 3 states None (do nothing) True, make lock

1709

make_lock can have 3 states None (do nothing) True, make lock

1710

False release lock, This value is later propagated to hooks, which

1710

False release lock, This value is later propagated to hooks, which

1711

do the locking. Think about this as signals passed to hooks what to do.

1711

do the locking. Think about this as signals passed to hooks what to do.

1712

1713

"""

1713

"""

1714

# TODO: johbo: This is part of the business logic and should be moved

1714

# TODO: johbo: This is part of the business logic and should be moved

1715

# into the RepositoryModel.

1715

# into the RepositoryModel.

1716

1717

if action not in ('push', 'pull'):

1717

if action not in ('push', 'pull'):

1718

raise ValueError("Invalid action value: %s" % repr(action))

1718

raise ValueError("Invalid action value: %s" % repr(action))

1719

1720

# defines if locked error should be thrown to user

1720

# defines if locked error should be thrown to user

1721

currently_locked = False

1721

currently_locked = False

1722

# defines if new lock should be made, tri-state

1722

# defines if new lock should be made, tri-state

1723

make_lock = None

1723

make_lock = None

1724

repo = self

1724

repo = self

1725

user = User.get(user_id)

1725

user = User.get(user_id)

1726

1727

lock_info = repo.locked

1727

lock_info = repo.locked

1728

1729

if repo and (repo.enable_locking or not only_when_enabled):

1729

if repo and (repo.enable_locking or not only_when_enabled):

1730

if action == 'push':

1730

if action == 'push':

1731

# check if it's already locked !, if it is compare users

1731

# check if it's already locked !, if it is compare users

1732

locked_by_user_id = lock_info[0]

1732

locked_by_user_id = lock_info[0]

1733

if user.user_id == locked_by_user_id:

1733

if user.user_id == locked_by_user_id:

1734

log.debug(

1734

log.debug(

1735

'Got `push` action from user %s, now unlocking', user)

1735

'Got `push` action from user %s, now unlocking', user)

1736

# unlock if we have push from user who locked

1736

# unlock if we have push from user who locked

1737

make_lock = False

1737

make_lock = False

1738

else:

1738

else:

1739

# we're not the same user who locked, ban with

1739

# we're not the same user who locked, ban with

1740

# code defined in settings (default is 423 HTTP Locked) !

1740

# code defined in settings (default is 423 HTTP Locked) !

1741

log.debug('Repo %s is currently locked by %s', repo, user)

1741

log.debug('Repo %s is currently locked by %s', repo, user)

1742

currently_locked = True

1742

currently_locked = True

1743

elif action == 'pull':

1743

elif action == 'pull':

1744

# [0] user [1] date

1744

# [0] user [1] date

1745

if lock_info[0] and lock_info[1]:

1745

if lock_info[0] and lock_info[1]:

1746

log.debug('Repo %s is currently locked by %s', repo, user)

1746

log.debug('Repo %s is currently locked by %s', repo, user)

1747

currently_locked = True

1747

currently_locked = True

1748

else:

1748

else:

1749

log.debug('Setting lock on repo %s by %s', repo, user)

1749

log.debug('Setting lock on repo %s by %s', repo, user)

1750

make_lock = True

1750

make_lock = True

1751

1752

else:

1752

else:

1753

log.debug('Repository %s do not have locking enabled', repo)

1753

log.debug('Repository %s do not have locking enabled', repo)

1754

1755

log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',

1755

log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',

1756

make_lock, currently_locked, lock_info)

1756

make_lock, currently_locked, lock_info)

1757

1758

from rhodecode.lib.auth import HasRepoPermissionAny

1758

from rhodecode.lib.auth import HasRepoPermissionAny

1759

perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')

1759

perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')

1760

if make_lock and not perm_check(repo_name=repo.repo_name, user=user):

1760

if make_lock and not perm_check(repo_name=repo.repo_name, user=user):

1761

# if we don't have at least write permission we cannot make a lock

1761

# if we don't have at least write permission we cannot make a lock

1762

log.debug('lock state reset back to FALSE due to lack '

1762

log.debug('lock state reset back to FALSE due to lack '

1763

'of at least read permission')

1763

'of at least read permission')

1764

make_lock = False

1764

make_lock = False

1765

1766

return make_lock, currently_locked, lock_info

1766

return make_lock, currently_locked, lock_info

1767

1768

@property

1768

@property

1769

def last_db_change(self):

1769

def last_db_change(self):

1770

return self.updated_on

1770

return self.updated_on

1771

1772

@property

1772

@property

1773

def clone_uri_hidden(self):

1773

def clone_uri_hidden(self):

1774

clone_uri = self.clone_uri

1774

clone_uri = self.clone_uri

1775

if clone_uri:

1775

if clone_uri:

1776

import urlobject

1776

import urlobject

1777

url_obj = urlobject.URLObject(clone_uri)

1777

url_obj = urlobject.URLObject(clone_uri)

1778

if url_obj.password:

1778

if url_obj.password:

1779

clone_uri = url_obj.with_password('*****')

1779

clone_uri = url_obj.with_password('*****')

1780

return clone_uri

1780

return clone_uri

1781

1782

def clone_url(self, **override):

1782

def clone_url(self, **override):

1783

qualified_home_url = url('home', qualified=True)

1783

qualified_home_url = url('home', qualified=True)

1784

1785

uri_tmpl = None

1785

uri_tmpl = None

1786

if 'with_id' in override:

1786

if 'with_id' in override:

1787

uri_tmpl = self.DEFAULT_CLONE_URI_ID

1787

uri_tmpl = self.DEFAULT_CLONE_URI_ID

1788

del override['with_id']

1788

del override['with_id']

1789

1790

if 'uri_tmpl' in override:

1790

if 'uri_tmpl' in override:

1791

uri_tmpl = override['uri_tmpl']

1791

uri_tmpl = override['uri_tmpl']

1792

del override['uri_tmpl']

1792

del override['uri_tmpl']

1793

1794

# we didn't override our tmpl from **overrides

1794

# we didn't override our tmpl from **overrides

1795

if not uri_tmpl:

1795

if not uri_tmpl:

1796

uri_tmpl = self.DEFAULT_CLONE_URI

1796

uri_tmpl = self.DEFAULT_CLONE_URI

1797

try:

1797

try:

1798

from pylons import tmpl_context as c

1798

from pylons import tmpl_context as c

1799

uri_tmpl = c.clone_uri_tmpl

1799

uri_tmpl = c.clone_uri_tmpl

1800

except Exception:

1800

except Exception:

1801

# in any case if we call this outside of request context,

1801

# in any case if we call this outside of request context,

1802

# ie, not having tmpl_context set up

1802

# ie, not having tmpl_context set up

1803

pass

1803

pass

1804

1805

return get_clone_url(uri_tmpl=uri_tmpl,

1805

return get_clone_url(uri_tmpl=uri_tmpl,

1806

qualifed_home_url=qualified_home_url,

1806

qualifed_home_url=qualified_home_url,

1807

repo_name=self.repo_name,

1807

repo_name=self.repo_name,

1808

repo_id=self.repo_id, **override)

1808

repo_id=self.repo_id, **override)

1809

1810

def set_state(self, state):

1810

def set_state(self, state):

1811

self.repo_state = state

1811

self.repo_state = state

1812

Session().add(self)

1812

Session().add(self)

1813

#==========================================================================

1813

#==========================================================================

1814

# SCM PROPERTIES

1814

# SCM PROPERTIES

1815

#==========================================================================

1815

#==========================================================================

1816

1817

def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):

1817

def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):

1818

return get_commit_safe(

1818

return get_commit_safe(

1819

self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)

1819

self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)

1820

1821

def get_changeset(self, rev=None, pre_load=None):

1821

def get_changeset(self, rev=None, pre_load=None):

1822

warnings.warn("Use get_commit", DeprecationWarning)

1822

warnings.warn("Use get_commit", DeprecationWarning)

1823

commit_id = None

1823

commit_id = None

1824

commit_idx = None

1824

commit_idx = None

1825

if isinstance(rev, basestring):

1825

if isinstance(rev, basestring):

1826

commit_id = rev

1826

commit_id = rev

1827

else:

1827

else:

1828

commit_idx = rev

1828

commit_idx = rev

1829

return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,

1829

return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,

1830

pre_load=pre_load)

1830

pre_load=pre_load)

1831

1832

def get_landing_commit(self):

1832

def get_landing_commit(self):

1833

"""

1833

"""

1834

Returns landing commit, or if that doesn't exist returns the tip

1834

Returns landing commit, or if that doesn't exist returns the tip

1835

"""

1835

"""

1836

_rev_type, _rev = self.landing_rev

1836

_rev_type, _rev = self.landing_rev

1837

commit = self.get_commit(_rev)

1837

commit = self.get_commit(_rev)

1838

if isinstance(commit, EmptyCommit):

1838

if isinstance(commit, EmptyCommit):

1839

return self.get_commit()

1839

return self.get_commit()

1840

return commit

1840

return commit

1841

1842

def update_commit_cache(self, cs_cache=None, config=None):

1842

def update_commit_cache(self, cs_cache=None, config=None):

1843

"""

1843

"""

1844

Update cache of last changeset for repository, keys should be::

1844

Update cache of last changeset for repository, keys should be::

1845

1846

short_id

1846

short_id

1847

raw_id

1847

raw_id

1848

revision

1848

revision

1849

parents

1849

parents

1850

message

1850

message

1851

date

1851

date

1852

author

1852

author

1853

1854

:param cs_cache:

1854

:param cs_cache:

1855

"""

1855

"""

1856

from rhodecode.lib.vcs.backends.base import BaseChangeset

1856

from rhodecode.lib.vcs.backends.base import BaseChangeset

1857

if cs_cache is None:

1857

if cs_cache is None:

1858

# use no-cache version here

1858

# use no-cache version here

1859

scm_repo = self.scm_instance(cache=False, config=config)

1859

scm_repo = self.scm_instance(cache=False, config=config)

1860

if scm_repo:

1860

if scm_repo:

1861

cs_cache = scm_repo.get_commit(

1861

cs_cache = scm_repo.get_commit(

1862

pre_load=["author", "date", "message", "parents"])

1862

pre_load=["author", "date", "message", "parents"])

1863

else:

1863

else:

1864

cs_cache = EmptyCommit()

1864

cs_cache = EmptyCommit()

1865

1866

if isinstance(cs_cache, BaseChangeset):

1866

if isinstance(cs_cache, BaseChangeset):

1867

cs_cache = cs_cache.__json__()

1867

cs_cache = cs_cache.__json__()

1868

1869

def is_outdated(new_cs_cache):

1869

def is_outdated(new_cs_cache):

1870

if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or

1870

if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or

1871

new_cs_cache['revision'] != self.changeset_cache['revision']):

1871

new_cs_cache['revision'] != self.changeset_cache['revision']):

1872

return True

1872

return True

1873

return False

1873

return False

1874

1875

# check if we have maybe already latest cached revision

1875

# check if we have maybe already latest cached revision

1876

if is_outdated(cs_cache) or not self.changeset_cache:

1876

if is_outdated(cs_cache) or not self.changeset_cache:

1877

_default = datetime.datetime.fromtimestamp(0)

1877

_default = datetime.datetime.fromtimestamp(0)

1878

last_change = cs_cache.get('date') or _default

1878

last_change = cs_cache.get('date') or _default

1879

log.debug('updated repo %s with new cs cache %s',

1879

log.debug('updated repo %s with new cs cache %s',

1880

self.repo_name, cs_cache)

1880

self.repo_name, cs_cache)

1881

self.updated_on = last_change

1881

self.updated_on = last_change

1882

self.changeset_cache = cs_cache

1882

self.changeset_cache = cs_cache

1883

Session().add(self)

1883

Session().add(self)

1884

Session().commit()

1884

Session().commit()

1885

else:

1885

else:

1886

log.debug('Skipping update_commit_cache for repo:`%s` '

1886

log.debug('Skipping update_commit_cache for repo:`%s` '

1887

'commit already with latest changes', self.repo_name)

1887

'commit already with latest changes', self.repo_name)

1888

1889

@property

1889

@property

1890

def tip(self):

1890

def tip(self):

1891

return self.get_commit('tip')

1891

return self.get_commit('tip')

1892

1893

@property

1893

@property

1894

def author(self):

1894

def author(self):

1895

return self.tip.author

1895

return self.tip.author

1896

1897

@property

1897

@property

1898

def last_change(self):

1898

def last_change(self):

1899

return self.scm_instance().last_change

1899

return self.scm_instance().last_change

1900

1901

def get_comments(self, revisions=None):

1901

def get_comments(self, revisions=None):

1902

"""

1902

"""

1903

Returns comments for this repository grouped by revisions

1903

Returns comments for this repository grouped by revisions

1904

1905

:param revisions: filter query by revisions only

1905

:param revisions: filter query by revisions only

1906

"""

1906

"""

1907

cmts = ChangesetComment.query()\

1907

cmts = ChangesetComment.query()\

1908

.filter(ChangesetComment.repo == self)

1908

.filter(ChangesetComment.repo == self)

1909

if revisions:

1909

if revisions:

1910

cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

1910

cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

1911

grouped = collections.defaultdict(list)

1911

grouped = collections.defaultdict(list)

1912

for cmt in cmts.all():

1912

for cmt in cmts.all():

1913

grouped[cmt.revision].append(cmt)

1913

grouped[cmt.revision].append(cmt)

1914

return grouped

1914

return grouped

1915

1916

def statuses(self, revisions=None):

1916

def statuses(self, revisions=None):

1917

"""

1917

"""

1918

Returns statuses for this repository

1918

Returns statuses for this repository

1919

1920

:param revisions: list of revisions to get statuses for

1920

:param revisions: list of revisions to get statuses for

1921

"""

1921

"""

1922

statuses = ChangesetStatus.query()\

1922

statuses = ChangesetStatus.query()\

1923

.filter(ChangesetStatus.repo == self)\

1923

.filter(ChangesetStatus.repo == self)\

1924

.filter(ChangesetStatus.version == 0)

1924

.filter(ChangesetStatus.version == 0)

1925

1926

if revisions:

1926

if revisions:

1927

# Try doing the filtering in chunks to avoid hitting limits

1927

# Try doing the filtering in chunks to avoid hitting limits

1928

size = 500

1928

size = 500

1929

status_results = []

1929

status_results = []

1930

for chunk in xrange(0, len(revisions), size):

1930

for chunk in xrange(0, len(revisions), size):

1931

status_results += statuses.filter(

1931

status_results += statuses.filter(

1932

ChangesetStatus.revision.in_(

1932

ChangesetStatus.revision.in_(

1933

revisions[chunk: chunk+size])

1933

revisions[chunk: chunk+size])

1934

).all()

1934

).all()

1935

else:

1935

else:

1936

status_results = statuses.all()

1936

status_results = statuses.all()

1937

1938

grouped = {}

1938

grouped = {}

1939

1940

# maybe we have open new pullrequest without a status?

1940

# maybe we have open new pullrequest without a status?

1941

stat = ChangesetStatus.STATUS_UNDER_REVIEW

1941

stat = ChangesetStatus.STATUS_UNDER_REVIEW

1942

status_lbl = ChangesetStatus.get_status_lbl(stat)

1942

status_lbl = ChangesetStatus.get_status_lbl(stat)

1943

for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():

1943

for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():

1944

for rev in pr.revisions:

1944

for rev in pr.revisions:

1945

pr_id = pr.pull_request_id

1945

pr_id = pr.pull_request_id

1946

pr_repo = pr.target_repo.repo_name

1946

pr_repo = pr.target_repo.repo_name

1947

grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

1947

grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

1948

1949

for stat in status_results:

1949

for stat in status_results:

1950

pr_id = pr_repo = None

1950

pr_id = pr_repo = None

1951

if stat.pull_request:

1951

if stat.pull_request:

1952

pr_id = stat.pull_request.pull_request_id

1952

pr_id = stat.pull_request.pull_request_id

1953

pr_repo = stat.pull_request.target_repo.repo_name

1953

pr_repo = stat.pull_request.target_repo.repo_name

1954

grouped[stat.revision] = [str(stat.status), stat.status_lbl,

1954

grouped[stat.revision] = [str(stat.status), stat.status_lbl,

1955

pr_id, pr_repo]

1955

pr_id, pr_repo]

1956

return grouped

1956

return grouped

1957

1958

# ==========================================================================

1958

# ==========================================================================

1959

# SCM CACHE INSTANCE

1959

# SCM CACHE INSTANCE

1960

# ==========================================================================

1960

# ==========================================================================

1961

1962

def scm_instance(self, **kwargs):

1962

def scm_instance(self, **kwargs):

1963

import rhodecode

1963

import rhodecode

1964

1965

# Passing a config will not hit the cache currently only used

1965

# Passing a config will not hit the cache currently only used

1966

# for repo2dbmapper

1966

# for repo2dbmapper

1967

config = kwargs.pop('config', None)

1967

config = kwargs.pop('config', None)

1968

cache = kwargs.pop('cache', None)

1968

cache = kwargs.pop('cache', None)

1969

full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

1969

full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

1970

# if cache is NOT defined use default global, else we have a full

1970

# if cache is NOT defined use default global, else we have a full

1971

# control over cache behaviour

1971

# control over cache behaviour

1972

if cache is None and full_cache and not config:

1972

if cache is None and full_cache and not config:

1973

return self._get_instance_cached()

1973

return self._get_instance_cached()

1974

return self._get_instance(cache=bool(cache), config=config)

1974

return self._get_instance(cache=bool(cache), config=config)

1975

1976

def _get_instance_cached(self):

1976

def _get_instance_cached(self):

1977

@cache_region('long_term')

1977

@cache_region('long_term')

1978

def _get_repo(cache_key):

1978

def _get_repo(cache_key):

1979

return self._get_instance()

1979

return self._get_instance()

1980

1981

invalidator_context = CacheKey.repo_context_cache(

1981

invalidator_context = CacheKey.repo_context_cache(

1982

_get_repo, self.repo_name, None, thread_scoped=True)

1982

_get_repo, self.repo_name, None, thread_scoped=True)

1983

1984

with invalidator_context as context:

1984

with invalidator_context as context:

1985

context.invalidate()

1985

context.invalidate()

1986

repo = context.compute()

1986

repo = context.compute()

1987

1988

return repo

1988

return repo

1989

1990

def _get_instance(self, cache=True, config=None):

1990

def _get_instance(self, cache=True, config=None):

1991

config = config or self._config

1991

config = config or self._config

1992

custom_wire = {

1992

custom_wire = {

1993

'cache': cache # controls the vcs.remote cache

1993

'cache': cache # controls the vcs.remote cache

1994

}

1994

}

1995

1996

repo = get_vcs_instance(

1996

repo = get_vcs_instance(

1997

repo_path=safe_str(self.repo_full_path),

1997

repo_path=safe_str(self.repo_full_path),

1998

config=config,

1998

config=config,

1999

with_wire=custom_wire,

1999

with_wire=custom_wire,

2000

create=False)

2000

create=False)

2001

2002

return repo

2002

return repo

2003

2004

def __json__(self):

2004

def __json__(self):

2005

return {'landing_rev': self.landing_rev}

2005

return {'landing_rev': self.landing_rev}

2006

2007

def get_dict(self):

2007

def get_dict(self):

2008

2009

# Since we transformed `repo_name` to a hybrid property, we need to

2009

# Since we transformed `repo_name` to a hybrid property, we need to

2010

# keep compatibility with the code which uses `repo_name` field.

2010

# keep compatibility with the code which uses `repo_name` field.

2011

2012

result = super(Repository, self).get_dict()

2012

result = super(Repository, self).get_dict()

2013

result['repo_name'] = result.pop('_repo_name', None)

2013

result['repo_name'] = result.pop('_repo_name', None)

2014

return result

2014

return result

2015

2016

2017

class RepoGroup(Base, BaseModel):

2017

class RepoGroup(Base, BaseModel):

2018

__tablename__ = 'groups'

2018

__tablename__ = 'groups'

2019

__table_args__ = (

2019

__table_args__ = (

2020

UniqueConstraint('group_name', 'group_parent_id'),

2020

UniqueConstraint('group_name', 'group_parent_id'),

2021

CheckConstraint('group_id != group_parent_id'),

2021

CheckConstraint('group_id != group_parent_id'),

2022

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2022

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2023

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2023

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2024

)

2024

)

2025

__mapper_args__ = {'order_by': 'group_name'}

2025

__mapper_args__ = {'order_by': 'group_name'}

2026

2027

CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups

2027

CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups

2028

2029

group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2029

group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2030

group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)

2030

group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)

2031

group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

2031

group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

2032

group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)

2032

group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)

2033

enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)

2033

enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)

2034

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

2034

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

2035

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2035

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2036

2037

repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

2037

repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

2038

users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

2038

users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

2039

parent_group = relationship('RepoGroup', remote_side=group_id)

2039

parent_group = relationship('RepoGroup', remote_side=group_id)

2040

user = relationship('User')

2040

user = relationship('User')

2041

integrations = relationship('Integration',

2041

integrations = relationship('Integration',

2042

cascade="all, delete, delete-orphan")

2042

cascade="all, delete, delete-orphan")

2043

2044

def __init__(self, group_name='', parent_group=None):

2044

def __init__(self, group_name='', parent_group=None):

2045

self.group_name = group_name

2045

self.group_name = group_name

2046

self.parent_group = parent_group

2046

self.parent_group = parent_group

2047

2048

def __unicode__(self):

2048

def __unicode__(self):

2049

return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,

2049

return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,

2050

self.group_name)

2050

self.group_name)

2051

2052

@classmethod

2052

@classmethod

2053

def _generate_choice(cls, repo_group):

2053

def _generate_choice(cls, repo_group):

2054

from webhelpers.html import literal as _literal

2054

from webhelpers.html import literal as _literal

2055

_name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))

2055

_name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))

2056

return repo_group.group_id, _name(repo_group.full_path_splitted)

2056

return repo_group.group_id, _name(repo_group.full_path_splitted)

2057

2058

@classmethod

2058

@classmethod

2059

def groups_choices(cls, groups=None, show_empty_group=True):

2059

def groups_choices(cls, groups=None, show_empty_group=True):

2060

if not groups:

2060

if not groups:

2061

groups = cls.query().all()

2061

groups = cls.query().all()

2062

2063

repo_groups = []

2063

repo_groups = []

2064

if show_empty_group:

2064

if show_empty_group:

2065

repo_groups = [('-1', u'-- %s --' % _('No parent'))]

2065

repo_groups = [('-1', u'-- %s --' % _('No parent'))]

2066

2067

repo_groups.extend([cls._generate_choice(x) for x in groups])

2067

repo_groups.extend([cls._generate_choice(x) for x in groups])

2068

2069

repo_groups = sorted(

2069

repo_groups = sorted(

2070

repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])

2070

repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])

2071

return repo_groups

2071

return repo_groups

2072

2073

@classmethod

2073

@classmethod

2074

def url_sep(cls):

2074

def url_sep(cls):

2075

return URL_SEP

2075

return URL_SEP

2076

2077

@classmethod

2077

@classmethod

2078

def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

2078

def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

2079

if case_insensitive:

2079

if case_insensitive:

2080

gr = cls.query().filter(func.lower(cls.group_name)

2080

gr = cls.query().filter(func.lower(cls.group_name)

2081

== func.lower(group_name))

2081

== func.lower(group_name))

2082

else:

2082

else:

2083

gr = cls.query().filter(cls.group_name == group_name)

2083

gr = cls.query().filter(cls.group_name == group_name)

2084

if cache:

2084

if cache:

2085

gr = gr.options(FromCache(

2085

gr = gr.options(FromCache(

2086

"sql_cache_short",

2086

"sql_cache_short",

2087

"get_group_%s" % _hash_key(group_name)))

2087

"get_group_%s" % _hash_key(group_name)))

2088

return gr.scalar()

2088

return gr.scalar()

2089

2090

@classmethod

2090

@classmethod

2091

def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),

2091

def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),

2092

case_insensitive=True):

2092

case_insensitive=True):

2093

q = RepoGroup.query()

2093

q = RepoGroup.query()

2094

2095

if not isinstance(user_id, Optional):

2095

if not isinstance(user_id, Optional):

2096

q = q.filter(RepoGroup.user_id == user_id)

2096

q = q.filter(RepoGroup.user_id == user_id)

2097

2098

if not isinstance(group_id, Optional):

2098

if not isinstance(group_id, Optional):

2099

q = q.filter(RepoGroup.group_parent_id == group_id)

2099

q = q.filter(RepoGroup.group_parent_id == group_id)

2100

2101

if case_insensitive:

2101

if case_insensitive:

2102

q = q.order_by(func.lower(RepoGroup.group_name))

2102

q = q.order_by(func.lower(RepoGroup.group_name))

2103

else:

2103

else:

2104

q = q.order_by(RepoGroup.group_name)

2104

q = q.order_by(RepoGroup.group_name)

2105

return q.all()

2105

return q.all()

2106

2107

@property

2107

@property

2108

def parents(self):

2108

def parents(self):

2109

parents_recursion_limit = 10

2109

parents_recursion_limit = 10

2110

groups = []

2110

groups = []

2111

if self.parent_group is None:

2111

if self.parent_group is None:

2112

return groups

2112

return groups

2113

cur_gr = self.parent_group

2113

cur_gr = self.parent_group

2114

groups.insert(0, cur_gr)

2114

groups.insert(0, cur_gr)

2115

cnt = 0

2115

cnt = 0

2116

while 1:

2116

while 1:

2117

cnt += 1

2117

cnt += 1

2118

gr = getattr(cur_gr, 'parent_group', None)

2118

gr = getattr(cur_gr, 'parent_group', None)

2119

cur_gr = cur_gr.parent_group

2119

cur_gr = cur_gr.parent_group

2120

if gr is None:

2120

if gr is None:

2121

break

2121

break

2122

if cnt == parents_recursion_limit:

2122

if cnt == parents_recursion_limit:

2123

# this will prevent accidental infinit loops

2123

# this will prevent accidental infinit loops

2124

log.error(('more than %s parents found for group %s, stopping '

2124

log.error(('more than %s parents found for group %s, stopping '

2125

'recursive parent fetching' % (parents_recursion_limit, self)))

2125

'recursive parent fetching' % (parents_recursion_limit, self)))

2126

break

2126

break

2127

2128

groups.insert(0, gr)

2128

groups.insert(0, gr)

2129

return groups

2129

return groups

2130

2131

@property

2131

@property

2132

def children(self):

2132

def children(self):

2133

return RepoGroup.query().filter(RepoGroup.parent_group == self)

2133

return RepoGroup.query().filter(RepoGroup.parent_group == self)

2134

2135

@property

2135

@property

2136

def name(self):

2136

def name(self):

2137

return self.group_name.split(RepoGroup.url_sep())[-1]

2137

return self.group_name.split(RepoGroup.url_sep())[-1]

2138

2139

@property

2139

@property

2140

def full_path(self):

2140

def full_path(self):

2141

return self.group_name

2141

return self.group_name

2142

2143

@property

2143

@property

2144

def full_path_splitted(self):

2144

def full_path_splitted(self):

2145

return self.group_name.split(RepoGroup.url_sep())

2145

return self.group_name.split(RepoGroup.url_sep())

2146

2147

@property

2147

@property

2148

def repositories(self):

2148

def repositories(self):

2149

return Repository.query()\

2149

return Repository.query()\

2150

.filter(Repository.group == self)\

2150

.filter(Repository.group == self)\

2151

.order_by(Repository.repo_name)

2151

.order_by(Repository.repo_name)

2152

2153

@property

2153

@property

2154

def repositories_recursive_count(self):

2154

def repositories_recursive_count(self):

2155

cnt = self.repositories.count()

2155

cnt = self.repositories.count()

2156

2157

def children_count(group):

2157

def children_count(group):

2158

cnt = 0

2158

cnt = 0

2159

for child in group.children:

2159

for child in group.children:

2160

cnt += child.repositories.count()

2160

cnt += child.repositories.count()

2161

cnt += children_count(child)

2161

cnt += children_count(child)

2162

return cnt

2162

return cnt

2163

2164

return cnt + children_count(self)

2164

return cnt + children_count(self)

2165

2166

def _recursive_objects(self, include_repos=True):

2166

def _recursive_objects(self, include_repos=True):

2167

all_ = []

2167

all_ = []

2168

2169

def _get_members(root_gr):

2169

def _get_members(root_gr):

2170

if include_repos:

2170

if include_repos:

2171

for r in root_gr.repositories:

2171

for r in root_gr.repositories:

2172

all_.append(r)

2172

all_.append(r)

2173

childs = root_gr.children.all()

2173

childs = root_gr.children.all()

2174

if childs:

2174

if childs:

2175

for gr in childs:

2175

for gr in childs:

2176

all_.append(gr)

2176

all_.append(gr)

2177

_get_members(gr)

2177

_get_members(gr)

2178

2179

_get_members(self)

2179

_get_members(self)

2180

return [self] + all_

2180

return [self] + all_

2181

2182

def recursive_groups_and_repos(self):

2182

def recursive_groups_and_repos(self):

2183

"""

2183

"""

2184

Recursive return all groups, with repositories in those groups

2184

Recursive return all groups, with repositories in those groups

2185

"""

2185

"""

2186

return self._recursive_objects()

2186

return self._recursive_objects()

2187

2188

def recursive_groups(self):

2188

def recursive_groups(self):

2189

"""

2189

"""

2190

Returns all children groups for this group including children of children

2190

Returns all children groups for this group including children of children

2191

"""

2191

"""

2192

return self._recursive_objects(include_repos=False)

2192

return self._recursive_objects(include_repos=False)

2193

2194

def get_new_name(self, group_name):

2194

def get_new_name(self, group_name):

2195

"""

2195

"""

2196

returns new full group name based on parent and new name

2196

returns new full group name based on parent and new name

2197

2198

:param group_name:

2198

:param group_name:

2199

"""

2199

"""

2200

path_prefix = (self.parent_group.full_path_splitted if

2200

path_prefix = (self.parent_group.full_path_splitted if

2201

self.parent_group else [])

2201

self.parent_group else [])

2202

return RepoGroup.url_sep().join(path_prefix + [group_name])

2202

return RepoGroup.url_sep().join(path_prefix + [group_name])

2203

2204

def permissions(self, with_admins=True, with_owner=True):

2204

def permissions(self, with_admins=True, with_owner=True):

2205

q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)

2205

q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)

2206

q = q.options(joinedload(UserRepoGroupToPerm.group),

2206

q = q.options(joinedload(UserRepoGroupToPerm.group),

2207

joinedload(UserRepoGroupToPerm.user),

2207

joinedload(UserRepoGroupToPerm.user),

2208

joinedload(UserRepoGroupToPerm.permission),)

2208

joinedload(UserRepoGroupToPerm.permission),)

2209

2210

# get owners and admins and permissions. We do a trick of re-writing

2210

# get owners and admins and permissions. We do a trick of re-writing

2211

# objects from sqlalchemy to named-tuples due to sqlalchemy session

2211

# objects from sqlalchemy to named-tuples due to sqlalchemy session

2212

# has a global reference and changing one object propagates to all

2212

# has a global reference and changing one object propagates to all

2213

# others. This means if admin is also an owner admin_row that change

2213

# others. This means if admin is also an owner admin_row that change

2214

# would propagate to both objects

2214

# would propagate to both objects

2215

perm_rows = []

2215

perm_rows = []

2216

for _usr in q.all():

2216

for _usr in q.all():

2217

usr = AttributeDict(_usr.user.get_dict())

2217

usr = AttributeDict(_usr.user.get_dict())

2218

usr.permission = _usr.permission.permission_name

2218

usr.permission = _usr.permission.permission_name

2219

perm_rows.append(usr)

2219

perm_rows.append(usr)

2220

2221

# filter the perm rows by 'default' first and then sort them by

2221

# filter the perm rows by 'default' first and then sort them by

2222

# admin,write,read,none permissions sorted again alphabetically in

2222

# admin,write,read,none permissions sorted again alphabetically in

2223

# each group

2223

# each group

2224

perm_rows = sorted(perm_rows, key=display_sort)

2224

perm_rows = sorted(perm_rows, key=display_sort)

2225

2226

_admin_perm = 'group.admin'

2226

_admin_perm = 'group.admin'

2227

owner_row = []

2227

owner_row = []

2228

if with_owner:

2228

if with_owner:

2229

usr = AttributeDict(self.user.get_dict())

2229

usr = AttributeDict(self.user.get_dict())

2230

usr.owner_row = True

2230

usr.owner_row = True

2231

usr.permission = _admin_perm

2231

usr.permission = _admin_perm

2232

owner_row.append(usr)

2232

owner_row.append(usr)

2233

2234

super_admin_rows = []

2234

super_admin_rows = []

2235

if with_admins:

2235

if with_admins:

2236

for usr in User.get_all_super_admins():

2236

for usr in User.get_all_super_admins():

2237

# if this admin is also owner, don't double the record

2237

# if this admin is also owner, don't double the record

2238

if usr.user_id == owner_row[0].user_id:

2238

if usr.user_id == owner_row[0].user_id:

2239

owner_row[0].admin_row = True

2239

owner_row[0].admin_row = True

2240

else:

2240

else:

2241

usr = AttributeDict(usr.get_dict())

2241

usr = AttributeDict(usr.get_dict())

2242

usr.admin_row = True

2242

usr.admin_row = True

2243

usr.permission = _admin_perm

2243

usr.permission = _admin_perm

2244

super_admin_rows.append(usr)

2244

super_admin_rows.append(usr)

2245

2246

return super_admin_rows + owner_row + perm_rows

2246

return super_admin_rows + owner_row + perm_rows

2247

2248

def permission_user_groups(self):

2248

def permission_user_groups(self):

2249

q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)

2249

q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)

2250

q = q.options(joinedload(UserGroupRepoGroupToPerm.group),

2250

q = q.options(joinedload(UserGroupRepoGroupToPerm.group),

2251

joinedload(UserGroupRepoGroupToPerm.users_group),

2251

joinedload(UserGroupRepoGroupToPerm.users_group),

2252

joinedload(UserGroupRepoGroupToPerm.permission),)

2252

joinedload(UserGroupRepoGroupToPerm.permission),)

2253

2254

perm_rows = []

2254

perm_rows = []

2255

for _user_group in q.all():

2255

for _user_group in q.all():

2256

usr = AttributeDict(_user_group.users_group.get_dict())

2256

usr = AttributeDict(_user_group.users_group.get_dict())

2257

usr.permission = _user_group.permission.permission_name

2257

usr.permission = _user_group.permission.permission_name

2258

perm_rows.append(usr)

2258

perm_rows.append(usr)

2259

2260

return perm_rows

2260

return perm_rows

2261

2262

def get_api_data(self):

2262

def get_api_data(self):

2263

"""

2263

"""

2264

Common function for generating api data

2264

Common function for generating api data

2265

2266

"""

2266

"""

2267

group = self

2267

group = self

2268

data = {

2268

data = {

2269

'group_id': group.group_id,

2269

'group_id': group.group_id,

2270

'group_name': group.group_name,

2270

'group_name': group.group_name,

2271

'group_description': group.group_description,

2271

'group_description': group.group_description,

2272

'parent_group': group.parent_group.group_name if group.parent_group else None,

2272

'parent_group': group.parent_group.group_name if group.parent_group else None,

2273

'repositories': [x.repo_name for x in group.repositories],

2273

'repositories': [x.repo_name for x in group.repositories],

2274

'owner': group.user.username,

2274

'owner': group.user.username,

2275

}

2275

}

2276

return data

2276

return data

2277

2278

2279

class Permission(Base, BaseModel):

2279

class Permission(Base, BaseModel):

2280

__tablename__ = 'permissions'

2280

__tablename__ = 'permissions'

2281

__table_args__ = (

2281

__table_args__ = (

2282

Index('p_perm_name_idx', 'permission_name'),

2282

Index('p_perm_name_idx', 'permission_name'),

2283

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2283

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2284

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2284

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2285

)

2285

)

2286

PERMS = [

2286

PERMS = [

2287

('hg.admin', _('RhodeCode Super Administrator')),

2287

('hg.admin', _('RhodeCode Super Administrator')),

2288

2289

('repository.none', _('Repository no access')),

2289

('repository.none', _('Repository no access')),

2290

('repository.read', _('Repository read access')),

2290

('repository.read', _('Repository read access')),

2291

('repository.write', _('Repository write access')),

2291

('repository.write', _('Repository write access')),

2292

('repository.admin', _('Repository admin access')),

2292

('repository.admin', _('Repository admin access')),

2293

2294

('group.none', _('Repository group no access')),

2294

('group.none', _('Repository group no access')),

2295

('group.read', _('Repository group read access')),

2295

('group.read', _('Repository group read access')),

2296

('group.write', _('Repository group write access')),

2296

('group.write', _('Repository group write access')),

2297

('group.admin', _('Repository group admin access')),

2297

('group.admin', _('Repository group admin access')),

2298

2299

('usergroup.none', _('User group no access')),

2299

('usergroup.none', _('User group no access')),

2300

('usergroup.read', _('User group read access')),

2300

('usergroup.read', _('User group read access')),

2301

('usergroup.write', _('User group write access')),

2301

('usergroup.write', _('User group write access')),

2302

('usergroup.admin', _('User group admin access')),

2302

('usergroup.admin', _('User group admin access')),

2303

2304

('hg.repogroup.create.false', _('Repository Group creation disabled')),

2304

('hg.repogroup.create.false', _('Repository Group creation disabled')),

2305

('hg.repogroup.create.true', _('Repository Group creation enabled')),

2305

('hg.repogroup.create.true', _('Repository Group creation enabled')),

2306

2307

('hg.usergroup.create.false', _('User Group creation disabled')),

2307

('hg.usergroup.create.false', _('User Group creation disabled')),

2308

('hg.usergroup.create.true', _('User Group creation enabled')),

2308

('hg.usergroup.create.true', _('User Group creation enabled')),

2309

2310

('hg.create.none', _('Repository creation disabled')),

2310

('hg.create.none', _('Repository creation disabled')),

2311

('hg.create.repository', _('Repository creation enabled')),

2311

('hg.create.repository', _('Repository creation enabled')),

2312

('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),

2312

('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),

2313

('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),

2313

('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),

2314

2315

('hg.fork.none', _('Repository forking disabled')),

2315

('hg.fork.none', _('Repository forking disabled')),

2316

('hg.fork.repository', _('Repository forking enabled')),

2316

('hg.fork.repository', _('Repository forking enabled')),

2317

2318

('hg.register.none', _('Registration disabled')),

2318

('hg.register.none', _('Registration disabled')),

2319

('hg.register.manual_activate', _('User Registration with manual account activation')),

2319

('hg.register.manual_activate', _('User Registration with manual account activation')),

2320

('hg.register.auto_activate', _('User Registration with automatic account activation')),

2320

('hg.register.auto_activate', _('User Registration with automatic account activation')),

2321

2322

('hg.extern_activate.manual', _('Manual activation of external account')),

2322

('hg.extern_activate.manual', _('Manual activation of external account')),

2323

('hg.extern_activate.auto', _('Automatic activation of external account')),

2323

('hg.extern_activate.auto', _('Automatic activation of external account')),

2324

2325

('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),

2325

('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),

2326

('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),

2326

('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),

2327

]

2327

]

2328

2329

# definition of system default permissions for DEFAULT user

2329

# definition of system default permissions for DEFAULT user

2330

DEFAULT_USER_PERMISSIONS = [

2330

DEFAULT_USER_PERMISSIONS = [

2331

'repository.read',

2331

'repository.read',

2332

'group.read',

2332

'group.read',

2333

'usergroup.read',

2333

'usergroup.read',

2334

'hg.create.repository',

2334

'hg.create.repository',

2335

'hg.repogroup.create.false',

2335

'hg.repogroup.create.false',

2336

'hg.usergroup.create.false',

2336

'hg.usergroup.create.false',

2337

'hg.create.write_on_repogroup.true',

2337

'hg.create.write_on_repogroup.true',

2338

'hg.fork.repository',

2338

'hg.fork.repository',

2339

'hg.register.manual_activate',

2339

'hg.register.manual_activate',

2340

'hg.extern_activate.auto',

2340

'hg.extern_activate.auto',

2341

'hg.inherit_default_perms.true',

2341

'hg.inherit_default_perms.true',

2342

]

2342

]

2343

2344

# defines which permissions are more important higher the more important

2344

# defines which permissions are more important higher the more important

2345

# Weight defines which permissions are more important.

2345

# Weight defines which permissions are more important.

2346

# The higher number the more important.

2346

# The higher number the more important.

2347

PERM_WEIGHTS = {

2347

PERM_WEIGHTS = {

2348

'repository.none': 0,

2348

'repository.none': 0,

2349

'repository.read': 1,

2349

'repository.read': 1,

2350

'repository.write': 3,

2350

'repository.write': 3,

2351

'repository.admin': 4,

2351

'repository.admin': 4,

2352

2353

'group.none': 0,

2353

'group.none': 0,

2354

'group.read': 1,

2354

'group.read': 1,

2355

'group.write': 3,

2355

'group.write': 3,

2356

'group.admin': 4,

2356

'group.admin': 4,

2357

2358

'usergroup.none': 0,

2358

'usergroup.none': 0,

2359

'usergroup.read': 1,

2359

'usergroup.read': 1,

2360

'usergroup.write': 3,

2360

'usergroup.write': 3,

2361

'usergroup.admin': 4,

2361

'usergroup.admin': 4,

2362

2363

'hg.repogroup.create.false': 0,

2363

'hg.repogroup.create.false': 0,

2364

'hg.repogroup.create.true': 1,

2364

'hg.repogroup.create.true': 1,

2365

2366

'hg.usergroup.create.false': 0,

2366

'hg.usergroup.create.false': 0,

2367

'hg.usergroup.create.true': 1,

2367

'hg.usergroup.create.true': 1,

2368

2369

'hg.fork.none': 0,

2369

'hg.fork.none': 0,

2370

'hg.fork.repository': 1,

2370

'hg.fork.repository': 1,

2371

'hg.create.none': 0,

2371

'hg.create.none': 0,

2372

'hg.create.repository': 1

2372

'hg.create.repository': 1

2373

}

2373

}

2374

2375

permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2375

permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2376

permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)

2376

permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)

2377

permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)

2377

permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)

2378

2379

def __unicode__(self):

2379

def __unicode__(self):

2380

return u"<%s('%s:%s')>" % (

2380

return u"<%s('%s:%s')>" % (

2381

self.__class__.__name__, self.permission_id, self.permission_name

2381

self.__class__.__name__, self.permission_id, self.permission_name

2382

)

2382

)

2383

2384

@classmethod

2384

@classmethod

2385

def get_by_key(cls, key):

2385

def get_by_key(cls, key):

2386

return cls.query().filter(cls.permission_name == key).scalar()

2386

return cls.query().filter(cls.permission_name == key).scalar()

2387

2388

@classmethod

2388

@classmethod

2389

def get_default_repo_perms(cls, user_id, repo_id=None):

2389

def get_default_repo_perms(cls, user_id, repo_id=None):

2390

q = Session().query(UserRepoToPerm, Repository, Permission)\

2390

q = Session().query(UserRepoToPerm, Repository, Permission)\

2391

.join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\

2391

.join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\

2392

.join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

2392

.join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

2393

.filter(UserRepoToPerm.user_id == user_id)

2393

.filter(UserRepoToPerm.user_id == user_id)

2394

if repo_id:

2394

if repo_id:

2395

q = q.filter(UserRepoToPerm.repository_id == repo_id)

2395

q = q.filter(UserRepoToPerm.repository_id == repo_id)

2396

return q.all()

2396

return q.all()

2397

2398

@classmethod

2398

@classmethod

2399

def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):

2399

def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):

2400

q = Session().query(UserGroupRepoToPerm, Repository, Permission)\

2400

q = Session().query(UserGroupRepoToPerm, Repository, Permission)\

2401

.join(

2401

.join(

2402

Permission,

2402

Permission,

2403

UserGroupRepoToPerm.permission_id == Permission.permission_id)\

2403

UserGroupRepoToPerm.permission_id == Permission.permission_id)\

2404

.join(

2404

.join(

2405

Repository,

2405

Repository,

2406

UserGroupRepoToPerm.repository_id == Repository.repo_id)\

2406

UserGroupRepoToPerm.repository_id == Repository.repo_id)\

2407

.join(

2407

.join(

2408

UserGroup,

2408

UserGroup,

2409

UserGroupRepoToPerm.users_group_id ==

2409

UserGroupRepoToPerm.users_group_id ==

2410

UserGroup.users_group_id)\

2410

UserGroup.users_group_id)\

2411

.join(

2411

.join(

2412

UserGroupMember,

2412

UserGroupMember,

2413

UserGroupRepoToPerm.users_group_id ==

2413

UserGroupRepoToPerm.users_group_id ==

2414

UserGroupMember.users_group_id)\

2414

UserGroupMember.users_group_id)\

2415

.filter(

2415

.filter(

2416

UserGroupMember.user_id == user_id,

2416

UserGroupMember.user_id == user_id,

2417

UserGroup.users_group_active == true())

2417

UserGroup.users_group_active == true())

2418

if repo_id:

2418

if repo_id:

2419

q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)

2419

q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)

2420

return q.all()

2420

return q.all()

2421

2422

@classmethod

2422

@classmethod

2423

def get_default_group_perms(cls, user_id, repo_group_id=None):

2423

def get_default_group_perms(cls, user_id, repo_group_id=None):

2424

q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\

2424

q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\

2425

.join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\

2425

.join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\

2426

.join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

2426

.join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

2427

.filter(UserRepoGroupToPerm.user_id == user_id)

2427

.filter(UserRepoGroupToPerm.user_id == user_id)

2428

if repo_group_id:

2428

if repo_group_id:

2429

q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)

2429

q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)

2430

return q.all()

2430

return q.all()

2431

2432

@classmethod

2432

@classmethod

2433

def get_default_group_perms_from_user_group(

2433

def get_default_group_perms_from_user_group(

2434

cls, user_id, repo_group_id=None):

2434

cls, user_id, repo_group_id=None):

2435

q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\

2435

q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\

2436

.join(

2436

.join(

2437

Permission,

2437

Permission,

2438

UserGroupRepoGroupToPerm.permission_id ==

2438

UserGroupRepoGroupToPerm.permission_id ==

2439

Permission.permission_id)\

2439

Permission.permission_id)\

2440

.join(

2440

.join(

2441

RepoGroup,

2441

RepoGroup,

2442

UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\

2442

UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\

2443

.join(

2443

.join(

2444

UserGroup,

2444

UserGroup,

2445

UserGroupRepoGroupToPerm.users_group_id ==

2445

UserGroupRepoGroupToPerm.users_group_id ==

2446

UserGroup.users_group_id)\

2446

UserGroup.users_group_id)\

2447

.join(

2447

.join(

2448

UserGroupMember,

2448

UserGroupMember,

2449

UserGroupRepoGroupToPerm.users_group_id ==

2449

UserGroupRepoGroupToPerm.users_group_id ==

2450

UserGroupMember.users_group_id)\

2450

UserGroupMember.users_group_id)\

2451

.filter(

2451

.filter(

2452

UserGroupMember.user_id == user_id,

2452

UserGroupMember.user_id == user_id,

2453

UserGroup.users_group_active == true())

2453

UserGroup.users_group_active == true())

2454

if repo_group_id:

2454

if repo_group_id:

2455

q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)

2455

q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)

2456

return q.all()

2456

return q.all()

2457

2458

@classmethod

2458

@classmethod

2459

def get_default_user_group_perms(cls, user_id, user_group_id=None):

2459

def get_default_user_group_perms(cls, user_id, user_group_id=None):

2460

q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\

2460

q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\

2461

.join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\

2461

.join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\

2462

.join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\

2462

.join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\

2463

.filter(UserUserGroupToPerm.user_id == user_id)

2463

.filter(UserUserGroupToPerm.user_id == user_id)

2464

if user_group_id:

2464

if user_group_id:

2465

q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)

2465

q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)

2466

return q.all()

2466

return q.all()

2467

2468

@classmethod

2468

@classmethod

2469

def get_default_user_group_perms_from_user_group(

2469

def get_default_user_group_perms_from_user_group(

2470

cls, user_id, user_group_id=None):

2470

cls, user_id, user_group_id=None):

2471

TargetUserGroup = aliased(UserGroup, name='target_user_group')

2471

TargetUserGroup = aliased(UserGroup, name='target_user_group')

2472

q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\

2472

q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\

2473

.join(

2473

.join(

2474

Permission,

2474

Permission,

2475

UserGroupUserGroupToPerm.permission_id ==

2475

UserGroupUserGroupToPerm.permission_id ==

2476

Permission.permission_id)\

2476

Permission.permission_id)\

2477

.join(

2477

.join(

2478

TargetUserGroup,

2478

TargetUserGroup,

2479

UserGroupUserGroupToPerm.target_user_group_id ==

2479

UserGroupUserGroupToPerm.target_user_group_id ==

2480

TargetUserGroup.users_group_id)\

2480

TargetUserGroup.users_group_id)\

2481

.join(

2481

.join(

2482

UserGroup,

2482

UserGroup,

2483

UserGroupUserGroupToPerm.user_group_id ==

2483

UserGroupUserGroupToPerm.user_group_id ==

2484

UserGroup.users_group_id)\

2484

UserGroup.users_group_id)\

2485

.join(

2485

.join(

2486

UserGroupMember,

2486

UserGroupMember,

2487

UserGroupUserGroupToPerm.user_group_id ==

2487

UserGroupUserGroupToPerm.user_group_id ==

2488

UserGroupMember.users_group_id)\

2488

UserGroupMember.users_group_id)\

2489

.filter(

2489

.filter(

2490

UserGroupMember.user_id == user_id,

2490

UserGroupMember.user_id == user_id,

2491

UserGroup.users_group_active == true())

2491

UserGroup.users_group_active == true())

2492

if user_group_id:

2492

if user_group_id:

2493

q = q.filter(

2493

q = q.filter(

2494

UserGroupUserGroupToPerm.user_group_id == user_group_id)

2494

UserGroupUserGroupToPerm.user_group_id == user_group_id)

2495

2496

return q.all()

2496

return q.all()

2497

2498

2499

class UserRepoToPerm(Base, BaseModel):

2499

class UserRepoToPerm(Base, BaseModel):

2500

__tablename__ = 'repo_to_perm'

2500

__tablename__ = 'repo_to_perm'

2501

__table_args__ = (

2501

__table_args__ = (

2502

UniqueConstraint('user_id', 'repository_id', 'permission_id'),

2502

UniqueConstraint('user_id', 'repository_id', 'permission_id'),

2503

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2503

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2504

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2504

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2505

)

2505

)

2506

repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2506

repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2507

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2507

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2508

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2508

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2509

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2509

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2510

2511

user = relationship('User')

2511

user = relationship('User')

2512

repository = relationship('Repository')

2512

repository = relationship('Repository')

2513

permission = relationship('Permission')

2513

permission = relationship('Permission')

2514

2515

@classmethod

2515

@classmethod

2516

def create(cls, user, repository, permission):

2516

def create(cls, user, repository, permission):

2517

n = cls()

2517

n = cls()

2518

n.user = user

2518

n.user = user

2519

n.repository = repository

2519

n.repository = repository

2520

n.permission = permission

2520

n.permission = permission

2521

Session().add(n)

2521

Session().add(n)

2522

return n

2522

return n

2523

2524

def __unicode__(self):

2524

def __unicode__(self):

2525

return u'<%s => %s >' % (self.user, self.repository)

2525

return u'<%s => %s >' % (self.user, self.repository)

2526

2527

2528

class UserUserGroupToPerm(Base, BaseModel):

2528

class UserUserGroupToPerm(Base, BaseModel):

2529

__tablename__ = 'user_user_group_to_perm'

2529

__tablename__ = 'user_user_group_to_perm'

2530

__table_args__ = (

2530

__table_args__ = (

2531

UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

2531

UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

2532

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2532

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2533

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2533

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2534

)

2534

)

2535

user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2535

user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2536

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2536

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2537

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2537

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2538

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2538

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2539

2540

user = relationship('User')

2540

user = relationship('User')

2541

user_group = relationship('UserGroup')

2541

user_group = relationship('UserGroup')

2542

permission = relationship('Permission')

2542

permission = relationship('Permission')

2543

2544

@classmethod

2544

@classmethod

2545

def create(cls, user, user_group, permission):

2545

def create(cls, user, user_group, permission):

2546

n = cls()

2546

n = cls()

2547

n.user = user

2547

n.user = user

2548

n.user_group = user_group

2548

n.user_group = user_group

2549

n.permission = permission

2549

n.permission = permission

2550

Session().add(n)

2550

Session().add(n)

2551

return n

2551

return n

2552

2553

def __unicode__(self):

2553

def __unicode__(self):

2554

return u'<%s => %s >' % (self.user, self.user_group)

2554

return u'<%s => %s >' % (self.user, self.user_group)

2555

2556

2557

class UserToPerm(Base, BaseModel):

2557

class UserToPerm(Base, BaseModel):

2558

__tablename__ = 'user_to_perm'

2558

__tablename__ = 'user_to_perm'

2559

__table_args__ = (

2559

__table_args__ = (

2560

UniqueConstraint('user_id', 'permission_id'),

2560

UniqueConstraint('user_id', 'permission_id'),

2561

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2561

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2562

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2562

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2563

)

2563

)

2564

user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2564

user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2565

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2565

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2566

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2566

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2567

2568

user = relationship('User')

2568

user = relationship('User')

2569

permission = relationship('Permission', lazy='joined')

2569

permission = relationship('Permission', lazy='joined')

2570

2571

def __unicode__(self):

2571

def __unicode__(self):

2572

return u'<%s => %s >' % (self.user, self.permission)

2572

return u'<%s => %s >' % (self.user, self.permission)

2573

2574

2575

class UserGroupRepoToPerm(Base, BaseModel):

2575

class UserGroupRepoToPerm(Base, BaseModel):

2576

__tablename__ = 'users_group_repo_to_perm'

2576

__tablename__ = 'users_group_repo_to_perm'

2577

__table_args__ = (

2577

__table_args__ = (

2578

UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

2578

UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

2579

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2579

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2580

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2580

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2581

)

2581

)

2582

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2582

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2583

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2583

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2584

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2584

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2585

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2585

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2586

2587

users_group = relationship('UserGroup')

2587

users_group = relationship('UserGroup')

2588

permission = relationship('Permission')

2588

permission = relationship('Permission')

2589

repository = relationship('Repository')

2589

repository = relationship('Repository')

2590

2591

@classmethod

2591

@classmethod

2592

def create(cls, users_group, repository, permission):

2592

def create(cls, users_group, repository, permission):

2593

n = cls()

2593

n = cls()

2594

n.users_group = users_group

2594

n.users_group = users_group

2595

n.repository = repository

2595

n.repository = repository

2596

n.permission = permission

2596

n.permission = permission

2597

Session().add(n)

2597

Session().add(n)

2598

return n

2598

return n

2599

2600

def __unicode__(self):

2600

def __unicode__(self):

2601

return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)

2601

return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)

2602

2603

2604

class UserGroupUserGroupToPerm(Base, BaseModel):

2604

class UserGroupUserGroupToPerm(Base, BaseModel):

2605

__tablename__ = 'user_group_user_group_to_perm'

2605

__tablename__ = 'user_group_user_group_to_perm'

2606

__table_args__ = (

2606

__table_args__ = (

2607

UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

2607

UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

2608

CheckConstraint('target_user_group_id != user_group_id'),

2608

CheckConstraint('target_user_group_id != user_group_id'),

2609

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2609

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2610

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2610

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2611

)

2611

)

2612

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)

2612

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)

2613

target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2613

target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2614

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2614

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2615

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2615

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2616

2617

target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

2617

target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

2618

user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')

2618

user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')

2619

permission = relationship('Permission')

2619

permission = relationship('Permission')

2620

2621

@classmethod

2621

@classmethod

2622

def create(cls, target_user_group, user_group, permission):

2622

def create(cls, target_user_group, user_group, permission):

2623

n = cls()

2623

n = cls()

2624

n.target_user_group = target_user_group

2624

n.target_user_group = target_user_group

2625

n.user_group = user_group

2625

n.user_group = user_group

2626

n.permission = permission

2626

n.permission = permission

2627

Session().add(n)

2627

Session().add(n)

2628

return n

2628

return n

2629

2630

def __unicode__(self):

2630

def __unicode__(self):

2631

return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

2631

return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

2632

2633

2634

class UserGroupToPerm(Base, BaseModel):

2634

class UserGroupToPerm(Base, BaseModel):

2635

__tablename__ = 'users_group_to_perm'

2635

__tablename__ = 'users_group_to_perm'

2636

__table_args__ = (

2636

__table_args__ = (

2637

UniqueConstraint('users_group_id', 'permission_id',),

2637

UniqueConstraint('users_group_id', 'permission_id',),

2638

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2638

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2639

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2639

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2640

)

2640

)

2641

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2641

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2642

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2642

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2643

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2643

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2644

2645

users_group = relationship('UserGroup')

2645

users_group = relationship('UserGroup')

2646

permission = relationship('Permission')

2646

permission = relationship('Permission')

2647

2648

2649

class UserRepoGroupToPerm(Base, BaseModel):

2649

class UserRepoGroupToPerm(Base, BaseModel):

2650

__tablename__ = 'user_repo_group_to_perm'

2650

__tablename__ = 'user_repo_group_to_perm'

2651

__table_args__ = (

2651

__table_args__ = (

2652

UniqueConstraint('user_id', 'group_id', 'permission_id'),

2652

UniqueConstraint('user_id', 'group_id', 'permission_id'),

2653

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2653

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2654

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2654

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2655

)

2655

)

2656

2657

group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2657

group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2658

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2658

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2659

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

2659

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

2660

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2660

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2661

2662

user = relationship('User')

2662

user = relationship('User')

2663

group = relationship('RepoGroup')

2663

group = relationship('RepoGroup')

2664

permission = relationship('Permission')

2664

permission = relationship('Permission')

2665

2666

@classmethod

2666

@classmethod

2667

def create(cls, user, repository_group, permission):

2667

def create(cls, user, repository_group, permission):

2668

n = cls()

2668

n = cls()

2669

n.user = user

2669

n.user = user

2670

n.group = repository_group

2670

n.group = repository_group

2671

n.permission = permission

2671

n.permission = permission

2672

Session().add(n)

2672

Session().add(n)

2673

return n

2673

return n

2674

2675

2676

class UserGroupRepoGroupToPerm(Base, BaseModel):

2676

class UserGroupRepoGroupToPerm(Base, BaseModel):

2677

__tablename__ = 'users_group_repo_group_to_perm'

2677

__tablename__ = 'users_group_repo_group_to_perm'

2678

__table_args__ = (

2678

__table_args__ = (

2679

UniqueConstraint('users_group_id', 'group_id'),

2679

UniqueConstraint('users_group_id', 'group_id'),

2680

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2680

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2681

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2681

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2682

)

2682

)

2683

2684

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)

2684

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)

2685

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2685

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2686

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

2686

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

2687

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2687

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2688

2689

users_group = relationship('UserGroup')

2689

users_group = relationship('UserGroup')

2690

permission = relationship('Permission')

2690

permission = relationship('Permission')

2691

group = relationship('RepoGroup')

2691

group = relationship('RepoGroup')

2692

2693

@classmethod

2693

@classmethod

2694

def create(cls, user_group, repository_group, permission):

2694

def create(cls, user_group, repository_group, permission):

2695

n = cls()

2695

n = cls()

2696

n.users_group = user_group

2696

n.users_group = user_group

2697

n.group = repository_group

2697

n.group = repository_group

2698

n.permission = permission

2698

n.permission = permission

2699

Session().add(n)

2699

Session().add(n)

2700

return n

2700

return n

2701

2702

def __unicode__(self):

2702

def __unicode__(self):

2703

return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)

2703

return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)

2704

2705

2706

class Statistics(Base, BaseModel):

2706

class Statistics(Base, BaseModel):

2707

__tablename__ = 'statistics'

2707

__tablename__ = 'statistics'

2708

__table_args__ = (

2708

__table_args__ = (

2709

UniqueConstraint('repository_id'),

2709

UniqueConstraint('repository_id'),

2710

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2710

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2711

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2711

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2712

)

2712

)

2713

stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2713

stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2714

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

2714

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

2715

stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

2715

stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

2716

commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

2716

commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

2717

commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

2717

commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

2718

languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

2718

languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

2719

2720

repository = relationship('Repository', single_parent=True)

2720

repository = relationship('Repository', single_parent=True)

2721

2722

2723

class UserFollowing(Base, BaseModel):

2723

class UserFollowing(Base, BaseModel):

2724

__tablename__ = 'user_followings'

2724

__tablename__ = 'user_followings'

2725

__table_args__ = (

2725

__table_args__ = (

2726

UniqueConstraint('user_id', 'follows_repository_id'),

2726

UniqueConstraint('user_id', 'follows_repository_id'),

2727

UniqueConstraint('user_id', 'follows_user_id'),

2727

UniqueConstraint('user_id', 'follows_user_id'),

2728

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2728

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2729

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2729

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2730

)

2730

)

2731

2732

user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2732

user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2733

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2733

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2734

follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

2734

follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

2735

follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

2735

follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

2736

follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

2736

follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

2737

2738

user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

2738

user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

2739

2740

follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

2740

follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

2741

follows_repository = relationship('Repository', order_by='Repository.repo_name')

2741

follows_repository = relationship('Repository', order_by='Repository.repo_name')

2742

2743

@classmethod

2743

@classmethod

2744

def get_repo_followers(cls, repo_id):

2744

def get_repo_followers(cls, repo_id):

2745

return cls.query().filter(cls.follows_repo_id == repo_id)

2745

return cls.query().filter(cls.follows_repo_id == repo_id)

2746

2747

2748

class CacheKey(Base, BaseModel):

2748

class CacheKey(Base, BaseModel):

2749

__tablename__ = 'cache_invalidation'

2749

__tablename__ = 'cache_invalidation'

2750

__table_args__ = (

2750

__table_args__ = (

2751

UniqueConstraint('cache_key'),

2751

UniqueConstraint('cache_key'),

2752

Index('key_idx', 'cache_key'),

2752

Index('key_idx', 'cache_key'),

2753

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2753

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2754

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2754

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2755

)

2755

)

2756

CACHE_TYPE_ATOM = 'ATOM'

2756

CACHE_TYPE_ATOM = 'ATOM'

2757

CACHE_TYPE_RSS = 'RSS'

2757

CACHE_TYPE_RSS = 'RSS'

2758

CACHE_TYPE_README = 'README'

2758

CACHE_TYPE_README = 'README'

2759

2760

cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2760

cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2761

cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)

2761

cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)

2762

cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)

2762

cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)

2763

cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

2763

cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

2764

2765

def __init__(self, cache_key, cache_args=''):

2765

def __init__(self, cache_key, cache_args=''):

2766

self.cache_key = cache_key

2766

self.cache_key = cache_key

2767

self.cache_args = cache_args

2767

self.cache_args = cache_args

2768

self.cache_active = False

2768

self.cache_active = False

2769

2770

def __unicode__(self):

2770

def __unicode__(self):

2771

return u"<%s('%s:%s[%s]')>" % (

2771

return u"<%s('%s:%s[%s]')>" % (

2772

self.__class__.__name__,

2772

self.__class__.__name__,

2773

self.cache_id, self.cache_key, self.cache_active)

2773

self.cache_id, self.cache_key, self.cache_active)

2774

2775

def _cache_key_partition(self):

2775

def _cache_key_partition(self):

2776

prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

2776

prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

2777

return prefix, repo_name, suffix

2777

return prefix, repo_name, suffix

2778

2779

def get_prefix(self):

2779

def get_prefix(self):

2780

"""

2780

"""

2781

Try to extract prefix from existing cache key. The key could consist

2781

Try to extract prefix from existing cache key. The key could consist

2782

of prefix, repo_name, suffix

2782

of prefix, repo_name, suffix

2783

"""

2783

"""

2784

# this returns prefix, repo_name, suffix

2784

# this returns prefix, repo_name, suffix

2785

return self._cache_key_partition()[0]

2785

return self._cache_key_partition()[0]

2786

2787

def get_suffix(self):

2787

def get_suffix(self):

2788

"""

2788

"""

2789

get suffix that might have been used in _get_cache_key to

2789

get suffix that might have been used in _get_cache_key to

2790

generate self.cache_key. Only used for informational purposes

2790

generate self.cache_key. Only used for informational purposes

2791

in repo_edit.html.

2791

in repo_edit.html.

2792

"""

2792

"""

2793

# prefix, repo_name, suffix

2793

# prefix, repo_name, suffix

2794

return self._cache_key_partition()[2]

2794

return self._cache_key_partition()[2]

2795

2796

@classmethod

2796

@classmethod

2797

def delete_all_cache(cls):

2797

def delete_all_cache(cls):

2798

"""

2798

"""

2799

Delete all cache keys from database.

2799

Delete all cache keys from database.

2800

Should only be run when all instances are down and all entries

2800

Should only be run when all instances are down and all entries

2801

thus stale.

2801

thus stale.

2802

"""

2802

"""

2803

cls.query().delete()

2803

cls.query().delete()

2804

Session().commit()

2804

Session().commit()

2805

2806

@classmethod

2806

@classmethod

2807

def get_cache_key(cls, repo_name, cache_type):

2807

def get_cache_key(cls, repo_name, cache_type):

2808

"""

2808

"""

2809

2810

Generate a cache key for this process of RhodeCode instance.

2810

Generate a cache key for this process of RhodeCode instance.

2811

Prefix most likely will be process id or maybe explicitly set

2811

Prefix most likely will be process id or maybe explicitly set

2812

instance_id from .ini file.

2812

instance_id from .ini file.

2813

"""

2813

"""

2814

import rhodecode

2814

import rhodecode

2815

prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')

2815

prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')

2816

2817

repo_as_unicode = safe_unicode(repo_name)

2817

repo_as_unicode = safe_unicode(repo_name)

2818

key = u'{}_{}'.format(repo_as_unicode, cache_type) \

2818

key = u'{}_{}'.format(repo_as_unicode, cache_type) \

2819

if cache_type else repo_as_unicode

2819

if cache_type else repo_as_unicode

2820

2821

return u'{}{}'.format(prefix, key)

2821

return u'{}{}'.format(prefix, key)

2822

2823

@classmethod

2823

@classmethod

2824

def set_invalidate(cls, repo_name, delete=False):

2824

def set_invalidate(cls, repo_name, delete=False):

2825

"""

2825

"""

2826

Mark all caches of a repo as invalid in the database.

2826

Mark all caches of a repo as invalid in the database.

2827

"""

2827

"""

2828

2829

try:

2829

try:

2830

qry = Session().query(cls).filter(cls.cache_args == repo_name)

2830

qry = Session().query(cls).filter(cls.cache_args == repo_name)

2831

if delete:

2831

if delete:

2832

log.debug('cache objects deleted for repo %s',

2832

log.debug('cache objects deleted for repo %s',

2833

safe_str(repo_name))

2833

safe_str(repo_name))

2834

qry.delete()

2834

qry.delete()

2835

else:

2835

else:

2836

log.debug('cache objects marked as invalid for repo %s',

2836

log.debug('cache objects marked as invalid for repo %s',

2837

safe_str(repo_name))

2837

safe_str(repo_name))

2838

qry.update({"cache_active": False})

2838

qry.update({"cache_active": False})

2839

2840

Session().commit()

2840

Session().commit()

2841

except Exception:

2841

except Exception:

2842

log.exception(

2842

log.exception(

2843

'Cache key invalidation failed for repository %s',

2843

'Cache key invalidation failed for repository %s',

2844

safe_str(repo_name))

2844

safe_str(repo_name))

2845

Session().rollback()

2845

Session().rollback()

2846

2847

@classmethod

2847

@classmethod

2848

def get_active_cache(cls, cache_key):

2848

def get_active_cache(cls, cache_key):

2849

inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

2849

inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

2850

if inv_obj:

2850

if inv_obj:

2851

return inv_obj

2851

return inv_obj

2852

return None

2852

return None

2853

2854

@classmethod

2854

@classmethod

2855

def repo_context_cache(cls, compute_func, repo_name, cache_type,

2855

def repo_context_cache(cls, compute_func, repo_name, cache_type,

2856

thread_scoped=False):

2856

thread_scoped=False):

2857

"""

2857

"""

2858

@cache_region('long_term')

2858

@cache_region('long_term')

2859

def _heavy_calculation(cache_key):

2859

def _heavy_calculation(cache_key):

2860

return 'result'

2860

return 'result'

2861

2862

cache_context = CacheKey.repo_context_cache(

2862

cache_context = CacheKey.repo_context_cache(

2863

_heavy_calculation, repo_name, cache_type)

2863

_heavy_calculation, repo_name, cache_type)

2864

2865

with cache_context as context:

2865

with cache_context as context:

2866

context.invalidate()

2866

context.invalidate()

2867

computed = context.compute()

2867

computed = context.compute()

2868

2869

assert computed == 'result'

2869

assert computed == 'result'

2870

"""

2870

"""

2871

from rhodecode.lib import caches

2871

from rhodecode.lib import caches

2872

return caches.InvalidationContext(

2872

return caches.InvalidationContext(

2873

compute_func, repo_name, cache_type, thread_scoped=thread_scoped)

2873

compute_func, repo_name, cache_type, thread_scoped=thread_scoped)

2874

2875

2876

class ChangesetComment(Base, BaseModel):

2876

class ChangesetComment(Base, BaseModel):

2877

__tablename__ = 'changeset_comments'

2877

__tablename__ = 'changeset_comments'

2878

__table_args__ = (

2878

__table_args__ = (

2879

Index('cc_revision_idx', 'revision'),

2879

Index('cc_revision_idx', 'revision'),

2880

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2880

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2881

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2881

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2882

)

2882

)

2883

2884

COMMENT_OUTDATED = u'comment_outdated'

2884

COMMENT_OUTDATED = u'comment_outdated'

2885

2886

comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

2886

comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

2887

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

2887

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

2888

revision = Column('revision', String(40), nullable=True)

2888

revision = Column('revision', String(40), nullable=True)

2889

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

2889

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

2890

pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)

2890

pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)

2891

line_no = Column('line_no', Unicode(10), nullable=True)

2891

line_no = Column('line_no', Unicode(10), nullable=True)

2892

hl_lines = Column('hl_lines', Unicode(512), nullable=True)

2892

hl_lines = Column('hl_lines', Unicode(512), nullable=True)

2893

f_path = Column('f_path', Unicode(1000), nullable=True)

2893

f_path = Column('f_path', Unicode(1000), nullable=True)

2894

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

2894

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

2895

text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)

2895

text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)

2896

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2896

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2897

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2897

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

2898

renderer = Column('renderer', Unicode(64), nullable=True)

2898

renderer = Column('renderer', Unicode(64), nullable=True)

2899

display_state = Column('display_state', Unicode(128), nullable=True)

2899

display_state = Column('display_state', Unicode(128), nullable=True)

2900

2901

author = relationship('User', lazy='joined')

2901

author = relationship('User', lazy='joined')

2902

repo = relationship('Repository')

2902

repo = relationship('Repository')

2903

status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")

2903

status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")

2904

pull_request = relationship('PullRequest', lazy='joined')

2904

pull_request = relationship('PullRequest', lazy='joined')

2905

pull_request_version = relationship('PullRequestVersion')

2905

pull_request_version = relationship('PullRequestVersion')

2906

2907

@classmethod

2907

@classmethod

2908

def get_users(cls, revision=None, pull_request_id=None):

2908

def get_users(cls, revision=None, pull_request_id=None):

2909

"""

2909

"""

2910

Returns user associated with this ChangesetComment. ie those

2910

Returns user associated with this ChangesetComment. ie those

2911

who actually commented

2911

who actually commented

2912

2913

:param cls:

2913

:param cls:

2914

:param revision:

2914

:param revision:

2915

"""

2915

"""

2916

q = Session().query(User)\

2916

q = Session().query(User)\

2917

.join(ChangesetComment.author)

2917

.join(ChangesetComment.author)

2918

if revision:

2918

if revision:

2919

q = q.filter(cls.revision == revision)

2919

q = q.filter(cls.revision == revision)

2920

elif pull_request_id:

2920

elif pull_request_id:

2921

q = q.filter(cls.pull_request_id == pull_request_id)

2921

q = q.filter(cls.pull_request_id == pull_request_id)

2922

return q.all()

2922

return q.all()

2923

2924

def render(self, mentions=False):

2924

def render(self, mentions=False):

2925

from rhodecode.lib import helpers as h

2925

from rhodecode.lib import helpers as h

2926

return h.render(self.text, renderer=self.renderer, mentions=mentions)

2926

return h.render(self.text, renderer=self.renderer, mentions=mentions)

2927

2928

def __repr__(self):

2928

def __repr__(self):

2929

if self.comment_id:

2929

if self.comment_id:

2930

return '<DB:ChangesetComment #%s>' % self.comment_id

2930

return '<DB:ChangesetComment #%s>' % self.comment_id

2931

else:

2931

else:

2932

return '<DB:ChangesetComment at %#x>' % id(self)

2932

return '<DB:ChangesetComment at %#x>' % id(self)

2933

2934

2935

class ChangesetStatus(Base, BaseModel):

2935

class ChangesetStatus(Base, BaseModel):

2936

__tablename__ = 'changeset_statuses'

2936

__tablename__ = 'changeset_statuses'

2937

__table_args__ = (

2937

__table_args__ = (

2938

Index('cs_revision_idx', 'revision'),

2938

Index('cs_revision_idx', 'revision'),

2939

Index('cs_version_idx', 'version'),

2939

Index('cs_version_idx', 'version'),

2940

UniqueConstraint('repo_id', 'revision', 'version'),

2940

UniqueConstraint('repo_id', 'revision', 'version'),

2941

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2941

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2942

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2942

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2943

)

2943

)

2944

STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

2944

STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

2945

STATUS_APPROVED = 'approved'

2945

STATUS_APPROVED = 'approved'

2946

STATUS_REJECTED = 'rejected'

2946

STATUS_REJECTED = 'rejected'

2947

STATUS_UNDER_REVIEW = 'under_review'

2947

STATUS_UNDER_REVIEW = 'under_review'

2948

2949

STATUSES = [

2949

STATUSES = [

2950

(STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default

2950

(STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default

2951

(STATUS_APPROVED, _("Approved")),

2951

(STATUS_APPROVED, _("Approved")),

2952

(STATUS_REJECTED, _("Rejected")),

2952

(STATUS_REJECTED, _("Rejected")),

2953

(STATUS_UNDER_REVIEW, _("Under Review")),

2953

(STATUS_UNDER_REVIEW, _("Under Review")),

2954

]

2954

]

2955

2956

changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)

2956

changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)

2957

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

2957

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

2958

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

2958

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

2959

revision = Column('revision', String(40), nullable=False)

2959

revision = Column('revision', String(40), nullable=False)

2960

status = Column('status', String(128), nullable=False, default=DEFAULT)

2960

status = Column('status', String(128), nullable=False, default=DEFAULT)

2961

changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))

2961

changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))

2962

modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

2962

modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

2963

version = Column('version', Integer(), nullable=False, default=0)

2963

version = Column('version', Integer(), nullable=False, default=0)

2964

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

2964

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

2965

2966

author = relationship('User', lazy='joined')

2966

author = relationship('User', lazy='joined')

2967

repo = relationship('Repository')

2967

repo = relationship('Repository')

2968

comment = relationship('ChangesetComment', lazy='joined')

2968

comment = relationship('ChangesetComment', lazy='joined')

2969

pull_request = relationship('PullRequest', lazy='joined')

2969

pull_request = relationship('PullRequest', lazy='joined')

2970

2971

def __unicode__(self):

2971

def __unicode__(self):

2972

return u"<%s('%s[%s]:%s')>" % (

2972

return u"<%s('%s[%s]:%s')>" % (

2973

self.__class__.__name__,

2973

self.__class__.__name__,

2974

self.status, self.version, self.author

2974

self.status, self.version, self.author

2975

)

2975

)

2976

2977

@classmethod

2977

@classmethod

2978

def get_status_lbl(cls, value):

2978

def get_status_lbl(cls, value):

2979

return dict(cls.STATUSES).get(value)

2979

return dict(cls.STATUSES).get(value)

2980

2981

@property

2981

@property

2982

def status_lbl(self):

2982

def status_lbl(self):

2983

return ChangesetStatus.get_status_lbl(self.status)

2983

return ChangesetStatus.get_status_lbl(self.status)

2984

2985

2986

class _PullRequestBase(BaseModel):

2986

class _PullRequestBase(BaseModel):

2987

"""

2987

"""

2988

Common attributes of pull request and version entries.

2988

Common attributes of pull request and version entries.

2989

"""

2989

"""

2990

2991

# .status values

2991

# .status values

2992

STATUS_NEW = u'new'

2992

STATUS_NEW = u'new'

2993

STATUS_OPEN = u'open'

2993

STATUS_OPEN = u'open'

2994

STATUS_CLOSED = u'closed'

2994

STATUS_CLOSED = u'closed'

2995

2996

title = Column('title', Unicode(255), nullable=True)

2996

title = Column('title', Unicode(255), nullable=True)

2997

description = Column(

2997

description = Column(

2998

'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),

2998

'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),

2999

nullable=True)

2999

nullable=True)

3000

# new/open/closed status of pull request (not approve/reject/etc)

3000

# new/open/closed status of pull request (not approve/reject/etc)

3001

status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)

3001

status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)

3002

created_on = Column(

3002

created_on = Column(

3003

'created_on', DateTime(timezone=False), nullable=False,

3003

'created_on', DateTime(timezone=False), nullable=False,

3004

default=datetime.datetime.now)

3004

default=datetime.datetime.now)

3005

updated_on = Column(

3005

updated_on = Column(

3006

'updated_on', DateTime(timezone=False), nullable=False,

3006

'updated_on', DateTime(timezone=False), nullable=False,

3007

default=datetime.datetime.now)

3007

default=datetime.datetime.now)

3008

3009

@declared_attr

3009

@declared_attr

3010

def user_id(cls):

3010

def user_id(cls):

3011

return Column(

3011

return Column(

3012

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

3012

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

3013

unique=None)

3013

unique=None)

3014

3015

# 500 revisions max

3015

# 500 revisions max

3016

_revisions = Column(

3016

_revisions = Column(

3017

'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))

3017

'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))

3018

3019

@declared_attr

3019

@declared_attr

3020

def source_repo_id(cls):

3020

def source_repo_id(cls):

3021

# TODO: dan: rename column to source_repo_id

3021

# TODO: dan: rename column to source_repo_id

3022

return Column(

3022

return Column(

3023

'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3023

'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3024

nullable=False)

3024

nullable=False)

3025

3026

source_ref = Column('org_ref', Unicode(255), nullable=False)

3026

source_ref = Column('org_ref', Unicode(255), nullable=False)

3027

3028

@declared_attr

3028

@declared_attr

3029

def target_repo_id(cls):

3029

def target_repo_id(cls):

3030

# TODO: dan: rename column to target_repo_id

3030

# TODO: dan: rename column to target_repo_id

3031

return Column(

3031

return Column(

3032

'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3032

'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3033

nullable=False)

3033

nullable=False)

3034

3035

target_ref = Column('other_ref', Unicode(255), nullable=False)

3035

target_ref = Column('other_ref', Unicode(255), nullable=False)

3036

3037

# TODO: dan: rename column to last_merge_source_rev

3037

# TODO: dan: rename column to last_merge_source_rev

3038

_last_merge_source_rev = Column(

3038

_last_merge_source_rev = Column(

3039

'last_merge_org_rev', String(40), nullable=True)

3039

'last_merge_org_rev', String(40), nullable=True)

3040

# TODO: dan: rename column to last_merge_target_rev

3040

# TODO: dan: rename column to last_merge_target_rev

3041

_last_merge_target_rev = Column(

3041

_last_merge_target_rev = Column(

3042

'last_merge_other_rev', String(40), nullable=True)

3042

'last_merge_other_rev', String(40), nullable=True)

3043

_last_merge_status = Column('merge_status', Integer(), nullable=True)

3043

_last_merge_status = Column('merge_status', Integer(), nullable=True)

3044

merge_rev = Column('merge_rev', String(40), nullable=True)

3044

merge_rev = Column('merge_rev', String(40), nullable=True)

3045

3046

@hybrid_property

3046

@hybrid_property

3047

def revisions(self):

3047

def revisions(self):

3048

return self._revisions.split(':') if self._revisions else []

3048

return self._revisions.split(':') if self._revisions else []

3049

3050

@revisions.setter

3050

@revisions.setter

3051

def revisions(self, val):

3051

def revisions(self, val):

3052

self._revisions = ':'.join(val)

3052

self._revisions = ':'.join(val)

3053

3054

@declared_attr

3054

@declared_attr

3055

def author(cls):

3055

def author(cls):

3056

return relationship('User', lazy='joined')

3056

return relationship('User', lazy='joined')

3057

3058

@declared_attr

3058

@declared_attr

3059

def source_repo(cls):

3059

def source_repo(cls):

3060

return relationship(

3060

return relationship(

3061

'Repository',

3061

'Repository',

3062

primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)

3062

primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)

3063

3064

@property

3064

@property

3065

def source_ref_parts(self):

3065

def source_ref_parts(self):

3066

refs = self.source_ref.split(':')

3066

refs = self.source_ref.split(':')

3067

return Reference(refs[0], refs[1], refs[2])

3067

return Reference(refs[0], refs[1], refs[2])

3068

3069

@declared_attr

3069

@declared_attr

3070

def target_repo(cls):

3070

def target_repo(cls):

3071

return relationship(

3071

return relationship(

3072

'Repository',

3072

'Repository',

3073

primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)

3073

primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)

3074

3075

@property

3075

@property

3076

def target_ref_parts(self):

3076

def target_ref_parts(self):

3077

refs = self.target_ref.split(':')

3077

refs = self.target_ref.split(':')

3078

return Reference(refs[0], refs[1], refs[2])

3078

return Reference(refs[0], refs[1], refs[2])

3079

3080

3081

class PullRequest(Base, _PullRequestBase):

3081

class PullRequest(Base, _PullRequestBase):

3082

__tablename__ = 'pull_requests'

3082

__tablename__ = 'pull_requests'

3083

__table_args__ = (

3083

__table_args__ = (

3084

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3084

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3085

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3085

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3086

)

3086

)

3087

3088

pull_request_id = Column(

3088

pull_request_id = Column(

3089

'pull_request_id', Integer(), nullable=False, primary_key=True)

3089

'pull_request_id', Integer(), nullable=False, primary_key=True)

3090

3091

def __repr__(self):

3091

def __repr__(self):

3092

if self.pull_request_id:

3092

if self.pull_request_id:

3093

return '<DB:PullRequest #%s>' % self.pull_request_id

3093

return '<DB:PullRequest #%s>' % self.pull_request_id

3094

else:

3094

else:

3095

return '<DB:PullRequest at %#x>' % id(self)

3095

return '<DB:PullRequest at %#x>' % id(self)

3096

3097

reviewers = relationship('PullRequestReviewers',

3097

reviewers = relationship('PullRequestReviewers',

3098

cascade="all, delete, delete-orphan")

3098

cascade="all, delete, delete-orphan")

3099

statuses = relationship('ChangesetStatus')

3099

statuses = relationship('ChangesetStatus')

3100

comments = relationship('ChangesetComment',

3100

comments = relationship('ChangesetComment',

3101

cascade="all, delete, delete-orphan")

3101

cascade="all, delete, delete-orphan")

3102

versions = relationship('PullRequestVersion',

3102

versions = relationship('PullRequestVersion',

3103

cascade="all, delete, delete-orphan")

3103

cascade="all, delete, delete-orphan")

3104

3105

def is_closed(self):

3105

def is_closed(self):

3106

return self.status == self.STATUS_CLOSED

3106

return self.status == self.STATUS_CLOSED

3107

3108

def get_api_data(self):

3108

def get_api_data(self):

3109

from rhodecode.model.pull_request import PullRequestModel

3109

from rhodecode.model.pull_request import PullRequestModel

3110

pull_request = self

3110

pull_request = self

3111

merge_status = PullRequestModel().merge_status(pull_request)

3111

merge_status = PullRequestModel().merge_status(pull_request)

3112

pull_request_url = url(

3113

'pullrequest_show', repo_name=self.target_repo.repo_name,

3114

pull_request_id=self.pull_request_id, qualified=True)

3112

data = {

3115

data = {

3113

'pull_request_id': pull_request.pull_request_id,

3116

'pull_request_id': pull_request.pull_request_id,

3114

'url': url('pullrequest_show', repo_name=self.target_repo.repo_name,

3117

'url': pull_request_url,

3115

pull_request_id=self.pull_request_id,

3116

qualified=True),

3117

'title': pull_request.title,

3118

'title': pull_request.title,

3118

'description': pull_request.description,

3119

'description': pull_request.description,

3119

'status': pull_request.status,

3120

'status': pull_request.status,

3120

'created_on': pull_request.created_on,

3121

'created_on': pull_request.created_on,

3121

'updated_on': pull_request.updated_on,

3122

'updated_on': pull_request.updated_on,

3122

'commit_ids': pull_request.revisions,

3123

'commit_ids': pull_request.revisions,

3123

'review_status': pull_request.calculated_review_status(),

3124

'review_status': pull_request.calculated_review_status(),

3124

'mergeable': {

3125

'mergeable': {

3125

'status': merge_status[0],

3126

'status': merge_status[0],

3126

'message': unicode(merge_status[1]),

3127

'message': unicode(merge_status[1]),

3127

},

3128

},

3128

'source': {

3129

'source': {

3129

'clone_url': pull_request.source_repo.clone_url(),

3130

'clone_url': pull_request.source_repo.clone_url(),

3130

'repository': pull_request.source_repo.repo_name,

3131

'repository': pull_request.source_repo.repo_name,

3131

'reference': {

3132

'reference': {

3132

'name': pull_request.source_ref_parts.name,

3133

'name': pull_request.source_ref_parts.name,

3133

'type': pull_request.source_ref_parts.type,

3134

'type': pull_request.source_ref_parts.type,

3134

'commit_id': pull_request.source_ref_parts.commit_id,

3135

'commit_id': pull_request.source_ref_parts.commit_id,

3135

},

3136

},

3136

},

3137

},

3137

'target': {

3138

'target': {

3138

'clone_url': pull_request.target_repo.clone_url(),

3139

'clone_url': pull_request.target_repo.clone_url(),

3139

'repository': pull_request.target_repo.repo_name,

3140

'repository': pull_request.target_repo.repo_name,

3140

'reference': {

3141

'reference': {

3141

'name': pull_request.target_ref_parts.name,

3142

'name': pull_request.target_ref_parts.name,

3142

'type': pull_request.target_ref_parts.type,

3143

'type': pull_request.target_ref_parts.type,

3143

'commit_id': pull_request.target_ref_parts.commit_id,

3144

'commit_id': pull_request.target_ref_parts.commit_id,

3144

},

3145

},

3145

},

3146

},

3147

'shadow': {

3148

# TODO: martinb: Unify generation/suffix of clone url.

3149

'clone_url': '{}/repository'.format(pull_request_url),

3150

},

3146

'author': pull_request.author.get_api_data(include_secrets=False,

3151

'author': pull_request.author.get_api_data(include_secrets=False,

3147

details='basic'),

3152

details='basic'),

3148

'reviewers': [

3153

'reviewers': [

3149

{

3154

{

3150

'user': reviewer.get_api_data(include_secrets=False,

3155

'user': reviewer.get_api_data(include_secrets=False,

3151

details='basic'),

3156

details='basic'),

3152

'reasons': reasons,

3157

'reasons': reasons,

3153

'review_status': st[0][1].status if st else 'not_reviewed',

3158

'review_status': st[0][1].status if st else 'not_reviewed',

3154

}

3159

}

3155

for reviewer, reasons, st in pull_request.reviewers_statuses()

3160

for reviewer, reasons, st in pull_request.reviewers_statuses()

3156

]

3161

]

3157

}

3162

}

3158

3163

3159

return data

3164

return data

3160

3165

3161

def __json__(self):

3166

def __json__(self):

3162

return {

3167

return {

3163

'revisions': self.revisions,

3168

'revisions': self.revisions,

3164

}

3169

}

3165

3170

3166

def calculated_review_status(self):

3171

def calculated_review_status(self):

3167

# TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html

3172

# TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html

3168

# because it's tricky on how to use ChangesetStatusModel from there

3173

# because it's tricky on how to use ChangesetStatusModel from there

3169

warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)

3174

warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)

3170

from rhodecode.model.changeset_status import ChangesetStatusModel

3175

from rhodecode.model.changeset_status import ChangesetStatusModel

3171

return ChangesetStatusModel().calculated_review_status(self)

3176

return ChangesetStatusModel().calculated_review_status(self)

3172

3177

3173

def reviewers_statuses(self):

3178

def reviewers_statuses(self):

3174

warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)

3179

warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)

3175

from rhodecode.model.changeset_status import ChangesetStatusModel

3180

from rhodecode.model.changeset_status import ChangesetStatusModel

3176

return ChangesetStatusModel().reviewers_statuses(self)

3181

return ChangesetStatusModel().reviewers_statuses(self)

3177

3182

3178

3183

3179

class PullRequestVersion(Base, _PullRequestBase):

3184

class PullRequestVersion(Base, _PullRequestBase):

3180

__tablename__ = 'pull_request_versions'

3185

__tablename__ = 'pull_request_versions'

3181

__table_args__ = (

3186

__table_args__ = (

3182

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3187

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3183

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3188

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3184

)

3189

)

3185

3190

3186

pull_request_version_id = Column(

3191

pull_request_version_id = Column(

3187

'pull_request_version_id', Integer(), nullable=False, primary_key=True)

3192

'pull_request_version_id', Integer(), nullable=False, primary_key=True)

3188

pull_request_id = Column(

3193

pull_request_id = Column(

3189

'pull_request_id', Integer(),

3194

'pull_request_id', Integer(),

3190

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3195

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3191

pull_request = relationship('PullRequest')

3196

pull_request = relationship('PullRequest')

3192

3197

3193

def __repr__(self):

3198

def __repr__(self):

3194

if self.pull_request_version_id:

3199

if self.pull_request_version_id:

3195

return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id

3200

return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id

3196

else:

3201

else:

3197

return '<DB:PullRequestVersion at %#x>' % id(self)

3202

return '<DB:PullRequestVersion at %#x>' % id(self)

3198

3203

3199

3204

3200

class PullRequestReviewers(Base, BaseModel):

3205

class PullRequestReviewers(Base, BaseModel):

3201

__tablename__ = 'pull_request_reviewers'

3206

__tablename__ = 'pull_request_reviewers'

3202

__table_args__ = (

3207

__table_args__ = (

3203

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3208

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3204

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3209

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3205

)

3210

)

3206

3211

3207

def __init__(self, user=None, pull_request=None, reasons=None):

3212

def __init__(self, user=None, pull_request=None, reasons=None):

3208

self.user = user

3213

self.user = user

3209

self.pull_request = pull_request

3214

self.pull_request = pull_request

3210

self.reasons = reasons or []

3215

self.reasons = reasons or []

3211

3216

3212

@hybrid_property

3217

@hybrid_property

3213

def reasons(self):

3218

def reasons(self):

3214

if not self._reasons:

3219

if not self._reasons:

3215

return []

3220

return []

3216

return self._reasons

3221

return self._reasons

3217

3222

3218

@reasons.setter

3223

@reasons.setter

3219

def reasons(self, val):

3224

def reasons(self, val):

3220

val = val or []

3225

val = val or []

3221

if any(not isinstance(x, basestring) for x in val):

3226

if any(not isinstance(x, basestring) for x in val):

3222

raise Exception('invalid reasons type, must be list of strings')

3227

raise Exception('invalid reasons type, must be list of strings')

3223

self._reasons = val

3228

self._reasons = val

3224

3229

3225

pull_requests_reviewers_id = Column(

3230

pull_requests_reviewers_id = Column(

3226

'pull_requests_reviewers_id', Integer(), nullable=False,

3231

'pull_requests_reviewers_id', Integer(), nullable=False,

3227

primary_key=True)

3232

primary_key=True)

3228

pull_request_id = Column(

3233

pull_request_id = Column(

3229

"pull_request_id", Integer(),

3234

"pull_request_id", Integer(),

3230

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3235

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3231

user_id = Column(

3236

user_id = Column(

3232

"user_id", Integer(), ForeignKey('users.user_id'), nullable=True)

3237

"user_id", Integer(), ForeignKey('users.user_id'), nullable=True)

3233

_reasons = Column(

3238

_reasons = Column(

3234

'reason', MutationList.as_mutable(

3239

'reason', MutationList.as_mutable(

3235

JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))

3240

JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))

3236

3241

3237

user = relationship('User')

3242

user = relationship('User')

3238

pull_request = relationship('PullRequest')

3243

pull_request = relationship('PullRequest')

3239

3244

3240

3245

3241

class Notification(Base, BaseModel):

3246

class Notification(Base, BaseModel):

3242

__tablename__ = 'notifications'

3247

__tablename__ = 'notifications'

3243

__table_args__ = (

3248

__table_args__ = (

3244

Index('notification_type_idx', 'type'),

3249

Index('notification_type_idx', 'type'),

3245

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3250

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3246

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3251

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3247

)

3252

)

3248

3253

3249

TYPE_CHANGESET_COMMENT = u'cs_comment'

3254

TYPE_CHANGESET_COMMENT = u'cs_comment'

3250

TYPE_MESSAGE = u'message'

3255

TYPE_MESSAGE = u'message'

3251

TYPE_MENTION = u'mention'

3256

TYPE_MENTION = u'mention'

3252

TYPE_REGISTRATION = u'registration'

3257

TYPE_REGISTRATION = u'registration'

3253

TYPE_PULL_REQUEST = u'pull_request'

3258

TYPE_PULL_REQUEST = u'pull_request'

3254

TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

3259

TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

3255

3260

3256

notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

3261

notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

3257

subject = Column('subject', Unicode(512), nullable=True)

3262

subject = Column('subject', Unicode(512), nullable=True)

3258

body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)

3263

body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)

3259

created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

3264

created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

3260

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3265

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3261

type_ = Column('type', Unicode(255))

3266

type_ = Column('type', Unicode(255))

3262

3267

3263

created_by_user = relationship('User')

3268

created_by_user = relationship('User')

3264

notifications_to_users = relationship('UserNotification', lazy='joined',

3269

notifications_to_users = relationship('UserNotification', lazy='joined',

3265

cascade="all, delete, delete-orphan")

3270

cascade="all, delete, delete-orphan")

3266

3271

3267

@property

3272

@property

3268

def recipients(self):

3273

def recipients(self):

3269

return [x.user for x in UserNotification.query()\

3274

return [x.user for x in UserNotification.query()\

3270

.filter(UserNotification.notification == self)\

3275

.filter(UserNotification.notification == self)\

3271

.order_by(UserNotification.user_id.asc()).all()]

3276

.order_by(UserNotification.user_id.asc()).all()]

3272

3277

3273

@classmethod

3278

@classmethod

3274

def create(cls, created_by, subject, body, recipients, type_=None):

3279

def create(cls, created_by, subject, body, recipients, type_=None):

3275

if type_ is None:

3280

if type_ is None:

3276

type_ = Notification.TYPE_MESSAGE

3281

type_ = Notification.TYPE_MESSAGE

3277

3282

3278

notification = cls()

3283

notification = cls()

3279

notification.created_by_user = created_by

3284

notification.created_by_user = created_by

3280

notification.subject = subject

3285

notification.subject = subject

3281

notification.body = body

3286

notification.body = body

3282

notification.type_ = type_

3287

notification.type_ = type_

3283

notification.created_on = datetime.datetime.now()

3288

notification.created_on = datetime.datetime.now()

3284

3289

3285

for u in recipients:

3290

for u in recipients:

3286

assoc = UserNotification()

3291

assoc = UserNotification()

3287

assoc.notification = notification

3292

assoc.notification = notification

3288

3293

3289

# if created_by is inside recipients mark his notification

3294

# if created_by is inside recipients mark his notification

3290

# as read

3295

# as read

3291

if u.user_id == created_by.user_id:

3296

if u.user_id == created_by.user_id:

3292

assoc.read = True

3297

assoc.read = True

3293

3298

3294

u.notifications.append(assoc)

3299

u.notifications.append(assoc)

3295

Session().add(notification)

3300

Session().add(notification)

3296

3301

3297

return notification

3302

return notification

3298

3303

3299

@property

3304

@property

3300

def description(self):

3305

def description(self):

3301

from rhodecode.model.notification import NotificationModel

3306

from rhodecode.model.notification import NotificationModel

3302

return NotificationModel().make_description(self)

3307

return NotificationModel().make_description(self)

3303

3308

3304

3309

3305

class UserNotification(Base, BaseModel):

3310

class UserNotification(Base, BaseModel):

3306

__tablename__ = 'user_to_notification'

3311

__tablename__ = 'user_to_notification'

3307

__table_args__ = (

3312

__table_args__ = (

3308

UniqueConstraint('user_id', 'notification_id'),

3313

UniqueConstraint('user_id', 'notification_id'),

3309

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3314

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3310

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3315

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3311

)

3316

)

3312

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

3317

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

3313

notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

3318

notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

3314

read = Column('read', Boolean, default=False)

3319

read = Column('read', Boolean, default=False)

3315

sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

3320

sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

3316

3321

3317

user = relationship('User', lazy="joined")

3322

user = relationship('User', lazy="joined")

3318

notification = relationship('Notification', lazy="joined",

3323

notification = relationship('Notification', lazy="joined",

3319

order_by=lambda: Notification.created_on.desc(),)

3324

order_by=lambda: Notification.created_on.desc(),)

3320

3325

3321

def mark_as_read(self):

3326

def mark_as_read(self):

3322

self.read = True

3327

self.read = True

3323

Session().add(self)

3328

Session().add(self)

3324

3329

3325

3330

3326

class Gist(Base, BaseModel):

3331

class Gist(Base, BaseModel):

3327

__tablename__ = 'gists'

3332

__tablename__ = 'gists'

3328

__table_args__ = (

3333

__table_args__ = (

3329

Index('g_gist_access_id_idx', 'gist_access_id'),

3334

Index('g_gist_access_id_idx', 'gist_access_id'),

3330

Index('g_created_on_idx', 'created_on'),

3335

Index('g_created_on_idx', 'created_on'),

3331

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3336

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3332

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3337

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3333

)

3338

)

3334

GIST_PUBLIC = u'public'

3339

GIST_PUBLIC = u'public'

3335

GIST_PRIVATE = u'private'

3340

GIST_PRIVATE = u'private'

3336

DEFAULT_FILENAME = u'gistfile1.txt'

3341

DEFAULT_FILENAME = u'gistfile1.txt'

3337

3342

3338

ACL_LEVEL_PUBLIC = u'acl_public'

3343

ACL_LEVEL_PUBLIC = u'acl_public'

3339

ACL_LEVEL_PRIVATE = u'acl_private'

3344

ACL_LEVEL_PRIVATE = u'acl_private'

3340

3345

3341

gist_id = Column('gist_id', Integer(), primary_key=True)

3346

gist_id = Column('gist_id', Integer(), primary_key=True)

3342

gist_access_id = Column('gist_access_id', Unicode(250))

3347

gist_access_id = Column('gist_access_id', Unicode(250))

3343

gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

3348

gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

3344

gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)

3349

gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)

3345

gist_expires = Column('gist_expires', Float(53), nullable=False)

3350

gist_expires = Column('gist_expires', Float(53), nullable=False)

3346

gist_type = Column('gist_type', Unicode(128), nullable=False)

3351

gist_type = Column('gist_type', Unicode(128), nullable=False)

3347

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3352

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3348

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3353

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3349

acl_level = Column('acl_level', Unicode(128), nullable=True)

3354

acl_level = Column('acl_level', Unicode(128), nullable=True)

3350

3355

3351

owner = relationship('User')

3356

owner = relationship('User')

3352

3357

3353

def __repr__(self):

3358

def __repr__(self):

3354

return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

3359

return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

3355

3360

3356

@classmethod

3361

@classmethod

3357

def get_or_404(cls, id_):

3362

def get_or_404(cls, id_):

3358

res = cls.query().filter(cls.gist_access_id == id_).scalar()

3363

res = cls.query().filter(cls.gist_access_id == id_).scalar()

3359

if not res:

3364

if not res:

3360

raise HTTPNotFound

3365

raise HTTPNotFound

3361

return res

3366

return res

3362

3367

3363

@classmethod

3368

@classmethod

3364

def get_by_access_id(cls, gist_access_id):

3369

def get_by_access_id(cls, gist_access_id):

3365

return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

3370

return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

3366

3371

3367

def gist_url(self):

3372

def gist_url(self):

3368

import rhodecode

3373

import rhodecode

3369

alias_url = rhodecode.CONFIG.get('gist_alias_url')

3374

alias_url = rhodecode.CONFIG.get('gist_alias_url')

3370

if alias_url:

3375

if alias_url:

3371

return alias_url.replace('{gistid}', self.gist_access_id)

3376

return alias_url.replace('{gistid}', self.gist_access_id)

3372

3377

3373

return url('gist', gist_id=self.gist_access_id, qualified=True)

3378

return url('gist', gist_id=self.gist_access_id, qualified=True)

3374

3379

3375

@classmethod

3380

@classmethod

3376

def base_path(cls):

3381

def base_path(cls):

3377

"""

3382

"""

3378

Returns base path when all gists are stored

3383

Returns base path when all gists are stored

3379

3384

3380

:param cls:

3385

:param cls:

3381

"""

3386

"""

3382

from rhodecode.model.gist import GIST_STORE_LOC

3387

from rhodecode.model.gist import GIST_STORE_LOC

3383

q = Session().query(RhodeCodeUi)\

3388

q = Session().query(RhodeCodeUi)\

3384

.filter(RhodeCodeUi.ui_key == URL_SEP)

3389

.filter(RhodeCodeUi.ui_key == URL_SEP)

3385

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

3390

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

3386

return os.path.join(q.one().ui_value, GIST_STORE_LOC)

3391

return os.path.join(q.one().ui_value, GIST_STORE_LOC)

3387

3392

3388

def get_api_data(self):

3393

def get_api_data(self):

3389

"""

3394

"""

3390

Common function for generating gist related data for API

3395

Common function for generating gist related data for API

3391

"""

3396

"""

3392

gist = self

3397

gist = self

3393

data = {

3398

data = {

3394

'gist_id': gist.gist_id,

3399

'gist_id': gist.gist_id,

3395

'type': gist.gist_type,

3400

'type': gist.gist_type,

3396

'access_id': gist.gist_access_id,

3401

'access_id': gist.gist_access_id,

3397

'description': gist.gist_description,

3402

'description': gist.gist_description,

3398

'url': gist.gist_url(),

3403

'url': gist.gist_url(),

3399

'expires': gist.gist_expires,

3404

'expires': gist.gist_expires,

3400

'created_on': gist.created_on,

3405

'created_on': gist.created_on,

3401

'modified_at': gist.modified_at,

3406

'modified_at': gist.modified_at,

3402

'content': None,

3407

'content': None,

3403

'acl_level': gist.acl_level,

3408

'acl_level': gist.acl_level,

3404

}

3409

}

3405

return data

3410

return data

3406

3411

3407

def __json__(self):

3412

def __json__(self):

3408

data = dict(

3413

data = dict(

3409

)

3414

)

3410

data.update(self.get_api_data())

3415

data.update(self.get_api_data())

3411

return data

3416

return data

3412

# SCM functions

3417

# SCM functions

3413

3418

3414

def scm_instance(self, **kwargs):

3419

def scm_instance(self, **kwargs):

3415

full_repo_path = os.path.join(self.base_path(), self.gist_access_id)

3420

full_repo_path = os.path.join(self.base_path(), self.gist_access_id)

3416

return get_vcs_instance(

3421

return get_vcs_instance(

3417

repo_path=safe_str(full_repo_path), create=False)

3422

repo_path=safe_str(full_repo_path), create=False)

3418

3423

3419

3424

3420

class DbMigrateVersion(Base, BaseModel):

3425

class DbMigrateVersion(Base, BaseModel):

3421

__tablename__ = 'db_migrate_version'

3426

__tablename__ = 'db_migrate_version'

3422

__table_args__ = (

3427

__table_args__ = (

3423

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3428

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3424

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3429

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3425

)

3430

)

3426

repository_id = Column('repository_id', String(250), primary_key=True)

3431

repository_id = Column('repository_id', String(250), primary_key=True)

3427

repository_path = Column('repository_path', Text)

3432

repository_path = Column('repository_path', Text)

3428

version = Column('version', Integer)

3433

version = Column('version', Integer)

3429

3434

3430

3435

3431

class ExternalIdentity(Base, BaseModel):

3436

class ExternalIdentity(Base, BaseModel):

3432

__tablename__ = 'external_identities'

3437

__tablename__ = 'external_identities'

3433

__table_args__ = (

3438

__table_args__ = (

3434

Index('local_user_id_idx', 'local_user_id'),

3439

Index('local_user_id_idx', 'local_user_id'),

3435

Index('external_id_idx', 'external_id'),

3440

Index('external_id_idx', 'external_id'),

3436

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3441

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3437

'mysql_charset': 'utf8'})

3442

'mysql_charset': 'utf8'})

3438

3443

3439

external_id = Column('external_id', Unicode(255), default=u'',

3444

external_id = Column('external_id', Unicode(255), default=u'',

3440

primary_key=True)

3445

primary_key=True)

3441

external_username = Column('external_username', Unicode(1024), default=u'')

3446

external_username = Column('external_username', Unicode(1024), default=u'')

3442

local_user_id = Column('local_user_id', Integer(),

3447

local_user_id = Column('local_user_id', Integer(),

3443

ForeignKey('users.user_id'), primary_key=True)

3448

ForeignKey('users.user_id'), primary_key=True)

3444

provider_name = Column('provider_name', Unicode(255), default=u'',

3449

provider_name = Column('provider_name', Unicode(255), default=u'',

3445

primary_key=True)

3450

primary_key=True)

3446

access_token = Column('access_token', String(1024), default=u'')

3451

access_token = Column('access_token', String(1024), default=u'')

3447

alt_token = Column('alt_token', String(1024), default=u'')

3452

alt_token = Column('alt_token', String(1024), default=u'')

3448

token_secret = Column('token_secret', String(1024), default=u'')

3453

token_secret = Column('token_secret', String(1024), default=u'')

3449

3454

3450

@classmethod

3455

@classmethod

3451

def by_external_id_and_provider(cls, external_id, provider_name,

3456

def by_external_id_and_provider(cls, external_id, provider_name,

3452

local_user_id=None):

3457

local_user_id=None):

3453

"""

3458

"""

3454

Returns ExternalIdentity instance based on search params

3459

Returns ExternalIdentity instance based on search params

3455

3460

3456

:param external_id:

3461

:param external_id:

3457

:param provider_name:

3462

:param provider_name:

3458

:return: ExternalIdentity

3463

:return: ExternalIdentity

3459

"""

3464

"""

3460

query = cls.query()

3465

query = cls.query()

3461

query = query.filter(cls.external_id == external_id)

3466

query = query.filter(cls.external_id == external_id)

3462

query = query.filter(cls.provider_name == provider_name)

3467

query = query.filter(cls.provider_name == provider_name)

3463

if local_user_id:

3468

if local_user_id:

3464

query = query.filter(cls.local_user_id == local_user_id)

3469

query = query.filter(cls.local_user_id == local_user_id)

3465

return query.first()

3470

return query.first()

3466

3471

3467

@classmethod

3472

@classmethod

3468

def user_by_external_id_and_provider(cls, external_id, provider_name):

3473

def user_by_external_id_and_provider(cls, external_id, provider_name):

3469

"""

3474

"""

3470

Returns User instance based on search params

3475

Returns User instance based on search params

3471

3476

3472

:param external_id:

3477

:param external_id:

3473

:param provider_name:

3478

:param provider_name:

3474

:return: User

3479

:return: User

3475

"""

3480

"""

3476

query = User.query()

3481

query = User.query()

3477

query = query.filter(cls.external_id == external_id)

3482

query = query.filter(cls.external_id == external_id)

3478

query = query.filter(cls.provider_name == provider_name)

3483

query = query.filter(cls.provider_name == provider_name)

3479

query = query.filter(User.user_id == cls.local_user_id)

3484

query = query.filter(User.user_id == cls.local_user_id)

3480

return query.first()

3485

return query.first()

3481

3486

3482

@classmethod

3487

@classmethod

3483

def by_local_user_id(cls, local_user_id):

3488

def by_local_user_id(cls, local_user_id):

3484

"""

3489

"""

3485

Returns all tokens for user

3490

Returns all tokens for user

3486

3491

3487

:param local_user_id:

3492

:param local_user_id:

3488

:return: ExternalIdentity

3493

:return: ExternalIdentity

3489

"""

3494

"""

3490

query = cls.query()

3495

query = cls.query()

3491

query = query.filter(cls.local_user_id == local_user_id)

3496

query = query.filter(cls.local_user_id == local_user_id)

3492

return query

3497

return query

3493

3498

3494

3499

3495

class Integration(Base, BaseModel):

3500

class Integration(Base, BaseModel):

3496

__tablename__ = 'integrations'

3501

__tablename__ = 'integrations'

3497

__table_args__ = (

3502

__table_args__ = (

3498

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3503

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3499

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3504

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3500

)

3505

)

3501

3506

3502

integration_id = Column('integration_id', Integer(), primary_key=True)

3507

integration_id = Column('integration_id', Integer(), primary_key=True)

3503

integration_type = Column('integration_type', String(255))

3508

integration_type = Column('integration_type', String(255))

3504

enabled = Column('enabled', Boolean(), nullable=False)

3509

enabled = Column('enabled', Boolean(), nullable=False)

3505

name = Column('name', String(255), nullable=False)

3510

name = Column('name', String(255), nullable=False)

3506

child_repos_only = Column('child_repos_only', Boolean(), nullable=False,

3511

child_repos_only = Column('child_repos_only', Boolean(), nullable=False,

3507

default=False)

3512

default=False)

3508

3513

3509

settings = Column(

3514

settings = Column(

3510

'settings_json', MutationObj.as_mutable(

3515

'settings_json', MutationObj.as_mutable(

3511

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

3516

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

3512

repo_id = Column(

3517

repo_id = Column(

3513

'repo_id', Integer(), ForeignKey('repositories.repo_id'),

3518

'repo_id', Integer(), ForeignKey('repositories.repo_id'),

3514

nullable=True, unique=None, default=None)

3519

nullable=True, unique=None, default=None)

3515

repo = relationship('Repository', lazy='joined')

3520

repo = relationship('Repository', lazy='joined')

3516

3521

3517

repo_group_id = Column(

3522

repo_group_id = Column(

3518

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

3523

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

3519

nullable=True, unique=None, default=None)

3524

nullable=True, unique=None, default=None)

3520

repo_group = relationship('RepoGroup', lazy='joined')

3525

repo_group = relationship('RepoGroup', lazy='joined')

3521

3526

3522

@property

3527

@property

3523

def scope(self):

3528

def scope(self):

3524

if self.repo:

3529

if self.repo:

3525

return repr(self.repo)

3530

return repr(self.repo)

3526

if self.repo_group:

3531

if self.repo_group:

3527

if self.child_repos_only:

3532

if self.child_repos_only:

3528

return repr(self.repo_group) + ' (child repos only)'

3533

return repr(self.repo_group) + ' (child repos only)'

3529

else:

3534

else:

3530

return repr(self.repo_group) + ' (recursive)'

3535

return repr(self.repo_group) + ' (recursive)'

3531

if self.child_repos_only:

3536

if self.child_repos_only:

3532

return 'root_repos'

3537

return 'root_repos'

3533

return 'global'

3538

return 'global'

3534

3539

3535

def __repr__(self):

3540

def __repr__(self):

3536

return '<Integration(%r, %r)>' % (self.integration_type, self.scope)

3541

return '<Integration(%r, %r)>' % (self.integration_type, self.scope)

3537

3542

3538

3543

3539

class RepoReviewRuleUser(Base, BaseModel):

3544

class RepoReviewRuleUser(Base, BaseModel):

3540

__tablename__ = 'repo_review_rules_users'

3545

__tablename__ = 'repo_review_rules_users'

3541

__table_args__ = (

3546

__table_args__ = (

3542

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3547

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3543

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3548

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3544

)

3549

)

3545

repo_review_rule_user_id = Column(

3550

repo_review_rule_user_id = Column(

3546

'repo_review_rule_user_id', Integer(), primary_key=True)

3551

'repo_review_rule_user_id', Integer(), primary_key=True)

3547

repo_review_rule_id = Column("repo_review_rule_id",

3552

repo_review_rule_id = Column("repo_review_rule_id",

3548

Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

3553

Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

3549

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),

3554

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),

3550

nullable=False)

3555

nullable=False)

3551

user = relationship('User')

3556

user = relationship('User')

3552

3557

3553

3558

3554

class RepoReviewRuleUserGroup(Base, BaseModel):

3559

class RepoReviewRuleUserGroup(Base, BaseModel):

3555

__tablename__ = 'repo_review_rules_users_groups'

3560

__tablename__ = 'repo_review_rules_users_groups'

3556

__table_args__ = (

3561

__table_args__ = (

3557

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3562

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3558

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3563

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3559

)

3564

)

3560

repo_review_rule_users_group_id = Column(

3565

repo_review_rule_users_group_id = Column(

3561

'repo_review_rule_users_group_id', Integer(), primary_key=True)

3566

'repo_review_rule_users_group_id', Integer(), primary_key=True)

3562

repo_review_rule_id = Column("repo_review_rule_id",

3567

repo_review_rule_id = Column("repo_review_rule_id",

3563

Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

3568

Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

3564

users_group_id = Column("users_group_id", Integer(),

3569

users_group_id = Column("users_group_id", Integer(),

3565

ForeignKey('users_groups.users_group_id'), nullable=False)

3570

ForeignKey('users_groups.users_group_id'), nullable=False)

3566

users_group = relationship('UserGroup')

3571

users_group = relationship('UserGroup')

3567

3572

3568

3573

3569

class RepoReviewRule(Base, BaseModel):

3574

class RepoReviewRule(Base, BaseModel):

3570

__tablename__ = 'repo_review_rules'

3575

__tablename__ = 'repo_review_rules'

3571

__table_args__ = (

3576

__table_args__ = (

3572

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3577

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3573

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3578

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

3574

)

3579

)

3575

3580

3576

repo_review_rule_id = Column(

3581

repo_review_rule_id = Column(

3577

'repo_review_rule_id', Integer(), primary_key=True)

3582

'repo_review_rule_id', Integer(), primary_key=True)

3578

repo_id = Column(

3583

repo_id = Column(

3579

"repo_id", Integer(), ForeignKey('repositories.repo_id'))

3584

"repo_id", Integer(), ForeignKey('repositories.repo_id'))

3580

repo = relationship('Repository', backref='review_rules')

3585

repo = relationship('Repository', backref='review_rules')

3581

3586

3582

_branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),

3587

_branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),

3583

default=u'*') # glob

3588

default=u'*') # glob

3584

_file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),

3589

_file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),

3585

default=u'*') # glob

3590

default=u'*') # glob

3586

3591

3587

use_authors_for_review = Column("use_authors_for_review", Boolean(),

3592

use_authors_for_review = Column("use_authors_for_review", Boolean(),

3588

nullable=False, default=False)

3593

nullable=False, default=False)

3589

rule_users = relationship('RepoReviewRuleUser')

3594

rule_users = relationship('RepoReviewRuleUser')

3590

rule_user_groups = relationship('RepoReviewRuleUserGroup')

3595

rule_user_groups = relationship('RepoReviewRuleUserGroup')

3591

3596

3592

@hybrid_property

3597

@hybrid_property

3593

def branch_pattern(self):

3598

def branch_pattern(self):

3594

return self._branch_pattern or '*'

3599

return self._branch_pattern or '*'

3595

3600

3596

def _validate_glob(self, value):

3601

def _validate_glob(self, value):

3597

re.compile('^' + glob2re(value) + '$')

3602

re.compile('^' + glob2re(value) + '$')

3598

3603

3599

@branch_pattern.setter

3604

@branch_pattern.setter

3600

def branch_pattern(self, value):

3605

def branch_pattern(self, value):

3601

self._validate_glob(value)

3606

self._validate_glob(value)

3602

self._branch_pattern = value or '*'

3607

self._branch_pattern = value or '*'

3603

3608

3604

@hybrid_property

3609

@hybrid_property

3605

def file_pattern(self):

3610

def file_pattern(self):

3606

return self._file_pattern or '*'

3611

return self._file_pattern or '*'

3607

3612

3608

@file_pattern.setter

3613

@file_pattern.setter

3609

def file_pattern(self, value):

3614

def file_pattern(self, value):

3610

self._validate_glob(value)

3615

self._validate_glob(value)

3611

self._file_pattern = value or '*'

3616

self._file_pattern = value or '*'

3612

3617

3613

def matches(self, branch, files_changed):

3618

def matches(self, branch, files_changed):

3614

"""

3619

"""

3615

Check if this review rule matches a branch/files in a pull request

3620

Check if this review rule matches a branch/files in a pull request

3616

3621

3617

:param branch: branch name for the commit

3622

:param branch: branch name for the commit

3618

:param files_changed: list of file paths changed in the pull request

3623

:param files_changed: list of file paths changed in the pull request

3619

"""

3624

"""

3620

3625

3621

branch = branch or ''

3626

branch = branch or ''

3622

files_changed = files_changed or []

3627

files_changed = files_changed or []

3623

3628

3624

branch_matches = True

3629

branch_matches = True

3625

if branch:

3630

if branch:

3626

branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')

3631

branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')

3627

branch_matches = bool(branch_regex.search(branch))

3632

branch_matches = bool(branch_regex.search(branch))

3628

3633

3629

files_matches = True

3634

files_matches = True

3630

if self.file_pattern != '*':

3635

if self.file_pattern != '*':

3631

files_matches = False

3636

files_matches = False

3632

file_regex = re.compile(glob2re(self.file_pattern))

3637

file_regex = re.compile(glob2re(self.file_pattern))

3633

for filename in files_changed:

3638

for filename in files_changed:

3634

if file_regex.search(filename):

3639

if file_regex.search(filename):

3635

files_matches = True

3640

files_matches = True

3636

break

3641

break

3637

3642

3638

return branch_matches and files_matches

3643

return branch_matches and files_matches

3639

3644

3640

@property

3645

@property

3641

def review_users(self):

3646

def review_users(self):

3642

""" Returns the users which this rule applies to """

3647

""" Returns the users which this rule applies to """

3643

3648

3644

users = set()

3649

users = set()

3645

users |= set([

3650

users |= set([

3646

rule_user.user for rule_user in self.rule_users

3651

rule_user.user for rule_user in self.rule_users

3647

if rule_user.user.active])

3652

if rule_user.user.active])

3648

users |= set(

3653

users |= set(

3649

member.user

3654

member.user

3650

for rule_user_group in self.rule_user_groups

3655

for rule_user_group in self.rule_user_groups

3651

for member in rule_user_group.users_group.members

3656

for member in rule_user_group.users_group.members

3652

if member.user.active

3657

if member.user.active

3653

)

3658

)

3654

return users

3659

return users

3655

3660

3656

def __repr__(self):

3661

def __repr__(self):

3657

return '<RepoReviewerRule(id=%r, repo=%r)>' % (

3662

return '<RepoReviewerRule(id=%r, repo=%r)>' % (

3658

self.repo_review_rule_id, self.repo)

3663

self.repo_review_rule_id, self.repo)

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             # -*- coding: utf-8 -*-
             # Copyright (C) 2011-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             import logging
             from rhodecode.api import jsonrpc_method, JSONRPCError
             from rhodecode.api.utils import (
                 has_superadmin_permission, Optional, OAttr, get_repo_or_error,
                 get_pull_request_or_error, get_commit_or_error, get_user_or_error,
                 has_repo_permissions, resolve_ref_or_error)
             from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
             from rhodecode.lib.base import vcs_operation_context
             from rhodecode.lib.utils2 import str2bool
             from rhodecode.model.changeset_status import ChangesetStatusModel
             from rhodecode.model.comment import ChangesetCommentsModel
             from rhodecode.model.db import Session, ChangesetStatus
             from rhodecode.model.pull_request import PullRequestModel
             from rhodecode.model.settings import SettingsModel
             log = logging.getLogger(__name__)
             @jsonrpc_method()
             def get_pull_request(request, apiuser, repoid, pullrequestid):
                 """
                 Get a pull request based on the given ID.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: Repository name or repository ID from where the pull
                     request was opened.
                 :type repoid: str or int
                 :param pullrequestid: ID of the requested pull request.
                 :type pullrequestid: int
                 Example output:
                 .. code-block:: bash
                   "id": <id_given_in_input>,
                   "result":
                     {
                         "pull_request_id":   "<pull_request_id>",
                         "url":               "<url>",
                         "title":             "<title>",
                         "description":       "<description>",
                         "status" :           "<status>",
                         "created_on":        "<date_time_created>",
                         "updated_on":        "<date_time_updated>",
                         "commit_ids":        [
                                                  ...
                                                  "<commit_id>",
                                                  "<commit_id>",
                                                  ...
                                              ],
                         "review_status":    "<review_status>",
                         "mergeable":         {
                                                  "status":  "<bool>",
                                                  "message": "<message>",
                                              },
                         "source":            {
                                                  "clone_url":     "<clone_url>",
                                                  "repository":    "<repository_name>",
                                                  "reference":
                                                  {
                                                      "name":      "<name>",
                                                      "type":      "<type>",
                                                      "commit_id": "<commit_id>",
                                                  }
                                              },
                         "target":            {
                                                  "clone_url":   "<clone_url>",
                                                  "repository":    "<repository_name>",
                                                  "reference":
                                                  {
                                                      "name":      "<name>",
                                                      "type":      "<type>",
                                                      "commit_id": "<commit_id>",
                                                  }
                                              },
+                        "shadow":            {
+                                                 "clone_url":   "<clone_url>",
+                                             },
                        "author":             <user_obj>,
                        "reviewers":          [
                                                  ...
                                                  {
                                                     "user":          "<user_obj>",
                                                     "review_status": "<review_status>",
                                                  }
                                                  ...
                                              ]
                     },
                    "error": null
                 """
                 get_repo_or_error(repoid)
                 pull_request = get_pull_request_or_error(pullrequestid)
                 if not PullRequestModel().check_user_read(
                         pull_request, apiuser, api=True):
                     raise JSONRPCError('repository `%s` does not exist' % (repoid,))
                 data = pull_request.get_api_data()
                 return data
             @jsonrpc_method()
             def get_pull_requests(request, apiuser, repoid, status=Optional('new')):
                 """
                 Get all pull requests from the repository specified in `repoid`.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: Repository name or repository ID.
                 :type repoid: str or int
                 :param status: Only return pull requests with the specified status.
                     Valid options are.
                     * ``new`` (default)
                     * ``open``
                     * ``closed``
                 :type status: str
                 Example output:
                 .. code-block:: bash
                   "id": <id_given_in_input>,
                   "result":
                     [
                         ...
                         {
                             "pull_request_id":   "<pull_request_id>",
                             "url":               "<url>",
                             "title" :            "<title>",
                             "description":       "<description>",
                             "status":            "<status>",
                             "created_on":        "<date_time_created>",
                             "updated_on":        "<date_time_updated>",
                             "commit_ids":        [
                                                      ...
                                                      "<commit_id>",
                                                      "<commit_id>",
                                                      ...
                                                  ],
                             "review_status":    "<review_status>",
                             "mergeable":         {
                                                     "status":      "<bool>",
                                                     "message:      "<message>",
                                                  },
                             "source":            {
                                                      "clone_url":     "<clone_url>",
                                                      "reference":
                                                      {
                                                          "name":      "<name>",
                                                          "type":      "<type>",
                                                          "commit_id": "<commit_id>",
                                                      }
                                                  },
                             "target":            {
                                                      "clone_url":   "<clone_url>",
                                                      "reference":
                                                      {
                                                          "name":      "<name>",
                                                          "type":      "<type>",
                                                          "commit_id": "<commit_id>",
                                                      }
                                                  },
+                            "shadow":            {
+                                                     "clone_url":   "<clone_url>",
+                                                 },
                            "author":             <user_obj>,
                            "reviewers":          [
                                                      ...
                                                      {
                                                         "user":          "<user_obj>",
                                                         "review_status": "<review_status>",
                                                      }
                                                      ...
                                                  ]
                         }
                         ...
                     ],
                   "error": null
                 """
                 repo = get_repo_or_error(repoid)
                 if not has_superadmin_permission(apiuser):
                     _perms = (
                         'repository.admin', 'repository.write', 'repository.read',)
                     has_repo_permissions(apiuser, repoid, repo, _perms)
                 status = Optional.extract(status)
                 pull_requests = PullRequestModel().get_all(repo, statuses=[status])
                 data = [pr.get_api_data() for pr in pull_requests]
                 return data
             @jsonrpc_method()
             def merge_pull_request(request, apiuser, repoid, pullrequestid,
                                    userid=Optional(OAttr('apiuser'))):
                 """
                 Merge the pull request specified by `pullrequestid` into its target
                 repository.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: The Repository name or repository ID of the
                     target repository to which the |pr| is to be merged.
                 :type repoid: str or int
                 :param pullrequestid: ID of the pull request which shall be merged.
                 :type pullrequestid: int
                 :param userid: Merge the pull request as this user.
                 :type userid: Optional(str or int)
                 Example output:
                 .. code-block:: bash
                   "id": <id_given_in_input>,
                   "result":
                     {
                         "executed":         "<bool>",
                         "failure_reason":   "<int>",
                         "merge_commit_id":  "<merge_commit_id>",
                         "possible":         "<bool>"
                     },
                   "error": null
                 """
                 repo = get_repo_or_error(repoid)
                 if not isinstance(userid, Optional):
                     if (has_superadmin_permission(apiuser) or
                             HasRepoPermissionAnyApi('repository.admin')(
                                 user=apiuser, repo_name=repo.repo_name)):
                         apiuser = get_user_or_error(userid)
                     else:
                         raise JSONRPCError('userid is not the same as your user')
                 pull_request = get_pull_request_or_error(pullrequestid)
                 if not PullRequestModel().check_user_merge(
                         pull_request, apiuser, api=True):
                     raise JSONRPCError('repository `%s` does not exist' % (repoid,))
                 if pull_request.is_closed():
                     raise JSONRPCError(
                         'pull request `%s` merge failed, pull request is closed' % (
                             pullrequestid,))
                 target_repo = pull_request.target_repo
                 extras = vcs_operation_context(
                     request.environ, repo_name=target_repo.repo_name,
                     username=apiuser.username, action='push',
                     scm=target_repo.repo_type)
                 data = PullRequestModel().merge(pull_request, apiuser, extras=extras)
                 if data.executed:
                     PullRequestModel().close_pull_request(
                         pull_request.pull_request_id, apiuser)
                     Session().commit()
                 return data
             @jsonrpc_method()
             def close_pull_request(request, apiuser, repoid, pullrequestid,
                                    userid=Optional(OAttr('apiuser'))):
                 """
                 Close the pull request specified by `pullrequestid`.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: Repository name or repository ID to which the pull
                     request belongs.
                 :type repoid: str or int
                 :param pullrequestid: ID of the pull request to be closed.
                 :type pullrequestid: int
                 :param userid: Close the pull request as this user.
                 :type userid: Optional(str or int)
                 Example output:
                 .. code-block:: bash
                   "id": <id_given_in_input>,
                   "result":
                     {
                         "pull_request_id":  "<int>",
                         "closed":           "<bool>"
                     },
                   "error": null
                 """
                 repo = get_repo_or_error(repoid)
                 if not isinstance(userid, Optional):
                     if (has_superadmin_permission(apiuser) or
                             HasRepoPermissionAnyApi('repository.admin')(
                                 user=apiuser, repo_name=repo.repo_name)):
                         apiuser = get_user_or_error(userid)
                     else:
                         raise JSONRPCError('userid is not the same as your user')
                 pull_request = get_pull_request_or_error(pullrequestid)
                 if not PullRequestModel().check_user_update(
                         pull_request, apiuser, api=True):
                     raise JSONRPCError(
                         'pull request `%s` close failed, no permission to close.' % (
                             pullrequestid,))
                 if pull_request.is_closed():
                     raise JSONRPCError(
                         'pull request `%s` is already closed' % (pullrequestid,))
                 PullRequestModel().close_pull_request(
                     pull_request.pull_request_id, apiuser)
                 Session().commit()
                 data = {
                     'pull_request_id': pull_request.pull_request_id,
                     'closed': True,
                 }
                 return data
             @jsonrpc_method()
             def comment_pull_request(request, apiuser, repoid, pullrequestid,
                                      message=Optional(None), status=Optional(None),
                                      userid=Optional(OAttr('apiuser'))):
                 """
                 Comment on the pull request specified with the `pullrequestid`,
                 in the |repo| specified by the `repoid`, and optionally change the
                 review status.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: The repository name or repository ID.
                 :type repoid: str or int
                 :param pullrequestid: The pull request ID.
                 :type pullrequestid: int
                 :param message: The text content of the comment.
                 :type message: str
                 :param status: (**Optional**) Set the approval status of the pull
                     request. Valid options are:
                     * not_reviewed
                     * approved
                     * rejected
                     * under_review
                 :type status: str
                 :param userid: Comment on the pull request as this user
                 :type userid: Optional(str or int)
                 Example output:
                 .. code-block:: bash
                   id : <id_given_in_input>
                   result :
                     {
                         "pull_request_id":  "<Integer>",
                         "comment_id":       "<Integer>"
                     }
                   error :  null
                 """
                 repo = get_repo_or_error(repoid)
                 if not isinstance(userid, Optional):
                     if (has_superadmin_permission(apiuser) or
                             HasRepoPermissionAnyApi('repository.admin')(
                                 user=apiuser, repo_name=repo.repo_name)):
                         apiuser = get_user_or_error(userid)
                     else:
                         raise JSONRPCError('userid is not the same as your user')
                 pull_request = get_pull_request_or_error(pullrequestid)
                 if not PullRequestModel().check_user_read(
                         pull_request, apiuser, api=True):
                     raise JSONRPCError('repository `%s` does not exist' % (repoid,))
                 message = Optional.extract(message)
                 status = Optional.extract(status)
                 if not message and not status:
                     raise JSONRPCError('message and status parameter missing')
                 if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
                         status is not None):
                     raise JSONRPCError('unknown comment status`%s`' % status)
                 allowed_to_change_status = PullRequestModel().check_user_change_status(
                     pull_request, apiuser)
                 text = message
                 if status and allowed_to_change_status:
                     st_message = (('Status change %(transition_icon)s %(status)s')
                                   % {'transition_icon': '>',
                                      'status': ChangesetStatus.get_status_lbl(status)})
                     text = message or st_message
                 rc_config = SettingsModel().get_all_settings()
                 renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
                 comment = ChangesetCommentsModel().create(
                     text=text,
                     repo=pull_request.target_repo.repo_id,
                     user=apiuser.user_id,
                     pull_request=pull_request.pull_request_id,
                     f_path=None,
                     line_no=None,
                     status_change=(ChangesetStatus.get_status_lbl(status)
                                    if status and allowed_to_change_status else None),
                     status_change_type=(status
                                         if status and allowed_to_change_status else None),
                     closing_pr=False,
                     renderer=renderer
                 )
                 if allowed_to_change_status and status:
                     ChangesetStatusModel().set_status(
                         pull_request.target_repo.repo_id,
                         status,
                         apiuser.user_id,
                         comment,
                         pull_request=pull_request.pull_request_id
                     )
                     Session().flush()
                 Session().commit()
                 data = {
                     'pull_request_id': pull_request.pull_request_id,
                     'comment_id': comment.comment_id,
                     'status': status
                 }
                 return data
             @jsonrpc_method()
             def create_pull_request(
                     request, apiuser, source_repo, target_repo, source_ref, target_ref,
                     title, description=Optional(''), reviewers=Optional(None)):
                 """
                 Creates a new pull request.
                 Accepts refs in the following formats:
                     * branch:<branch_name>:<sha>
                     * branch:<branch_name>
                     * bookmark:<bookmark_name>:<sha> (Mercurial only)
                     * bookmark:<bookmark_name> (Mercurial only)
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param source_repo: Set the source repository name.
                 :type source_repo: str
                 :param target_repo: Set the target repository name.
                 :type target_repo: str
                 :param source_ref: Set the source ref name.
                 :type source_ref: str
                 :param target_ref: Set the target ref name.
                 :type target_ref: str
                 :param title: Set the pull request title.
                 :type title: str
                 :param description: Set the pull request description.
                 :type description: Optional(str)
                 :param reviewers: Set the new pull request reviewers list.
                 :type reviewers: Optional(list)
                     Accepts username strings or objects of the format:
                     {
                         'username': 'nick', 'reasons': ['original author']
                     }
                 """
                 source = get_repo_or_error(source_repo)
                 target = get_repo_or_error(target_repo)
                 if not has_superadmin_permission(apiuser):
                     _perms = ('repository.admin', 'repository.write', 'repository.read',)
                     has_repo_permissions(apiuser, source_repo, source, _perms)
                 full_source_ref = resolve_ref_or_error(source_ref, source)
                 full_target_ref = resolve_ref_or_error(target_ref, target)
                 source_commit = get_commit_or_error(full_source_ref, source)
                 target_commit = get_commit_or_error(full_target_ref, target)
                 source_scm = source.scm_instance()
                 target_scm = target.scm_instance()
                 commit_ranges = target_scm.compare(
                     target_commit.raw_id, source_commit.raw_id, source_scm,
                     merge=True, pre_load=[])
                 ancestor = target_scm.get_common_ancestor(
                     target_commit.raw_id, source_commit.raw_id, source_scm)
                 if not commit_ranges:
                     raise JSONRPCError('no commits found')
                 if not ancestor:
                     raise JSONRPCError('no common ancestor found')
                 reviewer_objects = Optional.extract(reviewers) or []
                 if not isinstance(reviewer_objects, list):
                     raise JSONRPCError('reviewers should be specified as a list')
                 reviewers_reasons = []
                 for reviewer_object in reviewer_objects:
                     reviewer_reasons = []
                     if isinstance(reviewer_object, (basestring, int)):
                         reviewer_username = reviewer_object
                     else:
                         reviewer_username = reviewer_object['username']
                         reviewer_reasons = reviewer_object.get('reasons', [])
                     user = get_user_or_error(reviewer_username)
                     reviewers_reasons.append((user.user_id, reviewer_reasons))
                 pull_request_model = PullRequestModel()
                 pull_request = pull_request_model.create(
                     created_by=apiuser.user_id,
                     source_repo=source_repo,
                     source_ref=full_source_ref,
                     target_repo=target_repo,
                     target_ref=full_target_ref,
                     revisions=reversed(
                         [commit.raw_id for commit in reversed(commit_ranges)]),
                     reviewers=reviewers_reasons,
                     title=title,
                     description=Optional.extract(description)
                 )
                 Session().commit()
                 data = {
                     'msg': 'Created new pull request `{}`'.format(title),
                     'pull_request_id': pull_request.pull_request_id,
                 }
                 return data
             @jsonrpc_method()
             def update_pull_request(
                     request, apiuser, repoid, pullrequestid, title=Optional(''),
                     description=Optional(''), reviewers=Optional(None),
                     update_commits=Optional(None), close_pull_request=Optional(None)):
                 """
                 Updates a pull request.
                 :param apiuser: This is filled automatically from the |authtoken|.
                 :type apiuser: AuthUser
                 :param repoid: The repository name or repository ID.
                 :type repoid: str or int
                 :param pullrequestid: The pull request ID.
                 :type pullrequestid: int
                 :param title: Set the pull request title.
                 :type title: str
                 :param description: Update pull request description.
                 :type description: Optional(str)
                 :param reviewers: Update pull request reviewers list with new value.
                 :type reviewers: Optional(list)
                 :param update_commits: Trigger update of commits for this pull request
                 :type: update_commits: Optional(bool)
                 :param close_pull_request: Close this pull request with rejected state
                 :type: close_pull_request: Optional(bool)
                 Example output:
                 .. code-block:: bash
                   id : <id_given_in_input>
                   result :
                     {
                         "msg": "Updated pull request `63`",
                         "pull_request": <pull_request_object>,
                         "updated_reviewers": {
                           "added": [
                             "username"
                           ],
                           "removed": []
                         },
                         "updated_commits": {
                           "added": [
                             "<sha1_hash>"
                           ],
                           "common": [
                             "<sha1_hash>",
                             "<sha1_hash>",
                           ],
                           "removed": []
                         }
                     }
                   error :  null
                 """
                 repo = get_repo_or_error(repoid)
                 pull_request = get_pull_request_or_error(pullrequestid)
                 if not PullRequestModel().check_user_update(
                         pull_request, apiuser, api=True):
                     raise JSONRPCError(
                         'pull request `%s` update failed, no permission to update.' % (
                             pullrequestid,))
                 if pull_request.is_closed():
                     raise JSONRPCError(
                         'pull request `%s` update failed, pull request is closed' % (
                             pullrequestid,))
                 reviewer_objects = Optional.extract(reviewers) or []
                 if not isinstance(reviewer_objects, list):
                     raise JSONRPCError('reviewers should be specified as a list')
                 reviewers_reasons = []
                 reviewer_ids = set()
                 for reviewer_object in reviewer_objects:
                     reviewer_reasons = []
                     if isinstance(reviewer_object, (int, basestring)):
                         reviewer_username = reviewer_object
                     else:
                         reviewer_username = reviewer_object['username']
                         reviewer_reasons = reviewer_object.get('reasons', [])
                     user = get_user_or_error(reviewer_username)
                     reviewer_ids.add(user.user_id)
                     reviewers_reasons.append((user.user_id, reviewer_reasons))
                 title = Optional.extract(title)
                 description = Optional.extract(description)
                 if title or description:
                     PullRequestModel().edit(
                         pull_request, title or pull_request.title,
                         description or pull_request.description)
                     Session().commit()
                 commit_changes = {"added": [], "common": [], "removed": []}
                 if str2bool(Optional.extract(update_commits)):
                     if PullRequestModel().has_valid_update_type(pull_request):
                         _version, _commit_changes = PullRequestModel().update_commits(
                             pull_request)
                         commit_changes = _commit_changes or commit_changes
                     Session().commit()
                 reviewers_changes = {"added": [], "removed": []}
                 if reviewer_ids:
                     added_reviewers, removed_reviewers = \
                         PullRequestModel().update_reviewers(pull_request, reviewers_reasons)
                     reviewers_changes['added'] = sorted(
                         [get_user_or_error(n).username for n in added_reviewers])
                     reviewers_changes['removed'] = sorted(
                         [get_user_or_error(n).username for n in removed_reviewers])
                     Session().commit()
                 if str2bool(Optional.extract(close_pull_request)):
                     PullRequestModel().close_pull_request_with_comment(
                         pull_request, apiuser, repo)
                     Session().commit()
                 data = {
                     'msg': 'Updated pull request `{}`'.format(
                         pull_request.pull_request_id),
                     'pull_request': pull_request.get_api_data(),
                     'updated_commits': commit_changes,
                     'updated_reviewers': reviewers_changes
                 }
                 return data

             # -*- coding: utf-8 -*-
             # Copyright (C) 2014-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             SimpleVCS middleware for handling protocol request (push/clone etc.)
             It's implemented with basic auth function
             """
             import os
             import logging
             import importlib
             import re
             from functools import wraps
             from paste.httpheaders import REMOTE_USER, AUTH_TYPE
             from webob.exc import (
                 HTTPNotFound, HTTPForbidden, HTTPNotAcceptable, HTTPInternalServerError)
             import rhodecode
             from rhodecode.authentication.base import authenticate, VCS_TYPE
             from rhodecode.lib.auth import AuthUser, HasPermissionAnyMiddleware
             from rhodecode.lib.base import BasicAuth, get_ip_addr, vcs_operation_context
             from rhodecode.lib.exceptions import (
                 HTTPLockedRC, HTTPRequirementError, UserCreationError,
                 NotAllowedToCreateUserError)
             from rhodecode.lib.hooks_daemon import prepare_callback_daemon
             from rhodecode.lib.middleware import appenlight
             from rhodecode.lib.middleware.utils import scm_app
             from rhodecode.lib.utils import (
                 is_valid_repo, get_rhodecode_realm, get_rhodecode_base_path)
             from rhodecode.lib.utils2 import safe_str, fix_PATH, str2bool
             from rhodecode.lib.vcs.conf import settings as vcs_settings
             from rhodecode.lib.vcs.backends import base
             from rhodecode.model import meta
             from rhodecode.model.db import User, Repository
             from rhodecode.model.scm import ScmModel
             log = logging.getLogger(__name__)
             def initialize_generator(factory):
                 """
                 Initializes the returned generator by draining its first element.
                 This can be used to give a generator an initializer, which is the code
                 up to the first yield statement. This decorator enforces that the first
                 produced element has the value ``"__init__"`` to make its special
                 purpose very explicit in the using code.
                 """
                 @wraps(factory)
                 def wrapper(*args, **kwargs):
                     gen = factory(*args, **kwargs)
                     try:
                         init = gen.next()
                     except StopIteration:
                         raise ValueError('Generator must yield at least one element.')
                     if init != "__init__":
                         raise ValueError('First yielded element must be "__init__".')
                     return gen
                 return wrapper
             class SimpleVCS(object):
                 """Common functionality for SCM HTTP handlers."""
                 SCM = 'unknown'
                 acl_repo_name = None
                 url_repo_name = None
                 vcs_repo_name = None
                 def __init__(self, application, config, registry):
                     self.registry = registry
                     self.application = application
                     self.config = config
                     # re-populated by specialized middleware
                     self.repo_vcs_config = base.Config()
                     # base path of repo locations
                     self.basepath = get_rhodecode_base_path()
                     # authenticate this VCS request using authfunc
                     auth_ret_code_detection = \
                         str2bool(self.config.get('auth_ret_code_detection', False))
                     self.authenticate = BasicAuth(
                         '', authenticate, registry, config.get('auth_ret_code'),
                         auth_ret_code_detection)
                     self.ip_addr = '0.0.0.0'
                 def set_repo_names(self, environ):
                     """
                     This will populate the attributes acl_repo_name, url_repo_name,
                     vcs_repo_name and pr_id on the current instance.
                     """
+                    # TODO: martinb: Unify generation/suffix of clone url. It is currently
+                    #       used here in the regex, in PullRequest in get_api_data() and
+                    #       indirectly in routing configuration.
                     # TODO: martinb: Move to class or module scope.
                     # TODO: martinb: Check if we have to use re.UNICODE.
                     # TODO: martinb: Check which chars are allowed for repo/group names.
                     #       These chars are excluded: '`?=[]\;\'"<>,/~!@#$%^&*()+{}|: '
                     #       Code from: rhodecode/lib/utils.py:repo_name_slug()
                     pr_regex = re.compile(
                         '(?P<base_name>(?:[\w-]+)(?:/[\w-]+)*)/'    # repo groups
                         '(?P<repo_name>[\w-]+)'                     # target repo name
                         '/pull-request/(?P<pr_id>\d+)/repository')  # pr suffix
                     # Get url repo name from environment.
                     self.url_repo_name = self._get_repository_name(environ)
                     # Check if this is a request to a shadow repository. In case of a
                     # shadow repo set vcs_repo_name to the file system path pointing to the
                     # shadow repo. And set acl_repo_name to the pull request target repo
                     # because we use the target repo for permission checks. Otherwise all
                     # names are equal.
                     match = pr_regex.match(self.url_repo_name)
                     if match:
                         # Get pull request instance.
                         match_dict = match.groupdict()
                         pr_id = match_dict['pr_id']
                         pull_request = PullRequest.get(pr_id)
                         # Get file system path to shadow repository.
                         workspace_id = PullRequestModel()._workspace_id(pull_request)
                         target_vcs = pull_request.target_repo.scm_instance()
                         vcs_repo_name = target_vcs._get_shadow_repository_path(
                             workspace_id)
                         # Store names for later usage.
                         self.pr_id = pr_id
                         self.vcs_repo_name = vcs_repo_name
                         self.acl_repo_name = pull_request.target_repo.repo_name
                     else:
                         # All names are equal for normal (non shadow) repositories.
                         self.acl_repo_name = self.url_repo_name
                         self.vcs_repo_name = self.url_repo_name
                         self.pr_id = None
                 @property
                 def repo_name(self):
                     # TODO: johbo: Remove, switch to correct repo name attribute
                     return self.acl_repo_name
                 @property
                 def scm_app(self):
                     custom_implementation = self.config.get('vcs.scm_app_implementation')
                     if custom_implementation and custom_implementation != 'pyro4':
                         log.info(
                             "Using custom implementation of scm_app: %s",
                             custom_implementation)
                         scm_app_impl = importlib.import_module(custom_implementation)
                     else:
                         scm_app_impl = scm_app
                     return scm_app_impl
                 def _get_by_id(self, repo_name):
                     """
                     Gets a special pattern _<ID> from clone url and tries to replace it
                     with a repository_name for support of _<ID> non changeable urls
                     """
                     data = repo_name.split('/')
                     if len(data) >= 2:
                         from rhodecode.model.repo import RepoModel
                         by_id_match = RepoModel().get_repo_by_id(repo_name)
                         if by_id_match:
                             data[1] = by_id_match.repo_name
                     return safe_str('/'.join(data))
                 def _invalidate_cache(self, repo_name):
                     """
                     Set's cache for this repository for invalidation on next access
                     :param repo_name: full repo name, also a cache key
                     """
                     ScmModel().mark_for_invalidation(repo_name)
                 def is_valid_and_existing_repo(self, repo_name, base_path, scm_type):
                     db_repo = Repository.get_by_repo_name(repo_name)
                     if not db_repo:
                         log.debug('Repository `%s` not found inside the database.',
                                   repo_name)
                         return False
                     if db_repo.repo_type != scm_type:
                         log.warning(
                             'Repository `%s` have incorrect scm_type, expected %s got %s',
                             repo_name, db_repo.repo_type, scm_type)
                         return False
                     return is_valid_repo(repo_name, base_path, expect_scm=scm_type)
                 def valid_and_active_user(self, user):
                     """
                     Checks if that user is not empty, and if it's actually object it checks
                     if he's active.
                     :param user: user object or None
                     :return: boolean
                     """
                     if user is None:
                         return False
                     elif user.active:
                         return True
                     return False
                 def _check_permission(self, action, user, repo_name, ip_addr=None):
                     """
                     Checks permissions using action (push/pull) user and repository
                     name
                     :param action: push or pull action
                     :param user: user instance
                     :param repo_name: repository name
                     """
                     # check IP
                     inherit = user.inherit_default_permissions
                     ip_allowed = AuthUser.check_ip_allowed(user.user_id, ip_addr,
                                                            inherit_from_default=inherit)
                     if ip_allowed:
                         log.info('Access for IP:%s allowed', ip_addr)
                     else:
                         return False
                     if action == 'push':
                         if not HasPermissionAnyMiddleware('repository.write',
                                                           'repository.admin')(user,
                                                                               repo_name):
                             return False
                     else:
                         # any other action need at least read permission
                         if not HasPermissionAnyMiddleware('repository.read',
                                                           'repository.write',
                                                           'repository.admin')(user,
                                                                               repo_name):
                             return False
                     return True
                 def _check_ssl(self, environ, start_response):
                     """
                     Checks the SSL check flag and returns False if SSL is not present
                     and required True otherwise
                     """
                     org_proto = environ['wsgi._org_proto']
                     # check if we have SSL required  ! if not it's a bad request !
                     require_ssl = str2bool(self.repo_vcs_config.get('web', 'push_ssl'))
                     if require_ssl and org_proto == 'http':
                         log.debug('proto is %s and SSL is required BAD REQUEST !',
                                   org_proto)
                         return False
                     return True
                 def __call__(self, environ, start_response):
                     try:
                         return self._handle_request(environ, start_response)
                     except Exception:
                         log.exception("Exception while handling request")
                         appenlight.track_exception(environ)
                         return HTTPInternalServerError()(environ, start_response)
                     finally:
                         meta.Session.remove()
                 def _handle_request(self, environ, start_response):
                     if not self._check_ssl(environ, start_response):
                         reason = ('SSL required, while RhodeCode was unable '
                                   'to detect this as SSL request')
                         log.debug('User not allowed to proceed, %s', reason)
                         return HTTPNotAcceptable(reason)(environ, start_response)
                     if not self.repo_name:
                         log.warning('Repository name is empty: %s', self.repo_name)
                         # failed to get repo name, we fail now
                         return HTTPNotFound()(environ, start_response)
                     log.debug('Extracted repo name is %s', self.repo_name)
                     ip_addr = get_ip_addr(environ)
                     username = None
                     # skip passing error to error controller
                     environ['pylons.status_code_redirect'] = True
                     # ======================================================================
                     # GET ACTION PULL or PUSH
                     # ======================================================================
                     action = self._get_action(environ)
                     # ======================================================================
                     # Check if this is a request to a shadow repository of a pull request.
                     # In this case only pull action is allowed.
                     # ======================================================================
                     if self.pr_id is not None and action != 'pull':
                         reason = 'Only pull action is allowed for shadow repositories.'
                         log.debug('User not allowed to proceed, %s', reason)
                         return HTTPNotAcceptable(reason)(environ, start_response)
                     # ======================================================================
                     # CHECK ANONYMOUS PERMISSION
                     # ======================================================================
                     if action in ['pull', 'push']:
                         anonymous_user = User.get_default_user()
                         username = anonymous_user.username
                         if anonymous_user.active:
                             # ONLY check permissions if the user is activated
                             anonymous_perm = self._check_permission(
                                 action, anonymous_user, self.repo_name, ip_addr)
                         else:
                             anonymous_perm = False
                         if not anonymous_user.active or not anonymous_perm:
                             if not anonymous_user.active:
                                 log.debug('Anonymous access is disabled, running '
                                           'authentication')
                             if not anonymous_perm:
                                 log.debug('Not enough credentials to access this '
                                           'repository as anonymous user')
                             username = None
                             # ==============================================================
                             # DEFAULT PERM FAILED OR ANONYMOUS ACCESS IS DISABLED SO WE
                             # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS
                             # ==============================================================
                             # try to auth based on environ, container auth methods
                             log.debug('Running PRE-AUTH for container based authentication')
                             pre_auth = authenticate(
                                 '', '', environ, VCS_TYPE, registry=self.registry)
                             if pre_auth and pre_auth.get('username'):
                                 username = pre_auth['username']
                             log.debug('PRE-AUTH got %s as username', username)
                             # If not authenticated by the container, running basic auth
                             if not username:
                                 self.authenticate.realm = get_rhodecode_realm()
                                 try:
                                     result = self.authenticate(environ)
                                 except (UserCreationError, NotAllowedToCreateUserError) as e:
                                     log.error(e)
                                     reason = safe_str(e)
                                     return HTTPNotAcceptable(reason)(environ, start_response)
                                 if isinstance(result, str):
                                     AUTH_TYPE.update(environ, 'basic')
                                     REMOTE_USER.update(environ, result)
                                     username = result
                                 else:
                                     return result.wsgi_application(environ, start_response)
                             # ==============================================================
                             # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
                             # ==============================================================
                             user = User.get_by_username(username)
                             if not self.valid_and_active_user(user):
                                 return HTTPForbidden()(environ, start_response)
                             username = user.username
                             user.update_lastactivity()
                             meta.Session().commit()
                             # check user attributes for password change flag
                             user_obj = user
                             if user_obj and user_obj.username != User.DEFAULT_USER and \
                                     user_obj.user_data.get('force_password_change'):
                                 reason = 'password change required'
                                 log.debug('User not allowed to authenticate, %s', reason)
                                 return HTTPNotAcceptable(reason)(environ, start_response)
                             # check permissions for this repository
                             perm = self._check_permission(
                                 action, user, self.repo_name, ip_addr)
                             if not perm:
                                 return HTTPForbidden()(environ, start_response)
                     # extras are injected into UI object and later available
                     # in hooks executed by rhodecode
                     check_locking = _should_check_locking(environ.get('QUERY_STRING'))
                     extras = vcs_operation_context(
                         environ, repo_name=self.repo_name, username=username,
                         action=action, scm=self.SCM,
                         check_locking=check_locking)
                     # ======================================================================
                     # REQUEST HANDLING
                     # ======================================================================
                     str_repo_name = safe_str(self.repo_name)
                     repo_path = os.path.join(
                         safe_str(self.basepath), safe_str(self.vcs_repo_name))
                     log.debug('Repository path is %s', repo_path)
                     fix_PATH()
                     log.info(
                         '%s action on %s repo "%s" by "%s" from %s',
                         action, self.SCM, str_repo_name, safe_str(username), ip_addr)
                     return self._generate_vcs_response(
                         environ, start_response, repo_path, self.url_repo_name, extras, action)
                 @initialize_generator
                 def _generate_vcs_response(
                         self, environ, start_response, repo_path, repo_name, extras,
                         action):
                     """
                     Returns a generator for the response content.
                     This method is implemented as a generator, so that it can trigger
                     the cache validation after all content sent back to the client. It
                     also handles the locking exceptions which will be triggered when
                     the first chunk is produced by the underlying WSGI application.
                     """
                     callback_daemon, extras = self._prepare_callback_daemon(extras)
                     config = self._create_config(extras, self.acl_repo_name)
                     log.debug('HOOKS extras is %s', extras)
                     app = self._create_wsgi_app(repo_path, repo_name, config)
                     try:
                         with callback_daemon:
                             try:
                                 response = app(environ, start_response)
                             finally:
                                 # This statement works together with the decorator
                                 # "initialize_generator" above. The decorator ensures that
                                 # we hit the first yield statement before the generator is
                                 # returned back to the WSGI server. This is needed to
                                 # ensure that the call to "app" above triggers the
                                 # needed callback to "start_response" before the
                                 # generator is actually used.
                                 yield "__init__"
                             for chunk in response:
                                 yield chunk
                     except Exception as exc:
                         # TODO: johbo: Improve "translating" back the exception.
                         if getattr(exc, '_vcs_kind', None) == 'repo_locked':
                             exc = HTTPLockedRC(*exc.args)
                             _code = rhodecode.CONFIG.get('lock_ret_code')
                             log.debug('Repository LOCKED ret code %s!', (_code,))
                         elif getattr(exc, '_vcs_kind', None) == 'requirement':
                             log.debug(
                                 'Repository requires features unknown to this Mercurial')
                             exc = HTTPRequirementError(*exc.args)
                         else:
                             raise
                         for chunk in exc(environ, start_response):
                             yield chunk
                     finally:
                         # invalidate cache on push
                         try:
                             if action == 'push':
                                 self._invalidate_cache(repo_name)
                         finally:
                             meta.Session.remove()
                 def _get_repository_name(self, environ):
                     """Get repository name out of the environmnent
                     :param environ: WSGI environment
                     """
                     raise NotImplementedError()
                 def _get_action(self, environ):
                     """Map request commands into a pull or push command.
                     :param environ: WSGI environment
                     """
                     raise NotImplementedError()
                 def _create_wsgi_app(self, repo_path, repo_name, config):
                     """Return the WSGI app that will finally handle the request."""
                     raise NotImplementedError()
                 def _create_config(self, extras, repo_name):
                     """Create a Pyro safe config representation."""
                     raise NotImplementedError()
                 def _prepare_callback_daemon(self, extras):
                     return prepare_callback_daemon(
                         extras, protocol=vcs_settings.HOOKS_PROTOCOL,
                         use_direct_calls=vcs_settings.HOOKS_DIRECT_CALLS)
             def _should_check_locking(query_string):
                 # this is kind of hacky, but due to how mercurial handles client-server
                 # server see all operation on commit; bookmarks, phases and
                 # obsolescence marker in different transaction, we don't want to check
                 # locking on those
                 return query_string not in ['cmd=listkeys']

             # -*- coding: utf-8 -*-
             # Copyright (C) 2010-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             Database Models for RhodeCode Enterprise
             """
             import re
             import os
             import sys
             import time
             import hashlib
             import logging
             import datetime
             import warnings
             import ipaddress
             import functools
             import traceback
             import collections
             from sqlalchemy import *
             from sqlalchemy.exc import IntegrityError
             from sqlalchemy.ext.declarative import declared_attr
             from sqlalchemy.ext.hybrid import hybrid_property
             from sqlalchemy.orm import (
                 relationship, joinedload, class_mapper, validates, aliased)
             from sqlalchemy.sql.expression import true
             from beaker.cache import cache_region, region_invalidate
             from webob.exc import HTTPNotFound
             from zope.cachedescriptors.property import Lazy as LazyProperty
             from pylons import url
             from pylons.i18n.translation import lazy_ugettext as _
             from rhodecode.lib.vcs import get_backend, get_vcs_instance
             from rhodecode.lib.vcs.utils.helpers import get_scm
             from rhodecode.lib.vcs.exceptions import VCSError
             from rhodecode.lib.vcs.backends.base import (
                 EmptyCommit, Reference, MergeFailureReason)
             from rhodecode.lib.utils2 import (
                 str2bool, safe_str, get_commit_safe, safe_unicode, remove_prefix, md5_safe,
                 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
                 glob2re)
             from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, JSONDict
             from rhodecode.lib.ext_json import json
             from rhodecode.lib.caching_query import FromCache
             from rhodecode.lib.encrypt import AESCipher
             from rhodecode.model.meta import Base, Session
             URL_SEP = '/'
             log = logging.getLogger(__name__)
             # =============================================================================
             # BASE CLASSES
             # =============================================================================
             # this is propagated from .ini file rhodecode.encrypted_values.secret or
             # beaker.session.secret if first is not set.
             # and initialized at environment.py
             ENCRYPTION_KEY = None
             # used to sort permissions by types, '#' used here is not allowed to be in
             # usernames, and it's very early in sorted string.printable table.
             PERMISSION_TYPE_SORT = {
                 'admin': '####',
                 'write': '###',
                 'read':  '##',
                 'none':  '#',
             }
             def display_sort(obj):
                 """
                 Sort function used to sort permissions in .permissions() function of
                 Repository, RepoGroup, UserGroup. Also it put the default user in front
                 of all other resources
                 """
                 if obj.username == User.DEFAULT_USER:
                     return '#####'
                 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
                 return prefix + obj.username
             def _hash_key(k):
                 return md5_safe(k)
             class EncryptedTextValue(TypeDecorator):
                 """
                 Special column for encrypted long text data, use like::
                     value = Column("encrypted_value", EncryptedValue(), nullable=False)
                 This column is intelligent so if value is in unencrypted form it return
                 unencrypted form, but on save it always encrypts
                 """
                 impl = Text
                 def process_bind_param(self, value, dialect):
                     if not value:
                         return value
                     if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
                         # protect against double encrypting if someone manually starts
                         # doing
                         raise ValueError('value needs to be in unencrypted format, ie. '
                                          'not starting with enc$aes')
                     return 'enc$aes_hmac$%s' % AESCipher(
                         ENCRYPTION_KEY, hmac=True).encrypt(value)
                 def process_result_value(self, value, dialect):
                     import rhodecode
                     if not value:
                         return value
                     parts = value.split('$', 3)
                     if not len(parts) == 3:
                         # probably not encrypted values
                         return value
                     else:
                         if parts[0] != 'enc':
                             # parts ok but without our header ?
                             return value
                         enc_strict_mode = str2bool(rhodecode.CONFIG.get(
                             'rhodecode.encrypted_values.strict') or True)
                         # at that stage we know it's our encryption
                         if parts[1] == 'aes':
                             decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
                         elif parts[1] == 'aes_hmac':
                             decrypted_data = AESCipher(
                                 ENCRYPTION_KEY, hmac=True,
                                 strict_verification=enc_strict_mode).decrypt(parts[2])
                         else:
                             raise ValueError(
                                 'Encryption type part is wrong, must be `aes` '
                                 'or `aes_hmac`, got `%s` instead' % (parts[1]))
                         return decrypted_data
             class BaseModel(object):
                 """
                 Base Model for all classes
                 """
                 @classmethod
                 def _get_keys(cls):
                     """return column names for this model """
                     return class_mapper(cls).c.keys()
                 def get_dict(self):
                     """
                     return dict with keys and values corresponding
                     to this model data """
                     d = {}
                     for k in self._get_keys():
                         d[k] = getattr(self, k)
                     # also use __json__() if present to get additional fields
                     _json_attr = getattr(self, '__json__', None)
                     if _json_attr:
                         # update with attributes from __json__
                         if callable(_json_attr):
                             _json_attr = _json_attr()
                         for k, val in _json_attr.iteritems():
                             d[k] = val
                     return d
                 def get_appstruct(self):
                     """return list with keys and values tuples corresponding
                     to this model data """
                     l = []
                     for k in self._get_keys():
                         l.append((k, getattr(self, k),))
                     return l
                 def populate_obj(self, populate_dict):
                     """populate model with data from given populate_dict"""
                     for k in self._get_keys():
                         if k in populate_dict:
                             setattr(self, k, populate_dict[k])
                 @classmethod
                 def query(cls):
                     return Session().query(cls)
                 @classmethod
                 def get(cls, id_):
                     if id_:
                         return cls.query().get(id_)
                 @classmethod
                 def get_or_404(cls, id_):
                     try:
                         id_ = int(id_)
                     except (TypeError, ValueError):
                         raise HTTPNotFound
                     res = cls.query().get(id_)
                     if not res:
                         raise HTTPNotFound
                     return res
                 @classmethod
                 def getAll(cls):
                     # deprecated and left for backward compatibility
                     return cls.get_all()
                 @classmethod
                 def get_all(cls):
                     return cls.query().all()
                 @classmethod
                 def delete(cls, id_):
                     obj = cls.query().get(id_)
                     Session().delete(obj)
                 @classmethod
                 def identity_cache(cls, session, attr_name, value):
                     exist_in_session = []
                     for (item_cls, pkey), instance in session.identity_map.items():
                         if cls == item_cls and getattr(instance, attr_name) == value:
                             exist_in_session.append(instance)
                     if exist_in_session:
                         if len(exist_in_session) == 1:
                             return exist_in_session[0]
                         log.exception(
                             'multiple objects with attr %s and '
                             'value %s found with same name: %r',
                             attr_name, value, exist_in_session)
                 def __repr__(self):
                     if hasattr(self, '__unicode__'):
                         # python repr needs to return str
                         try:
                             return safe_str(self.__unicode__())
                         except UnicodeDecodeError:
                             pass
                     return '<DB:%s>' % (self.__class__.__name__)
             class RhodeCodeSetting(Base, BaseModel):
                 __tablename__ = 'rhodecode_settings'
                 __table_args__ = (
                     UniqueConstraint('app_settings_name'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 SETTINGS_TYPES = {
                     'str': safe_str,
                     'int': safe_int,
                     'unicode': safe_unicode,
                     'bool': str2bool,
                     'list': functools.partial(aslist, sep=',')
                 }
                 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
                 GLOBAL_CONF_KEY = 'app_settings'
                 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
                 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
                 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
                 def __init__(self, key='', val='', type='unicode'):
                     self.app_settings_name = key
                     self.app_settings_type = type
                     self.app_settings_value = val
                 @validates('_app_settings_value')
                 def validate_settings_value(self, key, val):
                     assert type(val) == unicode
                     return val
                 @hybrid_property
                 def app_settings_value(self):
                     v = self._app_settings_value
                     _type = self.app_settings_type
                     if _type:
                         _type = self.app_settings_type.split('.')[0]
                         # decode the encrypted value
                         if 'encrypted' in self.app_settings_type:
                             cipher = EncryptedTextValue()
                             v = safe_unicode(cipher.process_result_value(v, None))
                     converter = self.SETTINGS_TYPES.get(_type) or \
                         self.SETTINGS_TYPES['unicode']
                     return converter(v)
                 @app_settings_value.setter
                 def app_settings_value(self, val):
                     """
                     Setter that will always make sure we use unicode in app_settings_value
                     :param val:
                     """
                     val = safe_unicode(val)
                     # encode the encrypted value
                     if 'encrypted' in self.app_settings_type:
                         cipher = EncryptedTextValue()
                         val = safe_unicode(cipher.process_bind_param(val, None))
                     self._app_settings_value = val
                 @hybrid_property
                 def app_settings_type(self):
                     return self._app_settings_type
                 @app_settings_type.setter
                 def app_settings_type(self, val):
                     if val.split('.')[0] not in self.SETTINGS_TYPES:
                         raise Exception('type must be one of %s got %s'
                                         % (self.SETTINGS_TYPES.keys(), val))
                     self._app_settings_type = val
                 def __unicode__(self):
                     return u"<%s('%s:%s[%s]')>" % (
                         self.__class__.__name__,
                         self.app_settings_name, self.app_settings_value,
                         self.app_settings_type
                     )
             class RhodeCodeUi(Base, BaseModel):
                 __tablename__ = 'rhodecode_ui'
                 __table_args__ = (
                     UniqueConstraint('ui_key'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 HOOK_REPO_SIZE = 'changegroup.repo_size'
                 # HG
                 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
                 HOOK_PULL = 'outgoing.pull_logger'
                 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
                 HOOK_PUSH = 'changegroup.push_logger'
                 # TODO: johbo: Unify way how hooks are configured for git and hg,
                 # git part is currently hardcoded.
                 # SVN PATTERNS
                 SVN_BRANCH_ID = 'vcs_svn_branch'
                 SVN_TAG_ID = 'vcs_svn_tag'
                 ui_id = Column(
                     "ui_id", Integer(), nullable=False, unique=True, default=None,
                     primary_key=True)
                 ui_section = Column(
                     "ui_section", String(255), nullable=True, unique=None, default=None)
                 ui_key = Column(
                     "ui_key", String(255), nullable=True, unique=None, default=None)
                 ui_value = Column(
                     "ui_value", String(255), nullable=True, unique=None, default=None)
                 ui_active = Column(
                     "ui_active", Boolean(), nullable=True, unique=None, default=True)
                 def __repr__(self):
                     return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
                                                 self.ui_key, self.ui_value)
             class RepoRhodeCodeSetting(Base, BaseModel):
                 __tablename__ = 'repo_rhodecode_settings'
                 __table_args__ = (
                     UniqueConstraint(
                         'app_settings_name', 'repository_id',
                         name='uq_repo_rhodecode_setting_name_repo_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 repository_id = Column(
                     "repository_id", Integer(), ForeignKey('repositories.repo_id'),
                     nullable=False)
                 app_settings_id = Column(
                     "app_settings_id", Integer(), nullable=False, unique=True,
                     default=None, primary_key=True)
                 app_settings_name = Column(
                     "app_settings_name", String(255), nullable=True, unique=None,
                     default=None)
                 _app_settings_value = Column(
                     "app_settings_value", String(4096), nullable=True, unique=None,
                     default=None)
                 _app_settings_type = Column(
                     "app_settings_type", String(255), nullable=True, unique=None,
                     default=None)
                 repository = relationship('Repository')
                 def __init__(self, repository_id, key='', val='', type='unicode'):
                     self.repository_id = repository_id
                     self.app_settings_name = key
                     self.app_settings_type = type
                     self.app_settings_value = val
                 @validates('_app_settings_value')
                 def validate_settings_value(self, key, val):
                     assert type(val) == unicode
                     return val
                 @hybrid_property
                 def app_settings_value(self):
                     v = self._app_settings_value
                     type_ = self.app_settings_type
                     SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
                     converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
                     return converter(v)
                 @app_settings_value.setter
                 def app_settings_value(self, val):
                     """
                     Setter that will always make sure we use unicode in app_settings_value
                     :param val:
                     """
                     self._app_settings_value = safe_unicode(val)
                 @hybrid_property
                 def app_settings_type(self):
                     return self._app_settings_type
                 @app_settings_type.setter
                 def app_settings_type(self, val):
                     SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
                     if val not in SETTINGS_TYPES:
                         raise Exception('type must be one of %s got %s'
                                         % (SETTINGS_TYPES.keys(), val))
                     self._app_settings_type = val
                 def __unicode__(self):
                     return u"<%s('%s:%s:%s[%s]')>" % (
                         self.__class__.__name__, self.repository.repo_name,
                         self.app_settings_name, self.app_settings_value,
                         self.app_settings_type
                     )
             class RepoRhodeCodeUi(Base, BaseModel):
                 __tablename__ = 'repo_rhodecode_ui'
                 __table_args__ = (
                     UniqueConstraint(
                         'repository_id', 'ui_section', 'ui_key',
                         name='uq_repo_rhodecode_ui_repository_id_section_key'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 repository_id = Column(
                     "repository_id", Integer(), ForeignKey('repositories.repo_id'),
                     nullable=False)
                 ui_id = Column(
                     "ui_id", Integer(), nullable=False, unique=True, default=None,
                     primary_key=True)
                 ui_section = Column(
                     "ui_section", String(255), nullable=True, unique=None, default=None)
                 ui_key = Column(
                     "ui_key", String(255), nullable=True, unique=None, default=None)
                 ui_value = Column(
                     "ui_value", String(255), nullable=True, unique=None, default=None)
                 ui_active = Column(
                     "ui_active", Boolean(), nullable=True, unique=None, default=True)
                 repository = relationship('Repository')
                 def __repr__(self):
                     return '<%s[%s:%s]%s=>%s]>' % (
                         self.__class__.__name__, self.repository.repo_name,
                         self.ui_section, self.ui_key, self.ui_value)
             class User(Base, BaseModel):
                 __tablename__ = 'users'
                 __table_args__ = (
                     UniqueConstraint('username'), UniqueConstraint('email'),
                     Index('u_username_idx', 'username'),
                     Index('u_email_idx', 'email'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 DEFAULT_USER = 'default'
                 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
                 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
                 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 username = Column("username", String(255), nullable=True, unique=None, default=None)
                 password = Column("password", String(255), nullable=True, unique=None, default=None)
                 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
                 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
                 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
                 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
                 _email = Column("email", String(255), nullable=True, unique=None, default=None)
                 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
                 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
                 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
                 api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
                 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
                 user_log = relationship('UserLog')
                 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
                 repositories = relationship('Repository')
                 repository_groups = relationship('RepoGroup')
                 user_groups = relationship('UserGroup')
                 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
                 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
                 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
                 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
                 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
                 group_member = relationship('UserGroupMember', cascade='all')
                 notifications = relationship('UserNotification', cascade='all')
                 # notifications assigned to this user
                 user_created_notifications = relationship('Notification', cascade='all')
                 # comments created by this user
                 user_comments = relationship('ChangesetComment', cascade='all')
                 # user profile extra info
                 user_emails = relationship('UserEmailMap', cascade='all')
                 user_ip_map = relationship('UserIpMap', cascade='all')
                 user_auth_tokens = relationship('UserApiKeys', cascade='all')
                 # gists
                 user_gists = relationship('Gist', cascade='all')
                 # user pull requests
                 user_pull_requests = relationship('PullRequest', cascade='all')
                 # external identities
                 extenal_identities = relationship(
                     'ExternalIdentity',
                     primaryjoin="User.user_id==ExternalIdentity.local_user_id",
                     cascade='all')
                 def __unicode__(self):
                     return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
                                                   self.user_id, self.username)
                 @hybrid_property
                 def email(self):
                     return self._email
                 @email.setter
                 def email(self, val):
                     self._email = val.lower() if val else None
                 @property
                 def firstname(self):
                     # alias for future
                     return self.name
                 @property
                 def emails(self):
                     other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
                     return [self.email] + [x.email for x in other]
                 @property
                 def auth_tokens(self):
                     return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
                 @property
                 def extra_auth_tokens(self):
                     return UserApiKeys.query().filter(UserApiKeys.user == self).all()
                 @property
                 def feed_token(self):
                     feed_tokens = UserApiKeys.query()\
                         .filter(UserApiKeys.user == self)\
                         .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
                         .all()
                     if feed_tokens:
                         return feed_tokens[0].api_key
                     else:
                         # use the main token so we don't end up with nothing...
                         return self.api_key
                 @classmethod
                 def extra_valid_auth_tokens(cls, user, role=None):
                     tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
                             .filter(or_(UserApiKeys.expires == -1,
                                         UserApiKeys.expires >= time.time()))
                     if role:
                         tokens = tokens.filter(or_(UserApiKeys.role == role,
                                                    UserApiKeys.role == UserApiKeys.ROLE_ALL))
                     return tokens.all()
                 @property
                 def ip_addresses(self):
                     ret = UserIpMap.query().filter(UserIpMap.user == self).all()
                     return [x.ip_addr for x in ret]
                 @property
                 def username_and_name(self):
                     return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
                 @property
                 def username_or_name_or_email(self):
                     full_name = self.full_name if self.full_name is not ' ' else None
                     return self.username or full_name or self.email
                 @property
                 def full_name(self):
                     return '%s %s' % (self.firstname, self.lastname)
                 @property
                 def full_name_or_username(self):
                     return ('%s %s' % (self.firstname, self.lastname)
                             if (self.firstname and self.lastname) else self.username)
                 @property
                 def full_contact(self):
                     return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
                 @property
                 def short_contact(self):
                     return '%s %s' % (self.firstname, self.lastname)
                 @property
                 def is_admin(self):
                     return self.admin
                 @property
                 def AuthUser(self):
                     """
                     Returns instance of AuthUser for this user
                     """
                     from rhodecode.lib.auth import AuthUser
                     return AuthUser(user_id=self.user_id, api_key=self.api_key,
                                     username=self.username)
                 @hybrid_property
                 def user_data(self):
                     if not self._user_data:
                         return {}
                     try:
                         return json.loads(self._user_data)
                     except TypeError:
                         return {}
                 @user_data.setter
                 def user_data(self, val):
                     if not isinstance(val, dict):
                         raise Exception('user_data must be dict, got %s' % type(val))
                     try:
                         self._user_data = json.dumps(val)
                     except Exception:
                         log.error(traceback.format_exc())
                 @classmethod
                 def get_by_username(cls, username, case_insensitive=False,
                                     cache=False, identity_cache=False):
                     session = Session()
                     if case_insensitive:
                         q = cls.query().filter(
                             func.lower(cls.username) == func.lower(username))
                     else:
                         q = cls.query().filter(cls.username == username)
                     if cache:
                         if identity_cache:
                             val = cls.identity_cache(session, 'username', username)
                             if val:
                                 return val
                         else:
                             q = q.options(
                                 FromCache("sql_cache_short",
                                           "get_user_by_name_%s" % _hash_key(username)))
                     return q.scalar()
                 @classmethod
                 def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
                     q = cls.query().filter(cls.api_key == auth_token)
                     if cache:
                         q = q.options(FromCache("sql_cache_short",
                                                 "get_auth_token_%s" % auth_token))
                     res = q.scalar()
                     if fallback and not res:
                         #fallback to additional keys
                         _res = UserApiKeys.query()\
                             .filter(UserApiKeys.api_key == auth_token)\
                             .filter(or_(UserApiKeys.expires == -1,
                                         UserApiKeys.expires >= time.time()))\
                             .first()
                         if _res:
                             res = _res.user
                     return res
                 @classmethod
                 def get_by_email(cls, email, case_insensitive=False, cache=False):
                     if case_insensitive:
                         q = cls.query().filter(func.lower(cls.email) == func.lower(email))
                     else:
                         q = cls.query().filter(cls.email == email)
                     if cache:
                         q = q.options(FromCache("sql_cache_short",
                                                 "get_email_key_%s" % _hash_key(email)))
                     ret = q.scalar()
                     if ret is None:
                         q = UserEmailMap.query()
                         # try fetching in alternate email map
                         if case_insensitive:
                             q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
                         else:
                             q = q.filter(UserEmailMap.email == email)
                         q = q.options(joinedload(UserEmailMap.user))
                         if cache:
                             q = q.options(FromCache("sql_cache_short",
                                                     "get_email_map_key_%s" % email))
                         ret = getattr(q.scalar(), 'user', None)
                     return ret
                 @classmethod
                 def get_from_cs_author(cls, author):
                     """
                     Tries to get User objects out of commit author string
                     :param author:
                     """
                     from rhodecode.lib.helpers import email, author_name
                     # Valid email in the attribute passed, see if they're in the system
                     _email = email(author)
                     if _email:
                         user = cls.get_by_email(_email, case_insensitive=True)
                         if user:
                             return user
                     # Maybe we can match by username?
                     _author = author_name(author)
                     user = cls.get_by_username(_author, case_insensitive=True)
                     if user:
                         return user
                 def update_userdata(self, **kwargs):
                     usr = self
                     old = usr.user_data
                     old.update(**kwargs)
                     usr.user_data = old
                     Session().add(usr)
                     log.debug('updated userdata with ', kwargs)
                 def update_lastlogin(self):
                     """Update user lastlogin"""
                     self.last_login = datetime.datetime.now()
                     Session().add(self)
                     log.debug('updated user %s lastlogin', self.username)
                 def update_lastactivity(self):
                     """Update user lastactivity"""
                     usr = self
                     old = usr.user_data
                     old.update({'last_activity': time.time()})
                     usr.user_data = old
                     Session().add(usr)
                     log.debug('updated user %s lastactivity', usr.username)
                 def update_password(self, new_password, change_api_key=False):
                     from rhodecode.lib.auth import get_crypt_password,generate_auth_token
                     self.password = get_crypt_password(new_password)
                     if change_api_key:
                         self.api_key = generate_auth_token(self.username)
                     Session().add(self)
                 @classmethod
                 def get_first_super_admin(cls):
                     user = User.query().filter(User.admin == true()).first()
                     if user is None:
                         raise Exception('FATAL: Missing administrative account!')
                     return user
                 @classmethod
                 def get_all_super_admins(cls):
                     """
                     Returns all admin accounts sorted by username
                     """
                     return User.query().filter(User.admin == true())\
                         .order_by(User.username.asc()).all()
                 @classmethod
                 def get_default_user(cls, cache=False):
                     user = User.get_by_username(User.DEFAULT_USER, cache=cache)
                     if user is None:
                         raise Exception('FATAL: Missing default account!')
                     return user
                 def _get_default_perms(self, user, suffix=''):
                     from rhodecode.model.permission import PermissionModel
                     return PermissionModel().get_default_perms(user.user_perms, suffix)
                 def get_default_perms(self, suffix=''):
                     return self._get_default_perms(self, suffix)
                 def get_api_data(self, include_secrets=False, details='full'):
                     """
                     Common function for generating user related data for API
                     :param include_secrets: By default secrets in the API data will be replaced
                        by a placeholder value to prevent exposing this data by accident. In case
                        this data shall be exposed, set this flag to ``True``.
                     :param details: details can be 'basic|full' basic gives only a subset of
                        the available user information that includes user_id, name and emails.
                     """
                     user = self
                     user_data = self.user_data
                     data = {
                         'user_id': user.user_id,
                         'username': user.username,
                         'firstname': user.name,
                         'lastname': user.lastname,
                         'email': user.email,
                         'emails': user.emails,
                     }
                     if details == 'basic':
                         return data
                     api_key_length = 40
                     api_key_replacement = '*' * api_key_length
                     extras = {
                         'api_key': api_key_replacement,
                         'api_keys': [api_key_replacement],
                         'active': user.active,
                         'admin': user.admin,
                         'extern_type': user.extern_type,
                         'extern_name': user.extern_name,
                         'last_login': user.last_login,
                         'ip_addresses': user.ip_addresses,
                         'language': user_data.get('language')
                     }
                     data.update(extras)
                     if include_secrets:
                         data['api_key'] = user.api_key
                         data['api_keys'] = user.auth_tokens
                     return data
                 def __json__(self):
                     data = {
                         'full_name': self.full_name,
                         'full_name_or_username': self.full_name_or_username,
                         'short_contact': self.short_contact,
                         'full_contact': self.full_contact,
                     }
                     data.update(self.get_api_data())
                     return data
             class UserApiKeys(Base, BaseModel):
                 __tablename__ = 'user_api_keys'
                 __table_args__ = (
                     Index('uak_api_key_idx', 'api_key'),
                     Index('uak_api_key_expires_idx', 'api_key', 'expires'),
                     UniqueConstraint('api_key'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 __mapper_args__ = {}
                 # ApiKey role
                 ROLE_ALL = 'token_role_all'
                 ROLE_HTTP = 'token_role_http'
                 ROLE_VCS = 'token_role_vcs'
                 ROLE_API = 'token_role_api'
                 ROLE_FEED = 'token_role_feed'
                 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
                 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 api_key = Column("api_key", String(255), nullable=False, unique=True)
                 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
                 expires = Column('expires', Float(53), nullable=False)
                 role = Column('role', String(255), nullable=True)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 user = relationship('User', lazy='joined')
                 @classmethod
                 def _get_role_name(cls, role):
                     return {
                         cls.ROLE_ALL: _('all'),
                         cls.ROLE_HTTP: _('http/web interface'),
                         cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
                         cls.ROLE_API: _('api calls'),
                         cls.ROLE_FEED: _('feed access'),
                     }.get(role, role)
                 @property
                 def expired(self):
                     if self.expires == -1:
                         return False
                     return time.time() > self.expires
                 @property
                 def role_humanized(self):
                     return self._get_role_name(self.role)
             class UserEmailMap(Base, BaseModel):
                 __tablename__ = 'user_email_map'
                 __table_args__ = (
                     Index('uem_email_idx', 'email'),
                     UniqueConstraint('email'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 __mapper_args__ = {}
                 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 _email = Column("email", String(255), nullable=True, unique=False, default=None)
                 user = relationship('User', lazy='joined')
                 @validates('_email')
                 def validate_email(self, key, email):
                     # check if this email is not main one
                     main_email = Session().query(User).filter(User.email == email).scalar()
                     if main_email is not None:
                         raise AttributeError('email %s is present is user table' % email)
                     return email
                 @hybrid_property
                 def email(self):
                     return self._email
                 @email.setter
                 def email(self, val):
                     self._email = val.lower() if val else None
             class UserIpMap(Base, BaseModel):
                 __tablename__ = 'user_ip_map'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'ip_addr'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 __mapper_args__ = {}
                 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
                 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
                 description = Column("description", String(10000), nullable=True, unique=None, default=None)
                 user = relationship('User', lazy='joined')
                 @classmethod
                 def _get_ip_range(cls, ip_addr):
                     net = ipaddress.ip_network(ip_addr, strict=False)
                     return [str(net.network_address), str(net.broadcast_address)]
                 def __json__(self):
                     return {
                       'ip_addr': self.ip_addr,
                       'ip_range': self._get_ip_range(self.ip_addr),
                     }
                 def __unicode__(self):
                     return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
                                                         self.user_id, self.ip_addr)
             class UserLog(Base, BaseModel):
                 __tablename__ = 'user_logs'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 username = Column("username", String(255), nullable=True, unique=None, default=None)
                 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
                 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
                 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
                 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
                 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
                 def __unicode__(self):
                     return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
                                                   self.repository_name,
                                                   self.action)
                 @property
                 def action_as_day(self):
                     return datetime.date(*self.action_date.timetuple()[:3])
                 user = relationship('User')
                 repository = relationship('Repository', cascade='')
             class UserGroup(Base, BaseModel):
                 __tablename__ = 'users_groups'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
                 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
                 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
                 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
                 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
                 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
                 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
                 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
                 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
                 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
                 user = relationship('User')
                 @hybrid_property
                 def group_data(self):
                     if not self._group_data:
                         return {}
                     try:
                         return json.loads(self._group_data)
                     except TypeError:
                         return {}
                 @group_data.setter
                 def group_data(self, val):
                     try:
                         self._group_data = json.dumps(val)
                     except Exception:
                         log.error(traceback.format_exc())
                 def __unicode__(self):
                     return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
                                                   self.users_group_id,
                                                   self.users_group_name)
                 @classmethod
                 def get_by_group_name(cls, group_name, cache=False,
                                       case_insensitive=False):
                     if case_insensitive:
                         q = cls.query().filter(func.lower(cls.users_group_name) ==
                                                func.lower(group_name))
                     else:
                         q = cls.query().filter(cls.users_group_name == group_name)
                     if cache:
                         q = q.options(FromCache(
                                         "sql_cache_short",
                                         "get_group_%s" % _hash_key(group_name)))
                     return q.scalar()
                 @classmethod
                 def get(cls, user_group_id, cache=False):
                     user_group = cls.query()
                     if cache:
                         user_group = user_group.options(FromCache("sql_cache_short",
                                                 "get_users_group_%s" % user_group_id))
                     return user_group.get(user_group_id)
                 def permissions(self, with_admins=True, with_owner=True):
                     q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
                     q = q.options(joinedload(UserUserGroupToPerm.user_group),
                                   joinedload(UserUserGroupToPerm.user),
                                   joinedload(UserUserGroupToPerm.permission),)
                     # get owners and admins and permissions. We do a trick of re-writing
                     # objects from sqlalchemy to named-tuples due to sqlalchemy session
                     # has a global reference and changing one object propagates to all
                     # others. This means if admin is also an owner admin_row that change
                     # would propagate to both objects
                     perm_rows = []
                     for _usr in q.all():
                         usr = AttributeDict(_usr.user.get_dict())
                         usr.permission = _usr.permission.permission_name
                         perm_rows.append(usr)
                     # filter the perm rows by 'default' first and then sort them by
                     # admin,write,read,none permissions sorted again alphabetically in
                     # each group
                     perm_rows = sorted(perm_rows, key=display_sort)
                     _admin_perm = 'usergroup.admin'
                     owner_row = []
                     if with_owner:
                         usr = AttributeDict(self.user.get_dict())
                         usr.owner_row = True
                         usr.permission = _admin_perm
                         owner_row.append(usr)
                     super_admin_rows = []
                     if with_admins:
                         for usr in User.get_all_super_admins():
                             # if this admin is also owner, don't double the record
                             if usr.user_id == owner_row[0].user_id:
                                 owner_row[0].admin_row = True
                             else:
                                 usr = AttributeDict(usr.get_dict())
                                 usr.admin_row = True
                                 usr.permission = _admin_perm
                                 super_admin_rows.append(usr)
                     return super_admin_rows + owner_row + perm_rows
                 def permission_user_groups(self):
                     q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
                     q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
                                   joinedload(UserGroupUserGroupToPerm.target_user_group),
                                   joinedload(UserGroupUserGroupToPerm.permission),)
                     perm_rows = []
                     for _user_group in q.all():
                         usr = AttributeDict(_user_group.user_group.get_dict())
                         usr.permission = _user_group.permission.permission_name
                         perm_rows.append(usr)
                     return perm_rows
                 def _get_default_perms(self, user_group, suffix=''):
                     from rhodecode.model.permission import PermissionModel
                     return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
                 def get_default_perms(self, suffix=''):
                     return self._get_default_perms(self, suffix)
                 def get_api_data(self, with_group_members=True, include_secrets=False):
                     """
                     :param include_secrets: See :meth:`User.get_api_data`, this parameter is
                        basically forwarded.
                     """
                     user_group = self
                     data = {
                         'users_group_id': user_group.users_group_id,
                         'group_name': user_group.users_group_name,
                         'group_description': user_group.user_group_description,
                         'active': user_group.users_group_active,
                         'owner': user_group.user.username,
                     }
                     if with_group_members:
                         users = []
                         for user in user_group.members:
                             user = user.user
                             users.append(user.get_api_data(include_secrets=include_secrets))
                         data['users'] = users
                     return data
             class UserGroupMember(Base, BaseModel):
                 __tablename__ = 'users_groups_members'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 user = relationship('User', lazy='joined')
                 users_group = relationship('UserGroup')
                 def __init__(self, gr_id='', u_id=''):
                     self.users_group_id = gr_id
                     self.user_id = u_id
             class RepositoryField(Base, BaseModel):
                 __tablename__ = 'repositories_fields'
                 __table_args__ = (
                     UniqueConstraint('repository_id', 'field_key'),  # no-multi field
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields
                 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
                 field_key = Column("field_key", String(250))
                 field_label = Column("field_label", String(1024), nullable=False)
                 field_value = Column("field_value", String(10000), nullable=False)
                 field_desc = Column("field_desc", String(1024), nullable=False)
                 field_type = Column("field_type", String(255), nullable=False, unique=None)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 repository = relationship('Repository')
                 @property
                 def field_key_prefixed(self):
                     return 'ex_%s' % self.field_key
                 @classmethod
                 def un_prefix_key(cls, key):
                     if key.startswith(cls.PREFIX):
                         return key[len(cls.PREFIX):]
                     return key
                 @classmethod
                 def get_by_key_name(cls, key, repo):
                     row = cls.query()\
                             .filter(cls.repository == repo)\
                             .filter(cls.field_key == key).scalar()
                     return row
             class Repository(Base, BaseModel):
                 __tablename__ = 'repositories'
                 __table_args__ = (
                     Index('r_repo_name_idx', 'repo_name', mysql_length=255),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
                 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
                 STATE_CREATED = 'repo_state_created'
                 STATE_PENDING = 'repo_state_pending'
                 STATE_ERROR = 'repo_state_error'
                 LOCK_AUTOMATIC = 'lock_auto'
                 LOCK_API = 'lock_api'
                 LOCK_WEB = 'lock_web'
                 LOCK_PULL = 'lock_pull'
                 NAME_SEP = URL_SEP
                 repo_id = Column(
                     "repo_id", Integer(), nullable=False, unique=True, default=None,
                     primary_key=True)
                 _repo_name = Column(
                     "repo_name", Text(), nullable=False, default=None)
                 _repo_name_hash = Column(
                     "repo_name_hash", String(255), nullable=False, unique=True)
                 repo_state = Column("repo_state", String(255), nullable=True)
                 clone_uri = Column(
                     "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
                     default=None)
                 repo_type = Column(
                     "repo_type", String(255), nullable=False, unique=False, default=None)
                 user_id = Column(
                     "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
                     unique=False, default=None)
                 private = Column(
                     "private", Boolean(), nullable=True, unique=None, default=None)
                 enable_statistics = Column(
                     "statistics", Boolean(), nullable=True, unique=None, default=True)
                 enable_downloads = Column(
                     "downloads", Boolean(), nullable=True, unique=None, default=True)
                 description = Column(
                     "description", String(10000), nullable=True, unique=None, default=None)
                 created_on = Column(
                     'created_on', DateTime(timezone=False), nullable=True, unique=None,
                     default=datetime.datetime.now)
                 updated_on = Column(
                     'updated_on', DateTime(timezone=False), nullable=True, unique=None,
                     default=datetime.datetime.now)
                 _landing_revision = Column(
                     "landing_revision", String(255), nullable=False, unique=False,
                     default=None)
                 enable_locking = Column(
                     "enable_locking", Boolean(), nullable=False, unique=None,
                     default=False)
                 _locked = Column(
                     "locked", String(255), nullable=True, unique=False, default=None)
                 _changeset_cache = Column(
                     "changeset_cache", LargeBinary(), nullable=True)  # JSON data
                 fork_id = Column(
                     "fork_id", Integer(), ForeignKey('repositories.repo_id'),
                     nullable=True, unique=False, default=None)
                 group_id = Column(
                     "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
                     unique=False, default=None)
                 user = relationship('User', lazy='joined')
                 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
                 group = relationship('RepoGroup', lazy='joined')
                 repo_to_perm = relationship(
                     'UserRepoToPerm', cascade='all',
                     order_by='UserRepoToPerm.repo_to_perm_id')
                 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
                 stats = relationship('Statistics', cascade='all', uselist=False)
                 followers = relationship(
                     'UserFollowing',
                     primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
                     cascade='all')
                 extra_fields = relationship(
                     'RepositoryField', cascade="all, delete, delete-orphan")
                 logs = relationship('UserLog')
                 comments = relationship(
                     'ChangesetComment', cascade="all, delete, delete-orphan")
                 pull_requests_source = relationship(
                     'PullRequest',
                     primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
                     cascade="all, delete, delete-orphan")
                 pull_requests_target = relationship(
                     'PullRequest',
                     primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
                     cascade="all, delete, delete-orphan")
                 ui = relationship('RepoRhodeCodeUi', cascade="all")
                 settings = relationship('RepoRhodeCodeSetting', cascade="all")
                 integrations = relationship('Integration',
                                             cascade="all, delete, delete-orphan")
                 def __unicode__(self):
                     return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
                                                safe_unicode(self.repo_name))
                 @hybrid_property
                 def landing_rev(self):
                     # always should return [rev_type, rev]
                     if self._landing_revision:
                         _rev_info = self._landing_revision.split(':')
                         if len(_rev_info) < 2:
                             _rev_info.insert(0, 'rev')
                         return [_rev_info[0], _rev_info[1]]
                     return [None, None]
                 @landing_rev.setter
                 def landing_rev(self, val):
                     if ':' not in val:
                         raise ValueError('value must be delimited with `:` and consist '
                                          'of <rev_type>:<rev>, got %s instead' % val)
                     self._landing_revision = val
                 @hybrid_property
                 def locked(self):
                     if self._locked:
                         user_id, timelocked, reason = self._locked.split(':')
                         lock_values = int(user_id), timelocked, reason
                     else:
                         lock_values = [None, None, None]
                     return lock_values
                 @locked.setter
                 def locked(self, val):
                     if val and isinstance(val, (list, tuple)):
                         self._locked = ':'.join(map(str, val))
                     else:
                         self._locked = None
                 @hybrid_property
                 def changeset_cache(self):
                     from rhodecode.lib.vcs.backends.base import EmptyCommit
                     dummy = EmptyCommit().__json__()
                     if not self._changeset_cache:
                         return dummy
                     try:
                         return json.loads(self._changeset_cache)
                     except TypeError:
                         return dummy
                     except Exception:
                         log.error(traceback.format_exc())
                         return dummy
                 @changeset_cache.setter
                 def changeset_cache(self, val):
                     try:
                         self._changeset_cache = json.dumps(val)
                     except Exception:
                         log.error(traceback.format_exc())
                 @hybrid_property
                 def repo_name(self):
                     return self._repo_name
                 @repo_name.setter
                 def repo_name(self, value):
                     self._repo_name = value
                     self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
                 @classmethod
                 def normalize_repo_name(cls, repo_name):
                     """
                     Normalizes os specific repo_name to the format internally stored inside
                     database using URL_SEP
                     :param cls:
                     :param repo_name:
                     """
                     return cls.NAME_SEP.join(repo_name.split(os.sep))
                 @classmethod
                 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
                     session = Session()
                     q = session.query(cls).filter(cls.repo_name == repo_name)
                     if cache:
                         if identity_cache:
                             val = cls.identity_cache(session, 'repo_name', repo_name)
                             if val:
                                 return val
                         else:
                             q = q.options(
                                 FromCache("sql_cache_short",
                                           "get_repo_by_name_%s" % _hash_key(repo_name)))
                     return q.scalar()
                 @classmethod
                 def get_by_full_path(cls, repo_full_path):
                     repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
                     repo_name = cls.normalize_repo_name(repo_name)
                     return cls.get_by_repo_name(repo_name.strip(URL_SEP))
                 @classmethod
                 def get_repo_forks(cls, repo_id):
                     return cls.query().filter(Repository.fork_id == repo_id)
                 @classmethod
                 def base_path(cls):
                     """
                     Returns base path when all repos are stored
                     :param cls:
                     """
                     q = Session().query(RhodeCodeUi)\
                         .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
                     q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
                     return q.one().ui_value
                 @classmethod
                 def is_valid(cls, repo_name):
                     """
                     returns True if given repo name is a valid filesystem repository
                     :param cls:
                     :param repo_name:
                     """
                     from rhodecode.lib.utils import is_valid_repo
                     return is_valid_repo(repo_name, cls.base_path())
                 @classmethod
                 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
                                   case_insensitive=True):
                     q = Repository.query()
                     if not isinstance(user_id, Optional):
                         q = q.filter(Repository.user_id == user_id)
                     if not isinstance(group_id, Optional):
                         q = q.filter(Repository.group_id == group_id)
                     if case_insensitive:
                         q = q.order_by(func.lower(Repository.repo_name))
                     else:
                         q = q.order_by(Repository.repo_name)
                     return q.all()
                 @property
                 def forks(self):
                     """
                     Return forks of this repo
                     """
                     return Repository.get_repo_forks(self.repo_id)
                 @property
                 def parent(self):
                     """
                     Returns fork parent
                     """
                     return self.fork
                 @property
                 def just_name(self):
                     return self.repo_name.split(self.NAME_SEP)[-1]
                 @property
                 def groups_with_parents(self):
                     groups = []
                     if self.group is None:
                         return groups
                     cur_gr = self.group
                     groups.insert(0, cur_gr)
                     while 1:
                         gr = getattr(cur_gr, 'parent_group', None)
                         cur_gr = cur_gr.parent_group
                         if gr is None:
                             break
                         groups.insert(0, gr)
                     return groups
                 @property
                 def groups_and_repo(self):
                     return self.groups_with_parents, self
                 @LazyProperty
                 def repo_path(self):
                     """
                     Returns base full path for that repository means where it actually
                     exists on a filesystem
                     """
                     q = Session().query(RhodeCodeUi).filter(
                         RhodeCodeUi.ui_key == self.NAME_SEP)
                     q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
                     return q.one().ui_value
                 @property
                 def repo_full_path(self):
                     p = [self.repo_path]
                     # we need to split the name by / since this is how we store the
                     # names in the database, but that eventually needs to be converted
                     # into a valid system path
                     p += self.repo_name.split(self.NAME_SEP)
                     return os.path.join(*map(safe_unicode, p))
                 @property
                 def cache_keys(self):
                     """
                     Returns associated cache keys for that repo
                     """
                     return CacheKey.query()\
                         .filter(CacheKey.cache_args == self.repo_name)\
                         .order_by(CacheKey.cache_key)\
                         .all()
                 def get_new_name(self, repo_name):
                     """
                     returns new full repository name based on assigned group and new new
                     :param group_name:
                     """
                     path_prefix = self.group.full_path_splitted if self.group else []
                     return self.NAME_SEP.join(path_prefix + [repo_name])
                 @property
                 def _config(self):
                     """
                     Returns db based config object.
                     """
                     from rhodecode.lib.utils import make_db_config
                     return make_db_config(clear_session=False, repo=self)
                 def permissions(self, with_admins=True, with_owner=True):
                     q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
                     q = q.options(joinedload(UserRepoToPerm.repository),
                                   joinedload(UserRepoToPerm.user),
                                   joinedload(UserRepoToPerm.permission),)
                     # get owners and admins and permissions. We do a trick of re-writing
                     # objects from sqlalchemy to named-tuples due to sqlalchemy session
                     # has a global reference and changing one object propagates to all
                     # others. This means if admin is also an owner admin_row that change
                     # would propagate to both objects
                     perm_rows = []
                     for _usr in q.all():
                         usr = AttributeDict(_usr.user.get_dict())
                         usr.permission = _usr.permission.permission_name
                         perm_rows.append(usr)
                     # filter the perm rows by 'default' first and then sort them by
                     # admin,write,read,none permissions sorted again alphabetically in
                     # each group
                     perm_rows = sorted(perm_rows, key=display_sort)
                     _admin_perm = 'repository.admin'
                     owner_row = []
                     if with_owner:
                         usr = AttributeDict(self.user.get_dict())
                         usr.owner_row = True
                         usr.permission = _admin_perm
                         owner_row.append(usr)
                     super_admin_rows = []
                     if with_admins:
                         for usr in User.get_all_super_admins():
                             # if this admin is also owner, don't double the record
                             if usr.user_id == owner_row[0].user_id:
                                 owner_row[0].admin_row = True
                             else:
                                 usr = AttributeDict(usr.get_dict())
                                 usr.admin_row = True
                                 usr.permission = _admin_perm
                                 super_admin_rows.append(usr)
                     return super_admin_rows + owner_row + perm_rows
                 def permission_user_groups(self):
                     q = UserGroupRepoToPerm.query().filter(
                         UserGroupRepoToPerm.repository == self)
                     q = q.options(joinedload(UserGroupRepoToPerm.repository),
                                   joinedload(UserGroupRepoToPerm.users_group),
                                   joinedload(UserGroupRepoToPerm.permission),)
                     perm_rows = []
                     for _user_group in q.all():
                         usr = AttributeDict(_user_group.users_group.get_dict())
                         usr.permission = _user_group.permission.permission_name
                         perm_rows.append(usr)
                     return perm_rows
                 def get_api_data(self, include_secrets=False):
                     """
                     Common function for generating repo api data
                     :param include_secrets: See :meth:`User.get_api_data`.
                     """
                     # TODO: mikhail: Here there is an anti-pattern, we probably need to
                     # move this methods on models level.
                     from rhodecode.model.settings import SettingsModel
                     repo = self
                     _user_id, _time, _reason = self.locked
                     data = {
                         'repo_id': repo.repo_id,
                         'repo_name': repo.repo_name,
                         'repo_type': repo.repo_type,
                         'clone_uri': repo.clone_uri or '',
                         'url': url('summary_home', repo_name=self.repo_name, qualified=True),
                         'private': repo.private,
                         'created_on': repo.created_on,
                         'description': repo.description,
                         'landing_rev': repo.landing_rev,
                         'owner': repo.user.username,
                         'fork_of': repo.fork.repo_name if repo.fork else None,
                         'enable_statistics': repo.enable_statistics,
                         'enable_locking': repo.enable_locking,
                         'enable_downloads': repo.enable_downloads,
                         'last_changeset': repo.changeset_cache,
                         'locked_by': User.get(_user_id).get_api_data(
                             include_secrets=include_secrets) if _user_id else None,
                         'locked_date': time_to_datetime(_time) if _time else None,
                         'lock_reason': _reason if _reason else None,
                     }
                     # TODO: mikhail: should be per-repo settings here
                     rc_config = SettingsModel().get_all_settings()
                     repository_fields = str2bool(
                         rc_config.get('rhodecode_repository_fields'))
                     if repository_fields:
                         for f in self.extra_fields:
                             data[f.field_key_prefixed] = f.field_value
                     return data
                 @classmethod
                 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
                     if not lock_time:
                         lock_time = time.time()
                     if not lock_reason:
                         lock_reason = cls.LOCK_AUTOMATIC
                     repo.locked = [user_id, lock_time, lock_reason]
                     Session().add(repo)
                     Session().commit()
                 @classmethod
                 def unlock(cls, repo):
                     repo.locked = None
                     Session().add(repo)
                     Session().commit()
                 @classmethod
                 def getlock(cls, repo):
                     return repo.locked
                 def is_user_lock(self, user_id):
                     if self.lock[0]:
                         lock_user_id = safe_int(self.lock[0])
                         user_id = safe_int(user_id)
                         # both are ints, and they are equal
                         return all([lock_user_id, user_id]) and lock_user_id == user_id
                     return False
                 def get_locking_state(self, action, user_id, only_when_enabled=True):
                     """
                     Checks locking on this repository, if locking is enabled and lock is
                     present returns a tuple of make_lock, locked, locked_by.
                     make_lock can have 3 states None (do nothing) True, make lock
                     False release lock, This value is later propagated to hooks, which
                     do the locking. Think about this as signals passed to hooks what to do.
                     """
                     # TODO: johbo: This is part of the business logic and should be moved
                     # into the RepositoryModel.
                     if action not in ('push', 'pull'):
                         raise ValueError("Invalid action value: %s" % repr(action))
                     # defines if locked error should be thrown to user
                     currently_locked = False
                     # defines if new lock should be made, tri-state
                     make_lock = None
                     repo = self
                     user = User.get(user_id)
                     lock_info = repo.locked
                     if repo and (repo.enable_locking or not only_when_enabled):
                         if action == 'push':
                             # check if it's already locked !, if it is compare users
                             locked_by_user_id = lock_info[0]
                             if user.user_id == locked_by_user_id:
                                 log.debug(
                                     'Got `push` action from user %s, now unlocking', user)
                                 # unlock if we have push from user who locked
                                 make_lock = False
                             else:
                                 # we're not the same user who locked, ban with
                                 # code defined in settings (default is 423 HTTP Locked) !
                                 log.debug('Repo %s is currently locked by %s', repo, user)
                                 currently_locked = True
                         elif action == 'pull':
                             # [0] user [1] date
                             if lock_info[0] and lock_info[1]:
                                 log.debug('Repo %s is currently locked by %s', repo, user)
                                 currently_locked = True
                             else:
                                 log.debug('Setting lock on repo %s by %s', repo, user)
                                 make_lock = True
                     else:
                         log.debug('Repository %s do not have locking enabled', repo)
                     log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
                               make_lock, currently_locked, lock_info)
                     from rhodecode.lib.auth import HasRepoPermissionAny
                     perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
                     if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
                         # if we don't have at least write permission we cannot make a lock
                         log.debug('lock state reset back to FALSE due to lack '
                                   'of at least read permission')
                         make_lock = False
                     return make_lock, currently_locked, lock_info
                 @property
                 def last_db_change(self):
                     return self.updated_on
                 @property
                 def clone_uri_hidden(self):
                     clone_uri = self.clone_uri
                     if clone_uri:
                         import urlobject
                         url_obj = urlobject.URLObject(clone_uri)
                         if url_obj.password:
                             clone_uri = url_obj.with_password('*****')
                     return clone_uri
                 def clone_url(self, **override):
                     qualified_home_url = url('home', qualified=True)
                     uri_tmpl = None
                     if 'with_id' in override:
                         uri_tmpl = self.DEFAULT_CLONE_URI_ID
                         del override['with_id']
                     if 'uri_tmpl' in override:
                         uri_tmpl = override['uri_tmpl']
                         del override['uri_tmpl']
                     # we didn't override our tmpl from **overrides
                     if not uri_tmpl:
                         uri_tmpl = self.DEFAULT_CLONE_URI
                         try:
                             from pylons import tmpl_context as c
                             uri_tmpl = c.clone_uri_tmpl
                         except Exception:
                             # in any case if we call this outside of request context,
                             # ie, not having tmpl_context set up
                             pass
                     return get_clone_url(uri_tmpl=uri_tmpl,
                                          qualifed_home_url=qualified_home_url,
                                          repo_name=self.repo_name,
                                          repo_id=self.repo_id, **override)
                 def set_state(self, state):
                     self.repo_state = state
                     Session().add(self)
                 #==========================================================================
                 # SCM PROPERTIES
                 #==========================================================================
                 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
                     return get_commit_safe(
                         self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
                 def get_changeset(self, rev=None, pre_load=None):
                     warnings.warn("Use get_commit", DeprecationWarning)
                     commit_id = None
                     commit_idx = None
                     if isinstance(rev, basestring):
                         commit_id = rev
                     else:
                         commit_idx = rev
                     return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
                                            pre_load=pre_load)
                 def get_landing_commit(self):
                     """
                     Returns landing commit, or if that doesn't exist returns the tip
                     """
                     _rev_type, _rev = self.landing_rev
                     commit = self.get_commit(_rev)
                     if isinstance(commit, EmptyCommit):
                         return self.get_commit()
                     return commit
                 def update_commit_cache(self, cs_cache=None, config=None):
                     """
                     Update cache of last changeset for repository, keys should be::
                         short_id
                         raw_id
                         revision
                         parents
                         message
                         date
                         author
                     :param cs_cache:
                     """
                     from rhodecode.lib.vcs.backends.base import BaseChangeset
                     if cs_cache is None:
                         # use no-cache version here
                         scm_repo = self.scm_instance(cache=False, config=config)
                         if scm_repo:
                             cs_cache = scm_repo.get_commit(
                                 pre_load=["author", "date", "message", "parents"])
                         else:
                             cs_cache = EmptyCommit()
                     if isinstance(cs_cache, BaseChangeset):
                         cs_cache = cs_cache.__json__()
                     def is_outdated(new_cs_cache):
                         if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
                             new_cs_cache['revision'] != self.changeset_cache['revision']):
                             return True
                         return False
                     # check if we have maybe already latest cached revision
                     if is_outdated(cs_cache) or not self.changeset_cache:
                         _default = datetime.datetime.fromtimestamp(0)
                         last_change = cs_cache.get('date') or _default
                         log.debug('updated repo %s with new cs cache %s',
                                   self.repo_name, cs_cache)
                         self.updated_on = last_change
                         self.changeset_cache = cs_cache
                         Session().add(self)
                         Session().commit()
                     else:
                         log.debug('Skipping update_commit_cache for repo:`%s` '
                                   'commit already with latest changes', self.repo_name)
                 @property
                 def tip(self):
                     return self.get_commit('tip')
                 @property
                 def author(self):
                     return self.tip.author
                 @property
                 def last_change(self):
                     return self.scm_instance().last_change
                 def get_comments(self, revisions=None):
                     """
                     Returns comments for this repository grouped by revisions
                     :param revisions: filter query by revisions only
                     """
                     cmts = ChangesetComment.query()\
                         .filter(ChangesetComment.repo == self)
                     if revisions:
                         cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
                     grouped = collections.defaultdict(list)
                     for cmt in cmts.all():
                         grouped[cmt.revision].append(cmt)
                     return grouped
                 def statuses(self, revisions=None):
                     """
                     Returns statuses for this repository
                     :param revisions: list of revisions to get statuses for
                     """
                     statuses = ChangesetStatus.query()\
                         .filter(ChangesetStatus.repo == self)\
                         .filter(ChangesetStatus.version == 0)
                     if revisions:
                         # Try doing the filtering in chunks to avoid hitting limits
                         size = 500
                         status_results = []
                         for chunk in xrange(0, len(revisions), size):
                             status_results += statuses.filter(
                                 ChangesetStatus.revision.in_(
                                     revisions[chunk: chunk+size])
                             ).all()
                     else:
                         status_results = statuses.all()
                     grouped = {}
                     # maybe we have open new pullrequest without a status?
                     stat = ChangesetStatus.STATUS_UNDER_REVIEW
                     status_lbl = ChangesetStatus.get_status_lbl(stat)
                     for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
                         for rev in pr.revisions:
                             pr_id = pr.pull_request_id
                             pr_repo = pr.target_repo.repo_name
                             grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
                     for stat in status_results:
                         pr_id = pr_repo = None
                         if stat.pull_request:
                             pr_id = stat.pull_request.pull_request_id
                             pr_repo = stat.pull_request.target_repo.repo_name
                         grouped[stat.revision] = [str(stat.status), stat.status_lbl,
                                                   pr_id, pr_repo]
                     return grouped
                 # ==========================================================================
                 # SCM CACHE INSTANCE
                 # ==========================================================================
                 def scm_instance(self, **kwargs):
                     import rhodecode
                     # Passing a config will not hit the cache currently only used
                     # for repo2dbmapper
                     config = kwargs.pop('config', None)
                     cache = kwargs.pop('cache', None)
                     full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
                     # if cache is NOT defined use default global, else we have a full
                     # control over cache behaviour
                     if cache is None and full_cache and not config:
                         return self._get_instance_cached()
                     return self._get_instance(cache=bool(cache), config=config)
                 def _get_instance_cached(self):
                     @cache_region('long_term')
                     def _get_repo(cache_key):
                         return self._get_instance()
                     invalidator_context = CacheKey.repo_context_cache(
                         _get_repo, self.repo_name, None, thread_scoped=True)
                     with invalidator_context as context:
                         context.invalidate()
                         repo = context.compute()
                     return repo
                 def _get_instance(self, cache=True, config=None):
                     config = config or self._config
                     custom_wire = {
                         'cache': cache  # controls the vcs.remote cache
                     }
                     repo = get_vcs_instance(
                         repo_path=safe_str(self.repo_full_path),
                         config=config,
                         with_wire=custom_wire,
                         create=False)
                     return repo
                 def __json__(self):
                     return {'landing_rev': self.landing_rev}
                 def get_dict(self):
                     # Since we transformed `repo_name` to a hybrid property, we need to
                     # keep compatibility with the code which uses `repo_name` field.
                     result = super(Repository, self).get_dict()
                     result['repo_name'] = result.pop('_repo_name', None)
                     return result
             class RepoGroup(Base, BaseModel):
                 __tablename__ = 'groups'
                 __table_args__ = (
                     UniqueConstraint('group_name', 'group_parent_id'),
                     CheckConstraint('group_id != group_parent_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 __mapper_args__ = {'order_by': 'group_name'}
                 CHOICES_SEPARATOR = '/'  # used to generate select2 choices for nested groups
                 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
                 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
                 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
                 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
                 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
                 parent_group = relationship('RepoGroup', remote_side=group_id)
                 user = relationship('User')
                 integrations = relationship('Integration',
                                             cascade="all, delete, delete-orphan")
                 def __init__(self, group_name='', parent_group=None):
                     self.group_name = group_name
                     self.parent_group = parent_group
                 def __unicode__(self):
                     return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
                                                   self.group_name)
                 @classmethod
                 def _generate_choice(cls, repo_group):
                     from webhelpers.html import literal as _literal
                     _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
                     return repo_group.group_id, _name(repo_group.full_path_splitted)
                 @classmethod
                 def groups_choices(cls, groups=None, show_empty_group=True):
                     if not groups:
                         groups = cls.query().all()
                     repo_groups = []
                     if show_empty_group:
                         repo_groups = [('-1', u'-- %s --' % _('No parent'))]
                     repo_groups.extend([cls._generate_choice(x) for x in groups])
                     repo_groups = sorted(
                         repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
                     return repo_groups
                 @classmethod
                 def url_sep(cls):
                     return URL_SEP
                 @classmethod
                 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
                     if case_insensitive:
                         gr = cls.query().filter(func.lower(cls.group_name)
                                                 == func.lower(group_name))
                     else:
                         gr = cls.query().filter(cls.group_name == group_name)
                     if cache:
                         gr = gr.options(FromCache(
                                         "sql_cache_short",
                                         "get_group_%s" % _hash_key(group_name)))
                     return gr.scalar()
                 @classmethod
                 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
                                         case_insensitive=True):
                     q = RepoGroup.query()
                     if not isinstance(user_id, Optional):
                         q = q.filter(RepoGroup.user_id == user_id)
                     if not isinstance(group_id, Optional):
                         q = q.filter(RepoGroup.group_parent_id == group_id)
                     if case_insensitive:
                         q = q.order_by(func.lower(RepoGroup.group_name))
                     else:
                         q = q.order_by(RepoGroup.group_name)
                     return q.all()
                 @property
                 def parents(self):
                     parents_recursion_limit = 10
                     groups = []
                     if self.parent_group is None:
                         return groups
                     cur_gr = self.parent_group
                     groups.insert(0, cur_gr)
                     cnt = 0
                     while 1:
                         cnt += 1
                         gr = getattr(cur_gr, 'parent_group', None)
                         cur_gr = cur_gr.parent_group
                         if gr is None:
                             break
                         if cnt == parents_recursion_limit:
                             # this will prevent accidental infinit loops
                             log.error(('more than %s parents found for group %s, stopping '
                                        'recursive parent fetching' % (parents_recursion_limit, self)))
                             break
                         groups.insert(0, gr)
                     return groups
                 @property
                 def children(self):
                     return RepoGroup.query().filter(RepoGroup.parent_group == self)
                 @property
                 def name(self):
                     return self.group_name.split(RepoGroup.url_sep())[-1]
                 @property
                 def full_path(self):
                     return self.group_name
                 @property
                 def full_path_splitted(self):
                     return self.group_name.split(RepoGroup.url_sep())
                 @property
                 def repositories(self):
                     return Repository.query()\
                             .filter(Repository.group == self)\
                             .order_by(Repository.repo_name)
                 @property
                 def repositories_recursive_count(self):
                     cnt = self.repositories.count()
                     def children_count(group):
                         cnt = 0
                         for child in group.children:
                             cnt += child.repositories.count()
                             cnt += children_count(child)
                         return cnt
                     return cnt + children_count(self)
                 def _recursive_objects(self, include_repos=True):
                     all_ = []
                     def _get_members(root_gr):
                         if include_repos:
                             for r in root_gr.repositories:
                                 all_.append(r)
                         childs = root_gr.children.all()
                         if childs:
                             for gr in childs:
                                 all_.append(gr)
                                 _get_members(gr)
                     _get_members(self)
                     return [self] + all_
                 def recursive_groups_and_repos(self):
                     """
                     Recursive return all groups, with repositories in those groups
                     """
                     return self._recursive_objects()
                 def recursive_groups(self):
                     """
                     Returns all children groups for this group including children of children
                     """
                     return self._recursive_objects(include_repos=False)
                 def get_new_name(self, group_name):
                     """
                     returns new full group name based on parent and new name
                     :param group_name:
                     """
                     path_prefix = (self.parent_group.full_path_splitted if
                                    self.parent_group else [])
                     return RepoGroup.url_sep().join(path_prefix + [group_name])
                 def permissions(self, with_admins=True, with_owner=True):
                     q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
                     q = q.options(joinedload(UserRepoGroupToPerm.group),
                                   joinedload(UserRepoGroupToPerm.user),
                                   joinedload(UserRepoGroupToPerm.permission),)
                     # get owners and admins and permissions. We do a trick of re-writing
                     # objects from sqlalchemy to named-tuples due to sqlalchemy session
                     # has a global reference and changing one object propagates to all
                     # others. This means if admin is also an owner admin_row that change
                     # would propagate to both objects
                     perm_rows = []
                     for _usr in q.all():
                         usr = AttributeDict(_usr.user.get_dict())
                         usr.permission = _usr.permission.permission_name
                         perm_rows.append(usr)
                     # filter the perm rows by 'default' first and then sort them by
                     # admin,write,read,none permissions sorted again alphabetically in
                     # each group
                     perm_rows = sorted(perm_rows, key=display_sort)
                     _admin_perm = 'group.admin'
                     owner_row = []
                     if with_owner:
                         usr = AttributeDict(self.user.get_dict())
                         usr.owner_row = True
                         usr.permission = _admin_perm
                         owner_row.append(usr)
                     super_admin_rows = []
                     if with_admins:
                         for usr in User.get_all_super_admins():
                             # if this admin is also owner, don't double the record
                             if usr.user_id == owner_row[0].user_id:
                                 owner_row[0].admin_row = True
                             else:
                                 usr = AttributeDict(usr.get_dict())
                                 usr.admin_row = True
                                 usr.permission = _admin_perm
                                 super_admin_rows.append(usr)
                     return super_admin_rows + owner_row + perm_rows
                 def permission_user_groups(self):
                     q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
                     q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
                                   joinedload(UserGroupRepoGroupToPerm.users_group),
                                   joinedload(UserGroupRepoGroupToPerm.permission),)
                     perm_rows = []
                     for _user_group in q.all():
                         usr = AttributeDict(_user_group.users_group.get_dict())
                         usr.permission = _user_group.permission.permission_name
                         perm_rows.append(usr)
                     return perm_rows
                 def get_api_data(self):
                     """
                     Common function for generating api data
                     """
                     group = self
                     data = {
                         'group_id': group.group_id,
                         'group_name': group.group_name,
                         'group_description': group.group_description,
                         'parent_group': group.parent_group.group_name if group.parent_group else None,
                         'repositories': [x.repo_name for x in group.repositories],
                         'owner': group.user.username,
                     }
                     return data
             class Permission(Base, BaseModel):
                 __tablename__ = 'permissions'
                 __table_args__ = (
                     Index('p_perm_name_idx', 'permission_name'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 PERMS = [
                     ('hg.admin', _('RhodeCode Super Administrator')),
                     ('repository.none', _('Repository no access')),
                     ('repository.read', _('Repository read access')),
                     ('repository.write', _('Repository write access')),
                     ('repository.admin', _('Repository admin access')),
                     ('group.none', _('Repository group no access')),
                     ('group.read', _('Repository group read access')),
                     ('group.write', _('Repository group write access')),
                     ('group.admin', _('Repository group admin access')),
                     ('usergroup.none', _('User group no access')),
                     ('usergroup.read', _('User group read access')),
                     ('usergroup.write', _('User group write access')),
                     ('usergroup.admin', _('User group admin access')),
                     ('hg.repogroup.create.false', _('Repository Group creation disabled')),
                     ('hg.repogroup.create.true', _('Repository Group creation enabled')),
                     ('hg.usergroup.create.false', _('User Group creation disabled')),
                     ('hg.usergroup.create.true', _('User Group creation enabled')),
                     ('hg.create.none', _('Repository creation disabled')),
                     ('hg.create.repository', _('Repository creation enabled')),
                     ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
                     ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
                     ('hg.fork.none', _('Repository forking disabled')),
                     ('hg.fork.repository', _('Repository forking enabled')),
                     ('hg.register.none', _('Registration disabled')),
                     ('hg.register.manual_activate', _('User Registration with manual account activation')),
                     ('hg.register.auto_activate', _('User Registration with automatic account activation')),
                     ('hg.extern_activate.manual', _('Manual activation of external account')),
                     ('hg.extern_activate.auto', _('Automatic activation of external account')),
                     ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
                     ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
                 ]
                 # definition of system default permissions for DEFAULT user
                 DEFAULT_USER_PERMISSIONS = [
                     'repository.read',
                     'group.read',
                     'usergroup.read',
                     'hg.create.repository',
                     'hg.repogroup.create.false',
                     'hg.usergroup.create.false',
                     'hg.create.write_on_repogroup.true',
                     'hg.fork.repository',
                     'hg.register.manual_activate',
                     'hg.extern_activate.auto',
                     'hg.inherit_default_perms.true',
                 ]
                 # defines which permissions are more important higher the more important
                 # Weight defines which permissions are more important.
                 # The higher number the more important.
                 PERM_WEIGHTS = {
                     'repository.none': 0,
                     'repository.read': 1,
                     'repository.write': 3,
                     'repository.admin': 4,
                     'group.none': 0,
                     'group.read': 1,
                     'group.write': 3,
                     'group.admin': 4,
                     'usergroup.none': 0,
                     'usergroup.read': 1,
                     'usergroup.write': 3,
                     'usergroup.admin': 4,
                     'hg.repogroup.create.false': 0,
                     'hg.repogroup.create.true': 1,
                     'hg.usergroup.create.false': 0,
                     'hg.usergroup.create.true': 1,
                     'hg.fork.none': 0,
                     'hg.fork.repository': 1,
                     'hg.create.none': 0,
                     'hg.create.repository': 1
                 }
                 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
                 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
                 def __unicode__(self):
                     return u"<%s('%s:%s')>" % (
                         self.__class__.__name__, self.permission_id, self.permission_name
                     )
                 @classmethod
                 def get_by_key(cls, key):
                     return cls.query().filter(cls.permission_name == key).scalar()
                 @classmethod
                 def get_default_repo_perms(cls, user_id, repo_id=None):
                     q = Session().query(UserRepoToPerm, Repository, Permission)\
                         .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
                         .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
                         .filter(UserRepoToPerm.user_id == user_id)
                     if repo_id:
                         q = q.filter(UserRepoToPerm.repository_id == repo_id)
                     return q.all()
                 @classmethod
                 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
                     q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
                         .join(
                             Permission,
                             UserGroupRepoToPerm.permission_id == Permission.permission_id)\
                         .join(
                             Repository,
                             UserGroupRepoToPerm.repository_id == Repository.repo_id)\
                         .join(
                             UserGroup,
                             UserGroupRepoToPerm.users_group_id ==
                             UserGroup.users_group_id)\
                         .join(
                             UserGroupMember,
                             UserGroupRepoToPerm.users_group_id ==
                             UserGroupMember.users_group_id)\
                         .filter(
                             UserGroupMember.user_id == user_id,
                             UserGroup.users_group_active == true())
                     if repo_id:
                         q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
                     return q.all()
                 @classmethod
                 def get_default_group_perms(cls, user_id, repo_group_id=None):
                     q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
                         .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
                         .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
                         .filter(UserRepoGroupToPerm.user_id == user_id)
                     if repo_group_id:
                         q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
                     return q.all()
                 @classmethod
                 def get_default_group_perms_from_user_group(
                         cls, user_id, repo_group_id=None):
                     q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
                         .join(
                             Permission,
                             UserGroupRepoGroupToPerm.permission_id ==
                             Permission.permission_id)\
                         .join(
                             RepoGroup,
                             UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
                         .join(
                             UserGroup,
                             UserGroupRepoGroupToPerm.users_group_id ==
                             UserGroup.users_group_id)\
                         .join(
                             UserGroupMember,
                             UserGroupRepoGroupToPerm.users_group_id ==
                             UserGroupMember.users_group_id)\
                         .filter(
                             UserGroupMember.user_id == user_id,
                             UserGroup.users_group_active == true())
                     if repo_group_id:
                         q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
                     return q.all()
                 @classmethod
                 def get_default_user_group_perms(cls, user_id, user_group_id=None):
                     q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
                         .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
                         .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
                         .filter(UserUserGroupToPerm.user_id == user_id)
                     if user_group_id:
                         q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
                     return q.all()
                 @classmethod
                 def get_default_user_group_perms_from_user_group(
                         cls, user_id, user_group_id=None):
                     TargetUserGroup = aliased(UserGroup, name='target_user_group')
                     q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
                         .join(
                             Permission,
                             UserGroupUserGroupToPerm.permission_id ==
                             Permission.permission_id)\
                         .join(
                             TargetUserGroup,
                             UserGroupUserGroupToPerm.target_user_group_id ==
                             TargetUserGroup.users_group_id)\
                         .join(
                             UserGroup,
                             UserGroupUserGroupToPerm.user_group_id ==
                             UserGroup.users_group_id)\
                         .join(
                             UserGroupMember,
                             UserGroupUserGroupToPerm.user_group_id ==
                             UserGroupMember.users_group_id)\
                         .filter(
                             UserGroupMember.user_id == user_id,
                             UserGroup.users_group_active == true())
                     if user_group_id:
                         q = q.filter(
                             UserGroupUserGroupToPerm.user_group_id == user_group_id)
                     return q.all()
             class UserRepoToPerm(Base, BaseModel):
                 __tablename__ = 'repo_to_perm'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'repository_id', 'permission_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
                 user = relationship('User')
                 repository = relationship('Repository')
                 permission = relationship('Permission')
                 @classmethod
                 def create(cls, user, repository, permission):
                     n = cls()
                     n.user = user
                     n.repository = repository
                     n.permission = permission
                     Session().add(n)
                     return n
                 def __unicode__(self):
                     return u'<%s => %s >' % (self.user, self.repository)
             class UserUserGroupToPerm(Base, BaseModel):
                 __tablename__ = 'user_user_group_to_perm'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 user = relationship('User')
                 user_group = relationship('UserGroup')
                 permission = relationship('Permission')
                 @classmethod
                 def create(cls, user, user_group, permission):
                     n = cls()
                     n.user = user
                     n.user_group = user_group
                     n.permission = permission
                     Session().add(n)
                     return n
                 def __unicode__(self):
                     return u'<%s => %s >' % (self.user, self.user_group)
             class UserToPerm(Base, BaseModel):
                 __tablename__ = 'user_to_perm'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'permission_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 user = relationship('User')
                 permission = relationship('Permission', lazy='joined')
                 def __unicode__(self):
                     return u'<%s => %s >' % (self.user, self.permission)
             class UserGroupRepoToPerm(Base, BaseModel):
                 __tablename__ = 'users_group_repo_to_perm'
                 __table_args__ = (
                     UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
                 users_group = relationship('UserGroup')
                 permission = relationship('Permission')
                 repository = relationship('Repository')
                 @classmethod
                 def create(cls, users_group, repository, permission):
                     n = cls()
                     n.users_group = users_group
                     n.repository = repository
                     n.permission = permission
                     Session().add(n)
                     return n
                 def __unicode__(self):
                     return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
             class UserGroupUserGroupToPerm(Base, BaseModel):
                 __tablename__ = 'user_group_user_group_to_perm'
                 __table_args__ = (
                     UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
                     CheckConstraint('target_user_group_id != user_group_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 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)
                 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
                 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
                 permission = relationship('Permission')
                 @classmethod
                 def create(cls, target_user_group, user_group, permission):
                     n = cls()
                     n.target_user_group = target_user_group
                     n.user_group = user_group
                     n.permission = permission
                     Session().add(n)
                     return n
                 def __unicode__(self):
                     return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
             class UserGroupToPerm(Base, BaseModel):
                 __tablename__ = 'users_group_to_perm'
                 __table_args__ = (
                     UniqueConstraint('users_group_id', 'permission_id',),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 users_group = relationship('UserGroup')
                 permission = relationship('Permission')
             class UserRepoGroupToPerm(Base, BaseModel):
                 __tablename__ = 'user_repo_group_to_perm'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'group_id', 'permission_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 user = relationship('User')
                 group = relationship('RepoGroup')
                 permission = relationship('Permission')
                 @classmethod
                 def create(cls, user, repository_group, permission):
                     n = cls()
                     n.user = user
                     n.group = repository_group
                     n.permission = permission
                     Session().add(n)
                     return n
             class UserGroupRepoGroupToPerm(Base, BaseModel):
                 __tablename__ = 'users_group_repo_group_to_perm'
                 __table_args__ = (
                     UniqueConstraint('users_group_id', 'group_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 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)
                 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
                 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
                 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
                 users_group = relationship('UserGroup')
                 permission = relationship('Permission')
                 group = relationship('RepoGroup')
                 @classmethod
                 def create(cls, user_group, repository_group, permission):
                     n = cls()
                     n.users_group = user_group
                     n.group = repository_group
                     n.permission = permission
                     Session().add(n)
                     return n
                 def __unicode__(self):
                     return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
             class Statistics(Base, BaseModel):
                 __tablename__ = 'statistics'
                 __table_args__ = (
                      UniqueConstraint('repository_id'),
                      {'extend_existing': True, 'mysql_engine': 'InnoDB',
                       'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
                 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
                 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
                 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
                 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
                 repository = relationship('Repository', single_parent=True)
             class UserFollowing(Base, BaseModel):
                 __tablename__ = 'user_followings'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'follows_repository_id'),
                     UniqueConstraint('user_id', 'follows_user_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
                 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
                 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
                 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
                 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
                 follows_repository = relationship('Repository', order_by='Repository.repo_name')
                 @classmethod
                 def get_repo_followers(cls, repo_id):
                     return cls.query().filter(cls.follows_repo_id == repo_id)
             class CacheKey(Base, BaseModel):
                 __tablename__ = 'cache_invalidation'
                 __table_args__ = (
                     UniqueConstraint('cache_key'),
                     Index('key_idx', 'cache_key'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 CACHE_TYPE_ATOM = 'ATOM'
                 CACHE_TYPE_RSS = 'RSS'
                 CACHE_TYPE_README = 'README'
                 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
                 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
                 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
                 def __init__(self, cache_key, cache_args=''):
                     self.cache_key = cache_key
                     self.cache_args = cache_args
                     self.cache_active = False
                 def __unicode__(self):
                     return u"<%s('%s:%s[%s]')>" % (
                         self.__class__.__name__,
                         self.cache_id, self.cache_key, self.cache_active)
                 def _cache_key_partition(self):
                     prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
                     return prefix, repo_name, suffix
                 def get_prefix(self):
                     """
                     Try to extract prefix from existing cache key. The key could consist
                     of prefix, repo_name, suffix
                     """
                     # this returns prefix, repo_name, suffix
                     return self._cache_key_partition()[0]
                 def get_suffix(self):
                     """
                     get suffix that might have been used in _get_cache_key to
                     generate self.cache_key. Only used for informational purposes
                     in repo_edit.html.
                     """
                     # prefix, repo_name, suffix
                     return self._cache_key_partition()[2]
                 @classmethod
                 def delete_all_cache(cls):
                     """
                     Delete all cache keys from database.
                     Should only be run when all instances are down and all entries
                     thus stale.
                     """
                     cls.query().delete()
                     Session().commit()
                 @classmethod
                 def get_cache_key(cls, repo_name, cache_type):
                     """
                     Generate a cache key for this process of RhodeCode instance.
                     Prefix most likely will be process id or maybe explicitly set
                     instance_id from .ini file.
                     """
                     import rhodecode
                     prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
                     repo_as_unicode = safe_unicode(repo_name)
                     key = u'{}_{}'.format(repo_as_unicode, cache_type) \
                         if cache_type else repo_as_unicode
                     return u'{}{}'.format(prefix, key)
                 @classmethod
                 def set_invalidate(cls, repo_name, delete=False):
                     """
                     Mark all caches of a repo as invalid in the database.
                     """
                     try:
                         qry = Session().query(cls).filter(cls.cache_args == repo_name)
                         if delete:
                             log.debug('cache objects deleted for repo %s',
                                       safe_str(repo_name))
                             qry.delete()
                         else:
                             log.debug('cache objects marked as invalid for repo %s',
                                       safe_str(repo_name))
                             qry.update({"cache_active": False})
                         Session().commit()
                     except Exception:
                         log.exception(
                             'Cache key invalidation failed for repository %s',
                             safe_str(repo_name))
                         Session().rollback()
                 @classmethod
                 def get_active_cache(cls, cache_key):
                     inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
                     if inv_obj:
                         return inv_obj
                     return None
                 @classmethod
                 def repo_context_cache(cls, compute_func, repo_name, cache_type,
                                        thread_scoped=False):
                     """
                     @cache_region('long_term')
                     def _heavy_calculation(cache_key):
                         return 'result'
                     cache_context = CacheKey.repo_context_cache(
                         _heavy_calculation, repo_name, cache_type)
                     with cache_context as context:
                         context.invalidate()
                         computed = context.compute()
                     assert computed == 'result'
                     """
                     from rhodecode.lib import caches
                     return caches.InvalidationContext(
                         compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
             class ChangesetComment(Base, BaseModel):
                 __tablename__ = 'changeset_comments'
                 __table_args__ = (
                     Index('cc_revision_idx', 'revision'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 COMMENT_OUTDATED = u'comment_outdated'
                 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
                 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
                 revision = Column('revision', String(40), nullable=True)
                 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
                 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
                 line_no = Column('line_no', Unicode(10), nullable=True)
                 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
                 f_path = Column('f_path', Unicode(1000), nullable=True)
                 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
                 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 renderer = Column('renderer', Unicode(64), nullable=True)
                 display_state = Column('display_state',  Unicode(128), nullable=True)
                 author = relationship('User', lazy='joined')
                 repo = relationship('Repository')
                 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
                 pull_request = relationship('PullRequest', lazy='joined')
                 pull_request_version = relationship('PullRequestVersion')
                 @classmethod
                 def get_users(cls, revision=None, pull_request_id=None):
                     """
                     Returns user associated with this ChangesetComment. ie those
                     who actually commented
                     :param cls:
                     :param revision:
                     """
                     q = Session().query(User)\
                             .join(ChangesetComment.author)
                     if revision:
                         q = q.filter(cls.revision == revision)
                     elif pull_request_id:
                         q = q.filter(cls.pull_request_id == pull_request_id)
                     return q.all()
                 def render(self, mentions=False):
                     from rhodecode.lib import helpers as h
                     return h.render(self.text, renderer=self.renderer, mentions=mentions)
                 def __repr__(self):
                     if self.comment_id:
                         return '<DB:ChangesetComment #%s>' % self.comment_id
                     else:
                         return '<DB:ChangesetComment at %#x>' % id(self)
             class ChangesetStatus(Base, BaseModel):
                 __tablename__ = 'changeset_statuses'
                 __table_args__ = (
                     Index('cs_revision_idx', 'revision'),
                     Index('cs_version_idx', 'version'),
                     UniqueConstraint('repo_id', 'revision', 'version'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
                 STATUS_APPROVED = 'approved'
                 STATUS_REJECTED = 'rejected'
                 STATUS_UNDER_REVIEW = 'under_review'
                 STATUSES = [
                     (STATUS_NOT_REVIEWED, _("Not Reviewed")),  # (no icon) and default
                     (STATUS_APPROVED, _("Approved")),
                     (STATUS_REJECTED, _("Rejected")),
                     (STATUS_UNDER_REVIEW, _("Under Review")),
                 ]
                 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
                 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
                 revision = Column('revision', String(40), nullable=False)
                 status = Column('status', String(128), nullable=False, default=DEFAULT)
                 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
                 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
                 version = Column('version', Integer(), nullable=False, default=0)
                 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
                 author = relationship('User', lazy='joined')
                 repo = relationship('Repository')
                 comment = relationship('ChangesetComment', lazy='joined')
                 pull_request = relationship('PullRequest', lazy='joined')
                 def __unicode__(self):
                     return u"<%s('%s[%s]:%s')>" % (
                         self.__class__.__name__,
                         self.status, self.version, self.author
                     )
                 @classmethod
                 def get_status_lbl(cls, value):
                     return dict(cls.STATUSES).get(value)
                 @property
                 def status_lbl(self):
                     return ChangesetStatus.get_status_lbl(self.status)
             class _PullRequestBase(BaseModel):
                 """
                 Common attributes of pull request and version entries.
                 """
                 # .status values
                 STATUS_NEW = u'new'
                 STATUS_OPEN = u'open'
                 STATUS_CLOSED = u'closed'
                 title = Column('title', Unicode(255), nullable=True)
                 description = Column(
                     'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
                     nullable=True)
                 # new/open/closed status of pull request (not approve/reject/etc)
                 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
                 created_on = Column(
                     'created_on', DateTime(timezone=False), nullable=False,
                     default=datetime.datetime.now)
                 updated_on = Column(
                     'updated_on', DateTime(timezone=False), nullable=False,
                     default=datetime.datetime.now)
                 @declared_attr
                 def user_id(cls):
                     return Column(
                         "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
                         unique=None)
                 # 500 revisions max
                 _revisions = Column(
                     'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
                 @declared_attr
                 def source_repo_id(cls):
                     # TODO: dan: rename column to source_repo_id
                     return Column(
                         'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
                         nullable=False)
                 source_ref = Column('org_ref', Unicode(255), nullable=False)
                 @declared_attr
                 def target_repo_id(cls):
                     # TODO: dan: rename column to target_repo_id
                     return Column(
                         'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
                         nullable=False)
                 target_ref = Column('other_ref', Unicode(255), nullable=False)
                 # TODO: dan: rename column to last_merge_source_rev
                 _last_merge_source_rev = Column(
                     'last_merge_org_rev', String(40), nullable=True)
                 # TODO: dan: rename column to last_merge_target_rev
                 _last_merge_target_rev = Column(
                     'last_merge_other_rev', String(40), nullable=True)
                 _last_merge_status = Column('merge_status', Integer(), nullable=True)
                 merge_rev = Column('merge_rev', String(40), nullable=True)
                 @hybrid_property
                 def revisions(self):
                     return self._revisions.split(':') if self._revisions else []
                 @revisions.setter
                 def revisions(self, val):
                     self._revisions = ':'.join(val)
                 @declared_attr
                 def author(cls):
                     return relationship('User', lazy='joined')
                 @declared_attr
                 def source_repo(cls):
                     return relationship(
                         'Repository',
                         primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
                 @property
                 def source_ref_parts(self):
                     refs = self.source_ref.split(':')
                     return Reference(refs[0], refs[1], refs[2])
                 @declared_attr
                 def target_repo(cls):
                     return relationship(
                         'Repository',
                         primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
                 @property
                 def target_ref_parts(self):
                     refs = self.target_ref.split(':')
                     return Reference(refs[0], refs[1], refs[2])
             class PullRequest(Base, _PullRequestBase):
                 __tablename__ = 'pull_requests'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 pull_request_id = Column(
                     'pull_request_id', Integer(), nullable=False, primary_key=True)
                 def __repr__(self):
                     if self.pull_request_id:
                         return '<DB:PullRequest #%s>' % self.pull_request_id
                     else:
                         return '<DB:PullRequest at %#x>' % id(self)
                 reviewers = relationship('PullRequestReviewers',
                                          cascade="all, delete, delete-orphan")
                 statuses = relationship('ChangesetStatus')
                 comments = relationship('ChangesetComment',
                                         cascade="all, delete, delete-orphan")
                 versions = relationship('PullRequestVersion',
                                         cascade="all, delete, delete-orphan")
                 def is_closed(self):
                     return self.status == self.STATUS_CLOSED
                 def get_api_data(self):
                     from rhodecode.model.pull_request import PullRequestModel
                     pull_request = self
                     merge_status = PullRequestModel().merge_status(pull_request)
+                    pull_request_url = url(
+                        'pullrequest_show', repo_name=self.target_repo.repo_name,
+                        pull_request_id=self.pull_request_id, qualified=True)
                     data = {
                         'pull_request_id': pull_request.pull_request_id,
-                        'url': url('pullrequest_show', repo_name=self.target_repo.repo_name,
+                        'url': pull_request_url,
-                                                   pull_request_id=self.pull_request_id,
-                                                   qualified=True),
                         'title': pull_request.title,
                         'description': pull_request.description,
                         'status': pull_request.status,
                         'created_on': pull_request.created_on,
                         'updated_on': pull_request.updated_on,
                         'commit_ids': pull_request.revisions,
                         'review_status': pull_request.calculated_review_status(),
                         'mergeable': {
                             'status': merge_status[0],
                             'message': unicode(merge_status[1]),
                         },
                         'source': {
                             'clone_url': pull_request.source_repo.clone_url(),
                             'repository': pull_request.source_repo.repo_name,
                             'reference': {
                                 'name': pull_request.source_ref_parts.name,
                                 'type': pull_request.source_ref_parts.type,
                                 'commit_id': pull_request.source_ref_parts.commit_id,
                             },
                         },
                         'target': {
                             'clone_url': pull_request.target_repo.clone_url(),
                             'repository': pull_request.target_repo.repo_name,
                             'reference': {
                                 'name': pull_request.target_ref_parts.name,
                                 'type': pull_request.target_ref_parts.type,
                                 'commit_id': pull_request.target_ref_parts.commit_id,
                             },
                         },
+                        'shadow': {
+                            # TODO: martinb: Unify generation/suffix of clone url.
+                            'clone_url': '{}/repository'.format(pull_request_url),
+                        },
                         'author': pull_request.author.get_api_data(include_secrets=False,
                                                                    details='basic'),
                         'reviewers': [
                             {
                                 'user': reviewer.get_api_data(include_secrets=False,
                                                               details='basic'),
                                 'reasons': reasons,
                                 'review_status': st[0][1].status if st else 'not_reviewed',
                             }
                             for reviewer, reasons, st in pull_request.reviewers_statuses()
                         ]
                     }
                     return data
                 def __json__(self):
                     return {
                         'revisions': self.revisions,
                     }
                 def calculated_review_status(self):
                     # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
                     # because it's tricky on how to use ChangesetStatusModel from there
                     warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
                     from rhodecode.model.changeset_status import ChangesetStatusModel
                     return ChangesetStatusModel().calculated_review_status(self)
                 def reviewers_statuses(self):
                     warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
                     from rhodecode.model.changeset_status import ChangesetStatusModel
                     return ChangesetStatusModel().reviewers_statuses(self)
             class PullRequestVersion(Base, _PullRequestBase):
                 __tablename__ = 'pull_request_versions'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 pull_request_version_id = Column(
                     'pull_request_version_id', Integer(), nullable=False, primary_key=True)
                 pull_request_id = Column(
                     'pull_request_id', Integer(),
                     ForeignKey('pull_requests.pull_request_id'), nullable=False)
                 pull_request = relationship('PullRequest')
                 def __repr__(self):
                     if self.pull_request_version_id:
                         return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
                     else:
                         return '<DB:PullRequestVersion at %#x>' % id(self)
             class PullRequestReviewers(Base, BaseModel):
                 __tablename__ = 'pull_request_reviewers'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 def __init__(self, user=None, pull_request=None, reasons=None):
                     self.user = user
                     self.pull_request = pull_request
                     self.reasons = reasons or []
                 @hybrid_property
                 def reasons(self):
                     if not self._reasons:
                         return []
                     return self._reasons
                 @reasons.setter
                 def reasons(self, val):
                     val = val or []
                     if any(not isinstance(x, basestring) for x in val):
                         raise Exception('invalid reasons type, must be list of strings')
                     self._reasons = val
                 pull_requests_reviewers_id = Column(
                     'pull_requests_reviewers_id', Integer(), nullable=False,
                     primary_key=True)
                 pull_request_id = Column(
                     "pull_request_id", Integer(),
                     ForeignKey('pull_requests.pull_request_id'), nullable=False)
                 user_id = Column(
                     "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
                 _reasons = Column(
                     'reason', MutationList.as_mutable(
                         JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
                 user = relationship('User')
                 pull_request = relationship('PullRequest')
             class Notification(Base, BaseModel):
                 __tablename__ = 'notifications'
                 __table_args__ = (
                     Index('notification_type_idx', 'type'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 TYPE_CHANGESET_COMMENT = u'cs_comment'
                 TYPE_MESSAGE = u'message'
                 TYPE_MENTION = u'mention'
                 TYPE_REGISTRATION = u'registration'
                 TYPE_PULL_REQUEST = u'pull_request'
                 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
                 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
                 subject = Column('subject', Unicode(512), nullable=True)
                 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
                 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 type_ = Column('type', Unicode(255))
                 created_by_user = relationship('User')
                 notifications_to_users = relationship('UserNotification', lazy='joined',
                                                       cascade="all, delete, delete-orphan")
                 @property
                 def recipients(self):
                     return [x.user for x in UserNotification.query()\
                             .filter(UserNotification.notification == self)\
                             .order_by(UserNotification.user_id.asc()).all()]
                 @classmethod
                 def create(cls, created_by, subject, body, recipients, type_=None):
                     if type_ is None:
                         type_ = Notification.TYPE_MESSAGE
                     notification = cls()
                     notification.created_by_user = created_by
                     notification.subject = subject
                     notification.body = body
                     notification.type_ = type_
                     notification.created_on = datetime.datetime.now()
                     for u in recipients:
                         assoc = UserNotification()
                         assoc.notification = notification
                         # if created_by is inside recipients mark his notification
                         # as read
                         if u.user_id == created_by.user_id:
                             assoc.read = True
                         u.notifications.append(assoc)
                     Session().add(notification)
                     return notification
                 @property
                 def description(self):
                     from rhodecode.model.notification import NotificationModel
                     return NotificationModel().make_description(self)
             class UserNotification(Base, BaseModel):
                 __tablename__ = 'user_to_notification'
                 __table_args__ = (
                     UniqueConstraint('user_id', 'notification_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
                 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
                 read = Column('read', Boolean, default=False)
                 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
                 user = relationship('User', lazy="joined")
                 notification = relationship('Notification', lazy="joined",
                                             order_by=lambda: Notification.created_on.desc(),)
                 def mark_as_read(self):
                     self.read = True
                     Session().add(self)
             class Gist(Base, BaseModel):
                 __tablename__ = 'gists'
                 __table_args__ = (
                     Index('g_gist_access_id_idx', 'gist_access_id'),
                     Index('g_created_on_idx', 'created_on'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 GIST_PUBLIC = u'public'
                 GIST_PRIVATE = u'private'
                 DEFAULT_FILENAME = u'gistfile1.txt'
                 ACL_LEVEL_PUBLIC = u'acl_public'
                 ACL_LEVEL_PRIVATE = u'acl_private'
                 gist_id = Column('gist_id', Integer(), primary_key=True)
                 gist_access_id = Column('gist_access_id', Unicode(250))
                 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
                 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
                 gist_expires = Column('gist_expires', Float(53), nullable=False)
                 gist_type = Column('gist_type', Unicode(128), nullable=False)
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 acl_level = Column('acl_level', Unicode(128), nullable=True)
                 owner = relationship('User')
                 def __repr__(self):
                     return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
                 @classmethod
                 def get_or_404(cls, id_):
                     res = cls.query().filter(cls.gist_access_id == id_).scalar()
                     if not res:
                         raise HTTPNotFound
                     return res
                 @classmethod
                 def get_by_access_id(cls, gist_access_id):
                     return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
                 def gist_url(self):
                     import rhodecode
                     alias_url = rhodecode.CONFIG.get('gist_alias_url')
                     if alias_url:
                         return alias_url.replace('{gistid}', self.gist_access_id)
                     return url('gist', gist_id=self.gist_access_id, qualified=True)
                 @classmethod
                 def base_path(cls):
                     """
                     Returns base path when all gists are stored
                     :param cls:
                     """
                     from rhodecode.model.gist import GIST_STORE_LOC
                     q = Session().query(RhodeCodeUi)\
                         .filter(RhodeCodeUi.ui_key == URL_SEP)
                     q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
                     return os.path.join(q.one().ui_value, GIST_STORE_LOC)
                 def get_api_data(self):
                     """
                     Common function for generating gist related data for API
                     """
                     gist = self
                     data = {
                         'gist_id': gist.gist_id,
                         'type': gist.gist_type,
                         'access_id': gist.gist_access_id,
                         'description': gist.gist_description,
                         'url': gist.gist_url(),
                         'expires': gist.gist_expires,
                         'created_on': gist.created_on,
                         'modified_at': gist.modified_at,
                         'content': None,
                         'acl_level': gist.acl_level,
                     }
                     return data
                 def __json__(self):
                     data = dict(
                     )
                     data.update(self.get_api_data())
                     return data
                 # SCM functions
                 def scm_instance(self, **kwargs):
                     full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
                     return get_vcs_instance(
                         repo_path=safe_str(full_repo_path), create=False)
             class DbMigrateVersion(Base, BaseModel):
                 __tablename__ = 'db_migrate_version'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 repository_id = Column('repository_id', String(250), primary_key=True)
                 repository_path = Column('repository_path', Text)
                 version = Column('version', Integer)
             class ExternalIdentity(Base, BaseModel):
                 __tablename__ = 'external_identities'
                 __table_args__ = (
                     Index('local_user_id_idx', 'local_user_id'),
                     Index('external_id_idx', 'external_id'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8'})
                 external_id = Column('external_id', Unicode(255), default=u'',
                                      primary_key=True)
                 external_username = Column('external_username', Unicode(1024), default=u'')
                 local_user_id = Column('local_user_id', Integer(),
                                        ForeignKey('users.user_id'), primary_key=True)
                 provider_name = Column('provider_name', Unicode(255), default=u'',
                                        primary_key=True)
                 access_token = Column('access_token', String(1024), default=u'')
                 alt_token = Column('alt_token', String(1024), default=u'')
                 token_secret = Column('token_secret', String(1024), default=u'')
                 @classmethod
                 def by_external_id_and_provider(cls, external_id, provider_name,
                                                 local_user_id=None):
                     """
                     Returns ExternalIdentity instance based on search params
                     :param external_id:
                     :param provider_name:
                     :return: ExternalIdentity
                     """
                     query = cls.query()
                     query = query.filter(cls.external_id == external_id)
                     query = query.filter(cls.provider_name == provider_name)
                     if local_user_id:
                         query = query.filter(cls.local_user_id == local_user_id)
                     return query.first()
                 @classmethod
                 def user_by_external_id_and_provider(cls, external_id, provider_name):
                     """
                     Returns User instance based on search params
                     :param external_id:
                     :param provider_name:
                     :return: User
                     """
                     query = User.query()
                     query = query.filter(cls.external_id == external_id)
                     query = query.filter(cls.provider_name == provider_name)
                     query = query.filter(User.user_id == cls.local_user_id)
                     return query.first()
                 @classmethod
                 def by_local_user_id(cls, local_user_id):
                     """
                     Returns all tokens for user
                     :param local_user_id:
                     :return: ExternalIdentity
                     """
                     query = cls.query()
                     query = query.filter(cls.local_user_id == local_user_id)
                     return query
             class Integration(Base, BaseModel):
                 __tablename__ = 'integrations'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 integration_id = Column('integration_id', Integer(), primary_key=True)
                 integration_type = Column('integration_type', String(255))
                 enabled = Column('enabled', Boolean(), nullable=False)
                 name = Column('name', String(255), nullable=False)
                 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
                     default=False)
                 settings = Column(
                     'settings_json', MutationObj.as_mutable(
                         JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
                 repo_id = Column(
                     'repo_id', Integer(), ForeignKey('repositories.repo_id'),
                     nullable=True, unique=None, default=None)
                 repo = relationship('Repository', lazy='joined')
                 repo_group_id = Column(
                     'repo_group_id', Integer(), ForeignKey('groups.group_id'),
                     nullable=True, unique=None, default=None)
                 repo_group = relationship('RepoGroup', lazy='joined')
                 @property
                 def scope(self):
                     if self.repo:
                         return repr(self.repo)
                     if self.repo_group:
                         if self.child_repos_only:
                             return repr(self.repo_group) + ' (child repos only)'
                         else:
                             return repr(self.repo_group) + ' (recursive)'
                     if self.child_repos_only:
                         return 'root_repos'
                     return 'global'
                 def __repr__(self):
                     return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
             class RepoReviewRuleUser(Base, BaseModel):
                 __tablename__ = 'repo_review_rules_users'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
                 )
                 repo_review_rule_user_id = Column(
                     'repo_review_rule_user_id', Integer(), primary_key=True)
                 repo_review_rule_id = Column("repo_review_rule_id",
                     Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
                 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
                     nullable=False)
                 user = relationship('User')
             class RepoReviewRuleUserGroup(Base, BaseModel):
                 __tablename__ = 'repo_review_rules_users_groups'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
                 )
                 repo_review_rule_users_group_id = Column(
                     'repo_review_rule_users_group_id', Integer(), primary_key=True)
                 repo_review_rule_id = Column("repo_review_rule_id",
                     Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
                 users_group_id = Column("users_group_id", Integer(),
                     ForeignKey('users_groups.users_group_id'), nullable=False)
                 users_group = relationship('UserGroup')
             class RepoReviewRule(Base, BaseModel):
                 __tablename__ = 'repo_review_rules'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
                 )
                 repo_review_rule_id = Column(
                     'repo_review_rule_id', Integer(), primary_key=True)
                 repo_id = Column(
                     "repo_id", Integer(), ForeignKey('repositories.repo_id'))
                 repo = relationship('Repository', backref='review_rules')
                 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
                     default=u'*') # glob
                 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
                     default=u'*') # glob
                 use_authors_for_review = Column("use_authors_for_review", Boolean(),
                     nullable=False, default=False)
                 rule_users = relationship('RepoReviewRuleUser')
                 rule_user_groups = relationship('RepoReviewRuleUserGroup')
                 @hybrid_property
                 def branch_pattern(self):
                     return self._branch_pattern or '*'
                 def _validate_glob(self, value):
                     re.compile('^' + glob2re(value) + '$')
                 @branch_pattern.setter
                 def branch_pattern(self, value):
                     self._validate_glob(value)
                     self._branch_pattern = value or '*'
                 @hybrid_property
                 def file_pattern(self):
                     return self._file_pattern or '*'
                 @file_pattern.setter
                 def file_pattern(self, value):
                     self._validate_glob(value)
                     self._file_pattern = value or '*'
                 def matches(self, branch, files_changed):
                     """
                     Check if this review rule matches a branch/files in a pull request
                     :param branch: branch name for the commit
                     :param files_changed: list of file paths changed in the pull request
                     """
                     branch = branch or ''
                     files_changed = files_changed or []
                     branch_matches = True
                     if branch:
                         branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
                         branch_matches = bool(branch_regex.search(branch))
                     files_matches = True
                     if self.file_pattern != '*':
                         files_matches = False
                         file_regex = re.compile(glob2re(self.file_pattern))
                         for filename in files_changed:
                             if file_regex.search(filename):
                                 files_matches = True
                                 break
                     return branch_matches and files_matches
                 @property
                 def review_users(self):
                     """ Returns the users which this rule applies to """
                     users = set()
                     users |= set([
                         rule_user.user for rule_user in self.rule_users
                         if rule_user.user.active])
                     users |= set(
                         member.user
                         for rule_user_group in self.rule_user_groups
                         for member in rule_user_group.users_group.members
                         if member.user.active
                     )
                     return users
                 def __repr__(self):
                     return '<RepoReviewerRule(id=%r, repo=%r)>' % (
                         self.repo_review_rule_id, self.repo)