def exchange(self):
params = self.request.params
page1 = Page.get_by_id(params.get('page1'), parent=self.master_key)
page2 = Page.get_by_id(params.get('page2'), parent=self.master_key)
page1.order, page2.order = page2.order, page1.order
page1.put()
page2.put()
def add_page_pair_to_database(from_page, to_page, limit):
with db_lock:
cou = session.query(Page.id).filter(Page.url == from_page).scalar()
cou1 = session.query(Page.id).filter(Page.url == to_page).scalar()
if cou is None:
new_page_from = Page(url=from_page, text="", rank=0)
session.add(new_page_from)
session.flush()
id0 = new_page_from.id
else:
id0 = cou
if cou1 is None:
allowed = limit < 1 or limit > session.query(Page).count()
if not allowed:
return
new_page_to = Page(url=to_page, text="", rank=0)
session.add(new_page_to)
session.flush()
id1 = new_page_to.id
else:
id1 = cou1
new_relation = Relation(page_id=id0, destination_id=id1)
# print(new_relation.page_id.id)
session.add(new_relation)
session.commit()
def exchange(self):
params = self.request.params
page1 = Page.get_by_id(params.get('page1'), parent=self.master_key)
page2 = Page.get_by_id(params.get('page2'), parent=self.master_key)
page1.order, page2.order = page2.order, page1.order
page1.put()
page2.put()
def save(self):
params = self.request.params
page = Page.get_or_create(params.get('id'), self._get_parent_key())
page.mergeProps(params)
if page.order is None:
page.order = Page.get_children_count(self.master_key)
page.put()
self.redirect(self._redirect_url(page))
def delete_page(self, page_id):
page = Page.get_by_id(page_id, parent=self.master_key)
if page:
Page.dec_order_number(self.master_key, page.order)
page.key.delete()
self.redirect(self._redirect_url())
else:
self.error(404)
def delete_page(self, page_id):
page = Page.get_by_id(page_id, parent=self.master_key)
if page:
Page.dec_order_number(self.master_key, page.order)
page.key.delete()
self.redirect(self._redirect_url())
else:
self.error(404)
def save(self):
params = self.request.params
page = Page.get_or_create(params.get('id'), self._get_parent_key())
page.mergeProps(params)
if page.order is None:
page.order = Page.get_children_count(self.master_key)
page.put()
self.redirect(self._redirect_url(page))
def get(self, page_id=''):
if page_id:
page = Page.get_by_id(page_id, parent=self.master_key)
else:
page = Page.get_first_child(self.master_key, False)
if page:
return self._get_page(page)
else:
self.redirect('/_add?type=post')
def get(self, page_id=''):
if page_id:
page = Page.get_by_id(page_id, parent=self.master_key)
else:
page = Page.get_first_child(self.master_key, False)
if page:
return self._get_page(page)
else:
self.redirect('/_add?type=post')
def add_page(self):
params = self.request.params
order = params.get('order', Page.get_children_count(self.master_key))
parent = self._get_parent_key()
page_type = params.get('type', None)
if page_type:
page = Page(parent=parent, page_type=page_type, order=int(order))
self._get_page(page)
else:
self.error(400)
def __init__(self):
self.structure = {}
pages = Page.find()
for page in pages:
if page.attr['title'] != 'index':
self.structure[page.attr['title']] = \
{"_type": "button", "data": {"href": '/%s' % page.attr['title']}}
def get(self, page_id):
uid = self.request.get('uid')
token = self.request.get('token')
user = AcceptAuthorshipToken.get_user_from_token_string(token)
valid = user is not None
if page_id is not None:
page_id = Page.get_long_uid(page_id)
page = self.api.get_by_id(page_id)
authors = page.authors
# Add to authors if token is valid
if valid and uid not in authors:
authors.append(uid)
page.authors = authors
page.put()
AcceptAuthorshipToken.delete(token)
self.redirect('/pages/{}'.format(page_id), permanent=True)
else:
self.write('404.html', message='invalid token')
# self.response.write(json.dumps(
# {'error': True, 'message': 'invalid token'}))
else:
self.response.write(
json.dumps({
'error': True,
'message': 'invalid parameters'
}))
def post(self, pid):
try:
page = Page.get(id = pid)
except:
self.flash("此栏目不存在")
self.redirect("/admin/pages")
return
name = self.get_argument("name", None)
slug = self.get_argument("slug", None)
content = self.get_argument("content", "")
template = self.get_argument("template", "staticpage.html")
page.name = name
page.slug = slug
page.content = content
page.template = template
try:
page.validate()
page.save()
self.flash(u"栏目%s修改成功" % name)
self.redirect("/admin/pages")
return
except Exception, ex:
self.flash(str(ex))
def get_file(self, file_id):
page = Page.get_by_id(file_id, parent=self.master_key)
if page and page.file_content:
self.response.headers['Content-Type'] = str(page.file_type)
self.response.write(page.file_content)
else:
self.error(404)
def get(self):
books = (Book.query().filter(Book.listed == True).filter(
Book.status == 'approved').filter(Book.deleted == False).order(
-Book.display_order, -Book.votes_for).fetch(10))
for book in books:
if book.book_image:
book.book_image = json.loads(book.book_image)['link']
if book.icon:
book.icon = json.loads(book.icon)['link']
book.author_users = [
user.to_client_dict() for user in User.get_by_id(book.authors)
]
pages = (Page.query().filter(Page.listed == True).filter(
Page.status == 'approved').filter(Book.deleted == False).order(
-Page.display_order, -Page.votes_for).fetch(5))
for page in pages:
if page.iconPath:
page.icon_thumbnail = page.iconPath + '?size=120'
page.author_users = [
user.to_client_dict() for user in User.get_by_id(page.authors)
]
self.write(
'main.html',
featuredBooks=books,
featuredPages=pages,
)
def post(self, pid):
try:
page = Page.get(id=pid)
except:
self.flash("此栏目不存在")
self.redirect("/admin/pages")
return
name = self.get_argument("name", None)
slug = self.get_argument("slug", None)
content = self.get_argument("content", "")
template = self.get_argument("template", "staticpage.html")
page.name = name
page.slug = slug
page.content = content
page.template = template
try:
page.validate()
page.save()
self.flash(u"栏目%s修改成功" % name)
self.redirect("/admin/pages")
return
except Exception, ex:
self.flash(str(ex))
def get(self, link):
page = Page.by_path(link)
params = {}
if self.user and page:
params = {
'name': self.user.username,
'name_ev': 'edit',
'name_lio': 'logout',
'link_ev': self.uri_for('edit', link=link),
'link_lio': self.uri_for('logout')
}
elif not self.user and page:
params = {
'name_lio': 'login',
'link_lio': self.uri_for('login')
}
else:
return self.redirect_to('edit', link=link)
self.render_response(self.template, page=page, params=params)
def get_file(self, file_id):
page = Page.get_by_id(file_id, parent=self.master_key)
if page and page.file_content:
self.response.headers['Content-Type'] = str(page.file_type)
self.response.write(page.file_content)
else:
self.error(404)
async def domain_handler(request):
domain = request.match_info.get('dom')
all_objects = await objects.execute(
Page.select().where(Page.domain == domain).limit(1000))
context = {'pages': all_objects}
response = render_template('website.html', request, context)
return response
def getPage(self, id):
"""Return a Page object
@type id: string, or Page object
@param id: page id, or Page object
@rtype: Page"""
return Page.create(self.pm_getSpaceManager().getPage(self._unbox(id)), self._modelDataManager)
def load_pages():
"""Load pages from seed data into database"""
with open("seed_data/pages.txt") as pages:
for row in pages:
page = row.rstrip().split("|")
hidden = True if page[3] == "True" else False
kwargs = dict(
page_id = page[0],
user_id = page[1],
page = page[2],
hidden = hidden
)
keys_to_remove = []
for key in kwargs.keys():
if kwargs[key] == "":
keys_to_remove.append(key)
for key in keys_to_remove:
del kwargs[key]
page = Page(**kwargs)
db.session.add(page)
db.session.commit()
def process_list(self, page):
queue = self.application.queue
logging.debug('Processing list %s' % page.url)
processed = 0
if page.state == Page.State.PARSED:
with session_scope(self.application.Session) as session:
for url in page.get_contents():
(page_exists, ), = session.query(
exists().where(Page.url == url))
if not page_exists:
if 'http' not in url:
url = self.application.config.SCRAPE_ROOT_PATH + url
subpage = Page(url=url)
session.add(subpage)
session.commit()
queue.add_page(subpage.page_id)
processed += 1
page.state = Page.State.PROCESSED
logging.debug('Processed list %s' % page.url)
print(
'Processed %s urls! Fetching movies & getting more movie urls...'
% processed)
else:
logging.debug('Aleady processed list %s' % page.url)
def get(self, pid):
try:
page = Page.get(id = pid)
except:
self.flash("此栏目不存在")
self.redirect("/admin/pages")
return
self.render('admin/editpage.html', page = page)
def get(self, slug):
try:
page = Page.get(slug=slug)
except:
raise HTTPError(404)
return
self.render("static/%s" % page.template, page=page)
def findPage(self, space, title):
"""Return a Page object
@type space: string, or Space object
@param space: space key, or Space object
@param title: the title of the page
@rtype: Page"""
return Page.create(self.pm_getSpaceManager().findPage(self._unbox(space), title), self._modelDataManager)
async def home_handler(request):
all_objects = await objects.execute(
Page.select(Page.domain,
fn.COUNT(Page.id).alias('pages_count')).group_by(
Page.domain).limit(100))
context = {'objects': all_objects}
response = render_template('index.html', request, context)
return response
def get(self, pid):
try:
page = Page.get(id=pid)
except:
self.flash("此栏目不存在")
self.redirect("/admin/pages")
return
self.render('admin/editpage.html', page=page)
def editPage(self, page):
"""Update content of page
@type page: Page object
@param page: Page object having the updated content
@rtype: Page
@return: updated Page"""
return Page.create(self.pm_getSpaceManager().editPage(page.toDict()), self._modelDataManager)
def listPages(self, space):
"""Return a list of available pages in this space
@type space: string, or Space Object
@param space: space key, or Space object
@rtype: Page list
@return: list of Pages contained in space"""
return tuple(Page.create(page, self._modelDataManager) for page in self.pm_getSpaceManager().listPages(self._unbox(space)))
def getPageParent(self,page):#get parent from its page if page: my_key = page.parent; if my_key: PID = my_key.id(); parent = Page.get_by_id(PID); return parent; return;
def getPage(self, id):
"""Return a Page object
@type id: string, or Page object
@param id: page id, or Page object
@rtype: Page"""
return Page.create(self.pm_getSpaceManager().getPage(self._unbox(id)),
self._modelDataManager)
def get(self, slug):
try:
page = Page.get(slug = slug)
except:
raise HTTPError(404)
return
self.render("static/%s" % page.template, page = page)
def linkNodeDelete(ID): link = None; if ID: link = Page.get_by_id(ID); myKey = None; if link: myKey = link.key; for m in Page.query(Page.parent == myKey): linkDelete(m.key.id()); for m in Post.query(Post.parent == myKey): m.key.delete(); return link;
def editPage(self, page):
"""Update content of page
@type page: Page object
@param page: Page object having the updated content
@rtype: Page
@return: updated Page"""
return Page.create(self.pm_getSpaceManager().editPage(page.toDict()),
self._modelDataManager)
def create_book_page(page_text, page_image, email):
"""Create a pages of book"""
book_id = get_book_id(email)
page = Page(text= page_text, image=page_image, book_id = book_id)
db.session.add(page)
db.session.commit()
return page
def listPages(self, space):
"""Return a list of available pages in this space
@type space: string, or Space Object
@param space: space key, or Space object
@rtype: Page list
@return: list of Pages contained in space"""
return tuple(
Page.create(page, self._modelDataManager) for page in
self.pm_getSpaceManager().listPages(self._unbox(space)))
def submit_createfolder():
""" handle folder creation """
# example request.form is {'submit_createfolder': 'create',
# 'foldername': 'testfolder'}
# page.abs path is current directory i.e. /User/mahoney/.../folder1/
foldername = request.form['foldername']
print_debug(' submit_createfolder : foldername="{}" '.format(foldername))
if not is_clean_folder_name(foldername):
print_debug(' submit_createfolder: illegal chars in foldername')
flash('Oops: folder names may only contain ' + \
'lowercase letters, numbers, or underbar.', 'folder')
flash(foldername)
return url_for('mainroute', pagepath=request.page.path, action='edit')
folderpath = os.path.join(request.page.path, foldername)
folderabspath = os.path.join(request.page.abspath, foldername)
print_debug(
' submit_createfolder : newfolderabspath="{}" '.format(folderabspath))
Page.new_folder(folderabspath, user=request.page.user)
return url_for('mainroute', pagepath=request.page.path, action='edit')
def add_page(self):
params = self.request.params
order = params.get('order', Page.get_children_count(self.master_key))
parent = self._get_parent_key()
page_type = params.get('type', None)
if page_type:
page = Page(parent=parent, page_type=page_type, order=int(order))
self._get_page(page)
else:
self.error(400)
def findPage(self, space, title):
"""Return a Page object
@type space: string, or Space object
@param space: space key, or Space object
@param title: the title of the page
@rtype: Page"""
return Page.create(
self.pm_getSpaceManager().findPage(self._unbox(space), title),
self._modelDataManager)
def addPage(self, space, title, parent = None, content = ''):
"""Create a Page
@type space: string, or Space object
@param space: space key, or Space object
@param title: page title
@type parent: string, or Page object
@param parent: the page id of the parent page, or Page object of the parent page(if not passed the page has no parent)
@param content: page content written as wiki text
@rtype: Page
@return: newly created Page"""
return Page.create(self.pm_getSpaceManager().addPage(self._unbox(space), title, self._unbox(parent), content), self._modelDataManager)
def _get_page(self, page):
master = 'admin' if users.is_current_user_admin() else 'public'
menu_pages = Page.get_children_names(self.master_key, False)
values = {
'id': page.key.string_id(),
'master': master + '.html',
'menu': menu_pages,
'page': page,
'site_name': site_name
}
template = JINJA_ENV.get_template(page.page_type + '.html')
self.response.write(template.render(values))
def create_cover_page(page_text, cover_image, email):
"""Create a cover of book"""
book_id = 0
book_id_list = db.session.query(Book.id).all()
for last_book in book_id_list:
book_id = last_book
cover_page = Page(text= page_text, cover_image=cover_image, book_id = book_id)
db.session.add(cover_page)
db.session.commit()
return cover_page
def createPageFromFile(self, localFilePath, space, title = None, parentId = None, addFileAsAttachment = False):
"""Create a page and add the localFilePath path content as the page content
@param localPath: the path of the file on local machine containing the wiki text to be used as new page content
@type space: string , or Space object
@param space: space key, or Space object
@param title: page title(if default value, the file name will be used as a title)
@param parentId: the page id of the parent page (if default value, the page has no parent)
@param addFileAsAttachment: if True, the file specified is added as attachment to the page(if default value, no attachment is created)
@rtype: Page
@return: newly created Page"""
return Page.create(self.pm_getSpaceManager().createPageFromFile(localFilePath, self._unbox(space), title, parentId, addFileAsAttachment), self._modelDataManager)
def _get_page(self, page):
master = 'admin' if users.is_current_user_admin() else 'public'
menu_pages = Page.get_children_names(self.master_key, False)
values = {
'id': page.key.string_id(),
'master': master + '.html',
'menu': menu_pages,
'page': page,
'site_name': site_name
}
template = JINJA_ENV.get_template(page.page_type + '.html')
self.response.write(template.render(values))
def getPage(self, article, oldid=None):
global wikiDatabase
if article not in wikiDatabase:
return NoPage(article=article, controller=self)
if oldid:
return OldPage(article=article,
wikitext=wikiDatabase[article][1][int(oldid)][0],
controller=self)
return Page(article=article,
wikitext=wikiDatabase[article][0],
controller=self)
def add_page():
"""Add a Page."""
data = json.loads(request.data.decode())
title = data.get('title')
content = data.get('content')
page = Page(title, content)
db.session.add(page)
db.session.commit()
return get_page_json(page.id)
def post(self, link):
if not self.user:
self.notfound()
content = self.request.get('content')
if content:
p = Page.by_path(link)
if p:
p.content = content
else:
p = Page(link=link, content=content)
p.put()
self.redirect_to('wiki', link=link)
else:
error = 'You must add some content before submitting.'
self.render_response(self.template, error=error, params=None,
page=None)
def addPage(self, space, title, parent=None, content=''):
"""Create a Page
@type space: string, or Space object
@param space: space key, or Space object
@param title: page title
@type parent: string, or Page object
@param parent: the page id of the parent page, or Page object of the parent page(if not passed the page has no parent)
@param content: page content written as wiki text
@rtype: Page
@return: newly created Page"""
return Page.create(
self.pm_getSpaceManager().addPage(self._unbox(space), title,
self._unbox(parent), content),
self._modelDataManager)
def post(self):
name = self.get_argument("name", None)
slug = self.get_argument("slug", None)
content = self.get_argument("content", "")
template = self.get_argument("template", "staticpage.html")
page = Page()
page.name = name
page.slug = slug
page.content = content
page.template = template
try:
page.validate()
page.save()
self.flash("栏目%s添加成功" % name)
self.redirect("/admin/pages")
return
except Exception as ex:
self.flash(str(ex))
self.render('admin/addpage.html')
def update_pages():
"""change what pages to display"""
user_id = session["current_user"]
user = User.query.get(user_id)
new_pages = request.form.getlist("pages")
print(new_pages)
Page.query.filter_by(user_id=user_id).delete()
for page in new_pages:
kwargs = dict(user_id=user_id, page=page)
db.session.add(Page(**kwargs))
db.session.commit()
print(user.pages)
return redirect("users/{}/my_homepage".format(user_id))
def get(self, link):
if not self.user:
return self.redirect_to('login')
page = None
page = Page.by_path(link)
params = {
'name': self.user.username,
'name_ev': 'view',
'name_lio': 'logout',
'link_ev': self.uri_for('wiki', link=link),
'link_lio': self.uri_for('logout')
}
self.render_response(self.template, page=page, params=params)
def createPageFromFile(self,
localFilePath,
space,
title=None,
parentId=None,
addFileAsAttachment=False):
"""Create a page and add the localFilePath path content as the page content
@param localPath: the path of the file on local machine containing the wiki text to be used as new page content
@type space: string , or Space object
@param space: space key, or Space object
@param title: page title(if default value, the file name will be used as a title)
@param parentId: the page id of the parent page (if default value, the page has no parent)
@param addFileAsAttachment: if True, the file specified is added as attachment to the page(if default value, no attachment is created)
@rtype: Page
@return: newly created Page"""
return Page.create(
self.pm_getSpaceManager().createPageFromFile(
localFilePath, self._unbox(space), title, parentId,
addFileAsAttachment), self._modelDataManager)
def request_page(self, url):
global last_requst_time
import hashlib
from sqlalchemy import desc
query_result = self.__session_crawler.query(Page).filter_by(
url=url).order_by(desc(Page.mtime)).first()
if query_result and os.path.isfile(
os.path.join(self.__data_dir, query_result.file_path)):
return open(os.path.join(self.__data_dir, query_result.file_path),
'rb').read()
now = datetime.datetime.now()
print('[{0}] Request {1}'.format(now.strftime("%Y-%m-%d %H:%M:%S.%f"),
url))
requst_timedelta = (now - last_requst_time).microseconds
if requst_timedelta < 500000: # 0.5s
time.sleep(0.5 - requst_timedelta / 1000000)
request_args = {'cookies': self.get_cookies(url)}
r = requests.get(url, **request_args)
#print('[{0}] Receive {1}'.format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),url))
last_requst_time = now
if r is None or r.status_code != 200 or r.content is None:
return '<html></html>'
content_hash = hashlib.md5(r.content).hexdigest()
file_path = os.path.abspath(
os.path.join(self.__data_dir,
self.url_to_file_path(url, content_hash)))
try:
os.makedirs(os.path.dirname(file_path))
except:
pass
page = Page(url=url,
size=len(r.content),
file_path=file_path,
content_hash=content_hash,
mtime=now)
self.__session_crawler.add(page)
self.__session_crawler.commit()
open(os.path.join(self.__data_dir, file_path), 'wb').write(r.content)
return r.content
def save():
try:
add = False
title = request.form['title']
content = request.form['content']
slug = request.form['slug']
if 'id' in request.form:
page = Page.query.get(request.form['id'])
cache.delete('view-page-%s' % slug) #Remove this page from cache for update in next view
else:
add = True
page = Page()
page.date_created = datetime.today()
page.title = title
page.content = content
page.slug = slug
page.date_updated = datetime.today()
if add:
db.session.add(page)
db.session.commit()
data = {}
data['message'] = "Página salva com sucesso! <a href='%s'>Visualizar</a>" % url_for('pages.view', slug=slug)
data['id'] = page.id
return jsonify(data)
except IntegrityError as e:
db.session.rollback()
data = {}
data['message'] = "O Slug informado ja existe. Altere e tente novamente."
return jsonify(data)
except:
db.session.rollback()
print "Unexpected error:", sys.exc_info()[0]
raise
def syncdb():
from lib.util import find_subclasses
from model import db, User, Distribution, Category, Page
models = find_subclasses(db.Model)
for model in models:
if model.table_exists():
model.drop_table()
model.create_table()
logging.info('created table:%s' % model._meta.db_table)
Distribution.create(name = '免费配送', price = 0)
Distribution.create(name = '上门自提', price = 0)
Category.create(name = '积分商品', slug = 'credit', order = 1)
Category.create(name = '搭配购买', slug = 'acc', order = 2)
Category.create(name = '慕斯蛋糕', slug = 'mousse', order = 3)
Category.create(name = '巧克力蛋糕', slug = 'chocolate', order = 4)
Category.create(name = '乳酪蛋糕', slug = 'cheese', order = 5)
Category.create(name = '乳脂奶油蛋糕', slug = 'creambutter', order = 6)
Category.create(name = '冰淇淋蛋糕', slug = 'icecream', order = 7)
Page.create(name = '吉米的厨房', slug = 'aboutus', content = '')
Page.create(name = '包装展示', slug = 'bzzs', content = '')
Page.create(name = '订购说明', slug = 'dgsm', content = '')
Page.create(name = '如何收货', slug = 'rhsh', content = '')
Page.create(name = '付款方式', slug = 'fkfs', content = '')
Page.create(name = '配送范围', slug = 'psfw', content = '')
User.create(mobile = 'root', password = User.create_password('111111'), group = 9)
logging.info('superuser - username:root password:111111')
def getLinkContent(self): return Page.query( Page.parent == self.getParentKey() ).order(-Page.timeOfCreation)
def getParent(self): parent = None; if self.ID: parent = Page.get_by_id(self.ID); return parent;
def get(self, pid):
Page.delete().where(Page.id == pid).execute()
self.flash(u"栏目删除成功")
self.redirect(self.request.headers["Referer"])
def get(self):
pages = [page for page in Page.select()]
self.render('admin/page.html', pages = pages)
from flask_sqlalchemy import SQLAlchemy
from model import Page, User, Role, Image
from setting import app
db = SQLAlchemy(app)
# db.drop_all()
# db.create_all()
page = Page()
x=page.query.filter_by(title='homepage').first()
if x is None:
page.title='homepage'
page.contents='<h1> Selamat datang di dunia python </h1>'
page.is_homepage=True
db.session.add(page)
db.session.commit()
# x1=page.query.filter_by(title='Hallo Dunia').first()
# if x1 is None:
# page.title='Hallo Dunia'
# page.contents='<h1> Hallo Dunia ? apa kabar... </h1>'
# page.is_homepage=False
# page.url='page/hallo-dunia'
# page.image_id=1
# db.session.add(page)
# db.session.commit()
gbr=Image()
