running life

run_auth_token_admin.py

from django.contrib import admin

# Register your models here.

run_auth_token_backends.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'yinzishao'

from django.contrib.auth.backends import ModelBackend
from django.contrib.auth.models import User
from tokens import check_token_in_cache_encode,check_token_in_cache

class TokenCacheBackend(ModelBackend):
    def authenticate(self,pk,token):
        data={}
        data["token"]=token
        data["userpk"]=pk
        # print data
        # user,inf=check_token_in_cache_encode(data)
        user,inf=check_token_in_cache(data)
        print user
        if user:
            return user
        else:
            return None

run_auth_token_decorators.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import json
from django.http.response import HttpResponseForbidden

__author__ = 'yinzishao'
from base64 import b64decode

from django.contrib.auth import authenticate
from django.views.decorators.csrf import csrf_exempt
from functools import wraps

def token_cache_required(view_func):
    @csrf_exempt
    @wraps(view_func)
    def _wrapped_view(request,*args,**kwargs):
        userpk = None
        token = None
        basic_auth = request.META.get('HTTP_AUTHORIZATION')
        userpk = request.POST.get('userpk', request.GET.get('userpk'))
        # userpk = request.POST.get('userpk')
        token = request.POST.get('token', request.GET.get('token'))
        # token = request.POST.get('token')
        print userpk,token
        if not (userpk and token) and request.body:
        # print request.body
            try:
                request_data= json.loads(request.body)
            except Exception:
                return HttpResponseForbidden("data should be json")
            else:
                userpk = request_data['userpk']
                token = request_data['token']
        if not (userpk and token) and basic_auth:
            auth_method, auth_string = basic_auth.split(' ', 1)

            if auth_method.lower() == 'basic':
                auth_string = b64decode(auth_string.strip())
                userpk, token = auth_string.decode().split(':', 1)
        if not (userpk and token):
            return HttpResponseForbidden("Must include 'userpk' and 'token' parameters with request.")
        # print userpk,token
        user = authenticate(pk=userpk, token=token)
        # print user
        if user:
            request.user = user
            return view_func(request, *args, **kwargs)
        return HttpResponseForbidden("authentication failer ")
    return _wrapped_view

run_auth_token_models.py

from django.db import models

# Create your models here.

run_auth_token_redisutil.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'yinzishao'

from redis import Redis
host = 'localhost'
port=6379
r = Redis(host,port,db=0)

#(token,userid)插入redis
def insert_token(data):
    # data={"token": "zASR0MqjgvD_t6bWl9H8x9SPIR1", "userid": "FgsrjCxMETo6hgMNoeR8Tufa1-o"}
    token = data['token']
    userpk =data['userpk']
    r.set(token,userpk)
    # userid_fromredis = r.get(token)
    # print userid_fromredis

#根据token返回userpk
def get_userpk(token):
    # print token,type(token)
    return r.get(token)

#定时清理set（过期时间）
def clear_token():
    pass
# r.flushdb()

#1成功
def delete_token(token):
    return r.delete(token)

token = u"1b46US:_uw-1cM6p3M8H10r7SF3DR6EQCk"
# print get_userpk(token)
# print delete_token("1b45lx:L6pYuXNvwVY3nfo14AkvYsJv-Hk")
# sty = "17:"+"FgsrjCxMETo6hgMNoeR8Tufa1-o"
# print "17:FgsrjCxMETo6hgMNoeR8Tufa1-o"  ==sty

run_auth_token_templates_aut_login.html

{% block content %}

  {% if form.errors %}
    <p class="error">Sorry, that's not a valid username or password</p>
  {% endif %}

  <form action="/auth/" method="post">{% csrf_token %}
    <label for="username">User name:</label>
    <input type="text" name="username" value="" id="username">
    <label for="password">Password:</label>
    <input type="password" name="password" value="" id="password">

    <input type="submit" value="login" />
    <input type="hidden" name="next" value="{{ next|escape }}" />
  </form>

{% endblock %}

run_auth_token_templates_login.html

<!DOCTYPE html>
<html>
<head></head>
<body>
{{ user.date_joined }}
<form action="/login_from_pwd/" method="POST">
    <div data-role="fieldcontain">
        <label for="email">username:</label><input type="text" name="username" id="email" value="" />
    </div>
    <div data-role="fieldcontain">
        <label for="password">Password:</label><input type="password" name="password" id="password" value="" />
    </div>    
    <button type="submit" name="submit" value="submit-value">Sign in</button>
</form>
<body>
<form action="/signup/" method="POST">
    <div data-role="fieldcontain">
        <label for="email">username:</label><input type="text" name="username" id="email" value="" />
    </div>
    <div data-role="fieldcontain">
        <label for="password">Password:</label><input type="password" name="password" id="password" value="" />
    </div>    
    <button type="submit" name="submit" value="submit-value">Sign up</button>
</form>
</body>
</html>

run_auth_token_templates_secure.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
{{user}}
{% if user.is_authenticated %}
    <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
    <p>Welcome, new user. Please log in.</p>
{% endif %}
I'm secure.
<a  href = "/signout"><button src="signout">Sign out</button></a>
</body>
</html>

run_auth_token_tests.py

from django.test import TestCase

# Create your tests here.

run_auth_token_tokens.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.contrib.auth.models import User
from django.http.response import HttpResponse

__author__ = 'yinzishao'

from django.core.signing import Signer,TimestampSigner
from redisutil import get_userpk,delete_token

token_cahce_salt = "make_token_in_cache"
time_signer = TimestampSigner(salt=token_cahce_salt)
user_salt = "user_salt"
user_signer = Signer(salt=user_salt)


#根据id和timestamp生成token
def make_token_in_cache(user):

    userpk = user.pk
    user_str = "userpk"+"-"+str(userpk)
    token = time_signer.sign(user_str)
    return token
    # password =user.password
    # id_pwd=str(userid)+"-"+password
    # value = singer.sign(id_pwd)
        # return HttpResponse(id_pwd)
        # value = singer.sign('token')

#check token in cache withod encode

def check_token_in_cache(data):
    token = data['token']
    userpk= data['userpk']
    userpk_origin = get_userpk(token)
    if userpk_origin:
        # try :
        if userpk ==userpk_origin:
            user = User.objects.get(pk=userpk_origin)
            return user,HttpResponse("succeed")
        else:
            return None,HttpResponse("Login in Fail PK ")
    else:
        return None,HttpResponse("token is not valid ")


#根据token和userpk判断是否出现和篡改
def check_token_in_cache_encode(data):
    token = data['token']
    userpk= data['userpk']
    #过期时间，默认10天
    max_age= 60*60*24*10
    # time_signer.unsign(token)
    userpk_origin = get_userpk(token)
    # print userpk_origin
    if userpk_origin:
        user_str = "userpk"+"-"+str(userpk_origin)
        value = user_str+":"+token
        try:
            time_signer.unsign(value,max_age=max_age)
        except Exception,e:
            # print e.message
            delete_token(token)
            return None,HttpResponse("expired please login in again")
        else:
            userpk_str = str(userpk_origin)+":"+str(userpk)
            # print userpk_str,type(userpk_str),id(userpk_str)
            userpk_sige_str=user_signer.sign(userpk_origin)
            # print userpk_sige_str,type(userpk_sige_str),id(userpk_sige_str)
            if userpk_str ==userpk_sige_str:
                #更新token时间?
                user = User.objects.get(pk=userpk_origin)
                return user,HttpResponse("succeed")
            else:
                return None,HttpResponse("Login in Fail PK ")

    else:
        return None,HttpResponse("Login in Fail")

    #
    # user_str = "userpk"+"-"+str(userpk)
    # value = user_str+":"+token
    # try :
    #     time_signer.unsign(value)
    # except:
    #     return HttpResponse("Token is invalid")
    # else:
    #     return HttpResponse("succeed")

run_auth_token_urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.conf.urls import url

__author__ = 'yinzishao'


urlpatterns = [
    url(r'^login/$','auth_token.views.loginview',name='loginview'),
    url(r'^signup/$','auth_token.views.signup',name='signup'),
    url(r'^auth/$','auth_token.views.auth',name='auth'),
    url(r'^test/$','auth_token.views.test',name='test'),
    url(r'^login_from_pwd/?$','auth_token.views.login_from_pwd',name='login_from_pwd'),
    # url(r'^token/new.json$', token_new, name='api_token_new'),
    # url(r'^token/(?P<token>.{24})/(?P<user>\d+).json$', token, name='api_token'),
]

run_auth_token_views.py

# -*- coding:utf-8 -*-
from base64 import b64decode
import json
from django.contrib.auth import authenticate
from django.contrib.auth.views import login
from django.shortcuts import render, render_to_response,HttpResponse, redirect
from django.contrib.auth.models import User
from django.template.context_processors import csrf
from django.views.decorators.csrf import csrf_exempt
from django.db import IntegrityError
from redisutil import get_userpk,delete_token,insert_token
from tokens import user_signer,make_token_in_cache,check_token_in_cache_encode

# from tokenapi.decorators import token_required
# from tokenapi.views import token_new

# @token_required
def loginview(request):
    # c = {"yin":"yin"}
    # c.update(csrf(request))
    basic_auth = request.META.get('HTTP_AUTHORIZATION')
    # print basic_auth
    return render(request,'login.html')
    # return render_to_response('login.html', c,)

# def auth(request):
#     result =  token_new(request)
#     return result

#注册
def signup(request):
    data={}
    # print request.method
    if request.method == "POST":
        username = request.POST.get('username',None)
        password = request.POST.get('password',None)
        print username,password
        if not (username and password):
            # print request.body
            request_data= json.loads(request.body)
            username =  request_data["username"]
            password =  request_data["password"]
            # email =request_data['email']

        if username and password :
            try:
                print "test get user"
                user = User.objects.get_by_natural_key(username)
                print user
            except User.DoesNotExist,e:
                print e
                user = User.objects.create_user(username,password=password)
                if user.is_active:
                    return HttpResponse("success")
                else:

                    return HttpResponse("fail")
            else:
                return HttpResponse("User already exists")
        else:
            return HttpResponse("username or password is none")


            # print request_data
            # return HttpResponse(request.body,content_type="application/json")
            # print request_data
        # print username,password
        # data['username']=username
        # data['password']=password
        # return HttpResponse(json.dumps(data),content_type="application/json")

    return HttpResponse("signup fail")


#用户密码登录返回token
def login_from_pwd(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
    # username="yzs"
    # password="pwd"
        if username and password:
            user = authenticate(username=username,password=password)

            if user and user.is_active:
                login(request,user)
                token = make_token_in_cache(user).split(":",1)[1]

                #将{token:id}放在redis内
                redis_data = {
                    'token':token,
                    'userpk':user.pk,
                }
                insert_token(redis_data)
                #将pk加密

                # userpk_encode = user_signer.sign(user.pk).split(":",1)[1]
                # data = {
                #     'token':token,
                #     'userpk':userpk_encode,
                # }
                #不加密
                data = {
                    'token':token,
                    'userpk':user.pk,
                }
                return HttpResponse(json.dumps(data),content_type="application/json")
            else:
                return HttpResponse("Fail")
    else:
            return HttpResponse("POST is required")
from decorators import token_cache_required

@token_cache_required
# @csrf_exempt
def test(request):
    # basic_auth = request.META.get('HTTP_AUTHORIZATION')
    # userpk = request.POST.get('userpk', request.GET.get('userpk'))
    # token = request.POST.get('token', request.GET.get('token'))
    # print userpk,token
    # if not (userpk and token) and basic_auth:
    #         auth_method, auth_string = basic_auth.split(' ', 1)
    #
    #         if auth_method.lower() == 'basic':
    #             auth_string = b64decode(auth_string.strip())
    #             userpk, token = auth_string.decode().split(':', 1)
    # if not (userpk and token):
    #     # print request.body
    #     request_data= json.loads(request.body)
    #     userpk = request_data['userpk']
    #     token = request_data['token']
    # print userpk,token
    # us = None
    # pw = None
    # print request.method
    # if request.method == 'POST':
    #     print "POST"
    #     # print request.META
    #     print request.POST
    #     us = request.POST.get('userpk')
    #     pw = request.POST.get('token')
    # print us,pw
    return HttpResponse("token login succeed")
    # data={
    #     "token": "1b46US:_uw-1cM6p3M8H10r7SF3DR6EQCk",
    #     "userpk": "FgsrjCxMETo6hgMNoeR8Tufa1-o",
    # }
    # return check_token_in_cache(data)

    #
    # """
    # 测试密码登陆
    # """
    # if request.method == 'POST':
    #     username = request.POST.get('username')
    #     password = request.POST.get('password')
    # username="yzs"
    # password="pwd"
    # if username and password:
    #     user = authenticate(username=username,password=password)
    #
    #     if user and user.is_active:
    #         login(request,user)
    #         token = make_token_in_cache(user).split(":",1)[1]
    #
    #         #将{token:id}放在redis内
    #         redis_data = {
    #             'token':token,
    #             'userpk':user.pk,
    #         }
    #         insert_token(redis_data)
    #         #将pk加密
    #         userpk = user_signer.sign(user.pk).split(":",1)[1]
    #
    #         data = {
    #             'token':token,
    #             'userpk':userpk,
    #         }
    #         return HttpResponse(json.dumps(data),content_type="application/json")
    #     else:
    #         return HttpResponse("Fail")


def createUser(**kwargs):
    username = kwargs['username']
    password = kwargs['password']
    email = kwargs['email']
    try:
        user = User.objects.create_user(username,email,password)
    except IntegrityError:
        HttpResponse("Fail")
    # if user.







#
#
# def auth_and_login(request, onsuccess='/secure', onfail='/login/'):
#     user = authenticate(username=request.POST['email'], password=request.POST['password'])
#     if user is not None and user.is_active:
#         login(request, user)
#         request.session['name'] = "yin"
#         return redirect(onsuccess)
#     else:
#         return redirect(onfail)
#
# def create_user(username, email, password):
#     user = User(username=username, email=email)
#     user.set_password(password)
#     user.save()
#     return user
#
# def user_exists(username):
#     user_count = User.objects.filter(username=username).count()
#     if user_count == 0:
#         return False
#     return True
#
# def sign_up_in(request):
#     post = request.POST
#     if not user_exists(post['email']):
#         user = create_user(username=post['email'], email=post['email'], password=post['password'])
#         return auth_and_login(request)
#     else:
#         return redirect("/login/")

run_manage.py

#!/usr/bin/env python
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "run.settings")

    from django.core.management import execute_from_command_line

    execute_from_command_line(sys.argv)

run_run_models.py

# This is an auto-generated Django model module.
# You'll have to do the following manually to clean this up:
#   * Rearrange models' order
#   * Make sure each model has one field with primary_key=True
#   * Remove `managed = False` lines if you wish to allow Django to create, modify, and delete the table
# Feel free to rename the models, but don't rename db_table values or field names.
#
# Also note: You'll have to insert the output of 'django-admin sqlcustom [app_label]'
# into your database.
from __future__ import unicode_literals

from django.db import models


class AuthGroup(models.Model):
    name = models.CharField(unique=True, max_length=80)

    class Meta:
        managed = False
        db_table = 'auth_group'


class AuthGroupPermissions(models.Model):
    group = models.ForeignKey(AuthGroup)
    permission = models.ForeignKey('AuthPermission')

    class Meta:
        managed = False
        db_table = 'auth_group_permissions'
        unique_together = (('group_id', 'permission_id'),)


class AuthPermission(models.Model):
    name = models.CharField(max_length=255)
    content_type = models.ForeignKey('DjangoContentType')
    codename = models.CharField(max_length=100)

    class Meta:
        managed = False
        db_table = 'auth_permission'
        unique_together = (('content_type_id', 'codename'),)


class AuthUser(models.Model):
    password = models.CharField(max_length=128)
    last_login = models.DateTimeField(blank=True, null=True)
    is_superuser = models.IntegerField()
    username = models.CharField(unique=True, max_length=30)
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    email = models.CharField(max_length=254)
    is_staff = models.IntegerField()
    is_active = models.IntegerField()
    date_joined = models.DateTimeField()

    class Meta:
        managed = False
        db_table = 'auth_user'


class AuthUserGroups(models.Model):
    user = models.ForeignKey(AuthUser)
    group = models.ForeignKey(AuthGroup)

    class Meta:
        managed = False
        db_table = 'auth_user_groups'
        unique_together = (('user_id', 'group_id'),)


class AuthUserUserPermissions(models.Model):
    user = models.ForeignKey(AuthUser)
    permission = models.ForeignKey(AuthPermission)

    class Meta:
        managed = False
        db_table = 'auth_user_user_permissions'
        unique_together = (('user_id', 'permission_id'),)


class DjangoAdminLog(models.Model):
    action_time = models.DateTimeField()
    object_id = models.TextField(blank=True, null=True)
    object_repr = models.CharField(max_length=200)
    action_flag = models.SmallIntegerField()
    change_message = models.TextField()
    content_type = models.ForeignKey('DjangoContentType', blank=True, null=True)
    user = models.ForeignKey(AuthUser)

    class Meta:
        managed = False
        db_table = 'django_admin_log'


class DjangoContentType(models.Model):
    app_label = models.CharField(max_length=100)
    model = models.CharField(max_length=100)

    class Meta:
        managed = False
        db_table = 'django_content_type'
        unique_together = (('app_label', 'model'),)


class DjangoMigrations(models.Model):
    app = models.CharField(max_length=255)
    name = models.CharField(max_length=255)
    applied = models.DateTimeField()

    class Meta:
        managed = False
        db_table = 'django_migrations'


class DjangoSession(models.Model):
    session_key = models.CharField(primary_key=True, max_length=40)
    session_data = models.TextField()
    expire_date = models.DateTimeField()

    class Meta:
        managed = False
        db_table = 'django_session'


class RunningResult(models.Model):
    running_result_id = models.IntegerField(primary_key=True)
    running_result_distance = models.CharField(max_length=45, blank=True, null=True)
    running_result_duration = models.TimeField(blank=True, null=True)
    running_result_steps = models.IntegerField(blank=True, null=True)
    running_result_starttime = models.DateTimeField(blank=True, null=True)
    running_result_endtime = models.DateTimeField(blank=True, null=True)
    location = models.IntegerField(blank=True, null=True)
    user = models.ForeignKey(AuthUser, blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'running_result'


class UserInformation(models.Model):
    user_information_id = models.AutoField(primary_key=True)
    user_avatar = models.CharField(max_length=45, blank=True, null=True)
    user_height = models.CharField(max_length=10, blank=True, null=True)
    user_weight = models.CharField(max_length=10, blank=True, null=True)
    user_sex = models.CharField(max_length=1, blank=True, null=True)
    user_birth = models.DateField(blank=True, null=True)
    user = models.ForeignKey(AuthUser, blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'user_information'

run_run_settings.py

"""
Django settings for run project.

Generated by 'django-admin startproject' using Django 1.8.2.

For more information on this file, see
https://docs.djangoproject.com/en/1.8/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.8/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'vnonx()hmhpw*49^0tj8!4uxb1pgtu@(=d@6j((m=yz$1cv!s5'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'auth_token',
    'running',
)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    # 'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django.middleware.security.SecurityMiddleware',
)

ROOT_URLCONF = 'run.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'run.wsgi.application'


# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': 'run',                      # Or path to database file if using sqlite3.
        # The following settings are not used with sqlite3:
        'USER': 'root',
        'PASSWORD': 'yinzishao',
        'HOST': '127.0.0.1',                      # Empty for localhost through domain sockets or '127.0.0.1' for localhost through TCP.
        'PORT': '3306',                      # Set to empty string for default.
    }
}
# Internationalization
# https://docs.djangoproject.com/en/1.8/topics/i18n/

LANGUAGE_CODE = 'en-us'


USE_I18N = True

USE_L10N = True

# USE_TZ = True
#
# TIME_ZONE = 'UTC'

TIME_ZONE = 'Asia/Shanghai'

USE_TZ = False

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.8/howto/static-files/

STATIC_URL = '/static/'

run_run_urls.py

"""run URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.8/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Add an import:  from blog import urls as blog_urls
    2. Add a URL to urlpatterns:  url(r'^blog/', include(blog_urls))
"""
from django.conf.urls import include, url
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'',include('auth_token.urls'))
]

run_run_wsgi.py

"""
WSGI config for run project.

It exposes the WSGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "run.settings")

application = get_wsgi_application()

run_running_admin.py

from django.contrib import admin

# Register your models here.

run_running_models.py

from django.db import models

# Create your models here.

run_running_tests.py

from django.test import TestCase

# Create your tests here.

run_running_views.py

from django.shortcuts import render

# Create your views here.