From d2dd74aaccb4fa34133da7328467aa248a795546 Mon Sep 17 00:00:00 2001 From: Fabian Stamm Date: Tue, 5 Dec 2017 10:32:45 +0100 Subject: [PATCH] first commit --- .vscode/.ropeproject/config.py | 112 ++++++++++++++++++++++++++++++++ .vscode/.ropeproject/objectdb | Bin 0 -> 6 bytes .vscode/settings.json | 4 ++ radicale_stamm_auth/__init__.py | 34 ++++++++++ radicale_stamm_auth/setup.py | 5 ++ test.py | 13 ++++ 6 files changed, 168 insertions(+) create mode 100644 .vscode/.ropeproject/config.py create mode 100644 .vscode/.ropeproject/objectdb create mode 100644 .vscode/settings.json create mode 100644 radicale_stamm_auth/__init__.py create mode 100644 radicale_stamm_auth/setup.py create mode 100644 test.py diff --git a/.vscode/.ropeproject/config.py b/.vscode/.ropeproject/config.py new file mode 100644 index 0000000..0bf7750 --- /dev/null +++ b/.vscode/.ropeproject/config.py @@ -0,0 +1,112 @@ +# The default ``config.py`` +# flake8: noqa + + +def set_prefs(prefs): + """This function is called before opening the project""" + + # Specify which files and folders to ignore in the project. + # Changes to ignored resources are not added to the history and + # VCSs. Also they are not returned in `Project.get_files()`. + # Note that ``?`` and ``*`` match all characters but slashes. + # '*.pyc': matches 'test.pyc' and 'pkg/test.pyc' + # 'mod*.pyc': matches 'test/mod1.pyc' but not 'mod/1.pyc' + # '.svn': matches 'pkg/.svn' and all of its children + # 'build/*.o': matches 'build/lib.o' but not 'build/sub/lib.o' + # 'build//*.o': matches 'build/lib.o' and 'build/sub/lib.o' + prefs['ignored_resources'] = ['*.pyc', '*~', '.ropeproject', + '.hg', '.svn', '_svn', '.git', '.tox'] + + # Specifies which files should be considered python files. It is + # useful when you have scripts inside your project. Only files + # ending with ``.py`` are considered to be python files by + # default. + #prefs['python_files'] = ['*.py'] + + # Custom source folders: By default rope searches the project + # for finding source folders (folders that should be searched + # for finding modules). You can add paths to that list. Note + # that rope guesses project source folders correctly most of the + # time; use this if you have any problems. + # The folders should be relative to project root and use '/' for + # separating folders regardless of the platform rope is running on. + # 'src/my_source_folder' for instance. + #prefs.add('source_folders', 'src') + + # You can extend python path for looking up modules + #prefs.add('python_path', '~/python/') + + # Should rope save object information or not. + prefs['save_objectdb'] = True + prefs['compress_objectdb'] = False + + # If `True`, rope analyzes each module when it is being saved. + prefs['automatic_soa'] = True + # The depth of calls to follow in static object analysis + prefs['soa_followed_calls'] = 0 + + # If `False` when running modules or unit tests "dynamic object + # analysis" is turned off. This makes them much faster. + prefs['perform_doa'] = True + + # Rope can check the validity of its object DB when running. + prefs['validate_objectdb'] = True + + # How many undos to hold? + prefs['max_history_items'] = 32 + + # Shows whether to save history across sessions. + prefs['save_history'] = True + prefs['compress_history'] = False + + # Set the number spaces used for indenting. According to + # :PEP:`8`, it is best to use 4 spaces. Since most of rope's + # unit-tests use 4 spaces it is more reliable, too. + prefs['indent_size'] = 4 + + # Builtin and c-extension modules that are allowed to be imported + # and inspected by rope. + prefs['extension_modules'] = [] + + # Add all standard c-extensions to extension_modules list. + prefs['import_dynload_stdmods'] = True + + # If `True` modules with syntax errors are considered to be empty. + # The default value is `False`; When `False` syntax errors raise + # `rope.base.exceptions.ModuleSyntaxError` exception. + prefs['ignore_syntax_errors'] = False + + # If `True`, rope ignores unresolvable imports. Otherwise, they + # appear in the importing namespace. + prefs['ignore_bad_imports'] = False + + # If `True`, rope will insert new module imports as + # `from import ` by default. + prefs['prefer_module_from_imports'] = False + + # If `True`, rope will transform a comma list of imports into + # multiple separate import statements when organizing + # imports. + prefs['split_imports'] = False + + # If `True`, rope will remove all top-level import statements and + # reinsert them at the top of the module when making changes. + prefs['pull_imports_to_top'] = True + + # If `True`, rope will sort imports alphabetically by module name instead of + # alphabetically by import statement, with from imports after normal + # imports. + prefs['sort_imports_alphabetically'] = False + + # Location of implementation of rope.base.oi.type_hinting.interfaces.ITypeHintingFactory + # In general case, you don't have to change this value, unless you're an rope expert. + # Change this value to inject you own implementations of interfaces + # listed in module rope.base.oi.type_hinting.providers.interfaces + # For example, you can add you own providers for Django Models, or disable the search + # type-hinting in a class hierarchy, etc. + prefs['type_hinting_factory'] = 'rope.base.oi.type_hinting.factory.default_type_hinting_factory' + + +def project_opened(project): + """This function is called after opening the project""" + # Do whatever you like here! diff --git a/.vscode/.ropeproject/objectdb b/.vscode/.ropeproject/objectdb new file mode 100644 index 0000000000000000000000000000000000000000..0a47446c0ad231c193bdd44ff327ba2ab28bf3d8 GIT binary patch literal 6 NcmZo*sx4&D0{{kv0iOT> literal 0 HcmV?d00001 diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..cec31ed --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "python.autoComplete.extraPaths": [], + "python.linting.enabled": false +} \ No newline at end of file diff --git a/radicale_stamm_auth/__init__.py b/radicale_stamm_auth/__init__.py new file mode 100644 index 0000000..6c9e4a9 --- /dev/null +++ b/radicale_stamm_auth/__init__.py @@ -0,0 +1,34 @@ +from radicale.auth import BaseAuth +import urllib + + +class Auth(BaseAuth): + def _generateBaseUri(endpoint) + server = self.configuration.get("auth", "server") + id = self.configuration.get("auth", "client_id") + secret = self.configuration.get("auth", "client_secret") + return "{}{}?client_id={}&client_secret={}".format(server, endpoint, id, secret) + + def is_authenticated(self, user, password): + if user == None + return False + main_uri = self._generateBaseUri( + "/client/check_pw") + "&uuid=" + user + "&password=" + password + req = urllib.request.urlopen(main_uri, data=None) + jsons = req.read() + data = json.loads(jsons) + print(data["username"], data["uuid"]) + if data["error"] + return False + return True + + def map_login_to_user(self, login) + # Get uuid from username + main_uri = self._generateBaseUri("/client/uuid") + "&username=" + login + req = urllib.request.urlopen(main_uri, data=None) + jsons = req.read() + data = json.loads(jsons) + print(data["error"], data["username"], data["uuid"]) + if data["error"] != None + return None + return data["uuid"] diff --git a/radicale_stamm_auth/setup.py b/radicale_stamm_auth/setup.py new file mode 100644 index 0000000..3cbe888 --- /dev/null +++ b/radicale_stamm_auth/setup.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python3 + +from distutils.core import setup + +setup(name="radicale_stamm_auth", packages=["radicale_stamm_auth"]) diff --git a/test.py b/test.py new file mode 100644 index 0000000..1802f65 --- /dev/null +++ b/test.py @@ -0,0 +1,13 @@ +import urllib.request +import json +user = "test" +password = "test2" +auth_server = "http://localhost:3500/login" +auth_client_id = "213" +auth_secret = "888" +main_uri = "{}?username={}&password={}&client_id={}&client_secret={}".format( + auth_server, user, password, auth_client_id, auth_secret) +req = urllib.request.urlopen(main_uri, data=None) +jsons = req.read() +data = json.loads(jsons) +print(data["username"], data["uuid"])