signup

import os
import re
import random
import hashlib
import hmac
from string import letters

import webapp2
import jinja2

from google.appengine.ext import db

template_dir = os.path.join(os.path.dirname(__file__),'templates')
jinja_env = jinja2.Environment(loader = jinja2.FileSystemLoader(template_dir),autoescape = True)

secret = 'du.uyX9fE~Tb6.pp&U3D-0smY0,Gqi$^jS34tzu9'

def render_str(template, **params):
  t = jinja_env.get_template(template)
	return t.render(params)
	
def make_secure_val(val):
	return '%s|%s'%(val,hmac.new(secret,val).hexdigest())
	
def check_secure_val(secure_val):
	val = secure_val.split('|')[0]
	if secure_val == make_secure_val(val):
		return val
		
class BlogHandler(webapp2.RequestHandler):
	def write(self,*a,**kw):
		self.response.out.write(*a,**kw)
	def render_str(self,template,**params):
		params['user'] = self.user
		t = jinja_env.get_template(template)
		return t.render(params)
		
	def render(self, template, **kw):
		self.write(self.render_str(template,**kw))
		
		
	def set_secure_cookie(self,name,val):
		cookie_val = make_secure_val(val)
		self.response.headers.add_header(
					'set-cookie',
					'%s=%s; Path=/', %(name, cookie_val))
	def read_secure_cookie(self,name):
	
		cookie_val = self.request.cookies.get(name)
		return cookie_val and check_secure_val(cookie_val)
		
	def login(self):
		self.set_secure_cookie('user_id',str(user.key().id()))
	
	def logout(self):
		self.response.headers.add_header('set_cookie', 'user_id=; Path=/')
		
	def initialize(self, *a, **kw):
		webapp2.RequestHandler.initialize(self,*a,**kw)
		uid = self.read_secure_cookie('user_id')
		self.user = uid and User_by_id(int(uid))
		
def render_post(response,post):
	response.out.write('<br>' + post.subject + '</br><br>')
	response.out.write(post.content)

class MainPage(BlogHandler):
    def get(self):
        self.write('hello')

def make_salt(length = 5):
	return ''.join(random.choice(letters) for x in xrange(length))

def make_pw_hash(name, pw, salt = None):	
	if not salt:
		salt = make_salt()
	h = hashlib.sha256(name + pw + salt).hexdigest()
	return '%s,%s' %(salt, h)
	
def valid_pw(name,password, h):
	salt = h.split(',')[0]
	return h == make_pw_hash(name, password, salt)
	
def users_key(group = 'default'):
	return db.key.from_path('user',group)
	
class User(db.Model):
	name = db.StringProperty(required = True)
	pw_hash = db.StringProperty(required = True)
	email = db.StringProperty()

	@classmethod
	def by_id(cls, uid):
		return User.get_by_id(uid, parent = users_key())
		
	@classmethod
	def by_name(cls, name):
		u = User.all().filter('name =', name).get()
		return u
		
	@classmethod
	def register(cls, name, pw, email = None):
		pw_hash = make_pw_hash(name, pw)
		return User(parent = users_key(),
					name = name,
					pw_hash = pw_hash,
					email = email)
					
	@classmethod
	def login(cls, name, pw):
		u = cls.by_name(name)
		if u and valid_pw(name, pw, u.pw_hash):
			return u
			
class Signup(BlogHandler):
	def get(self):
		self.render("signup-form.html")
		
	def post(self):
		have_error = False
		self.username = self.request.get('username')
		self.password = self.request.get('password')
		self.verify = self.request.get('verify')
		self.email = self.request.get('email')
		
		params = dict(username = self.username,
					   email = self.email)
		
		if not valid_username(self.username):
			params['error_username'] = "That's not a valid username."
			have_error = True
		
		if not valid_password(self.password):
			params['error_password'] = "That's not a valid password."
			have_error = True
			
		elif self.password != self.verify:
			params['error_verify'] = "your password not match."   
			have_error = True
		
		if not valid_email(self.email):
			params['error_email'] = "That's not a valid email."
			have_error = True
			
		if have_error:
			self.render('signup-form.html', **params)
		else:
			self.done()
			
	def done(self, *a, **kw):
		raise NotImplementedError
		
class Unit2Signup(Signup):
	def done(self):
		self.redirect('unit2/welcome?username=' +self.username)
		
class Register(Signup):
	def done(self):
		u = User.by_name(self.username)
		if u:
			msg = 'That user already exists.'
			self.render('signup-form.html',error_username = msg)
		else:
			u = User.register(self.username, self.password, self.email)
			u.put()
			
			self.login(u)
			self.redirect('/unit3/welcome')
			
class Login(BlogHandler):
	def get(self):
		self.render('login-form.html')
		
	def post(self):
		username = self.request.get('username')
		password = self.request.get('password')
		
		u = User.login(username, password)
		if u:
			self.login(u)
			self.redirect('/unit3/welcome')
		else:
			msg = 'invalid login'
			self.render('login-form.html', error = msg)
			
class Logout(BlogHandler):
	def get(self):
		self.logout()
		self.redirect('/signup')

class Unit3Welcome(BlogHandler):
	def done(self):		
		if self.user:
			self.render('welcome.html',username = self.user.name)
		else:
			self.redirect('/signup')
			
class Welcome(BlogHandler):
	def done(self):
		username = self.request.get('username')
		if valid_username(username):
			self.render('welcome.html',username = self.user.name)
		else:
			self.redirect('unit2/signup')
			
app = webapp2.WSGIApplication([('/', MainPage), 
				('/unit2/rot13', Rot13),
				('/unit2/signup', unit2Signup),
				('/unit2/welcome', Welcome),
				('/blog/?', BlogFront),
				('/blog/([0-9]+)',PostPage),
				('/blog/newpost', NewPost),
				('/signup', Register),
				('/login', Login),
				('/logout', Logout),
				('/unit3/welcome', Unit3Welcome),
			       ],
			      debug=True)