Python models.Author类代码示例

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")