|  | @@ -117,8 +117,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 117 | 117 |  
 | 
	
		
			
			| 118 | 118 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 119 | 119 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 120 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 121 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 120 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 121 | +            current_user=user,
 | 
	
		
			
			|  | 122 | +            session=self.session
 | 
	
		
			
			|  | 123 | +        ).create_workspace('test workspace', save_now=True)
 | 
	
		
			
			| 122 | 124 |          api = ContentApi(
 | 
	
		
			
			| 123 | 125 |              current_user=user,
 | 
	
		
			
			| 124 | 126 |              session=self.session,
 | 
	
	
		
			
			|  | @@ -134,7 +136,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 134 | 136 |          # Refresh instances after commit
 | 
	
		
			
			| 135 | 137 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 136 | 138 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 137 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 139 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 138 | 140 |          api = ContentApi(current_user=user, session=self.session)
 | 
	
		
			
			| 139 | 141 |          items = api.get_all(None, ContentType.Any, workspace)
 | 
	
		
			
			| 140 | 142 |          eq_(2, len(items))
 | 
	
	
		
			
			|  | @@ -151,7 +153,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 151 | 153 |          # Refresh instances after commit
 | 
	
		
			
			| 152 | 154 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 153 | 155 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 154 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 156 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 155 | 157 |          api = ContentApi(
 | 
	
		
			
			| 156 | 158 |              current_user=user, 
 | 
	
		
			
			| 157 | 159 |              session=self.session
 | 
	
	
		
			
			|  | @@ -172,14 +174,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 172 | 174 |          items = api.get_all(None, ContentType.Any, workspace)
 | 
	
		
			
			| 173 | 175 |          eq_(2, len(items))
 | 
	
		
			
			| 174 | 176 |  
 | 
	
		
			
			| 175 |  | -
 | 
	
		
			
			| 176 | 177 |      def test_archive(self):
 | 
	
		
			
			| 177 | 178 |          uapi = UserApi(
 | 
	
		
			
			| 178 | 179 |              session=self.session,
 | 
	
		
			
			| 179 | 180 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 180 | 181 |              current_user=None,
 | 
	
		
			
			| 181 | 182 |          )
 | 
	
		
			
			| 182 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 183 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 183 | 184 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 184 | 185 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 185 | 186 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -225,7 +226,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 225 | 226 |          # Refresh instances after commit
 | 
	
		
			
			| 226 | 227 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 227 | 228 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 228 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 229 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 229 | 230 |          api = ContentApi(
 | 
	
		
			
			| 230 | 231 |              current_user=user, 
 | 
	
		
			
			| 231 | 232 |              session=self.session
 | 
	
	
		
			
			|  | @@ -238,9 +239,9 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 238 | 239 |          # Refresh instances after commit
 | 
	
		
			
			| 239 | 240 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 240 | 241 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 241 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 242 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 242 | 243 |          api = ContentApi(
 | 
	
		
			
			| 243 |  | -            current_user=user, 
 | 
	
		
			
			|  | 244 | +            current_user=user,
 | 
	
		
			
			| 244 | 245 |              session=self.session
 | 
	
		
			
			| 245 | 246 |          )
 | 
	
		
			
			| 246 | 247 |  
 | 
	
	
		
			
			|  | @@ -259,15 +260,24 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 259 | 260 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 260 | 261 |              current_user=None,
 | 
	
		
			
			| 261 | 262 |          )
 | 
	
		
			
			| 262 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 263 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 263 | 264 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 264 | 265 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 265 | 266 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 266 | 267 |  
 | 
	
		
			
			| 267 |  | -        user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 268 |  | -                                groups=groups, save_now=True)
 | 
	
		
			
			| 269 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 270 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 268 | +        user = uapi.create_user(
 | 
	
		
			
			|  | 269 | +            email='this.is@user',
 | 
	
		
			
			|  | 270 | +            groups=groups,
 | 
	
		
			
			|  | 271 | +            save_now=True
 | 
	
		
			
			|  | 272 | +        )
 | 
	
		
			
			|  | 273 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 274 | +            current_user=user,
 | 
	
		
			
			|  | 275 | +            session=self.session
 | 
	
		
			
			|  | 276 | +        ).create_workspace(
 | 
	
		
			
			|  | 277 | +            'test workspace',
 | 
	
		
			
			|  | 278 | +            save_now=True
 | 
	
		
			
			|  | 279 | +        )
 | 
	
		
			
			|  | 280 | +
 | 
	
		
			
			| 271 | 281 |          api = ContentApi(
 | 
	
		
			
			| 272 | 282 |              current_user=user,
 | 
	
		
			
			| 273 | 283 |              session=self.session,
 | 
	
	
		
			
			|  | @@ -282,7 +292,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 282 | 292 |          # Refresh instances after commit
 | 
	
		
			
			| 283 | 293 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 284 | 294 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 285 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 295 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 286 | 296 |          api = ContentApi(
 | 
	
		
			
			| 287 | 297 |              current_user=user, 
 | 
	
		
			
			| 288 | 298 |              session=self.session
 | 
	
	
		
			
			|  | @@ -305,15 +315,17 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 305 | 315 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 306 | 316 |              current_user=None,
 | 
	
		
			
			| 307 | 317 |          )
 | 
	
		
			
			| 308 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 318 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 309 | 319 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 310 | 320 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 311 | 321 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 312 | 322 |  
 | 
	
		
			
			| 313 | 323 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 314 | 324 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 315 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 316 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 325 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 326 | +            current_user=user,
 | 
	
		
			
			|  | 327 | +            session=self.session
 | 
	
		
			
			|  | 328 | +        ).create_workspace('test workspace', save_now=True)
 | 
	
		
			
			| 317 | 329 |          api = ContentApi(
 | 
	
		
			
			| 318 | 330 |              current_user=user, 
 | 
	
		
			
			| 319 | 331 |              session=self.session
 | 
	
	
		
			
			|  | @@ -348,7 +360,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 348 | 360 |          # Refresh instances after commit
 | 
	
		
			
			| 349 | 361 |          user = uapi.get_one(uid)
 | 
	
		
			
			| 350 | 362 |          workspace_api = WorkspaceApi(current_user=user, session=self.session)
 | 
	
		
			
			| 351 |  | -        workspace= workspace_api.get_one(wid)
 | 
	
		
			
			|  | 363 | +        workspace = workspace_api.get_one(wid)
 | 
	
		
			
			| 352 | 364 |          api = ContentApi(
 | 
	
		
			
			| 353 | 365 |              current_user=user,
 | 
	
		
			
			| 354 | 366 |              session=self.session
 | 
	
	
		
			
			|  | @@ -368,7 +380,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 368 | 380 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 369 | 381 |              current_user=None,
 | 
	
		
			
			| 370 | 382 |          )
 | 
	
		
			
			| 371 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 383 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 384 | +            current_user=None,
 | 
	
		
			
			|  | 385 | +            session=self.session
 | 
	
		
			
			|  | 386 | +        )
 | 
	
		
			
			| 372 | 387 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 373 | 388 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 374 | 389 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -376,8 +391,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 376 | 391 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 377 | 392 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 378 | 393 |  
 | 
	
		
			
			| 379 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 380 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 394 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 395 | +            current_user=user,
 | 
	
		
			
			|  | 396 | +            session=self.session
 | 
	
		
			
			|  | 397 | +        ).create_workspace(
 | 
	
		
			
			|  | 398 | +            'test workspace',
 | 
	
		
			
			|  | 399 | +            save_now=True
 | 
	
		
			
			|  | 400 | +        )
 | 
	
		
			
			| 381 | 401 |          api = ContentApi(
 | 
	
		
			
			| 382 | 402 |              current_user=user, 
 | 
	
		
			
			| 383 | 403 |              session=self.session
 | 
	
	
		
			
			|  | @@ -396,7 +416,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 396 | 416 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 397 | 417 |              current_user=None,
 | 
	
		
			
			| 398 | 418 |          )
 | 
	
		
			
			| 399 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 419 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 420 | +            current_user=None,
 | 
	
		
			
			|  | 421 | +            session=self.session
 | 
	
		
			
			|  | 422 | +        )
 | 
	
		
			
			| 400 | 423 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 401 | 424 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 402 | 425 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -404,8 +427,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 404 | 427 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 405 | 428 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 406 | 429 |  
 | 
	
		
			
			| 407 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 408 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 430 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 431 | +            current_user=user,
 | 
	
		
			
			|  | 432 | +            session=self.session
 | 
	
		
			
			|  | 433 | +        ).create_workspace(
 | 
	
		
			
			|  | 434 | +            'test workspace',
 | 
	
		
			
			|  | 435 | +            save_now=True
 | 
	
		
			
			|  | 436 | +        )
 | 
	
		
			
			| 409 | 437 |          api = ContentApi(
 | 
	
		
			
			| 410 | 438 |              current_user=user, 
 | 
	
		
			
			| 411 | 439 |              session=self.session
 | 
	
	
		
			
			|  | @@ -429,7 +457,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 429 | 457 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 430 | 458 |              current_user=None,
 | 
	
		
			
			| 431 | 459 |          )
 | 
	
		
			
			| 432 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 460 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 461 | +            current_user=None,
 | 
	
		
			
			|  | 462 | +            session=self.session
 | 
	
		
			
			|  | 463 | +        )
 | 
	
		
			
			| 433 | 464 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 434 | 465 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 435 | 466 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -437,8 +468,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 437 | 468 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 438 | 469 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 439 | 470 |  
 | 
	
		
			
			| 440 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 441 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 471 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 472 | +            current_user=user,
 | 
	
		
			
			|  | 473 | +            session=self.session
 | 
	
		
			
			|  | 474 | +        ).create_workspace(
 | 
	
		
			
			|  | 475 | +            'test workspace',
 | 
	
		
			
			|  | 476 | +            save_now=True
 | 
	
		
			
			|  | 477 | +        )
 | 
	
		
			
			| 442 | 478 |  
 | 
	
		
			
			| 443 | 479 |          api = ContentApi(
 | 
	
		
			
			| 444 | 480 |              current_user=user,
 | 
	
	
		
			
			|  | @@ -462,7 +498,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 462 | 498 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 463 | 499 |              current_user=None,
 | 
	
		
			
			| 464 | 500 |          )
 | 
	
		
			
			| 465 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 501 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 502 | +            current_user=None,
 | 
	
		
			
			|  | 503 | +            session=self.session
 | 
	
		
			
			|  | 504 | +        )
 | 
	
		
			
			| 466 | 505 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 467 | 506 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 468 | 507 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -477,7 +516,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 477 | 516 |              groups=groups,
 | 
	
		
			
			| 478 | 517 |              save_now=True
 | 
	
		
			
			| 479 | 518 |          )
 | 
	
		
			
			| 480 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
 | 
	
		
			
			|  | 519 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 520 | +            current_user=user,
 | 
	
		
			
			|  | 521 | +            session=self.session
 | 
	
		
			
			|  | 522 | +        ).create_workspace(
 | 
	
		
			
			| 481 | 523 |              'test workspace',
 | 
	
		
			
			| 482 | 524 |              save_now=True
 | 
	
		
			
			| 483 | 525 |          )
 | 
	
	
		
			
			|  | @@ -563,7 +605,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 563 | 605 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 564 | 606 |              current_user=None,
 | 
	
		
			
			| 565 | 607 |          )
 | 
	
		
			
			| 566 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 608 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 609 | +            current_user=None,
 | 
	
		
			
			|  | 610 | +            session=self.session
 | 
	
		
			
			|  | 611 | +        )
 | 
	
		
			
			| 567 | 612 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 568 | 613 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 569 | 614 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -578,7 +623,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 578 | 623 |              groups=groups,
 | 
	
		
			
			| 579 | 624 |              save_now=True
 | 
	
		
			
			| 580 | 625 |          )
 | 
	
		
			
			| 581 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
 | 
	
		
			
			|  | 626 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 627 | +            current_user=user,
 | 
	
		
			
			|  | 628 | +            session=self.session
 | 
	
		
			
			|  | 629 | +        ).create_workspace(
 | 
	
		
			
			| 582 | 630 |              'test workspace',
 | 
	
		
			
			| 583 | 631 |              save_now=True
 | 
	
		
			
			| 584 | 632 |          )
 | 
	
	
		
			
			|  | @@ -665,7 +713,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 665 | 713 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 666 | 714 |              current_user=None,
 | 
	
		
			
			| 667 | 715 |          )
 | 
	
		
			
			| 668 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 716 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 717 | +            current_user=None,
 | 
	
		
			
			|  | 718 | +            session=self.session
 | 
	
		
			
			|  | 719 | +        )
 | 
	
		
			
			| 669 | 720 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 670 | 721 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 671 | 722 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -680,7 +731,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 680 | 731 |              groups=groups,
 | 
	
		
			
			| 681 | 732 |              save_now=True
 | 
	
		
			
			| 682 | 733 |          )
 | 
	
		
			
			| 683 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
 | 
	
		
			
			|  | 734 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 735 | +            current_user=user,
 | 
	
		
			
			|  | 736 | +            session=self.session
 | 
	
		
			
			|  | 737 | +        ).create_workspace(
 | 
	
		
			
			| 684 | 738 |              'test workspace',
 | 
	
		
			
			| 685 | 739 |              save_now=True
 | 
	
		
			
			| 686 | 740 |          )
 | 
	
	
		
			
			|  | @@ -753,7 +807,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 753 | 807 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 754 | 808 |              current_user=None,
 | 
	
		
			
			| 755 | 809 |          )
 | 
	
		
			
			| 756 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 810 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 811 | +            current_user=None,
 | 
	
		
			
			|  | 812 | +            session=self.session
 | 
	
		
			
			|  | 813 | +        )
 | 
	
		
			
			| 757 | 814 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 758 | 815 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 759 | 816 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -778,8 +835,12 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 778 | 835 |              current_user=user_a,
 | 
	
		
			
			| 779 | 836 |              session=self.session,
 | 
	
		
			
			| 780 | 837 |          )
 | 
	
		
			
			| 781 |  | -        role_api1.create_one(user_b, workspace1, UserRoleInWorkspace.READER,
 | 
	
		
			
			| 782 |  | -                            False)
 | 
	
		
			
			|  | 838 | +        role_api1.create_one(
 | 
	
		
			
			|  | 839 | +            user_b,
 | 
	
		
			
			|  | 840 | +            workspace1,
 | 
	
		
			
			|  | 841 | +            UserRoleInWorkspace.READER,
 | 
	
		
			
			|  | 842 | +            False
 | 
	
		
			
			|  | 843 | +        )
 | 
	
		
			
			| 783 | 844 |  
 | 
	
		
			
			| 784 | 845 |          role_api2 = RoleApi(
 | 
	
		
			
			| 785 | 846 |              current_user=user_b,
 | 
	
	
		
			
			|  | @@ -797,7 +858,6 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 797 | 858 |              session=self.session,
 | 
	
		
			
			| 798 | 859 |          )
 | 
	
		
			
			| 799 | 860 |  
 | 
	
		
			
			| 800 |  | -
 | 
	
		
			
			| 801 | 861 |          # Creates page_1 & page_2 in workspace 1
 | 
	
		
			
			| 802 | 862 |          #     and page_3 & page_4 in workspace 2
 | 
	
		
			
			| 803 | 863 |          page_1 = cont_api_a.create(ContentType.Page, workspace1, None,
 | 
	
	
		
			
			|  | @@ -848,18 +908,30 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 848 | 908 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 849 | 909 |              current_user=None,
 | 
	
		
			
			| 850 | 910 |          )
 | 
	
		
			
			| 851 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 911 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 912 | +            current_user=None,
 | 
	
		
			
			|  | 913 | +            session=self.session
 | 
	
		
			
			|  | 914 | +        )
 | 
	
		
			
			| 852 | 915 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 853 | 916 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 854 | 917 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 855 | 918 |  
 | 
	
		
			
			| 856 |  | -        user_a = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 857 |  | -                                 groups=groups, save_now=True)
 | 
	
		
			
			| 858 |  | -        user_b = uapi.create_user(email='this.is@another.user',
 | 
	
		
			
			| 859 |  | -                                 groups=groups, save_now=True)
 | 
	
		
			
			|  | 919 | +        user_a = uapi.create_user(
 | 
	
		
			
			|  | 920 | +            email='this.is@user',
 | 
	
		
			
			|  | 921 | +            groups=groups,
 | 
	
		
			
			|  | 922 | +            save_now=True
 | 
	
		
			
			|  | 923 | +        )
 | 
	
		
			
			|  | 924 | +        user_b = uapi.create_user(
 | 
	
		
			
			|  | 925 | +            email='this.is@another.user',
 | 
	
		
			
			|  | 926 | +            groups=groups,
 | 
	
		
			
			|  | 927 | +            save_now=True
 | 
	
		
			
			|  | 928 | +        )
 | 
	
		
			
			| 860 | 929 |  
 | 
	
		
			
			| 861 | 930 |          wapi = WorkspaceApi(current_user=user_a, session=self.session)
 | 
	
		
			
			| 862 |  | -        workspace_api = WorkspaceApi(current_user=user_a, session=self.session)
 | 
	
		
			
			|  | 931 | +        workspace_api = WorkspaceApi(
 | 
	
		
			
			|  | 932 | +            current_user=user_a,
 | 
	
		
			
			|  | 933 | +            session=self.session
 | 
	
		
			
			|  | 934 | +        )
 | 
	
		
			
			| 863 | 935 |          workspace = wapi.create_workspace(
 | 
	
		
			
			| 864 | 936 |              'test workspace',
 | 
	
		
			
			| 865 | 937 |              save_now=True)
 | 
	
	
		
			
			|  | @@ -868,7 +940,12 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 868 | 940 |              current_user=user_a,
 | 
	
		
			
			| 869 | 941 |              session=self.session,
 | 
	
		
			
			| 870 | 942 |          )
 | 
	
		
			
			| 871 |  | -        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
 | 
	
		
			
			|  | 943 | +        role_api.create_one(
 | 
	
		
			
			|  | 944 | +            user_b,
 | 
	
		
			
			|  | 945 | +            workspace,
 | 
	
		
			
			|  | 946 | +            UserRoleInWorkspace.READER,
 | 
	
		
			
			|  | 947 | +            False
 | 
	
		
			
			|  | 948 | +        )
 | 
	
		
			
			| 872 | 949 |          cont_api_a = ContentApi(
 | 
	
		
			
			| 873 | 950 |              current_user=user_a,
 | 
	
		
			
			| 874 | 951 |              session=self.session,
 | 
	
	
		
			
			|  | @@ -889,22 +966,27 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 889 | 966 |          for rev in page_1.revisions:
 | 
	
		
			
			| 890 | 967 |              eq_(user_b in rev.read_by.keys(), True)
 | 
	
		
			
			| 891 | 968 |  
 | 
	
		
			
			| 892 |  | -
 | 
	
		
			
			| 893 | 969 |      def test_mark_read__all(self):
 | 
	
		
			
			| 894 | 970 |          uapi = UserApi(
 | 
	
		
			
			| 895 | 971 |              session=self.session,
 | 
	
		
			
			| 896 | 972 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 897 | 973 |              current_user=None,
 | 
	
		
			
			| 898 | 974 |          )
 | 
	
		
			
			| 899 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 975 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 900 | 976 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 901 | 977 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 902 | 978 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 903 | 979 |  
 | 
	
		
			
			| 904 |  | -        user_a = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 905 |  | -                                 groups=groups, save_now=True)
 | 
	
		
			
			| 906 |  | -        user_b = uapi.create_user(email='this.is@another.user',
 | 
	
		
			
			| 907 |  | -                                 groups=groups, save_now=True)
 | 
	
		
			
			|  | 980 | +        user_a = uapi.create_user(
 | 
	
		
			
			|  | 981 | +            email='this.is@user',
 | 
	
		
			
			|  | 982 | +            groups=groups,
 | 
	
		
			
			|  | 983 | +            save_now=True
 | 
	
		
			
			|  | 984 | +        )
 | 
	
		
			
			|  | 985 | +        user_b = uapi.create_user(
 | 
	
		
			
			|  | 986 | +            email='this.is@another.user',
 | 
	
		
			
			|  | 987 | +            groups=groups,
 | 
	
		
			
			|  | 988 | +            save_now=True
 | 
	
		
			
			|  | 989 | +        )
 | 
	
		
			
			| 908 | 990 |  
 | 
	
		
			
			| 909 | 991 |          wapi = WorkspaceApi(
 | 
	
		
			
			| 910 | 992 |              current_user=user_a,
 | 
	
	
		
			
			|  | @@ -918,7 +1000,12 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 918 | 1000 |              current_user=user_a,
 | 
	
		
			
			| 919 | 1001 |              session=self.session,
 | 
	
		
			
			| 920 | 1002 |          )
 | 
	
		
			
			| 921 |  | -        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
 | 
	
		
			
			|  | 1003 | +        role_api.create_one(
 | 
	
		
			
			|  | 1004 | +            user_b,
 | 
	
		
			
			|  | 1005 | +            workspace,
 | 
	
		
			
			|  | 1006 | +            UserRoleInWorkspace.READER,
 | 
	
		
			
			|  | 1007 | +            False
 | 
	
		
			
			|  | 1008 | +        )
 | 
	
		
			
			| 922 | 1009 |          cont_api_a = ContentApi(
 | 
	
		
			
			| 923 | 1010 |              current_user=user_a,
 | 
	
		
			
			| 924 | 1011 |              session=self.session,
 | 
	
	
		
			
			|  | @@ -928,9 +1015,27 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 928 | 1015 |              session=self.session,
 | 
	
		
			
			| 929 | 1016 |          )
 | 
	
		
			
			| 930 | 1017 |  
 | 
	
		
			
			| 931 |  | -        page_2 = cont_api_a.create(ContentType.Page, workspace, None, 'this is page1', do_save=True)
 | 
	
		
			
			| 932 |  | -        page_3 = cont_api_a.create(ContentType.Thread, workspace, None, 'this is page2', do_save=True)
 | 
	
		
			
			| 933 |  | -        page_4 = cont_api_a.create(ContentType.File, workspace, None, 'this is page3', do_save=True)
 | 
	
		
			
			|  | 1018 | +        page_2 = cont_api_a.create(
 | 
	
		
			
			|  | 1019 | +            ContentType.Page,
 | 
	
		
			
			|  | 1020 | +            workspace,
 | 
	
		
			
			|  | 1021 | +            None,
 | 
	
		
			
			|  | 1022 | +            'this is page1',
 | 
	
		
			
			|  | 1023 | +            do_save=True
 | 
	
		
			
			|  | 1024 | +        )
 | 
	
		
			
			|  | 1025 | +        page_3 = cont_api_a.create(
 | 
	
		
			
			|  | 1026 | +            ContentType.Thread,
 | 
	
		
			
			|  | 1027 | +            workspace,
 | 
	
		
			
			|  | 1028 | +            None,
 | 
	
		
			
			|  | 1029 | +            'this is page2',
 | 
	
		
			
			|  | 1030 | +            do_save=True
 | 
	
		
			
			|  | 1031 | +        )
 | 
	
		
			
			|  | 1032 | +        page_4 = cont_api_a.create(
 | 
	
		
			
			|  | 1033 | +            ContentType.File,
 | 
	
		
			
			|  | 1034 | +            workspace,
 | 
	
		
			
			|  | 1035 | +            None,
 | 
	
		
			
			|  | 1036 | +            'this is page3',
 | 
	
		
			
			|  | 1037 | +            do_save=True
 | 
	
		
			
			|  | 1038 | +        )
 | 
	
		
			
			| 934 | 1039 |  
 | 
	
		
			
			| 935 | 1040 |          for rev in page_2.revisions:
 | 
	
		
			
			| 936 | 1041 |              eq_(user_b not in rev.read_by.keys(), True)
 | 
	
	
		
			
			|  | @@ -952,23 +1057,22 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 952 | 1057 |          for rev in page_4.revisions:
 | 
	
		
			
			| 953 | 1058 |              eq_(user_b in rev.read_by.keys(), True)
 | 
	
		
			
			| 954 | 1059 |  
 | 
	
		
			
			| 955 |  | -
 | 
	
		
			
			| 956 |  | -
 | 
	
		
			
			| 957 |  | -
 | 
	
		
			
			| 958 |  | -
 | 
	
		
			
			| 959 | 1060 |      def test_update(self):
 | 
	
		
			
			| 960 | 1061 |          uapi = UserApi(
 | 
	
		
			
			| 961 | 1062 |              session=self.session,
 | 
	
		
			
			| 962 | 1063 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 963 | 1064 |              current_user=None,
 | 
	
		
			
			| 964 | 1065 |          )
 | 
	
		
			
			| 965 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1066 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 966 | 1067 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 967 | 1068 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 968 | 1069 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 969 | 1070 |  
 | 
	
		
			
			| 970 |  | -        user1 = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 971 |  | -                                groups=groups, save_now=True)
 | 
	
		
			
			|  | 1071 | +        user1 = uapi.create_user(
 | 
	
		
			
			|  | 1072 | +            email='this.is@user',
 | 
	
		
			
			|  | 1073 | +            groups=groups,
 | 
	
		
			
			|  | 1074 | +            save_now=True
 | 
	
		
			
			|  | 1075 | +        )
 | 
	
		
			
			| 972 | 1076 |  
 | 
	
		
			
			| 973 | 1077 |          workspace_api = WorkspaceApi(current_user=user1, session=self.session)
 | 
	
		
			
			| 974 | 1078 |          workspace = workspace_api.create_workspace(
 | 
	
	
		
			
			|  | @@ -982,10 +1086,16 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 982 | 1086 |          user2.email = 'this.is@another.user'
 | 
	
		
			
			| 983 | 1087 |          uapi.save(user2)
 | 
	
		
			
			| 984 | 1088 |  
 | 
	
		
			
			| 985 |  | -        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
 | 
	
		
			
			| 986 |  | -                                  UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			| 987 |  | -                                  with_notif=False,
 | 
	
		
			
			| 988 |  | -                                  flush=True)
 | 
	
		
			
			|  | 1089 | +        RoleApi(
 | 
	
		
			
			|  | 1090 | +            current_user=user1,
 | 
	
		
			
			|  | 1091 | +            session=self.session
 | 
	
		
			
			|  | 1092 | +        ).create_one(
 | 
	
		
			
			|  | 1093 | +            user2,
 | 
	
		
			
			|  | 1094 | +            workspace,
 | 
	
		
			
			|  | 1095 | +            UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			|  | 1096 | +            with_notif=False,
 | 
	
		
			
			|  | 1097 | +            flush=True
 | 
	
		
			
			|  | 1098 | +        )
 | 
	
		
			
			| 989 | 1099 |  
 | 
	
		
			
			| 990 | 1100 |          # Test starts here
 | 
	
		
			
			| 991 | 1101 |  
 | 
	
	
		
			
			|  | @@ -1034,7 +1144,11 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1034 | 1144 |             tm=transaction.manager,
 | 
	
		
			
			| 1035 | 1145 |             content=content2,
 | 
	
		
			
			| 1036 | 1146 |          ):
 | 
	
		
			
			| 1037 |  | -            api2.update_content(content2, 'this is an updated page', 'new content')
 | 
	
		
			
			|  | 1147 | +            api2.update_content(
 | 
	
		
			
			|  | 1148 | +                content2,
 | 
	
		
			
			|  | 1149 | +                'this is an updated page',
 | 
	
		
			
			|  | 1150 | +                'new content'
 | 
	
		
			
			|  | 1151 | +            )
 | 
	
		
			
			| 1038 | 1152 |          api2.save(content2)
 | 
	
		
			
			| 1039 | 1153 |          transaction.commit()
 | 
	
		
			
			| 1040 | 1154 |  
 | 
	
	
		
			
			|  | @@ -1064,7 +1178,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1064 | 1178 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1065 | 1179 |              current_user=None,
 | 
	
		
			
			| 1066 | 1180 |          )
 | 
	
		
			
			| 1067 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1181 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 1182 | +            current_user=None,
 | 
	
		
			
			|  | 1183 | +            session=self.session
 | 
	
		
			
			|  | 1184 | +        )
 | 
	
		
			
			| 1068 | 1185 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1069 | 1186 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1070 | 1187 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -1075,7 +1192,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1075 | 1192 |              save_now=True,
 | 
	
		
			
			| 1076 | 1193 |          )
 | 
	
		
			
			| 1077 | 1194 |  
 | 
	
		
			
			| 1078 |  | -        workspace = WorkspaceApi(user1).create_workspace(
 | 
	
		
			
			|  | 1195 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 1196 | +            current_user=user1,
 | 
	
		
			
			|  | 1197 | +            session=self.session,
 | 
	
		
			
			|  | 1198 | +        ).create_workspace(
 | 
	
		
			
			| 1079 | 1199 |              'test workspace',
 | 
	
		
			
			| 1080 | 1200 |              save_now=True
 | 
	
		
			
			| 1081 | 1201 |          )
 | 
	
	
		
			
			|  | @@ -1084,7 +1204,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1084 | 1204 |          user2.email = 'this.is@another.user'
 | 
	
		
			
			| 1085 | 1205 |          uapi.save(user2)
 | 
	
		
			
			| 1086 | 1206 |  
 | 
	
		
			
			| 1087 |  | -        RoleApi(current_user=user1,session=self.session).create_one(
 | 
	
		
			
			|  | 1207 | +        RoleApi(
 | 
	
		
			
			|  | 1208 | +            current_user=user1,
 | 
	
		
			
			|  | 1209 | +            session=self.session
 | 
	
		
			
			|  | 1210 | +        ).create_one(
 | 
	
		
			
			| 1088 | 1211 |              user2,
 | 
	
		
			
			| 1089 | 1212 |              workspace,
 | 
	
		
			
			| 1090 | 1213 |              UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
	
		
			
			|  | @@ -1106,7 +1229,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1106 | 1229 |          api.save(page, ActionDescription.CREATION, do_notify=True)
 | 
	
		
			
			| 1107 | 1230 |          transaction.commit()
 | 
	
		
			
			| 1108 | 1231 |  
 | 
	
		
			
			| 1109 |  | -        api2 = ContentApi(user2)
 | 
	
		
			
			|  | 1232 | +        api2 = ContentApi(
 | 
	
		
			
			|  | 1233 | +            current_user=user2,
 | 
	
		
			
			|  | 1234 | +            session=self.session,
 | 
	
		
			
			|  | 1235 | +        )
 | 
	
		
			
			| 1110 | 1236 |          content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
 | 
	
		
			
			| 1111 | 1237 |          with new_revision(
 | 
	
		
			
			| 1112 | 1238 |             session=self.session,
 | 
	
	
		
			
			|  | @@ -1127,13 +1253,19 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1127 | 1253 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1128 | 1254 |              current_user=None,
 | 
	
		
			
			| 1129 | 1255 |          )
 | 
	
		
			
			| 1130 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1256 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 1257 | +            current_user=None,
 | 
	
		
			
			|  | 1258 | +            session=self.session
 | 
	
		
			
			|  | 1259 | +        )
 | 
	
		
			
			| 1131 | 1260 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1132 | 1261 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1133 | 1262 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 1134 | 1263 |  
 | 
	
		
			
			| 1135 |  | -        user1 = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1136 |  | -                                groups=groups, save_now=True)
 | 
	
		
			
			|  | 1264 | +        user1 = uapi.create_user(
 | 
	
		
			
			|  | 1265 | +            email='this.is@user',
 | 
	
		
			
			|  | 1266 | +            groups=groups,
 | 
	
		
			
			|  | 1267 | +            save_now=True
 | 
	
		
			
			|  | 1268 | +        )
 | 
	
		
			
			| 1137 | 1269 |  
 | 
	
		
			
			| 1138 | 1270 |          workspace_api = WorkspaceApi(current_user=user1, session=self.session)
 | 
	
		
			
			| 1139 | 1271 |          workspace = workspace_api.create_workspace(
 | 
	
	
		
			
			|  | @@ -1146,10 +1278,16 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1146 | 1278 |          user2.email = 'this.is@another.user'
 | 
	
		
			
			| 1147 | 1279 |          uapi.save(user2)
 | 
	
		
			
			| 1148 | 1280 |  
 | 
	
		
			
			| 1149 |  | -        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
 | 
	
		
			
			| 1150 |  | -                                  UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			| 1151 |  | -                                  with_notif=True,
 | 
	
		
			
			| 1152 |  | -                                  flush=True)
 | 
	
		
			
			|  | 1281 | +        RoleApi(
 | 
	
		
			
			|  | 1282 | +            current_user=user1,
 | 
	
		
			
			|  | 1283 | +            session=self.session,
 | 
	
		
			
			|  | 1284 | +        ).create_one(
 | 
	
		
			
			|  | 1285 | +            user2,
 | 
	
		
			
			|  | 1286 | +            workspace,
 | 
	
		
			
			|  | 1287 | +            UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			|  | 1288 | +            with_notif=True,
 | 
	
		
			
			|  | 1289 | +            flush=True
 | 
	
		
			
			|  | 1290 | +        )
 | 
	
		
			
			| 1153 | 1291 |  
 | 
	
		
			
			| 1154 | 1292 |          # Test starts here
 | 
	
		
			
			| 1155 | 1293 |          api = ContentApi(
 | 
	
	
		
			
			|  | @@ -1220,7 +1358,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1220 | 1358 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1221 | 1359 |              current_user=None,
 | 
	
		
			
			| 1222 | 1360 |          )
 | 
	
		
			
			| 1223 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1361 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 1362 | +            current_user=None,
 | 
	
		
			
			|  | 1363 | +            session=self.session,
 | 
	
		
			
			|  | 1364 | +        )
 | 
	
		
			
			| 1224 | 1365 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1225 | 1366 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1226 | 1367 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -1241,7 +1382,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1241 | 1382 |          user2.email = 'this.is@another.user'
 | 
	
		
			
			| 1242 | 1383 |          uapi.save(user2)
 | 
	
		
			
			| 1243 | 1384 |  
 | 
	
		
			
			| 1244 |  | -        RoleApi(current_user=user1,session=self.session).create_one(
 | 
	
		
			
			|  | 1385 | +        RoleApi(
 | 
	
		
			
			|  | 1386 | +            current_user=user1,
 | 
	
		
			
			|  | 1387 | +            session=self.session,
 | 
	
		
			
			|  | 1388 | +        ).create_one(
 | 
	
		
			
			| 1245 | 1389 |              user2,
 | 
	
		
			
			| 1246 | 1390 |              workspace,
 | 
	
		
			
			| 1247 | 1391 |              UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
	
		
			
			|  | @@ -1281,20 +1425,22 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1281 | 1425 |          api2.save(content2)
 | 
	
		
			
			| 1282 | 1426 |          transaction.commit()
 | 
	
		
			
			| 1283 | 1427 |  
 | 
	
		
			
			| 1284 |  | -
 | 
	
		
			
			| 1285 | 1428 |      def test_archive_unarchive(self):
 | 
	
		
			
			| 1286 | 1429 |          uapi = UserApi(
 | 
	
		
			
			| 1287 | 1430 |              session=self.session,
 | 
	
		
			
			| 1288 | 1431 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1289 | 1432 |              current_user=None,
 | 
	
		
			
			| 1290 | 1433 |          )
 | 
	
		
			
			| 1291 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1434 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 1292 | 1435 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1293 | 1436 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1294 | 1437 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 1295 | 1438 |  
 | 
	
		
			
			| 1296 |  | -        user1 = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1297 |  | -                                groups=groups, save_now=True)
 | 
	
		
			
			|  | 1439 | +        user1 = uapi.create_user(
 | 
	
		
			
			|  | 1440 | +            email='this.is@user',
 | 
	
		
			
			|  | 1441 | +            groups=groups,
 | 
	
		
			
			|  | 1442 | +            save_now=True
 | 
	
		
			
			|  | 1443 | +        )
 | 
	
		
			
			| 1298 | 1444 |          u1id = user1.user_id
 | 
	
		
			
			| 1299 | 1445 |  
 | 
	
		
			
			| 1300 | 1446 |          workspace_api = WorkspaceApi(current_user=user1, session=self.session)
 | 
	
	
		
			
			|  | @@ -1308,10 +1454,16 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1308 | 1454 |          user2.email = 'this.is@another.user'
 | 
	
		
			
			| 1309 | 1455 |          uapi.save(user2)
 | 
	
		
			
			| 1310 | 1456 |  
 | 
	
		
			
			| 1311 |  | -        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
 | 
	
		
			
			| 1312 |  | -                                  UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			| 1313 |  | -                                  with_notif=True,
 | 
	
		
			
			| 1314 |  | -                                  flush=True)
 | 
	
		
			
			|  | 1457 | +        RoleApi(
 | 
	
		
			
			|  | 1458 | +            current_user=user1,
 | 
	
		
			
			|  | 1459 | +            session=self.session
 | 
	
		
			
			|  | 1460 | +        ).create_one(
 | 
	
		
			
			|  | 1461 | +            user2,
 | 
	
		
			
			|  | 1462 | +            workspace,
 | 
	
		
			
			|  | 1463 | +            UserRoleInWorkspace.CONTENT_MANAGER,
 | 
	
		
			
			|  | 1464 | +            with_notif=True,
 | 
	
		
			
			|  | 1465 | +            flush=True
 | 
	
		
			
			|  | 1466 | +        )
 | 
	
		
			
			| 1315 | 1467 |  
 | 
	
		
			
			| 1316 | 1468 |          # show archived is used at the top end of the test
 | 
	
		
			
			| 1317 | 1469 |          api = ContentApi(
 | 
	
	
		
			
			|  | @@ -1371,7 +1523,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1371 | 1523 |          user1 = UserApi(
 | 
	
		
			
			| 1372 | 1524 |              current_user=None,
 | 
	
		
			
			| 1373 | 1525 |              session=self.session,
 | 
	
		
			
			| 1374 |  | -            config= self.config
 | 
	
		
			
			|  | 1526 | +            config=self.config,
 | 
	
		
			
			| 1375 | 1527 |          ).get_one(u1id)
 | 
	
		
			
			| 1376 | 1528 |          workspace = WorkspaceApi(
 | 
	
		
			
			| 1377 | 1529 |              current_user=user1,
 | 
	
	
		
			
			|  | @@ -1429,8 +1581,11 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1429 | 1581 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1430 | 1582 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
		
			
			| 1431 | 1583 |  
 | 
	
		
			
			| 1432 |  | -        user1 = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1433 |  | -                                groups=groups, save_now=True)
 | 
	
		
			
			|  | 1584 | +        user1 = uapi.create_user(
 | 
	
		
			
			|  | 1585 | +            email='this.is@user',
 | 
	
		
			
			|  | 1586 | +            groups=groups,
 | 
	
		
			
			|  | 1587 | +            save_now=True
 | 
	
		
			
			|  | 1588 | +        )
 | 
	
		
			
			| 1434 | 1589 |          u1id = user1.user_id
 | 
	
		
			
			| 1435 | 1590 |  
 | 
	
		
			
			| 1436 | 1591 |          workspace_api = WorkspaceApi(current_user=user1, session=self.session)
 | 
	
	
		
			
			|  | @@ -1564,7 +1719,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1564 | 1719 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1565 | 1720 |              current_user=None,
 | 
	
		
			
			| 1566 | 1721 |          )
 | 
	
		
			
			| 1567 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1722 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 1723 | +            current_user=None,
 | 
	
		
			
			|  | 1724 | +            session=self.session,
 | 
	
		
			
			|  | 1725 | +        )
 | 
	
		
			
			| 1568 | 1726 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1569 | 1727 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1570 | 1728 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -1572,8 +1730,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1572 | 1730 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1573 | 1731 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 1574 | 1732 |  
 | 
	
		
			
			| 1575 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 1576 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 1733 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 1734 | +            current_user=user,
 | 
	
		
			
			|  | 1735 | +            session=self.session
 | 
	
		
			
			|  | 1736 | +        ).create_workspace(
 | 
	
		
			
			|  | 1737 | +            'test workspace',
 | 
	
		
			
			|  | 1738 | +            save_now=True
 | 
	
		
			
			|  | 1739 | +        )
 | 
	
		
			
			| 1577 | 1740 |  
 | 
	
		
			
			| 1578 | 1741 |          api = ContentApi(
 | 
	
		
			
			| 1579 | 1742 |              current_user=user, 
 | 
	
	
		
			
			|  | @@ -1609,7 +1772,10 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1609 | 1772 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1610 | 1773 |              current_user=None,
 | 
	
		
			
			| 1611 | 1774 |          )
 | 
	
		
			
			| 1612 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1775 | +        group_api = GroupApi(
 | 
	
		
			
			|  | 1776 | +            current_user=None,
 | 
	
		
			
			|  | 1777 | +            session=self.session,
 | 
	
		
			
			|  | 1778 | +        )
 | 
	
		
			
			| 1613 | 1779 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1614 | 1780 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1615 | 1781 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -1617,8 +1783,13 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1617 | 1783 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1618 | 1784 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 1619 | 1785 |  
 | 
	
		
			
			| 1620 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 1621 |  | -                                                        save_now=True)
 | 
	
		
			
			|  | 1786 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 1787 | +            current_user=user,
 | 
	
		
			
			|  | 1788 | +            session=self.session
 | 
	
		
			
			|  | 1789 | +        ).create_workspace(
 | 
	
		
			
			|  | 1790 | +            'test workspace',
 | 
	
		
			
			|  | 1791 | +            save_now=True,
 | 
	
		
			
			|  | 1792 | +        )
 | 
	
		
			
			| 1622 | 1793 |  
 | 
	
		
			
			| 1623 | 1794 |          api = ContentApi(
 | 
	
		
			
			| 1624 | 1795 |              current_user=user, 
 | 
	
	
		
			
			|  | @@ -1654,7 +1825,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1654 | 1825 |              config=CFG(self.config.get_settings()),
 | 
	
		
			
			| 1655 | 1826 |              current_user=None,
 | 
	
		
			
			| 1656 | 1827 |          )
 | 
	
		
			
			| 1657 |  | -        group_api = GroupApi(current_user=None,session=self.session)
 | 
	
		
			
			|  | 1828 | +        group_api = GroupApi(current_user=None, session=self.session)
 | 
	
		
			
			| 1658 | 1829 |          groups = [group_api.get_one(Group.TIM_USER),
 | 
	
		
			
			| 1659 | 1830 |                    group_api.get_one(Group.TIM_MANAGER),
 | 
	
		
			
			| 1660 | 1831 |                    group_api.get_one(Group.TIM_ADMIN)]
 | 
	
	
		
			
			|  | @@ -1662,14 +1833,11 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1662 | 1833 |          user = uapi.create_user(email='this.is@user',
 | 
	
		
			
			| 1663 | 1834 |                                  groups=groups, save_now=True)
 | 
	
		
			
			| 1664 | 1835 |  
 | 
	
		
			
			| 1665 |  | -        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
 | 
	
		
			
			| 1666 |  | -                                                        save_now=True)
 | 
	
		
			
			| 1667 |  | -
 | 
	
		
			
			| 1668 |  | -
 | 
	
		
			
			| 1669 |  | -        api = ContentApi(
 | 
	
		
			
			| 1670 |  | -            current_user=user, 
 | 
	
		
			
			|  | 1836 | +        workspace = WorkspaceApi(
 | 
	
		
			
			|  | 1837 | +            current_user=user,
 | 
	
		
			
			| 1671 | 1838 |              session=self.session
 | 
	
		
			
			| 1672 |  | -        )
 | 
	
		
			
			|  | 1839 | +        ).create_workspace('test workspace', save_now=True)
 | 
	
		
			
			|  | 1840 | +
 | 
	
		
			
			| 1673 | 1841 |          api = ContentApi(
 | 
	
		
			
			| 1674 | 1842 |              current_user=user, 
 | 
	
		
			
			| 1675 | 1843 |              session=self.session
 | 
	
	
		
			
			|  | @@ -1685,7 +1853,7 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1685 | 1853 |              tm=transaction.manager,
 | 
	
		
			
			| 1686 | 1854 |              content=p1,
 | 
	
		
			
			| 1687 | 1855 |          ):
 | 
	
		
			
			| 1688 |  | -           p1.description = 'This is some amazing test'
 | 
	
		
			
			|  | 1856 | +            p1.description = 'This is some amazing test'
 | 
	
		
			
			| 1689 | 1857 |  
 | 
	
		
			
			| 1690 | 1858 |          with new_revision(
 | 
	
		
			
			| 1691 | 1859 |              session=self.session,
 | 
	
	
		
			
			|  | @@ -1713,13 +1881,34 @@ class TestContentApi(DefaultTest):
 | 
	
		
			
			| 1713 | 1881 |          eq_(True, id1 in [o.content_id for o in res.all()])
 | 
	
		
			
			| 1714 | 1882 |          eq_(True, id2 in [o.content_id for o in res.all()])
 | 
	
		
			
			| 1715 | 1883 |  
 | 
	
		
			
			| 1716 |  | -    def test_unit__search_exclude_content_under_deleted_or_archived_parents__ok(self):
 | 
	
		
			
			| 1717 |  | -        admin = self.session.query(User).filter(User.email == 'admin@admin.admin').one()
 | 
	
		
			
			| 1718 |  | -        workspace = self._create_workspace_and_test('workspace_1', admin)
 | 
	
		
			
			| 1719 |  | -        folder_1 = self._create_content_and_test('folder_1', workspace=workspace, type=ContentType.Folder)
 | 
	
		
			
			| 1720 |  | -        folder_2 = self._create_content_and_test('folder_2', workspace=workspace, type=ContentType.Folder)
 | 
	
		
			
			| 1721 |  | -        page_1 = self._create_content_and_test('foo', workspace=workspace, type=ContentType.Page, parent=folder_1)
 | 
	
		
			
			| 1722 |  | -        page_2 = self._create_content_and_test('bar', workspace=workspace, type=ContentType.Page, parent=folder_2)
 | 
	
		
			
			|  | 1884 | +    def test_unit__search_exclude_content_under_deleted_or_archived_parents__ok(self):  # nopep8
 | 
	
		
			
			|  | 1885 | +        admin = self.session.query(User)\
 | 
	
		
			
			|  | 1886 | +            .filter(User.email == 'admin@admin.admin').one()
 | 
	
		
			
			|  | 1887 | +        workspace = self._create_workspace_and_test(
 | 
	
		
			
			|  | 1888 | +            'workspace_1',
 | 
	
		
			
			|  | 1889 | +            admin
 | 
	
		
			
			|  | 1890 | +        )
 | 
	
		
			
			|  | 1891 | +        folder_1 = self._create_content_and_test(
 | 
	
		
			
			|  | 1892 | +            'folder_1',
 | 
	
		
			
			|  | 1893 | +            workspace=workspace,
 | 
	
		
			
			|  | 1894 | +            type=ContentType.Folder
 | 
	
		
			
			|  | 1895 | +        )
 | 
	
		
			
			|  | 1896 | +        folder_2 = self._create_content_and_test(
 | 
	
		
			
			|  | 1897 | +            'folder_2',
 | 
	
		
			
			|  | 1898 | +            workspace=workspace,
 | 
	
		
			
			|  | 1899 | +            type=ContentType.Folder
 | 
	
		
			
			|  | 1900 | +        )
 | 
	
		
			
			|  | 1901 | +        page_1 = self._create_content_and_test(
 | 
	
		
			
			|  | 1902 | +            'foo', workspace=workspace,
 | 
	
		
			
			|  | 1903 | +            type=ContentType.Page,
 | 
	
		
			
			|  | 1904 | +            parent=folder_1
 | 
	
		
			
			|  | 1905 | +        )
 | 
	
		
			
			|  | 1906 | +        page_2 = self._create_content_and_test(
 | 
	
		
			
			|  | 1907 | +            'bar',
 | 
	
		
			
			|  | 1908 | +            workspace=workspace,
 | 
	
		
			
			|  | 1909 | +            type=ContentType.Page,
 | 
	
		
			
			|  | 1910 | +            parent=folder_2
 | 
	
		
			
			|  | 1911 | +        )
 | 
	
		
			
			| 1723 | 1912 |  
 | 
	
		
			
			| 1724 | 1913 |          api = ContentApi(
 | 
	
		
			
			| 1725 | 1914 |              current_user=admin,
 | 
	
	
		
			
			|  | @@ -1790,21 +1979,30 @@ class TestContentApiSecurity(DefaultTest):
 | 
	
		
			
			| 1790 | 1979 |              save_now=True,
 | 
	
		
			
			| 1791 | 1980 |          )
 | 
	
		
			
			| 1792 | 1981 |  
 | 
	
		
			
			| 1793 |  | -        bob_page = ContentApi(current_user=bob,session=self.session).create(
 | 
	
		
			
			|  | 1982 | +        bob_page = ContentApi(
 | 
	
		
			
			|  | 1983 | +            current_user=bob,
 | 
	
		
			
			|  | 1984 | +            session=self.session
 | 
	
		
			
			|  | 1985 | +        ).create(
 | 
	
		
			
			| 1794 | 1986 |              content_type=ContentType.Page,
 | 
	
		
			
			| 1795 | 1987 |              workspace=bob_workspace,
 | 
	
		
			
			| 1796 | 1988 |              label='bob_page',
 | 
	
		
			
			| 1797 | 1989 |              do_save=True,
 | 
	
		
			
			| 1798 | 1990 |          )
 | 
	
		
			
			| 1799 | 1991 |  
 | 
	
		
			
			| 1800 |  | -        admin_page = ContentApi(current_user=admin,session=self.session).create(
 | 
	
		
			
			|  | 1992 | +        admin_page = ContentApi(
 | 
	
		
			
			|  | 1993 | +            current_user=admin,
 | 
	
		
			
			|  | 1994 | +            session=self.session
 | 
	
		
			
			|  | 1995 | +        ).create(
 | 
	
		
			
			| 1801 | 1996 |              content_type=ContentType.Page,
 | 
	
		
			
			| 1802 | 1997 |              workspace=admin_workspace,
 | 
	
		
			
			| 1803 | 1998 |              label='admin_page',
 | 
	
		
			
			| 1804 | 1999 |              do_save=True,
 | 
	
		
			
			| 1805 | 2000 |          )
 | 
	
		
			
			| 1806 | 2001 |  
 | 
	
		
			
			| 1807 |  | -        bob_viewable = ContentApi(current_user=bob,session=self.session).get_all()
 | 
	
		
			
			|  | 2002 | +        bob_viewable = ContentApi(
 | 
	
		
			
			|  | 2003 | +            current_user=bob,
 | 
	
		
			
			|  | 2004 | +            session=self.session
 | 
	
		
			
			|  | 2005 | +        ).get_all()
 | 
	
		
			
			| 1808 | 2006 |          eq_(1, len(bob_viewable), 'Bob should view only one content')
 | 
	
		
			
			| 1809 | 2007 |          eq_(
 | 
	
		
			
			| 1810 | 2008 |              'bob_page',
 |