def save_article(request, page_name):
continent_list = dropdown()
page_content = request.POST['Content']
continent_content = request.POST['continent_rad']
try:
article = Article.objects.get(article_title=page_name)
except Article.DoesNotExist:
author = request.user
authorname = author.username
article = Article(article_title=page_name,
article_continent=continent_content,
article_author=authorname)
article.save()
content_author = request.user
content_author_name = content_author.username
content = Content(content_content=page_content,
content_article=article,
content_change_date=datetime.now(),
content_author=content_author_name)
content.save()
article.article_last_revision = content
article.save()
return HttpResponseRedirect("/wikijourney/" + page_name + "/")
def test_post_req_content_res(self):
with open('tests/services/test_req1.json') as json_data:
req = json.load(json_data)
json_data.close()
res = services.classify_content(Content(req))
self.assertEqual(len(res.result_list), 4,
'Missing response result')
def add_page():
form = EditPageForm()
if form.validate_on_submit():
page = Content()
page.title = form.title.data
page.content_type = 'page'
page.url = form.url.data.lower()
page.data_blob = form.content.data
page.created_by = session['user'].id
page.created_on = datetime.now()
page.edited_by = -1
page.edited_on = datetime.utcfromtimestamp(0)
page.required_priv_level = form.level.data
page.show_in_nav = form.navigation.data
db.session.add(page)
db.session.commit()
flash('Page "' + page.title + '" created.')
return redirect('/admin/content')
return render_template('admin/content/edit_page.html', action='Creating New', title='Create Page', form=form)
def upload(request):
"""
Renders the upload form page.
Args:
request: the request object
Returns:
response: a http response object
"""
if request.method == 'POST': # If the form has been submitted...
form = UploadForm(request.POST,
request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
c = Content()
originalname = str(request.FILES["file"])
c.user = request.user # Only authenticated users can use this view
c.set_file(originalname,
tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
Uploadinfo.create(c, request)
# uli.set_request_data(request)
# uli.save()
return HttpResponseRedirect(reverse('content:edit', args=[c.uid]))
else:
form = UploadForm(initial={}) # An unbound form
return _render_to_response(request, 'content_upload.html', {
'uploadform': form,
})
def create_do(request):
user, email, usernum = request.user.username.split("|")[:]
if redirect_validation(request, request.POST['type'], "type"):
return redirect_post_review(request.POST)
if redirect_validation(request, request.POST['project'], "project"):
return redirect_post_review(request.POST)
if redirect_validation(request, request.POST['version'], "version"):
return redirect_post_review(request.POST)
if redirect_validation(request, request.POST['comment'], "comment"):
return redirect_post_review(request.POST)
request.session['err'] = ''
s = Content(
type=request.POST['type'],
project=request.POST['project'],
env="",
run_id="",
comment=request.POST['comment'],
version=request.POST['version'],
status=1,
create_time=int(time.time()),
deploy_time=0,
finish_time=0,
create_user=user,
deploy_user="",
)
s.save()
initialization_release_status(request.POST['project'])
return HttpResponseRedirect("/task/list/1/")
def test_content_add_model(self):
"""
Test that the content of the page is successfully added to the database
"""
content = Content(header="Test_Header", content="Test_Content")
db.session.add(content)
db.session.commit()
self.assertEqual(
Content.query.filter_by(header="Test_Header",
content="Test_Content").count(), 1)
def api_upload(request):
"""
Renders the upload form page.
Args:
request: the request object
Returns:
response: a http response object
"""
if request.method == 'POST': # If the form has been submitted...
# for header in request.META.keys():
# if header.startswith('HTTP'):
# print header, request.META[header]
# print request.raw_post_data[:1000]
if request.user.is_authenticated() is False:
return HttpResponse(status=401)
form = UploadForm(request.POST,
request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
SUPPORTED_FIELDS = ['title', 'caption', 'author']
kwargs = {}
for field in SUPPORTED_FIELDS:
kwargs[field] = request.POST.get(field)
try:
kwargs['point'] = Point(float(request.POST.get('lon')),
float(request.POST.get('lat')))
except:
# raise
pass
print kwargs
c = Content(**kwargs)
originalname = str(request.FILES["file"])
# Only authenticated users can use this view
c.user = request.user
# Save uploaded file to filesystem
c.set_file(originalname, tmpname)
# Create thumbnail if it is supported
c.get_type_instance()
c.save()
Uploadinfo.create(c, request)
break # We save only the first file
response = HttpResponse(status=201)
# response.status_code = 201
# FIXME: use reverse()
response['Location'] = '/content/api/v1/content/%s/' % c.uid
return response
# return HttpResponseRedirect(reverse('content:edit', args=[c.uid]))
else:
response = HttpResponse(status=204)
return response
else:
raise Http404
def parse_post_req_content(insert=False):
try:
json_content = request.get_json()
content = Content(json_content)
content.insert = insert
return content
except:
err = traceback.format_exc()
logger.error(err)
raise InvalidUsage(
'Could not parse request! Please check ids and request format.')
def __init__(self, log, course, answers, courses):
self.course_name = ''
self.users = Users()
self.tasks = Tasks()
self.modules = Modules()
self.content = Content()
self._parse(log)
for item in (self.users, self.tasks, self.modules, self.content):
item.update_data(course, answers)
self.course_long_name = courses[self.course_name]
def write(request):
if request.method =='POST':
content = Content(date = timezone.now())
form = PostForm(request.POST, instance=content)
if form.is_valid():
form.save()
return HttpResponseRedirect('')
else:
form = PostForm()
content_list = Content.objects.all().order_by('id').reverse()
return render_to_response('blog/index.html',
RequestContext(request,
{ 'content_list':content_list,
'form':PostForm,
}))
def html5upload(request):
"""
Renders the upload form page.
Args:
request: the request object
Returns:
response: a http response object
"""
if request.method == 'POST': # If the form has been submitted...
result = []
for filefield, tmpname in handle_uploaded_file(request):
c = Content()
originalname = str(request.FILES["file"])
c.user = request.user # Only authenticated users can use this view
c.set_file(originalname,
tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
Uploadinfo.create(c, request).save()
# print originalname
# generating json response array
result.append({
"name":
originalname,
"size":
c.filesize,
"url":
reverse('content:edit', args=[c.uid]),
"thumbnail_url":
'/content/instance/%s-200x200.jpg' % c.uid,
"delete_url":
reverse('content:edit', args=[c.uid]),
"delete_type":
"POST",
})
# print result
response_data = json.dumps(result)
# print response_data
# checking for json data type
# big thanks to Guy Shapiro
if "application/json" in request.META['HTTP_ACCEPT_ENCODING']:
mimetype = 'application/json'
else:
mimetype = 'text/plain'
return HttpResponse(response_data, mimetype=mimetype)
return _render_to_response(request, 'content_html5upload.html', {})
def line_type(line):
"""
seperate line's msg into many type
content: normal text
multiline: is part of last content, because we split log by \n
datestamp: date for following message
invite: someone invite others into group
join: the one was invited join group
title: Group's name
savedate: the date user saved log
"""
content_r = re.match('(\d{2}:\d{2})\t(.*?)\t(.*?)', line)
if content_r:
time = content_r.group(1)
name = content_r.group(2)
text = content_r.group(3)
content = Content(time, name, text)
return content
datestamp_r = re.match('^(\d{4}\/\d{2}\/\d{2})\((週.)\)', line)
if datestamp_r:
return ('datestamp', datestamp_r.group(1), datestamp_r.group(2))
invite_r = re.match('(\d{2}:\d{2})\t(.*)邀請(.*)加入群組。', line)
if invite:
time = invite_r.group(1)
inviter = invite_r.group(2)
invitee = invite_r.group(3)
invite = Invite(time, inviter, invitee)
return invite
join = re.match('(\d{2}:\d{2})\t(.*)加入聊天', line)
if join:
dic = {'time': join.group(1), 'name': join.group(2)}
return ('join', dic)
title = re.match('\ufeff\[LINE\] (.*)的聊天記錄', line)
if title:
return ('title', title.group(1))
save_date = re.match('儲存日期：(\d{4}\/\d{2}\/\d{2} \d{2}:\d{2})', line)
if save_date:
return ('save_date', save_date.group(1))
if line.strip() == "":
return ('empty', line)
return ('multiline', line)
def search(self, topic, site):
bs = self.getPage(site.searchUrl + topic)
searchResults = bs.select(site.resultListing)
for result in searchResults:
url = result.select(site.resultUrl)[0].attrs["href"]
if (site.absoluteUrl):
bs = self.getPage(url)
else:
bs = self.getPage(site.url + url)
if bs is None:
print("page or url wrong!")
return
title = self.safeGet(bs, site.titleTag)
body = self.safeGet(bs, site.bodyTag)
if title != "" and body != "":
content = Content(topic, title, body, url)
content.print()
def file_upload():
if 'file' not in request.files:
raise FileNotFoundException("File not Found")
file = request.files['file']
data = request.form['description']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
raise FileNotSelectedException("No selected file")
if file and allowed_file(file.filename):
filename = secure_filename(random_string() + ".jpg")
path = UPLOAD_FOLDER
content = Content(filename, path, data)
Content.add_content(content)
image_file = Image.open(file)
image_file.save(os.path.join(path, filename), quality=30)
def create_content(content_name,
browser=False,
script=False,
url=None,
script_body=None):
if db_session.query(Content).filter(
Content.content_name == content_name).first():
return False # Content already exists with this name
# TODO : Fix scripts being saved without newlines
new_content = Content(content_name=content_name,
browser=browser,
url=url,
script=script,
script_body=script_body)
db_session.add(new_content)
db_session.commit()
return True
def create(request):
if request.method == 'GET':
new = ContentForm()
if request.method == 'POST':
new = ContentForm(request.POST)
print new.is_valid()
if new.is_valid(
): #如果is_valid()不对可以打印new.errors来看哪块有问题,可以搜form组件is_valid校验机制
date = new.cleaned_data['date']
customer_name = new.cleaned_data['customer_name']
dfe_name = new.cleaned_data['dfe_name']
question = new.cleaned_data['question']
solution = new.cleaned_data['solution']
solution_or_not = new.cleaned_data['solution_or_not']
update_or_not = new.cleaned_data['update_or_not']
change_or_not = new.cleaned_data['change_or_not']
share_or_not = new.cleaned_data['share_or_not']
# author = request.user.username
print request.user
# aa = {}
# aa.update(new.cleaned_data)
# aa['author'] = author
aa = Content()
aa.date = date
aa.customer_name = customer_name
aa.dfe_name = dfe_name
aa.question = question
aa.solution = solution
aa.solution_or_not = solution_or_not
aa.update_or_not = update_or_not
aa.change_or_not = change_or_not
aa.share_or_not = share_or_not
aa.author = request.user
aa.save()
return redirect('index')
else:
print 'ccccc'
for i in new.errors:
print i
return render(request, 'jihua/input.html', locals())
def post(self, partner_id):
db_session = maker()
body = self.get_argument('body')
my_user_query = self.get_a_user_query_from_id(self.current_user)
time_stamp = time.strftime('%Y-%m-%d %H:%M:%S')
# データ追加
new_content = Content(from_id=my_user_query.id,
to_id=partner_id,
content=body,
datetime=time_stamp)
try:
db_session.add(new_content)
db_session.commit()
except Exception as e:
db_session.rollback()
logging.warning(e)
finally:
db_session.close()
self.redirect('/chat/{}'.format(partner_id))
async def admin_upload_content(request: Request,
content_data: UploadFile = File(...),
content_short: str = Form(...),
content_filetype: str = Form(...),
admin: User = Depends(get_current_admin)):
from extensions.mongo import mongo_engine
file_id = ObjectId()
new_content = Content(id=file_id,
short=content_short,
filetype=content_filetype)
await Content.insert_one(new_content.dict(by_alias=True))
grid_in = mongo_engine.fs.open_upload_stream_with_id(
file_id,
content_data.filename,
metadata=new_content.dict(by_alias=True))
with content_data.file as f:
await grid_in.write(f.read())
await grid_in.close()
return RedirectResponse(url="/", status_code=303)
def test_questions_answers_add_model(self):
"""
Test that the question and then answer is successfully added to the database
"""
content = Content(header="Test_Header", content="Test_Content")
question = Questions(question_text="Test_Question?", content=content)
answer = Answers(answer_text="Answer_Test",
correct=0,
question=question)
db.session.add(content)
db.session.add(question)
db.session.add(answer)
db.session.commit()
self.assertEqual(
Questions.query.filter_by(question_text="Test_Question?").count(),
1)
self.assertEqual(
Answers.query.filter_by(answer_text="Answer_Test",
correct=0,
question=question).count(), 1)
def save_record():
data = request.get_json()
header = data['header']
title = data['title']
content = data['text']
content = add_class(content, "img", "img-fluid")
content = add_img_id(content)
if 'id' in data:
id = data['id']
article = Content.query.get(id)
if not article:
return jsonify("An error occured")
article.header = header
article.title = title
article.content = content
else:
article = Content(header=header, title=title, content=content)
db.session.add(article)
db.session.commit()
return jsonify("Action executed with success")
async def init_testing_database():
warning("Initialize fresh development database")
await User.collection.drop()
await Group.collection.drop()
await Node.collection.drop()
await Content.collection.drop()
async for data in mongo_engine.fs.find():
mongo_engine.fs.delete(data._id)
# Pdf example content
file_id = ObjectId()
content_1 = Content(id=file_id,
short="An example of pdf file.",
filetype="pdf")
await Content.collection.insert_one(content_1.dict(by_alias=True))
grid_in = mongo_engine.fs.open_upload_stream_with_id(
file_id, "pdfexample.pdf", metadata=content_1.dict(by_alias=True))
with open("static/contents/pdfexample.pdf", "rb") as f:
await grid_in.write(f.read())
await grid_in.close()
# Md example content
file_id = ObjectId()
content_2 = Content(id=file_id,
short="An example of md file.",
filetype="md")
await Content.collection.insert_one(content_2.dict(by_alias=True))
grid_in = mongo_engine.fs.open_upload_stream_with_id(
file_id, "mdexample.pdf", metadata=content_2.dict(by_alias=True))
with open("static/contents/mdexample.md", "rb") as f:
await grid_in.write(f.read())
await grid_in.close()
inserted_nodes_result = await Node.collection.insert_many([
{
"short":
f"node{i}",
"contents": [
# DBRef(**content_1.dict(by_alias=True)).dict(by_alias=True),
content_1.id,
content_2.id,
]
} for i in range(10)
])
# inserted_nodes_refs = [{"_id": _id, "collection_name": "nodes"} for _id in inserted_nodes_result.inserted_ids]
inserted_groups_result = (await Group.collection.insert_many([{
"short":
"first",
"nodes":
inserted_nodes_result.inserted_ids[0:5]
}, {
"short":
"second",
"nodes":
inserted_nodes_result.inserted_ids[3:97]
}]))
# inserted_groups_refs = [{"_id": _id, "collection_name": "groups"} for _id in inserted_groups_result.inserted_ids]
User.collection.insert_many([
{
"email": "*****@*****.**",
"password_hash": get_password_hash("pass"),
"username": "",
"groups": inserted_groups_result.inserted_ids,
},
{
"email": "*****@*****.**",
"password_hash": get_password_hash("pass"),
"username": "",
"groups": [],
"is_admin": True,
},
])
def load_content(self):
content_data = self.__read_csv("content")
localized_content_data = self.__read_csv("content_localized")
contentblocks_data = self.__read_csv("content_blocks")
style_sys_data = self.__read_csv("system_style")[0]
#load style
## READ STYLE
style = SystemStyle()
self.__fill_members_with_csv_data(
style, ('fg_color', 'bg_color', 'hl_color', 'ch_color', 'icon',
'custom_marker'), style_sys_data)
#load content
self.content = {}
for item in content_data:
c = Content()
self.__fill_members_with_csv_data(
c, ('content_id', 'name', 'image_name', 'tags', 'category'),
item)
c.tags = c.tags.split(',') #split tags
c.category = int(c.category) #parse category to int
c.style = style
self.content[c.content_id] = c #add to content items
#load localized info
for item in localized_content_data:
lang = LocalizedContentInformation()
self.__fill_members_with_csv_data(
lang, ('content_id', 'language', 'title', 'description'), item)
#add to right content
if self.content.has_key(item[0]):
self.content[item[0]].localized_content_information[
item[1]] = lang
else:
logging.warn(
"Localized Content Data with invalid content id: " +
item[0])
#load content blocks
for item in contentblocks_data:
#they have to be parsed in a special way,because they vary in terms of fields
b = ContentBlock()
b.content_id = item[0]
b.content_block_type = int(item[2])
b.public = string_to_bool(item[3])
if b.content_block_type == ContentBlockTypes.TEXT:
b.title = item[4]
b.text = item[5]
elif b.content_block_type == ContentBlockTypes.AUDIO:
b.title = item[4]
b.artists = item[5]
b.file_id = item[6]
elif b.content_block_type == ContentBlockTypes.VIDEO:
b.title = item[4]
b.youtube_url = item[5]
elif b.content_block_type == ContentBlockTypes.IMAGE:
b.title = item[4]
b.file_id = item[5]
b.scale_x = float(item[6])
b.alt_text = item[7]
elif b.content_block_type == ContentBlockTypes.LINK:
b.title = item[4]
b.text = item[5]
b.link_type = int(item[6])
b.link_url = item[7]
elif b.content_block_type == ContentBlockTypes.EBOOK:
b.title = item[4]
b.artists = item[5]
b.file_id = item[6]
elif b.content_block_type == ContentBlockTypes.CONTENT:
b.title = item[4]
b.content_id = item[5]
elif b.content_block_type == ContentBlockTypes.SOUNDCLOUD:
b.title = item[4]
b.soundcloud_url = item[5]
elif b.content_block_type == ContentBlockTypes.DOWNLOAD:
b.title = item[4]
b.text = item[5]
b.download_type = int(item[6])
b.file_id = item[7]
elif b.content_block_type == ContentBlockTypes.SPOTMAP:
b.title = item[4]
b.spot_map_tag = item[5]
else:
raise Exception("Unknown Content Block Type: " +
str(b.content_block_type))
#add to right content and lang
if self.content.has_key(item[0]):
if self.content[item[0]].localized_content_information.has_key(
item[1]):
self.content[item[0]].localized_content_information[
item[1]].content_blocks.append(b)
else:
logging.warn("Content Block Data with invalid lang: " +
item[0] + "/" + item[1])
else:
logging.warn("Content Block Data with invalid content id: " +
item[0])
def show():
form_pass = ChangePassWord()
user = User.query.filter_by(username=current_user.username).first()
if form_pass.validate_on_submit():
if not user.is_correct_password(form_pass.lastpass.data):
flash('初始密码错误')
return redirect('/accounts/settings')
else:
if form_pass.confirpass.data != form_pass.newpass.data:
flash('两次密码不一致')
return redirect('/accounts/settings')
else:
user.password = form_pass.newpass.data
db.session.commit()
flash('修改成功')
return redirect('/accounts/settings')
username = current_user.username
user_content = Content.query.filter_by(user_name=username).order_by(
Content.pub_date.desc()).first()
form = ContentForm()
if form.validate_on_submit():
if user_content == None:
new_content = Content(body=form.contentbox.data, user=current_user)
db.session.add(new_content)
user.nickname = form.nickname.data
db.session.commit()
return redirect('accounts/settings')
else:
user.nickname = form.nickname.data
db.session.commit()
user_content.body = form.contentbox.data
db.session.commit()
return redirect('/accounts/settings')
form_media = MediaForm()
user_media = Media.query.filter_by(user_name=username).first()
if form_media.validate_on_submit():
if user_media == None:
media_setting = Media(
user=current_user,
weibo=form_media.weibo.data,
weixin=form_media.weixin.data,
douban=form_media.douban.data,
twitter=form_media.twitter.data,
github=form_media.github.data,
zhihu=form_media.zhihu.data,
)
db.session.add(media_setting)
db.session.commit()
if form_media.weibo.data != '' and user_media != None:
user_media.weibo = form_media.weibo.data
db.session.commit()
if form_media.weixin.data != '' and user_media != None:
user_media.weixin = form_media.weixin.data
db.session.commit()
if form_media.douban.data != '' and user_media != None:
user_media.douban = form_media.douban.data
db.session.commit()
if form_media.twitter.data != '' and user_media != None:
user_media.twitter = form_media.twitter.data
db.session.commit()
if form_media.github.data != '' and user_media != None:
user_media.github = form_media.github.data
db.session.commit()
if form_media.zhihu.data != '' and user_media != None:
user_media.zhihu = form_media.zhihu.data
db.session.commit()
return redirect('/accounts/settings')
useravatar = User.query.filter_by(username=username).first()
if request.method == 'POST':
global file
file = request.files['file']
useravatar.avatar = secure_filename(file.filename)
db.session.commit()
if file and allowed_file(file.filename):
global filename
filename = secure_filename(file.filename)
file.save(os.path.join(UPLOAD_FOLDER, filename))
avatar_url = url_for('uploaded_file', filename=filename)
return redirect('accounts/settings')
return render_template('/accounts/settings.html',
form=form,
user_content=user_content,
form_media=form_media,
user_media=user_media,
file=file,
useravatar=useravatar,
form_pass=form_pass,
user=user)
def insert_cache(self):
last = "<!-- " + self.current_page + " -->"
self.session.add(
Content(page_id=self.get_page_id(), html=str(self.bsObj) + last))
