File: PKG-INFO

package info (click to toggle)
python-django-casclient 1.2.0-2%2Bdeb9u1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 400 kB
  • sloc: python: 764; makefile: 160; sh: 24
file content (184 lines) | stat: -rw-r--r-- 6,581 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
Metadata-Version: 1.1
Name: django-cas-client
Version: 1.2.0
Summary: Django Cas Client
Home-page: http://github.com/kstateome/django-cas/
Author: Derek Stegelman, Garrett Pennington
Author-email: derekst@k-state.edu, garrettp@gmail.com
License: MIT
Description: # django-cas
        
        CAS client for Django.  This library requires Django 1.5 or above, and Python 2.6, 2.7, 3.4
        
        Current version: 1.2.0
        
        This is [K-State's fork](https://github.com/kstateome/django-cas) of [the original](https://bitbucket.org/cpcc/django-cas/overview) and includes [several additional features](https://github.com/kstateome/django-cas/#additional-features) as well as features merged from
        
        *  [KTHse's django-cas2](https://github.com/KTHse/django-cas2).
        *  [Edmund Crewe's proxy ticket patch](http://code.google.com/r/edmundcrewe-proxypatch/source/browse/django-cas-proxy.patch).
        
        
        ## Install
        
        This project is registered on PyPi as django-cas-client.  To install::
        
            pip install django-cas-client==1.2.0
        
        
        ### Add to URLs
        
        Add the login and logout patterns to your main URLS conf.
        
            # CAS
            url(r'^accounts/login/$', 'cas.views.login', name='login'),
            url(r'^accounts/logout/$', 'cas.views.logout', name='logout'),
        
        ### Add middleware and settings
        
        Set your CAS server URL
        
            CAS_SERVER_URL = "https://signin.somehwere/cas/"
        
        Add cas to middleware classes
        
            'cas.middleware.CASMiddleware',
        
        
        ### Add authentication backends
        
            AUTHENTICATION_BACKENDS = (
                'django.contrib.auth.backends.ModelBackend',
                'cas.backends.CASBackend',
            )
        
        ## How to Contribute
        
        Fork and branch off of the ``develop`` branch.  Submit Pull requests back to ``kstateome:develop``.
        
        ### Run The Tests
        
        All PRs must pass unit tests.  To run the tests locally:
        
            pip install -r requirements-dev.txt
            python run_tests.py
        
        
        ## Settings.py for CAS
        
        Add the following to middleware if you want to use CAS::
        
            MIDDLEWARE_CLASSES = (
            'cas.middleware.CASMiddleware',
            )
        
        
        Add these to ``settings.py`` to use the CAS Backend::
        
        
            CAS_SERVER_URL = "Your Cas Server"
            CAS_LOGOUT_COMPLETELY = True
            CAS_PROVIDE_URL_TO_LOGOUT = True
        
        # Additional Features
        
        This fork contains additional features not found in the original:
        *  Proxied Hosts
        *  CAS Response Callbacks
        *  CAS Gateway
        *  Proxy Tickets (From Edmund Crewe)
        
        ## Proxied Hosts
        
        You will need to setup middleware to handle the use of proxies.
        
        Add a setting ``PROXY_DOMAIN`` of the domain you want the client to use.  Then add
        
            MIDDLEWARE_CLASSES = (
            'cas.middleware.ProxyMiddleware',
            )
        
        This middleware needs to be added before the django ``common`` middleware.
        
        
        ## CAS Response Callbacks
        
        To store data from CAS, create a callback function that accepts the ElementTree object from the
        proxyValidate response. There can be multiple callbacks, and they can live anywhere. Define the
        callback(s) in ``settings.py``:
        
            CAS_RESPONSE_CALLBACKS = (
                'path.to.module.callbackfunction',
                'anotherpath.to.module.callbackfunction2',
            )
        
        and create the functions in ``path/to/module.py``:
        
            def callbackfunction(tree):
                username = tree[0][0].text
        
                user, user_created = User.objects.get_or_create(username=username)
                profile, created = user.get_profile()
        
                profile.email = tree[0][1].text
                profile.position = tree[0][2].text
                profile.save()
        
        
        ## CAS Gateway
        
        To use the CAS Gateway feature, first enable it in settings. Trying to use it without explicitly
        enabling this setting will raise an ImproperlyConfigured:
        
            CAS_GATEWAY = True
        
        Then, add the ``gateway`` decorator to a view:
        
            from cas.decorators import gateway
        
            @gateway()
            def foo(request):
                #stuff
                return render(request, 'foo/bar.html')
        
        
        ## Custom Forbidden Page
        
        To show a custom forbidden page, set ``CAS_CUSTOM_FORBIDDEN`` to a ``path.to.some_view``.  Otherwise,
        a generic ``HttpResponseForbidden`` will be returned.
        
        ## Require SSL Login
        
        To force the service url to always target HTTPS, set ``CAS_FORCE_SSL_SERVICE_URL`` to ``True``.
        
        ## Automatically Create Users on First Login
        
        By default, a stub user record will be created on the first successful CAS authentication
        using the username in the response. If this behavior is not desired set
        ``CAS_AUTO_CREATE_USER`` to ``Flase``.
        
        ## Proxy Tickets
        
        This fork also includes
        [Edmund Crewe's proxy ticket patch](http://code.google.com/r/edmundcrewe-proxypatch/source/browse/django-cas-proxy.patch).
        
        You can opt out of the time delay sometimes caused by proxy ticket validation by setting:
        
            CAS_PGT_FETCH_WAIT = False
        
Keywords: django cas
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Framework :: Django
Classifier: Framework :: Django :: 1.5
Classifier: Framework :: Django :: 1.6
Classifier: Framework :: Django :: 1.7
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 2
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content :: CGI Tools/Libraries
Classifier: Topic :: Utilities
Classifier: License :: OSI Approved :: MIT License