rhodecode-enterprise-ce Commit - r2797:169efce7

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 time

27

import time

28

import hashlib

28

import hashlib

29

import logging

29

import logging

30

import datetime

30

import datetime

31

import warnings

31

import warnings

32

import ipaddress

32

import ipaddress

33

import functools

33

import functools

34

import traceback

34

import traceback

35

import collections

35

import collections

36

37

from sqlalchemy import (

37

from sqlalchemy import (

38

or_, and_, not_, func, TypeDecorator, event,

38

or_, and_, not_, func, TypeDecorator, event,

39

Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,

39

Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,

40

Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,

40

Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,

41

Text, Float, PickleType)

41

Text, Float, PickleType)

42

from sqlalchemy.sql.expression import true, false

42

from sqlalchemy.sql.expression import true, false

43

from sqlalchemy.sql.functions import coalesce, count # noqa

43

from sqlalchemy.sql.functions import coalesce, count # noqa

44

from sqlalchemy.orm import (

44

from sqlalchemy.orm import (

45

relationship, joinedload, class_mapper, validates, aliased)

45

relationship, joinedload, class_mapper, validates, aliased)

46

from sqlalchemy.ext.declarative import declared_attr

46

from sqlalchemy.ext.declarative import declared_attr

47

from sqlalchemy.ext.hybrid import hybrid_property

47

from sqlalchemy.ext.hybrid import hybrid_property

48

from sqlalchemy.exc import IntegrityError # noqa

48

from sqlalchemy.exc import IntegrityError # noqa

49

from sqlalchemy.dialects.mysql import LONGTEXT

49

from sqlalchemy.dialects.mysql import LONGTEXT

50

from beaker.cache import cache_region

50

from beaker.cache import cache_region

51

from zope.cachedescriptors.property import Lazy as LazyProperty

51

from zope.cachedescriptors.property import Lazy as LazyProperty

52

53

from pyramid.threadlocal import get_current_request

53

from pyramid.threadlocal import get_current_request

54

55

from rhodecode.translation import _

55

from rhodecode.translation import _

56

from rhodecode.lib.vcs import get_vcs_instance

56

from rhodecode.lib.vcs import get_vcs_instance

57

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

57

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

58

from rhodecode.lib.utils2 import (

58

from rhodecode.lib.utils2 import (

59

str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,

59

str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,

60

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

60

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

61

glob2re, StrictAttributeDict, cleaned_uri)

61

glob2re, StrictAttributeDict, cleaned_uri)

62

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

62

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

63

JsonRaw

63

JsonRaw

64

from rhodecode.lib.ext_json import json

64

from rhodecode.lib.ext_json import json

65

from rhodecode.lib.caching_query import FromCache

65

from rhodecode.lib.caching_query import FromCache

66

from rhodecode.lib.encrypt import AESCipher

66

from rhodecode.lib.encrypt import AESCipher

67

68

from rhodecode.model.meta import Base, Session

68

from rhodecode.model.meta import Base, Session

69

70

URL_SEP = '/'

70

URL_SEP = '/'

71

log = logging.getLogger(__name__)

71

log = logging.getLogger(__name__)

72

73

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

73

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

74

# BASE CLASSES

74

# BASE CLASSES

75

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

75

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

76

77

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

77

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

78

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

78

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

79

# and initialized at environment.py

79

# and initialized at environment.py

80

ENCRYPTION_KEY = None

80

ENCRYPTION_KEY = None

81

82

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

82

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

83

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

83

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

84

PERMISSION_TYPE_SORT = {

84

PERMISSION_TYPE_SORT = {

85

'admin': '####',

85

'admin': '####',

86

'write': '###',

86

'write': '###',

87

'read': '##',

87

'read': '##',

88

'none': '#',

88

'none': '#',

89

}

89

}

90

91

92

def display_user_sort(obj):

92

def display_user_sort(obj):

93

"""

93

"""

94

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

94

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

95

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

95

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

96

of all other resources

96

of all other resources

97

"""

97

"""

98

99

if obj.username == User.DEFAULT_USER:

99

if obj.username == User.DEFAULT_USER:

100

return '#####'

100

return '#####'

101

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

101

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

102

return prefix + obj.username

102

return prefix + obj.username

103

104

105

def display_user_group_sort(obj):

105

def display_user_group_sort(obj):

106

"""

106

"""

107

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

107

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

108

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

108

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

109

of all other resources

109

of all other resources

110

"""

110

"""

111

112

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

112

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

113

return prefix + obj.users_group_name

113

return prefix + obj.users_group_name

114

115

116

def _hash_key(k):

116

def _hash_key(k):

117

return md5_safe(k)

117

return md5_safe(k)

118

119

120

def in_filter_generator(qry, items, limit=500):

120

def in_filter_generator(qry, items, limit=500):

121

"""

121

"""

122

Splits IN() into multiple with OR

122

Splits IN() into multiple with OR

123

e.g.::

123

e.g.::

124

cnt = Repository.query().filter(

124

cnt = Repository.query().filter(

125

or_(

125

or_(

126

*in_filter_generator(Repository.repo_id, range(100000))

126

*in_filter_generator(Repository.repo_id, range(100000))

127

)).count()

127

)).count()

128

"""

128

"""

129

if not items:

129

if not items:

130

# empty list will cause empty query which might cause security issues

130

# empty list will cause empty query which might cause security issues

131

# this can lead to hidden unpleasant results

131

# this can lead to hidden unpleasant results

132

items = [-1]

132

items = [-1]

133

134

parts = []

134

parts = []

135

for chunk in xrange(0, len(items), limit):

135

for chunk in xrange(0, len(items), limit):

136

parts.append(

136

parts.append(

137

qry.in_(items[chunk: chunk + limit])

137

qry.in_(items[chunk: chunk + limit])

138

)

138

)

139

140

return parts

140

return parts

141

142

143

class EncryptedTextValue(TypeDecorator):

143

class EncryptedTextValue(TypeDecorator):

144

"""

144

"""

145

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

145

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

146

147

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

147

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

148

149

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

149

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

150

unencrypted form, but on save it always encrypts

150

unencrypted form, but on save it always encrypts

151

"""

151

"""

152

impl = Text

152

impl = Text

153

154

def process_bind_param(self, value, dialect):

154

def process_bind_param(self, value, dialect):

155

if not value:

155

if not value:

156

return value

156

return value

157

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

157

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

158

# protect against double encrypting if someone manually starts

158

# protect against double encrypting if someone manually starts

159

# doing

159

# doing

160

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

160

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

161

'not starting with enc$aes')

161

'not starting with enc$aes')

162

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

162

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

163

ENCRYPTION_KEY, hmac=True).encrypt(value)

163

ENCRYPTION_KEY, hmac=True).encrypt(value)

164

165

def process_result_value(self, value, dialect):

165

def process_result_value(self, value, dialect):

166

import rhodecode

166

import rhodecode

167

168

if not value:

168

if not value:

169

return value

169

return value

170

171

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

171

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

172

if not len(parts) == 3:

172

if not len(parts) == 3:

173

# probably not encrypted values

173

# probably not encrypted values

174

return value

174

return value

175

else:

175

else:

176

if parts[0] != 'enc':

176

if parts[0] != 'enc':

177

# parts ok but without our header ?

177

# parts ok but without our header ?

178

return value

178

return value

179

enc_strict_mode = str2bool(rhodecode.CONFIG.get(

179

enc_strict_mode = str2bool(rhodecode.CONFIG.get(

180

'rhodecode.encrypted_values.strict') or True)

180

'rhodecode.encrypted_values.strict') or True)

181

# at that stage we know it's our encryption

181

# at that stage we know it's our encryption

182

if parts[1] == 'aes':

182

if parts[1] == 'aes':

183

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

183

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

184

elif parts[1] == 'aes_hmac':

184

elif parts[1] == 'aes_hmac':

185

decrypted_data = AESCipher(

185

decrypted_data = AESCipher(

186

ENCRYPTION_KEY, hmac=True,

186

ENCRYPTION_KEY, hmac=True,

187

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

187

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

188

else:

188

else:

189

raise ValueError(

189

raise ValueError(

190

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

190

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

191

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

191

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

192

return decrypted_data

192

return decrypted_data

193

194

195

class BaseModel(object):

195

class BaseModel(object):

196

"""

196

"""

197

Base Model for all classes

197

Base Model for all classes

198

"""

198

"""

199

200

@classmethod

200

@classmethod

201

def _get_keys(cls):

201

def _get_keys(cls):

202

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

202

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

203

return class_mapper(cls).c.keys()

203

return class_mapper(cls).c.keys()

204

205

def get_dict(self):

205

def get_dict(self):

206

"""

206

"""

207

return dict with keys and values corresponding

207

return dict with keys and values corresponding

208

to this model data """

208

to this model data """

209

210

d = {}

210

d = {}

211

for k in self._get_keys():

211

for k in self._get_keys():

212

d[k] = getattr(self, k)

212

d[k] = getattr(self, k)

213

214

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

214

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

215

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

215

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

216

if _json_attr:

216

if _json_attr:

217

# update with attributes from __json__

217

# update with attributes from __json__

218

if callable(_json_attr):

218

if callable(_json_attr):

219

_json_attr = _json_attr()

219

_json_attr = _json_attr()

220

for k, val in _json_attr.iteritems():

220

for k, val in _json_attr.iteritems():

221

d[k] = val

221

d[k] = val

222

return d

222

return d

223

224

def get_appstruct(self):

224

def get_appstruct(self):

225

"""return list with keys and values tuples corresponding

225

"""return list with keys and values tuples corresponding

226

to this model data """

226

to this model data """

227

228

lst = []

228

lst = []

229

for k in self._get_keys():

229

for k in self._get_keys():

230

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

230

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

231

return lst

231

return lst

232

233

def populate_obj(self, populate_dict):

233

def populate_obj(self, populate_dict):

234

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

234

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

235

236

for k in self._get_keys():

236

for k in self._get_keys():

237

if k in populate_dict:

237

if k in populate_dict:

238

setattr(self, k, populate_dict[k])

238

setattr(self, k, populate_dict[k])

239

240

@classmethod

240

@classmethod

241

def query(cls):

241

def query(cls):

242

return Session().query(cls)

242

return Session().query(cls)

243

244

@classmethod

244

@classmethod

245

def get(cls, id_):

245

def get(cls, id_):

246

if id_:

246

if id_:

247

return cls.query().get(id_)

247

return cls.query().get(id_)

248

249

@classmethod

249

@classmethod

250

def get_or_404(cls, id_):

250

def get_or_404(cls, id_):

251

from pyramid.httpexceptions import HTTPNotFound

251

from pyramid.httpexceptions import HTTPNotFound

252

253

try:

253

try:

254

id_ = int(id_)

254

id_ = int(id_)

255

except (TypeError, ValueError):

255

except (TypeError, ValueError):

256

raise HTTPNotFound()

256

raise HTTPNotFound()

257

258

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

258

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

259

if not res:

259

if not res:

260

raise HTTPNotFound()

260

raise HTTPNotFound()

261

return res

261

return res

262

263

@classmethod

263

@classmethod

264

def getAll(cls):

264

def getAll(cls):

265

# deprecated and left for backward compatibility

265

# deprecated and left for backward compatibility

266

return cls.get_all()

266

return cls.get_all()

267

268

@classmethod

268

@classmethod

269

def get_all(cls):

269

def get_all(cls):

270

return cls.query().all()

270

return cls.query().all()

271

272

@classmethod

272

@classmethod

273

def delete(cls, id_):

273

def delete(cls, id_):

274

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

274

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

275

Session().delete(obj)

275

Session().delete(obj)

276

277

@classmethod

277

@classmethod

278

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

278

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

279

exist_in_session = []

279

exist_in_session = []

280

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

280

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

281

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

281

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

282

exist_in_session.append(instance)

282

exist_in_session.append(instance)

283

if exist_in_session:

283

if exist_in_session:

284

if len(exist_in_session) == 1:

284

if len(exist_in_session) == 1:

285

return exist_in_session[0]

285

return exist_in_session[0]

286

log.exception(

286

log.exception(

287

'multiple objects with attr %s and '

287

'multiple objects with attr %s and '

288

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

288

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

289

attr_name, value, exist_in_session)

289

attr_name, value, exist_in_session)

290

291

def __repr__(self):

291

def __repr__(self):

292

if hasattr(self, '__unicode__'):

292

if hasattr(self, '__unicode__'):

293

# python repr needs to return str

293

# python repr needs to return str

294

try:

294

try:

295

return safe_str(self.__unicode__())

295

return safe_str(self.__unicode__())

296

except UnicodeDecodeError:

296

except UnicodeDecodeError:

297

pass

297

pass

298

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

298

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

299

300

301

class RhodeCodeSetting(Base, BaseModel):

301

class RhodeCodeSetting(Base, BaseModel):

302

__tablename__ = 'rhodecode_settings'

302

__tablename__ = 'rhodecode_settings'

303

__table_args__ = (

303

__table_args__ = (

304

UniqueConstraint('app_settings_name'),

304

UniqueConstraint('app_settings_name'),

305

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

305

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

306

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

306

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

307

)

307

)

308

309

SETTINGS_TYPES = {

309

SETTINGS_TYPES = {

310

'str': safe_str,

310

'str': safe_str,

311

'int': safe_int,

311

'int': safe_int,

312

'unicode': safe_unicode,

312

'unicode': safe_unicode,

313

'bool': str2bool,

313

'bool': str2bool,

314

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

314

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

315

}

315

}

316

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

316

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

317

GLOBAL_CONF_KEY = 'app_settings'

317

GLOBAL_CONF_KEY = 'app_settings'

318

319

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

319

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

320

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

320

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

321

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

321

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

322

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

322

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

323

324

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

324

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

325

self.app_settings_name = key

325

self.app_settings_name = key

326

self.app_settings_type = type

326

self.app_settings_type = type

327

self.app_settings_value = val

327

self.app_settings_value = val

328

329

@validates('_app_settings_value')

329

@validates('_app_settings_value')

330

def validate_settings_value(self, key, val):

330

def validate_settings_value(self, key, val):

331

assert type(val) == unicode

331

assert type(val) == unicode

332

return val

332

return val

333

334

@hybrid_property

334

@hybrid_property

335

def app_settings_value(self):

335

def app_settings_value(self):

336

v = self._app_settings_value

336

v = self._app_settings_value

337

_type = self.app_settings_type

337

_type = self.app_settings_type

338

if _type:

338

if _type:

339

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

339

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

340

# decode the encrypted value

340

# decode the encrypted value

341

if 'encrypted' in self.app_settings_type:

341

if 'encrypted' in self.app_settings_type:

342

cipher = EncryptedTextValue()

342

cipher = EncryptedTextValue()

343

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

343

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

344

345

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

345

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

346

self.SETTINGS_TYPES['unicode']

346

self.SETTINGS_TYPES['unicode']

347

return converter(v)

347

return converter(v)

348

349

@app_settings_value.setter

349

@app_settings_value.setter

350

def app_settings_value(self, val):

350

def app_settings_value(self, val):

351

"""

351

"""

352

Setter that will always make sure we use unicode in app_settings_value

352

Setter that will always make sure we use unicode in app_settings_value

353

354

:param val:

354

:param val:

355

"""

355

"""

356

val = safe_unicode(val)

356

val = safe_unicode(val)

357

# encode the encrypted value

357

# encode the encrypted value

358

if 'encrypted' in self.app_settings_type:

358

if 'encrypted' in self.app_settings_type:

359

cipher = EncryptedTextValue()

359

cipher = EncryptedTextValue()

360

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

360

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

361

self._app_settings_value = val

361

self._app_settings_value = val

362

363

@hybrid_property

363

@hybrid_property

364

def app_settings_type(self):

364

def app_settings_type(self):

365

return self._app_settings_type

365

return self._app_settings_type

366

367

@app_settings_type.setter

367

@app_settings_type.setter

368

def app_settings_type(self, val):

368

def app_settings_type(self, val):

369

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

369

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

370

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

370

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

371

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

371

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

372

self._app_settings_type = val

372

self._app_settings_type = val

373

374

def __unicode__(self):

374

def __unicode__(self):

375

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

375

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

376

self.__class__.__name__,

376

self.__class__.__name__,

377

self.app_settings_name, self.app_settings_value,

377

self.app_settings_name, self.app_settings_value,

378

self.app_settings_type

378

self.app_settings_type

379

)

379

)

380

381

382

class RhodeCodeUi(Base, BaseModel):

382

class RhodeCodeUi(Base, BaseModel):

383

__tablename__ = 'rhodecode_ui'

383

__tablename__ = 'rhodecode_ui'

384

__table_args__ = (

384

__table_args__ = (

385

UniqueConstraint('ui_key'),

385

UniqueConstraint('ui_key'),

386

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

386

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

387

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

387

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

388

)

388

)

389

390

HOOK_REPO_SIZE = 'changegroup.repo_size'

390

HOOK_REPO_SIZE = 'changegroup.repo_size'

391

# HG

391

# HG

392

HOOK_PRE_PULL = 'preoutgoing.pre_pull'

392

HOOK_PRE_PULL = 'preoutgoing.pre_pull'

393

HOOK_PULL = 'outgoing.pull_logger'

393

HOOK_PULL = 'outgoing.pull_logger'

394

HOOK_PRE_PUSH = 'prechangegroup.pre_push'

394

HOOK_PRE_PUSH = 'prechangegroup.pre_push'

395

HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'

395

HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'

396

HOOK_PUSH = 'changegroup.push_logger'

396

HOOK_PUSH = 'changegroup.push_logger'

397

HOOK_PUSH_KEY = 'pushkey.key_push'

397

HOOK_PUSH_KEY = 'pushkey.key_push'

398

399

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

399

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

400

# git part is currently hardcoded.

400

# git part is currently hardcoded.

401

402

# SVN PATTERNS

402

# SVN PATTERNS

403

SVN_BRANCH_ID = 'vcs_svn_branch'

403

SVN_BRANCH_ID = 'vcs_svn_branch'

404

SVN_TAG_ID = 'vcs_svn_tag'

404

SVN_TAG_ID = 'vcs_svn_tag'

405

406

ui_id = Column(

406

ui_id = Column(

407

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

407

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

408

primary_key=True)

408

primary_key=True)

409

ui_section = Column(

409

ui_section = Column(

410

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

410

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

411

ui_key = Column(

411

ui_key = Column(

412

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

412

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

413

ui_value = Column(

413

ui_value = Column(

414

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

414

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

415

ui_active = Column(

415

ui_active = Column(

416

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

416

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

417

418

def __repr__(self):

418

def __repr__(self):

419

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

419

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

420

self.ui_key, self.ui_value)

420

self.ui_key, self.ui_value)

421

422

423

class RepoRhodeCodeSetting(Base, BaseModel):

423

class RepoRhodeCodeSetting(Base, BaseModel):

424

__tablename__ = 'repo_rhodecode_settings'

424

__tablename__ = 'repo_rhodecode_settings'

425

__table_args__ = (

425

__table_args__ = (

426

UniqueConstraint(

426

UniqueConstraint(

427

'app_settings_name', 'repository_id',

427

'app_settings_name', 'repository_id',

428

name='uq_repo_rhodecode_setting_name_repo_id'),

428

name='uq_repo_rhodecode_setting_name_repo_id'),

429

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

429

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

430

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

430

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

431

)

431

)

432

433

repository_id = Column(

433

repository_id = Column(

434

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

434

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

435

nullable=False)

435

nullable=False)

436

app_settings_id = Column(

436

app_settings_id = Column(

437

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

437

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

438

default=None, primary_key=True)

438

default=None, primary_key=True)

439

app_settings_name = Column(

439

app_settings_name = Column(

440

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

440

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

441

default=None)

441

default=None)

442

_app_settings_value = Column(

442

_app_settings_value = Column(

443

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

443

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

444

default=None)

444

default=None)

445

_app_settings_type = Column(

445

_app_settings_type = Column(

446

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

446

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

447

default=None)

447

default=None)

448

449

repository = relationship('Repository')

449

repository = relationship('Repository')

450

451

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

451

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

452

self.repository_id = repository_id

452

self.repository_id = repository_id

453

self.app_settings_name = key

453

self.app_settings_name = key

454

self.app_settings_type = type

454

self.app_settings_type = type

455

self.app_settings_value = val

455

self.app_settings_value = val

456

457

@validates('_app_settings_value')

457

@validates('_app_settings_value')

458

def validate_settings_value(self, key, val):

458

def validate_settings_value(self, key, val):

459

assert type(val) == unicode

459

assert type(val) == unicode

460

return val

460

return val

461

462

@hybrid_property

462

@hybrid_property

463

def app_settings_value(self):

463

def app_settings_value(self):

464

v = self._app_settings_value

464

v = self._app_settings_value

465

type_ = self.app_settings_type

465

type_ = self.app_settings_type

466

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

466

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

467

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

467

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

468

return converter(v)

468

return converter(v)

469

470

@app_settings_value.setter

470

@app_settings_value.setter

471

def app_settings_value(self, val):

471

def app_settings_value(self, val):

472

"""

472

"""

473

Setter that will always make sure we use unicode in app_settings_value

473

Setter that will always make sure we use unicode in app_settings_value

474

475

:param val:

475

:param val:

476

"""

476

"""

477

self._app_settings_value = safe_unicode(val)

477

self._app_settings_value = safe_unicode(val)

478

479

@hybrid_property

479

@hybrid_property

480

def app_settings_type(self):

480

def app_settings_type(self):

481

return self._app_settings_type

481

return self._app_settings_type

482

483

@app_settings_type.setter

483

@app_settings_type.setter

484

def app_settings_type(self, val):

484

def app_settings_type(self, val):

485

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

485

SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES

486

if val not in SETTINGS_TYPES:

486

if val not in SETTINGS_TYPES:

487

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

487

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

488

% (SETTINGS_TYPES.keys(), val))

488

% (SETTINGS_TYPES.keys(), val))

489

self._app_settings_type = val

489

self._app_settings_type = val

490

491

def __unicode__(self):

491

def __unicode__(self):

492

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

492

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

493

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

493

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

494

self.app_settings_name, self.app_settings_value,

494

self.app_settings_name, self.app_settings_value,

495

self.app_settings_type

495

self.app_settings_type

496

)

496

)

497

498

499

class RepoRhodeCodeUi(Base, BaseModel):

499

class RepoRhodeCodeUi(Base, BaseModel):

500

__tablename__ = 'repo_rhodecode_ui'

500

__tablename__ = 'repo_rhodecode_ui'

501

__table_args__ = (

501

__table_args__ = (

502

UniqueConstraint(

502

UniqueConstraint(

503

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

503

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

504

name='uq_repo_rhodecode_ui_repository_id_section_key'),

504

name='uq_repo_rhodecode_ui_repository_id_section_key'),

505

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

505

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

506

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

506

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

507

)

507

)

508

509

repository_id = Column(

509

repository_id = Column(

510

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

510

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

511

nullable=False)

511

nullable=False)

512

ui_id = Column(

512

ui_id = Column(

513

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

513

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

514

primary_key=True)

514

primary_key=True)

515

ui_section = Column(

515

ui_section = Column(

516

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

516

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

517

ui_key = Column(

517

ui_key = Column(

518

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

518

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

519

ui_value = Column(

519

ui_value = Column(

520

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

520

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

521

ui_active = Column(

521

ui_active = Column(

522

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

522

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

523

524

repository = relationship('Repository')

524

repository = relationship('Repository')

525

526

def __repr__(self):

526

def __repr__(self):

527

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

527

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

528

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

528

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

529

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

529

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

530

531

532

class User(Base, BaseModel):

532

class User(Base, BaseModel):

533

__tablename__ = 'users'

533

__tablename__ = 'users'

534

__table_args__ = (

534

__table_args__ = (

535

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

535

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

536

Index('u_username_idx', 'username'),

536

Index('u_username_idx', 'username'),

537

Index('u_email_idx', 'email'),

537

Index('u_email_idx', 'email'),

538

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

538

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

539

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

539

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

540

)

540

)

541

DEFAULT_USER = 'default'

541

DEFAULT_USER = 'default'

542

DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'

542

DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'

543

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

543

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

544

545

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

545

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

546

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

546

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

547

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

547

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

548

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

548

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

549

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

549

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

550

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

550

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

551

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

551

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

552

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

552

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

553

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

553

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

554

last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)

554

last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)

555

556

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

556

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

557

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

557

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

558

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

558

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

559

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

559

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

560

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

560

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

561

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

561

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

562

563

user_log = relationship('UserLog')

563

user_log = relationship('UserLog')

564

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

564

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

565

566

repositories = relationship('Repository')

566

repositories = relationship('Repository')

567

repository_groups = relationship('RepoGroup')

567

repository_groups = relationship('RepoGroup')

568

user_groups = relationship('UserGroup')

568

user_groups = relationship('UserGroup')

569

570

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

570

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

571

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

571

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

572

573

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

573

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

574

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

574

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

575

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

575

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

576

577

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

577

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

578

579

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

579

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

580

# notifications assigned to this user

580

# notifications assigned to this user

581

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

581

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

582

# comments created by this user

582

# comments created by this user

583

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

583

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

584

# user profile extra info

584

# user profile extra info

585

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

585

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

586

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

586

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

587

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

587

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

588

user_ssh_keys = relationship('UserSshKeys', cascade='all')

588

user_ssh_keys = relationship('UserSshKeys', cascade='all')

589

590

# gists

590

# gists

591

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

591

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

592

# user pull requests

592

# user pull requests

593

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

593

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

594

# external identities

594

# external identities

595

extenal_identities = relationship(

595

extenal_identities = relationship(

596

'ExternalIdentity',

596

'ExternalIdentity',

597

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

597

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

598

cascade='all')

598

cascade='all')

599

# review rules

599

# review rules

600

user_review_rules = relationship('RepoReviewRuleUser', cascade='all')

600

user_review_rules = relationship('RepoReviewRuleUser', cascade='all')

601

602

def __unicode__(self):

602

def __unicode__(self):

603

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

603

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

604

self.user_id, self.username)

604

self.user_id, self.username)

605

606

@hybrid_property

606

@hybrid_property

607

def email(self):

607

def email(self):

608

return self._email

608

return self._email

609

610

@email.setter

610

@email.setter

611

def email(self, val):

611

def email(self, val):

612

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

612

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

613

614

@hybrid_property

614

@hybrid_property

615

def first_name(self):

615

def first_name(self):

616

from rhodecode.lib import helpers as h

616

from rhodecode.lib import helpers as h

617

if self.name:

617

if self.name:

618

return h.escape(self.name)

618

return h.escape(self.name)

619

return self.name

619

return self.name

620

621

@hybrid_property

621

@hybrid_property

622

def last_name(self):

622

def last_name(self):

623

from rhodecode.lib import helpers as h

623

from rhodecode.lib import helpers as h

624

if self.lastname:

624

if self.lastname:

625

return h.escape(self.lastname)

625

return h.escape(self.lastname)

626

return self.lastname

626

return self.lastname

627

628

@hybrid_property

628

@hybrid_property

629

def api_key(self):

629

def api_key(self):

630

"""

630

"""

631

Fetch if exist an auth-token with role ALL connected to this user

631

Fetch if exist an auth-token with role ALL connected to this user

632

"""

632

"""

633

user_auth_token = UserApiKeys.query()\

633

user_auth_token = UserApiKeys.query()\

634

.filter(UserApiKeys.user_id == self.user_id)\

634

.filter(UserApiKeys.user_id == self.user_id)\

635

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

635

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

636

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

636

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

637

.filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()

637

.filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()

638

if user_auth_token:

638

if user_auth_token:

639

user_auth_token = user_auth_token.api_key

639

user_auth_token = user_auth_token.api_key

640

641

return user_auth_token

641

return user_auth_token

642

643

@api_key.setter

643

@api_key.setter

644

def api_key(self, val):

644

def api_key(self, val):

645

# don't allow to set API key this is deprecated for now

645

# don't allow to set API key this is deprecated for now

646

self._api_key = None

646

self._api_key = None

647

648

@property

648

@property

649

def reviewer_pull_requests(self):

649

def reviewer_pull_requests(self):

650

return PullRequestReviewers.query() \

650

return PullRequestReviewers.query() \

651

.options(joinedload(PullRequestReviewers.pull_request)) \

651

.options(joinedload(PullRequestReviewers.pull_request)) \

652

.filter(PullRequestReviewers.user_id == self.user_id) \

652

.filter(PullRequestReviewers.user_id == self.user_id) \

653

.all()

653

.all()

654

655

@property

655

@property

656

def firstname(self):

656

def firstname(self):

657

# alias for future

657

# alias for future

658

return self.name

658

return self.name

659

660

@property

660

@property

661

def emails(self):

661

def emails(self):

662

other = UserEmailMap.query()\

662

other = UserEmailMap.query()\

663

.filter(UserEmailMap.user == self) \

663

.filter(UserEmailMap.user == self) \

664

.order_by(UserEmailMap.email_id.asc()) \

664

.order_by(UserEmailMap.email_id.asc()) \

665

.all()

665

.all()

666

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

666

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

667

668

@property

668

@property

669

def auth_tokens(self):

669

def auth_tokens(self):

670

auth_tokens = self.get_auth_tokens()

670

auth_tokens = self.get_auth_tokens()

671

return [x.api_key for x in auth_tokens]

671

return [x.api_key for x in auth_tokens]

672

673

def get_auth_tokens(self):

673

def get_auth_tokens(self):

674

return UserApiKeys.query()\

674

return UserApiKeys.query()\

675

.filter(UserApiKeys.user == self)\

675

.filter(UserApiKeys.user == self)\

676

.order_by(UserApiKeys.user_api_key_id.asc())\

676

.order_by(UserApiKeys.user_api_key_id.asc())\

677

.all()

677

.all()

678

679

@LazyProperty

679

@LazyProperty

680

def feed_token(self):

680

def feed_token(self):

681

return self.get_feed_token()

681

return self.get_feed_token()

682

683

def get_feed_token(self, cache=True):

683

def get_feed_token(self, cache=True):

684

feed_tokens = UserApiKeys.query()\

684

feed_tokens = UserApiKeys.query()\

685

.filter(UserApiKeys.user == self)\

685

.filter(UserApiKeys.user == self)\

686

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

686

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

687

if cache:

687

if cache:

688

feed_tokens = feed_tokens.options(

688

feed_tokens = feed_tokens.options(

689

FromCache("long_term", "get_user_feed_token_%s" % self.user_id))

689

FromCache("long_term", "get_user_feed_token_%s" % self.user_id))

690

691

feed_tokens = feed_tokens.all()

691

feed_tokens = feed_tokens.all()

692

if feed_tokens:

692

if feed_tokens:

693

return feed_tokens[0].api_key

693

return feed_tokens[0].api_key

694

return 'NO_FEED_TOKEN_AVAILABLE'

694

return 'NO_FEED_TOKEN_AVAILABLE'

695

696

@classmethod

696

@classmethod

697

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

697

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

698

if not user_id:

698

if not user_id:

699

return

699

return

700

701

user = cls.query()

701

user = cls.query()

702

if cache:

702

if cache:

703

user = user.options(

703

user = user.options(

704

FromCache("sql_cache_short", "get_users_%s" % user_id))

704

FromCache("sql_cache_short", "get_users_%s" % user_id))

705

return user.get(user_id)

705

return user.get(user_id)

706

707

@classmethod

707

@classmethod

708

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

708

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

709

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

709

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

710

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

710

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

711

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

711

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

712

if role:

712

if role:

713

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

713

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

714

UserApiKeys.role == UserApiKeys.ROLE_ALL))

714

UserApiKeys.role == UserApiKeys.ROLE_ALL))

715

return tokens.all()

715

return tokens.all()

716

717

def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):

717

def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):

718

from rhodecode.lib import auth

718

from rhodecode.lib import auth

719

720

log.debug('Trying to authenticate user: %s via auth-token, '

720

log.debug('Trying to authenticate user: %s via auth-token, '

721

'and roles: %s', self, roles)

721

'and roles: %s', self, roles)

722

723

if not auth_token:

723

if not auth_token:

724

return False

724

return False

725

726

crypto_backend = auth.crypto_backend()

726

crypto_backend = auth.crypto_backend()

727

728

roles = (roles or []) + [UserApiKeys.ROLE_ALL]

728

roles = (roles or []) + [UserApiKeys.ROLE_ALL]

729

tokens_q = UserApiKeys.query()\

729

tokens_q = UserApiKeys.query()\

730

.filter(UserApiKeys.user_id == self.user_id)\

730

.filter(UserApiKeys.user_id == self.user_id)\

731

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

731

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

732

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

732

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

733

734

tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))

734

tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))

735

736

plain_tokens = []

736

plain_tokens = []

737

hash_tokens = []

737

hash_tokens = []

738

739

for token in tokens_q.all():

739

for token in tokens_q.all():

740

# verify scope first

740

# verify scope first

741

if token.repo_id:

741

if token.repo_id:

742

# token has a scope, we need to verify it

742

# token has a scope, we need to verify it

743

if scope_repo_id != token.repo_id:

743

if scope_repo_id != token.repo_id:

744

log.debug(

744

log.debug(

745

'Scope mismatch: token has a set repo scope: %s, '

745

'Scope mismatch: token has a set repo scope: %s, '

746

'and calling scope is:%s, skipping further checks',

746

'and calling scope is:%s, skipping further checks',

747

token.repo, scope_repo_id)

747

token.repo, scope_repo_id)

748

# token has a scope, and it doesn't match, skip token

748

# token has a scope, and it doesn't match, skip token

749

continue

749

continue

750

751

if token.api_key.startswith(crypto_backend.ENC_PREF):

751

if token.api_key.startswith(crypto_backend.ENC_PREF):

752

hash_tokens.append(token.api_key)

752

hash_tokens.append(token.api_key)

753

else:

753

else:

754

plain_tokens.append(token.api_key)

754

plain_tokens.append(token.api_key)

755

756

is_plain_match = auth_token in plain_tokens

756

is_plain_match = auth_token in plain_tokens

757

if is_plain_match:

757

if is_plain_match:

758

return True

758

return True

759

760

for hashed in hash_tokens:

760

for hashed in hash_tokens:

761

# TODO(marcink): this is expensive to calculate, but most secure

761

# TODO(marcink): this is expensive to calculate, but most secure

762

match = crypto_backend.hash_check(auth_token, hashed)

762

match = crypto_backend.hash_check(auth_token, hashed)

763

if match:

763

if match:

764

return True

764

return True

765

766

return False

766

return False

767

768

@property

768

@property

769

def ip_addresses(self):

769

def ip_addresses(self):

770

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

770

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

771

return [x.ip_addr for x in ret]

771

return [x.ip_addr for x in ret]

772

773

@property

773

@property

774

def username_and_name(self):

774

def username_and_name(self):

775

return '%s (%s %s)' % (self.username, self.first_name, self.last_name)

775

return '%s (%s %s)' % (self.username, self.first_name, self.last_name)

776

777

@property

777

@property

778

def username_or_name_or_email(self):

778

def username_or_name_or_email(self):

779

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

779

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

780

return self.username or full_name or self.email

780

return self.username or full_name or self.email

781

782

@property

782

@property

783

def full_name(self):

783

def full_name(self):

784

return '%s %s' % (self.first_name, self.last_name)

784

return '%s %s' % (self.first_name, self.last_name)

785

786

@property

786

@property

787

def full_name_or_username(self):

787

def full_name_or_username(self):

788

return ('%s %s' % (self.first_name, self.last_name)

788

return ('%s %s' % (self.first_name, self.last_name)

789

if (self.first_name and self.last_name) else self.username)

789

if (self.first_name and self.last_name) else self.username)

790

791

@property

791

@property

792

def full_contact(self):

792

def full_contact(self):

793

return '%s %s <%s>' % (self.first_name, self.last_name, self.email)

793

return '%s %s <%s>' % (self.first_name, self.last_name, self.email)

794

795

@property

795

@property

796

def short_contact(self):

796

def short_contact(self):

797

return '%s %s' % (self.first_name, self.last_name)

797

return '%s %s' % (self.first_name, self.last_name)

798

799

@property

799

@property

800

def is_admin(self):

800

def is_admin(self):

801

return self.admin

801

return self.admin

802

803

def AuthUser(self, **kwargs):

803

def AuthUser(self, **kwargs):

804

"""

804

"""

805

Returns instance of AuthUser for this user

805

Returns instance of AuthUser for this user

806

"""

806

"""

807

from rhodecode.lib.auth import AuthUser

807

from rhodecode.lib.auth import AuthUser

808

return AuthUser(user_id=self.user_id, username=self.username, **kwargs)

808

return AuthUser(user_id=self.user_id, username=self.username, **kwargs)

809

810

@hybrid_property

810

@hybrid_property

811

def user_data(self):

811

def user_data(self):

812

if not self._user_data:

812

if not self._user_data:

813

return {}

813

return {}

814

815

try:

815

try:

816

return json.loads(self._user_data)

816

return json.loads(self._user_data)

817

except TypeError:

817

except TypeError:

818

return {}

818

return {}

819

820

@user_data.setter

820

@user_data.setter

821

def user_data(self, val):

821

def user_data(self, val):

822

if not isinstance(val, dict):

822

if not isinstance(val, dict):

823

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

823

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

824

try:

824

try:

825

self._user_data = json.dumps(val)

825

self._user_data = json.dumps(val)

826

except Exception:

826

except Exception:

827

log.error(traceback.format_exc())

827

log.error(traceback.format_exc())

828

829

@classmethod

829

@classmethod

830

def get_by_username(cls, username, case_insensitive=False,

830

def get_by_username(cls, username, case_insensitive=False,

831

cache=False, identity_cache=False):

831

cache=False, identity_cache=False):

832

session = Session()

832

session = Session()

833

834

if case_insensitive:

834

if case_insensitive:

835

q = cls.query().filter(

835

q = cls.query().filter(

836

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

836

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

837

else:

837

else:

838

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

838

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

839

840

if cache:

840

if cache:

841

if identity_cache:

841

if identity_cache:

842

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

842

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

843

if val:

843

if val:

844

return val

844

return val

845

else:

845

else:

846

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

846

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

847

q = q.options(

847

q = q.options(

848

FromCache("sql_cache_short", cache_key))

848

FromCache("sql_cache_short", cache_key))

849

850

return q.scalar()

850

return q.scalar()

851

852

@classmethod

852

@classmethod

853

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

853

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

854

q = UserApiKeys.query()\

854

q = UserApiKeys.query()\

855

.filter(UserApiKeys.api_key == auth_token)\

855

.filter(UserApiKeys.api_key == auth_token)\

856

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

856

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

857

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

857

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

858

if cache:

858

if cache:

859

q = q.options(

859

q = q.options(

860

FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))

860

FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))

861

862

match = q.first()

862

match = q.first()

863

if match:

863

if match:

864

return match.user

864

return match.user

865

866

@classmethod

866

@classmethod

867

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

867

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

868

869

if case_insensitive:

869

if case_insensitive:

870

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

870

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

871

872

else:

872

else:

873

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

873

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

874

875

email_key = _hash_key(email)

875

email_key = _hash_key(email)

876

if cache:

876

if cache:

877

q = q.options(

877

q = q.options(

878

FromCache("sql_cache_short", "get_email_key_%s" % email_key))

878

FromCache("sql_cache_short", "get_email_key_%s" % email_key))

879

880

ret = q.scalar()

880

ret = q.scalar()

881

if ret is None:

881

if ret is None:

882

q = UserEmailMap.query()

882

q = UserEmailMap.query()

883

# try fetching in alternate email map

883

# try fetching in alternate email map

884

if case_insensitive:

884

if case_insensitive:

885

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

885

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

886

else:

886

else:

887

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

887

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

888

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

888

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

889

if cache:

889

if cache:

890

q = q.options(

890

q = q.options(

891

FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))

891

FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))

892

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

892

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

893

894

return ret

894

return ret

895

896

@classmethod

896

@classmethod

897

def get_from_cs_author(cls, author):

897

def get_from_cs_author(cls, author):

898

"""

898

"""

899

Tries to get User objects out of commit author string

899

Tries to get User objects out of commit author string

900

901

:param author:

901

:param author:

902

"""

902

"""

903

from rhodecode.lib.helpers import email, author_name

903

from rhodecode.lib.helpers import email, author_name

904

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

904

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

905

_email = email(author)

905

_email = email(author)

906

if _email:

906

if _email:

907

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

907

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

908

if user:

908

if user:

909

return user

909

return user

910

# Maybe we can match by username?

910

# Maybe we can match by username?

911

_author = author_name(author)

911

_author = author_name(author)

912

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

912

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

913

if user:

913

if user:

914

return user

914

return user

915

916

def update_userdata(self, **kwargs):

916

def update_userdata(self, **kwargs):

917

usr = self

917

usr = self

918

old = usr.user_data

918

old = usr.user_data

919

old.update(**kwargs)

919

old.update(**kwargs)

920

usr.user_data = old

920

usr.user_data = old

921

Session().add(usr)

921

Session().add(usr)

922

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

922

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

923

924

def update_lastlogin(self):

924

def update_lastlogin(self):

925

"""Update user lastlogin"""

925

"""Update user lastlogin"""

926

self.last_login = datetime.datetime.now()

926

self.last_login = datetime.datetime.now()

927

Session().add(self)

927

Session().add(self)

928

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

928

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

929

930

def update_lastactivity(self):

930

def update_lastactivity(self):

931

"""Update user lastactivity"""

931

"""Update user lastactivity"""

932

self.last_activity = datetime.datetime.now()

932

self.last_activity = datetime.datetime.now()

933

Session().add(self)

933

Session().add(self)

934

log.debug('updated user `%s` last activity', self.username)

934

log.debug('updated user `%s` last activity', self.username)

935

936

def update_password(self, new_password):

936

def update_password(self, new_password):

937

from rhodecode.lib.auth import get_crypt_password

937

from rhodecode.lib.auth import get_crypt_password

938

939

self.password = get_crypt_password(new_password)

939

self.password = get_crypt_password(new_password)

940

Session().add(self)

940

Session().add(self)

941

942

@classmethod

942

@classmethod

943

def get_first_super_admin(cls):

943

def get_first_super_admin(cls):

944

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

944

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

945

if user is None:

945

if user is None:

946

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

946

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

947

return user

947

return user

948

949

@classmethod

949

@classmethod

950

def get_all_super_admins(cls):

950

def get_all_super_admins(cls):

951

"""

951

"""

952

Returns all admin accounts sorted by username

952

Returns all admin accounts sorted by username

953

"""

953

"""

954

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

954

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

955

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

955

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

956

957

@classmethod

957

@classmethod

958

def get_default_user(cls, cache=False, refresh=False):

958

def get_default_user(cls, cache=False, refresh=False):

959

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

959

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

960

if user is None:

960

if user is None:

961

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

961

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

962

if refresh:

962

if refresh:

963

# The default user might be based on outdated state which

963

# The default user might be based on outdated state which

964

# has been loaded from the cache.

964

# has been loaded from the cache.

965

# A call to refresh() ensures that the

965

# A call to refresh() ensures that the

966

# latest state from the database is used.

966

# latest state from the database is used.

967

Session().refresh(user)

967

Session().refresh(user)

968

return user

968

return user

969

970

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

970

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

971

from rhodecode.model.permission import PermissionModel

971

from rhodecode.model.permission import PermissionModel

972

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

972

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

973

974

def get_default_perms(self, suffix=''):

974

def get_default_perms(self, suffix=''):

975

return self._get_default_perms(self, suffix)

975

return self._get_default_perms(self, suffix)

976

977

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

977

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

978

"""

978

"""

979

Common function for generating user related data for API

979

Common function for generating user related data for API

980

981

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

981

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

982

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

982

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

983

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

983

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

984

985

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

985

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

986

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

986

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

987

"""

987

"""

988

user = self

988

user = self

989

user_data = self.user_data

989

user_data = self.user_data

990

data = {

990

data = {

991

'user_id': user.user_id,

991

'user_id': user.user_id,

992

'username': user.username,

992

'username': user.username,

993

'firstname': user.name,

993

'firstname': user.name,

994

'lastname': user.lastname,

994

'lastname': user.lastname,

995

'email': user.email,

995

'email': user.email,

996

'emails': user.emails,

996

'emails': user.emails,

997

}

997

}

998

if details == 'basic':

998

if details == 'basic':

999

return data

999

return data

1000

1001

auth_token_length = 40

1001

auth_token_length = 40

1002

auth_token_replacement = '*' * auth_token_length

1002

auth_token_replacement = '*' * auth_token_length

1003

1004

extras = {

1004

extras = {

1005

'auth_tokens': [auth_token_replacement],

1005

'auth_tokens': [auth_token_replacement],

1006

'active': user.active,

1006

'active': user.active,

1007

'admin': user.admin,

1007

'admin': user.admin,

1008

'extern_type': user.extern_type,

1008

'extern_type': user.extern_type,

1009

'extern_name': user.extern_name,

1009

'extern_name': user.extern_name,

1010

'last_login': user.last_login,

1010

'last_login': user.last_login,

1011

'last_activity': user.last_activity,

1011

'last_activity': user.last_activity,

1012

'ip_addresses': user.ip_addresses,

1012

'ip_addresses': user.ip_addresses,

1013

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

1013

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

1014

}

1014

}

1015

data.update(extras)

1015

data.update(extras)

1016

1017

if include_secrets:

1017

if include_secrets:

1018

data['auth_tokens'] = user.auth_tokens

1018

data['auth_tokens'] = user.auth_tokens

1019

return data

1019

return data

1020

1021

def __json__(self):

1021

def __json__(self):

1022

data = {

1022

data = {

1023

'full_name': self.full_name,

1023

'full_name': self.full_name,

1024

'full_name_or_username': self.full_name_or_username,

1024

'full_name_or_username': self.full_name_or_username,

1025

'short_contact': self.short_contact,

1025

'short_contact': self.short_contact,

1026

'full_contact': self.full_contact,

1026

'full_contact': self.full_contact,

1027

}

1027

}

1028

data.update(self.get_api_data())

1028

data.update(self.get_api_data())

1029

return data

1029

return data

1030

1031

1032

class UserApiKeys(Base, BaseModel):

1032

class UserApiKeys(Base, BaseModel):

1033

__tablename__ = 'user_api_keys'

1033

__tablename__ = 'user_api_keys'

1034

__table_args__ = (

1034

__table_args__ = (

1035

Index('uak_api_key_idx', 'api_key', unique=True),

1035

Index('uak_api_key_idx', 'api_key', unique=True),

1036

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

1036

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

1037

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

1037

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

1038

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

1038

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

1039

)

1039

)

1040

__mapper_args__ = {}

1040

__mapper_args__ = {}

1041

1042

# ApiKey role

1042

# ApiKey role

1043

ROLE_ALL = 'token_role_all'

1043

ROLE_ALL = 'token_role_all'

1044

ROLE_HTTP = 'token_role_http'

1044

ROLE_HTTP = 'token_role_http'

1045

ROLE_VCS = 'token_role_vcs'

1045

ROLE_VCS = 'token_role_vcs'

1046

ROLE_API = 'token_role_api'

1046

ROLE_API = 'token_role_api'

1047

ROLE_FEED = 'token_role_feed'

1047

ROLE_FEED = 'token_role_feed'

1048

ROLE_PASSWORD_RESET = 'token_password_reset'

1048

ROLE_PASSWORD_RESET = 'token_password_reset'

1049

1050

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

1050

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

1051

1052

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

1052

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

1053

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

1053

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

1054

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

1054

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

1055

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

1055

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

1056

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

1056

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

1057

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

1057

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

1058

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

1058

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

1059

1060

# scope columns

1060

# scope columns

1061

repo_id = Column(

1061

repo_id = Column(

1062

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

1062

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

1063

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

1063

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

1064

repo = relationship('Repository', lazy='joined')

1064

repo = relationship('Repository', lazy='joined')

1065

1066

repo_group_id = Column(

1066

repo_group_id = Column(

1067

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

1067

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

1068

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

1068

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

1069

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

1069

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

1070

1071

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

1071

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

1072

1073

def __unicode__(self):

1073

def __unicode__(self):

1074

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

1074

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

1075

1076

def __json__(self):

1076

def __json__(self):

1077

data = {

1077

data = {

1078

'auth_token': self.api_key,

1078

'auth_token': self.api_key,

1079

'role': self.role,

1079

'role': self.role,

1080

'scope': self.scope_humanized,

1080

'scope': self.scope_humanized,

1081

'expired': self.expired

1081

'expired': self.expired

1082

}

1082

}

1083

return data

1083

return data

1084

1085

def get_api_data(self, include_secrets=False):

1085

def get_api_data(self, include_secrets=False):

1086

data = self.__json__()

1086

data = self.__json__()

1087

if include_secrets:

1087

if include_secrets:

1088

return data

1088

return data

1089

else:

1089

else:

1090

data['auth_token'] = self.token_obfuscated

1090

data['auth_token'] = self.token_obfuscated

1091

return data

1091

return data

1092

1093

@hybrid_property

1093

@hybrid_property

1094

def description_safe(self):

1094

def description_safe(self):

1095

from rhodecode.lib import helpers as h

1095

from rhodecode.lib import helpers as h

1096

return h.escape(self.description)

1096

return h.escape(self.description)

1097

1098

@property

1098

@property

1099

def expired(self):

1099

def expired(self):

1100

if self.expires == -1:

1100

if self.expires == -1:

1101

return False

1101

return False

1102

return time.time() > self.expires

1102

return time.time() > self.expires

1103

1104

@classmethod

1104

@classmethod

1105

def _get_role_name(cls, role):

1105

def _get_role_name(cls, role):

1106

return {

1106

return {

1107

cls.ROLE_ALL: _('all'),

1107

cls.ROLE_ALL: _('all'),

1108

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

1108

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

1109

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

1109

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

1110

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

1110

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

1111

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

1111

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

1112

}.get(role, role)

1112

}.get(role, role)

1113

1114

@property

1114

@property

1115

def role_humanized(self):

1115

def role_humanized(self):

1116

return self._get_role_name(self.role)

1116

return self._get_role_name(self.role)

1117

1118

def _get_scope(self):

1118

def _get_scope(self):

1119

if self.repo:

1119

if self.repo:

1120

return repr(self.repo)

1120

return repr(self.repo)

1121

if self.repo_group:

1121

if self.repo_group:

1122

return repr(self.repo_group) + ' (recursive)'

1122

return repr(self.repo_group) + ' (recursive)'

1123

return 'global'

1123

return 'global'

1124

1125

@property

1125

@property

1126

def scope_humanized(self):

1126

def scope_humanized(self):

1127

return self._get_scope()

1127

return self._get_scope()

1128

1129

@property

1129

@property

1130

def token_obfuscated(self):

1130

def token_obfuscated(self):

1131

if self.api_key:

1131

if self.api_key:

1132

return self.api_key[:4] + "****"

1132

return self.api_key[:4] + "****"

1133

1134

1135

class UserEmailMap(Base, BaseModel):

1135

class UserEmailMap(Base, BaseModel):

1136

__tablename__ = 'user_email_map'

1136

__tablename__ = 'user_email_map'

1137

__table_args__ = (

1137

__table_args__ = (

1138

Index('uem_email_idx', 'email'),

1138

Index('uem_email_idx', 'email'),

1139

UniqueConstraint('email'),

1139

UniqueConstraint('email'),

1140

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

1140

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

1141

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

1141

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

1142

)

1142

)

1143

__mapper_args__ = {}

1143

__mapper_args__ = {}

1144

1145

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

1145

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

1146

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

1146

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

1147

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

1147

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

1148

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

1148

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

1149

1150

@validates('_email')

1150

@validates('_email')

1151

def validate_email(self, key, email):

1151

def validate_email(self, key, email):

1152

# check if this email is not main one

1152

# check if this email is not main one

1153

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

1153

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

1154

if main_email is not None:

1154

if main_email is not None:

1155

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

1155

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

1156

return email

1156

return email

1157

1158

@hybrid_property

1158

@hybrid_property

1159

def email(self):

1159

def email(self):

1160

return self._email

1160

return self._email

1161

1162

@email.setter

1162

@email.setter

1163

def email(self, val):

1163

def email(self, val):

1164

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

1164

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

1165

1166

1167

class UserIpMap(Base, BaseModel):

1167

class UserIpMap(Base, BaseModel):

1168

__tablename__ = 'user_ip_map'

1168

__tablename__ = 'user_ip_map'

1169

__table_args__ = (

1169

__table_args__ = (

1170

UniqueConstraint('user_id', 'ip_addr'),

1170

UniqueConstraint('user_id', 'ip_addr'),

1171

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

1171

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

1172

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

1172

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

1173

)

1173

)

1174

__mapper_args__ = {}

1174

__mapper_args__ = {}

1175

1176

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

1176

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

1177

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

1177

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

1178

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

1178

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

1179

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

1179

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

1180

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

1180

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

1181

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

1181

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

1182

1183

@hybrid_property

1183

@hybrid_property

1184

def description_safe(self):

1184

def description_safe(self):

1185

from rhodecode.lib import helpers as h

1185

from rhodecode.lib import helpers as h

1186

return h.escape(self.description)

1186

return h.escape(self.description)

1187

1188

@classmethod

1188

@classmethod

1189

def _get_ip_range(cls, ip_addr):

1189

def _get_ip_range(cls, ip_addr):

1190

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

1190

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

1191

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

1191

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

1192

1193

def __json__(self):

1193

def __json__(self):

1194

return {

1194

return {

1195

'ip_addr': self.ip_addr,

1195

'ip_addr': self.ip_addr,

1196

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

1196

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

1197

}

1197

}

1198

1199

def __unicode__(self):

1199

def __unicode__(self):

1200

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

1200

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

1201

self.user_id, self.ip_addr)

1201

self.user_id, self.ip_addr)

1202

1203

1204

class UserSshKeys(Base, BaseModel):

1204

class UserSshKeys(Base, BaseModel):

1205

__tablename__ = 'user_ssh_keys'

1205

__tablename__ = 'user_ssh_keys'

1206

__table_args__ = (

1206

__table_args__ = (

1207

Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),

1207

Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),

1208

1209

UniqueConstraint('ssh_key_fingerprint'),

1209

UniqueConstraint('ssh_key_fingerprint'),

1210

1211

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

1211

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

1212

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

1212

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

1213

)

1213

)

1214

__mapper_args__ = {}

1214

__mapper_args__ = {}

1215

1216

ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)

1216

ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)

1217

ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)

1217

ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)

1218

ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)

1218

ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)

1219

1220

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

1220

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

1221

1222

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

1222

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

1223

accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)

1223

accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)

1224

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

1224

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

1225

1226

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

1226

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

1227

1228

def __json__(self):

1228

def __json__(self):

1229

data = {

1229

data = {

1230

'ssh_fingerprint': self.ssh_key_fingerprint,

1230

'ssh_fingerprint': self.ssh_key_fingerprint,

1231

'description': self.description,

1231

'description': self.description,

1232

'created_on': self.created_on

1232

'created_on': self.created_on

1233

}

1233

}

1234

return data

1234

return data

1235

1236

def get_api_data(self):

1236

def get_api_data(self):

1237

data = self.__json__()

1237

data = self.__json__()

1238

return data

1238

return data

1239

1240

1241

class UserLog(Base, BaseModel):

1241

class UserLog(Base, BaseModel):

1242

__tablename__ = 'user_logs'

1242

__tablename__ = 'user_logs'

1243

__table_args__ = (

1243

__table_args__ = (

1244

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

1244

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

1245

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

1245

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

1246

)

1246

)

1247

VERSION_1 = 'v1'

1247

VERSION_1 = 'v1'

1248

VERSION_2 = 'v2'

1248

VERSION_2 = 'v2'

1249

VERSIONS = [VERSION_1, VERSION_2]

1249

VERSIONS = [VERSION_1, VERSION_2]

1250

1251

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

1251

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

1252

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

1252

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

1253

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

1253

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

1254

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)

1254

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)

1255

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

1255

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

1256

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

1256

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

1257

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

1257

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

1258

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

1258

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

1259

1260

version = Column("version", String(255), nullable=True, default=VERSION_1)

1260

version = Column("version", String(255), nullable=True, default=VERSION_1)

1261

user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))

1261

user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))

1262

action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))

1262

action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))

1263

1264

def __unicode__(self):

1264

def __unicode__(self):

1265

return u"<%s('id:%s:%s')>" % (

1265

return u"<%s('id:%s:%s')>" % (

1266

self.__class__.__name__, self.repository_name, self.action)

1266

self.__class__.__name__, self.repository_name, self.action)

1267

1268

def __json__(self):

1268

def __json__(self):

1269

return {

1269

return {

1270

'user_id': self.user_id,

1270

'user_id': self.user_id,

1271

'username': self.username,

1271

'username': self.username,

1272

'repository_id': self.repository_id,

1272

'repository_id': self.repository_id,

1273

'repository_name': self.repository_name,

1273

'repository_name': self.repository_name,

1274

'user_ip': self.user_ip,

1274

'user_ip': self.user_ip,

1275

'action_date': self.action_date,

1275

'action_date': self.action_date,

1276

'action': self.action,

1276

'action': self.action,

1277

}

1277

}

1278

1279

@hybrid_property

1279

@hybrid_property

1280

def entry_id(self):

1280

def entry_id(self):

1281

return self.user_log_id

1281

return self.user_log_id

1282

1283

@property

1283

@property

1284

def action_as_day(self):

1284

def action_as_day(self):

1285

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

1285

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

1286

1287

user = relationship('User')

1287

user = relationship('User')

1288

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

1288

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

1289

1290

1291

class UserGroup(Base, BaseModel):

1291

class UserGroup(Base, BaseModel):

1292

__tablename__ = 'users_groups'

1292

__tablename__ = 'users_groups'

1293

__table_args__ = (

1293

__table_args__ = (

1294

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

1294

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

1295

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

1295

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

1296

)

1296

)

1297

1298

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

1298

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

1299

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

1299

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

1300

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

1300

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

1301

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

1301

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

1302

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

1302

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

1303

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

1303

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

1304

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

1304

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

1305

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

1305

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

1306

1307

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

1307

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

1308

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

1308

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

1309

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

1309

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

1310

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

1310

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

1311

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

1311

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

1312

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

1312

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

1313

1314

user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')

1314

user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')

1315

user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")

1315

user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")

1316

1317

@classmethod

1317

@classmethod

1318

def _load_group_data(cls, column):

1318

def _load_group_data(cls, column):

1319

if not column:

1319

if not column:

1320

return {}

1320

return {}

1321

1322

try:

1322

try:

1323

return json.loads(column) or {}

1323

return json.loads(column) or {}

1324

except TypeError:

1324

except TypeError:

1325

return {}

1325

return {}

1326

1327

@hybrid_property

1327

@hybrid_property

1328

def description_safe(self):

1328

def description_safe(self):

1329

from rhodecode.lib import helpers as h

1329

from rhodecode.lib import helpers as h

1330

return h.escape(self.user_group_description)

1330

return h.escape(self.user_group_description)

1331

1332

@hybrid_property

1332

@hybrid_property

1333

def group_data(self):

1333

def group_data(self):

1334

return self._load_group_data(self._group_data)

1334

return self._load_group_data(self._group_data)

1335

1336

@group_data.expression

1336

@group_data.expression

1337

def group_data(self, **kwargs):

1337

def group_data(self, **kwargs):

1338

return self._group_data

1338

return self._group_data

1339

1340

@group_data.setter

1340

@group_data.setter

1341

def group_data(self, val):

1341

def group_data(self, val):

1342

try:

1342

try:

1343

self._group_data = json.dumps(val)

1343

self._group_data = json.dumps(val)

1344

except Exception:

1344

except Exception:

1345

log.error(traceback.format_exc())

1345

log.error(traceback.format_exc())

1346

1347

@classmethod

1347

@classmethod

1348

def _load_sync(cls, group_data):

1348

def _load_sync(cls, group_data):

1349

if group_data:

1349

if group_data:

1350

return group_data.get('extern_type')

1350

return group_data.get('extern_type')

1351

1352

@property

1352

@property

1353

def sync(self):

1353

def sync(self):

1354

return self._load_sync(self.group_data)

1354

return self._load_sync(self.group_data)

1355

1356

def __unicode__(self):

1356

def __unicode__(self):

1357

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

1357

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

1358

self.users_group_id,

1358

self.users_group_id,

1359

self.users_group_name)

1359

self.users_group_name)

1360

1361

@classmethod

1361

@classmethod

1362

def get_by_group_name(cls, group_name, cache=False,

1362

def get_by_group_name(cls, group_name, cache=False,

1363

case_insensitive=False):

1363

case_insensitive=False):

1364

if case_insensitive:

1364

if case_insensitive:

1365

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

1365

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

1366

func.lower(group_name))

1366

func.lower(group_name))

1367

1368

else:

1368

else:

1369

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

1369

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

1370

if cache:

1370

if cache:

1371

q = q.options(

1371

q = q.options(

1372

FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))

1372

FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))

1373

return q.scalar()

1373

return q.scalar()

1374

1375

@classmethod

1375

@classmethod

1376

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

1376

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

1377

if not user_group_id:

1377

if not user_group_id:

1378

return

1378

return

1379

1380

user_group = cls.query()

1380

user_group = cls.query()

1381

if cache:

1381

if cache:

1382

user_group = user_group.options(

1382

user_group = user_group.options(

1383

FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))

1383

FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))

1384

return user_group.get(user_group_id)

1384

return user_group.get(user_group_id)

1385

1386

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

1386

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

1387

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

1387

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

1388

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

1388

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

1389

joinedload(UserUserGroupToPerm.user),

1389

joinedload(UserUserGroupToPerm.user),

1390

joinedload(UserUserGroupToPerm.permission),)

1390

joinedload(UserUserGroupToPerm.permission),)

1391

1392

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

1392

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

1393

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

1393

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

1394

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

1394

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

1395

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

1395

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

1396

# would propagate to both objects

1396

# would propagate to both objects

1397

perm_rows = []

1397

perm_rows = []

1398

for _usr in q.all():

1398

for _usr in q.all():

1399

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

1399

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

1400

usr.permission = _usr.permission.permission_name

1400

usr.permission = _usr.permission.permission_name

1401

perm_rows.append(usr)

1401

perm_rows.append(usr)

1402

1403

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

1403

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

1404

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

1404

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

1405

# each group

1405

# each group

1406

perm_rows = sorted(perm_rows, key=display_user_sort)

1406

perm_rows = sorted(perm_rows, key=display_user_sort)

1407

1408

_admin_perm = 'usergroup.admin'

1408

_admin_perm = 'usergroup.admin'

1409

owner_row = []

1409

owner_row = []

1410

if with_owner:

1410

if with_owner:

1411

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

1411

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

1412

usr.owner_row = True

1412

usr.owner_row = True

1413

usr.permission = _admin_perm

1413

usr.permission = _admin_perm

1414

owner_row.append(usr)

1414

owner_row.append(usr)

1415

1416

super_admin_rows = []

1416

super_admin_rows = []

1417

if with_admins:

1417

if with_admins:

1418

for usr in User.get_all_super_admins():

1418

for usr in User.get_all_super_admins():

1419

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

1419

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

1420

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

1420

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

1421

owner_row[0].admin_row = True

1421

owner_row[0].admin_row = True

1422

else:

1422

else:

1423

usr = AttributeDict(usr.get_dict())

1423

usr = AttributeDict(usr.get_dict())

1424

usr.admin_row = True

1424

usr.admin_row = True

1425

usr.permission = _admin_perm

1425

usr.permission = _admin_perm

1426

super_admin_rows.append(usr)

1426

super_admin_rows.append(usr)

1427

1428

return super_admin_rows + owner_row + perm_rows

1428

return super_admin_rows + owner_row + perm_rows

1429

1430

def permission_user_groups(self):

1430

def permission_user_groups(self):

1431

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

1431

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

1432

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

1432

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

1433

joinedload(UserGroupUserGroupToPerm.target_user_group),

1433

joinedload(UserGroupUserGroupToPerm.target_user_group),

1434

joinedload(UserGroupUserGroupToPerm.permission),)

1434

joinedload(UserGroupUserGroupToPerm.permission),)

1435

1436

perm_rows = []

1436

perm_rows = []

1437

for _user_group in q.all():

1437

for _user_group in q.all():

1438

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

1438

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

1439

usr.permission = _user_group.permission.permission_name

1439

usr.permission = _user_group.permission.permission_name

1440

perm_rows.append(usr)

1440

perm_rows.append(usr)

1441

1442

perm_rows = sorted(perm_rows, key=display_user_group_sort)

1442

perm_rows = sorted(perm_rows, key=display_user_group_sort)

1443

return perm_rows

1443

return perm_rows

1444

1445

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

1445

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

1446

from rhodecode.model.permission import PermissionModel

1446

from rhodecode.model.permission import PermissionModel

1447

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

1447

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

1448

1449

def get_default_perms(self, suffix=''):

1449

def get_default_perms(self, suffix=''):

1450

return self._get_default_perms(self, suffix)

1450

return self._get_default_perms(self, suffix)

1451

1452

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

1452

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

1453

"""

1453

"""

1454

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

1454

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

1455

basically forwarded.

1455

basically forwarded.

1456

1457

"""

1457

"""

1458

user_group = self

1458

user_group = self

1459

data = {

1459

data = {

1460

'users_group_id': user_group.users_group_id,

1460

'users_group_id': user_group.users_group_id,

1461

'group_name': user_group.users_group_name,

1461

'group_name': user_group.users_group_name,

1462

'group_description': user_group.user_group_description,

1462

'group_description': user_group.user_group_description,

1463

'active': user_group.users_group_active,

1463

'active': user_group.users_group_active,

1464

'owner': user_group.user.username,

1464

'owner': user_group.user.username,

1465

'sync': user_group.sync,

1465

'sync': user_group.sync,

1466

'owner_email': user_group.user.email,

1466

'owner_email': user_group.user.email,

1467

}

1467

}

1468

1469

if with_group_members:

1469

if with_group_members:

1470

users = []

1470

users = []

1471

for user in user_group.members:

1471

for user in user_group.members:

1472

user = user.user

1472

user = user.user

1473

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

1473

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

1474

data['users'] = users

1474

data['users'] = users

1475

1476

return data

1476

return data

1477

1478

1479

class UserGroupMember(Base, BaseModel):

1479

class UserGroupMember(Base, BaseModel):

1480

__tablename__ = 'users_groups_members'

1480

__tablename__ = 'users_groups_members'

1481

__table_args__ = (

1481

__table_args__ = (

1482

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

1482

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

1483

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

1483

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

1484

)

1484

)

1485

1486

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

1486

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

1487

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

1487

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

1488

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

1488

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

1489

1490

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

1490

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

1491

users_group = relationship('UserGroup')

1491

users_group = relationship('UserGroup')

1492

1493

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

1493

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

1494

self.users_group_id = gr_id

1494

self.users_group_id = gr_id

1495

self.user_id = u_id

1495

self.user_id = u_id

1496

1497

1498

class RepositoryField(Base, BaseModel):

1498

class RepositoryField(Base, BaseModel):

1499

__tablename__ = 'repositories_fields'

1499

__tablename__ = 'repositories_fields'

1500

__table_args__ = (

1500

__table_args__ = (

1501

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

1501

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

1502

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

1502

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

1503

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

1503

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

1504

)

1504

)

1505

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

1505

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

1506

1507

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

1507

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

1508

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

1508

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

1509

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

1509

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

1510

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

1510

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

1511

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

1511

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

1512

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

1512

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

1513

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

1513

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

1514

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

1514

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

1515

1516

repository = relationship('Repository')

1516

repository = relationship('Repository')

1517

1518

@property

1518

@property

1519

def field_key_prefixed(self):

1519

def field_key_prefixed(self):

1520

return 'ex_%s' % self.field_key

1520

return 'ex_%s' % self.field_key

1521

1522

@classmethod

1522

@classmethod

1523

def un_prefix_key(cls, key):

1523

def un_prefix_key(cls, key):

1524

if key.startswith(cls.PREFIX):

1524

if key.startswith(cls.PREFIX):

1525

return key[len(cls.PREFIX):]

1525

return key[len(cls.PREFIX):]

1526

return key

1526

return key

1527

1528

@classmethod

1528

@classmethod

1529

def get_by_key_name(cls, key, repo):

1529

def get_by_key_name(cls, key, repo):

1530

row = cls.query()\

1530

row = cls.query()\

1531

.filter(cls.repository == repo)\

1531

.filter(cls.repository == repo)\

1532

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

1532

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

1533

return row

1533

return row

1534

1535

1536

class Repository(Base, BaseModel):

1536

class Repository(Base, BaseModel):

1537

__tablename__ = 'repositories'

1537

__tablename__ = 'repositories'

1538

__table_args__ = (

1538

__table_args__ = (

1539

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

1539

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

1540

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

1540

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

1541

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

1541

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

1542

)

1542

)

1543

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

1543

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

1544

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

1544

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

1545

DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'

1545

DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'

1546

1547

STATE_CREATED = 'repo_state_created'

1547

STATE_CREATED = 'repo_state_created'

1548

STATE_PENDING = 'repo_state_pending'

1548

STATE_PENDING = 'repo_state_pending'

1549

STATE_ERROR = 'repo_state_error'

1549

STATE_ERROR = 'repo_state_error'

1550

1551

LOCK_AUTOMATIC = 'lock_auto'

1551

LOCK_AUTOMATIC = 'lock_auto'

1552

LOCK_API = 'lock_api'

1552

LOCK_API = 'lock_api'

1553

LOCK_WEB = 'lock_web'

1553

LOCK_WEB = 'lock_web'

1554

LOCK_PULL = 'lock_pull'

1554

LOCK_PULL = 'lock_pull'

1555

1556

NAME_SEP = URL_SEP

1556

NAME_SEP = URL_SEP

1557

1558

repo_id = Column(

1558

repo_id = Column(

1559

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

1559

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

1560

primary_key=True)

1560

primary_key=True)

1561

_repo_name = Column(

1561

_repo_name = Column(

1562

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

1562

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

1563

_repo_name_hash = Column(

1563

_repo_name_hash = Column(

1564

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

1564

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

1565

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

1565

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

1566

1567

clone_uri = Column(

1567

clone_uri = Column(

1568

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

1568

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

1569

default=None)

1569

default=None)

1570

push_uri = Column(

1570

push_uri = Column(

1571

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

1571

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

1572

default=None)

1572

default=None)

1573

repo_type = Column(

1573

repo_type = Column(

1574

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

1574

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

1575

user_id = Column(

1575

user_id = Column(

1576

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

1576

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

1577

unique=False, default=None)

1577

unique=False, default=None)

1578

private = Column(

1578

private = Column(

1579

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

1579

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

1580

enable_statistics = Column(

1580

enable_statistics = Column(

1581

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

1581

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

1582

enable_downloads = Column(

1582

enable_downloads = Column(

1583

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

1583

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

1584

description = Column(

1584

description = Column(

1585

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

1585

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

1586

created_on = Column(

1586

created_on = Column(

1587

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

1587

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

1588

default=datetime.datetime.now)

1588

default=datetime.datetime.now)

1589

updated_on = Column(

1589

updated_on = Column(

1590

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

1590

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

1591

default=datetime.datetime.now)

1591

default=datetime.datetime.now)

1592

_landing_revision = Column(

1592

_landing_revision = Column(

1593

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

1593

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

1594

default=None)

1594

default=None)

1595

enable_locking = Column(

1595

enable_locking = Column(

1596

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

1596

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

1597

default=False)

1597

default=False)

1598

_locked = Column(

1598

_locked = Column(

1599

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

1599

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

1600

_changeset_cache = Column(

1600

_changeset_cache = Column(

1601

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

1601

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

1602

1603

fork_id = Column(

1603

fork_id = Column(

1604

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

1604

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

1605

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

1605

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

1606

group_id = Column(

1606

group_id = Column(

1607

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

1607

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

1608

unique=False, default=None)

1608

unique=False, default=None)

1609

1610

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

1610

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

1611

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

1611

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

1612

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

1612

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

1613

repo_to_perm = relationship(

1613

repo_to_perm = relationship(

1614

'UserRepoToPerm', cascade='all',

1614

'UserRepoToPerm', cascade='all',

1615

order_by='UserRepoToPerm.repo_to_perm_id')

1615

order_by='UserRepoToPerm.repo_to_perm_id')

1616

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

1616

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

1617

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

1617

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

1618

1619

followers = relationship(

1619

followers = relationship(

1620

'UserFollowing',

1620

'UserFollowing',

1621

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

1621

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

1622

cascade='all')

1622

cascade='all')

1623

extra_fields = relationship(

1623

extra_fields = relationship(

1624

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

1624

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

1625

logs = relationship('UserLog')

1625

logs = relationship('UserLog')

1626

comments = relationship(

1626

comments = relationship(

1627

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

1627

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

1628

pull_requests_source = relationship(

1628

pull_requests_source = relationship(

1629

'PullRequest',

1629

'PullRequest',

1630

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

1630

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

1631

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

1631

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

1632

pull_requests_target = relationship(

1632

pull_requests_target = relationship(

1633

'PullRequest',

1633

'PullRequest',

1634

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

1634

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

1635

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

1635

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

1636

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

1636

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

1637

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

1637

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

1638

integrations = relationship('Integration',

1638

integrations = relationship('Integration',

1639

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

1639

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

1640

1641

scoped_tokens = relationship('UserApiKeys', cascade="all")

1641

scoped_tokens = relationship('UserApiKeys', cascade="all")

1642

1643

def __unicode__(self):

1643

def __unicode__(self):

1644

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

1644

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

1645

safe_unicode(self.repo_name))

1645

safe_unicode(self.repo_name))

1646

1647

@hybrid_property

1647

@hybrid_property

1648

def description_safe(self):

1648

def description_safe(self):

1649

from rhodecode.lib import helpers as h

1649

from rhodecode.lib import helpers as h

1650

return h.escape(self.description)

1650

return h.escape(self.description)

1651

1652

@hybrid_property

1652

@hybrid_property

1653

def landing_rev(self):

1653

def landing_rev(self):

1654

# always should return [rev_type, rev]

1654

# always should return [rev_type, rev]

1655

if self._landing_revision:

1655

if self._landing_revision:

1656

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

1656

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

1657

if len(_rev_info) < 2:

1657

if len(_rev_info) < 2:

1658

_rev_info.insert(0, 'rev')

1658

_rev_info.insert(0, 'rev')

1659

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

1659

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

1660

return [None, None]

1660

return [None, None]

1661

1662

@landing_rev.setter

1662

@landing_rev.setter

1663

def landing_rev(self, val):

1663

def landing_rev(self, val):

1664

if ':' not in val:

1664

if ':' not in val:

1665

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

1665

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

1666

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

1666

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

1667

self._landing_revision = val

1667

self._landing_revision = val

1668

1669

@hybrid_property

1669

@hybrid_property

1670

def locked(self):

1670

def locked(self):

1671

if self._locked:

1671

if self._locked:

1672

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

1672

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

1673

lock_values = int(user_id), timelocked, reason

1673

lock_values = int(user_id), timelocked, reason

1674

else:

1674

else:

1675

lock_values = [None, None, None]

1675

lock_values = [None, None, None]

1676

return lock_values

1676

return lock_values

1677

1678

@locked.setter

1678

@locked.setter

1679

def locked(self, val):

1679

def locked(self, val):

1680

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

1680

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

1681

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

1681

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

1682

else:

1682

else:

1683

self._locked = None

1683

self._locked = None

1684

1685

@hybrid_property

1685

@hybrid_property

1686

def changeset_cache(self):

1686

def changeset_cache(self):

1687

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

1687

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

1688

dummy = EmptyCommit().__json__()

1688

dummy = EmptyCommit().__json__()

1689

if not self._changeset_cache:

1689

if not self._changeset_cache:

1690

return dummy

1690

return dummy

1691

try:

1691

try:

1692

return json.loads(self._changeset_cache)

1692

return json.loads(self._changeset_cache)

1693

except TypeError:

1693

except TypeError:

1694

return dummy

1694

return dummy

1695

except Exception:

1695

except Exception:

1696

log.error(traceback.format_exc())

1696

log.error(traceback.format_exc())

1697

return dummy

1697

return dummy

1698

1699

@changeset_cache.setter

1699

@changeset_cache.setter

1700

def changeset_cache(self, val):

1700

def changeset_cache(self, val):

1701

try:

1701

try:

1702

self._changeset_cache = json.dumps(val)

1702

self._changeset_cache = json.dumps(val)

1703

except Exception:

1703

except Exception:

1704

log.error(traceback.format_exc())

1704

log.error(traceback.format_exc())

1705

1706

@hybrid_property

1706

@hybrid_property

1707

def repo_name(self):

1707

def repo_name(self):

1708

return self._repo_name

1708

return self._repo_name

1709

1710

@repo_name.setter

1710

@repo_name.setter

1711

def repo_name(self, value):

1711

def repo_name(self, value):

1712

self._repo_name = value

1712

self._repo_name = value

1713

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

1713

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

1714

1715

@classmethod

1715

@classmethod

1716

def normalize_repo_name(cls, repo_name):

1716

def normalize_repo_name(cls, repo_name):

1717

"""

1717

"""

1718

Normalizes os specific repo_name to the format internally stored inside

1718

Normalizes os specific repo_name to the format internally stored inside

1719

database using URL_SEP

1719

database using URL_SEP

1720

1721

:param cls:

1721

:param cls:

1722

:param repo_name:

1722

:param repo_name:

1723

"""

1723

"""

1724

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

1724

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

1725

1726

@classmethod

1726

@classmethod

1727

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

1727

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

1728

session = Session()

1728

session = Session()

1729

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

1729

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

1730

1731

if cache:

1731

if cache:

1732

if identity_cache:

1732

if identity_cache:

1733

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

1733

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

1734

if val:

1734

if val:

1735

return val

1735

return val

1736

else:

1736

else:

1737

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

1737

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

1738

q = q.options(

1738

q = q.options(

1739

FromCache("sql_cache_short", cache_key))

1739

FromCache("sql_cache_short", cache_key))

1740

1741

return q.scalar()

1741

return q.scalar()

1742

1743

@classmethod

1743

@classmethod

1744

def get_by_id_or_repo_name(cls, repoid):

1744

def get_by_id_or_repo_name(cls, repoid):

1745

if isinstance(repoid, (int, long)):

1745

if isinstance(repoid, (int, long)):

1746

try:

1746

try:

1747

repo = cls.get(repoid)

1747

repo = cls.get(repoid)

1748

except ValueError:

1748

except ValueError:

1749

repo = None

1749

repo = None

1750

else:

1750

else:

1751

repo = cls.get_by_repo_name(repoid)

1751

repo = cls.get_by_repo_name(repoid)

1752

return repo

1752

return repo

1753

1754

@classmethod

1754

@classmethod

1755

def get_by_full_path(cls, repo_full_path):

1755

def get_by_full_path(cls, repo_full_path):

1756

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

1756

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

1757

repo_name = cls.normalize_repo_name(repo_name)

1757

repo_name = cls.normalize_repo_name(repo_name)

1758

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

1758

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

1759

1760

@classmethod

1760

@classmethod

1761

def get_repo_forks(cls, repo_id):

1761

def get_repo_forks(cls, repo_id):

1762

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

1762

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

1763

1764

@classmethod

1764

@classmethod

1765

def base_path(cls):

1765

def base_path(cls):

1766

"""

1766

"""

1767

Returns base path when all repos are stored

1767

Returns base path when all repos are stored

1768

1769

:param cls:

1769

:param cls:

1770

"""

1770

"""

1771

q = Session().query(RhodeCodeUi)\

1771

q = Session().query(RhodeCodeUi)\

1772

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

1772

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

1773

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

1773

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

1774

return q.one().ui_value

1774

return q.one().ui_value

1775

1776

@classmethod

1776

@classmethod

1777

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

1777

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

1778

case_insensitive=True):

1778

case_insensitive=True):

1779

q = Repository.query()

1779

q = Repository.query()

1780

1781

if not isinstance(user_id, Optional):

1781

if not isinstance(user_id, Optional):

1782

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

1782

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

1783

1784

if not isinstance(group_id, Optional):

1784

if not isinstance(group_id, Optional):

1785

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

1785

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

1786

1787

if case_insensitive:

1787

if case_insensitive:

1788

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

1788

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

1789

else:

1789

else:

1790

q = q.order_by(Repository.repo_name)

1790

q = q.order_by(Repository.repo_name)

1791

return q.all()

1791

return q.all()

1792

1793

@property

1793

@property

1794

def forks(self):

1794

def forks(self):

1795

"""

1795

"""

1796

Return forks of this repo

1796

Return forks of this repo

1797

"""

1797

"""

1798

return Repository.get_repo_forks(self.repo_id)

1798

return Repository.get_repo_forks(self.repo_id)

1799

1800

@property

1800

@property

1801

def parent(self):

1801

def parent(self):

1802

"""

1802

"""

1803

Returns fork parent

1803

Returns fork parent

1804

"""

1804

"""

1805

return self.fork

1805

return self.fork

1806

1807

@property

1807

@property

1808

def just_name(self):

1808

def just_name(self):

1809

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

1809

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

1810

1811

@property

1811

@property

1812

def groups_with_parents(self):

1812

def groups_with_parents(self):

1813

groups = []

1813

groups = []

1814

if self.group is None:

1814

if self.group is None:

1815

return groups

1815

return groups

1816

1817

cur_gr = self.group

1817

cur_gr = self.group

1818

groups.insert(0, cur_gr)

1818

groups.insert(0, cur_gr)

1819

while 1:

1819

while 1:

1820

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

1820

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

1821

cur_gr = cur_gr.parent_group

1821

cur_gr = cur_gr.parent_group

1822

if gr is None:

1822

if gr is None:

1823

break

1823

break

1824

groups.insert(0, gr)

1824

groups.insert(0, gr)

1825

1826

return groups

1826

return groups

1827

1828

@property

1828

@property

1829

def groups_and_repo(self):

1829

def groups_and_repo(self):

1830

return self.groups_with_parents, self

1830

return self.groups_with_parents, self

1831

1832

@LazyProperty

1832

@LazyProperty

1833

def repo_path(self):

1833

def repo_path(self):

1834

"""

1834

"""

1835

Returns base full path for that repository means where it actually

1835

Returns base full path for that repository means where it actually

1836

exists on a filesystem

1836

exists on a filesystem

1837

"""

1837

"""

1838

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

1838

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

1839

RhodeCodeUi.ui_key == self.NAME_SEP)

1839

RhodeCodeUi.ui_key == self.NAME_SEP)

1840

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

1840

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

1841

return q.one().ui_value

1841

return q.one().ui_value

1842

1843

@property

1843

@property

1844

def repo_full_path(self):

1844

def repo_full_path(self):

1845

p = [self.repo_path]

1845

p = [self.repo_path]

1846

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

1846

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

1847

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

1847

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

1848

# into a valid system path

1848

# into a valid system path

1849

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

1849

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

1850

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

1850

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

1851

1852

@property

1852

@property

1853

def cache_keys(self):

1853

def cache_keys(self):

1854

"""

1854

"""

1855

Returns associated cache keys for that repo

1855

Returns associated cache keys for that repo

1856

"""

1856

"""

1857

return CacheKey.query()\

1857

return CacheKey.query()\

1858

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

1858

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

1859

.order_by(CacheKey.cache_key)\

1859

.order_by(CacheKey.cache_key)\

1860

.all()

1860

.all()

1861

1862

@property

1862

@property

1863

def cached_diffs_relative_dir(self):

1863

def cached_diffs_relative_dir(self):

1864

"""

1864

"""

1865

Return a relative to the repository store path of cached diffs

1865

Return a relative to the repository store path of cached diffs

1866

used for safe display for users, who shouldn't know the absolute store

1866

used for safe display for users, who shouldn't know the absolute store

1867

path

1867

path

1868

"""

1868

"""

1869

return os.path.join(

1869

return os.path.join(

1870

os.path.dirname(self.repo_name),

1870

os.path.dirname(self.repo_name),

1871

self.cached_diffs_dir.split(os.path.sep)[-1])

1871

self.cached_diffs_dir.split(os.path.sep)[-1])

1872

1873

@property

1873

@property

1874

def cached_diffs_dir(self):

1874

def cached_diffs_dir(self):

1875

path = self.repo_full_path

1875

path = self.repo_full_path

1876

return os.path.join(

1876

return os.path.join(

1877

os.path.dirname(path),

1877

os.path.dirname(path),

1878

'.__shadow_diff_cache_repo_{}'.format(self.repo_id))

1878

'.__shadow_diff_cache_repo_{}'.format(self.repo_id))

1879

1880

def cached_diffs(self):

1880

def cached_diffs(self):

1881

diff_cache_dir = self.cached_diffs_dir

1881

diff_cache_dir = self.cached_diffs_dir

1882

if os.path.isdir(diff_cache_dir):

1882

if os.path.isdir(diff_cache_dir):

1883

return os.listdir(diff_cache_dir)

1883

return os.listdir(diff_cache_dir)

1884

return []

1884

return []

1885

1886

def get_new_name(self, repo_name):

1886

def get_new_name(self, repo_name):

1887

"""

1887

"""

1888

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

1888

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

1889

1890

:param group_name:

1890

:param group_name:

1891

"""

1891

"""

1892

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

1892

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

1893

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

1893

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

1894

1895

@property

1895

@property

1896

def _config(self):

1896

def _config(self):

1897

"""

1897

"""

1898

Returns db based config object.

1898

Returns db based config object.

1899

"""

1899

"""

1900

from rhodecode.lib.utils import make_db_config

1900

from rhodecode.lib.utils import make_db_config

1901

return make_db_config(clear_session=False, repo=self)

1901

return make_db_config(clear_session=False, repo=self)

1902

1903

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

1903

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

1904

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

1904

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

1905

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

1905

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

1906

joinedload(UserRepoToPerm.user),

1906

joinedload(UserRepoToPerm.user),

1907

joinedload(UserRepoToPerm.permission),)

1907

joinedload(UserRepoToPerm.permission),)

1908

1909

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

1909

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

1910

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

1910

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

1911

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

1911

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

1912

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

1912

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

1913

# would propagate to both objects

1913

# would propagate to both objects

1914

perm_rows = []

1914

perm_rows = []

1915

for _usr in q.all():

1915

for _usr in q.all():

1916

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

1916

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

1917

usr.permission = _usr.permission.permission_name

1917

usr.permission = _usr.permission.permission_name

1918

perm_rows.append(usr)

1918

perm_rows.append(usr)

1919

1920

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

1920

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

1921

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

1921

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

1922

# each group

1922

# each group

1923

perm_rows = sorted(perm_rows, key=display_user_sort)

1923

perm_rows = sorted(perm_rows, key=display_user_sort)

1924

1925

_admin_perm = 'repository.admin'

1925

_admin_perm = 'repository.admin'

1926

owner_row = []

1926

owner_row = []

1927

if with_owner:

1927

if with_owner:

1928

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

1928

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

1929

usr.owner_row = True

1929

usr.owner_row = True

1930

usr.permission = _admin_perm

1930

usr.permission = _admin_perm

1931

owner_row.append(usr)

1931

owner_row.append(usr)

1932

1933

super_admin_rows = []

1933

super_admin_rows = []

1934

if with_admins:

1934

if with_admins:

1935

for usr in User.get_all_super_admins():

1935

for usr in User.get_all_super_admins():

1936

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

1936

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

1937

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

1937

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

1938

owner_row[0].admin_row = True

1938

owner_row[0].admin_row = True

1939

else:

1939

else:

1940

usr = AttributeDict(usr.get_dict())

1940

usr = AttributeDict(usr.get_dict())

1941

usr.admin_row = True

1941

usr.admin_row = True

1942

usr.permission = _admin_perm

1942

usr.permission = _admin_perm

1943

super_admin_rows.append(usr)

1943

super_admin_rows.append(usr)

1944

1945

return super_admin_rows + owner_row + perm_rows

1945

return super_admin_rows + owner_row + perm_rows

1946

1947

def permission_user_groups(self):

1947

def permission_user_groups(self):

1948

q = UserGroupRepoToPerm.query().filter(

1948

q = UserGroupRepoToPerm.query().filter(

1949

UserGroupRepoToPerm.repository == self)

1949

UserGroupRepoToPerm.repository == self)

1950

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

1950

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

1951

joinedload(UserGroupRepoToPerm.users_group),

1951

joinedload(UserGroupRepoToPerm.users_group),

1952

joinedload(UserGroupRepoToPerm.permission),)

1952

joinedload(UserGroupRepoToPerm.permission),)

1953

1954

perm_rows = []

1954

perm_rows = []

1955

for _user_group in q.all():

1955

for _user_group in q.all():

1956

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

1956

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

1957

usr.permission = _user_group.permission.permission_name

1957

usr.permission = _user_group.permission.permission_name

1958

perm_rows.append(usr)

1958

perm_rows.append(usr)

1959

1960

perm_rows = sorted(perm_rows, key=display_user_group_sort)

1960

perm_rows = sorted(perm_rows, key=display_user_group_sort)

1961

return perm_rows

1961

return perm_rows

1962

1963

def get_api_data(self, include_secrets=False):

1963

def get_api_data(self, include_secrets=False):

1964

"""

1964

"""

1965

Common function for generating repo api data

1965

Common function for generating repo api data

1966

1967

:param include_secrets: See :meth:`User.get_api_data`.

1967

:param include_secrets: See :meth:`User.get_api_data`.

1968

1969

"""

1969

"""

1970

# TODO: mikhail: Here there is an anti-pattern, we probably need to

1970

# TODO: mikhail: Here there is an anti-pattern, we probably need to

1971

# move this methods on models level.

1971

# move this methods on models level.

1972

from rhodecode.model.settings import SettingsModel

1972

from rhodecode.model.settings import SettingsModel

1973

from rhodecode.model.repo import RepoModel

1973

from rhodecode.model.repo import RepoModel

1974

1975

repo = self

1975

repo = self

1976

_user_id, _time, _reason = self.locked

1976

_user_id, _time, _reason = self.locked

1977

1978

data = {

1978

data = {

1979

'repo_id': repo.repo_id,

1979

'repo_id': repo.repo_id,

1980

'repo_name': repo.repo_name,

1980

'repo_name': repo.repo_name,

1981

'repo_type': repo.repo_type,

1981

'repo_type': repo.repo_type,

1982

'clone_uri': repo.clone_uri or '',

1982

'clone_uri': repo.clone_uri or '',

1983

'push_uri': repo.push_uri or '',

1983

'push_uri': repo.push_uri or '',

1984

'url': RepoModel().get_url(self),

1984

'url': RepoModel().get_url(self),

1985

'private': repo.private,

1985

'private': repo.private,

1986

'created_on': repo.created_on,

1986

'created_on': repo.created_on,

1987

'description': repo.description_safe,

1987

'description': repo.description_safe,

1988

'landing_rev': repo.landing_rev,

1988

'landing_rev': repo.landing_rev,

1989

'owner': repo.user.username,

1989

'owner': repo.user.username,

1990

'fork_of': repo.fork.repo_name if repo.fork else None,

1990

'fork_of': repo.fork.repo_name if repo.fork else None,

1991

'fork_of_id': repo.fork.repo_id if repo.fork else None,

1991

'fork_of_id': repo.fork.repo_id if repo.fork else None,

1992

'enable_statistics': repo.enable_statistics,

1992

'enable_statistics': repo.enable_statistics,

1993

'enable_locking': repo.enable_locking,

1993

'enable_locking': repo.enable_locking,

1994

'enable_downloads': repo.enable_downloads,

1994

'enable_downloads': repo.enable_downloads,

1995

'last_changeset': repo.changeset_cache,

1995

'last_changeset': repo.changeset_cache,

1996

'locked_by': User.get(_user_id).get_api_data(

1996

'locked_by': User.get(_user_id).get_api_data(

1997

include_secrets=include_secrets) if _user_id else None,

1997

include_secrets=include_secrets) if _user_id else None,

1998

'locked_date': time_to_datetime(_time) if _time else None,

1998

'locked_date': time_to_datetime(_time) if _time else None,

1999

'lock_reason': _reason if _reason else None,

1999

'lock_reason': _reason if _reason else None,

2000

}

2000

}

2001

2002

# TODO: mikhail: should be per-repo settings here

2002

# TODO: mikhail: should be per-repo settings here

2003

rc_config = SettingsModel().get_all_settings()

2003

rc_config = SettingsModel().get_all_settings()

2004

repository_fields = str2bool(

2004

repository_fields = str2bool(

2005

rc_config.get('rhodecode_repository_fields'))

2005

rc_config.get('rhodecode_repository_fields'))

2006

if repository_fields:

2006

if repository_fields:

2007

for f in self.extra_fields:

2007

for f in self.extra_fields:

2008

data[f.field_key_prefixed] = f.field_value

2008

data[f.field_key_prefixed] = f.field_value

2009

2010

return data

2010

return data

2011

2012

@classmethod

2012

@classmethod

2013

def lock(cls, repo, user_id, lock_time=None, lock_reason=None):

2013

def lock(cls, repo, user_id, lock_time=None, lock_reason=None):

2014

if not lock_time:

2014

if not lock_time:

2015

lock_time = time.time()

2015

lock_time = time.time()

2016

if not lock_reason:

2016

if not lock_reason:

2017

lock_reason = cls.LOCK_AUTOMATIC

2017

lock_reason = cls.LOCK_AUTOMATIC

2018

repo.locked = [user_id, lock_time, lock_reason]

2018

repo.locked = [user_id, lock_time, lock_reason]

2019

Session().add(repo)

2019

Session().add(repo)

2020

Session().commit()

2020

Session().commit()

2021

2022

@classmethod

2022

@classmethod

2023

def unlock(cls, repo):

2023

def unlock(cls, repo):

2024

repo.locked = None

2024

repo.locked = None

2025

Session().add(repo)

2025

Session().add(repo)

2026

Session().commit()

2026

Session().commit()

2027

2028

@classmethod

2028

@classmethod

2029

def getlock(cls, repo):

2029

def getlock(cls, repo):

2030

return repo.locked

2030

return repo.locked

2031

2032

def is_user_lock(self, user_id):

2032

def is_user_lock(self, user_id):

2033

if self.lock[0]:

2033

if self.lock[0]:

2034

lock_user_id = safe_int(self.lock[0])

2034

lock_user_id = safe_int(self.lock[0])

2035

user_id = safe_int(user_id)

2035

user_id = safe_int(user_id)

2036

# both are ints, and they are equal

2036

# both are ints, and they are equal

2037

return all([lock_user_id, user_id]) and lock_user_id == user_id

2037

return all([lock_user_id, user_id]) and lock_user_id == user_id

2038

2039

return False

2039

return False

2040

2041

def get_locking_state(self, action, user_id, only_when_enabled=True):

2041

def get_locking_state(self, action, user_id, only_when_enabled=True):

2042

"""

2042

"""

2043

Checks locking on this repository, if locking is enabled and lock is

2043

Checks locking on this repository, if locking is enabled and lock is

2044

present returns a tuple of make_lock, locked, locked_by.

2044

present returns a tuple of make_lock, locked, locked_by.

2045

make_lock can have 3 states None (do nothing) True, make lock

2045

make_lock can have 3 states None (do nothing) True, make lock

2046

False release lock, This value is later propagated to hooks, which

2046

False release lock, This value is later propagated to hooks, which

2047

do the locking. Think about this as signals passed to hooks what to do.

2047

do the locking. Think about this as signals passed to hooks what to do.

2048

2049

"""

2049

"""

2050

# TODO: johbo: This is part of the business logic and should be moved

2050

# TODO: johbo: This is part of the business logic and should be moved

2051

# into the RepositoryModel.

2051

# into the RepositoryModel.

2052

2053

if action not in ('push', 'pull'):

2053

if action not in ('push', 'pull'):

2054

raise ValueError("Invalid action value: %s" % repr(action))

2054

raise ValueError("Invalid action value: %s" % repr(action))

2055

2056

# defines if locked error should be thrown to user

2056

# defines if locked error should be thrown to user

2057

currently_locked = False

2057

currently_locked = False

2058

# defines if new lock should be made, tri-state

2058

# defines if new lock should be made, tri-state

2059

make_lock = None

2059

make_lock = None

2060

repo = self

2060

repo = self

2061

user = User.get(user_id)

2061

user = User.get(user_id)

2062

2063

lock_info = repo.locked

2063

lock_info = repo.locked

2064

2065

if repo and (repo.enable_locking or not only_when_enabled):

2065

if repo and (repo.enable_locking or not only_when_enabled):

2066

if action == 'push':

2066

if action == 'push':

2067

# check if it's already locked !, if it is compare users

2067

# check if it's already locked !, if it is compare users

2068

locked_by_user_id = lock_info[0]

2068

locked_by_user_id = lock_info[0]

2069

if user.user_id == locked_by_user_id:

2069

if user.user_id == locked_by_user_id:

2070

log.debug(

2070

log.debug(

2071

'Got `push` action from user %s, now unlocking', user)

2071

'Got `push` action from user %s, now unlocking', user)

2072

# unlock if we have push from user who locked

2072

# unlock if we have push from user who locked

2073

make_lock = False

2073

make_lock = False

2074

else:

2074

else:

2075

# we're not the same user who locked, ban with

2075

# we're not the same user who locked, ban with

2076

# code defined in settings (default is 423 HTTP Locked) !

2076

# code defined in settings (default is 423 HTTP Locked) !

2077

log.debug('Repo %s is currently locked by %s', repo, user)

2077

log.debug('Repo %s is currently locked by %s', repo, user)

2078

currently_locked = True

2078

currently_locked = True

2079

elif action == 'pull':

2079

elif action == 'pull':

2080

# [0] user [1] date

2080

# [0] user [1] date

2081

if lock_info[0] and lock_info[1]:

2081

if lock_info[0] and lock_info[1]:

2082

log.debug('Repo %s is currently locked by %s', repo, user)

2082

log.debug('Repo %s is currently locked by %s', repo, user)

2083

currently_locked = True

2083

currently_locked = True

2084

else:

2084

else:

2085

log.debug('Setting lock on repo %s by %s', repo, user)

2085

log.debug('Setting lock on repo %s by %s', repo, user)

2086

make_lock = True

2086

make_lock = True

2087

2088

else:

2088

else:

2089

log.debug('Repository %s do not have locking enabled', repo)

2089

log.debug('Repository %s do not have locking enabled', repo)

2090

2091

log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',

2091

log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',

2092

make_lock, currently_locked, lock_info)

2092

make_lock, currently_locked, lock_info)

2093

2094

from rhodecode.lib.auth import HasRepoPermissionAny

2094

from rhodecode.lib.auth import HasRepoPermissionAny

2095

perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')

2095

perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')

2096

if make_lock and not perm_check(repo_name=repo.repo_name, user=user):

2096

if make_lock and not perm_check(repo_name=repo.repo_name, user=user):

2097

# if we don't have at least write permission we cannot make a lock

2097

# if we don't have at least write permission we cannot make a lock

2098

log.debug('lock state reset back to FALSE due to lack '

2098

log.debug('lock state reset back to FALSE due to lack '

2099

'of at least read permission')

2099

'of at least read permission')

2100

make_lock = False

2100

make_lock = False

2101

2102

return make_lock, currently_locked, lock_info

2102

return make_lock, currently_locked, lock_info

2103

2104

@property

2104

@property

2105

def last_db_change(self):

2105

def last_db_change(self):

2106

return self.updated_on

2106

return self.updated_on

2107

2108

@property

2108

@property

2109

def clone_uri_hidden(self):

2109

def clone_uri_hidden(self):

2110

clone_uri = self.clone_uri

2110

clone_uri = self.clone_uri

2111

if clone_uri:

2111

if clone_uri:

2112

import urlobject

2112

import urlobject

2113

url_obj = urlobject.URLObject(cleaned_uri(clone_uri))

2113

url_obj = urlobject.URLObject(cleaned_uri(clone_uri))

2114

if url_obj.password:

2114

if url_obj.password:

2115

clone_uri = url_obj.with_password('*****')

2115

clone_uri = url_obj.with_password('*****')

2116

return clone_uri

2116

return clone_uri

2117

2118

@property

2118

@property

2119

def push_uri_hidden(self):

2119

def push_uri_hidden(self):

2120

push_uri = self.push_uri

2120

push_uri = self.push_uri

2121

if push_uri:

2121

if push_uri:

2122

import urlobject

2122

import urlobject

2123

url_obj = urlobject.URLObject(cleaned_uri(push_uri))

2123

url_obj = urlobject.URLObject(cleaned_uri(push_uri))

2124

if url_obj.password:

2124

if url_obj.password:

2125

push_uri = url_obj.with_password('*****')

2125

push_uri = url_obj.with_password('*****')

2126

return push_uri

2126

return push_uri

2127

2128

def clone_url(self, **override):

2128

def clone_url(self, **override):

2129

from rhodecode.model.settings import SettingsModel

2129

from rhodecode.model.settings import SettingsModel

2130

2131

uri_tmpl = None

2131

uri_tmpl = None

2132

if 'with_id' in override:

2132

if 'with_id' in override:

2133

uri_tmpl = self.DEFAULT_CLONE_URI_ID

2133

uri_tmpl = self.DEFAULT_CLONE_URI_ID

2134

del override['with_id']

2134

del override['with_id']

2135

2136

if 'uri_tmpl' in override:

2136

if 'uri_tmpl' in override:

2137

uri_tmpl = override['uri_tmpl']

2137

uri_tmpl = override['uri_tmpl']

2138

del override['uri_tmpl']

2138

del override['uri_tmpl']

2139

2140

ssh = False

2140

ssh = False

2141

if 'ssh' in override:

2141

if 'ssh' in override:

2142

ssh = True

2142

ssh = True

2143

del override['ssh']

2143

del override['ssh']

2144

2145

# we didn't override our tmpl from **overrides

2145

# we didn't override our tmpl from **overrides

2146

if not uri_tmpl:

2146

if not uri_tmpl:

2147

rc_config = SettingsModel().get_all_settings(cache=True)

2147

rc_config = SettingsModel().get_all_settings(cache=True)

2148

if ssh:

2148

if ssh:

2149

uri_tmpl = rc_config.get(

2149

uri_tmpl = rc_config.get(

2150

'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH

2150

'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH

2151

else:

2151

else:

2152

uri_tmpl = rc_config.get(

2152

uri_tmpl = rc_config.get(

2153

'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI

2153

'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI

2154

2155

request = get_current_request()

2155

request = get_current_request()

2156

return get_clone_url(request=request,

2156

return get_clone_url(request=request,

2157

uri_tmpl=uri_tmpl,

2157

uri_tmpl=uri_tmpl,

2158

repo_name=self.repo_name,

2158

repo_name=self.repo_name,

2159

repo_id=self.repo_id, **override)

2159

repo_id=self.repo_id, **override)

2160

2161

def set_state(self, state):

2161

def set_state(self, state):

2162

self.repo_state = state

2162

self.repo_state = state

2163

Session().add(self)

2163

Session().add(self)

2164

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

2164

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

2165

# SCM PROPERTIES

2165

# SCM PROPERTIES

2166

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

2166

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

2167

2168

def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):

2168

def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):

2169

return get_commit_safe(

2169

return get_commit_safe(

2170

self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)

2170

self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)

2171

2172

def get_changeset(self, rev=None, pre_load=None):

2172

def get_changeset(self, rev=None, pre_load=None):

2173

warnings.warn("Use get_commit", DeprecationWarning)

2173

warnings.warn("Use get_commit", DeprecationWarning)

2174

commit_id = None

2174

commit_id = None

2175

commit_idx = None

2175

commit_idx = None

2176

if isinstance(rev, basestring):

2176

if isinstance(rev, basestring):

2177

commit_id = rev

2177

commit_id = rev

2178

else:

2178

else:

2179

commit_idx = rev

2179

commit_idx = rev

2180

return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,

2180

return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,

2181

pre_load=pre_load)

2181

pre_load=pre_load)

2182

2183

def get_landing_commit(self):

2183

def get_landing_commit(self):

2184

"""

2184

"""

2185

Returns landing commit, or if that doesn't exist returns the tip

2185

Returns landing commit, or if that doesn't exist returns the tip

2186

"""

2186

"""

2187

_rev_type, _rev = self.landing_rev

2187

_rev_type, _rev = self.landing_rev

2188

commit = self.get_commit(_rev)

2188

commit = self.get_commit(_rev)

2189

if isinstance(commit, EmptyCommit):

2189

if isinstance(commit, EmptyCommit):

2190

return self.get_commit()

2190

return self.get_commit()

2191

return commit

2191

return commit

2192

2193

def update_commit_cache(self, cs_cache=None, config=None):

2193

def update_commit_cache(self, cs_cache=None, config=None):

2194

"""

2194

"""

2195

Update cache of last changeset for repository, keys should be::

2195

Update cache of last changeset for repository, keys should be::

2196

2197

short_id

2197

short_id

2198

raw_id

2198

raw_id

2199

revision

2199

revision

2200

parents

2200

parents

2201

message

2201

message

2202

date

2202

date

2203

author

2203

author

2204

2205

:param cs_cache:

2205

:param cs_cache:

2206

"""

2206

"""

2207

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

2207

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

2208

if cs_cache is None:

2208

if cs_cache is None:

2209

# use no-cache version here

2209

# use no-cache version here

2210

scm_repo = self.scm_instance(cache=False, config=config)

2210

scm_repo = self.scm_instance(cache=False, config=config)

2211

if scm_repo:

2211

if scm_repo:

2212

cs_cache = scm_repo.get_commit(

2212

cs_cache = scm_repo.get_commit(

2213

pre_load=["author", "date", "message", "parents"])

2213

pre_load=["author", "date", "message", "parents"])

2214

else:

2214

else:

2215

cs_cache = EmptyCommit()

2215

cs_cache = EmptyCommit()

2216

2217

if isinstance(cs_cache, BaseChangeset):

2217

if isinstance(cs_cache, BaseChangeset):

2218

cs_cache = cs_cache.__json__()

2218

cs_cache = cs_cache.__json__()

2219

2220

def is_outdated(new_cs_cache):

2220

def is_outdated(new_cs_cache):

2221

if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or

2221

if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or

2222

new_cs_cache['revision'] != self.changeset_cache['revision']):

2222

new_cs_cache['revision'] != self.changeset_cache['revision']):

2223

return True

2223

return True

2224

return False

2224

return False

2225

2226

# check if we have maybe already latest cached revision

2226

# check if we have maybe already latest cached revision

2227

if is_outdated(cs_cache) or not self.changeset_cache:

2227

if is_outdated(cs_cache) or not self.changeset_cache:

2228

_default = datetime.datetime.fromtimestamp(0)

2228

_default = datetime.datetime.fromtimestamp(0)

2229

last_change = cs_cache.get('date') or _default

2229

last_change = cs_cache.get('date') or _default

2230

log.debug('updated repo %s with new cs cache %s',

2230

log.debug('updated repo %s with new cs cache %s',

2231

self.repo_name, cs_cache)

2231

self.repo_name, cs_cache)

2232

self.updated_on = last_change

2232

self.updated_on = last_change

2233

self.changeset_cache = cs_cache

2233

self.changeset_cache = cs_cache

2234

Session().add(self)

2234

Session().add(self)

2235

Session().commit()

2235

Session().commit()

2236

else:

2236

else:

2237

log.debug('Skipping update_commit_cache for repo:`%s` '

2237

log.debug('Skipping update_commit_cache for repo:`%s` '

2238

'commit already with latest changes', self.repo_name)

2238

'commit already with latest changes', self.repo_name)

2239

2240

@property

2240

@property

2241

def tip(self):

2241

def tip(self):

2242

return self.get_commit('tip')

2242

return self.get_commit('tip')

2243

2244

@property

2244

@property

2245

def author(self):

2245

def author(self):

2246

return self.tip.author

2246

return self.tip.author

2247

2248

@property

2248

@property

2249

def last_change(self):

2249

def last_change(self):

2250

return self.scm_instance().last_change

2250

return self.scm_instance().last_change

2251

2252

def get_comments(self, revisions=None):

2252

def get_comments(self, revisions=None):

2253

"""

2253

"""

2254

Returns comments for this repository grouped by revisions

2254

Returns comments for this repository grouped by revisions

2255

2256

:param revisions: filter query by revisions only

2256

:param revisions: filter query by revisions only

2257

"""

2257

"""

2258

cmts = ChangesetComment.query()\

2258

cmts = ChangesetComment.query()\

2259

.filter(ChangesetComment.repo == self)

2259

.filter(ChangesetComment.repo == self)

2260

if revisions:

2260

if revisions:

2261

cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

2261

cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

2262

grouped = collections.defaultdict(list)

2262

grouped = collections.defaultdict(list)

2263

for cmt in cmts.all():

2263

for cmt in cmts.all():

2264

grouped[cmt.revision].append(cmt)

2264

grouped[cmt.revision].append(cmt)

2265

return grouped

2265

return grouped

2266

2267

def statuses(self, revisions=None):

2267

def statuses(self, revisions=None):

2268

"""

2268

"""

2269

Returns statuses for this repository

2269

Returns statuses for this repository

2270

2271

:param revisions: list of revisions to get statuses for

2271

:param revisions: list of revisions to get statuses for

2272

"""

2272

"""

2273

statuses = ChangesetStatus.query()\

2273

statuses = ChangesetStatus.query()\

2274

.filter(ChangesetStatus.repo == self)\

2274

.filter(ChangesetStatus.repo == self)\

2275

.filter(ChangesetStatus.version == 0)

2275

.filter(ChangesetStatus.version == 0)

2276

2277

if revisions:

2277

if revisions:

2278

# Try doing the filtering in chunks to avoid hitting limits

2278

# Try doing the filtering in chunks to avoid hitting limits

2279

size = 500

2279

size = 500

2280

status_results = []

2280

status_results = []

2281

for chunk in xrange(0, len(revisions), size):

2281

for chunk in xrange(0, len(revisions), size):

2282

status_results += statuses.filter(

2282

status_results += statuses.filter(

2283

ChangesetStatus.revision.in_(

2283

ChangesetStatus.revision.in_(

2284

revisions[chunk: chunk+size])

2284

revisions[chunk: chunk+size])

2285

).all()

2285

).all()

2286

else:

2286

else:

2287

status_results = statuses.all()

2287

status_results = statuses.all()

2288

2289

grouped = {}

2289

grouped = {}

2290

2291

# maybe we have open new pullrequest without a status?

2291

# maybe we have open new pullrequest without a status?

2292

stat = ChangesetStatus.STATUS_UNDER_REVIEW

2292

stat = ChangesetStatus.STATUS_UNDER_REVIEW

2293

status_lbl = ChangesetStatus.get_status_lbl(stat)

2293

status_lbl = ChangesetStatus.get_status_lbl(stat)

2294

for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():

2294

for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():

2295

for rev in pr.revisions:

2295

for rev in pr.revisions:

2296

pr_id = pr.pull_request_id

2296

pr_id = pr.pull_request_id

2297

pr_repo = pr.target_repo.repo_name

2297

pr_repo = pr.target_repo.repo_name

2298

grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

2298

grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

2299

2300

for stat in status_results:

2300

for stat in status_results:

2301

pr_id = pr_repo = None

2301

pr_id = pr_repo = None

2302

if stat.pull_request:

2302

if stat.pull_request:

2303

pr_id = stat.pull_request.pull_request_id

2303

pr_id = stat.pull_request.pull_request_id

2304

pr_repo = stat.pull_request.target_repo.repo_name

2304

pr_repo = stat.pull_request.target_repo.repo_name

2305

grouped[stat.revision] = [str(stat.status), stat.status_lbl,

2305

grouped[stat.revision] = [str(stat.status), stat.status_lbl,

2306

pr_id, pr_repo]

2306

pr_id, pr_repo]

2307

return grouped

2307

return grouped

2308

2309

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

2309

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

2310

# SCM CACHE INSTANCE

2310

# SCM CACHE INSTANCE

2311

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

2311

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

2312

2313

def scm_instance(self, **kwargs):

2313

def scm_instance(self, **kwargs):

2314

import rhodecode

2314

import rhodecode

2315

2316

# Passing a config will not hit the cache currently only used

2316

# Passing a config will not hit the cache currently only used

2317

# for repo2dbmapper

2317

# for repo2dbmapper

2318

config = kwargs.pop('config', None)

2318

config = kwargs.pop('config', None)

2319

cache = kwargs.pop('cache', None)

2319

cache = kwargs.pop('cache', None)

2320

full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

2320

full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

2321

# if cache is NOT defined use default global, else we have a full

2321

# if cache is NOT defined use default global, else we have a full

2322

# control over cache behaviour

2322

# control over cache behaviour

2323

if cache is None and full_cache and not config:

2323

if cache is None and full_cache and not config:

2324

return self._get_instance_cached()

2324

return self._get_instance_cached()

2325

return self._get_instance(cache=bool(cache), config=config)

2325

return self._get_instance(cache=bool(cache), config=config)

2326

2327

def _get_instance_cached(self):

2327

def _get_instance_cached(self):

2328

@cache_region('long_term')

2328

@cache_region('long_term')

2329

def _get_repo(cache_key):

2329

def _get_repo(cache_key):

2330

return self._get_instance()

2330

return self._get_instance()

2331

2332

invalidator_context = CacheKey.repo_context_cache(

2332

invalidator_context = CacheKey.repo_context_cache(

2333

_get_repo, self.repo_name, None, thread_scoped=True)

2333

_get_repo, self.repo_name, None, thread_scoped=True)

2334

2335

with invalidator_context as context:

2335

with invalidator_context as context:

2336

context.invalidate()

2336

context.invalidate()

2337

repo = context.compute()

2337

repo = context.compute()

2338

2339

return repo

2339

return repo

2340

2341

def _get_instance(self, cache=True, config=None):

2341

def _get_instance(self, cache=True, config=None):

2342

config = config or self._config

2342

config = config or self._config

2343

custom_wire = {

2343

custom_wire = {

2344

'cache': cache # controls the vcs.remote cache

2344

'cache': cache # controls the vcs.remote cache

2345

}

2345

}

2346

repo = get_vcs_instance(

2346

repo = get_vcs_instance(

2347

repo_path=safe_str(self.repo_full_path),

2347

repo_path=safe_str(self.repo_full_path),

2348

config=config,

2348

config=config,

2349

with_wire=custom_wire,

2349

with_wire=custom_wire,

2350

create=False,

2350

create=False,

2351

_vcs_alias=self.repo_type)

2351

_vcs_alias=self.repo_type)

2352

2353

return repo

2353

return repo

2354

2355

def __json__(self):

2355

def __json__(self):

2356

return {'landing_rev': self.landing_rev}

2356

return {'landing_rev': self.landing_rev}

2357

2358

def get_dict(self):

2358

def get_dict(self):

2359

2360

# Since we transformed `repo_name` to a hybrid property, we need to

2360

# Since we transformed `repo_name` to a hybrid property, we need to

2361

# keep compatibility with the code which uses `repo_name` field.

2361

# keep compatibility with the code which uses `repo_name` field.

2362

2363

result = super(Repository, self).get_dict()

2363

result = super(Repository, self).get_dict()

2364

result['repo_name'] = result.pop('_repo_name', None)

2364

result['repo_name'] = result.pop('_repo_name', None)

2365

return result

2365

return result

2366

2367

2368

class RepoGroup(Base, BaseModel):

2368

class RepoGroup(Base, BaseModel):

2369

__tablename__ = 'groups'

2369

__tablename__ = 'groups'

2370

__table_args__ = (

2370

__table_args__ = (

2371

UniqueConstraint('group_name', 'group_parent_id'),

2371

UniqueConstraint('group_name', 'group_parent_id'),

2372

CheckConstraint('group_id != group_parent_id'),

2372

CheckConstraint('group_id != group_parent_id'),

2373

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

2373

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

2374

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

2374

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

2375

)

2375

)

2376

__mapper_args__ = {'order_by': 'group_name'}

2376

__mapper_args__ = {'order_by': 'group_name'}

2377

2378

CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups

2378

CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups

2379

2380

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

2380

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

2381

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

2381

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

2382

group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

2382

group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

2383

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

2383

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

2384

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

2384

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

2385

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

2385

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

2386

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

2386

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

2387

updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

2387

updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

2388

personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)

2388

personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)

2389

2390

repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

2390

repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

2391

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

2391

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

2392

parent_group = relationship('RepoGroup', remote_side=group_id)

2392

parent_group = relationship('RepoGroup', remote_side=group_id)

2393

user = relationship('User')

2393

user = relationship('User')

2394

integrations = relationship('Integration',

2394

integrations = relationship('Integration',

2395

cascade="all, delete, delete-orphan")

2395

cascade="all, delete, delete-orphan")

2396

2397

def __init__(self, group_name='', parent_group=None):

2397

def __init__(self, group_name='', parent_group=None):

2398

self.group_name = group_name

2398

self.group_name = group_name

2399

self.parent_group = parent_group

2399

self.parent_group = parent_group

2400

2401

def __unicode__(self):

2401

def __unicode__(self):

2402

return u"<%s('id:%s:%s')>" % (

2402

return u"<%s('id:%s:%s')>" % (

2403

self.__class__.__name__, self.group_id, self.group_name)

2403

self.__class__.__name__, self.group_id, self.group_name)

2404

2405

@hybrid_property

2405

@hybrid_property

2406

def description_safe(self):

2406

def description_safe(self):

2407

from rhodecode.lib import helpers as h

2407

from rhodecode.lib import helpers as h

2408

return h.escape(self.group_description)

2408

return h.escape(self.group_description)

2409

2410

@classmethod

2410

@classmethod

2411

def _generate_choice(cls, repo_group):

2411

def _generate_choice(cls, repo_group):

2412

from webhelpers.html import literal as _literal

2412

from webhelpers.html import literal as _literal

2413

_name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))

2413

_name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))

2414

return repo_group.group_id, _name(repo_group.full_path_splitted)

2414

return repo_group.group_id, _name(repo_group.full_path_splitted)

2415

2416

@classmethod

2416

@classmethod

2417

def groups_choices(cls, groups=None, show_empty_group=True):

2417

def groups_choices(cls, groups=None, show_empty_group=True):

2418

if not groups:

2418

if not groups:

2419

groups = cls.query().all()

2419

groups = cls.query().all()

2420

2421

repo_groups = []

2421

repo_groups = []

2422

if show_empty_group:

2422

if show_empty_group:

2423

repo_groups = [(-1, u'-- %s --' % _('No parent'))]

2423

repo_groups = [(-1, u'-- %s --' % _('No parent'))]

2424

2425

repo_groups.extend([cls._generate_choice(x) for x in groups])

2425

repo_groups.extend([cls._generate_choice(x) for x in groups])

2426

2427

repo_groups = sorted(

2427

repo_groups = sorted(

2428

repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])

2428

repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])

2429

return repo_groups

2429

return repo_groups

2430

2431

@classmethod

2431

@classmethod

2432

def url_sep(cls):

2432

def url_sep(cls):

2433

return URL_SEP

2433

return URL_SEP

2434

2435

@classmethod

2435

@classmethod

2436

def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

2436

def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

2437

if case_insensitive:

2437

if case_insensitive:

2438

gr = cls.query().filter(func.lower(cls.group_name)

2438

gr = cls.query().filter(func.lower(cls.group_name)

2439

== func.lower(group_name))

2439

== func.lower(group_name))

2440

else:

2440

else:

2441

gr = cls.query().filter(cls.group_name == group_name)

2441

gr = cls.query().filter(cls.group_name == group_name)

2442

if cache:

2442

if cache:

2443

name_key = _hash_key(group_name)

2443

name_key = _hash_key(group_name)

2444

gr = gr.options(

2444

gr = gr.options(

2445

FromCache("sql_cache_short", "get_group_%s" % name_key))

2445

FromCache("sql_cache_short", "get_group_%s" % name_key))

2446

return gr.scalar()

2446

return gr.scalar()

2447

2448

@classmethod

2448

@classmethod

2449

def get_user_personal_repo_group(cls, user_id):

2449

def get_user_personal_repo_group(cls, user_id):

2450

user = User.get(user_id)

2450

user = User.get(user_id)

2451

if user.username == User.DEFAULT_USER:

2451

if user.username == User.DEFAULT_USER:

2452

return None

2452

return None

2453

2454

return cls.query()\

2454

return cls.query()\

2455

.filter(cls.personal == true()) \

2455

.filter(cls.personal == true()) \

2456

.filter(cls.user == user).scalar()

2456

.filter(cls.user == user).scalar()

2457

2458

@classmethod

2458

@classmethod

2459

def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),

2459

def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),

2460

case_insensitive=True):

2460

case_insensitive=True):

2461

q = RepoGroup.query()

2461

q = RepoGroup.query()

2462

2463

if not isinstance(user_id, Optional):

2463

if not isinstance(user_id, Optional):

2464

q = q.filter(RepoGroup.user_id == user_id)

2464

q = q.filter(RepoGroup.user_id == user_id)

2465

2466

if not isinstance(group_id, Optional):

2466

if not isinstance(group_id, Optional):

2467

q = q.filter(RepoGroup.group_parent_id == group_id)

2467

q = q.filter(RepoGroup.group_parent_id == group_id)

2468

2469

if case_insensitive:

2469

if case_insensitive:

2470

q = q.order_by(func.lower(RepoGroup.group_name))

2470

q = q.order_by(func.lower(RepoGroup.group_name))

2471

else:

2471

else:

2472

q = q.order_by(RepoGroup.group_name)

2472

q = q.order_by(RepoGroup.group_name)

2473

return q.all()

2473

return q.all()

2474

2475

@property

2475

@property

2476

def parents(self):

2476

def parents(self):

2477

parents_recursion_limit = 10

2477

parents_recursion_limit = 10

2478

groups = []

2478

groups = []

2479

if self.parent_group is None:

2479

if self.parent_group is None:

2480

return groups

2480

return groups

2481

cur_gr = self.parent_group

2481

cur_gr = self.parent_group

2482

groups.insert(0, cur_gr)

2482

groups.insert(0, cur_gr)

2483

cnt = 0

2483

cnt = 0

2484

while 1:

2484

while 1:

2485

cnt += 1

2485

cnt += 1

2486

gr = getattr(cur_gr, 'parent_group', None)

2486

gr = getattr(cur_gr, 'parent_group', None)

2487

cur_gr = cur_gr.parent_group

2487

cur_gr = cur_gr.parent_group

2488

if gr is None:

2488

if gr is None:

2489

break

2489

break

2490

if cnt == parents_recursion_limit:

2490

if cnt == parents_recursion_limit:

2491

# this will prevent accidental infinit loops

2491

# this will prevent accidental infinit loops

2492

log.error(('more than %s parents found for group %s, stopping '

2492

log.error(('more than %s parents found for group %s, stopping '

2493

'recursive parent fetching' % (parents_recursion_limit, self)))

2493

'recursive parent fetching' % (parents_recursion_limit, self)))

2494

break

2494

break

2495

2496

groups.insert(0, gr)

2496

groups.insert(0, gr)

2497

return groups

2497

return groups

2498

2499

@property

2499

@property

2500

def last_db_change(self):

2500

def last_db_change(self):

2501

return self.updated_on

2501

return self.updated_on

2502

2503

@property

2503

@property

2504

def children(self):

2504

def children(self):

2505

return RepoGroup.query().filter(RepoGroup.parent_group == self)

2505

return RepoGroup.query().filter(RepoGroup.parent_group == self)

2506

2507

@property

2507

@property

2508

def name(self):

2508

def name(self):

2509

return self.group_name.split(RepoGroup.url_sep())[-1]

2509

return self.group_name.split(RepoGroup.url_sep())[-1]

2510

2511

@property

2511

@property

2512

def full_path(self):

2512

def full_path(self):

2513

return self.group_name

2513

return self.group_name

2514

2515

@property

2515

@property

2516

def full_path_splitted(self):

2516

def full_path_splitted(self):

2517

return self.group_name.split(RepoGroup.url_sep())

2517

return self.group_name.split(RepoGroup.url_sep())

2518

2519

@property

2519

@property

2520

def repositories(self):

2520

def repositories(self):

2521

return Repository.query()\

2521

return Repository.query()\

2522

.filter(Repository.group == self)\

2522

.filter(Repository.group == self)\

2523

.order_by(Repository.repo_name)

2523

.order_by(Repository.repo_name)

2524

2525

@property

2525

@property

2526

def repositories_recursive_count(self):

2526

def repositories_recursive_count(self):

2527

cnt = self.repositories.count()

2527

cnt = self.repositories.count()

2528

2529

def children_count(group):

2529

def children_count(group):

2530

cnt = 0

2530

cnt = 0

2531

for child in group.children:

2531

for child in group.children:

2532

cnt += child.repositories.count()

2532

cnt += child.repositories.count()

2533

cnt += children_count(child)

2533

cnt += children_count(child)

2534

return cnt

2534

return cnt

2535

2536

return cnt + children_count(self)

2536

return cnt + children_count(self)

2537

2538

def _recursive_objects(self, include_repos=True):

2538

def _recursive_objects(self, include_repos=True):

2539

all_ = []

2539

all_ = []

2540

2541

def _get_members(root_gr):

2541

def _get_members(root_gr):

2542

if include_repos:

2542

if include_repos:

2543

for r in root_gr.repositories:

2543

for r in root_gr.repositories:

2544

all_.append(r)

2544

all_.append(r)

2545

childs = root_gr.children.all()

2545

childs = root_gr.children.all()

2546

if childs:

2546

if childs:

2547

for gr in childs:

2547

for gr in childs:

2548

all_.append(gr)

2548

all_.append(gr)

2549

_get_members(gr)

2549

_get_members(gr)

2550

2551

_get_members(self)

2551

_get_members(self)

2552

return [self] + all_

2552

return [self] + all_

2553

2554

def recursive_groups_and_repos(self):

2554

def recursive_groups_and_repos(self):

2555

"""

2555

"""

2556

Recursive return all groups, with repositories in those groups

2556

Recursive return all groups, with repositories in those groups

2557

"""

2557

"""

2558

return self._recursive_objects()

2558

return self._recursive_objects()

2559

2560

def recursive_groups(self):

2560

def recursive_groups(self):

2561

"""

2561

"""

2562

Returns all children groups for this group including children of children

2562

Returns all children groups for this group including children of children

2563

"""

2563

"""

2564

return self._recursive_objects(include_repos=False)

2564

return self._recursive_objects(include_repos=False)

2565

2566

def get_new_name(self, group_name):

2566

def get_new_name(self, group_name):

2567

"""

2567

"""

2568

returns new full group name based on parent and new name

2568

returns new full group name based on parent and new name

2569

2570

:param group_name:

2570

:param group_name:

2571

"""

2571

"""

2572

path_prefix = (self.parent_group.full_path_splitted if

2572

path_prefix = (self.parent_group.full_path_splitted if

2573

self.parent_group else [])

2573

self.parent_group else [])

2574

return RepoGroup.url_sep().join(path_prefix + [group_name])

2574

return RepoGroup.url_sep().join(path_prefix + [group_name])

2575

2576

def permissions(self, with_admins=True, with_owner=True):

2576

def permissions(self, with_admins=True, with_owner=True):

2577

q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)

2577

q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)

2578

q = q.options(joinedload(UserRepoGroupToPerm.group),

2578

q = q.options(joinedload(UserRepoGroupToPerm.group),

2579

joinedload(UserRepoGroupToPerm.user),

2579

joinedload(UserRepoGroupToPerm.user),

2580

joinedload(UserRepoGroupToPerm.permission),)

2580

joinedload(UserRepoGroupToPerm.permission),)

2581

2582

# get owners and admins and permissions. We do a trick of re-writing

2582

# get owners and admins and permissions. We do a trick of re-writing

2583

# objects from sqlalchemy to named-tuples due to sqlalchemy session

2583

# objects from sqlalchemy to named-tuples due to sqlalchemy session

2584

# has a global reference and changing one object propagates to all

2584

# has a global reference and changing one object propagates to all

2585

# others. This means if admin is also an owner admin_row that change

2585

# others. This means if admin is also an owner admin_row that change

2586

# would propagate to both objects

2586

# would propagate to both objects

2587

perm_rows = []

2587

perm_rows = []

2588

for _usr in q.all():

2588

for _usr in q.all():

2589

usr = AttributeDict(_usr.user.get_dict())

2589

usr = AttributeDict(_usr.user.get_dict())

2590

usr.permission = _usr.permission.permission_name

2590

usr.permission = _usr.permission.permission_name

2591

perm_rows.append(usr)

2591

perm_rows.append(usr)

2592

2593

# filter the perm rows by 'default' first and then sort them by

2593

# filter the perm rows by 'default' first and then sort them by

2594

# admin,write,read,none permissions sorted again alphabetically in

2594

# admin,write,read,none permissions sorted again alphabetically in

2595

# each group

2595

# each group

2596

perm_rows = sorted(perm_rows, key=display_user_sort)

2596

perm_rows = sorted(perm_rows, key=display_user_sort)

2597

2598

_admin_perm = 'group.admin'

2598

_admin_perm = 'group.admin'

2599

owner_row = []

2599

owner_row = []

2600

if with_owner:

2600

if with_owner:

2601

usr = AttributeDict(self.user.get_dict())

2601

usr = AttributeDict(self.user.get_dict())

2602

usr.owner_row = True

2602

usr.owner_row = True

2603

usr.permission = _admin_perm

2603

usr.permission = _admin_perm

2604

owner_row.append(usr)

2604

owner_row.append(usr)

2605

2606

super_admin_rows = []

2606

super_admin_rows = []

2607

if with_admins:

2607

if with_admins:

2608

for usr in User.get_all_super_admins():

2608

for usr in User.get_all_super_admins():

2609

# if this admin is also owner, don't double the record

2609

# if this admin is also owner, don't double the record

2610

if usr.user_id == owner_row[0].user_id:

2610

if usr.user_id == owner_row[0].user_id:

2611

owner_row[0].admin_row = True

2611

owner_row[0].admin_row = True

2612

else:

2612

else:

2613

usr = AttributeDict(usr.get_dict())

2613

usr = AttributeDict(usr.get_dict())

2614

usr.admin_row = True

2614

usr.admin_row = True

2615

usr.permission = _admin_perm

2615

usr.permission = _admin_perm

2616

super_admin_rows.append(usr)

2616

super_admin_rows.append(usr)

2617

2618

return super_admin_rows + owner_row + perm_rows

2618

return super_admin_rows + owner_row + perm_rows

2619

2620

def permission_user_groups(self):

2620

def permission_user_groups(self):

2621

q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)

2621

q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)

2622

q = q.options(joinedload(UserGroupRepoGroupToPerm.group),

2622

q = q.options(joinedload(UserGroupRepoGroupToPerm.group),

2623

joinedload(UserGroupRepoGroupToPerm.users_group),

2623

joinedload(UserGroupRepoGroupToPerm.users_group),

2624

joinedload(UserGroupRepoGroupToPerm.permission),)

2624

joinedload(UserGroupRepoGroupToPerm.permission),)

2625

2626

perm_rows = []

2626

perm_rows = []

2627

for _user_group in q.all():

2627

for _user_group in q.all():

2628

usr = AttributeDict(_user_group.users_group.get_dict())

2628

usr = AttributeDict(_user_group.users_group.get_dict())

2629

usr.permission = _user_group.permission.permission_name

2629

usr.permission = _user_group.permission.permission_name

2630

perm_rows.append(usr)

2630

perm_rows.append(usr)

2631

2632

perm_rows = sorted(perm_rows, key=display_user_group_sort)

2632

perm_rows = sorted(perm_rows, key=display_user_group_sort)

2633

return perm_rows

2633

return perm_rows

2634

2635

def get_api_data(self):

2635

def get_api_data(self):

2636

"""

2636

"""

2637

Common function for generating api data

2637

Common function for generating api data

2638

2639

"""

2639

"""

2640

group = self

2640

group = self

2641

data = {

2641

data = {

2642

'group_id': group.group_id,

2642

'group_id': group.group_id,

2643

'group_name': group.group_name,

2643

'group_name': group.group_name,

2644

'group_description': group.description_safe,

2644

'group_description': group.description_safe,

2645

'parent_group': group.parent_group.group_name if group.parent_group else None,

2645

'parent_group': group.parent_group.group_name if group.parent_group else None,

2646

'repositories': [x.repo_name for x in group.repositories],

2646

'repositories': [x.repo_name for x in group.repositories],

2647

'owner': group.user.username,

2647

'owner': group.user.username,

2648

}

2648

}

2649

return data

2649

return data

2650

2651

2652

class Permission(Base, BaseModel):

2652

class Permission(Base, BaseModel):

2653

__tablename__ = 'permissions'

2653

__tablename__ = 'permissions'

2654

__table_args__ = (

2654

__table_args__ = (

2655

Index('p_perm_name_idx', 'permission_name'),

2655

Index('p_perm_name_idx', 'permission_name'),

2656

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2656

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2657

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2657

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

2658

)

2658

)

2659

PERMS = [

2659

PERMS = [

2660

('hg.admin', _('RhodeCode Super Administrator')),

2660

('hg.admin', _('RhodeCode Super Administrator')),

2661

2662

('repository.none', _('Repository no access')),

2662

('repository.none', _('Repository no access')),

2663

('repository.read', _('Repository read access')),

2663

('repository.read', _('Repository read access')),

2664

('repository.write', _('Repository write access')),

2664

('repository.write', _('Repository write access')),

2665

('repository.admin', _('Repository admin access')),

2665

('repository.admin', _('Repository admin access')),

2666

2667

('group.none', _('Repository group no access')),

2667

('group.none', _('Repository group no access')),

2668

('group.read', _('Repository group read access')),

2668

('group.read', _('Repository group read access')),

2669

('group.write', _('Repository group write access')),

2669

('group.write', _('Repository group write access')),

2670

('group.admin', _('Repository group admin access')),

2670

('group.admin', _('Repository group admin access')),

2671

2672

('usergroup.none', _('User group no access')),

2672

('usergroup.none', _('User group no access')),

2673

('usergroup.read', _('User group read access')),

2673

('usergroup.read', _('User group read access')),

2674

('usergroup.write', _('User group write access')),

2674

('usergroup.write', _('User group write access')),

2675

('usergroup.admin', _('User group admin access')),

2675

('usergroup.admin', _('User group admin access')),

2676

2677

('hg.repogroup.create.false', _('Repository Group creation disabled')),

2677

('hg.repogroup.create.false', _('Repository Group creation disabled')),

2678

('hg.repogroup.create.true', _('Repository Group creation enabled')),

2678

('hg.repogroup.create.true', _('Repository Group creation enabled')),

2679

2680

('hg.usergroup.create.false', _('User Group creation disabled')),

2680

('hg.usergroup.create.false', _('User Group creation disabled')),

2681

('hg.usergroup.create.true', _('User Group creation enabled')),

2681

('hg.usergroup.create.true', _('User Group creation enabled')),

2682

2683

('hg.create.none', _('Repository creation disabled')),

2683

('hg.create.none', _('Repository creation disabled')),

2684

('hg.create.repository', _('Repository creation enabled')),

2684

('hg.create.repository', _('Repository creation enabled')),

2685

('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),

2685

('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),

2686

('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),

2686

('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),

2687

2688

('hg.fork.none', _('Repository forking disabled')),

2688

('hg.fork.none', _('Repository forking disabled')),

2689

('hg.fork.repository', _('Repository forking enabled')),

2689

('hg.fork.repository', _('Repository forking enabled')),

2690

2691

('hg.register.none', _('Registration disabled')),

2691

('hg.register.none', _('Registration disabled')),

2692

('hg.register.manual_activate', _('User Registration with manual account activation')),

2692

('hg.register.manual_activate', _('User Registration with manual account activation')),

2693

('hg.register.auto_activate', _('User Registration with automatic account activation')),

2693

('hg.register.auto_activate', _('User Registration with automatic account activation')),

2694

2695

('hg.password_reset.enabled', _('Password reset enabled')),

2695

('hg.password_reset.enabled', _('Password reset enabled')),

2696

('hg.password_reset.hidden', _('Password reset hidden')),

2696

('hg.password_reset.hidden', _('Password reset hidden')),

2697

('hg.password_reset.disabled', _('Password reset disabled')),

2697

('hg.password_reset.disabled', _('Password reset disabled')),

2698

2699

('hg.extern_activate.manual', _('Manual activation of external account')),

2699

('hg.extern_activate.manual', _('Manual activation of external account')),

2700

('hg.extern_activate.auto', _('Automatic activation of external account')),

2700

('hg.extern_activate.auto', _('Automatic activation of external account')),

2701

2702

('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),

2702

('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),

2703

('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),

2703

('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),

2704

]

2704

]

2705

2706

# definition of system default permissions for DEFAULT user

2706

# definition of system default permissions for DEFAULT user

2707

DEFAULT_USER_PERMISSIONS = [

2707

DEFAULT_USER_PERMISSIONS = [

2708

'repository.read',

2708

'repository.read',

2709

'group.read',

2709

'group.read',

2710

'usergroup.read',

2710

'usergroup.read',

2711

'hg.create.repository',

2711

'hg.create.repository',

2712

'hg.repogroup.create.false',

2712

'hg.repogroup.create.false',

2713

'hg.usergroup.create.false',

2713

'hg.usergroup.create.false',

2714

'hg.create.write_on_repogroup.true',

2714

'hg.create.write_on_repogroup.true',

2715

'hg.fork.repository',

2715

'hg.fork.repository',

2716

'hg.register.manual_activate',

2716

'hg.register.manual_activate',

2717

'hg.password_reset.enabled',

2717

'hg.password_reset.enabled',

2718

'hg.extern_activate.auto',

2718

'hg.extern_activate.auto',

2719

'hg.inherit_default_perms.true',

2719

'hg.inherit_default_perms.true',

2720

]

2720

]

2721

2722

# defines which permissions are more important higher the more important

2722

# defines which permissions are more important higher the more important

2723

# Weight defines which permissions are more important.

2723

# Weight defines which permissions are more important.

2724

# The higher number the more important.

2724

# The higher number the more important.

2725

PERM_WEIGHTS = {

2725

PERM_WEIGHTS = {

2726

'repository.none': 0,

2726

'repository.none': 0,

2727

'repository.read': 1,

2727

'repository.read': 1,

2728

'repository.write': 3,

2728

'repository.write': 3,

2729

'repository.admin': 4,

2729

'repository.admin': 4,

2730

2731

'group.none': 0,

2731

'group.none': 0,

2732

'group.read': 1,

2732

'group.read': 1,

2733

'group.write': 3,

2733

'group.write': 3,

2734

'group.admin': 4,

2734

'group.admin': 4,

2735

2736

'usergroup.none': 0,

2736

'usergroup.none': 0,

2737

'usergroup.read': 1,

2737

'usergroup.read': 1,

2738

'usergroup.write': 3,

2738

'usergroup.write': 3,

2739

'usergroup.admin': 4,

2739

'usergroup.admin': 4,

2740

2741

'hg.repogroup.create.false': 0,

2741

'hg.repogroup.create.false': 0,

2742

'hg.repogroup.create.true': 1,

2742

'hg.repogroup.create.true': 1,

2743

2744

'hg.usergroup.create.false': 0,

2744

'hg.usergroup.create.false': 0,

2745

'hg.usergroup.create.true': 1,

2745

'hg.usergroup.create.true': 1,

2746

2747

'hg.fork.none': 0,

2747

'hg.fork.none': 0,

2748

'hg.fork.repository': 1,

2748

'hg.fork.repository': 1,

2749

'hg.create.none': 0,

2749

'hg.create.none': 0,

2750

'hg.create.repository': 1

2750

'hg.create.repository': 1

2751

}

2751

}

2752

2753

permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2753

permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2754

permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)

2754

permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)

2755

permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)

2755

permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)

2756

2757

def __unicode__(self):

2757

def __unicode__(self):

2758

return u"<%s('%s:%s')>" % (

2758

return u"<%s('%s:%s')>" % (

2759

self.__class__.__name__, self.permission_id, self.permission_name

2759

self.__class__.__name__, self.permission_id, self.permission_name

2760

)

2760

)

2761

2762

@classmethod

2762

@classmethod

2763

def get_by_key(cls, key):

2763

def get_by_key(cls, key):

2764

return cls.query().filter(cls.permission_name == key).scalar()

2764

return cls.query().filter(cls.permission_name == key).scalar()

2765

2766

@classmethod

2766

@classmethod

2767

def get_default_repo_perms(cls, user_id, repo_id=None):

2767

def get_default_repo_perms(cls, user_id, repo_id=None):

2768

q = Session().query(UserRepoToPerm, Repository, Permission)\

2768

q = Session().query(UserRepoToPerm, Repository, Permission)\

2769

.join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\

2769

.join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\

2770

.join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

2770

.join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

2771

.filter(UserRepoToPerm.user_id == user_id)

2771

.filter(UserRepoToPerm.user_id == user_id)

2772

if repo_id:

2772

if repo_id:

2773

q = q.filter(UserRepoToPerm.repository_id == repo_id)

2773

q = q.filter(UserRepoToPerm.repository_id == repo_id)

2774

return q.all()

2774

return q.all()

2775

2776

@classmethod

2776

@classmethod

2777

def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):

2777

def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):

2778

q = Session().query(UserGroupRepoToPerm, Repository, Permission)\

2778

q = Session().query(UserGroupRepoToPerm, Repository, Permission)\

2779

.join(

2779

.join(

2780

Permission,

2780

Permission,

2781

UserGroupRepoToPerm.permission_id == Permission.permission_id)\

2781

UserGroupRepoToPerm.permission_id == Permission.permission_id)\

2782

.join(

2782

.join(

2783

Repository,

2783

Repository,

2784

UserGroupRepoToPerm.repository_id == Repository.repo_id)\

2784

UserGroupRepoToPerm.repository_id == Repository.repo_id)\

2785

.join(

2785

.join(

2786

UserGroup,

2786

UserGroup,

2787

UserGroupRepoToPerm.users_group_id ==

2787

UserGroupRepoToPerm.users_group_id ==

2788

UserGroup.users_group_id)\

2788

UserGroup.users_group_id)\

2789

.join(

2789

.join(

2790

UserGroupMember,

2790

UserGroupMember,

2791

UserGroupRepoToPerm.users_group_id ==

2791

UserGroupRepoToPerm.users_group_id ==

2792

UserGroupMember.users_group_id)\

2792

UserGroupMember.users_group_id)\

2793

.filter(

2793

.filter(

2794

UserGroupMember.user_id == user_id,

2794

UserGroupMember.user_id == user_id,

2795

UserGroup.users_group_active == true())

2795

UserGroup.users_group_active == true())

2796

if repo_id:

2796

if repo_id:

2797

q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)

2797

q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)

2798

return q.all()

2798

return q.all()

2799

2800

@classmethod

2800

@classmethod

2801

def get_default_group_perms(cls, user_id, repo_group_id=None):

2801

def get_default_group_perms(cls, user_id, repo_group_id=None):

2802

q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\

2802

q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\

2803

.join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\

2803

.join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\

2804

.join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

2804

.join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

2805

.filter(UserRepoGroupToPerm.user_id == user_id)

2805

.filter(UserRepoGroupToPerm.user_id == user_id)

2806

if repo_group_id:

2806

if repo_group_id:

2807

q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)

2807

q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)

2808

return q.all()

2808

return q.all()

2809

2810

@classmethod

2810

@classmethod

2811

def get_default_group_perms_from_user_group(

2811

def get_default_group_perms_from_user_group(

2812

cls, user_id, repo_group_id=None):

2812

cls, user_id, repo_group_id=None):

2813

q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\

2813

q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\

2814

.join(

2814

.join(

2815

Permission,

2815

Permission,

2816

UserGroupRepoGroupToPerm.permission_id ==

2816

UserGroupRepoGroupToPerm.permission_id ==

2817

Permission.permission_id)\

2817

Permission.permission_id)\

2818

.join(

2818

.join(

2819

RepoGroup,

2819

RepoGroup,

2820

UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\

2820

UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\

2821

.join(

2821

.join(

2822

UserGroup,

2822

UserGroup,

2823

UserGroupRepoGroupToPerm.users_group_id ==

2823

UserGroupRepoGroupToPerm.users_group_id ==

2824

UserGroup.users_group_id)\

2824

UserGroup.users_group_id)\

2825

.join(

2825

.join(

2826

UserGroupMember,

2826

UserGroupMember,

2827

UserGroupRepoGroupToPerm.users_group_id ==

2827

UserGroupRepoGroupToPerm.users_group_id ==

2828

UserGroupMember.users_group_id)\

2828

UserGroupMember.users_group_id)\

2829

.filter(

2829

.filter(

2830

UserGroupMember.user_id == user_id,

2830

UserGroupMember.user_id == user_id,

2831

UserGroup.users_group_active == true())

2831

UserGroup.users_group_active == true())

2832

if repo_group_id:

2832

if repo_group_id:

2833

q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)

2833

q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)

2834

return q.all()

2834

return q.all()

2835

2836

@classmethod

2836

@classmethod

2837

def get_default_user_group_perms(cls, user_id, user_group_id=None):

2837

def get_default_user_group_perms(cls, user_id, user_group_id=None):

2838

q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\

2838

q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\

2839

.join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\

2839

.join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\

2840

.join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\

2840

.join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\

2841

.filter(UserUserGroupToPerm.user_id == user_id)

2841

.filter(UserUserGroupToPerm.user_id == user_id)

2842

if user_group_id:

2842

if user_group_id:

2843

q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)

2843

q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)

2844

return q.all()

2844

return q.all()

2845

2846

@classmethod

2846

@classmethod

2847

def get_default_user_group_perms_from_user_group(

2847

def get_default_user_group_perms_from_user_group(

2848

cls, user_id, user_group_id=None):

2848

cls, user_id, user_group_id=None):

2849

TargetUserGroup = aliased(UserGroup, name='target_user_group')

2849

TargetUserGroup = aliased(UserGroup, name='target_user_group')

2850

q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\

2850

q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\

2851

.join(

2851

.join(

2852

Permission,

2852

Permission,

2853

UserGroupUserGroupToPerm.permission_id ==

2853

UserGroupUserGroupToPerm.permission_id ==

2854

Permission.permission_id)\

2854

Permission.permission_id)\

2855

.join(

2855

.join(

2856

TargetUserGroup,

2856

TargetUserGroup,

2857

UserGroupUserGroupToPerm.target_user_group_id ==

2857

UserGroupUserGroupToPerm.target_user_group_id ==

2858

TargetUserGroup.users_group_id)\

2858

TargetUserGroup.users_group_id)\

2859

.join(

2859

.join(

2860

UserGroup,

2860

UserGroup,

2861

UserGroupUserGroupToPerm.user_group_id ==

2861

UserGroupUserGroupToPerm.user_group_id ==

2862

UserGroup.users_group_id)\

2862

UserGroup.users_group_id)\

2863

.join(

2863

.join(

2864

UserGroupMember,

2864

UserGroupMember,

2865

UserGroupUserGroupToPerm.user_group_id ==

2865

UserGroupUserGroupToPerm.user_group_id ==

2866

UserGroupMember.users_group_id)\

2866

UserGroupMember.users_group_id)\

2867

.filter(

2867

.filter(

2868

UserGroupMember.user_id == user_id,

2868

UserGroupMember.user_id == user_id,

2869

UserGroup.users_group_active == true())

2869

UserGroup.users_group_active == true())

2870

if user_group_id:

2870

if user_group_id:

2871

q = q.filter(

2871

q = q.filter(

2872

UserGroupUserGroupToPerm.user_group_id == user_group_id)

2872

UserGroupUserGroupToPerm.user_group_id == user_group_id)

2873

2874

return q.all()

2874

return q.all()

2875

2876

2877

class UserRepoToPerm(Base, BaseModel):

2877

class UserRepoToPerm(Base, BaseModel):

2878

__tablename__ = 'repo_to_perm'

2878

__tablename__ = 'repo_to_perm'

2879

__table_args__ = (

2879

__table_args__ = (

2880

UniqueConstraint('user_id', 'repository_id', 'permission_id'),

2880

UniqueConstraint('user_id', 'repository_id', 'permission_id'),

2881

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2881

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2882

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2882

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2883

)

2883

)

2884

repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2884

repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2885

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2885

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2886

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2886

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2887

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2887

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2888

2889

user = relationship('User')

2889

user = relationship('User')

2890

repository = relationship('Repository')

2890

repository = relationship('Repository')

2891

permission = relationship('Permission')

2891

permission = relationship('Permission')

2892

2893

@classmethod

2893

@classmethod

2894

def create(cls, user, repository, permission):

2894

def create(cls, user, repository, permission):

2895

n = cls()

2895

n = cls()

2896

n.user = user

2896

n.user = user

2897

n.repository = repository

2897

n.repository = repository

2898

n.permission = permission

2898

n.permission = permission

2899

Session().add(n)

2899

Session().add(n)

2900

return n

2900

return n

2901

2902

def __unicode__(self):

2902

def __unicode__(self):

2903

return u'<%s => %s >' % (self.user, self.repository)

2903

return u'<%s => %s >' % (self.user, self.repository)

2904

2905

2906

class UserUserGroupToPerm(Base, BaseModel):

2906

class UserUserGroupToPerm(Base, BaseModel):

2907

__tablename__ = 'user_user_group_to_perm'

2907

__tablename__ = 'user_user_group_to_perm'

2908

__table_args__ = (

2908

__table_args__ = (

2909

UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

2909

UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

2910

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2910

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2911

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2911

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2912

)

2912

)

2913

user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2913

user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2914

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2914

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2915

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2915

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2916

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2916

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2917

2918

user = relationship('User')

2918

user = relationship('User')

2919

user_group = relationship('UserGroup')

2919

user_group = relationship('UserGroup')

2920

permission = relationship('Permission')

2920

permission = relationship('Permission')

2921

2922

@classmethod

2922

@classmethod

2923

def create(cls, user, user_group, permission):

2923

def create(cls, user, user_group, permission):

2924

n = cls()

2924

n = cls()

2925

n.user = user

2925

n.user = user

2926

n.user_group = user_group

2926

n.user_group = user_group

2927

n.permission = permission

2927

n.permission = permission

2928

Session().add(n)

2928

Session().add(n)

2929

return n

2929

return n

2930

2931

def __unicode__(self):

2931

def __unicode__(self):

2932

return u'<%s => %s >' % (self.user, self.user_group)

2932

return u'<%s => %s >' % (self.user, self.user_group)

2933

2934

2935

class UserToPerm(Base, BaseModel):

2935

class UserToPerm(Base, BaseModel):

2936

__tablename__ = 'user_to_perm'

2936

__tablename__ = 'user_to_perm'

2937

__table_args__ = (

2937

__table_args__ = (

2938

UniqueConstraint('user_id', 'permission_id'),

2938

UniqueConstraint('user_id', 'permission_id'),

2939

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2939

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2940

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2940

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2941

)

2941

)

2942

user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2942

user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2943

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2943

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

2944

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2944

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2945

2946

user = relationship('User')

2946

user = relationship('User')

2947

permission = relationship('Permission', lazy='joined')

2947

permission = relationship('Permission', lazy='joined')

2948

2949

def __unicode__(self):

2949

def __unicode__(self):

2950

return u'<%s => %s >' % (self.user, self.permission)

2950

return u'<%s => %s >' % (self.user, self.permission)

2951

2952

2953

class UserGroupRepoToPerm(Base, BaseModel):

2953

class UserGroupRepoToPerm(Base, BaseModel):

2954

__tablename__ = 'users_group_repo_to_perm'

2954

__tablename__ = 'users_group_repo_to_perm'

2955

__table_args__ = (

2955

__table_args__ = (

2956

UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

2956

UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

2957

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2957

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2958

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2958

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2959

)

2959

)

2960

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2960

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2961

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2961

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2962

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2962

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2963

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2963

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

2964

2965

users_group = relationship('UserGroup')

2965

users_group = relationship('UserGroup')

2966

permission = relationship('Permission')

2966

permission = relationship('Permission')

2967

repository = relationship('Repository')

2967

repository = relationship('Repository')

2968

2969

@classmethod

2969

@classmethod

2970

def create(cls, users_group, repository, permission):

2970

def create(cls, users_group, repository, permission):

2971

n = cls()

2971

n = cls()

2972

n.users_group = users_group

2972

n.users_group = users_group

2973

n.repository = repository

2973

n.repository = repository

2974

n.permission = permission

2974

n.permission = permission

2975

Session().add(n)

2975

Session().add(n)

2976

return n

2976

return n

2977

2978

def __unicode__(self):

2978

def __unicode__(self):

2979

return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)

2979

return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)

2980

2981

2982

class UserGroupUserGroupToPerm(Base, BaseModel):

2982

class UserGroupUserGroupToPerm(Base, BaseModel):

2983

__tablename__ = 'user_group_user_group_to_perm'

2983

__tablename__ = 'user_group_user_group_to_perm'

2984

__table_args__ = (

2984

__table_args__ = (

2985

UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

2985

UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

2986

CheckConstraint('target_user_group_id != user_group_id'),

2986

CheckConstraint('target_user_group_id != user_group_id'),

2987

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2987

{'extend_existing': True, 'mysql_engine': 'InnoDB',

2988

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2988

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

2989

)

2989

)

2990

user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2990

user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

2991

target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2991

target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2992

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2992

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

2993

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2993

user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

2994

2995

target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

2995

target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

2996

user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')

2996

user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')

2997

permission = relationship('Permission')

2997

permission = relationship('Permission')

2998

2999

@classmethod

2999

@classmethod

3000

def create(cls, target_user_group, user_group, permission):

3000

def create(cls, target_user_group, user_group, permission):

3001

n = cls()

3001

n = cls()

3002

n.target_user_group = target_user_group

3002

n.target_user_group = target_user_group

3003

n.user_group = user_group

3003

n.user_group = user_group

3004

n.permission = permission

3004

n.permission = permission

3005

Session().add(n)

3005

Session().add(n)

3006

return n

3006

return n

3007

3008

def __unicode__(self):

3008

def __unicode__(self):

3009

return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

3009

return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

3010

3011

3012

class UserGroupToPerm(Base, BaseModel):

3012

class UserGroupToPerm(Base, BaseModel):

3013

__tablename__ = 'users_group_to_perm'

3013

__tablename__ = 'users_group_to_perm'

3014

__table_args__ = (

3014

__table_args__ = (

3015

UniqueConstraint('users_group_id', 'permission_id',),

3015

UniqueConstraint('users_group_id', 'permission_id',),

3016

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3016

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3017

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3017

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3018

)

3018

)

3019

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3019

users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3020

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

3020

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

3021

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3021

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3022

3023

users_group = relationship('UserGroup')

3023

users_group = relationship('UserGroup')

3024

permission = relationship('Permission')

3024

permission = relationship('Permission')

3025

3026

3027

class UserRepoGroupToPerm(Base, BaseModel):

3027

class UserRepoGroupToPerm(Base, BaseModel):

3028

__tablename__ = 'user_repo_group_to_perm'

3028

__tablename__ = 'user_repo_group_to_perm'

3029

__table_args__ = (

3029

__table_args__ = (

3030

UniqueConstraint('user_id', 'group_id', 'permission_id'),

3030

UniqueConstraint('user_id', 'group_id', 'permission_id'),

3031

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3031

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3032

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3032

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3033

)

3033

)

3034

3035

group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3035

group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3036

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

3036

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

3037

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

3037

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

3038

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3038

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3039

3040

user = relationship('User')

3040

user = relationship('User')

3041

group = relationship('RepoGroup')

3041

group = relationship('RepoGroup')

3042

permission = relationship('Permission')

3042

permission = relationship('Permission')

3043

3044

@classmethod

3044

@classmethod

3045

def create(cls, user, repository_group, permission):

3045

def create(cls, user, repository_group, permission):

3046

n = cls()

3046

n = cls()

3047

n.user = user

3047

n.user = user

3048

n.group = repository_group

3048

n.group = repository_group

3049

n.permission = permission

3049

n.permission = permission

3050

Session().add(n)

3050

Session().add(n)

3051

return n

3051

return n

3052

3053

3054

class UserGroupRepoGroupToPerm(Base, BaseModel):

3054

class UserGroupRepoGroupToPerm(Base, BaseModel):

3055

__tablename__ = 'users_group_repo_group_to_perm'

3055

__tablename__ = 'users_group_repo_group_to_perm'

3056

__table_args__ = (

3056

__table_args__ = (

3057

UniqueConstraint('users_group_id', 'group_id'),

3057

UniqueConstraint('users_group_id', 'group_id'),

3058

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3058

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3059

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3059

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3060

)

3060

)

3061

3062

users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3062

users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3063

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

3063

users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

3064

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

3064

group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

3065

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3065

permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

3066

3067

users_group = relationship('UserGroup')

3067

users_group = relationship('UserGroup')

3068

permission = relationship('Permission')

3068

permission = relationship('Permission')

3069

group = relationship('RepoGroup')

3069

group = relationship('RepoGroup')

3070

3071

@classmethod

3071

@classmethod

3072

def create(cls, user_group, repository_group, permission):

3072

def create(cls, user_group, repository_group, permission):

3073

n = cls()

3073

n = cls()

3074

n.users_group = user_group

3074

n.users_group = user_group

3075

n.group = repository_group

3075

n.group = repository_group

3076

n.permission = permission

3076

n.permission = permission

3077

Session().add(n)

3077

Session().add(n)

3078

return n

3078

return n

3079

3080

def __unicode__(self):

3080

def __unicode__(self):

3081

return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)

3081

return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)

3082

3083

3084

class Statistics(Base, BaseModel):

3084

class Statistics(Base, BaseModel):

3085

__tablename__ = 'statistics'

3085

__tablename__ = 'statistics'

3086

__table_args__ = (

3086

__table_args__ = (

3087

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3087

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3088

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3088

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3089

)

3089

)

3090

stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3090

stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3091

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

3091

repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

3092

stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

3092

stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

3093

commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

3093

commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

3094

commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

3094

commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

3095

languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

3095

languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

3096

3097

repository = relationship('Repository', single_parent=True)

3097

repository = relationship('Repository', single_parent=True)

3098

3099

3100

class UserFollowing(Base, BaseModel):

3100

class UserFollowing(Base, BaseModel):

3101

__tablename__ = 'user_followings'

3101

__tablename__ = 'user_followings'

3102

__table_args__ = (

3102

__table_args__ = (

3103

UniqueConstraint('user_id', 'follows_repository_id'),

3103

UniqueConstraint('user_id', 'follows_repository_id'),

3104

UniqueConstraint('user_id', 'follows_user_id'),

3104

UniqueConstraint('user_id', 'follows_user_id'),

3105

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3105

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3106

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3106

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3107

)

3107

)

3108

3109

user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3109

user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3110

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

3110

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

3111

follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

3111

follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

3112

follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

3112

follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

3113

follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

3113

follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

3114

3115

user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

3115

user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

3116

3117

follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

3117

follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

3118

follows_repository = relationship('Repository', order_by='Repository.repo_name')

3118

follows_repository = relationship('Repository', order_by='Repository.repo_name')

3119

3120

@classmethod

3120

@classmethod

3121

def get_repo_followers(cls, repo_id):

3121

def get_repo_followers(cls, repo_id):

3122

return cls.query().filter(cls.follows_repo_id == repo_id)

3122

return cls.query().filter(cls.follows_repo_id == repo_id)

3123

3124

3125

class CacheKey(Base, BaseModel):

3125

class CacheKey(Base, BaseModel):

3126

__tablename__ = 'cache_invalidation'

3126

__tablename__ = 'cache_invalidation'

3127

__table_args__ = (

3127

__table_args__ = (

3128

UniqueConstraint('cache_key'),

3128

UniqueConstraint('cache_key'),

3129

Index('key_idx', 'cache_key'),

3129

Index('key_idx', 'cache_key'),

3130

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3130

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3131

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3131

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3132

)

3132

)

3133

CACHE_TYPE_ATOM = 'ATOM'

3133

CACHE_TYPE_ATOM = 'ATOM'

3134

CACHE_TYPE_RSS = 'RSS'

3134

CACHE_TYPE_RSS = 'RSS'

3135

CACHE_TYPE_README = 'README'

3135

CACHE_TYPE_README = 'README'

3136

3137

cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3137

cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

3138

cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)

3138

cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)

3139

cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)

3139

cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)

3140

cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

3140

cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

3141

3142

def __init__(self, cache_key, cache_args=''):

3142

def __init__(self, cache_key, cache_args=''):

3143

self.cache_key = cache_key

3143

self.cache_key = cache_key

3144

self.cache_args = cache_args

3144

self.cache_args = cache_args

3145

self.cache_active = False

3145

self.cache_active = False

3146

3147

def __unicode__(self):

3147

def __unicode__(self):

3148

return u"<%s('%s:%s[%s]')>" % (

3148

return u"<%s('%s:%s[%s]')>" % (

3149

self.__class__.__name__,

3149

self.__class__.__name__,

3150

self.cache_id, self.cache_key, self.cache_active)

3150

self.cache_id, self.cache_key, self.cache_active)

3151

3152

def _cache_key_partition(self):

3152

def _cache_key_partition(self):

3153

prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

3153

prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

3154

return prefix, repo_name, suffix

3154

return prefix, repo_name, suffix

3155

3156

def get_prefix(self):

3156

def get_prefix(self):

3157

"""

3157

"""

3158

Try to extract prefix from existing cache key. The key could consist

3158

Try to extract prefix from existing cache key. The key could consist

3159

of prefix, repo_name, suffix

3159

of prefix, repo_name, suffix

3160

"""

3160

"""

3161

# this returns prefix, repo_name, suffix

3161

# this returns prefix, repo_name, suffix

3162

return self._cache_key_partition()[0]

3162

return self._cache_key_partition()[0]

3163

3164

def get_suffix(self):

3164

def get_suffix(self):

3165

"""

3165

"""

3166

get suffix that might have been used in _get_cache_key to

3166

get suffix that might have been used in _get_cache_key to

3167

generate self.cache_key. Only used for informational purposes

3167

generate self.cache_key. Only used for informational purposes

3168

in repo_edit.mako.

3168

in repo_edit.mako.

3169

"""

3169

"""

3170

# prefix, repo_name, suffix

3170

# prefix, repo_name, suffix

3171

return self._cache_key_partition()[2]

3171

return self._cache_key_partition()[2]

3172

3173

@classmethod

3173

@classmethod

3174

def delete_all_cache(cls):

3174

def delete_all_cache(cls):

3175

"""

3175

"""

3176

Delete all cache keys from database.

3176

Delete all cache keys from database.

3177

Should only be run when all instances are down and all entries

3177

Should only be run when all instances are down and all entries

3178

thus stale.

3178

thus stale.

3179

"""

3179

"""

3180

cls.query().delete()

3180

cls.query().delete()

3181

Session().commit()

3181

Session().commit()

3182

3183

@classmethod

3183

@classmethod

3184

def get_cache_key(cls, repo_name, cache_type):

3184

def get_cache_key(cls, repo_name, cache_type):

3185

"""

3185

"""

3186

3187

Generate a cache key for this process of RhodeCode instance.

3187

Generate a cache key for this process of RhodeCode instance.

3188

Prefix most likely will be process id or maybe explicitly set

3188

Prefix most likely will be process id or maybe explicitly set

3189

instance_id from .ini file.

3189

instance_id from .ini file.

3190

"""

3190

"""

3191

import rhodecode

3191

import rhodecode

3192

prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')

3192

prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')

3193

3194

repo_as_unicode = safe_unicode(repo_name)

3194

repo_as_unicode = safe_unicode(repo_name)

3195

key = u'{}_{}'.format(repo_as_unicode, cache_type) \

3195

key = u'{}_{}'.format(repo_as_unicode, cache_type) \

3196

if cache_type else repo_as_unicode

3196

if cache_type else repo_as_unicode

3197

3198

return u'{}{}'.format(prefix, key)

3198

return u'{}{}'.format(prefix, key)

3199

3200

@classmethod

3200

@classmethod

3201

def set_invalidate(cls, repo_name, delete=False):

3201

def set_invalidate(cls, repo_name, delete=False):

3202

"""

3202

"""

3203

Mark all caches of a repo as invalid in the database.

3203

Mark all caches of a repo as invalid in the database.

3204

"""

3204

"""

3205

3206

try:

3206

try:

3207

qry = Session().query(cls).filter(cls.cache_args == repo_name)

3207

qry = Session().query(cls).filter(cls.cache_args == repo_name)

3208

if delete:

3208

if delete:

3209

log.debug('cache objects deleted for repo %s',

3209

log.debug('cache objects deleted for repo %s',

3210

safe_str(repo_name))

3210

safe_str(repo_name))

3211

qry.delete()

3211

qry.delete()

3212

else:

3212

else:

3213

log.debug('cache objects marked as invalid for repo %s',

3213

log.debug('cache objects marked as invalid for repo %s',

3214

safe_str(repo_name))

3214

safe_str(repo_name))

3215

qry.update({"cache_active": False})

3215

qry.update({"cache_active": False})

3216

3217

Session().commit()

3217

Session().commit()

3218

except Exception:

3218

except Exception:

3219

log.exception(

3219

log.exception(

3220

'Cache key invalidation failed for repository %s',

3220

'Cache key invalidation failed for repository %s',

3221

safe_str(repo_name))

3221

safe_str(repo_name))

3222

Session().rollback()

3222

Session().rollback()

3223

3224

@classmethod

3224

@classmethod

3225

def get_active_cache(cls, cache_key):

3225

def get_active_cache(cls, cache_key):

3226

inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

3226

inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

3227

if inv_obj:

3227

if inv_obj:

3228

return inv_obj

3228

return inv_obj

3229

return None

3229

return None

3230

3231

@classmethod

3231

@classmethod

3232

def repo_context_cache(cls, compute_func, repo_name, cache_type,

3232

def repo_context_cache(cls, compute_func, repo_name, cache_type,

3233

thread_scoped=False):

3233

thread_scoped=False):

3234

"""

3234

"""

3235

@cache_region('long_term')

3235

@cache_region('long_term')

3236

def _heavy_calculation(cache_key):

3236

def _heavy_calculation(cache_key):

3237

return 'result'

3237

return 'result'

3238

3239

cache_context = CacheKey.repo_context_cache(

3239

cache_context = CacheKey.repo_context_cache(

3240

_heavy_calculation, repo_name, cache_type)

3240

_heavy_calculation, repo_name, cache_type)

3241

3242

with cache_context as context:

3242

with cache_context as context:

3243

context.invalidate()

3243

context.invalidate()

3244

computed = context.compute()

3244

computed = context.compute()

3245

3246

assert computed == 'result'

3246

assert computed == 'result'

3247

"""

3247

"""

3248

from rhodecode.lib import caches

3248

from rhodecode.lib import caches

3249

return caches.InvalidationContext(

3249

return caches.InvalidationContext(

3250

compute_func, repo_name, cache_type, thread_scoped=thread_scoped)

3250

compute_func, repo_name, cache_type, thread_scoped=thread_scoped)

3251

3252

3253

class ChangesetComment(Base, BaseModel):

3253

class ChangesetComment(Base, BaseModel):

3254

__tablename__ = 'changeset_comments'

3254

__tablename__ = 'changeset_comments'

3255

__table_args__ = (

3255

__table_args__ = (

3256

Index('cc_revision_idx', 'revision'),

3256

Index('cc_revision_idx', 'revision'),

3257

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3257

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3258

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3258

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3259

)

3259

)

3260

3261

COMMENT_OUTDATED = u'comment_outdated'

3261

COMMENT_OUTDATED = u'comment_outdated'

3262

COMMENT_TYPE_NOTE = u'note'

3262

COMMENT_TYPE_NOTE = u'note'

3263

COMMENT_TYPE_TODO = u'todo'

3263

COMMENT_TYPE_TODO = u'todo'

3264

COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]

3264

COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]

3265

3266

comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

3266

comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

3267

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

3267

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

3268

revision = Column('revision', String(40), nullable=True)

3268

revision = Column('revision', String(40), nullable=True)

3269

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

3269

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

3270

pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)

3270

pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)

3271

line_no = Column('line_no', Unicode(10), nullable=True)

3271

line_no = Column('line_no', Unicode(10), nullable=True)

3272

hl_lines = Column('hl_lines', Unicode(512), nullable=True)

3272

hl_lines = Column('hl_lines', Unicode(512), nullable=True)

3273

f_path = Column('f_path', Unicode(1000), nullable=True)

3273

f_path = Column('f_path', Unicode(1000), nullable=True)

3274

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

3274

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

3275

text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)

3275

text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)

3276

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3276

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3277

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3277

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3278

renderer = Column('renderer', Unicode(64), nullable=True)

3278

renderer = Column('renderer', Unicode(64), nullable=True)

3279

display_state = Column('display_state', Unicode(128), nullable=True)

3279

display_state = Column('display_state', Unicode(128), nullable=True)

3280

3281

comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)

3281

comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)

3282

resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)

3282

resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)

3283

resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')

3283

resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')

3284

author = relationship('User', lazy='joined')

3284

author = relationship('User', lazy='joined')

3285

repo = relationship('Repository')

3285

repo = relationship('Repository')

3286

status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')

3286

status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')

3287

pull_request = relationship('PullRequest', lazy='joined')

3287

pull_request = relationship('PullRequest', lazy='joined')

3288

pull_request_version = relationship('PullRequestVersion')

3288

pull_request_version = relationship('PullRequestVersion')

3289

3290

@classmethod

3290

@classmethod

3291

def get_users(cls, revision=None, pull_request_id=None):

3291

def get_users(cls, revision=None, pull_request_id=None):

3292

"""

3292

"""

3293

Returns user associated with this ChangesetComment. ie those

3293

Returns user associated with this ChangesetComment. ie those

3294

who actually commented

3294

who actually commented

3295

3296

:param cls:

3296

:param cls:

3297

:param revision:

3297

:param revision:

3298

"""

3298

"""

3299

q = Session().query(User)\

3299

q = Session().query(User)\

3300

.join(ChangesetComment.author)

3300

.join(ChangesetComment.author)

3301

if revision:

3301

if revision:

3302

q = q.filter(cls.revision == revision)

3302

q = q.filter(cls.revision == revision)

3303

elif pull_request_id:

3303

elif pull_request_id:

3304

q = q.filter(cls.pull_request_id == pull_request_id)

3304

q = q.filter(cls.pull_request_id == pull_request_id)

3305

return q.all()

3305

return q.all()

3306

3307

@classmethod

3307

@classmethod

3308

def get_index_from_version(cls, pr_version, versions):

3308

def get_index_from_version(cls, pr_version, versions):

3309

num_versions = [x.pull_request_version_id for x in versions]

3309

num_versions = [x.pull_request_version_id for x in versions]

3310

try:

3310

try:

3311

return num_versions.index(pr_version) +1

3311

return num_versions.index(pr_version) +1

3312

except (IndexError, ValueError):

3312

except (IndexError, ValueError):

3313

return

3313

return

3314

3315

@property

3315

@property

3316

def outdated(self):

3316

def outdated(self):

3317

return self.display_state == self.COMMENT_OUTDATED

3317

return self.display_state == self.COMMENT_OUTDATED

3318

3319

def outdated_at_version(self, version):

3319

def outdated_at_version(self, version):

3320

"""

3320

"""

3321

Checks if comment is outdated for given pull request version

3321

Checks if comment is outdated for given pull request version

3322

"""

3322

"""

3323

return self.outdated and self.pull_request_version_id != version

3323

return self.outdated and self.pull_request_version_id != version

3324

3325

def older_than_version(self, version):

3325

def older_than_version(self, version):

3326

"""

3326

"""

3327

Checks if comment is made from previous version than given

3327

Checks if comment is made from previous version than given

3328

"""

3328

"""

3329

if version is None:

3329

if version is None:

3330

return self.pull_request_version_id is not None

3330

return self.pull_request_version_id is not None

3331

3332

return self.pull_request_version_id < version

3332

return self.pull_request_version_id < version

3333

3334

@property

3334

@property

3335

def resolved(self):

3335

def resolved(self):

3336

return self.resolved_by[0] if self.resolved_by else None

3336

return self.resolved_by[0] if self.resolved_by else None

3337

3338

@property

3338

@property

3339

def is_todo(self):

3339

def is_todo(self):

3340

return self.comment_type == self.COMMENT_TYPE_TODO

3340

return self.comment_type == self.COMMENT_TYPE_TODO

3341

3342

@property

3342

@property

3343

def is_inline(self):

3343

def is_inline(self):

3344

return self.line_no and self.f_path

3344

return self.line_no and self.f_path

3345

3346

def get_index_version(self, versions):

3346

def get_index_version(self, versions):

3347

return self.get_index_from_version(

3347

return self.get_index_from_version(

3348

self.pull_request_version_id, versions)

3348

self.pull_request_version_id, versions)

3349

3350

def __repr__(self):

3350

def __repr__(self):

3351

if self.comment_id:

3351

if self.comment_id:

3352

return '<DB:Comment #%s>' % self.comment_id

3352

return '<DB:Comment #%s>' % self.comment_id

3353

else:

3353

else:

3354

return '<DB:Comment at %#x>' % id(self)

3354

return '<DB:Comment at %#x>' % id(self)

3355

3356

def get_api_data(self):

3356

def get_api_data(self):

3357

comment = self

3357

comment = self

3358

data = {

3358

data = {

3359

'comment_id': comment.comment_id,

3359

'comment_id': comment.comment_id,

3360

'comment_type': comment.comment_type,

3360

'comment_type': comment.comment_type,

3361

'comment_text': comment.text,

3361

'comment_text': comment.text,

3362

'comment_status': comment.status_change,

3362

'comment_status': comment.status_change,

3363

'comment_f_path': comment.f_path,

3363

'comment_f_path': comment.f_path,

3364

'comment_lineno': comment.line_no,

3364

'comment_lineno': comment.line_no,

3365

'comment_author': comment.author,

3365

'comment_author': comment.author,

3366

'comment_created_on': comment.created_on

3366

'comment_created_on': comment.created_on

3367

}

3367

}

3368

return data

3368

return data

3369

3370

def __json__(self):

3370

def __json__(self):

3371

data = dict()

3371

data = dict()

3372

data.update(self.get_api_data())

3372

data.update(self.get_api_data())

3373

return data

3373

return data

3374

3375

3376

class ChangesetStatus(Base, BaseModel):

3376

class ChangesetStatus(Base, BaseModel):

3377

__tablename__ = 'changeset_statuses'

3377

__tablename__ = 'changeset_statuses'

3378

__table_args__ = (

3378

__table_args__ = (

3379

Index('cs_revision_idx', 'revision'),

3379

Index('cs_revision_idx', 'revision'),

3380

Index('cs_version_idx', 'version'),

3380

Index('cs_version_idx', 'version'),

3381

UniqueConstraint('repo_id', 'revision', 'version'),

3381

UniqueConstraint('repo_id', 'revision', 'version'),

3382

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3382

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3383

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3383

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3384

)

3384

)

3385

STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

3385

STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

3386

STATUS_APPROVED = 'approved'

3386

STATUS_APPROVED = 'approved'

3387

STATUS_REJECTED = 'rejected'

3387

STATUS_REJECTED = 'rejected'

3388

STATUS_UNDER_REVIEW = 'under_review'

3388

STATUS_UNDER_REVIEW = 'under_review'

3389

3390

STATUSES = [

3390

STATUSES = [

3391

(STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default

3391

(STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default

3392

(STATUS_APPROVED, _("Approved")),

3392

(STATUS_APPROVED, _("Approved")),

3393

(STATUS_REJECTED, _("Rejected")),

3393

(STATUS_REJECTED, _("Rejected")),

3394

(STATUS_UNDER_REVIEW, _("Under Review")),

3394

(STATUS_UNDER_REVIEW, _("Under Review")),

3395

]

3395

]

3396

3397

changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)

3397

changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)

3398

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

3398

repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

3399

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

3399

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

3400

revision = Column('revision', String(40), nullable=False)

3400

revision = Column('revision', String(40), nullable=False)

3401

status = Column('status', String(128), nullable=False, default=DEFAULT)

3401

status = Column('status', String(128), nullable=False, default=DEFAULT)

3402

changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))

3402

changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))

3403

modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

3403

modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

3404

version = Column('version', Integer(), nullable=False, default=0)

3404

version = Column('version', Integer(), nullable=False, default=0)

3405

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

3405

pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

3406

3407

author = relationship('User', lazy='joined')

3407

author = relationship('User', lazy='joined')

3408

repo = relationship('Repository')

3408

repo = relationship('Repository')

3409

comment = relationship('ChangesetComment', lazy='joined')

3409

comment = relationship('ChangesetComment', lazy='joined')

3410

pull_request = relationship('PullRequest', lazy='joined')

3410

pull_request = relationship('PullRequest', lazy='joined')

3411

3412

def __unicode__(self):

3412

def __unicode__(self):

3413

return u"<%s('%s[v%s]:%s')>" % (

3413

return u"<%s('%s[v%s]:%s')>" % (

3414

self.__class__.__name__,

3414

self.__class__.__name__,

3415

self.status, self.version, self.author

3415

self.status, self.version, self.author

3416

)

3416

)

3417

3418

@classmethod

3418

@classmethod

3419

def get_status_lbl(cls, value):

3419

def get_status_lbl(cls, value):

3420

return dict(cls.STATUSES).get(value)

3420

return dict(cls.STATUSES).get(value)

3421

3422

@property

3422

@property

3423

def status_lbl(self):

3423

def status_lbl(self):

3424

return ChangesetStatus.get_status_lbl(self.status)

3424

return ChangesetStatus.get_status_lbl(self.status)

3425

3426

def get_api_data(self):

3426

def get_api_data(self):

3427

status = self

3427

status = self

3428

data = {

3428

data = {

3429

'status_id': status.changeset_status_id,

3429

'status_id': status.changeset_status_id,

3430

'status': status.status,

3430

'status': status.status,

3431

}

3431

}

3432

return data

3432

return data

3433

3434

def __json__(self):

3434

def __json__(self):

3435

data = dict()

3435

data = dict()

3436

data.update(self.get_api_data())

3436

data.update(self.get_api_data())

3437

return data

3437

return data

3438

3439

3440

class _PullRequestBase(BaseModel):

3440

class _PullRequestBase(BaseModel):

3441

"""

3441

"""

3442

Common attributes of pull request and version entries.

3442

Common attributes of pull request and version entries.

3443

"""

3443

"""

3444

3445

# .status values

3445

# .status values

3446

STATUS_NEW = u'new'

3446

STATUS_NEW = u'new'

3447

STATUS_OPEN = u'open'

3447

STATUS_OPEN = u'open'

3448

STATUS_CLOSED = u'closed'

3448

STATUS_CLOSED = u'closed'

3449

3450

title = Column('title', Unicode(255), nullable=True)

3450

title = Column('title', Unicode(255), nullable=True)

3451

description = Column(

3451

description = Column(

3452

'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),

3452

'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),

3453

nullable=True)

3453

nullable=True)

3454

# new/open/closed status of pull request (not approve/reject/etc)

3454

# new/open/closed status of pull request (not approve/reject/etc)

3455

status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)

3455

status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)

3456

created_on = Column(

3456

created_on = Column(

3457

'created_on', DateTime(timezone=False), nullable=False,

3457

'created_on', DateTime(timezone=False), nullable=False,

3458

default=datetime.datetime.now)

3458

default=datetime.datetime.now)

3459

updated_on = Column(

3459

updated_on = Column(

3460

'updated_on', DateTime(timezone=False), nullable=False,

3460

'updated_on', DateTime(timezone=False), nullable=False,

3461

default=datetime.datetime.now)

3461

default=datetime.datetime.now)

3462

3463

@declared_attr

3463

@declared_attr

3464

def user_id(cls):

3464

def user_id(cls):

3465

return Column(

3465

return Column(

3466

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

3466

"user_id", Integer(), ForeignKey('users.user_id'), nullable=False,

3467

unique=None)

3467

unique=None)

3468

3469

# 500 revisions max

3469

# 500 revisions max

3470

_revisions = Column(

3470

_revisions = Column(

3471

'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))

3471

'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))

3472

3473

@declared_attr

3473

@declared_attr

3474

def source_repo_id(cls):

3474

def source_repo_id(cls):

3475

# TODO: dan: rename column to source_repo_id

3475

# TODO: dan: rename column to source_repo_id

3476

return Column(

3476

return Column(

3477

'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3477

'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3478

nullable=False)

3478

nullable=False)

3479

3480

source_ref = Column('org_ref', Unicode(255), nullable=False)

3480

source_ref = Column('org_ref', Unicode(255), nullable=False)

3481

3482

@declared_attr

3482

@declared_attr

3483

def target_repo_id(cls):

3483

def target_repo_id(cls):

3484

# TODO: dan: rename column to target_repo_id

3484

# TODO: dan: rename column to target_repo_id

3485

return Column(

3485

return Column(

3486

'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3486

'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),

3487

nullable=False)

3487

nullable=False)

3488

3489

target_ref = Column('other_ref', Unicode(255), nullable=False)

3489

target_ref = Column('other_ref', Unicode(255), nullable=False)

3490

_shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)

3490

_shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)

3491

3492

# TODO: dan: rename column to last_merge_source_rev

3492

# TODO: dan: rename column to last_merge_source_rev

3493

_last_merge_source_rev = Column(

3493

_last_merge_source_rev = Column(

3494

'last_merge_org_rev', String(40), nullable=True)

3494

'last_merge_org_rev', String(40), nullable=True)

3495

# TODO: dan: rename column to last_merge_target_rev

3495

# TODO: dan: rename column to last_merge_target_rev

3496

_last_merge_target_rev = Column(

3496

_last_merge_target_rev = Column(

3497

'last_merge_other_rev', String(40), nullable=True)

3497

'last_merge_other_rev', String(40), nullable=True)

3498

_last_merge_status = Column('merge_status', Integer(), nullable=True)

3498

_last_merge_status = Column('merge_status', Integer(), nullable=True)

3499

merge_rev = Column('merge_rev', String(40), nullable=True)

3499

merge_rev = Column('merge_rev', String(40), nullable=True)

3500

3501

reviewer_data = Column(

3501

reviewer_data = Column(

3502

'reviewer_data_json', MutationObj.as_mutable(

3502

'reviewer_data_json', MutationObj.as_mutable(

3503

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

3503

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

3504

3505

@property

3505

@property

3506

def reviewer_data_json(self):

3506

def reviewer_data_json(self):

3507

return json.dumps(self.reviewer_data)

3507

return json.dumps(self.reviewer_data)

3508

3509

@hybrid_property

3509

@hybrid_property

3510

def description_safe(self):

3510

def description_safe(self):

3511

from rhodecode.lib import helpers as h

3511

from rhodecode.lib import helpers as h

3512

return h.escape(self.description)

3512

return h.escape(self.description)

3513

3514

@hybrid_property

3514

@hybrid_property

3515

def revisions(self):

3515

def revisions(self):

3516

return self._revisions.split(':') if self._revisions else []

3516

return self._revisions.split(':') if self._revisions else []

3517

3518

@revisions.setter

3518

@revisions.setter

3519

def revisions(self, val):

3519

def revisions(self, val):

3520

self._revisions = ':'.join(val)

3520

self._revisions = ':'.join(val)

3521

3522

@hybrid_property

3522

@hybrid_property

3523

def last_merge_status(self):

3523

def last_merge_status(self):

3524

return safe_int(self._last_merge_status)

3524

return safe_int(self._last_merge_status)

3525

3526

@last_merge_status.setter

3526

@last_merge_status.setter

3527

def last_merge_status(self, val):

3527

def last_merge_status(self, val):

3528

self._last_merge_status = val

3528

self._last_merge_status = val

3529

3530

@declared_attr

3530

@declared_attr

3531

def author(cls):

3531

def author(cls):

3532

return relationship('User', lazy='joined')

3532

return relationship('User', lazy='joined')

3533

3534

@declared_attr

3534

@declared_attr

3535

def source_repo(cls):

3535

def source_repo(cls):

3536

return relationship(

3536

return relationship(

3537

'Repository',

3537

'Repository',

3538

primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)

3538

primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)

3539

3540

@property

3540

@property

3541

def source_ref_parts(self):

3541

def source_ref_parts(self):

3542

return self.unicode_to_reference(self.source_ref)

3542

return self.unicode_to_reference(self.source_ref)

3543

3544

@declared_attr

3544

@declared_attr

3545

def target_repo(cls):

3545

def target_repo(cls):

3546

return relationship(

3546

return relationship(

3547

'Repository',

3547

'Repository',

3548

primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)

3548

primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)

3549

3550

@property

3550

@property

3551

def target_ref_parts(self):

3551

def target_ref_parts(self):

3552

return self.unicode_to_reference(self.target_ref)

3552

return self.unicode_to_reference(self.target_ref)

3553

3554

@property

3554

@property

3555

def shadow_merge_ref(self):

3555

def shadow_merge_ref(self):

3556

return self.unicode_to_reference(self._shadow_merge_ref)

3556

return self.unicode_to_reference(self._shadow_merge_ref)

3557

3558

@shadow_merge_ref.setter

3558

@shadow_merge_ref.setter

3559

def shadow_merge_ref(self, ref):

3559

def shadow_merge_ref(self, ref):

3560

self._shadow_merge_ref = self.reference_to_unicode(ref)

3560

self._shadow_merge_ref = self.reference_to_unicode(ref)

3561

3562

def unicode_to_reference(self, raw):

3562

def unicode_to_reference(self, raw):

3563

"""

3563

"""

3564

Convert a unicode (or string) to a reference object.

3564

Convert a unicode (or string) to a reference object.

3565

If unicode evaluates to False it returns None.

3565

If unicode evaluates to False it returns None.

3566

"""

3566

"""

3567

if raw:

3567

if raw:

3568

refs = raw.split(':')

3568

refs = raw.split(':')

3569

return Reference(*refs)

3569

return Reference(*refs)

3570

else:

3570

else:

3571

return None

3571

return None

3572

3573

def reference_to_unicode(self, ref):

3573

def reference_to_unicode(self, ref):

3574

"""

3574

"""

3575

Convert a reference object to unicode.

3575

Convert a reference object to unicode.

3576

If reference is None it returns None.

3576

If reference is None it returns None.

3577

"""

3577

"""

3578

if ref:

3578

if ref:

3579

return u':'.join(ref)

3579

return u':'.join(ref)

3580

else:

3580

else:

3581

return None

3581

return None

3582

3583

def get_api_data(self, with_merge_state=True):

3583

def get_api_data(self, with_merge_state=True):

3584

from rhodecode.model.pull_request import PullRequestModel

3584

from rhodecode.model.pull_request import PullRequestModel

3585

3586

pull_request = self

3586

pull_request = self

3587

if with_merge_state:

3587

if with_merge_state:

3588

merge_status = PullRequestModel().merge_status(pull_request)

3588

merge_status = PullRequestModel().merge_status(pull_request)

3589

merge_state = {

3589

merge_state = {

3590

'status': merge_status[0],

3590

'status': merge_status[0],

3591

'message': safe_unicode(merge_status[1]),

3591

'message': safe_unicode(merge_status[1]),

3592

}

3592

}

3593

else:

3593

else:

3594

merge_state = {'status': 'not_available',

3594

merge_state = {'status': 'not_available',

3595

'message': 'not_available'}

3595

'message': 'not_available'}

3596

3597

merge_data = {

3597

merge_data = {

3598

'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),

3598

'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),

3599

'reference': (

3599

'reference': (

3600

pull_request.shadow_merge_ref._asdict()

3600

pull_request.shadow_merge_ref._asdict()

3601

if pull_request.shadow_merge_ref else None),

3601

if pull_request.shadow_merge_ref else None),

3602

}

3602

}

3603

3604

data = {

3604

data = {

3605

'pull_request_id': pull_request.pull_request_id,

3605

'pull_request_id': pull_request.pull_request_id,

3606

'url': PullRequestModel().get_url(pull_request),

3606

'url': PullRequestModel().get_url(pull_request),

3607

'title': pull_request.title,

3607

'title': pull_request.title,

3608

'description': pull_request.description,

3608

'description': pull_request.description,

3609

'status': pull_request.status,

3609

'status': pull_request.status,

3610

'created_on': pull_request.created_on,

3610

'created_on': pull_request.created_on,

3611

'updated_on': pull_request.updated_on,

3611

'updated_on': pull_request.updated_on,

3612

'commit_ids': pull_request.revisions,

3612

'commit_ids': pull_request.revisions,

3613

'review_status': pull_request.calculated_review_status(),

3613

'review_status': pull_request.calculated_review_status(),

3614

'mergeable': merge_state,

3614

'mergeable': merge_state,

3615

'source': {

3615

'source': {

3616

'clone_url': pull_request.source_repo.clone_url(),

3616

'clone_url': pull_request.source_repo.clone_url(),

3617

'repository': pull_request.source_repo.repo_name,

3617

'repository': pull_request.source_repo.repo_name,

3618

'reference': {

3618

'reference': {

3619

'name': pull_request.source_ref_parts.name,

3619

'name': pull_request.source_ref_parts.name,

3620

'type': pull_request.source_ref_parts.type,

3620

'type': pull_request.source_ref_parts.type,

3621

'commit_id': pull_request.source_ref_parts.commit_id,

3621

'commit_id': pull_request.source_ref_parts.commit_id,

3622

},

3622

},

3623

},

3623

},

3624

'target': {

3624

'target': {

3625

'clone_url': pull_request.target_repo.clone_url(),

3625

'clone_url': pull_request.target_repo.clone_url(),

3626

'repository': pull_request.target_repo.repo_name,

3626

'repository': pull_request.target_repo.repo_name,

3627

'reference': {

3627

'reference': {

3628

'name': pull_request.target_ref_parts.name,

3628

'name': pull_request.target_ref_parts.name,

3629

'type': pull_request.target_ref_parts.type,

3629

'type': pull_request.target_ref_parts.type,

3630

'commit_id': pull_request.target_ref_parts.commit_id,

3630

'commit_id': pull_request.target_ref_parts.commit_id,

3631

},

3631

},

3632

},

3632

},

3633

'merge': merge_data,

3633

'merge': merge_data,

3634

'author': pull_request.author.get_api_data(include_secrets=False,

3634

'author': pull_request.author.get_api_data(include_secrets=False,

3635

details='basic'),

3635

details='basic'),

3636

'reviewers': [

3636

'reviewers': [

3637

{

3637

{

3638

'user': reviewer.get_api_data(include_secrets=False,

3638

'user': reviewer.get_api_data(include_secrets=False,

3639

details='basic'),

3639

details='basic'),

3640

'reasons': reasons,

3640

'reasons': reasons,

3641

'review_status': st[0][1].status if st else 'not_reviewed',

3641

'review_status': st[0][1].status if st else 'not_reviewed',

3642

}

3642

}

3643

for obj, reviewer, reasons, mandatory, st in

3643

for obj, reviewer, reasons, mandatory, st in

3644

pull_request.reviewers_statuses()

3644

pull_request.reviewers_statuses()

3645

]

3645

]

3646

}

3646

}

3647

3648

return data

3648

return data

3649

3650

3651

class PullRequest(Base, _PullRequestBase):

3651

class PullRequest(Base, _PullRequestBase):

3652

__tablename__ = 'pull_requests'

3652

__tablename__ = 'pull_requests'

3653

__table_args__ = (

3653

__table_args__ = (

3654

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3654

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3655

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3655

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3656

)

3656

)

3657

3658

pull_request_id = Column(

3658

pull_request_id = Column(

3659

'pull_request_id', Integer(), nullable=False, primary_key=True)

3659

'pull_request_id', Integer(), nullable=False, primary_key=True)

3660

3661

def __repr__(self):

3661

def __repr__(self):

3662

if self.pull_request_id:

3662

if self.pull_request_id:

3663

return '<DB:PullRequest #%s>' % self.pull_request_id

3663

return '<DB:PullRequest #%s>' % self.pull_request_id

3664

else:

3664

else:

3665

return '<DB:PullRequest at %#x>' % id(self)

3665

return '<DB:PullRequest at %#x>' % id(self)

3666

3667

reviewers = relationship('PullRequestReviewers',

3667

reviewers = relationship('PullRequestReviewers',

3668

cascade="all, delete, delete-orphan")

3668

cascade="all, delete, delete-orphan")

3669

statuses = relationship('ChangesetStatus',

3669

statuses = relationship('ChangesetStatus',

3670

cascade="all, delete, delete-orphan")

3670

cascade="all, delete, delete-orphan")

3671

comments = relationship('ChangesetComment',

3671

comments = relationship('ChangesetComment',

3672

cascade="all, delete, delete-orphan")

3672

cascade="all, delete, delete-orphan")

3673

versions = relationship('PullRequestVersion',

3673

versions = relationship('PullRequestVersion',

3674

cascade="all, delete, delete-orphan",

3674

cascade="all, delete, delete-orphan",

3675

lazy='dynamic')

3675

lazy='dynamic')

3676

3677

@classmethod

3677

@classmethod

3678

def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,

3678

def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,

3679

internal_methods=None):

3679

internal_methods=None):

3680

3681

class PullRequestDisplay(object):

3681

class PullRequestDisplay(object):

3682

"""

3682

"""

3683

Special object wrapper for showing PullRequest data via Versions

3683

Special object wrapper for showing PullRequest data via Versions

3684

It mimics PR object as close as possible. This is read only object

3684

It mimics PR object as close as possible. This is read only object

3685

just for display

3685

just for display

3686

"""

3686

"""

3687

3688

def __init__(self, attrs, internal=None):

3688

def __init__(self, attrs, internal=None):

3689

self.attrs = attrs

3689

self.attrs = attrs

3690

# internal have priority over the given ones via attrs

3690

# internal have priority over the given ones via attrs

3691

self.internal = internal or ['versions']

3691

self.internal = internal or ['versions']

3692

3693

def __getattr__(self, item):

3693

def __getattr__(self, item):

3694

if item in self.internal:

3694

if item in self.internal:

3695

return getattr(self, item)

3695

return getattr(self, item)

3696

try:

3696

try:

3697

return self.attrs[item]

3697

return self.attrs[item]

3698

except KeyError:

3698

except KeyError:

3699

raise AttributeError(

3699

raise AttributeError(

3700

'%s object has no attribute %s' % (self, item))

3700

'%s object has no attribute %s' % (self, item))

3701

3702

def __repr__(self):

3702

def __repr__(self):

3703

return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')

3703

return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')

3704

3705

def versions(self):

3705

def versions(self):

3706

return pull_request_obj.versions.order_by(

3706

return pull_request_obj.versions.order_by(

3707

PullRequestVersion.pull_request_version_id).all()

3707

PullRequestVersion.pull_request_version_id).all()

3708

3709

def is_closed(self):

3709

def is_closed(self):

3710

return pull_request_obj.is_closed()

3710

return pull_request_obj.is_closed()

3711

3712

@property

3712

@property

3713

def pull_request_version_id(self):

3713

def pull_request_version_id(self):

3714

return getattr(pull_request_obj, 'pull_request_version_id', None)

3714

return getattr(pull_request_obj, 'pull_request_version_id', None)

3715

3716

attrs = StrictAttributeDict(pull_request_obj.get_api_data())

3716

attrs = StrictAttributeDict(pull_request_obj.get_api_data())

3717

3718

attrs.author = StrictAttributeDict(

3718

attrs.author = StrictAttributeDict(

3719

pull_request_obj.author.get_api_data())

3719

pull_request_obj.author.get_api_data())

3720

if pull_request_obj.target_repo:

3720

if pull_request_obj.target_repo:

3721

attrs.target_repo = StrictAttributeDict(

3721

attrs.target_repo = StrictAttributeDict(

3722

pull_request_obj.target_repo.get_api_data())

3722

pull_request_obj.target_repo.get_api_data())

3723

attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url

3723

attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url

3724

3725

if pull_request_obj.source_repo:

3725

if pull_request_obj.source_repo:

3726

attrs.source_repo = StrictAttributeDict(

3726

attrs.source_repo = StrictAttributeDict(

3727

pull_request_obj.source_repo.get_api_data())

3727

pull_request_obj.source_repo.get_api_data())

3728

attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url

3728

attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url

3729

3730

attrs.source_ref_parts = pull_request_obj.source_ref_parts

3730

attrs.source_ref_parts = pull_request_obj.source_ref_parts

3731

attrs.target_ref_parts = pull_request_obj.target_ref_parts

3731

attrs.target_ref_parts = pull_request_obj.target_ref_parts

3732

attrs.revisions = pull_request_obj.revisions

3732

attrs.revisions = pull_request_obj.revisions

3733

3734

attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref

3734

attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref

3735

attrs.reviewer_data = org_pull_request_obj.reviewer_data

3735

attrs.reviewer_data = org_pull_request_obj.reviewer_data

3736

attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json

3736

attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json

3737

3738

return PullRequestDisplay(attrs, internal=internal_methods)

3738

return PullRequestDisplay(attrs, internal=internal_methods)

3739

3740

def is_closed(self):

3740

def is_closed(self):

3741

return self.status == self.STATUS_CLOSED

3741

return self.status == self.STATUS_CLOSED

3742

3743

def __json__(self):

3743

def __json__(self):

3744

return {

3744

return {

3745

'revisions': self.revisions,

3745

'revisions': self.revisions,

3746

}

3746

}

3747

3748

def calculated_review_status(self):

3748

def calculated_review_status(self):

3749

from rhodecode.model.changeset_status import ChangesetStatusModel

3749

from rhodecode.model.changeset_status import ChangesetStatusModel

3750

return ChangesetStatusModel().calculated_review_status(self)

3750

return ChangesetStatusModel().calculated_review_status(self)

3751

3752

def reviewers_statuses(self):

3752

def reviewers_statuses(self):

3753

from rhodecode.model.changeset_status import ChangesetStatusModel

3753

from rhodecode.model.changeset_status import ChangesetStatusModel

3754

return ChangesetStatusModel().reviewers_statuses(self)

3754

return ChangesetStatusModel().reviewers_statuses(self)

3755

3756

@property

3756

@property

3757

def workspace_id(self):

3757

def workspace_id(self):

3758

from rhodecode.model.pull_request import PullRequestModel

3758

from rhodecode.model.pull_request import PullRequestModel

3759

return PullRequestModel()._workspace_id(self)

3759

return PullRequestModel()._workspace_id(self)

3760

3761

def get_shadow_repo(self):

3761

def get_shadow_repo(self):

3762

workspace_id = self.workspace_id

3762

workspace_id = self.workspace_id

3763

vcs_obj = self.target_repo.scm_instance()

3763

vcs_obj = self.target_repo.scm_instance()

3764

shadow_repository_path = vcs_obj._get_shadow_repository_path(

3764

shadow_repository_path = vcs_obj._get_shadow_repository_path(

3765

workspace_id)

3765

workspace_id)

3766

if os.path.isdir(shadow_repository_path):

3766

return vcs_obj._get_shadow_instance(shadow_repository_path)

3767

return vcs_obj._get_shadow_instance(shadow_repository_path)

3767

3768

3769

class PullRequestVersion(Base, _PullRequestBase):

3770

class PullRequestVersion(Base, _PullRequestBase):

3770

__tablename__ = 'pull_request_versions'

3771

__tablename__ = 'pull_request_versions'

3771

__table_args__ = (

3772

__table_args__ = (

3772

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3773

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3773

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3774

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3774

)

3775

)

3775

3776

pull_request_version_id = Column(

3777

pull_request_version_id = Column(

3777

'pull_request_version_id', Integer(), nullable=False, primary_key=True)

3778

'pull_request_version_id', Integer(), nullable=False, primary_key=True)

3778

pull_request_id = Column(

3779

pull_request_id = Column(

3779

'pull_request_id', Integer(),

3780

'pull_request_id', Integer(),

3780

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3781

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3781

pull_request = relationship('PullRequest')

3782

pull_request = relationship('PullRequest')

3782

3783

def __repr__(self):

3784

def __repr__(self):

3784

if self.pull_request_version_id:

3785

if self.pull_request_version_id:

3785

return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id

3786

return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id

3786

else:

3787

else:

3787

return '<DB:PullRequestVersion at %#x>' % id(self)

3788

return '<DB:PullRequestVersion at %#x>' % id(self)

3788

3789

@property

3790

@property

3790

def reviewers(self):

3791

def reviewers(self):

3791

return self.pull_request.reviewers

3792

return self.pull_request.reviewers

3792

3793

@property

3794

@property

3794

def versions(self):

3795

def versions(self):

3795

return self.pull_request.versions

3796

return self.pull_request.versions

3796

3797

def is_closed(self):

3798

def is_closed(self):

3798

# calculate from original

3799

# calculate from original

3799

return self.pull_request.status == self.STATUS_CLOSED

3800

return self.pull_request.status == self.STATUS_CLOSED

3800

3801

def calculated_review_status(self):

3802

def calculated_review_status(self):

3802

return self.pull_request.calculated_review_status()

3803

return self.pull_request.calculated_review_status()

3803

3804

def reviewers_statuses(self):

3805

def reviewers_statuses(self):

3805

return self.pull_request.reviewers_statuses()

3806

return self.pull_request.reviewers_statuses()

3806

3807

3808

class PullRequestReviewers(Base, BaseModel):

3809

class PullRequestReviewers(Base, BaseModel):

3809

__tablename__ = 'pull_request_reviewers'

3810

__tablename__ = 'pull_request_reviewers'

3810

__table_args__ = (

3811

__table_args__ = (

3811

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3812

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3812

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3813

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3813

)

3814

)

3814

3815

@hybrid_property

3816

@hybrid_property

3816

def reasons(self):

3817

def reasons(self):

3817

if not self._reasons:

3818

if not self._reasons:

3818

return []

3819

return []

3819

return self._reasons

3820

return self._reasons

3820

3821

@reasons.setter

3822

@reasons.setter

3822

def reasons(self, val):

3823

def reasons(self, val):

3823

val = val or []

3824

val = val or []

3824

if any(not isinstance(x, basestring) for x in val):

3825

if any(not isinstance(x, basestring) for x in val):

3825

raise Exception('invalid reasons type, must be list of strings')

3826

raise Exception('invalid reasons type, must be list of strings')

3826

self._reasons = val

3827

self._reasons = val

3827

3828

pull_requests_reviewers_id = Column(

3829

pull_requests_reviewers_id = Column(

3829

'pull_requests_reviewers_id', Integer(), nullable=False,

3830

'pull_requests_reviewers_id', Integer(), nullable=False,

3830

primary_key=True)

3831

primary_key=True)

3831

pull_request_id = Column(

3832

pull_request_id = Column(

3832

"pull_request_id", Integer(),

3833

"pull_request_id", Integer(),

3833

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3834

ForeignKey('pull_requests.pull_request_id'), nullable=False)

3834

user_id = Column(

3835

user_id = Column(

3835

"user_id", Integer(), ForeignKey('users.user_id'), nullable=True)

3836

"user_id", Integer(), ForeignKey('users.user_id'), nullable=True)

3836

_reasons = Column(

3837

_reasons = Column(

3837

'reason', MutationList.as_mutable(

3838

'reason', MutationList.as_mutable(

3838

JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))

3839

JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))

3839

3840

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

3841

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

3841

user = relationship('User')

3842

user = relationship('User')

3842

pull_request = relationship('PullRequest')

3843

pull_request = relationship('PullRequest')

3843

3844

rule_data = Column(

3845

rule_data = Column(

3845

'rule_data_json',

3846

'rule_data_json',

3846

JsonType(dialect_map=dict(mysql=UnicodeText(16384))))

3847

JsonType(dialect_map=dict(mysql=UnicodeText(16384))))

3847

3848

def rule_user_group_data(self):

3849

def rule_user_group_data(self):

3849

"""

3850

"""

3850

Returns the voting user group rule data for this reviewer

3851

Returns the voting user group rule data for this reviewer

3851

"""

3852

"""

3852

3853

if self.rule_data and 'vote_rule' in self.rule_data:

3854

if self.rule_data and 'vote_rule' in self.rule_data:

3854

user_group_data = {}

3855

user_group_data = {}

3855

if 'rule_user_group_entry_id' in self.rule_data:

3856

if 'rule_user_group_entry_id' in self.rule_data:

3856

# means a group with voting rules !

3857

# means a group with voting rules !

3857

user_group_data['id'] = self.rule_data['rule_user_group_entry_id']

3858

user_group_data['id'] = self.rule_data['rule_user_group_entry_id']

3858

user_group_data['name'] = self.rule_data['rule_name']

3859

user_group_data['name'] = self.rule_data['rule_name']

3859

user_group_data['vote_rule'] = self.rule_data['vote_rule']

3860

user_group_data['vote_rule'] = self.rule_data['vote_rule']

3860

3861

return user_group_data

3862

return user_group_data

3862

3863

def __unicode__(self):

3864

def __unicode__(self):

3864

return u"<%s('id:%s')>" % (self.__class__.__name__,

3865

return u"<%s('id:%s')>" % (self.__class__.__name__,

3865

self.pull_requests_reviewers_id)

3866

self.pull_requests_reviewers_id)

3866

3867

3868

class Notification(Base, BaseModel):

3869

class Notification(Base, BaseModel):

3869

__tablename__ = 'notifications'

3870

__tablename__ = 'notifications'

3870

__table_args__ = (

3871

__table_args__ = (

3871

Index('notification_type_idx', 'type'),

3872

Index('notification_type_idx', 'type'),

3872

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3873

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3873

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3874

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

3874

)

3875

)

3875

3876

TYPE_CHANGESET_COMMENT = u'cs_comment'

3877

TYPE_CHANGESET_COMMENT = u'cs_comment'

3877

TYPE_MESSAGE = u'message'

3878

TYPE_MESSAGE = u'message'

3878

TYPE_MENTION = u'mention'

3879

TYPE_MENTION = u'mention'

3879

TYPE_REGISTRATION = u'registration'

3880

TYPE_REGISTRATION = u'registration'

3880

TYPE_PULL_REQUEST = u'pull_request'

3881

TYPE_PULL_REQUEST = u'pull_request'

3881

TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

3882

TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

3882

3883

notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

3884

notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

3884

subject = Column('subject', Unicode(512), nullable=True)

3885

subject = Column('subject', Unicode(512), nullable=True)

3885

body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)

3886

body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)

3886

created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

3887

created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

3887

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3888

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3888

type_ = Column('type', Unicode(255))

3889

type_ = Column('type', Unicode(255))

3889

3890

created_by_user = relationship('User')

3891

created_by_user = relationship('User')

3891

notifications_to_users = relationship('UserNotification', lazy='joined',

3892

notifications_to_users = relationship('UserNotification', lazy='joined',

3892

cascade="all, delete, delete-orphan")

3893

cascade="all, delete, delete-orphan")

3893

3894

@property

3895

@property

3895

def recipients(self):

3896

def recipients(self):

3896

return [x.user for x in UserNotification.query()\

3897

return [x.user for x in UserNotification.query()\

3897

.filter(UserNotification.notification == self)\

3898

.filter(UserNotification.notification == self)\

3898

.order_by(UserNotification.user_id.asc()).all()]

3899

.order_by(UserNotification.user_id.asc()).all()]

3899

3900

@classmethod

3901

@classmethod

3901

def create(cls, created_by, subject, body, recipients, type_=None):

3902

def create(cls, created_by, subject, body, recipients, type_=None):

3902

if type_ is None:

3903

if type_ is None:

3903

type_ = Notification.TYPE_MESSAGE

3904

type_ = Notification.TYPE_MESSAGE

3904

3905

notification = cls()

3906

notification = cls()

3906

notification.created_by_user = created_by

3907

notification.created_by_user = created_by

3907

notification.subject = subject

3908

notification.subject = subject

3908

notification.body = body

3909

notification.body = body

3909

notification.type_ = type_

3910

notification.type_ = type_

3910

notification.created_on = datetime.datetime.now()

3911

notification.created_on = datetime.datetime.now()

3911

3912

for u in recipients:

3913

for u in recipients:

3913

assoc = UserNotification()

3914

assoc = UserNotification()

3914

assoc.notification = notification

3915

assoc.notification = notification

3915

3916

# if created_by is inside recipients mark his notification

3917

# if created_by is inside recipients mark his notification

3917

# as read

3918

# as read

3918

if u.user_id == created_by.user_id:

3919

if u.user_id == created_by.user_id:

3919

assoc.read = True

3920

assoc.read = True

3920

3921

u.notifications.append(assoc)

3922

u.notifications.append(assoc)

3922

Session().add(notification)

3923

Session().add(notification)

3923

3924

return notification

3925

return notification

3925

3926

3927

class UserNotification(Base, BaseModel):

3928

class UserNotification(Base, BaseModel):

3928

__tablename__ = 'user_to_notification'

3929

__tablename__ = 'user_to_notification'

3929

__table_args__ = (

3930

__table_args__ = (

3930

UniqueConstraint('user_id', 'notification_id'),

3931

UniqueConstraint('user_id', 'notification_id'),

3931

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3932

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3932

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3933

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3933

)

3934

)

3934

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

3935

user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

3935

notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

3936

notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

3936

read = Column('read', Boolean, default=False)

3937

read = Column('read', Boolean, default=False)

3937

sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

3938

sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

3938

3939

user = relationship('User', lazy="joined")

3940

user = relationship('User', lazy="joined")

3940

notification = relationship('Notification', lazy="joined",

3941

notification = relationship('Notification', lazy="joined",

3941

order_by=lambda: Notification.created_on.desc(),)

3942

order_by=lambda: Notification.created_on.desc(),)

3942

3943

def mark_as_read(self):

3944

def mark_as_read(self):

3944

self.read = True

3945

self.read = True

3945

Session().add(self)

3946

Session().add(self)

3946

3947

3948

class Gist(Base, BaseModel):

3949

class Gist(Base, BaseModel):

3949

__tablename__ = 'gists'

3950

__tablename__ = 'gists'

3950

__table_args__ = (

3951

__table_args__ = (

3951

Index('g_gist_access_id_idx', 'gist_access_id'),

3952

Index('g_gist_access_id_idx', 'gist_access_id'),

3952

Index('g_created_on_idx', 'created_on'),

3953

Index('g_created_on_idx', 'created_on'),

3953

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3954

{'extend_existing': True, 'mysql_engine': 'InnoDB',

3954

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3955

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

3955

)

3956

)

3956

GIST_PUBLIC = u'public'

3957

GIST_PUBLIC = u'public'

3957

GIST_PRIVATE = u'private'

3958

GIST_PRIVATE = u'private'

3958

DEFAULT_FILENAME = u'gistfile1.txt'

3959

DEFAULT_FILENAME = u'gistfile1.txt'

3959

3960

ACL_LEVEL_PUBLIC = u'acl_public'

3961

ACL_LEVEL_PUBLIC = u'acl_public'

3961

ACL_LEVEL_PRIVATE = u'acl_private'

3962

ACL_LEVEL_PRIVATE = u'acl_private'

3962

3963

gist_id = Column('gist_id', Integer(), primary_key=True)

3964

gist_id = Column('gist_id', Integer(), primary_key=True)

3964

gist_access_id = Column('gist_access_id', Unicode(250))

3965

gist_access_id = Column('gist_access_id', Unicode(250))

3965

gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

3966

gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))

3966

gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)

3967

gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)

3967

gist_expires = Column('gist_expires', Float(53), nullable=False)

3968

gist_expires = Column('gist_expires', Float(53), nullable=False)

3968

gist_type = Column('gist_type', Unicode(128), nullable=False)

3969

gist_type = Column('gist_type', Unicode(128), nullable=False)

3969

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3970

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3970

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3971

modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

3971

acl_level = Column('acl_level', Unicode(128), nullable=True)

3972

acl_level = Column('acl_level', Unicode(128), nullable=True)

3972

3973

owner = relationship('User')

3974

owner = relationship('User')

3974

3975

def __repr__(self):

3976

def __repr__(self):

3976

return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

3977

return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

3977

3978

@hybrid_property

3979

@hybrid_property

3979

def description_safe(self):

3980

def description_safe(self):

3980

from rhodecode.lib import helpers as h

3981

from rhodecode.lib import helpers as h

3981

return h.escape(self.gist_description)

3982

return h.escape(self.gist_description)

3982

3983

@classmethod

3984

@classmethod

3984

def get_or_404(cls, id_):

3985

def get_or_404(cls, id_):

3985

from pyramid.httpexceptions import HTTPNotFound

3986

from pyramid.httpexceptions import HTTPNotFound

3986

3987

res = cls.query().filter(cls.gist_access_id == id_).scalar()

3988

res = cls.query().filter(cls.gist_access_id == id_).scalar()

3988

if not res:

3989

if not res:

3989

raise HTTPNotFound()

3990

raise HTTPNotFound()

3990

return res

3991

return res

3991

3992

@classmethod

3993

@classmethod

3993

def get_by_access_id(cls, gist_access_id):

3994

def get_by_access_id(cls, gist_access_id):

3994

return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

3995

return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

3995

3996

def gist_url(self):

3997

def gist_url(self):

3997

from rhodecode.model.gist import GistModel

3998

from rhodecode.model.gist import GistModel

3998

return GistModel().get_url(self)

3999

return GistModel().get_url(self)

3999

4000

@classmethod

4001

@classmethod

4001

def base_path(cls):

4002

def base_path(cls):

4002

"""

4003

"""

4003

Returns base path when all gists are stored

4004

Returns base path when all gists are stored

4004

4005

:param cls:

4006

:param cls:

4006

"""

4007

"""

4007

from rhodecode.model.gist import GIST_STORE_LOC

4008

from rhodecode.model.gist import GIST_STORE_LOC

4008

q = Session().query(RhodeCodeUi)\

4009

q = Session().query(RhodeCodeUi)\

4009

.filter(RhodeCodeUi.ui_key == URL_SEP)

4010

.filter(RhodeCodeUi.ui_key == URL_SEP)

4010

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

4011

q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

4011

return os.path.join(q.one().ui_value, GIST_STORE_LOC)

4012

return os.path.join(q.one().ui_value, GIST_STORE_LOC)

4012

4013

def get_api_data(self):

4014

def get_api_data(self):

4014

"""

4015

"""

4015

Common function for generating gist related data for API

4016

Common function for generating gist related data for API

4016

"""

4017

"""

4017

gist = self

4018

gist = self

4018

data = {

4019

data = {

4019

'gist_id': gist.gist_id,

4020

'gist_id': gist.gist_id,

4020

'type': gist.gist_type,

4021

'type': gist.gist_type,

4021

'access_id': gist.gist_access_id,

4022

'access_id': gist.gist_access_id,

4022

'description': gist.gist_description,

4023

'description': gist.gist_description,

4023

'url': gist.gist_url(),

4024

'url': gist.gist_url(),

4024

'expires': gist.gist_expires,

4025

'expires': gist.gist_expires,

4025

'created_on': gist.created_on,

4026

'created_on': gist.created_on,

4026

'modified_at': gist.modified_at,

4027

'modified_at': gist.modified_at,

4027

'content': None,

4028

'content': None,

4028

'acl_level': gist.acl_level,

4029

'acl_level': gist.acl_level,

4029

}

4030

}

4030

return data

4031

return data

4031

4032

def __json__(self):

4033

def __json__(self):

4033

data = dict(

4034

data = dict(

4034

)

4035

)

4035

data.update(self.get_api_data())

4036

data.update(self.get_api_data())

4036

return data

4037

return data

4037

# SCM functions

4038

# SCM functions

4038

4039

def scm_instance(self, **kwargs):

4040

def scm_instance(self, **kwargs):

4040

full_repo_path = os.path.join(self.base_path(), self.gist_access_id)

4041

full_repo_path = os.path.join(self.base_path(), self.gist_access_id)

4041

return get_vcs_instance(

4042

return get_vcs_instance(

4042

repo_path=safe_str(full_repo_path), create=False)

4043

repo_path=safe_str(full_repo_path), create=False)

4043

4044

4045

class ExternalIdentity(Base, BaseModel):

4046

class ExternalIdentity(Base, BaseModel):

4046

__tablename__ = 'external_identities'

4047

__tablename__ = 'external_identities'

4047

__table_args__ = (

4048

__table_args__ = (

4048

Index('local_user_id_idx', 'local_user_id'),

4049

Index('local_user_id_idx', 'local_user_id'),

4049

Index('external_id_idx', 'external_id'),

4050

Index('external_id_idx', 'external_id'),

4050

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4051

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4051

'mysql_charset': 'utf8'})

4052

'mysql_charset': 'utf8'})

4052

4053

external_id = Column('external_id', Unicode(255), default=u'',

4054

external_id = Column('external_id', Unicode(255), default=u'',

4054

primary_key=True)

4055

primary_key=True)

4055

external_username = Column('external_username', Unicode(1024), default=u'')

4056

external_username = Column('external_username', Unicode(1024), default=u'')

4056

local_user_id = Column('local_user_id', Integer(),

4057

local_user_id = Column('local_user_id', Integer(),

4057

ForeignKey('users.user_id'), primary_key=True)

4058

ForeignKey('users.user_id'), primary_key=True)

4058

provider_name = Column('provider_name', Unicode(255), default=u'',

4059

provider_name = Column('provider_name', Unicode(255), default=u'',

4059

primary_key=True)

4060

primary_key=True)

4060

access_token = Column('access_token', String(1024), default=u'')

4061

access_token = Column('access_token', String(1024), default=u'')

4061

alt_token = Column('alt_token', String(1024), default=u'')

4062

alt_token = Column('alt_token', String(1024), default=u'')

4062

token_secret = Column('token_secret', String(1024), default=u'')

4063

token_secret = Column('token_secret', String(1024), default=u'')

4063

4064

@classmethod

4065

@classmethod

4065

def by_external_id_and_provider(cls, external_id, provider_name,

4066

def by_external_id_and_provider(cls, external_id, provider_name,

4066

local_user_id=None):

4067

local_user_id=None):

4067

"""

4068

"""

4068

Returns ExternalIdentity instance based on search params

4069

Returns ExternalIdentity instance based on search params

4069

4070

:param external_id:

4071

:param external_id:

4071

:param provider_name:

4072

:param provider_name:

4072

:return: ExternalIdentity

4073

:return: ExternalIdentity

4073

"""

4074

"""

4074

query = cls.query()

4075

query = cls.query()

4075

query = query.filter(cls.external_id == external_id)

4076

query = query.filter(cls.external_id == external_id)

4076

query = query.filter(cls.provider_name == provider_name)

4077

query = query.filter(cls.provider_name == provider_name)

4077

if local_user_id:

4078

if local_user_id:

4078

query = query.filter(cls.local_user_id == local_user_id)

4079

query = query.filter(cls.local_user_id == local_user_id)

4079

return query.first()

4080

return query.first()

4080

4081

@classmethod

4082

@classmethod

4082

def user_by_external_id_and_provider(cls, external_id, provider_name):

4083

def user_by_external_id_and_provider(cls, external_id, provider_name):

4083

"""

4084

"""

4084

Returns User instance based on search params

4085

Returns User instance based on search params

4085

4086

:param external_id:

4087

:param external_id:

4087

:param provider_name:

4088

:param provider_name:

4088

:return: User

4089

:return: User

4089

"""

4090

"""

4090

query = User.query()

4091

query = User.query()

4091

query = query.filter(cls.external_id == external_id)

4092

query = query.filter(cls.external_id == external_id)

4092

query = query.filter(cls.provider_name == provider_name)

4093

query = query.filter(cls.provider_name == provider_name)

4093

query = query.filter(User.user_id == cls.local_user_id)

4094

query = query.filter(User.user_id == cls.local_user_id)

4094

return query.first()

4095

return query.first()

4095

4096

@classmethod

4097

@classmethod

4097

def by_local_user_id(cls, local_user_id):

4098

def by_local_user_id(cls, local_user_id):

4098

"""

4099

"""

4099

Returns all tokens for user

4100

Returns all tokens for user

4100

4101

:param local_user_id:

4102

:param local_user_id:

4102

:return: ExternalIdentity

4103

:return: ExternalIdentity

4103

"""

4104

"""

4104

query = cls.query()

4105

query = cls.query()

4105

query = query.filter(cls.local_user_id == local_user_id)

4106

query = query.filter(cls.local_user_id == local_user_id)

4106

return query

4107

return query

4107

4108

4109

class Integration(Base, BaseModel):

4110

class Integration(Base, BaseModel):

4110

__tablename__ = 'integrations'

4111

__tablename__ = 'integrations'

4111

__table_args__ = (

4112

__table_args__ = (

4112

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4113

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4113

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

4114

'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

4114

)

4115

)

4115

4116

integration_id = Column('integration_id', Integer(), primary_key=True)

4117

integration_id = Column('integration_id', Integer(), primary_key=True)

4117

integration_type = Column('integration_type', String(255))

4118

integration_type = Column('integration_type', String(255))

4118

enabled = Column('enabled', Boolean(), nullable=False)

4119

enabled = Column('enabled', Boolean(), nullable=False)

4119

name = Column('name', String(255), nullable=False)

4120

name = Column('name', String(255), nullable=False)

4120

child_repos_only = Column('child_repos_only', Boolean(), nullable=False,

4121

child_repos_only = Column('child_repos_only', Boolean(), nullable=False,

4121

default=False)

4122

default=False)

4122

4123

settings = Column(

4124

settings = Column(

4124

'settings_json', MutationObj.as_mutable(

4125

'settings_json', MutationObj.as_mutable(

4125

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

4126

JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))

4126

repo_id = Column(

4127

repo_id = Column(

4127

'repo_id', Integer(), ForeignKey('repositories.repo_id'),

4128

'repo_id', Integer(), ForeignKey('repositories.repo_id'),

4128

nullable=True, unique=None, default=None)

4129

nullable=True, unique=None, default=None)

4129

repo = relationship('Repository', lazy='joined')

4130

repo = relationship('Repository', lazy='joined')

4130

4131

repo_group_id = Column(

4132

repo_group_id = Column(

4132

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

4133

'repo_group_id', Integer(), ForeignKey('groups.group_id'),

4133

nullable=True, unique=None, default=None)

4134

nullable=True, unique=None, default=None)

4134

repo_group = relationship('RepoGroup', lazy='joined')

4135

repo_group = relationship('RepoGroup', lazy='joined')

4135

4136

@property

4137

@property

4137

def scope(self):

4138

def scope(self):

4138

if self.repo:

4139

if self.repo:

4139

return repr(self.repo)

4140

return repr(self.repo)

4140

if self.repo_group:

4141

if self.repo_group:

4141

if self.child_repos_only:

4142

if self.child_repos_only:

4142

return repr(self.repo_group) + ' (child repos only)'

4143

return repr(self.repo_group) + ' (child repos only)'

4143

else:

4144

else:

4144

return repr(self.repo_group) + ' (recursive)'

4145

return repr(self.repo_group) + ' (recursive)'

4145

if self.child_repos_only:

4146

if self.child_repos_only:

4146

return 'root_repos'

4147

return 'root_repos'

4147

return 'global'

4148

return 'global'

4148

4149

def __repr__(self):

4150

def __repr__(self):

4150

return '<Integration(%r, %r)>' % (self.integration_type, self.scope)

4151

return '<Integration(%r, %r)>' % (self.integration_type, self.scope)

4151

4152

4153

class RepoReviewRuleUser(Base, BaseModel):

4154

class RepoReviewRuleUser(Base, BaseModel):

4154

__tablename__ = 'repo_review_rules_users'

4155

__tablename__ = 'repo_review_rules_users'

4155

__table_args__ = (

4156

__table_args__ = (

4156

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4157

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4157

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4158

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4158

)

4159

)

4159

4160

repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)

4161

repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)

4161

repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

4162

repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

4162

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)

4163

user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)

4163

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

4164

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

4164

user = relationship('User')

4165

user = relationship('User')

4165

4166

def rule_data(self):

4167

def rule_data(self):

4167

return {

4168

return {

4168

'mandatory': self.mandatory

4169

'mandatory': self.mandatory

4169

}

4170

}

4170

4171

4172

class RepoReviewRuleUserGroup(Base, BaseModel):

4173

class RepoReviewRuleUserGroup(Base, BaseModel):

4173

__tablename__ = 'repo_review_rules_users_groups'

4174

__tablename__ = 'repo_review_rules_users_groups'

4174

__table_args__ = (

4175

__table_args__ = (

4175

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4176

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4176

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4177

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4177

)

4178

)

4178

VOTE_RULE_ALL = -1

4179

VOTE_RULE_ALL = -1

4179

4180

repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)

4181

repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)

4181

repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

4182

repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))

4182

users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)

4183

users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)

4183

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

4184

mandatory = Column("mandatory", Boolean(), nullable=False, default=False)

4184

vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)

4185

vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)

4185

users_group = relationship('UserGroup')

4186

users_group = relationship('UserGroup')

4186

4187

def rule_data(self):

4188

def rule_data(self):

4188

return {

4189

return {

4189

'mandatory': self.mandatory,

4190

'mandatory': self.mandatory,

4190

'vote_rule': self.vote_rule

4191

'vote_rule': self.vote_rule

4191

}

4192

}

4192

4193

@property

4194

@property

4194

def vote_rule_label(self):

4195

def vote_rule_label(self):

4195

if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:

4196

if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:

4196

return 'all must vote'

4197

return 'all must vote'

4197

else:

4198

else:

4198

return 'min. vote {}'.format(self.vote_rule)

4199

return 'min. vote {}'.format(self.vote_rule)

4199

4200

4201

class RepoReviewRule(Base, BaseModel):

4202

class RepoReviewRule(Base, BaseModel):

4202

__tablename__ = 'repo_review_rules'

4203

__tablename__ = 'repo_review_rules'

4203

__table_args__ = (

4204

__table_args__ = (

4204

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4205

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4205

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4206

'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}

4206

)

4207

)

4207

4208

repo_review_rule_id = Column(

4209

repo_review_rule_id = Column(

4209

'repo_review_rule_id', Integer(), primary_key=True)

4210

'repo_review_rule_id', Integer(), primary_key=True)

4210

repo_id = Column(

4211

repo_id = Column(

4211

"repo_id", Integer(), ForeignKey('repositories.repo_id'))

4212

"repo_id", Integer(), ForeignKey('repositories.repo_id'))

4212

repo = relationship('Repository', backref='review_rules')

4213

repo = relationship('Repository', backref='review_rules')

4213

4214

review_rule_name = Column('review_rule_name', String(255))

4215

review_rule_name = Column('review_rule_name', String(255))

4215

_branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4216

_branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4216

_target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4217

_target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4217

_file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4218

_file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob

4218

4219

use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)

4220

use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)

4220

forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)

4221

forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)

4221

forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)

4222

forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)

4222

forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)

4223

forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)

4223

4224

rule_users = relationship('RepoReviewRuleUser')

4225

rule_users = relationship('RepoReviewRuleUser')

4225

rule_user_groups = relationship('RepoReviewRuleUserGroup')

4226

rule_user_groups = relationship('RepoReviewRuleUserGroup')

4226

4227

def _validate_glob(self, value):

4228

def _validate_glob(self, value):

4228

re.compile('^' + glob2re(value) + '$')

4229

re.compile('^' + glob2re(value) + '$')

4229

4230

@hybrid_property

4231

@hybrid_property

4231

def source_branch_pattern(self):

4232

def source_branch_pattern(self):

4232

return self._branch_pattern or '*'

4233

return self._branch_pattern or '*'

4233

4234

@source_branch_pattern.setter

4235

@source_branch_pattern.setter

4235

def source_branch_pattern(self, value):

4236

def source_branch_pattern(self, value):

4236

self._validate_glob(value)

4237

self._validate_glob(value)

4237

self._branch_pattern = value or '*'

4238

self._branch_pattern = value or '*'

4238

4239

@hybrid_property

4240

@hybrid_property

4240

def target_branch_pattern(self):

4241

def target_branch_pattern(self):

4241

return self._target_branch_pattern or '*'

4242

return self._target_branch_pattern or '*'

4242

4243

@target_branch_pattern.setter

4244

@target_branch_pattern.setter

4244

def target_branch_pattern(self, value):

4245

def target_branch_pattern(self, value):

4245

self._validate_glob(value)

4246

self._validate_glob(value)

4246

self._target_branch_pattern = value or '*'

4247

self._target_branch_pattern = value or '*'

4247

4248

@hybrid_property

4249

@hybrid_property

4249

def file_pattern(self):

4250

def file_pattern(self):

4250

return self._file_pattern or '*'

4251

return self._file_pattern or '*'

4251

4252

@file_pattern.setter

4253

@file_pattern.setter

4253

def file_pattern(self, value):

4254

def file_pattern(self, value):

4254

self._validate_glob(value)

4255

self._validate_glob(value)

4255

self._file_pattern = value or '*'

4256

self._file_pattern = value or '*'

4256

4257

def matches(self, source_branch, target_branch, files_changed):

4258

def matches(self, source_branch, target_branch, files_changed):

4258

"""

4259

"""

4259

Check if this review rule matches a branch/files in a pull request

4260

Check if this review rule matches a branch/files in a pull request

4260

4261

:param source_branch: source branch name for the commit

4262

:param source_branch: source branch name for the commit

4262

:param target_branch: target branch name for the commit

4263

:param target_branch: target branch name for the commit

4263

:param files_changed: list of file paths changed in the pull request

4264

:param files_changed: list of file paths changed in the pull request

4264

"""

4265

"""

4265

4266

source_branch = source_branch or ''

4267

source_branch = source_branch or ''

4267

target_branch = target_branch or ''

4268

target_branch = target_branch or ''

4268

files_changed = files_changed or []

4269

files_changed = files_changed or []

4269

4270

branch_matches = True

4271

branch_matches = True

4271

if source_branch or target_branch:

4272

if source_branch or target_branch:

4272

if self.source_branch_pattern == '*':

4273

if self.source_branch_pattern == '*':

4273

source_branch_match = True

4274

source_branch_match = True

4274

else:

4275

else:

4275

source_branch_regex = re.compile(

4276

source_branch_regex = re.compile(

4276

'^' + glob2re(self.source_branch_pattern) + '$')

4277

'^' + glob2re(self.source_branch_pattern) + '$')

4277

source_branch_match = bool(source_branch_regex.search(source_branch))

4278

source_branch_match = bool(source_branch_regex.search(source_branch))

4278

if self.target_branch_pattern == '*':

4279

if self.target_branch_pattern == '*':

4279

target_branch_match = True

4280

target_branch_match = True

4280

else:

4281

else:

4281

target_branch_regex = re.compile(

4282

target_branch_regex = re.compile(

4282

'^' + glob2re(self.target_branch_pattern) + '$')

4283

'^' + glob2re(self.target_branch_pattern) + '$')

4283

target_branch_match = bool(target_branch_regex.search(target_branch))

4284

target_branch_match = bool(target_branch_regex.search(target_branch))

4284

4285

branch_matches = source_branch_match and target_branch_match

4286

branch_matches = source_branch_match and target_branch_match

4286

4287

files_matches = True

4288

files_matches = True

4288

if self.file_pattern != '*':

4289

if self.file_pattern != '*':

4289

files_matches = False

4290

files_matches = False

4290

file_regex = re.compile(glob2re(self.file_pattern))

4291

file_regex = re.compile(glob2re(self.file_pattern))

4291

for filename in files_changed:

4292

for filename in files_changed:

4292

if file_regex.search(filename):

4293

if file_regex.search(filename):

4293

files_matches = True

4294

files_matches = True

4294

break

4295

break

4295

4296

return branch_matches and files_matches

4297

return branch_matches and files_matches

4297

4298

@property

4299

@property

4299

def review_users(self):

4300

def review_users(self):

4300

""" Returns the users which this rule applies to """

4301

""" Returns the users which this rule applies to """

4301

4302

users = collections.OrderedDict()

4303

users = collections.OrderedDict()

4303

4304

for rule_user in self.rule_users:

4305

for rule_user in self.rule_users:

4305

if rule_user.user.active:

4306

if rule_user.user.active:

4306

if rule_user.user not in users:

4307

if rule_user.user not in users:

4307

users[rule_user.user.username] = {

4308

users[rule_user.user.username] = {

4308

'user': rule_user.user,

4309

'user': rule_user.user,

4309

'source': 'user',

4310

'source': 'user',

4310

'source_data': {},

4311

'source_data': {},

4311

'data': rule_user.rule_data()

4312

'data': rule_user.rule_data()

4312

}

4313

}

4313

4314

for rule_user_group in self.rule_user_groups:

4315

for rule_user_group in self.rule_user_groups:

4315

source_data = {

4316

source_data = {

4316

'user_group_id': rule_user_group.users_group.users_group_id,

4317

'user_group_id': rule_user_group.users_group.users_group_id,

4317

'name': rule_user_group.users_group.users_group_name,

4318

'name': rule_user_group.users_group.users_group_name,

4318

'members': len(rule_user_group.users_group.members)

4319

'members': len(rule_user_group.users_group.members)

4319

}

4320

}

4320

for member in rule_user_group.users_group.members:

4321

for member in rule_user_group.users_group.members:

4321

if member.user.active:

4322

if member.user.active:

4322

key = member.user.username

4323

key = member.user.username

4323

if key in users:

4324

if key in users:

4324

# skip this member as we have him already

4325

# skip this member as we have him already

4325

# this prevents from override the "first" matched

4326

# this prevents from override the "first" matched

4326

# users with duplicates in multiple groups

4327

# users with duplicates in multiple groups

4327

continue

4328

continue

4328

4329

users[key] = {

4330

users[key] = {

4330

'user': member.user,

4331

'user': member.user,

4331

'source': 'user_group',

4332

'source': 'user_group',

4332

'source_data': source_data,

4333

'source_data': source_data,

4333

'data': rule_user_group.rule_data()

4334

'data': rule_user_group.rule_data()

4334

}

4335

}

4335

4336

return users

4337

return users

4337

4338

def user_group_vote_rule(self):

4339

def user_group_vote_rule(self):

4339

rules = []

4340

rules = []

4340

if self.rule_user_groups:

4341

if self.rule_user_groups:

4341

for user_group in self.rule_user_groups:

4342

for user_group in self.rule_user_groups:

4342

rules.append(user_group)

4343

rules.append(user_group)

4343

return rules

4344

return rules

4344

4345

def __repr__(self):

4346

def __repr__(self):

4346

return '<RepoReviewerRule(id=%r, repo=%r)>' % (

4347

return '<RepoReviewerRule(id=%r, repo=%r)>' % (

4347

self.repo_review_rule_id, self.repo)

4348

self.repo_review_rule_id, self.repo)

4348

4349

4350

class ScheduleEntry(Base, BaseModel):

4351

class ScheduleEntry(Base, BaseModel):

4351

__tablename__ = 'schedule_entries'

4352

__tablename__ = 'schedule_entries'

4352

__table_args__ = (

4353

__table_args__ = (

4353

UniqueConstraint('schedule_name', name='s_schedule_name_idx'),

4354

UniqueConstraint('schedule_name', name='s_schedule_name_idx'),

4354

UniqueConstraint('task_uid', name='s_task_uid_idx'),

4355

UniqueConstraint('task_uid', name='s_task_uid_idx'),

4355

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4356

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4356

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4357

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4357

)

4358

)

4358

schedule_types = ['crontab', 'timedelta', 'integer']

4359

schedule_types = ['crontab', 'timedelta', 'integer']

4359

schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)

4360

schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)

4360

4361

schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)

4362

schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)

4362

schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)

4363

schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)

4363

schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)

4364

schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)

4364

4365

_schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)

4366

_schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)

4366

schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))

4367

schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))

4367

4368

schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)

4369

schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)

4369

schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)

4370

schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)

4370

4371

# task

4372

# task

4372

task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)

4373

task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)

4373

task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)

4374

task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)

4374

task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))

4375

task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))

4375

task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))

4376

task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))

4376

4377

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

4378

created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

4378

updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)

4379

updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)

4379

4380

@hybrid_property

4381

@hybrid_property

4381

def schedule_type(self):

4382

def schedule_type(self):

4382

return self._schedule_type

4383

return self._schedule_type

4383

4384

@schedule_type.setter

4385

@schedule_type.setter

4385

def schedule_type(self, val):

4386

def schedule_type(self, val):

4386

if val not in self.schedule_types:

4387

if val not in self.schedule_types:

4387

raise ValueError('Value must be on of `{}` and got `{}`'.format(

4388

raise ValueError('Value must be on of `{}` and got `{}`'.format(

4388

val, self.schedule_type))

4389

val, self.schedule_type))

4389

4390

self._schedule_type = val

4391

self._schedule_type = val

4391

4392

@classmethod

4393

@classmethod

4393

def get_uid(cls, obj):

4394

def get_uid(cls, obj):

4394

args = obj.task_args

4395

args = obj.task_args

4395

kwargs = obj.task_kwargs

4396

kwargs = obj.task_kwargs

4396

if isinstance(args, JsonRaw):

4397

if isinstance(args, JsonRaw):

4397

try:

4398

try:

4398

args = json.loads(args)

4399

args = json.loads(args)

4399

except ValueError:

4400

except ValueError:

4400

args = tuple()

4401

args = tuple()

4401

4402

if isinstance(kwargs, JsonRaw):

4403

if isinstance(kwargs, JsonRaw):

4403

try:

4404

try:

4404

kwargs = json.loads(kwargs)

4405

kwargs = json.loads(kwargs)

4405

except ValueError:

4406

except ValueError:

4406

kwargs = dict()

4407

kwargs = dict()

4407

4408

dot_notation = obj.task_dot_notation

4409

dot_notation = obj.task_dot_notation

4409

val = '.'.join(map(safe_str, [

4410

val = '.'.join(map(safe_str, [

4410

sorted(dot_notation), args, sorted(kwargs.items())]))

4411

sorted(dot_notation), args, sorted(kwargs.items())]))

4411

return hashlib.sha1(val).hexdigest()

4412

return hashlib.sha1(val).hexdigest()

4412

4413

@classmethod

4414

@classmethod

4414

def get_by_schedule_name(cls, schedule_name):

4415

def get_by_schedule_name(cls, schedule_name):

4415

return cls.query().filter(cls.schedule_name == schedule_name).scalar()

4416

return cls.query().filter(cls.schedule_name == schedule_name).scalar()

4416

4417

@classmethod

4418

@classmethod

4418

def get_by_schedule_id(cls, schedule_id):

4419

def get_by_schedule_id(cls, schedule_id):

4419

return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()

4420

return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()

4420

4421

@property

4422

@property

4422

def task(self):

4423

def task(self):

4423

return self.task_dot_notation

4424

return self.task_dot_notation

4424

4425

@property

4426

@property

4426

def schedule(self):

4427

def schedule(self):

4427

from rhodecode.lib.celerylib.utils import raw_2_schedule

4428

from rhodecode.lib.celerylib.utils import raw_2_schedule

4428

schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)

4429

schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)

4429

return schedule

4430

return schedule

4430

4431

@property

4432

@property

4432

def args(self):

4433

def args(self):

4433

try:

4434

try:

4434

return list(self.task_args or [])

4435

return list(self.task_args or [])

4435

except ValueError:

4436

except ValueError:

4436

return list()

4437

return list()

4437

4438

@property

4439

@property

4439

def kwargs(self):

4440

def kwargs(self):

4440

try:

4441

try:

4441

return dict(self.task_kwargs or {})

4442

return dict(self.task_kwargs or {})

4442

except ValueError:

4443

except ValueError:

4443

return dict()

4444

return dict()

4444

4445

def _as_raw(self, val):

4446

def _as_raw(self, val):

4446

if hasattr(val, 'de_coerce'):

4447

if hasattr(val, 'de_coerce'):

4447

val = val.de_coerce()

4448

val = val.de_coerce()

4448

if val:

4449

if val:

4449

val = json.dumps(val)

4450

val = json.dumps(val)

4450

4451

return val

4452

return val

4452

4453

@property

4454

@property

4454

def schedule_definition_raw(self):

4455

def schedule_definition_raw(self):

4455

return self._as_raw(self.schedule_definition)

4456

return self._as_raw(self.schedule_definition)

4456

4457

@property

4458

@property

4458

def args_raw(self):

4459

def args_raw(self):

4459

return self._as_raw(self.task_args)

4460

return self._as_raw(self.task_args)

4460

4461

@property

4462

@property

4462

def kwargs_raw(self):

4463

def kwargs_raw(self):

4463

return self._as_raw(self.task_kwargs)

4464

return self._as_raw(self.task_kwargs)

4464

4465

def __repr__(self):

4466

def __repr__(self):

4466

return '<DB:ScheduleEntry({}:{})>'.format(

4467

return '<DB:ScheduleEntry({}:{})>'.format(

4467

self.schedule_entry_id, self.schedule_name)

4468

self.schedule_entry_id, self.schedule_name)

4468

4469

4470

@event.listens_for(ScheduleEntry, 'before_update')

4471

@event.listens_for(ScheduleEntry, 'before_update')

4471

def update_task_uid(mapper, connection, target):

4472

def update_task_uid(mapper, connection, target):

4472

target.task_uid = ScheduleEntry.get_uid(target)

4473

target.task_uid = ScheduleEntry.get_uid(target)

4473

4474

4475

@event.listens_for(ScheduleEntry, 'before_insert')

4476

@event.listens_for(ScheduleEntry, 'before_insert')

4476

def set_task_uid(mapper, connection, target):

4477

def set_task_uid(mapper, connection, target):

4477

target.task_uid = ScheduleEntry.get_uid(target)

4478

target.task_uid = ScheduleEntry.get_uid(target)

4478

4479

4480

class DbMigrateVersion(Base, BaseModel):

4481

class DbMigrateVersion(Base, BaseModel):

4481

__tablename__ = 'db_migrate_version'

4482

__tablename__ = 'db_migrate_version'

4482

__table_args__ = (

4483

__table_args__ = (

4483

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4484

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4484

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4485

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4485

)

4486

)

4486

repository_id = Column('repository_id', String(250), primary_key=True)

4487

repository_id = Column('repository_id', String(250), primary_key=True)

4487

repository_path = Column('repository_path', Text)

4488

repository_path = Column('repository_path', Text)

4488

version = Column('version', Integer)

4489

version = Column('version', Integer)

4489

4490

4491

class DbSession(Base, BaseModel):

4492

class DbSession(Base, BaseModel):

4492

__tablename__ = 'db_session'

4493

__tablename__ = 'db_session'

4493

__table_args__ = (

4494

__table_args__ = (

4494

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4495

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4495

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4496

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4496

)

4497

)

4497

4498

def __repr__(self):

4499

def __repr__(self):

4499

return '<DB:DbSession({})>'.format(self.id)

4500

return '<DB:DbSession({})>'.format(self.id)

4500

4501

id = Column('id', Integer())

4502

id = Column('id', Integer())

4502

namespace = Column('namespace', String(255), primary_key=True)

4503

namespace = Column('namespace', String(255), primary_key=True)

4503

accessed = Column('accessed', DateTime, nullable=False)

4504

accessed = Column('accessed', DateTime, nullable=False)

4504

created = Column('created', DateTime, nullable=False)

4505

created = Column('created', DateTime, nullable=False)

4505

data = Column('data', PickleType, nullable=False)

4506

data = Column('data', PickleType, nullable=False)

4506

4507

4508

4509

class BeakerCache(Base, BaseModel):

4510

class BeakerCache(Base, BaseModel):

4510

__tablename__ = 'beaker_cache'

4511

__tablename__ = 'beaker_cache'

4511

__table_args__ = (

4512

__table_args__ = (

4512

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4513

{'extend_existing': True, 'mysql_engine': 'InnoDB',

4513

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4514

'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

4514

)

4515

)

4515

4516

def __repr__(self):

4517

def __repr__(self):

4517

return '<DB:DbSession({})>'.format(self.id)

4518

return '<DB:DbSession({})>'.format(self.id)

4518

4519

id = Column('id', Integer())

4520

id = Column('id', Integer())

4520

namespace = Column('namespace', String(255), primary_key=True)

4521

namespace = Column('namespace', String(255), primary_key=True)

4521

accessed = Column('accessed', DateTime, nullable=False)

4522

accessed = Column('accessed', DateTime, nullable=False)

4522

created = Column('created', DateTime, nullable=False)

4523

created = Column('created', DateTime, nullable=False)

4523

data = Column('data', PickleType, nullable=False)

4524

data = Column('data', PickleType, nullable=False)

	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-2018 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
             import collections
             import formencode
             import formencode.htmlfill
             import peppercorn
             from pyramid.httpexceptions import (
                 HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest)
             from pyramid.view import view_config
             from pyramid.renderers import render
             from rhodecode import events
             from rhodecode.apps._base import RepoAppView, DataGridAppView
             from rhodecode.lib import helpers as h, diffs, codeblocks, channelstream
             from rhodecode.lib.base import vcs_operation_context
             from rhodecode.lib.diffs import load_cached_diff, cache_diff, diff_cache_exist
             from rhodecode.lib.ext_json import json
             from rhodecode.lib.auth import (
                 LoginRequired, HasRepoPermissionAny, HasRepoPermissionAnyDecorator,
                 NotAnonymous, CSRFRequired)
             from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode
             from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
             from rhodecode.lib.vcs.exceptions import (CommitDoesNotExistError,
                 RepositoryRequirementError, EmptyRepositoryError)
             from rhodecode.model.changeset_status import ChangesetStatusModel
             from rhodecode.model.comment import CommentsModel
             from rhodecode.model.db import (func, or_, PullRequest, PullRequestVersion,
                 ChangesetComment, ChangesetStatus, Repository)
             from rhodecode.model.forms import PullRequestForm
             from rhodecode.model.meta import Session
             from rhodecode.model.pull_request import PullRequestModel, MergeCheck
             from rhodecode.model.scm import ScmModel
             log = logging.getLogger(__name__)
             class RepoPullRequestsView(RepoAppView, DataGridAppView):
                 def load_default_context(self):
                     c = self._get_local_tmpl_context(include_app_defaults=True)
                     c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
                     c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
                     return c
                 def _get_pull_requests_list(
                         self, repo_name, source, filter_type, opened_by, statuses):
                     draw, start, limit = self._extract_chunk(self.request)
                     search_q, order_by, order_dir = self._extract_ordering(self.request)
                     _render = self.request.get_partial_renderer(
                         'rhodecode:templates/data_table/_dt_elements.mako')
                     # pagination
                     if filter_type == 'awaiting_review':
                         pull_requests = PullRequestModel().get_awaiting_review(
                             repo_name, source=source, opened_by=opened_by,
                             statuses=statuses, offset=start, length=limit,
                             order_by=order_by, order_dir=order_dir)
                         pull_requests_total_count = PullRequestModel().count_awaiting_review(
                             repo_name, source=source, statuses=statuses,
                             opened_by=opened_by)
                     elif filter_type == 'awaiting_my_review':
                         pull_requests = PullRequestModel().get_awaiting_my_review(
                             repo_name, source=source, opened_by=opened_by,
                             user_id=self._rhodecode_user.user_id, statuses=statuses,
                             offset=start, length=limit, order_by=order_by,
                             order_dir=order_dir)
                         pull_requests_total_count = PullRequestModel().count_awaiting_my_review(
                             repo_name, source=source, user_id=self._rhodecode_user.user_id,
                             statuses=statuses, opened_by=opened_by)
                     else:
                         pull_requests = PullRequestModel().get_all(
                             repo_name, source=source, opened_by=opened_by,
                             statuses=statuses, offset=start, length=limit,
                             order_by=order_by, order_dir=order_dir)
                         pull_requests_total_count = PullRequestModel().count_all(
                             repo_name, source=source, statuses=statuses,
                             opened_by=opened_by)
                     data = []
                     comments_model = CommentsModel()
                     for pr in pull_requests:
                         comments = comments_model.get_all_comments(
                             self.db_repo.repo_id, pull_request=pr)
                         data.append({
                             'name': _render('pullrequest_name',
                                             pr.pull_request_id, pr.target_repo.repo_name),
                             'name_raw': pr.pull_request_id,
                             'status': _render('pullrequest_status',
                                               pr.calculated_review_status()),
                             'title': _render(
                                 'pullrequest_title', pr.title, pr.description),
                             'description': h.escape(pr.description),
                             'updated_on': _render('pullrequest_updated_on',
                                                   h.datetime_to_time(pr.updated_on)),
                             'updated_on_raw': h.datetime_to_time(pr.updated_on),
                             'created_on': _render('pullrequest_updated_on',
                                                   h.datetime_to_time(pr.created_on)),
                             'created_on_raw': h.datetime_to_time(pr.created_on),
                             'author': _render('pullrequest_author',
                                               pr.author.full_contact, ),
                             'author_raw': pr.author.full_name,
                             'comments': _render('pullrequest_comments', len(comments)),
                             'comments_raw': len(comments),
                             'closed': pr.is_closed(),
                         })
                     data = ({
                         'draw': draw,
                         'data': data,
                         'recordsTotal': pull_requests_total_count,
                         'recordsFiltered': pull_requests_total_count,
                     })
                     return data
                 @LoginRequired()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_show_all', request_method='GET',
                     renderer='rhodecode:templates/pullrequests/pullrequests.mako')
                 def pull_request_list(self):
                     c = self.load_default_context()
                     req_get = self.request.GET
                     c.source = str2bool(req_get.get('source'))
                     c.closed = str2bool(req_get.get('closed'))
                     c.my = str2bool(req_get.get('my'))
                     c.awaiting_review = str2bool(req_get.get('awaiting_review'))
                     c.awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
                     c.active = 'open'
                     if c.my:
                         c.active = 'my'
                     if c.closed:
                         c.active = 'closed'
                     if c.awaiting_review and not c.source:
                         c.active = 'awaiting'
                     if c.source and not c.awaiting_review:
                         c.active = 'source'
                     if c.awaiting_my_review:
                         c.active = 'awaiting_my'
                     return self._get_template_context(c)
                 @LoginRequired()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_show_all_data', request_method='GET',
                     renderer='json_ext', xhr=True)
                 def pull_request_list_data(self):
                     self.load_default_context()
                     # additional filters
                     req_get = self.request.GET
                     source = str2bool(req_get.get('source'))
                     closed = str2bool(req_get.get('closed'))
                     my = str2bool(req_get.get('my'))
                     awaiting_review = str2bool(req_get.get('awaiting_review'))
                     awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
                     filter_type = 'awaiting_review' if awaiting_review \
                         else 'awaiting_my_review' if awaiting_my_review \
                         else None
                     opened_by = None
                     if my:
                         opened_by = [self._rhodecode_user.user_id]
                     statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
                     if closed:
                         statuses = [PullRequest.STATUS_CLOSED]
                     data = self._get_pull_requests_list(
                         repo_name=self.db_repo_name, source=source,
                         filter_type=filter_type, opened_by=opened_by, statuses=statuses)
                     return data
                 def _is_diff_cache_enabled(self, target_repo):
                     caching_enabled = self._get_general_setting(
                         target_repo, 'rhodecode_diff_cache')
                     log.debug('Diff caching enabled: %s', caching_enabled)
                     return caching_enabled
                 def _get_diffset(self, source_repo_name, source_repo,
                                  source_ref_id, target_ref_id,
                                  target_commit, source_commit, diff_limit, file_limit,
                                  fulldiff):
                     vcs_diff = PullRequestModel().get_diff(
                         source_repo, source_ref_id, target_ref_id)
                     diff_processor = diffs.DiffProcessor(
                         vcs_diff, format='newdiff', diff_limit=diff_limit,
                         file_limit=file_limit, show_full_diff=fulldiff)
                     _parsed = diff_processor.prepare()
                     diffset = codeblocks.DiffSet(
                         repo_name=self.db_repo_name,
                         source_repo_name=source_repo_name,
                         source_node_getter=codeblocks.diffset_node_getter(target_commit),
                         target_node_getter=codeblocks.diffset_node_getter(source_commit),
                     )
                     diffset = self.path_filter.render_patchset_filtered(
                         diffset, _parsed, target_commit.raw_id, source_commit.raw_id)
                     return diffset
                 @LoginRequired()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_show', request_method='GET',
                     renderer='rhodecode:templates/pullrequests/pullrequest_show.mako')
                 def pull_request_show(self):
                     pull_request_id = self.request.matchdict['pull_request_id']
                     c = self.load_default_context()
                     version = self.request.GET.get('version')
                     from_version = self.request.GET.get('from_version') or version
                     merge_checks = self.request.GET.get('merge_checks')
                     c.fulldiff = str2bool(self.request.GET.get('fulldiff'))
                     force_refresh = str2bool(self.request.GET.get('force_refresh'))
                     (pull_request_latest,
                      pull_request_at_ver,
                      pull_request_display_obj,
                      at_version) = PullRequestModel().get_pr_version(
                         pull_request_id, version=version)
                     pr_closed = pull_request_latest.is_closed()
                     if pr_closed and (version or from_version):
                         # not allow to browse versions
                         raise HTTPFound(h.route_path(
                             'pullrequest_show', repo_name=self.db_repo_name,
                             pull_request_id=pull_request_id))
                     versions = pull_request_display_obj.versions()
                     c.at_version = at_version
                     c.at_version_num = (at_version
                                         if at_version and at_version != 'latest'
                                         else None)
                     c.at_version_pos = ChangesetComment.get_index_from_version(
                         c.at_version_num, versions)
                     (prev_pull_request_latest,
                      prev_pull_request_at_ver,
                      prev_pull_request_display_obj,
                      prev_at_version) = PullRequestModel().get_pr_version(
                         pull_request_id, version=from_version)
                     c.from_version = prev_at_version
                     c.from_version_num = (prev_at_version
                                           if prev_at_version and prev_at_version != 'latest'
                                           else None)
                     c.from_version_pos = ChangesetComment.get_index_from_version(
                         c.from_version_num, versions)
                     # define if we're in COMPARE mode or VIEW at version mode
                     compare = at_version != prev_at_version
                     # pull_requests repo_name we opened it against
                     # ie. target_repo must match
                     if self.db_repo_name != pull_request_at_ver.target_repo.repo_name:
                         raise HTTPNotFound()
                     c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
                         pull_request_at_ver)
                     c.pull_request = pull_request_display_obj
                     c.pull_request_latest = pull_request_latest
                     if compare or (at_version and not at_version == 'latest'):
                         c.allowed_to_change_status = False
                         c.allowed_to_update = False
                         c.allowed_to_merge = False
                         c.allowed_to_delete = False
                         c.allowed_to_comment = False
                         c.allowed_to_close = False
                     else:
                         can_change_status = PullRequestModel().check_user_change_status(
                             pull_request_at_ver, self._rhodecode_user)
                         c.allowed_to_change_status = can_change_status and not pr_closed
                         c.allowed_to_update = PullRequestModel().check_user_update(
                             pull_request_latest, self._rhodecode_user) and not pr_closed
                         c.allowed_to_merge = PullRequestModel().check_user_merge(
                             pull_request_latest, self._rhodecode_user) and not pr_closed
                         c.allowed_to_delete = PullRequestModel().check_user_delete(
                             pull_request_latest, self._rhodecode_user) and not pr_closed
                         c.allowed_to_comment = not pr_closed
                         c.allowed_to_close = c.allowed_to_merge and not pr_closed
                     c.forbid_adding_reviewers = False
                     c.forbid_author_to_review = False
                     c.forbid_commit_author_to_review = False
                     if pull_request_latest.reviewer_data and \
                                     'rules' in pull_request_latest.reviewer_data:
                         rules = pull_request_latest.reviewer_data['rules'] or {}
                         try:
                             c.forbid_adding_reviewers = rules.get(
                                 'forbid_adding_reviewers')
                             c.forbid_author_to_review = rules.get(
                                 'forbid_author_to_review')
                             c.forbid_commit_author_to_review = rules.get(
                                 'forbid_commit_author_to_review')
                         except Exception:
                             pass
                     # check merge capabilities
                     _merge_check = MergeCheck.validate(
                         pull_request_latest, user=self._rhodecode_user,
                         translator=self.request.translate, force_shadow_repo_refresh=force_refresh)
                     c.pr_merge_errors = _merge_check.error_details
                     c.pr_merge_possible = not _merge_check.failed
                     c.pr_merge_message = _merge_check.merge_msg
                     c.pr_merge_info = MergeCheck.get_merge_conditions(
                         pull_request_latest, translator=self.request.translate)
                     c.pull_request_review_status = _merge_check.review_status
                     if merge_checks:
                         self.request.override_renderer = \
                             'rhodecode:templates/pullrequests/pullrequest_merge_checks.mako'
                         return self._get_template_context(c)
                     comments_model = CommentsModel()
                     # reviewers and statuses
                     c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
                     allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
                     # GENERAL COMMENTS with versions #
                     q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
                     q = q.order_by(ChangesetComment.comment_id.asc())
                     general_comments = q
                     # pick comments we want to render at current version
                     c.comment_versions = comments_model.aggregate_comments(
                         general_comments, versions, c.at_version_num)
                     c.comments = c.comment_versions[c.at_version_num]['until']
                     # INLINE COMMENTS with versions  #
                     q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
                     q = q.order_by(ChangesetComment.comment_id.asc())
                     inline_comments = q
                     c.inline_versions = comments_model.aggregate_comments(
                         inline_comments, versions, c.at_version_num, inline=True)
                     # inject latest version
                     latest_ver = PullRequest.get_pr_display_object(
                         pull_request_latest, pull_request_latest)
                     c.versions = versions + [latest_ver]
                     # if we use version, then do not show later comments
                     # than current version
                     display_inline_comments = collections.defaultdict(
                         lambda: collections.defaultdict(list))
                     for co in inline_comments:
                         if c.at_version_num:
                             # pick comments that are at least UPTO given version, so we
                             # don't render comments for higher version
                             should_render = co.pull_request_version_id and \
                                             co.pull_request_version_id <= c.at_version_num
                         else:
                             # showing all, for 'latest'
                             should_render = True
                         if should_render:
                             display_inline_comments[co.f_path][co.line_no].append(co)
                     # load diff data into template context, if we use compare mode then
                     # diff is calculated based on changes between versions of PR
                     source_repo = pull_request_at_ver.source_repo
                     source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
                     target_repo = pull_request_at_ver.target_repo
                     target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
                     if compare:
                         # in compare switch the diff base to latest commit from prev version
                         target_ref_id = prev_pull_request_display_obj.revisions[0]
                     # despite opening commits for bookmarks/branches/tags, we always
                     # convert this to rev to prevent changes after bookmark or branch change
                     c.source_ref_type = 'rev'
                     c.source_ref = source_ref_id
                     c.target_ref_type = 'rev'
                     c.target_ref = target_ref_id
                     c.source_repo = source_repo
                     c.target_repo = target_repo
                     c.commit_ranges = []
                     source_commit = EmptyCommit()
                     target_commit = EmptyCommit()
                     c.missing_requirements = False
                     source_scm = source_repo.scm_instance()
                     target_scm = target_repo.scm_instance()
-                    # try first shadow repo, fallback to regular repo
+                    shadow_scm = None
                     try:
-                        commits_source_repo = pull_request_latest.get_shadow_repo()
+                        shadow_scm = pull_request_latest.get_shadow_repo()
                     except Exception:
                         log.debug('Failed to get shadow repo', exc_info=True)
-                        commits_source_repo = source_scm
+                    # try first the existing source_repo, and then shadow
+                    # repo if we can obtain one
+                    commits_source_repo = source_scm or shadow_scm
                     c.commits_source_repo = commits_source_repo
                     c.ancestor = None  # set it to None, to hide it from PR view
                     # empty version means latest, so we keep this to prevent
                     # double caching
                     version_normalized = version or 'latest'
                     from_version_normalized = from_version or 'latest'
                     cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
                         target_repo)
                     cache_file_path = diff_cache_exist(
                         cache_path, 'pull_request', pull_request_id, version_normalized,
                         from_version_normalized, source_ref_id, target_ref_id, c.fulldiff)
                     caching_enabled = self._is_diff_cache_enabled(c.target_repo)
                     force_recache = str2bool(self.request.GET.get('force_recache'))
                     cached_diff = None
                     if caching_enabled:
                         cached_diff = load_cached_diff(cache_file_path)
                     has_proper_commit_cache = (
                             cached_diff and cached_diff.get('commits')
                             and len(cached_diff.get('commits', [])) == 5
                             and cached_diff.get('commits')[0]
                             and cached_diff.get('commits')[3])
                     if not force_recache and has_proper_commit_cache:
                         diff_commit_cache = \
                             (ancestor_commit, commit_cache, missing_requirements,
                              source_commit, target_commit) = cached_diff['commits']
                     else:
                         diff_commit_cache = \
                             (ancestor_commit, commit_cache, missing_requirements,
                              source_commit, target_commit) = self.get_commits(
                                 commits_source_repo,
                                 pull_request_at_ver,
                                 source_commit,
                                 source_ref_id,
                                 source_scm,
                                 target_commit,
                                 target_ref_id,
                                 target_scm)
                     # register our commit range
                     for comm in commit_cache.values():
                         c.commit_ranges.append(comm)
                     c.missing_requirements = missing_requirements
                     c.ancestor_commit = ancestor_commit
                     c.statuses = source_repo.statuses(
                         [x.raw_id for x in c.commit_ranges])
                     # auto collapse if we have more than limit
                     collapse_limit = diffs.DiffProcessor._collapse_commits_over
                     c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
                     c.compare_mode = compare
                     # diff_limit is the old behavior, will cut off the whole diff
                     # if the limit is applied  otherwise will just hide the
                     # big files from the front-end
                     diff_limit = c.visual.cut_off_limit_diff
                     file_limit = c.visual.cut_off_limit_file
                     c.missing_commits = False
                     if (c.missing_requirements
                         or isinstance(source_commit, EmptyCommit)
                         or source_commit == target_commit):
                         c.missing_commits = True
                     else:
                         c.inline_comments = display_inline_comments
                         has_proper_diff_cache = cached_diff and cached_diff.get('commits')
                         if not force_recache and has_proper_diff_cache:
                             c.diffset = cached_diff['diff']
                             (ancestor_commit, commit_cache, missing_requirements,
                              source_commit, target_commit) = cached_diff['commits']
                         else:
                             c.diffset = self._get_diffset(
                                 c.source_repo.repo_name, commits_source_repo,
                                 source_ref_id, target_ref_id,
                                 target_commit, source_commit,
                                 diff_limit, file_limit, c.fulldiff)
                             # save cached diff
                             if caching_enabled:
                                 cache_diff(cache_file_path, c.diffset, diff_commit_cache)
                         c.limited_diff = c.diffset.limited_diff
                         # calculate removed files that are bound to comments
                         comment_deleted_files = [
                             fname for fname in display_inline_comments
                             if fname not in c.diffset.file_stats]
                         c.deleted_files_comments = collections.defaultdict(dict)
                         for fname, per_line_comments in display_inline_comments.items():
                             if fname in comment_deleted_files:
                                 c.deleted_files_comments[fname]['stats'] = 0
                                 c.deleted_files_comments[fname]['comments'] = list()
                                 for lno, comments in per_line_comments.items():
                                     c.deleted_files_comments[fname]['comments'].extend(
                                         comments)
                     # this is a hack to properly display links, when creating PR, the
                     # compare view and others uses different notation, and
                     # compare_commits.mako renders links based on the target_repo.
                     # We need to swap that here to generate it properly on the html side
                     c.target_repo = c.source_repo
                     c.commit_statuses = ChangesetStatus.STATUSES
                     c.show_version_changes = not pr_closed
                     if c.show_version_changes:
                         cur_obj = pull_request_at_ver
                         prev_obj = prev_pull_request_at_ver
                         old_commit_ids = prev_obj.revisions
                         new_commit_ids = cur_obj.revisions
                         commit_changes = PullRequestModel()._calculate_commit_id_changes(
                             old_commit_ids, new_commit_ids)
                         c.commit_changes_summary = commit_changes
                         # calculate the diff for commits between versions
                         c.commit_changes = []
                         mark = lambda cs, fw: list(
                             h.itertools.izip_longest([], cs, fillvalue=fw))
                         for c_type, raw_id in mark(commit_changes.added, 'a') \
                                             + mark(commit_changes.removed, 'r') \
                                             + mark(commit_changes.common, 'c'):
                             if raw_id in commit_cache:
                                 commit = commit_cache[raw_id]
                             else:
                                 try:
                                     commit = commits_source_repo.get_commit(raw_id)
                                 except CommitDoesNotExistError:
                                     # in case we fail extracting still use "dummy" commit
                                     # for display in commit diff
                                     commit = h.AttributeDict(
                                         {'raw_id': raw_id,
                                          'message': 'EMPTY or MISSING COMMIT'})
                             c.commit_changes.append([c_type, commit])
                         # current user review statuses for each version
                         c.review_versions = {}
                         if self._rhodecode_user.user_id in allowed_reviewers:
                             for co in general_comments:
                                 if co.author.user_id == self._rhodecode_user.user_id:
                                     status = co.status_change
                                     if status:
                                         _ver_pr = status[0].comment.pull_request_version_id
                                         c.review_versions[_ver_pr] = status[0]
                     return self._get_template_context(c)
                 def get_commits(
                         self, commits_source_repo, pull_request_at_ver, source_commit,
                         source_ref_id, source_scm, target_commit, target_ref_id, target_scm):
                     commit_cache = collections.OrderedDict()
                     missing_requirements = False
                     try:
                         pre_load = ["author", "branch", "date", "message"]
                         show_revs = pull_request_at_ver.revisions
                         for rev in show_revs:
                             comm = commits_source_repo.get_commit(
                                 commit_id=rev, pre_load=pre_load)
                             commit_cache[comm.raw_id] = comm
                         # Order here matters, we first need to get target, and then
                         # the source
                         target_commit = commits_source_repo.get_commit(
                             commit_id=safe_str(target_ref_id))
                         source_commit = commits_source_repo.get_commit(
                             commit_id=safe_str(source_ref_id))
                     except CommitDoesNotExistError:
                         log.warning(
                             'Failed to get commit from `{}` repo'.format(
                                 commits_source_repo), exc_info=True)
                     except RepositoryRequirementError:
                         log.warning(
                             'Failed to get all required data from repo', exc_info=True)
                         missing_requirements = True
                     ancestor_commit = None
                     try:
                         ancestor_id = source_scm.get_common_ancestor(
                             source_commit.raw_id, target_commit.raw_id, target_scm)
                         ancestor_commit = source_scm.get_commit(ancestor_id)
                     except Exception:
                         ancestor_commit = None
                     return ancestor_commit, commit_cache, missing_requirements, source_commit, target_commit
                 def assure_not_empty_repo(self):
                     _ = self.request.translate
                     try:
                         self.db_repo.scm_instance().get_commit()
                     except EmptyRepositoryError:
                         h.flash(h.literal(_('There are no commits yet')),
                                 category='warning')
                         raise HTTPFound(
                             h.route_path('repo_summary', repo_name=self.db_repo.repo_name))
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_new', request_method='GET',
                     renderer='rhodecode:templates/pullrequests/pullrequest.mako')
                 def pull_request_new(self):
                     _ = self.request.translate
                     c = self.load_default_context()
                     self.assure_not_empty_repo()
                     source_repo = self.db_repo
                     commit_id = self.request.GET.get('commit')
                     branch_ref = self.request.GET.get('branch')
                     bookmark_ref = self.request.GET.get('bookmark')
                     try:
                         source_repo_data = PullRequestModel().generate_repo_data(
                             source_repo, commit_id=commit_id,
                             branch=branch_ref, bookmark=bookmark_ref,
                             translator=self.request.translate)
                     except CommitDoesNotExistError as e:
                         log.exception(e)
                         h.flash(_('Commit does not exist'), 'error')
                         raise HTTPFound(
                             h.route_path('pullrequest_new', repo_name=source_repo.repo_name))
                     default_target_repo = source_repo
                     if source_repo.parent:
                         parent_vcs_obj = source_repo.parent.scm_instance()
                         if parent_vcs_obj and not parent_vcs_obj.is_empty():
                             # change default if we have a parent repo
                             default_target_repo = source_repo.parent
                     target_repo_data = PullRequestModel().generate_repo_data(
                         default_target_repo, translator=self.request.translate)
                     selected_source_ref = source_repo_data['refs']['selected_ref']
                     title_source_ref = ''
                     if selected_source_ref:
                         title_source_ref = selected_source_ref.split(':', 2)[1]
                     c.default_title = PullRequestModel().generate_pullrequest_title(
                         source=source_repo.repo_name,
                         source_ref=title_source_ref,
                         target=default_target_repo.repo_name
                     )
                     c.default_repo_data = {
                         'source_repo_name': source_repo.repo_name,
                         'source_refs_json': json.dumps(source_repo_data),
                         'target_repo_name': default_target_repo.repo_name,
                         'target_refs_json': json.dumps(target_repo_data),
                     }
                     c.default_source_ref = selected_source_ref
                     return self._get_template_context(c)
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_repo_refs', request_method='GET',
                     renderer='json_ext', xhr=True)
                 def pull_request_repo_refs(self):
                     self.load_default_context()
                     target_repo_name = self.request.matchdict['target_repo_name']
                     repo = Repository.get_by_repo_name(target_repo_name)
                     if not repo:
                         raise HTTPNotFound()
                     target_perm = HasRepoPermissionAny(
                         'repository.read', 'repository.write', 'repository.admin')(
                         target_repo_name)
                     if not target_perm:
                         raise HTTPNotFound()
                     return PullRequestModel().generate_repo_data(
                         repo, translator=self.request.translate)
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @view_config(
                     route_name='pullrequest_repo_destinations', request_method='GET',
                     renderer='json_ext', xhr=True)
                 def pull_request_repo_destinations(self):
                     _ = self.request.translate
                     filter_query = self.request.GET.get('query')
                     query = Repository.query() \
                         .order_by(func.length(Repository.repo_name)) \
                         .filter(
                             or_(Repository.repo_name == self.db_repo.repo_name,
                                 Repository.fork_id == self.db_repo.repo_id))
                     if filter_query:
                         ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
                         query = query.filter(
                             Repository.repo_name.ilike(ilike_expression))
                     add_parent = False
                     if self.db_repo.parent:
                         if filter_query in self.db_repo.parent.repo_name:
                             parent_vcs_obj = self.db_repo.parent.scm_instance()
                             if parent_vcs_obj and not parent_vcs_obj.is_empty():
                                 add_parent = True
                     limit = 20 - 1 if add_parent else 20
                     all_repos = query.limit(limit).all()
                     if add_parent:
                         all_repos += [self.db_repo.parent]
                     repos = []
                     for obj in ScmModel().get_repos(all_repos):
                         repos.append({
                             'id': obj['name'],
                             'text': obj['name'],
                             'type': 'repo',
                             'repo_id': obj['dbrepo']['repo_id'],
                             'repo_type': obj['dbrepo']['repo_type'],
                             'private': obj['dbrepo']['private'],
                         })
                     data = {
                         'more': False,
                         'results': [{
                             'text': _('Repositories'),
                             'children': repos
                         }] if repos else []
                     }
                     return data
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_create', request_method='POST',
                     renderer=None)
                 def pull_request_create(self):
                     _ = self.request.translate
                     self.assure_not_empty_repo()
                     self.load_default_context()
                     controls = peppercorn.parse(self.request.POST.items())
                     try:
                         form = PullRequestForm(
                             self.request.translate, self.db_repo.repo_id)()
                         _form = form.to_python(controls)
                     except formencode.Invalid as errors:
                         if errors.error_dict.get('revisions'):
                             msg = 'Revisions: %s' % errors.error_dict['revisions']
                         elif errors.error_dict.get('pullrequest_title'):
                             msg = errors.error_dict.get('pullrequest_title')
                         else:
                             msg = _('Error creating pull request: {}').format(errors)
                         log.exception(msg)
                         h.flash(msg, 'error')
                         # would rather just go back to form ...
                         raise HTTPFound(
                             h.route_path('pullrequest_new', repo_name=self.db_repo_name))
                     source_repo = _form['source_repo']
                     source_ref = _form['source_ref']
                     target_repo = _form['target_repo']
                     target_ref = _form['target_ref']
                     commit_ids = _form['revisions'][::-1]
                     # find the ancestor for this pr
                     source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
                     target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
                     # re-check permissions again here
                     # source_repo we must have read permissions
                     source_perm = HasRepoPermissionAny(
                         'repository.read',
                         'repository.write', 'repository.admin')(source_db_repo.repo_name)
                     if not source_perm:
                         msg = _('Not Enough permissions to source repo `{}`.'.format(
                             source_db_repo.repo_name))
                         h.flash(msg, category='error')
                         # copy the args back to redirect
                         org_query = self.request.GET.mixed()
                         raise HTTPFound(
                             h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                                          _query=org_query))
                     # target repo we must have read permissions, and also later on
                     # we want to check branch permissions here
                     target_perm = HasRepoPermissionAny(
                         'repository.read',
                         'repository.write', 'repository.admin')(target_db_repo.repo_name)
                     if not target_perm:
                         msg = _('Not Enough permissions to target repo `{}`.'.format(
                             target_db_repo.repo_name))
                         h.flash(msg, category='error')
                         # copy the args back to redirect
                         org_query = self.request.GET.mixed()
                         raise HTTPFound(
                             h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                                          _query=org_query))
                     source_scm = source_db_repo.scm_instance()
                     target_scm = target_db_repo.scm_instance()
                     source_commit = source_scm.get_commit(source_ref.split(':')[-1])
                     target_commit = target_scm.get_commit(target_ref.split(':')[-1])
                     ancestor = source_scm.get_common_ancestor(
                         source_commit.raw_id, target_commit.raw_id, target_scm)
                     target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
                     target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
                     pullrequest_title = _form['pullrequest_title']
                     title_source_ref = source_ref.split(':', 2)[1]
                     if not pullrequest_title:
                         pullrequest_title = PullRequestModel().generate_pullrequest_title(
                             source=source_repo,
                             source_ref=title_source_ref,
                             target=target_repo
                         )
                     description = _form['pullrequest_desc']
                     get_default_reviewers_data, validate_default_reviewers = \
                         PullRequestModel().get_reviewer_functions()
                     # recalculate reviewers logic, to make sure we can validate this
                     reviewer_rules = get_default_reviewers_data(
                         self._rhodecode_db_user, source_db_repo,
                         source_commit, target_db_repo, target_commit)
                     given_reviewers = _form['review_members']
                     reviewers = validate_default_reviewers(given_reviewers, reviewer_rules)
                     try:
                         pull_request = PullRequestModel().create(
                             self._rhodecode_user.user_id, source_repo, source_ref,
                             target_repo, target_ref, commit_ids, reviewers,
                             pullrequest_title, description, reviewer_rules,
                             auth_user=self._rhodecode_user
                         )
                         Session().commit()
                         h.flash(_('Successfully opened new pull request'),
                                 category='success')
                     except Exception:
                         msg = _('Error occurred during creation of this pull request.')
                         log.exception(msg)
                         h.flash(msg, category='error')
                         # copy the args back to redirect
                         org_query = self.request.GET.mixed()
                         raise HTTPFound(
                             h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                                          _query=org_query))
                     raise HTTPFound(
                         h.route_path('pullrequest_show', repo_name=target_repo,
                                      pull_request_id=pull_request.pull_request_id))
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_update', request_method='POST',
                     renderer='json_ext')
                 def pull_request_update(self):
                     pull_request = PullRequest.get_or_404(
                         self.request.matchdict['pull_request_id'])
                     _ = self.request.translate
                     self.load_default_context()
                     if pull_request.is_closed():
                         log.debug('update: forbidden because pull request is closed')
                         msg = _(u'Cannot update closed pull requests.')
                         h.flash(msg, category='error')
                         return True
                     # only owner or admin can update it
                     allowed_to_update = PullRequestModel().check_user_update(
                         pull_request, self._rhodecode_user)
                     if allowed_to_update:
                         controls = peppercorn.parse(self.request.POST.items())
                         if 'review_members' in controls:
                             self._update_reviewers(
                                 pull_request, controls['review_members'],
                                 pull_request.reviewer_data)
                         elif str2bool(self.request.POST.get('update_commits', 'false')):
                             self._update_commits(pull_request)
                         elif str2bool(self.request.POST.get('edit_pull_request', 'false')):
                             self._edit_pull_request(pull_request)
                         else:
                             raise HTTPBadRequest()
                         return True
                     raise HTTPForbidden()
                 def _edit_pull_request(self, pull_request):
                     _ = self.request.translate
                     try:
                         PullRequestModel().edit(
                             pull_request, self.request.POST.get('title'),
                             self.request.POST.get('description'), self._rhodecode_user)
                     except ValueError:
                         msg = _(u'Cannot update closed pull requests.')
                         h.flash(msg, category='error')
                         return
                     else:
                         Session().commit()
                     msg = _(u'Pull request title & description updated.')
                     h.flash(msg, category='success')
                     return
                 def _update_commits(self, pull_request):
                     _ = self.request.translate
                     resp = PullRequestModel().update_commits(pull_request)
                     if resp.executed:
                         if resp.target_changed and resp.source_changed:
                             changed = 'target and source repositories'
                         elif resp.target_changed and not resp.source_changed:
                             changed = 'target repository'
                         elif not resp.target_changed and resp.source_changed:
                             changed = 'source repository'
                         else:
                             changed = 'nothing'
                         msg = _(
                             u'Pull request updated to "{source_commit_id}" with '
                             u'{count_added} added, {count_removed} removed commits. '
                             u'Source of changes: {change_source}')
                         msg = msg.format(
                             source_commit_id=pull_request.source_ref_parts.commit_id,
                             count_added=len(resp.changes.added),
                             count_removed=len(resp.changes.removed),
                             change_source=changed)
                         h.flash(msg, category='success')
                         channel = '/repo${}$/pr/{}'.format(
                             pull_request.target_repo.repo_name,
                             pull_request.pull_request_id)
                         message = msg + (
                             ' - <a onclick="window.location.reload()">'
                             '<strong>{}</strong></a>'.format(_('Reload page')))
                         channelstream.post_message(
                             channel, message, self._rhodecode_user.username,
                             registry=self.request.registry)
                     else:
                         msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
                         warning_reasons = [
                             UpdateFailureReason.NO_CHANGE,
                             UpdateFailureReason.WRONG_REF_TYPE,
                         ]
                         category = 'warning' if resp.reason in warning_reasons else 'error'
                         h.flash(msg, category=category)
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_merge', request_method='POST',
                     renderer='json_ext')
                 def pull_request_merge(self):
                     """
                     Merge will perform a server-side merge of the specified
                     pull request, if the pull request is approved and mergeable.
                     After successful merging, the pull request is automatically
                     closed, with a relevant comment.
                     """
                     pull_request = PullRequest.get_or_404(
                         self.request.matchdict['pull_request_id'])
                     self.load_default_context()
                     check = MergeCheck.validate(pull_request, self._rhodecode_db_user,
                                                 translator=self.request.translate)
                     merge_possible = not check.failed
                     for err_type, error_msg in check.errors:
                         h.flash(error_msg, category=err_type)
                     if merge_possible:
                         log.debug("Pre-conditions checked, trying to merge.")
                         extras = vcs_operation_context(
                             self.request.environ, repo_name=pull_request.target_repo.repo_name,
                             username=self._rhodecode_db_user.username, action='push',
                             scm=pull_request.target_repo.repo_type)
                         self._merge_pull_request(
                             pull_request, self._rhodecode_db_user, extras)
                     else:
                         log.debug("Pre-conditions failed, NOT merging.")
                     raise HTTPFound(
                         h.route_path('pullrequest_show',
                                      repo_name=pull_request.target_repo.repo_name,
                                      pull_request_id=pull_request.pull_request_id))
                 def _merge_pull_request(self, pull_request, user, extras):
                     _ = self.request.translate
                     merge_resp = PullRequestModel().merge(pull_request, user, extras=extras)
                     if merge_resp.executed:
                         log.debug("The merge was successful, closing the pull request.")
                         PullRequestModel().close_pull_request(
                             pull_request.pull_request_id, user)
                         Session().commit()
                         msg = _('Pull request was successfully merged and closed.')
                         h.flash(msg, category='success')
                     else:
                         log.debug(
                             "The merge was not successful. Merge response: %s",
                             merge_resp)
                         msg = PullRequestModel().merge_status_message(
                             merge_resp.failure_reason)
                         h.flash(msg, category='error')
                 def _update_reviewers(self, pull_request, review_members, reviewer_rules):
                     _ = self.request.translate
                     get_default_reviewers_data, validate_default_reviewers = \
                         PullRequestModel().get_reviewer_functions()
                     try:
                         reviewers = validate_default_reviewers(review_members, reviewer_rules)
                     except ValueError as e:
                         log.error('Reviewers Validation: {}'.format(e))
                         h.flash(e, category='error')
                         return
                     PullRequestModel().update_reviewers(
                         pull_request, reviewers, self._rhodecode_user)
                     h.flash(_('Pull request reviewers updated.'), category='success')
                     Session().commit()
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_delete', request_method='POST',
                     renderer='json_ext')
                 def pull_request_delete(self):
                     _ = self.request.translate
                     pull_request = PullRequest.get_or_404(
                         self.request.matchdict['pull_request_id'])
                     self.load_default_context()
                     pr_closed = pull_request.is_closed()
                     allowed_to_delete = PullRequestModel().check_user_delete(
                         pull_request, self._rhodecode_user) and not pr_closed
                     # only owner can delete it !
                     if allowed_to_delete:
                         PullRequestModel().delete(pull_request, self._rhodecode_user)
                         Session().commit()
                         h.flash(_('Successfully deleted pull request'),
                                 category='success')
                         raise HTTPFound(h.route_path('pullrequest_show_all',
                                                      repo_name=self.db_repo_name))
                     log.warning('user %s tried to delete pull request without access',
                                 self._rhodecode_user)
                     raise HTTPNotFound()
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_comment_create', request_method='POST',
                     renderer='json_ext')
                 def pull_request_comment_create(self):
                     _ = self.request.translate
                     pull_request = PullRequest.get_or_404(
                         self.request.matchdict['pull_request_id'])
                     pull_request_id = pull_request.pull_request_id
                     if pull_request.is_closed():
                         log.debug('comment: forbidden because pull request is closed')
                         raise HTTPForbidden()
                     allowed_to_comment = PullRequestModel().check_user_comment(
                         pull_request, self._rhodecode_user)
                     if not allowed_to_comment:
                         log.debug(
                             'comment: forbidden because pull request is from forbidden repo')
                         raise HTTPForbidden()
                     c = self.load_default_context()
                     status = self.request.POST.get('changeset_status', None)
                     text = self.request.POST.get('text')
                     comment_type = self.request.POST.get('comment_type')
                     resolves_comment_id = self.request.POST.get('resolves_comment_id', None)
                     close_pull_request = self.request.POST.get('close_pull_request')
                     # the logic here should work like following, if we submit close
                     # pr comment, use `close_pull_request_with_comment` function
                     # else handle regular comment logic
                     if close_pull_request:
                         # only owner or admin or person with write permissions
                         allowed_to_close = PullRequestModel().check_user_update(
                             pull_request, self._rhodecode_user)
                         if not allowed_to_close:
                             log.debug('comment: forbidden because not allowed to close '
                                       'pull request %s', pull_request_id)
                             raise HTTPForbidden()
                         comment, status = PullRequestModel().close_pull_request_with_comment(
                             pull_request, self._rhodecode_user, self.db_repo, message=text)
                         Session().flush()
                         events.trigger(
                             events.PullRequestCommentEvent(pull_request, comment))
                     else:
                         # regular comment case, could be inline, or one with status.
                         # for that one we check also permissions
                         allowed_to_change_status = PullRequestModel().check_user_change_status(
                             pull_request, self._rhodecode_user)
                         if status and allowed_to_change_status:
                             message = (_('Status change %(transition_icon)s %(status)s')
                                        % {'transition_icon': '>',
                                           'status': ChangesetStatus.get_status_lbl(status)})
                             text = text or message
                         comment = CommentsModel().create(
                             text=text,
                             repo=self.db_repo.repo_id,
                             user=self._rhodecode_user.user_id,
                             pull_request=pull_request,
                             f_path=self.request.POST.get('f_path'),
                             line_no=self.request.POST.get('line'),
                             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),
                             comment_type=comment_type,
                             resolves_comment_id=resolves_comment_id,
                             auth_user=self._rhodecode_user
                         )
                         if allowed_to_change_status:
                             # calculate old status before we change it
                             old_calculated_status = pull_request.calculated_review_status()
                             # get status if set !
                             if status:
                                 ChangesetStatusModel().set_status(
                                     self.db_repo.repo_id,
                                     status,
                                     self._rhodecode_user.user_id,
                                     comment,
                                     pull_request=pull_request
                                 )
                             Session().flush()
                             # this is somehow required to get access to some relationship
                             # loaded on comment
                             Session().refresh(comment)
                             events.trigger(
                                 events.PullRequestCommentEvent(pull_request, comment))
                             # we now calculate the status of pull request, and based on that
                             # calculation we set the commits status
                             calculated_status = pull_request.calculated_review_status()
                             if old_calculated_status != calculated_status:
                                 PullRequestModel()._trigger_pull_request_hook(
                                     pull_request, self._rhodecode_user, 'review_status_change')
                     Session().commit()
                     data = {
                         'target_id': h.safeid(h.safe_unicode(
                             self.request.POST.get('f_path'))),
                     }
                     if comment:
                         c.co = comment
                         rendered_comment = render(
                             'rhodecode:templates/changeset/changeset_comment_block.mako',
                             self._get_template_context(c), self.request)
                         data.update(comment.get_dict())
                         data.update({'rendered_text': rendered_comment})
                     return data
                 @LoginRequired()
                 @NotAnonymous()
                 @HasRepoPermissionAnyDecorator(
                     'repository.read', 'repository.write', 'repository.admin')
                 @CSRFRequired()
                 @view_config(
                     route_name='pullrequest_comment_delete', request_method='POST',
                     renderer='json_ext')
                 def pull_request_comment_delete(self):
                     pull_request = PullRequest.get_or_404(
                         self.request.matchdict['pull_request_id'])
                     comment = ChangesetComment.get_or_404(
                         self.request.matchdict['comment_id'])
                     comment_id = comment.comment_id
                     if pull_request.is_closed():
                         log.debug('comment: forbidden because pull request is closed')
                         raise HTTPForbidden()
                     if not comment:
                         log.debug('Comment with id:%s not found, skipping', comment_id)
                         # comment already deleted in another call probably
                         return True
                     if comment.pull_request.is_closed():
                         # don't allow deleting comments on closed pull request
                         raise HTTPForbidden()
                     is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
                     super_admin = h.HasPermissionAny('hg.admin')()
                     comment_owner = comment.author.user_id == self._rhodecode_user.user_id
                     is_repo_comment = comment.repo.repo_name == self.db_repo_name
                     comment_repo_admin = is_repo_admin and is_repo_comment
                     if super_admin or comment_owner or comment_repo_admin:
                         old_calculated_status = comment.pull_request.calculated_review_status()
                         CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user)
                         Session().commit()
                         calculated_status = comment.pull_request.calculated_review_status()
                         if old_calculated_status != calculated_status:
                             PullRequestModel()._trigger_pull_request_hook(
                                 comment.pull_request, self._rhodecode_user, 'review_status_change')
                         return True
                     else:
                         log.warning('No permissions for user %s to delete comment_id: %s',
                                     self._rhodecode_db_user, comment_id)
                         raise HTTPNotFound()

             # -*- coding: utf-8 -*-
             # Copyright (C) 2010-2018 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 time
             import hashlib
             import logging
             import datetime
             import warnings
             import ipaddress
             import functools
             import traceback
             import collections
             from sqlalchemy import (
                 or_, and_, not_, func, TypeDecorator, event,
                 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
                 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
                 Text, Float, PickleType)
             from sqlalchemy.sql.expression import true, false
             from sqlalchemy.sql.functions import coalesce, count  # noqa
             from sqlalchemy.orm import (
                 relationship, joinedload, class_mapper, validates, aliased)
             from sqlalchemy.ext.declarative import declared_attr
             from sqlalchemy.ext.hybrid import hybrid_property
             from sqlalchemy.exc import IntegrityError  # noqa
             from sqlalchemy.dialects.mysql import LONGTEXT
             from beaker.cache import cache_region
             from zope.cachedescriptors.property import Lazy as LazyProperty
             from pyramid.threadlocal import get_current_request
             from rhodecode.translation import _
             from rhodecode.lib.vcs import get_vcs_instance
             from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
             from rhodecode.lib.utils2 import (
                 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
                 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
                 glob2re, StrictAttributeDict, cleaned_uri)
             from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
                 JsonRaw
             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_user_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 display_user_group_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
                 """
                 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
                 return prefix + obj.users_group_name
             def _hash_key(k):
                 return md5_safe(k)
             def in_filter_generator(qry, items, limit=500):
                 """
                 Splits IN() into multiple with OR
                 e.g.::
                 cnt = Repository.query().filter(
                     or_(
                         *in_filter_generator(Repository.repo_id, range(100000))
                     )).count()
                 """
                 if not items:
                     # empty list will cause empty query which might cause security issues
                     # this can lead to hidden unpleasant results
                     items = [-1]
                 parts = []
                 for chunk in xrange(0, len(items), limit):
                     parts.append(
                         qry.in_(items[chunk: chunk + limit])
                     )
                 return parts
             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 """
                     lst = []
                     for k in self._get_keys():
                         lst.append((k, getattr(self, k),))
                     return lst
                 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_):
                     from pyramid.httpexceptions import HTTPNotFound
                     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_PRETX_PUSH = 'pretxnchangegroup.pre_push'
                 HOOK_PUSH = 'changegroup.push_logger'
                 HOOK_PUSH_KEY = 'pushkey.key_push'
                 # 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)
                 last_activity = Column('last_activity', 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')
                 user_ssh_keys = relationship('UserSshKeys', 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')
                 # review rules
                 user_review_rules = relationship('RepoReviewRuleUser', 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
                 @hybrid_property
                 def first_name(self):
                     from rhodecode.lib import helpers as h
                     if self.name:
                         return h.escape(self.name)
                     return self.name
                 @hybrid_property
                 def last_name(self):
                     from rhodecode.lib import helpers as h
                     if self.lastname:
                         return h.escape(self.lastname)
                     return self.lastname
                 @hybrid_property
                 def api_key(self):
                     """
                     Fetch if exist an auth-token with role ALL connected to this user
                     """
                     user_auth_token = UserApiKeys.query()\
                         .filter(UserApiKeys.user_id == self.user_id)\
                         .filter(or_(UserApiKeys.expires == -1,
                                         UserApiKeys.expires >= time.time()))\
                         .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
                     if user_auth_token:
                         user_auth_token = user_auth_token.api_key
                     return user_auth_token
                 @api_key.setter
                 def api_key(self, val):
                     # don't allow to set API key this is deprecated for now
                     self._api_key = None
                 @property
                 def reviewer_pull_requests(self):
                     return PullRequestReviewers.query() \
                         .options(joinedload(PullRequestReviewers.pull_request)) \
                         .filter(PullRequestReviewers.user_id == self.user_id) \
                         .all()
                 @property
                 def firstname(self):
                     # alias for future
                     return self.name
                 @property
                 def emails(self):
                     other = UserEmailMap.query()\
                         .filter(UserEmailMap.user == self) \
                         .order_by(UserEmailMap.email_id.asc()) \
                         .all()
                     return [self.email] + [x.email for x in other]
                 @property
                 def auth_tokens(self):
                     auth_tokens = self.get_auth_tokens()
                     return [x.api_key for x in auth_tokens]
                 def get_auth_tokens(self):
                     return UserApiKeys.query()\
                         .filter(UserApiKeys.user == self)\
                         .order_by(UserApiKeys.user_api_key_id.asc())\
                         .all()
                 @LazyProperty
                 def feed_token(self):
                     return self.get_feed_token()
                 def get_feed_token(self, cache=True):
                     feed_tokens = UserApiKeys.query()\
                         .filter(UserApiKeys.user == self)\
                         .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
                     if cache:
                         feed_tokens = feed_tokens.options(
                             FromCache("long_term", "get_user_feed_token_%s" % self.user_id))
                     feed_tokens = feed_tokens.all()
                     if feed_tokens:
                         return feed_tokens[0].api_key
                     return 'NO_FEED_TOKEN_AVAILABLE'
                 @classmethod
                 def get(cls, user_id, cache=False):
                     if not user_id:
                         return
                     user = cls.query()
                     if cache:
                         user = user.options(
                             FromCache("sql_cache_short", "get_users_%s" % user_id))
                     return user.get(user_id)
                 @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()
                 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
                     from rhodecode.lib import auth
                     log.debug('Trying to authenticate user: %s via auth-token, '
                               'and roles: %s', self, roles)
                     if not auth_token:
                         return False
                     crypto_backend = auth.crypto_backend()
                     roles = (roles or []) + [UserApiKeys.ROLE_ALL]
                     tokens_q = UserApiKeys.query()\
                         .filter(UserApiKeys.user_id == self.user_id)\
                         .filter(or_(UserApiKeys.expires == -1,
                                     UserApiKeys.expires >= time.time()))
                     tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
                     plain_tokens = []
                     hash_tokens = []
                     for token in tokens_q.all():
                         # verify scope first
                         if token.repo_id:
                             # token has a scope, we need to verify it
                             if scope_repo_id != token.repo_id:
                                 log.debug(
                                     'Scope mismatch: token has a set repo scope: %s, '
                                     'and calling scope is:%s, skipping further checks',
                                      token.repo, scope_repo_id)
                                 # token has a scope, and it doesn't match, skip token
                                 continue
                         if token.api_key.startswith(crypto_backend.ENC_PREF):
                             hash_tokens.append(token.api_key)
                         else:
                             plain_tokens.append(token.api_key)
                     is_plain_match = auth_token in plain_tokens
                     if is_plain_match:
                         return True
                     for hashed in hash_tokens:
                         # TODO(marcink): this is expensive to calculate, but most secure
                         match = crypto_backend.hash_check(auth_token, hashed)
                         if match:
                             return True
                     return False
                 @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.first_name, self.last_name)
                 @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.first_name, self.last_name)
                 @property
                 def full_name_or_username(self):
                     return ('%s %s' % (self.first_name, self.last_name)
                             if (self.first_name and self.last_name) else self.username)
                 @property
                 def full_contact(self):
                     return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
                 @property
                 def short_contact(self):
                     return '%s %s' % (self.first_name, self.last_name)
                 @property
                 def is_admin(self):
                     return self.admin
                 def AuthUser(self, **kwargs):
                     """
                     Returns instance of AuthUser for this user
                     """
                     from rhodecode.lib.auth import AuthUser
                     return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
                 @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:
                             cache_key = "get_user_by_name_%s" % _hash_key(username)
                             q = q.options(
                                 FromCache("sql_cache_short", cache_key))
                     return q.scalar()
                 @classmethod
                 def get_by_auth_token(cls, auth_token, cache=False):
                     q = UserApiKeys.query()\
                         .filter(UserApiKeys.api_key == auth_token)\
                         .filter(or_(UserApiKeys.expires == -1,
                                     UserApiKeys.expires >= time.time()))
                     if cache:
                         q = q.options(
                             FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
                     match = q.first()
                     if match:
                         return match.user
                 @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)
                     email_key = _hash_key(email)
                     if cache:
                         q = q.options(
                             FromCache("sql_cache_short", "get_email_key_%s" % email_key))
                     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_key))
                         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"""
                     self.last_activity = datetime.datetime.now()
                     Session().add(self)
                     log.debug('updated user `%s` last activity', self.username)
                 def update_password(self, new_password):
                     from rhodecode.lib.auth import get_crypt_password
                     self.password = get_crypt_password(new_password)
                     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, refresh=False):
                     user = User.get_by_username(User.DEFAULT_USER, cache=cache)
                     if user is None:
                         raise Exception('FATAL: Missing default account!')
                     if refresh:
                         # The default user might be based on outdated state which
                         # has been loaded from the cache.
                         # A call to refresh() ensures that the
                         # latest state from the database is used.
                         Session().refresh(user)
                     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
                     auth_token_length = 40
                     auth_token_replacement = '*' * auth_token_length
                     extras = {
                         'auth_tokens': [auth_token_replacement],
                         'active': user.active,
                         'admin': user.admin,
                         'extern_type': user.extern_type,
                         'extern_name': user.extern_name,
                         'last_login': user.last_login,
                         'last_activity': user.last_activity,
                         'ip_addresses': user.ip_addresses,
                         'language': user_data.get('language')
                     }
                     data.update(extras)
                     if include_secrets:
                         data['auth_tokens'] = 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', unique=True),
                     Index('uak_api_key_expires_idx', 'api_key', 'expires'),
                     {'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'
                 ROLE_PASSWORD_RESET = 'token_password_reset'
                 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)
                 # scope columns
                 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')
                 user = relationship('User', lazy='joined')
                 def __unicode__(self):
                     return u"<%s('%s')>" % (self.__class__.__name__, self.role)
                 def __json__(self):
                     data = {
                         'auth_token': self.api_key,
                         'role': self.role,
                         'scope': self.scope_humanized,
                         'expired': self.expired
                     }
                     return data
                 def get_api_data(self, include_secrets=False):
                     data = self.__json__()
                     if include_secrets:
                         return data
                     else:
                         data['auth_token'] = self.token_obfuscated
                         return data
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.description)
                 @property
                 def expired(self):
                     if self.expires == -1:
                         return False
                     return time.time() > self.expires
                 @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 role_humanized(self):
                     return self._get_role_name(self.role)
                 def _get_scope(self):
                     if self.repo:
                         return repr(self.repo)
                     if self.repo_group:
                         return repr(self.repo_group) + ' (recursive)'
                     return 'global'
                 @property
                 def scope_humanized(self):
                     return self._get_scope()
                 @property
                 def token_obfuscated(self):
                     if self.api_key:
                         return self.api_key[:4] + "****"
             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')
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.description)
                 @classmethod
                 def _get_ip_range(cls, ip_addr):
                     net = ipaddress.ip_network(safe_unicode(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 UserSshKeys(Base, BaseModel):
                 __tablename__ = 'user_ssh_keys'
                 __table_args__ = (
                     Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
                     UniqueConstraint('ssh_key_fingerprint'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
                 )
                 __mapper_args__ = {}
                 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
                 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
                 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
                 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
                 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
                 user = relationship('User', lazy='joined')
                 def __json__(self):
                     data = {
                         'ssh_fingerprint': self.ssh_key_fingerprint,
                         'description': self.description,
                         'created_on': self.created_on
                     }
                     return data
                 def get_api_data(self):
                     data = self.__json__()
                     return data
             class UserLog(Base, BaseModel):
                 __tablename__ = 'user_logs'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 VERSION_1 = 'v1'
                 VERSION_2 = 'v2'
                 VERSIONS = [VERSION_1, VERSION_2]
                 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',ondelete='SET NULL'), 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', ondelete='SET NULL'), nullable=True, unique=None, default=None)
                 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)
                 version = Column("version", String(255), nullable=True, default=VERSION_1)
                 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
                 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
                 def __unicode__(self):
                     return u"<%s('id:%s:%s')>" % (
                         self.__class__.__name__, self.repository_name, self.action)
                 def __json__(self):
                     return {
                         'user_id': self.user_id,
                         'username': self.username,
                         'repository_id': self.repository_id,
                         'repository_name': self.repository_name,
                         'user_ip': self.user_ip,
                         'action_date': self.action_date,
                         'action': self.action,
                     }
                 @hybrid_property
                 def entry_id(self):
                     return self.user_log_id
                 @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_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
                 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
                 @classmethod
                 def _load_group_data(cls, column):
                     if not column:
                         return {}
                     try:
                         return json.loads(column) or {}
                     except TypeError:
                         return {}
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.user_group_description)
                 @hybrid_property
                 def group_data(self):
                     return self._load_group_data(self._group_data)
                 @group_data.expression
                 def group_data(self, **kwargs):
                     return self._group_data
                 @group_data.setter
                 def group_data(self, val):
                     try:
                         self._group_data = json.dumps(val)
                     except Exception:
                         log.error(traceback.format_exc())
                 @classmethod
                 def _load_sync(cls, group_data):
                     if group_data:
                         return group_data.get('extern_type')
                 @property
                 def sync(self):
                     return self._load_sync(self.group_data)
                 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):
                     if not user_group_id:
                         return
                     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_user_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)
                     perm_rows = sorted(perm_rows, key=display_user_group_sort)
                     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,
                         'sync': user_group.sync,
                         'owner_email': user_group.user.email,
                     }
                     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}'
                 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
                 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)
                 push_uri = Column(
                     "push_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")
                 scoped_tokens = relationship('UserApiKeys', cascade="all")
                 def __unicode__(self):
                     return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
                                                safe_unicode(self.repo_name))
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.description)
                 @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:
                             cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
                             q = q.options(
                                 FromCache("sql_cache_short", cache_key))
                     return q.scalar()
                 @classmethod
                 def get_by_id_or_repo_name(cls, repoid):
                     if isinstance(repoid, (int, long)):
                         try:
                             repo = cls.get(repoid)
                         except ValueError:
                             repo = None
                     else:
                         repo = cls.get_by_repo_name(repoid)
                     return repo
                 @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 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()
                 @property
                 def cached_diffs_relative_dir(self):
                     """
                     Return a relative to the repository store path of cached diffs
                     used for safe display for users, who shouldn't know the absolute store
                     path
                     """
                     return os.path.join(
                         os.path.dirname(self.repo_name),
                         self.cached_diffs_dir.split(os.path.sep)[-1])
                 @property
                 def cached_diffs_dir(self):
                     path = self.repo_full_path
                     return os.path.join(
                         os.path.dirname(path),
                         '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
                 def cached_diffs(self):
                     diff_cache_dir = self.cached_diffs_dir
                     if os.path.isdir(diff_cache_dir):
                         return os.listdir(diff_cache_dir)
                     return []
                 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_user_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)
                     perm_rows = sorted(perm_rows, key=display_user_group_sort)
                     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
                     from rhodecode.model.repo import RepoModel
                     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 '',
                         'push_uri': repo.push_uri or '',
                         'url': RepoModel().get_url(self),
                         'private': repo.private,
                         'created_on': repo.created_on,
                         'description': repo.description_safe,
                         'landing_rev': repo.landing_rev,
                         'owner': repo.user.username,
                         'fork_of': repo.fork.repo_name if repo.fork else None,
                         'fork_of_id': repo.fork.repo_id 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(cleaned_uri(clone_uri))
                         if url_obj.password:
                             clone_uri = url_obj.with_password('*****')
                     return clone_uri
                 @property
                 def push_uri_hidden(self):
                     push_uri = self.push_uri
                     if push_uri:
                         import urlobject
                         url_obj = urlobject.URLObject(cleaned_uri(push_uri))
                         if url_obj.password:
                             push_uri = url_obj.with_password('*****')
                     return push_uri
                 def clone_url(self, **override):
                     from rhodecode.model.settings import SettingsModel
                     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']
                     ssh = False
                     if 'ssh' in override:
                         ssh = True
                         del override['ssh']
                     # we didn't override our tmpl from **overrides
                     if not uri_tmpl:
                         rc_config = SettingsModel().get_all_settings(cache=True)
                         if ssh:
                             uri_tmpl = rc_config.get(
                                 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
                         else:
                             uri_tmpl = rc_config.get(
                                 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
                     request = get_current_request()
                     return get_clone_url(request=request,
                                          uri_tmpl=uri_tmpl,
                                          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,
                         _vcs_alias=self.repo_type)
                     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)
                 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
                 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
                 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)
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.group_description)
                 @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:
                         name_key = _hash_key(group_name)
                         gr = gr.options(
                             FromCache("sql_cache_short", "get_group_%s" % name_key))
                     return gr.scalar()
                 @classmethod
                 def get_user_personal_repo_group(cls, user_id):
                     user = User.get(user_id)
                     if user.username == User.DEFAULT_USER:
                         return None
                     return cls.query()\
                         .filter(cls.personal == true()) \
                         .filter(cls.user == user).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 last_db_change(self):
                     return self.updated_on
                 @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_user_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)
                     perm_rows = sorted(perm_rows, key=display_user_group_sort)
                     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.description_safe,
                         '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.password_reset.enabled', _('Password reset enabled')),
                     ('hg.password_reset.hidden', _('Password reset hidden')),
                     ('hg.password_reset.disabled', _('Password reset disabled')),
                     ('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.password_reset.enabled',
                     '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__ = (
                      {'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.mako.
                     """
                     # 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_TYPE_NOTE = u'note'
                 COMMENT_TYPE_TODO = u'todo'
                 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
                 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)
                 comment_type = Column('comment_type',  Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
                 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
                 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')
                 author = relationship('User', lazy='joined')
                 repo = relationship('Repository')
                 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
                 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()
                 @classmethod
                 def get_index_from_version(cls, pr_version, versions):
                     num_versions = [x.pull_request_version_id for x in versions]
                     try:
                         return num_versions.index(pr_version) +1
                     except (IndexError, ValueError):
                         return
                 @property
                 def outdated(self):
                     return self.display_state == self.COMMENT_OUTDATED
                 def outdated_at_version(self, version):
                     """
                     Checks if comment is outdated for given pull request version
                     """
                     return self.outdated and self.pull_request_version_id != version
                 def older_than_version(self, version):
                     """
                     Checks if comment is made from previous version than given
                     """
                     if version is None:
                         return self.pull_request_version_id is not None
                     return self.pull_request_version_id < version
                 @property
                 def resolved(self):
                     return self.resolved_by[0] if self.resolved_by else None
                 @property
                 def is_todo(self):
                     return self.comment_type == self.COMMENT_TYPE_TODO
                 @property
                 def is_inline(self):
                     return self.line_no and self.f_path
                 def get_index_version(self, versions):
                     return self.get_index_from_version(
                         self.pull_request_version_id, versions)
                 def __repr__(self):
                     if self.comment_id:
                         return '<DB:Comment #%s>' % self.comment_id
                     else:
                         return '<DB:Comment at %#x>' % id(self)
                 def get_api_data(self):
                     comment = self
                     data = {
                         'comment_id': comment.comment_id,
                         'comment_type': comment.comment_type,
                         'comment_text': comment.text,
                         'comment_status': comment.status_change,
                         'comment_f_path': comment.f_path,
                         'comment_lineno': comment.line_no,
                         'comment_author': comment.author,
                         'comment_created_on': comment.created_on
                     }
                     return data
                 def __json__(self):
                     data = dict()
                     data.update(self.get_api_data())
                     return data
             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[v%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)
                 def get_api_data(self):
                     status = self
                     data = {
                         'status_id': status.changeset_status_id,
                         'status': status.status,
                     }
                     return data
                 def __json__(self):
                     data = dict()
                     data.update(self.get_api_data())
                     return data
             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)
                 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
                 # 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)
                 reviewer_data = Column(
                     'reviewer_data_json', MutationObj.as_mutable(
                         JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
                 @property
                 def reviewer_data_json(self):
                     return json.dumps(self.reviewer_data)
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.description)
                 @hybrid_property
                 def revisions(self):
                     return self._revisions.split(':') if self._revisions else []
                 @revisions.setter
                 def revisions(self, val):
                     self._revisions = ':'.join(val)
                 @hybrid_property
                 def last_merge_status(self):
                     return safe_int(self._last_merge_status)
                 @last_merge_status.setter
                 def last_merge_status(self, val):
                     self._last_merge_status = 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):
                     return self.unicode_to_reference(self.source_ref)
                 @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):
                     return self.unicode_to_reference(self.target_ref)
                 @property
                 def shadow_merge_ref(self):
                     return self.unicode_to_reference(self._shadow_merge_ref)
                 @shadow_merge_ref.setter
                 def shadow_merge_ref(self, ref):
                     self._shadow_merge_ref = self.reference_to_unicode(ref)
                 def unicode_to_reference(self, raw):
                     """
                     Convert a unicode (or string) to a reference object.
                     If unicode evaluates to False it returns None.
                     """
                     if raw:
                         refs = raw.split(':')
                         return Reference(*refs)
                     else:
                         return None
                 def reference_to_unicode(self, ref):
                     """
                     Convert a reference object to unicode.
                     If reference is None it returns None.
                     """
                     if ref:
                         return u':'.join(ref)
                     else:
                         return None
                 def get_api_data(self, with_merge_state=True):
                     from rhodecode.model.pull_request import PullRequestModel
                     pull_request = self
                     if with_merge_state:
                         merge_status = PullRequestModel().merge_status(pull_request)
                         merge_state = {
                             'status': merge_status[0],
                             'message': safe_unicode(merge_status[1]),
                         }
                     else:
                         merge_state = {'status': 'not_available',
                                        'message': 'not_available'}
                     merge_data = {
                         'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
                         'reference': (
                             pull_request.shadow_merge_ref._asdict()
                             if pull_request.shadow_merge_ref else None),
                     }
                     data = {
                         'pull_request_id': pull_request.pull_request_id,
                         'url': PullRequestModel().get_url(pull_request),
                         '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': merge_state,
                         '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,
                             },
                         },
                         'merge': merge_data,
                         '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 obj, reviewer, reasons, mandatory, st in
                             pull_request.reviewers_statuses()
                         ]
                     }
                     return data
             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',
                                         cascade="all, delete, delete-orphan")
                 comments = relationship('ChangesetComment',
                                         cascade="all, delete, delete-orphan")
                 versions = relationship('PullRequestVersion',
                                         cascade="all, delete, delete-orphan",
                                         lazy='dynamic')
                 @classmethod
                 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
                                           internal_methods=None):
                     class PullRequestDisplay(object):
                         """
                         Special object wrapper for showing PullRequest data via Versions
                         It mimics PR object as close as possible. This is read only object
                         just for display
                         """
                         def __init__(self, attrs, internal=None):
                             self.attrs = attrs
                             # internal have priority over the given ones via attrs
                             self.internal = internal or ['versions']
                         def __getattr__(self, item):
                             if item in self.internal:
                                 return getattr(self, item)
                             try:
                                 return self.attrs[item]
                             except KeyError:
                                 raise AttributeError(
                                     '%s object has no attribute %s' % (self, item))
                         def __repr__(self):
                             return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
                         def versions(self):
                             return pull_request_obj.versions.order_by(
                                 PullRequestVersion.pull_request_version_id).all()
                         def is_closed(self):
                             return pull_request_obj.is_closed()
                         @property
                         def pull_request_version_id(self):
                             return getattr(pull_request_obj, 'pull_request_version_id', None)
                     attrs = StrictAttributeDict(pull_request_obj.get_api_data())
                     attrs.author = StrictAttributeDict(
                         pull_request_obj.author.get_api_data())
                     if pull_request_obj.target_repo:
                         attrs.target_repo = StrictAttributeDict(
                             pull_request_obj.target_repo.get_api_data())
                         attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
                     if pull_request_obj.source_repo:
                         attrs.source_repo = StrictAttributeDict(
                             pull_request_obj.source_repo.get_api_data())
                         attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
                     attrs.source_ref_parts = pull_request_obj.source_ref_parts
                     attrs.target_ref_parts = pull_request_obj.target_ref_parts
                     attrs.revisions = pull_request_obj.revisions
                     attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
                     attrs.reviewer_data = org_pull_request_obj.reviewer_data
                     attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
                     return PullRequestDisplay(attrs, internal=internal_methods)
                 def is_closed(self):
                     return self.status == self.STATUS_CLOSED
                 def __json__(self):
                     return {
                         'revisions': self.revisions,
                     }
                 def calculated_review_status(self):
                     from rhodecode.model.changeset_status import ChangesetStatusModel
                     return ChangesetStatusModel().calculated_review_status(self)
                 def reviewers_statuses(self):
                     from rhodecode.model.changeset_status import ChangesetStatusModel
                     return ChangesetStatusModel().reviewers_statuses(self)
                 @property
                 def workspace_id(self):
                     from rhodecode.model.pull_request import PullRequestModel
                     return PullRequestModel()._workspace_id(self)
                 def get_shadow_repo(self):
                     workspace_id = self.workspace_id
                     vcs_obj = self.target_repo.scm_instance()
                     shadow_repository_path = vcs_obj._get_shadow_repository_path(
                         workspace_id)
+                    if os.path.isdir(shadow_repository_path):
                     return vcs_obj._get_shadow_instance(shadow_repository_path)
             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)
                 @property
                 def reviewers(self):
                     return self.pull_request.reviewers
                 @property
                 def versions(self):
                     return self.pull_request.versions
                 def is_closed(self):
                     # calculate from original
                     return self.pull_request.status == self.STATUS_CLOSED
                 def calculated_review_status(self):
                     return self.pull_request.calculated_review_status()
                 def reviewers_statuses(self):
                     return self.pull_request.reviewers_statuses()
             class PullRequestReviewers(Base, BaseModel):
                 __tablename__ = 'pull_request_reviewers'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 @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)))))
                 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
                 user = relationship('User')
                 pull_request = relationship('PullRequest')
                 rule_data = Column(
                     'rule_data_json',
                     JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
                 def rule_user_group_data(self):
                     """
                     Returns the voting user group rule data for this reviewer
                     """
                     if self.rule_data and 'vote_rule' in self.rule_data:
                         user_group_data = {}
                         if 'rule_user_group_entry_id' in self.rule_data:
                             # means a group with voting rules !
                             user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
                             user_group_data['name'] = self.rule_data['rule_name']
                             user_group_data['vote_rule'] = self.rule_data['vote_rule']
                         return user_group_data
                 def __unicode__(self):
                     return u"<%s('id:%s')>" % (self.__class__.__name__,
                                                self.pull_requests_reviewers_id)
             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
             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)
                 @hybrid_property
                 def description_safe(self):
                     from rhodecode.lib import helpers as h
                     return h.escape(self.gist_description)
                 @classmethod
                 def get_or_404(cls, id_):
                     from pyramid.httpexceptions import HTTPNotFound
                     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):
                     from rhodecode.model.gist import GistModel
                     return GistModel().get_url(self)
                 @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 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)
                 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
                 user = relationship('User')
                 def rule_data(self):
                     return {
                         'mandatory': self.mandatory
                     }
             class RepoReviewRuleUserGroup(Base, BaseModel):
                 __tablename__ = 'repo_review_rules_users_groups'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
                 )
                 VOTE_RULE_ALL = -1
                 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)
                 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
                 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
                 users_group = relationship('UserGroup')
                 def rule_data(self):
                     return {
                         'mandatory': self.mandatory,
                         'vote_rule': self.vote_rule
                     }
                 @property
                 def vote_rule_label(self):
                     if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
                         return 'all must vote'
                     else:
                         return 'min. vote {}'.format(self.vote_rule)
             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')
                 review_rule_name = Column('review_rule_name', String(255))
                 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*')  # glob
                 _target_branch_pattern = Column("target_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)
                 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
                 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
                 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
                 rule_users = relationship('RepoReviewRuleUser')
                 rule_user_groups = relationship('RepoReviewRuleUserGroup')
                 def _validate_glob(self, value):
                     re.compile('^' + glob2re(value) + '$')
                 @hybrid_property
                 def source_branch_pattern(self):
                     return self._branch_pattern or '*'
                 @source_branch_pattern.setter
                 def source_branch_pattern(self, value):
                     self._validate_glob(value)
                     self._branch_pattern = value or '*'
                 @hybrid_property
                 def target_branch_pattern(self):
                     return self._target_branch_pattern or '*'
                 @target_branch_pattern.setter
                 def target_branch_pattern(self, value):
                     self._validate_glob(value)
                     self._target_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, source_branch, target_branch, files_changed):
                     """
                     Check if this review rule matches a branch/files in a pull request
                     :param source_branch: source branch name for the commit
                     :param target_branch: target branch name for the commit
                     :param files_changed: list of file paths changed in the pull request
                     """
                     source_branch = source_branch or ''
                     target_branch = target_branch or ''
                     files_changed = files_changed or []
                     branch_matches = True
                     if source_branch or target_branch:
                         if self.source_branch_pattern == '*':
                             source_branch_match = True
                         else:
                             source_branch_regex = re.compile(
                                 '^' + glob2re(self.source_branch_pattern) + '$')
                             source_branch_match = bool(source_branch_regex.search(source_branch))
                         if self.target_branch_pattern == '*':
                             target_branch_match = True
                         else:
                             target_branch_regex = re.compile(
                                 '^' + glob2re(self.target_branch_pattern) + '$')
                             target_branch_match = bool(target_branch_regex.search(target_branch))
                         branch_matches = source_branch_match and target_branch_match
                     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 = collections.OrderedDict()
                     for rule_user in self.rule_users:
                         if rule_user.user.active:
                             if rule_user.user not in users:
                                 users[rule_user.user.username] = {
                                     'user': rule_user.user,
                                     'source': 'user',
                                     'source_data': {},
                                     'data': rule_user.rule_data()
                                 }
                     for rule_user_group in self.rule_user_groups:
                         source_data = {
                             'user_group_id': rule_user_group.users_group.users_group_id,
                             'name': rule_user_group.users_group.users_group_name,
                             'members': len(rule_user_group.users_group.members)
                         }
                         for member in rule_user_group.users_group.members:
                             if member.user.active:
                                 key = member.user.username
                                 if key in users:
                                     # skip this member as we have him already
                                     # this prevents from override the "first" matched
                                     # users with duplicates in multiple groups
                                     continue
                                 users[key] = {
                                     'user': member.user,
                                     'source': 'user_group',
                                     'source_data': source_data,
                                     'data': rule_user_group.rule_data()
                                 }
                     return users
                 def user_group_vote_rule(self):
                     rules = []
                     if self.rule_user_groups:
                         for user_group in self.rule_user_groups:
                             rules.append(user_group)
                     return rules
                 def __repr__(self):
                     return '<RepoReviewerRule(id=%r, repo=%r)>' % (
                         self.repo_review_rule_id, self.repo)
             class ScheduleEntry(Base, BaseModel):
                 __tablename__ = 'schedule_entries'
                 __table_args__ = (
                     UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
                     UniqueConstraint('task_uid', name='s_task_uid_idx'),
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 schedule_types = ['crontab', 'timedelta', 'integer']
                 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
                 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
                 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
                 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
                 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
                 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
                 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
                 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
                 # task
                 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
                 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
                 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
                 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
                 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
                 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
                 @hybrid_property
                 def schedule_type(self):
                     return self._schedule_type
                 @schedule_type.setter
                 def schedule_type(self, val):
                     if val not in self.schedule_types:
                         raise ValueError('Value must be on of `{}` and got `{}`'.format(
                             val, self.schedule_type))
                     self._schedule_type = val
                 @classmethod
                 def get_uid(cls, obj):
                     args = obj.task_args
                     kwargs = obj.task_kwargs
                     if isinstance(args, JsonRaw):
                         try:
                             args = json.loads(args)
                         except ValueError:
                             args = tuple()
                     if isinstance(kwargs, JsonRaw):
                         try:
                             kwargs = json.loads(kwargs)
                         except ValueError:
                             kwargs = dict()
                     dot_notation = obj.task_dot_notation
                     val = '.'.join(map(safe_str, [
                         sorted(dot_notation), args, sorted(kwargs.items())]))
                     return hashlib.sha1(val).hexdigest()
                 @classmethod
                 def get_by_schedule_name(cls, schedule_name):
                     return cls.query().filter(cls.schedule_name == schedule_name).scalar()
                 @classmethod
                 def get_by_schedule_id(cls, schedule_id):
                     return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
                 @property
                 def task(self):
                     return self.task_dot_notation
                 @property
                 def schedule(self):
                     from rhodecode.lib.celerylib.utils import raw_2_schedule
                     schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
                     return schedule
                 @property
                 def args(self):
                     try:
                         return list(self.task_args or [])
                     except ValueError:
                         return list()
                 @property
                 def kwargs(self):
                     try:
                         return dict(self.task_kwargs or {})
                     except ValueError:
                         return dict()
                 def _as_raw(self, val):
                     if hasattr(val, 'de_coerce'):
                         val = val.de_coerce()
                         if val:
                             val = json.dumps(val)
                     return val
                 @property
                 def schedule_definition_raw(self):
                     return self._as_raw(self.schedule_definition)
                 @property
                 def args_raw(self):
                     return self._as_raw(self.task_args)
                 @property
                 def kwargs_raw(self):
                     return self._as_raw(self.task_kwargs)
                 def __repr__(self):
                     return '<DB:ScheduleEntry({}:{})>'.format(
                         self.schedule_entry_id, self.schedule_name)
             @event.listens_for(ScheduleEntry, 'before_update')
             def update_task_uid(mapper, connection, target):
                 target.task_uid = ScheduleEntry.get_uid(target)
             @event.listens_for(ScheduleEntry, 'before_insert')
             def set_task_uid(mapper, connection, target):
                 target.task_uid = ScheduleEntry.get_uid(target)
             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 DbSession(Base, BaseModel):
                 __tablename__ = 'db_session'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 def __repr__(self):
                     return '<DB:DbSession({})>'.format(self.id)
                 id = Column('id', Integer())
                 namespace = Column('namespace', String(255), primary_key=True)
                 accessed = Column('accessed', DateTime, nullable=False)
                 created = Column('created', DateTime, nullable=False)
                 data = Column('data', PickleType, nullable=False)
             class BeakerCache(Base, BaseModel):
                 __tablename__ = 'beaker_cache'
                 __table_args__ = (
                     {'extend_existing': True, 'mysql_engine': 'InnoDB',
                      'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
                 )
                 def __repr__(self):
                     return '<DB:DbSession({})>'.format(self.id)
                 id = Column('id', Integer())
                 namespace = Column('namespace', String(255), primary_key=True)
                 accessed = Column('accessed', DateTime, nullable=False)
                 created = Column('created', DateTime, nullable=False)
                 data = Column('data', PickleType, nullable=False)