def setUp(self): # Set up activities for study_id in settings.DEFAULT_STUDY_IDS: models.Activity.objects.create(study_task_identifier=study_id) self.test_user = UserModel.objects.create_user("bar_user", "*****@*****.**") self.application = Application( name="Test Application", redirect_uris="http://localhost http://example.com http://example.org", user=self.test_user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, ) self.application.save() self.valid_token = AccessToken.objects.create( user=self.test_user, token="12345678901", application=self.application, expires=timezone.now() + datetime.timedelta(days=1), scope="read write" ) oauth2_settings._SCOPES = ["read", "write", "introspection", "dolphin"] oauth2_settings.READ_SCOPE = "read" oauth2_settings.WRITE_SCOPE = "write"
def setUp(self): super(PollAPITestCaseOAuthToolkit, self).setUp() # Prepare OAuth Toolkit Access from oauth2_provider.models import AccessToken, Application ot_application = Application( user=self.user, redirect_uris='http://example.com', client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, name='Test Application') ot_application.save() for scope in self.scopes + (None, ): options = { 'user': self.user, 'application': ot_application, 'expires': datetime.datetime.now() + datetime.timedelta(days=10), 'token': self.token } if scope: scope_attrbute_name = "token_" + scope.replace(" ", "_") options.update({ 'scope': scope, 'token': getattr(self, scope_attrbute_name) }) ot_access_token = AccessToken(**options) ot_access_token.save() self.choice_url = self.urls['choice_toolkit'] self.poll_url = self.urls['poll_toolkit'] self.scoped_choice_url = self.urls['scoped_choice_toolkit'] self.scoped_poll_url = self.urls['scoped_poll_toolkit']
def setUp(self): super(PollAPITestCase, self).setUp() self.poll_1 = Poll.objects.get(pk=1) self.poll_2 = Poll.objects.get(pk=2) self.urls = {} kwargs = {'api_name': 'v1'} for api in ['choice', 'poll']: kwargs['resource_name'] = api self.urls[api] = reverse('api_dispatch_list', kwargs=kwargs) # Create a user. username = '******' email = '*****@*****.**' password = '******' self.user = User.objects.create_user(username, email, password) # Prepare OAuth Toolkit Access ot_application = Application( user=self.user, redirect_uris='http://example.com', client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, name='Test Application' ) ot_application.save() self.ot_token = 'TOKEN' ot_access_token = AccessToken( user=self.user, application=ot_application, expires=datetime.datetime.now() + datetime.timedelta(days=10), scope='read', token=self.ot_token ) ot_access_token.save()
def setUp(self): self.client = APIClient() self.user = User.objects.create_user("Foo", "Bar", "*****@*****.**", "123456") self.user.is_active = True self.user.save() self.dev_user = User.objects.create_user("Foo", "Bar1", "*****@*****.**", "123456") self.dev_user.is_active = True self.dev_user.save() self.application = Application( name="Test Application", user=self.dev_user, client_type=Application.CLIENT_PUBLIC, authorization_grant_type=Application.GRANT_PASSWORD, ) self.application.save() token_request_data = { 'grant_type': 'password', 'username': '******', 'password': '******' } auth_headers = self.get_basic_auth_header(self.application.client_id, self.application.client_secret) response = self.client.post(reverse('oauth2_provider:token'), data=token_request_data, **auth_headers) content = json.loads(response.content.decode("utf-8")) self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + content['access_token'])
def register_application(request): if request.method == 'POST': app_name = request.POST['app_name'] redirect_url = request.POST['redirect_url'] app = None if Application.objects.filter(name=app_name).exists(): app = Application.objects.filter(name=app_name)[0] app.redirect_uris = app.redirect_uris + " " + redirect_url else: admin_user = User.objects.all()[0] app = Application( name=app_name, user=admin_user, redirect_uris=redirect_url, client_type="public", authorization_grant_type="Authorization code", ) app.save() return JsonResponse( { 'clientId': app.client_id, 'clientSecret': app.client_secret }, status=201) else: return HttpResponse(status=200)
def setUp(self): super(PollAPITestCaseOAuthToolkit, self).setUp() # Prepare OAuth Toolkit Access from oauth2_provider.models import AccessToken, Application ot_application = Application( user=self.user, redirect_uris='http://example.com', client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, name='Test Application' ) ot_application.save() for scope in self.scopes + (None,): options = { 'user': self.user, 'application': ot_application, 'expires': datetime.datetime.now() + datetime.timedelta(days=10), 'token': self.token } if scope: scope_attrbute_name = "token_" + scope.replace(" ", "_") options.update({ 'scope': scope, 'token': getattr(self, scope_attrbute_name) }) ot_access_token = AccessToken(**options) ot_access_token.save() self.choice_url = self.urls['choice_toolkit'] self.poll_url = self.urls['poll_toolkit'] self.scoped_choice_url = self.urls['scoped_choice_toolkit'] self.scoped_poll_url = self.urls['scoped_poll_toolkit']
def setUp(self): # add test data self.test_user = User.objects.create_user('test', 'test', '*****@*****.**') # Set Up a Test Application self.application = Application( name="Test Application", redirect_uris="http://localhost", user=self.test_user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, ) self.application.save() self.tok = AccessToken.objects.create( user=self.test_user, token='1234567890', application=self.application, scope='read write', expires=datetime.datetime.now() + datetime.timedelta(days=1) ) self.create_restaurant("Restaurant 1", "Mikonkatu 1, Helsinki") self.create_restaurant("Restaurant 2", "Mikonkatu 5, Helsinki") self.create_restaurant("Restaurant 3", "Mikonkatu 10, Helsinki") self.create_restaurant("Restaurant 4", "Mikonkatu 15, Helsinki")
def setUp(self): super(ProductCategoryTestCase, self).setUp() self.test_user = User.objects.create_user('user1', '*****@*****.**', 'qwer1234') self.application = Application( name="Test Application", user=self.test_user, client_type=Application.CLIENT_PUBLIC, authorization_grant_type=Application.GRANT_PASSWORD, ) self.application.save() self.app = Application.objects.get(name="Test Application") self.tok = AccessToken.objects.create(user=self.test_user, token='1234567890', application=self.application, scope='read write', expires=datetime.now() + timedelta(days=1)) self.test_user_category = UserCategory(title="shift head", ) self.test_user_category.save() self.test_user_system = UserSystem( user=self.test_user, user_categories=self.test_user_category, name='user1_name', ) self.test_user_system.save()
def post(self, request): try: name = request.DATA['name'] username = request.user.username if (OauthApp.objects.filter(name=name).exists()): e_msg = ('application with name: %s already exists.' % name) handle_exception(Exception(e_msg), request) try: user = User.objects.get(username=username) except: e_msg = ('User with name: %s does not exist' % username) handle_exception(Exception(e_msg), request) client_type = OauthApplication.CLIENT_CONFIDENTIAL auth_grant_type = OauthApplication.GRANT_CLIENT_CREDENTIALS app = OauthApplication(name=name, client_type=client_type, authorization_grant_type=auth_grant_type, user=user.user) app.save() oauth_app = OauthApp(name=name, application=app, user=user) oauth_app.save() return Response(OauthAppSerializer(oauth_app).data) except RockStorAPIException: raise except Exception, e: handle_exception(e, request)
def setUp(self): self.test_user = Client.objects.create_user('test', 'user', '*****@*****.**', 'testpassword') self.application = Application( name="Test Application", redirect_uris="http://localhost", user=self.test_user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, ) self.application.save() self.test_account = Account(owner=self.test_user, name='test', domain='http://www.example.com') self.test_account.save() self.test_list = models.List(account=self.test_account, created_by=self.test_user, title="Foo List") self.test_list.save() self.create_url = reverse('lists:list_create', kwargs={'account': self.test_account.uaid}) self.retrieve_url = reverse('lists:retrieve_update_delete', kwargs={ 'ugid': self.test_list.ugid, 'account': self.test_account.uaid, })
class RoleEndpointTest(TestCase): def setUp(self): self.client = APIClient() self.user = User.objects.create_user("Foo", "Bar", "*****@*****.**", "123456") self.dev_user = User.objects.create_user("Foo", "Bar1", "*****@*****.**", "123456") self.application = Application( name="Test Application", user=self.dev_user, client_type=Application.CLIENT_PUBLIC, authorization_grant_type=Application.GRANT_PASSWORD, ) self.application.save() self.token = AccessToken( token="ABC123", user=self.user, expires=datetime.datetime.now() + datetime.timedelta(days=1), scope='read write', application=self.application ) self.token.save() self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.token.token) def tearDown(self): self.application.delete() self.token.delete() self.user.delete() self.dev_user.delete()
def post(self, request): with self._handle_exception(request): name = request.data.get("name") username = request.user.username if OauthApp.objects.filter(name=name).exists(): e_msg = ("Application with name ({}) already exists. Choose a " "different name.").format(name) handle_exception(Exception(e_msg), request, status_code=400) try: user = User.objects.get(username=username) except: e_msg = "User with name ({}) does not exist.".format(username) handle_exception(Exception(e_msg), request) client_type = OauthApplication.CLIENT_CONFIDENTIAL auth_grant_type = OauthApplication.GRANT_CLIENT_CREDENTIALS app = OauthApplication( name=name, client_type=client_type, authorization_grant_type=auth_grant_type, user=user.user, ) app.save() oauth_app = OauthApp(name=name, application=app, user=user) oauth_app.save() return Response(OauthAppSerializer(oauth_app).data)
def register_application(request): if request.method == 'POST': app_name = request.POST['app_name'] redirect_url = request.POST['redirect_url'] app = None if Application.objects.filter(name=app_name).exists(): app = Application.objects.filter(name=app_name)[0] app.redirect_uris = app.redirect_uris + " " + redirect_url else: admin_user = User.objects.all()[0] app = Application( name=app_name, user=admin_user, redirect_uris=redirect_url, client_type=Application.CLIENT_PUBLIC, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, skip_authorization=True) app.save() return JsonResponse( { 'clientId': app.client_id, 'clientSecret': app.client_secret }, status=201) else: return HttpResponse(status=200)
def setUp(self): super(PollAPITestCaseOAuthToolkit, self).setUp() call_command('loaddata', 'polls_api_testdata.json', verbosity=0) self.client = Client() self.poll_1 = Poll.objects.get(pk=1) self.poll_2 = Poll.objects.get(pk=2) self.urls = {} kwargs = {'api_name': 'v1'} apis = [ 'choice_toolkit', 'scoped_choice_toolkit', 'poll_toolkit', 'scoped_poll_toolkit', ] for api in apis: kwargs['resource_name'] = api self.urls[api] = reverse('api_dispatch_list', kwargs=kwargs) # Create a user. username = '******' email = '*****@*****.**' password = '******' self.user = User.objects.create_user(username, email, password) self.scopes = ("read", "write", "read write") for scope in self.scopes: scope_attrbute_name = "token_" + scope.replace(" ", "_") setattr(self, scope_attrbute_name, "TOKEN" + scope) self.token = 'TOKEN' self.scoped_token = self.token_read_write ot_application = Application( user=self.user, redirect_uris='http://example.com', client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, name='Test Application' ) ot_application.save() for scope in self.scopes + (None,): options = { 'user': self.user, 'application': ot_application, 'expires': datetime.datetime.now() + datetime.timedelta(days=10), 'token': self.token } if scope: scope_attrbute_name = "token_" + scope.replace(" ", "_") options.update({ 'scope': scope, 'token': getattr(self, scope_attrbute_name) }) ot_access_token = AccessToken(**options) ot_access_token.save() self.choice_url = self.urls['choice_toolkit'] self.poll_url = self.urls['poll_toolkit'] self.scoped_choice_url = self.urls['scoped_choice_toolkit'] self.scoped_poll_url = self.urls['scoped_poll_toolkit']
def createApplication(self, user, name, id, secret): application = Application() application.user = user application.client_type = 'confidential' application.authorization_grant_type = 'password' application.name = name application.client_id = id application.client_secret = secret application.save()
def handle(self, *args, **options): new_application = Application( user=User.objects.filter(is_superuser=True)[0], client_type="confidential", authorization_grant_type="password", name=options["name"] or "socialauth_application", client_id=options["client_id"] or generate_client_id(), client_secret=options["client_secret"] or generate_client_secret(), ) new_application.save()
def setUp(self): self.test_user = User.objects.create_user("*****@*****.**", "*****@*****.**", "hunter23") self.staff_user = User.objects.create_user("*****@*****.**", "*****@*****.**", "hunter23", is_staff=True) self.application = Application( name = "Django Test", user= self.test_user, client_type = Application.CLIENT_PUBLIC, authorization_grant_type = Application.GRANT_PASSWORD, ) self.application.save()
def setUp(self) -> None: self.user = User.objects.create( username="******", password="******", is_superuser=True ) self.user1 = User.objects.create( username="******", password="******", is_superuser=True ) self.stock1 = Stock.objects.create( name="stock1", description="This is a test stock", launch_date=datetime.now(), ) self.stock2 = Stock.objects.create( name="stock2", description="This is another test stock", launch_date=datetime.now(), ) self.stock1.update_price(13.12) self.stock1.update_price(13.13) self.stock1.add_director("Director1") self.stock1.add_director("Director2") self.stock2.update_price(43.21) self.stock2.update_price(43.22) self.stock2.add_director("Director3") self.stock2.add_director("Director4") self.app = Application( name="Test App", user=self.user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, ) self.app.save() self.token = AccessToken.objects.create( user=self.user, token="123456789", application=self.app, scope="read write", expires=timezone.now() + timedelta(days=1), ) self.token1 = AccessToken.objects.create( user=self.user1, token="12345678911", application=self.app, scope="read", expires=timezone.now() + timedelta(days=1), ) self.auth_write = "Bearer {}".format(self.token.token) self.auth_read = "Bearer {}".format(self.token1.token)
def setUp(self): self.user = UserFactory() self.password = "******" self.user.set_password(self.password) self.user.save() self.app = Application( authorization_grant_type=Application.GRANT_PASSWORD, client_type=Application.CLIENT_CONFIDENTIAL, ) self.app.save() credentials = base64.b64encode('{}:{}'.format(self.app.client_id, self.app.client_secret).encode()).decode() self.client.defaults['HTTP_AUTHORIZATION'] = 'Basic ' + credentials
def create_application(self): app = Application.objects.filter(name="Myinstitute").first() if not app: app = Application( client_type=Application.CLIENT_PUBLIC, name="Myinstitute", user=self.superadmin, authorization_grant_type=Application.GRANT_PASSWORD, client_id=settings.CLIENT_ID, client_secret=settings.CLIENT_SECRET) # noqa app.save() return app
def setUp(self): application = Application( name="Test Application", redirect_uris="http://localhost", client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_CLIENT_CREDENTIALS, ) application.save() self.access_token = AccessToken.objects.create( token='1234567890', application=application, scope='read write', expires=timezone.now() + datetime.timedelta(days=1) )
def setUp(self): self.client = APIClient() self.test_user = User.objects.create_user("Edwin", "J", "*****@*****.**", "123456") self.application = Application( name="Test Application Client Credentials", redirect_uris="http://127.0.0.1:8000/api/", user=self.test_user, client_type=Application.CLIENT_PUBLIC, authorization_grant_type=Application.GRANT_CLIENT_CREDENTIALS, ) self.application.save()
def create_oath2_application(self, user_id): application = Application( name="library_management", client_id="c8fO42qEIvtn2NkHyBAmOwOHnQCYaAlkUTAZHBZW", client_secret= "SbkpN6VebOsjMKDaGYuEnquKwQwohi1UGdNmGdofUQbXI88cLuv6qqrCroDRYMuDKY8IJlQgOQQdctn6YRrOfcdbclfxeVTrkXfCw0AUPKliF35FNbGdfQ03IYHxSYQ3", client_type="confidential", authorization_grant_type="password", user_id=user_id) application.save() return application
def create_google_application(apps, schema_editor): # Application = apps.get_model('oauth2_provider', 'Application') from oauth2_provider.models import Application application = Application( client_id = '4O9vihRrTRAlwcSOJjLxgZgtvWq5ZT4UQzc3NXYx', client_secret = 'QG9uGNUQy6lvGhSYRwkPFban14UMi3juWVw8Y5aV9pOaDdRXIWW4Q7TbuQdvcrnTgbqOn6PPgYKapbr8gIAoCOFoBWimmWjJvHhQI2y2TQBh7DoI1bZfxTVyxH3pM2Iv', name = 'google', redirect_uris = 'https://oauth-redirect.googleusercontent.com/r/budgie-bf791', client_type = 'public', authorization_grant_type = 'authorization-code', ) application.save()
def create_google_application(apps, schema_editor): # Application = apps.get_model('oauth2_provider', 'Application') from oauth2_provider.models import Application application = Application( client_id='4O9vihRrTRAlwcSOJjLxgZgtvWq5ZT4UQzc3NXYx', client_secret= 'QG9uGNUQy6lvGhSYRwkPFban14UMi3juWVw8Y5aV9pOaDdRXIWW4Q7TbuQdvcrnTgbqOn6PPgYKapbr8gIAoCOFoBWimmWjJvHhQI2y2TQBh7DoI1bZfxTVyxH3pM2Iv', name='google', redirect_uris= 'https://oauth-redirect.googleusercontent.com/r/budgie-bf791', client_type='public', authorization_grant_type='authorization-code', ) application.save()
def setUp(self): self.user = User.objects.create_user(first_name="test_name", last_name="test_last_name", password='******', phone_number='+911234567890', username="******") self.application = Application( name="Test Application", redirect_uris="http://localhost http://example.com", user=self.user, client_type="public", authorization_grant_type="password", ) self.application.save()
def create_app(): try: result = Application.objects.get(client_id=settings.TEST_CLIENT_ID) except Application.DoesNotExist: result = Application(client_id=settings.TEST_CLIENT_ID, ) result.name = settings.TEST_CLIENT_NAME result.client_secret = settings.TEST_CLIENT_SECRET result.redirect_uris = settings.TEST_REDIRECT_URIS result.client_type = Application.CLIENT_CONFIDENTIAL result.authorization_grant_type = Application.GRANT_AUTHORIZATION_CODE result.save() return result
def test_login(self): data = { 'code': '209528202', 'nip': 'holapito', 'email': '*****@*****.**', 'phone_number': '3311995533', 'password': '******' } auth = self._create_authorization_header() response = self.client.post('/api/profile/udg_signup/', data, format='json', HTTP_AUTHORIZATION=auth) self.assertEqual(response.status_code, status.HTTP_201_CREATED) first_response = response.data profile = Profile.objects.get(code='209528202') self.assertEqual(profile.type, 'A') user = User.objects.get(pk=response.data['id']) data = { 'code': '208528202', 'nip': 'pablito', 'email': '*****@*****.**', 'phone_number': '3311995533', 'password': '******' } response = self.client.post('/api/profile/udg_signup/', data, format='json', HTTP_AUTHORIZATION=auth) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # # Login created user # application = Application( name="Test Application", redirect_uris="http://localhost", user=user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_PASSWORD, ) application.save() self.access_token = AccessToken.objects.create( user=user, token='1234567891', application=application, scope='read write', expires=timezone.now() + datetime.timedelta(days=1) ) auth = self._create_authorization_header() response = self.client.get('/api/profile/', HTTP_AUTHORIZATION=auth) self.assertEqual(first_response, response.data)
def setup_user_token(): # create user user = User.objects.create_user('hongzhi', password='******') # create oauth application app = Application() app.user = user app.save() token = AccessToken() token.user = user token.expires = timezone.now().replace(year=timezone.now().year + 1) token.application = app token.token = '987654321' token.save() return user, token.token
def setUp(self): self.client = APIClient() self.test_user = User.objects.create_user( first_name='test', last_name='user', username='******', email='*****@*****.**', password='******', ) self.application = Application( name="Test Application", redirect_uris="http://localhost:8000", user=self.test_user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE, ) self.application.save()
def add_auth(entity, user, form): if "client_id" in form.cleaned_data: if "client_secret" in form.cleaned_data: if "token_end_point" in form.cleaned_data: id = form.cleaned_data['client_id'] secret = form.cleaned_data['client_secret'] end_point = form.cleaned_data['token_end_point'] client = OAuthRemoteClient() client.client_id = id client.client_secret = secret client.token_endpoint = end_point client.entity = entity client.save() application = Application() application.user = user application.client_type = 'confidential' application.authorization_grant_type = 'client-credentials' application.name = entity.name application.save() entityOA = EntityOAuth() entityOA.entity = entity entityOA.application = application entityOA.save()
def setUp(self): self.username = "******" self.password = "******" self.tearDown() self.credentials = { 'username': self.username, 'password': self.password } u = User.objects.create_user(**self.credentials) u.is_staff = True u.save() app = Application(client_type='confidential', authorization_grant_type='password', name='Owner', user=u) app.save() self.user = u self.emptyCode = '' self.invalidCode = 'code123' self.fullname = "BSD Zero Clause License" self.shortIdentifier = "0BSD" self.sourceUrl = "http://landley.net/toybox/license.html" self.urls = [self.sourceUrl] self.incorrectOsiApproved = "no" # "no" is not a valid choice for osi self.osiApproved = "Rejected" self.comments = "" self.notes = "" self.licenseHeader = "" self.text = '<text> <copyrightText> <p>Copyright (C) 2006 by Rob Landley <[email protected]></p> </copyrightText> <p>Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.</p> <p>THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.</p> </text>' self.userEmail = "*****@*****.**" self.licenseAuthorName = "" self.listVersionAdded = "" self.xml = '<SPDXLicenseCollection xmlns="http://www.spdx.org/license"> <license isOsiApproved="false" licenseId="0BSD" listVersionAdded="" name="BSD Zero Clause License"> <crossRefs> <crossRef> http://landley.net/toybox/license.html</crossRef> </crossRefs> <standardLicenseHeader /> <notes /> <text> <p> <text> <copyrightText> <p>Copyright (C) 2006 by Rob Landley &lt;[email protected]&gt;</p> </copyrightText> <p>Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.</p> <p>THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.</p> </text></p> </text> </license> </SPDXLicenseCollection> ' self.data = { "fullname": self.fullname, "shortIdentifier": self.shortIdentifier, "sourceUrl": self.sourceUrl, 'osiApproved': self.osiApproved, 'notes': self.notes, "licenseHeader": self.licenseHeader, "text": self.text, "userEmail": self.userEmail, "licenseAuthorName": self.licenseAuthorName, "urlType": "tests" }
def save(self, commit=True): app = Application(**self.cleaned_data) app.authorization_grant_type = Application.GRANT_CLIENT_CREDENTIALS app.user = self.user app.client_type = Application.CLIENT_CONFIDENTIAL app.save(commit) return app
def post(self, request, *args, **kwargs): user = request.user resort = get_resort_for_user(user) operation = request.GET.get('operation', 'generate') # Only manager has the permission to access the resource if resort is not None: role = get_roleid_user(resort=resort, user=user) if role != 3: return Response( {_('detail'): _('you do not have permission to resource')}, status=400) else: return Response({_('detail'): _('no resort associated with user')}, status=400) if operation == 'generate': # If oauth app already exists then return existing credential try: app = ResortOauthApp.objects.get(resort=resort, is_active=True) app = app.oauth_app except: app = Application( user=user, authorization_grant_type='client-credentials', client_type='confidential', name=resort.resort_name) app.save() resort_oauth = ResortOauthApp(resort=resort, oauth_app=app) resort_oauth.save() elif operation == 'regenerate': try: app = ResortOauthApp.objects.get(resort=resort, is_active=True) oauth_app = app.oauth_app oauth_app.delete() except: pass app = Application(user=user, authorization_grant_type='client-credentials', client_type='confidential', name=resort.resort_name) app.save() resort_oauth = ResortOauthApp(resort=resort, oauth_app=app) resort_oauth.save() return Response( { 'client_id': app.client_id, 'client_secret': app.client_secret }, status=200)
def post(self, request): setup = Setup.objects.all()[0] setup.setup_user = True setup.save() # Create user res = super(SetupUserView, self).post(request) # Create cliapp id and secret for oauth name = "cliapp" user = User.objects.get(username=request.DATA["username"]) client_type = OauthApplication.CLIENT_CONFIDENTIAL auth_grant_type = OauthApplication.GRANT_CLIENT_CREDENTIALS app = OauthApplication( name=name, client_type=client_type, authorization_grant_type=auth_grant_type, user=user.user ) app.save() oauth_app = OauthApp(name=name, application=app, user=user) oauth_app.save() return res
def get_or_create_app(name, redirect_uri, user, client_id=None, client_secret=None): """ Get or creates an OAuth2 application. """ try: application = Application.objects.get(name=name) except Application.DoesNotExist: application = Application() application.user = user if client_id and client_secret: application.client_id = client_id application.client_secret = client_secret application.name = name application.authorization_grant_type = Application.GRANT_AUTHORIZATION_CODE application.client_type = Application.CLIENT_CONFIDENTIAL application.redirect_uris = redirect_uri application.save() return application
def save(self, *args, **kwargs): if hasattr(self, "application"): application = self.application else: application = Application() application.name = self.name application.user = self.coordinator.user application.client_type = Application.CLIENT_CONFIDENTIAL application.redirect_uris = self.redirect_url application.authorization_grant_type = Application.GRANT_AUTHORIZATION_CODE application.save() self.application = application super(OAuth2DataRequestProject, self).save(*args, **kwargs)
def post(self, request): with self._handle_exception(request): name = request.data.get('name') username = request.user.username if (OauthApp.objects.filter(name=name).exists()): e_msg = ('Application with name ({}) already exists. Choose a ' 'different name.').format(name) handle_exception(Exception(e_msg), request, status_code=400) try: user = User.objects.get(username=username) except: e_msg = 'User with name ({}) does not exist.'.format(username) handle_exception(Exception(e_msg), request) client_type = OauthApplication.CLIENT_CONFIDENTIAL auth_grant_type = OauthApplication.GRANT_CLIENT_CREDENTIALS app = OauthApplication(name=name, client_type=client_type, authorization_grant_type=auth_grant_type, user=user.user) app.save() oauth_app = OauthApp(name=name, application=app, user=user) oauth_app.save() return Response(OauthAppSerializer(oauth_app).data)
def form_valid(self, form): if Application.objects.filter(name=form.cleaned_data["application_name"]).exists(): messages.warning(self.request, "Application with this name already exists.") else: oapp = OAuthApplication() oapp.description = form.cleaned_data["description"] oapp.website = form.cleaned_data["website"] omodel = Application() omodel.user = self.request.user omodel.redirect_uris = form.cleaned_data["callback_url"] omodel.client_type = "confidential" omodel.authorization_grant_type = "authorization-code" omodel.name = form.cleaned_data["application_name"] omodel.save() oapp.client = omodel oapp.save() messages.success(self.request, "Application Created!") return super(OAuthClientCreateView, self).form_valid(form)