Mercurial > kallithea

comparison rhodecode/controllers/api/api.py @ 1593:92a4f7c496a5 beta

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Correct code style
author Nicolas VINOT <aeris@imirhil.fr>
date Sun, 23 Oct 2011 01:16:55 +0200
parents 0b63a0d2cede
children 9dae92a65e40
comparison
equal deleted inserted replaced
1592:8628c8706bf8 1593:92a4f7c496a5
12 from rhodecode.model.users_group import UsersGroupModel 12 from rhodecode.model.users_group import UsersGroupModel
13 from rhodecode.model import users_group 13 from rhodecode.model import users_group
14 from rhodecode.model.repos_group import ReposGroupModel 14 from rhodecode.model.repos_group import ReposGroupModel
15 from sqlalchemy.orm.exc import NoResultFound 15 from sqlalchemy.orm.exc import NoResultFound
16 16
17 log = logging.getLogger( __name__ ) 17 log = logging.getLogger(__name__)
18 18
19 19
20 class ApiController( JSONRPCController ): 20 class ApiController(JSONRPCController):
21 """ 21 """
22 API Controller 22 API Controller
23 23
24 24
25 Each method needs to have USER as argument this is then based on given 25 Each method needs to have USER as argument this is then based on given
31 Each function should also **raise** JSONRPCError for any 31 Each function should also **raise** JSONRPCError for any
32 errors that happens 32 errors that happens
33 33
34 """ 34 """
35 35
36 @HasPermissionAllDecorator( 'hg.admin' ) 36 @HasPermissionAllDecorator('hg.admin')
37 def pull( self, apiuser, repo ): 37 def pull(self, apiuser, repo):
38 """ 38 """
39 Dispatch pull action on given repo 39 Dispatch pull action on given repo
40 40
41 41
42 :param user: 42 :param user:
43 :param repo: 43 :param repo:
44 """ 44 """
45 45
46 if Repository.is_valid( repo ) is False: 46 if Repository.is_valid(repo) is False:
47 raise JSONRPCError( 'Unknown repo "%s"' % repo ) 47 raise JSONRPCError('Unknown repo "%s"' % repo)
48 48
49 try: 49 try:
50 ScmModel().pull_changes( repo, self.rhodecode_user.username ) 50 ScmModel().pull_changes(repo, self.rhodecode_user.username)
51 return 'Pulled from %s' % repo 51 return 'Pulled from %s' % repo
52 except Exception: 52 except Exception:
53 raise JSONRPCError( 'Unable to pull changes from "%s"' % repo ) 53 raise JSONRPCError('Unable to pull changes from "%s"' % repo)
54 54
55 @HasPermissionAllDecorator( 'hg.admin' ) 55 @HasPermissionAllDecorator('hg.admin')
56 def get_user( self, apiuser, username ): 56 def get_user(self, apiuser, username):
57 """" 57 """"
58 Get a user by username 58 Get a user by username
59 59
60 :param apiuser 60 :param apiuser
61 :param username 61 :param username
62 """ 62 """
63 63
64 user = User.get_by_username( username ) 64 user = User.get_by_username(username)
65 if not user: 65 if not user:
66 return None 66 return None
67 67
68 return dict( id = user.user_id, 68 return dict(id = user.user_id,
69 username = user.username, 69 username = user.username,
70 firstname = user.name, 70 firstname = user.name,
71 lastname = user.lastname, 71 lastname = user.lastname,
72 email = user.email, 72 email = user.email,
73 active = user.active, 73 active = user.active,
74 admin = user.admin, 74 admin = user.admin,
75 ldap = user.ldap_dn ) 75 ldap = user.ldap_dn)
76 76
77 @HasPermissionAllDecorator( 'hg.admin' ) 77 @HasPermissionAllDecorator('hg.admin')
78 def get_users( self, apiuser ): 78 def get_users(self, apiuser):
79 """" 79 """"
80 Get all users 80 Get all users
81 81
82 :param apiuser 82 :param apiuser
83 """ 83 """
84 84
85 result = [] 85 result = []
86 for user in User.getAll(): 86 for user in User.getAll():
87 result.append( dict( id = user.user_id, 87 result.append(dict(id = user.user_id,
88 username = user.username, 88 username = user.username,
89 firstname = user.name, 89 firstname = user.name,
90 lastname = user.lastname, 90 lastname = user.lastname,
91 email = user.email, 91 email = user.email,
92 active = user.active, 92 active = user.active,
93 admin = user.admin, 93 admin = user.admin,
94 ldap = user.ldap_dn ) ) 94 ldap = user.ldap_dn))
95 return result 95 return result
96 96
97 @HasPermissionAllDecorator( 'hg.admin' ) 97 @HasPermissionAllDecorator('hg.admin')
98 def create_user( self, apiuser, username, password, firstname, 98 def create_user(self, apiuser, username, password, firstname,
99 lastname, email, active = True, admin = False, ldap_dn = None ): 99 lastname, email, active = True, admin = False, ldap_dn = None):
100 """ 100 """
101 Create new user 101 Create new user
102 102
103 :param apiuser: 103 :param apiuser:
104 :param username: 104 :param username:
109 :param active: 109 :param active:
110 :param admin: 110 :param admin:
111 :param ldap_dn: 111 :param ldap_dn:
112 """ 112 """
113 113
114 if self.get_user( apiuser, username ): 114 if self.get_user(apiuser, username):
115 raise JSONRPCError( "user %s already exist" % username ) 115 raise JSONRPCError("user %s already exist" % username)
116 116
117 try: 117 try:
118 form_data = dict( username = username, 118 form_data = dict(username = username,
119 password = password, 119 password = password,
120 active = active, 120 active = active,
121 admin = admin, 121 admin = admin,
122 name = firstname, 122 name = firstname,
123 lastname = lastname, 123 lastname = lastname,
124 email = email, 124 email = email,
125 ldap_dn = ldap_dn ) 125 ldap_dn = ldap_dn)
126 UserModel().create_ldap( username, password, ldap_dn, form_data ) 126 UserModel().create_ldap(username, password, ldap_dn, form_data)
127 return dict( msg = 'created new user %s' % username ) 127 return dict(msg = 'created new user %s' % username)
128 except Exception: 128 except Exception:
129 log.error( traceback.format_exc() ) 129 log.error(traceback.format_exc())
130 raise JSONRPCError( 'failed to create user %s' % username ) 130 raise JSONRPCError('failed to create user %s' % username)
131 131
132 @HasPermissionAllDecorator( 'hg.admin' ) 132 @HasPermissionAllDecorator('hg.admin')
133 def get_users_group( self, apiuser, group_name ): 133 def get_users_group(self, apiuser, group_name):
134 """" 134 """"
135 Get users group by name 135 Get users group by name
136 136
137 :param apiuser 137 :param apiuser
138 :param group_name 138 :param group_name
139 """ 139 """
140 140
141 users_group = UsersGroup.get_by_group_name( group_name ) 141 users_group = UsersGroup.get_by_group_name(group_name)
142 if not users_group: 142 if not users_group:
143 return None 143 return None
144 144
145 members = [] 145 members = []
146 for user in users_group.members: 146 for user in users_group.members:
147 user = user.user 147 user = user.user
148 members.append( dict( id = user.user_id, 148 members.append(dict(id = user.user_id,
149 username = user.username, 149 username = user.username,
150 firstname = user.name, 150 firstname = user.name,
151 lastname = user.lastname, 151 lastname = user.lastname,
152 email = user.email, 152 email = user.email,
153 active = user.active, 153 active = user.active,
154 admin = user.admin, 154 admin = user.admin,
155 ldap = user.ldap_dn ) ) 155 ldap = user.ldap_dn))
156 156
157 return dict( id = users_group.users_group_id, 157 return dict(id = users_group.users_group_id,
158 name = users_group.users_group_name, 158 name = users_group.users_group_name,
159 active = users_group.users_group_active, 159 active = users_group.users_group_active,
160 members = members ) 160 members = members)
161 161
162 @HasPermissionAllDecorator( 'hg.admin' ) 162 @HasPermissionAllDecorator('hg.admin')
163 def get_users_groups( self, apiuser ): 163 def get_users_groups(self, apiuser):
164 """" 164 """"
165 Get all users groups 165 Get all users groups
166 166
167 :param apiuser 167 :param apiuser
168 """ 168 """
170 result = [] 170 result = []
171 for users_group in UsersGroup.getAll(): 171 for users_group in UsersGroup.getAll():
172 members = [] 172 members = []
173 for user in users_group.members: 173 for user in users_group.members:
174 user = user.user 174 user = user.user
175 members.append( dict( id = user.user_id, 175 members.append(dict(id = user.user_id,
176 username = user.username, 176 username = user.username,
177 firstname = user.name, 177 firstname = user.name,
178 lastname = user.lastname, 178 lastname = user.lastname,
179 email = user.email, 179 email = user.email,
180 active = user.active, 180 active = user.active,
181 admin = user.admin, 181 admin = user.admin,
182 ldap = user.ldap_dn ) ) 182 ldap = user.ldap_dn))
183 183
184 result.append( dict( id = users_group.users_group_id, 184 result.append(dict(id = users_group.users_group_id,
185 name = users_group.users_group_name, 185 name = users_group.users_group_name,
186 active = users_group.users_group_active, 186 active = users_group.users_group_active,
187 members = members ) ) 187 members = members))
188 return result 188 return result
189 189
190 @HasPermissionAllDecorator( 'hg.admin' ) 190 @HasPermissionAllDecorator('hg.admin')
191 def create_users_group( self, apiuser, name, active = True ): 191 def create_users_group(self, apiuser, name, active = True):
192 """ 192 """
193 Creates an new usergroup 193 Creates an new usergroup
194 194
195 :param name: 195 :param name:
196 :param active: 196 :param active:
197 """ 197 """
198 198
199 if self.get_users_group( apiuser, name ): 199 if self.get_users_group(apiuser, name):
200 raise JSONRPCError( "users group %s already exist" % name ) 200 raise JSONRPCError("users group %s already exist" % name)
201 201
202 try: 202 try:
203 form_data = dict( users_group_name = name, 203 form_data = dict(users_group_name = name,
204 users_group_active = active ) 204 users_group_active = active)
205 ug = UsersGroup.create( form_data ) 205 ug = UsersGroup.create(form_data)
206 return dict( id = ug.users_group_id, 206 return dict(id = ug.users_group_id,
207 msg = 'created new users group %s' % name ) 207 msg = 'created new users group %s' % name)
208 except Exception: 208 except Exception:
209 log.error( traceback.format_exc() ) 209 log.error(traceback.format_exc())
210 raise JSONRPCError( 'failed to create group %s' % name ) 210 raise JSONRPCError('failed to create group %s' % name)
211 211
212 @HasPermissionAllDecorator( 'hg.admin' ) 212 @HasPermissionAllDecorator('hg.admin')
213 def add_user_to_users_group( self, apiuser, group_name, user_name ): 213 def add_user_to_users_group(self, apiuser, group_name, user_name):
214 """" 214 """"
215 Add a user to a group 215 Add a user to a group
216 216
217 :param apiuser 217 :param apiuser
218 :param group_name 218 :param group_name
219 :param user_name 219 :param user_name
220 """ 220 """
221 221
222 try: 222 try:
223 users_group = UsersGroup.get_by_group_name( group_name ) 223 users_group = UsersGroup.get_by_group_name(group_name)
224 if not users_group: 224 if not users_group:
225 raise JSONRPCError( 'unknown users group %s' % group_name ) 225 raise JSONRPCError('unknown users group %s' % group_name)
226 226
227 try: 227 try:
228 user = User.get_by_username( user_name ) 228 user = User.get_by_username(user_name)
229 except NoResultFound: 229 except NoResultFound:
230 raise JSONRPCError( 'unknown user %s' % user_name ) 230 raise JSONRPCError('unknown user %s' % user_name)
231 231
232 ugm = UsersGroupModel().add_user_to_group( users_group, user ) 232 ugm = UsersGroupModel().add_user_to_group(users_group, user)
233 233
234 return dict( id = ugm.users_group_member_id, 234 return dict(id = ugm.users_group_member_id,
235 msg = 'created new users group member' ) 235 msg = 'created new users group member')
236 except Exception: 236 except Exception:
237 log.error( traceback.format_exc() ) 237 log.error(traceback.format_exc())
238 raise JSONRPCError( 'failed to create users group member' ) 238 raise JSONRPCError('failed to create users group member')
239 239
240 @HasPermissionAnyDecorator( 'hg.admin' ) 240 @HasPermissionAnyDecorator('hg.admin')
241 def get_repo( self, apiuser, repo_name ): 241 def get_repo(self, apiuser, repo_name):
242 """" 242 """"
243 Get repository by name 243 Get repository by name
244 244
245 :param apiuser 245 :param apiuser
246 :param repo_name 246 :param repo_name
247 """ 247 """
248 248
249 try: 249 try:
250 repo = Repository.get_by_repo_name( repo_name ) 250 repo = Repository.get_by_repo_name(repo_name)
251 except NoResultFound: 251 except NoResultFound:
252 return None 252 return None
253 253
254 members = [] 254 members = []
255 for user in repo.repo_to_perm: 255 for user in repo.repo_to_perm:
256 perm = user.permission.permission_name 256 perm = user.permission.permission_name
257 user = user.user 257 user = user.user
258 members.append( dict( type_ = "user", 258 members.append(dict(type_ = "user",
259 id = user.user_id, 259 id = user.user_id,
260 username = user.username, 260 username = user.username,
261 firstname = user.name, 261 firstname = user.name,
262 lastname = user.lastname, 262 lastname = user.lastname,
263 email = user.email, 263 email = user.email,
264 active = user.active, 264 active = user.active,
265 admin = user.admin, 265 admin = user.admin,
266 ldap = user.ldap_dn, 266 ldap = user.ldap_dn,
267 permission = perm ) ) 267 permission = perm))
268 for users_group in repo.users_group_to_perm: 268 for users_group in repo.users_group_to_perm:
269 perm = users_group.permission.permission_name 269 perm = users_group.permission.permission_name
270 users_group = users_group.users_group 270 users_group = users_group.users_group
271 members.append( dict( type_ = "users_group", 271 members.append(dict(type_ = "users_group",
272 id = users_group.users_group_id, 272 id = users_group.users_group_id,
273 name = users_group.users_group_name, 273 name = users_group.users_group_name,
274 active = users_group.users_group_active, 274 active = users_group.users_group_active,
275 permission = perm ) ) 275 permission = perm))
276 276
277 return dict( id = repo.repo_id, 277 return dict(id = repo.repo_id,
278 name = repo.repo_name, 278 name = repo.repo_name,
279 type = repo.repo_type, 279 type = repo.repo_type,
280 description = repo.description, 280 description = repo.description,
281 members = members ) 281 members = members)
282 282
283 @HasPermissionAnyDecorator( 'hg.admin' ) 283 @HasPermissionAnyDecorator('hg.admin')
284 def get_repos( self, apiuser ): 284 def get_repos(self, apiuser):
285 """" 285 """"
286 Get all repositories 286 Get all repositories
287 287
288 :param apiuser 288 :param apiuser
289 """ 289 """
290 290
291 result = [] 291 result = []
292 for repository in Repository.getAll(): 292 for repository in Repository.getAll():
293 result.append( dict( id = repository.repo_id, 293 result.append(dict(id = repository.repo_id,
294 name = repository.repo_name, 294 name = repository.repo_name,
295 type = repository.repo_type, 295 type = repository.repo_type,
296 description = repository.description ) ) 296 description = repository.description))
297 return result 297 return result
298 298
299 @HasPermissionAnyDecorator( 'hg.admin', 'hg.create.repository' ) 299 @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
300 def create_repo( self, apiuser, name, owner_name, description = '', repo_type = 'hg', \ 300 def create_repo(self, apiuser, name, owner_name, description = '', repo_type = 'hg', \
301 private = False ): 301 private = False):
302 """ 302 """
303 Create a repository 303 Create a repository
304 304
305 :param apiuser 305 :param apiuser
306 :param name 306 :param name
310 :param owner_name 310 :param owner_name
311 """ 311 """
312 312
313 try: 313 try:
314 try: 314 try:
315 owner = User.get_by_username( owner_name ) 315 owner = User.get_by_username(owner_name)
316 except NoResultFound: 316 except NoResultFound:
317 raise JSONRPCError( 'unknown user %s' % owner ) 317 raise JSONRPCError('unknown user %s' % owner)
318 318
319 if self.get_repo( apiuser, name ): 319 if self.get_repo(apiuser, name):
320 raise JSONRPCError( "repo %s already exist" % name ) 320 raise JSONRPCError("repo %s already exist" % name)
321 321
322 groups = name.split( '/' ) 322 groups = name.split('/')
323 real_name = groups[-1] 323 real_name = groups[-1]
324 groups = groups[:-1] 324 groups = groups[:-1]
325 parent_id = None 325 parent_id = None
326 for g in groups: 326 for g in groups:
327 group = Group.get_by_group_name( g ) 327 group = Group.get_by_group_name(g)
328 if not group: 328 if not group:
329 group = ReposGroupModel().create( dict( group_name = g, 329 group = ReposGroupModel().create(dict(group_name = g,
330 group_description = '', 330 group_description = '',
331 group_parent_id = parent_id ) ) 331 group_parent_id = parent_id))
332 parent_id = group.group_id 332 parent_id = group.group_id
333 333
334 RepoModel().create( dict( repo_name = real_name, 334 RepoModel().create(dict(repo_name = real_name,
335 repo_name_full = name, 335 repo_name_full = name,
336 description = description, 336 description = description,
337 private = private, 337 private = private,
338 repo_type = repo_type, 338 repo_type = repo_type,
339 repo_group = parent_id, 339 repo_group = parent_id,
340 clone_uri = None ), owner ) 340 clone_uri = None), owner)
341 except Exception: 341 except Exception:
342 log.error( traceback.format_exc() ) 342 log.error(traceback.format_exc())
343 raise JSONRPCError( 'failed to create repository %s' % name ) 343 raise JSONRPCError('failed to create repository %s' % name)
344 344
345 @HasPermissionAnyDecorator( 'hg.admin' ) 345 @HasPermissionAnyDecorator('hg.admin')
346 def add_user_to_repo( self, apiuser, repo_name, user_name, perm ): 346 def add_user_to_repo(self, apiuser, repo_name, user_name, perm):
347 """ 347 """
348 Add permission for a user to a repository 348 Add permission for a user to a repository
349 349
350 :param apiuser 350 :param apiuser
351 :param repo_name 351 :param repo_name
353 :param perm 353 :param perm
354 """ 354 """
355 355
356 try: 356 try:
357 try: 357 try:
358 repo = Repository.get_by_repo_name( repo_name ) 358 repo = Repository.get_by_repo_name(repo_name)
359 except NoResultFound: 359 except NoResultFound:
360 raise JSONRPCError( 'unknown repository %s' % repo ) 360 raise JSONRPCError('unknown repository %s' % repo)
361 361
362 try: 362 try:
363 user = User.get_by_username( user_name ) 363 user = User.get_by_username(user_name)
364 except NoResultFound: 364 except NoResultFound:
365 raise JSONRPCError( 'unknown user %s' % user ) 365 raise JSONRPCError('unknown user %s' % user)
366 366
367 RepositoryPermissionModel().updateOrDeleteUserPermission( repo, user, perm ) 367 RepositoryPermissionModel().update_or_delete_user_permission(repo, user, perm)
368 except Exception: 368 except Exception:
369 log.error( traceback.format_exc() ) 369 log.error(traceback.format_exc())
370 raise JSONRPCError( 'failed to edit permission %(repo)s for %(user)s' 370 raise JSONRPCError('failed to edit permission %(repo)s for %(user)s'
371 % dict( user = user_name, repo = repo_name ) ) 371 % dict(user = user_name, repo = repo_name))
372 372