def new_session(request):
	q=Author(name=request.GET['name'],email=request.GET['email'],password=request.GET['password'])
	q.save()
	request.session['author_id']=q.id
	request.session['author_name']=q.name
	request.session['author_email']=q.email
	return render(request,'../../demo/templates/nsession.html',{"author":q})

def update_books(books = get_books()):
    opener = urllib2.build_opener()
    opener.addheaders = [('User-agent', 'Mozilla/5.0')]
    for book in books:
        try:
            b = Book.objects.filter(title=book['title']).count()
            print '>>>', b
            if not b:
                b = Book()
                b.title = book['title']
                author = book['author']
                last_name = author.split(' ')[-1]
                first_name = ' '.join(author.split(' ')[:-1])
                try:
                    author = Author.objects.get(first_name=first_name, last_name=last_name)
                except:
                    author = Author(first_name=first_name, last_name=last_name)
                    author.save()
                b.author = author
                b.external_url = 'http://en.wikipedia.org'+book['link']
                try:
                    content = opener.open('http://en.wikipedia.org'+book['link']).read()
                    s = Soup(content)
                    info = s.find('table', {'class':'infobox'})
                    img = info.find('img')
                    if img:
                        b.image = 'http:'+img.get('src')
                except:
                    print "IMAGE FAILED FOR", book
                b.save()
        except Exception, e:
            print e
            print "WOAH TOTAL FAILURE", book

 def setUp(self):
     # Create a few Authors.
     self.au1 = Author(name="Author 1")
     self.au1.save()
     self.au2 = Author(name="Author 2")
     self.au2.save()
     # Create a couple of Articles.
     self.a1 = Article(headline="Article 1", pub_date=datetime(2005, 7, 26), author=self.au1)
     self.a1.save()
     self.a2 = Article(headline="Article 2", pub_date=datetime(2005, 7, 27), author=self.au1)
     self.a2.save()
     self.a3 = Article(headline="Article 3", pub_date=datetime(2005, 7, 27), author=self.au1)
     self.a3.save()
     self.a4 = Article(headline="Article 4", pub_date=datetime(2005, 7, 28), author=self.au1)
     self.a4.save()
     self.a5 = Article(headline="Article 5", pub_date=datetime(2005, 8, 1, 9, 0), author=self.au2)
     self.a5.save()
     self.a6 = Article(headline="Article 6", pub_date=datetime(2005, 8, 1, 8, 0), author=self.au2)
     self.a6.save()
     self.a7 = Article(headline="Article 7", pub_date=datetime(2005, 7, 27), author=self.au2)
     self.a7.save()
     # Create a few Tags.
     self.t1 = Tag(name="Tag 1")
     self.t1.save()
     self.t1.articles.add(self.a1, self.a2, self.a3)
     self.t2 = Tag(name="Tag 2")
     self.t2.save()
     self.t2.articles.add(self.a3, self.a4, self.a5)
     self.t3 = Tag(name="Tag 3")
     self.t3.save()
     self.t3.articles.add(self.a5, self.a6, self.a7)

def insert_paper():
    if request.method == 'POST':
        paper = db.session.query(Paper).filter_by(doi=request.json['doi']).first()
        if not paper:
            paper = Paper(year=request.json['year'],
                         title=request.json['title'],
                         abstract=request.json['abstract'],
                         user_id=g.user.id,
                         doi=request.json['doi'])
            db.session.add(paper)
            db.session.flush()
            for author in request.json['authors']:
                paper_author = db.session.query(Author).filter_by(name=author).first()
                if paper_author:
                    paper_author.start_owning(paper)
                else:
                    paper_author = Author(name=author)
                    db.session.add(paper_author)
                    db.session.flush()
                    paper_author.start_owning(paper)
            db.session.commit()
            for doi in request.json['doi_refs']:
                ref_paper = db.session.query(Paper).filter_by(doi=doi).first()
                if ref_paper:
                    paper.start_referencing(ref_paper)
                else:
                    ref_paper = Paper(doi=doi)
                    db.session.add(ref_paper)
                    db.session.flush()
                    paper.start_referencing(ref_paper)
            db.session.commit()
    return json.dumps(dict(data=request.json))

    def copyFromArticles(self, request):
        '''Copies articles and authors from legacy Articles Kind into new Article and Author kinds'''
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        for article in Articles().all():
            if '@' not in article.author:
                author_email = article.author + '@gmail.com'
            else:
                author_email = article.author

            a_key = ndb.Key(Author, author_email)
            author = a_key.get()
            # create new Author if not there
            if not author:
                author = Author(
                    key = a_key,
                    authorID = str(Author.allocate_ids(size=1)[0]),
                    displayName = author_email.split('@')[0],
                    mainEmail = author_email,
                )
                author.put()
            
            self.copyArticlesKind(article, author)

        return BooleanMessage(data=True)

def edit_book(id):
    book = Book.query.get(id)
    if book == None:
        flash("Book is not found")
        return redirect(url_for('books'))
    print book.authors
    form = EditBook(book=book)    
    print form.data, 'hah'
    #form.authors.min_entries = len(book.authors)
    # print form.authors.data
    # form.authors[0].data = book.authors[0].name
    # for author in book.authors[1:]:
    #     form.authors.append_entry(author.name)    
    # print form.authors.data

    if form.validate_on_submit():        
        print form.data
        name = form.data['title']
        newbook = Book.query.filter_by(name=name).first()         
        if newbook and id != newbook.id:
            flash("Can't change name to existing one.")
            return redirect(url_for('edit_book', id=id))
        book.name = name
        authors = list(set([Author.by_name(name=a)
            for a in form.data['authors'] if Author.exists(name=a)]))
        #print authors
        book.authors = authors        
        db.session.commit()
        flash('Changes have been saved.')
        return redirect(url_for('edit_book', id=id))
    return render_template('edit_book.html', form=form)

def make_author(author_link, commit=True):
    id = find_int(author_link['href'])
    username = unicode(author_link.string)
    key = db.Key.from_path('Author', int(id))
    author = Author(key=key, username=username)
    if commit:
        author.put()
    return author

def add_author(request):
    if request.POST:
        post = request.POST
        if post["AuthorID"] and post["Name"] and post["Age"] and post["Country"]:
            new_author = Author(AuthorID=post["AuthorID"], Name=post["Name"], Age=post["Age"], Country=post["Country"])
            new_author.save()
        else:
            return HttpResponse("Please full all information.")
    return render_to_response("add_author.html")

def delete_project(project_id):
    """Deletes the project matching the id project_id."""
    project = Project.objects(id=project_id).get()
    project.delete()

    # Removes the project from the list of the author projects.
    Author.objects(id=project.author_id).update_one(pull__projects=project.id)

    return jsonify(project.to_dict())

def update_author(author_id):
    """Updates the author matching the id author_id.
    Only the parameters to update or to add should be passed in the request body.
    """
    author = Author.objects(id=author_id).get()
    patched = Author(**dict(chain(author.to_dict().items(), request.get_json().items())))
    patched.save()

    return jsonify(patched.to_dict())

def addauthor(request):
    if request.POST:
        post = request.POST
        new_author = Author(
            Name = post["name"],
            Age = post["age"],
            Country = post["country"])
        new_author.save()
    return render_to_response('addauthor.html',context_instance=RequestContext(request))

 def testBasicModelPKCS7(self):
     """Try to sign a basic model
     """
     # Sign
     auth1 = Author(name="Raymond E. Feist", title="MR")
     auth1.save()
     data_signed = self.c_cert.sign_model(auth1, self.c_pwd)
     result = self.c_cert.verify_smime(data_signed)
     self.assertTrue(result)

def worker_authors(request):
    r = Repository.get(db.Key(request.POST["repo"]))
    logging.info("processing repository: %s" % r.name)
    base_url = "http://github.com/%s/%s" % (r.owner.name, r.name)
    url = base_url + "/network_meta"
    logging.info("  downloading network_meta from: %s" % url)
    try:
        s = urllib2.urlopen(url).read()
    except urllib2.HTTPError:
        logging.info("Probably bad repo, skipping.")
        return HttpResponse("Probably bad repo, skipping.\n")
    logging.info("  network_meta loaded")
    try:
        data = simplejson.loads(s)
    except ValueError:
        logging.info("Probably bad repo, skipping.")
        return HttpResponse("Probably bad repo, skipping.\n")
    logging.info("  network_meta parsed")
    dates = data["dates"]
    nethash = data["nethash"]
    url = "%s/network_data_chunk?nethash=%s&start=0&end=%d" % (base_url,
            nethash, len(dates)-1)
    logging.info("  downloading commits from: %s" % url)
    s = urllib2.urlopen(url).read()
    logging.info("  parsing commits...")
    data = simplejson.loads(s, encoding="latin-1")
    logging.info("  processing authors...")
    commits = data["commits"]
    m = [(x["author"], x["id"]) for x in commits]
    m = dict(m)
    logging.info(m)
    authors = m.keys()
    authors = list(set(authors))
    authors.sort()
    logging.info(authors)
    queue = get_github_queue()
    for author in authors:
        q = User.gql("WHERE name = :1", author)
        u = q.get()
        if u is None:
            u = User(name=author, email="None")
            u.save()
            task = taskqueue.Task(url="/hooks/worker/user_email/",
                    params={'user': u.key(),
                        'r_user_id': r.owner.name,
                        'r_repository': r.name,
                        'r_sha': m[u.name]
                        })
            queue.add(task)
        q = Author.gql("WHERE user = :1 AND repo = :2", u, r)
        a = q.get()
        if a is None:
            a = Author(repo=r, user=u)
            a.save()
    logging.info("  done.")
    return HttpResponse("OK\n")

def author_add():
    name = request.args.get('author')
    print name
    print Author.by_name(name)
    if name and not Author.by_name(name):        
        author = Author(name)
        db.session.add(author)
        db.session.commit()
        #return jsonify(author=author)
        return render_template('author.html', author=author)

def author_add(request):
    if request.POST:
        post = request.POST
        new_author = Author(
            AuthorID = post["AuthorID"],
            Name = post["Name"],
            Age = post["Age"],
            Country = post["Country"])
        new_author.save()
    return render_to_response("add_author.html")

 def dispatch_request(self):
     form = AuthorForm()
     form.books.query = Book.query.all()
     if request.method == "POST":
         if form.validate_on_submit():
             obj = Author()
             form.populate_obj(obj)
             obj.save()
             return redirect("/authors/")
     return render_template("author_add.html", form=form)

def create(request):
    """
    Create an author.
    """
    name = request.POST["name"]

    author = Author(name=name)
    author_id = author.put().id()

    return HttpResponse("Created an author: %s %s " % (name, author_id))

def submitauthor(request):
    if request.POST:    
        post = request.POST
        new_author = Author(
            AuthorID = post["id"],
            Name = post["name"],
            Age = post["age"],
            Country=post["country"]
            )
        new_author.save()
        return  HttpResponseRedirect('/authorlist/') 

def add_author(request):
    """添加作者"""
    if request.POST:
        post = request.POST
        new_Author = Author(
            name = post['name'],
            age = post['age'],
            country = post['country']
            )
        new_Author.save()
    return render_to_response("add_author.html")

def dbSavePapersAndAuthors(papers, latestMailing=True):
	"""Saves an array of paper information into the database.  Returns numbers of new papers and authors added.  
	
	If the latestMailing argument is true, then sets the paper dates to either today or tomorrow, 
	regardless of the date from the arXiv.  It sets to today if the function is run before 8pm ET, and to 
	tomorrow otherwise.  The idea is that this function should be run regularly every day, the night that the 
	mailing goes out.  If run late in the day before midnight, then the mailing has tomorrow's date.  If run 
	early in the day, e.g., if for some reason it didn't run when it should have, then the mailing was sent out 
	yesterday and is for today.  
	"""
	if latestMailing: 
		latestMailingDate = datetime.date.today()
		now = datetime.datetime.now(pytz.timezone('US/Eastern'))
		cutoff = now.replace(hour=20,minute=0,second=0,microsecond=0)
		if now > cutoff: 
			latestMailingDate += datetime.timedelta(days=+1)	# note: The official mailing date is the day the email goes out, a few hours after the paper was made available
	numNewPapersAdded = numNewAuthorsAdded = 0
	for paper in papers: 
		authors = []
		for author in paper['authors']: 
			authorsWithSameName = Author.objects.filter(name=author)
			if authorsWithSameName: 		# author with same name already exists in database---don't add a duplicate
				a = authorsWithSameName[0]	# there might be duplicates --- take the first (maybe fix later)
			else: 
				a = Author(name=author)
				a.save()
				numNewAuthorsAdded += 1
			authors.append(a)
		if Paper.objects.filter(arxivId=paper['arxivId']): continue		# NOTE: If we make a mistake adding the paper the first time, this line will keep the code below from ever running to fix it
		if latestMailing: 
			mailing_date = latestMailingDate
		else: 
			mailing_date = mailingDate(paper['datePublished'])
		p = Paper(
			arxivId = paper['arxivId'],
			title = paper['title'],
			abstract = paper['abstract'],
			date_published = paper['datePublished'],
			date_mailed = mailing_date,
			#authors = authors, 	# ManyToManyField is set up later
			category = paper['category'],
			categories = paper['categories'],
			version = paper['version'],
			linkAbsPage = paper['linkAbsPage'],
			linkPdf = paper['linkPdf']
		)
		p.save()	# need to save before setting up the ManyToMany field of authors
		for author in authors: 	# alternatively, to clear a ManyToMany field, use p.authors.clear()
			p.authors.add(author)
		p.save()
		numNewPapersAdded += 1
	print "%d new papers, %d new authors added" % (numNewPapersAdded, numNewAuthorsAdded)
	return numNewPapersAdded, numNewAuthorsAdded