def insert_initial_data():
try:
admin = User(
username='******',
password=app.config.get('ADMIN_PASSWORD')
)
db.session.add(admin)
db.session.commit()
except IntegrityError:
db.session.rollback()
return
admin_note = Note(
title='Hello world',
content=('Lorem ipsum dolor sit amet, consectetur '
'adipiscing elit, sed do eiusmod tempor incididunt...'),
owner=admin
)
db.session.add(admin_note)
admin_note = Note(
title='flag',
content=app.config.get('FLAG'),
owner=admin
)
db.session.add(admin_note)
db.session.commit()
def post(self):
user = users.get_current_user()
if user is None:
self.error(401)
self._create_note(user)
note = Note(title=self.request.get('title'),
content=self.request.get('content'))
note.put()
note = Note(parent=ndb.Key("User", user.nickname()),
title=self.request.get('title'),
content=self.request.get('content'))
note.put()
item_titles = self.request.get('checklist_items').split(',')
for item_title in item_titles:
item = CheckListItem(parent=note.key, title=item_title)
item.put()
note.checklist_items.append(item.key)
note.put()
logout_url = users.create_logout_url(self.request.uri)
template_context = {
'user': user.nickname(),
'logout_url': logout_url,
}
self.response.out.write(template.render(template_context))
def _render_template(self, template_name, context=None):
if context is None:
context = {}
user = users.get_current_user()
ancestor_key = ndb.Key("User", user.nickname())
qry = Note.owner_query(ancestor_key)
context['notes'] = qry.fetch()
template = jinja_env, get_template(template_name)
return template.render(context)
self.response.out.write(
self._render_template('main.html', template_context))
@ndb.transactional
def _create_note(self, user):
note = Note(parent=ndb.Key("User", user.nickname()),
title=self.request.get('title'),
content=self.request.get('content'))
note.put()
item_titles = self.request.get('checklist_items').split(',')
for item_title in item_titles:
item = CheckListItem(parent=note.key, title=item_title)
item.put()
note.checklist_items.append(item.key)
note.put()
def hour_notification():
while True:
now = datetime.now()
offset = 60 - (now.second + (now.microsecond / 1000000))
dt = int(now.timestamp() + offset)
sleep(offset)
[
notification(Note(*note))
for note in Note().select(f'datetime={dt + 3600}')
]
def day_notification(time='09:00'):
notification_time = datetime.strptime(time, '%H:%M').time()
while True:
now = datetime.now()
notification_dt = int(
datetime.combine(now.date(), notification_time).timestamp())
if now.time() > notification_time:
notification_dt += 86400
now_dt = int(now.timestamp())
sleep(notification_dt - now_dt)
[
notification(Note(*note)) for note in Note().select(
f'datetime BETWEEN {now_dt} AND {now_dt + 86400}')
]
def new_note():
if session.get('user'):
if request.method == 'POST':
title = request.form['title']
text = request.form['noteText']
from datetime import date
today = date.today()
today = today.strftime("%m-%d-%Y")
privacy = request.form['privacy']
new_record = Note(title, text, today, session['user_id'], privacy)
db.session.add(new_record)
db.session.commit()
return redirect(url_for('get_notes'))
else:
return render_template('new.html', user=session['user'])
else:
return redirect(url_for('login'))
def new_note():
# check if a user is saved in session
if session.get('user'):
# check method used for request
if request.method == "POST":
# get title data
title = request.form["title"]
# get note data
text = request.form["noteText"]
# create date stamp
from datetime import date
today = date.today()
# format date mm/dd/yyyy
today = today.strftime("%m-%d-%Y")
new_record = Note(title, text, today, session['user_id'])
db.session.add(new_record)
db.session.commit()
return redirect(url_for('get_notes'))
else:
# GET request - show new note form
return render_template("new.html", user=session['user'])
else:
# user is not in session redirect to login
return redirect(url_for('login'))
def add_applicant_note(applicant_user_id,
text,
title=None,
is_chat_log=False,
current_user=None):
application = Application.get_submitted_for_user(applicant_user_id)
if application is None:
raise BadRequestException('User {} is not an applicant'.format(
User.get(applicant_user_id).name))
else:
if not is_recruiter(current_user):
raise ForbiddenException('Current user is not a recruiter')
elif (application.recruiter_id != current_user.id
and not is_senior_recruiter(current_user)):
raise ForbiddenException(
'Current recruiter has not claimed applicant {}'.format(
applicant_user_id))
note = Note(
text=text,
title=title,
application_id=application.id,
is_chat_log=is_chat_log,
author_id=current_user.id,
)
db.session.add(note)
db.session.commit()
return {'status': 'ok'}
def note():
req_title = request.form.get('title')
req_content = request.form.get('content')
if not req_title or not req_content:
flash('title or content is blank', category='danger')
return redirect(url_for('index'))
if len(req_title) > app.config.get('NOTE_TITLE_MAX_LENGTH'):
flash(f'too long title (max length: {app.config.get("NOTE_TITLE_MAX_LENGTH")})', category='danger')
return redirect(url_for('index'))
if len(req_content) > app.config.get('NOTE_CONTENT_MAX_LENGTH'):
flash(f'too long content (max length: {app.config.get("NOTE_CONTENT_MAX_LENGTH")})', category='danger')
return redirect(url_for('index'))
new_note = Note(
title=req_title,
content=req_content,
author=current_user
)
db.session.add(new_note)
db.session.commit()
flash('added new note successfully', category='success')
return redirect(url_for('index'))
def post(self):
note = self.request.get('note')
if len(note) > 1500:
note = note[:1500]
user = users.get_current_user()
Note(user_id=user.user_id(), content=note).put()
self.redirect('/')
def new_note(request):
if request.method == 'POST' and 'b2' in request.POST :
form = NewNote(request.POST)
if form.is_valid():
new = Note()
new.owner = request.session['username']
new.head = form.cleaned_data["heading"]
new.content = form.cleaned_data["content"]
con = Markdown()
new.md = con.convert(new.content)
new.save()
return HttpResponseRedirect("./")
if request.method == 'POST' and 'b1' in request.POST :
form = NewNote(request.POST)
if form.is_valid():
con=Markdown()
request.session['temp'] = con.convert(form.cleaned_data['content'])
return HttpResponseRedirect('preview')
data = [i for i in Note.objects.all() if i.owner == request.session['username']]
context = dict()
context['data'] = data
context['form'] = NewNote()
context['username'] = request.session['username']
temp = loader.get_template('notes/newnote.html')
return HttpResponse(temp.render(context, request))
def new_note():
# retrieve user from database
# a_user = db.session.query(User).filter_by(email='*****@*****.**').one()
# check if a user is saved in session
if session.get('user'):
# check method used for request
# print('request method is', request.method)
if request.method == 'POST':
# get title data
title = request.form['title']
# get note data
text = request.form['noteText']
# create date stamp
from datetime import date
today = date.today()
# format date mm/dd/yyyy
today = today.strftime('%m-%d-%Y')
newEntry = Note(title, text, today, session['user_id'])
db.session.add(newEntry)
db.session.commit()
return redirect(url_for('get_notes'))
else:
return render_template('new.html', user=session['user'])
else:
# user is not in session redirect to login
return redirect(url_for('login'))
def add_notes_form(username):
""" GET: Display a form to add notes.
POST: Add a new note and redirect to /users/<username>
"""
if CURRENT_USER not in session:
flash("You are not authorized to view this page.")
return redirect("/login")
elif username != session[CURRENT_USER]:
flash("You are not authorized to access another user's page.")
logged_in_user = session[CURRENT_USER]
return redirect(f"/users/{logged_in_user}")
form = NoteForm()
user = User.query.get_or_404(username)
if form.validate_on_submit():
title = form.title.data
content = form.content.data
note = Note(title=title, content=content)
user.notes.append(note)
db.session.commit()
return redirect(f'/users/{username}')
else:
return render_template("new_note.html", user=user, form=form)
def _create_note(self, user, title, content, attachments):
note = Note(parent=ndb.Key("User", user.nickname()),
title=title,
content=content)
note.put()
if attachments:
bucket_name = app_identity.get_default_gcs_bucket_name()
for file_name, file_content in attachments:
content_t = mimetypes.guess_type(file_name)[0]
real_path = os.path.join('/', bucket_name, user.user_id(), file_name)
with cloudstorage.open(real_path, 'w', content_type=content_t,
options={'x-goog-acl': 'public-read'}) as f:
f.write(file_content.decode())
key = blobstore.create_gs_key('/gs' + real_path)
try:
url = images.get_serving_url(key, size=0)
thumbnail_url = images.get_serving_url(key, size=150, crop=True)
except images.TransformationError, images.NotImageError:
url = "http://storage.googleapis.com{}".format(real_path)
thumbnail_url = None
f = NoteFile(parent=note.key, name=file_name,
url=url, thumbnail_url=thumbnail_url,
full_path=real_path)
f.put()
note.files.append(f.key)
note.put()
def new_note():
# check if a user is saved in session
if session.get('user'):
# check method used for request
if request.method == 'POST':
# get title data
title = request.form['title']
# get note data
text = request.form['noteText']
# create data stamp
from datetime import date
today = date.today()
# format data mm/dd/yyyy
today = today.strftime("%m-%d-%Y")
new_record = Note(title, text, today, session['user_id'])
db.session.add(new_record)
db.session.commit()
return redirect(url_for('get_notes'))
else:
#GET request - show new note form
#retrieve user from database
a_user = db.session.query(User).filter_by(
id=session['user_id']).one()
return render_template('new.html', user=a_user)
else:
# user is not in session redirect to login
return redirect(url_for('login'))
def new_note():
# check if a user is saved in session
if session.get('user'):
if request.method == 'POST':
title = request.form['title']
text = request.form['noteText']
from datetime import date
from datetime import datetime
today = date.today()
now = datetime.now()
timestamp = now.strftime("%I:%M:%S")
today = today.strftime("%m-%d-%Y")
views = 0
new_record = Note(title, text, today,
timestamp, views, session['user_id'])
db.session.add(new_record)
db.session.commit()
return redirect(url_for('get_notes'))
else:
# GET request - show new note form
# retrieve user from database
a_user = db.session.query(User).filter_by(id=session['user_id']).one()
return render_template('new.html', user=session['user'])
else:
return redirect(url_for('login'))
def publish_note(request):
if request.POST['flag'] == 'index':
id = request.POST['userid']
pub = Publisher.objects.filter(id=id)[0]
return render(request, 'edit.html', {'pub': pub})
else:
username = request.POST['id']
title = request.POST['title']
content = request.POST['content']
flag = request.POST['flag']
timer = time.strftime("%Y-%m-%d %X", time.localtime())
note = Note(title=title,
time=timer,
content=content,
publisher_id=username)
note.save()
#待修改
#增刷新个人主页帖子window.location.reload;
return HttpResponse(
'<script type="text/javascript">alert("发布成功");window.history.go(-2);</script>'
)
def my_notes():
user = User.query.filter_by(id=current_user.id).first()
form = CreateNoteForm(meta={'csrf_context': session})
if form.validate_on_submit():
heading = form.heading.data
title = form.title.data
body = form.body.data
public = form.public.data
note = Note(title=title,
heading=heading,
body=body,
owner=user,
public=public)
db.session.add(note)
shares_list = {row.strip() for row in form.shares.data.split()}
for user_name in shares_list:
share = Share(note=note, user_name=user_name)
db.session.add(share)
db.session.commit()
flash('Notatka została dodana', 'alert alert-success')
notes = user.notes
return render_template('my_notes.html', form=form, notes=notes)
def new():
pcfg = {"title": "New note"}
form = NoteForm()
if form.validate_on_submit():
a = Note()
a.title = form.title.data
a.cat = form.cat.data
a.note = form.note.data
a.user_id = current_user.id
db.session.add(a)
db.session.commit()
flash("Success updating note: {0}".format(a.title), "success")
return redirect(url_for("bp_notes.notes"))
logbooks = (db.session.query(Logbook.id, Logbook.name, func.count(
Log.id)).join(Log).filter(Logbook.user_id == current_user.id).group_by(
Logbook.id).all())
return render_template("notes/new.jinja2",
pcfg=pcfg,
form=form,
logbooks=logbooks)
def handle_add_notes(username):
""" Display form to add notes for the logged in user.
Add new note and redirect to user detail.
"""
if session.get('user_id') != username:
flash("You are not authorized to add notes to this user!")
return redirect('/')
form = NoteForm()
if form.validate_on_submit():
new_note = Note()
form.populate_obj(new_note)
new_note.owner = username
db.session.add(new_note)
db.session.commit()
flash("Note has been added")
return redirect(f"/users/{username}")
else:
return render_template("add_notes.html", form=form)
def add_note(username):
"""
If GET, displays a form to add a new note
If POST, processes new note and redirects to user's info page
"""
#fail fast
#redirect and flash first
user = User.query.get_or_404(username)
if "username" not in session or username != session["username"]:
flash("You cannot add a note from this user")
return redirect("/")
form = NoteForm()
if form.validate_on_submit():
title = form.title.data
content = form.content.data
new_note = Note(title=title, content=content, owner=user.username)
db.session.add(new_note)
db.session.commit()
return redirect(f"/users/{user.username}")
else:
return render_template("new_note_form.html", form=form)
def post():
if request.method == 'POST':
note = Note(title=request.form['title'], body=request.form['note'])
db.session.add(note)
db.session.commit()
return redirect(url_for('index'))
return render_template('post.html')
def new_note():
if session.get('user'):
#check method used for request
if request.method == 'POST':
#get title data
title = request.form['title']
#get note data
text = request.form['noteText']
#create data stamp
from datetime import date
today = date.today()
# format date mm/dd/yyyy
today = today.strftime("%m-%d-%Y")
new_record = Note(title, text, today, session['user_id'])
db.session.add(new_record)
db.session.commit()
return redirect(url_for('get_notes'))
else:
return render_template('new.html', user=session['user'])
else:
return render_template(url_for('login'))
def to_internal_value(self, validated_data):
logging.debug('create note')
note = Note(
note=validated_data.get('note'),
user=self.context.get('request').user
)
return note
def _create_note(self, user, file_name, file_path):
note = Note(parent=ndb.Key("User", user.nickname()),
title=self.request.get('title'),
content=self.request.get('content'))
item_titles = self.request.get('checklist_items').split(',')
for item_title in item_titles:
if not item_title:
continue
item = CheckListItem(title=item_title)
note.checklist_items.append(item)
note.put()
if file_name and file_path:
url, thumbnail_url = self._get_urls_for(file_name)
f = NoteFile(parent=note.key,
name=file_name,
url=url,
thumbnail_url=thumbnail_url,
full_path=file_path)
f.put()
note.files.append(f.key)
note.put()
inc_note_counter()
def test_delete_ticket_note(self):
# Create our two users and make them owners of the same ticket.
self.add_users_to_db()
ticket = Ticket(id=3,
status=0,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(ticket)
users = self.session.query(User).all()
for user in users:
owner = Ownership(owner_id=user.id,
ticket_id=3,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(owner)
note = Note(id=6,
poster_id=users[0].id,
ticket_id=3,
message="My message to the world",
status=2,
type=3,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(note)
self.session.commit()
# Now delete the note and verify it is gone.
response = self.app.delete('/portal/ticket/note/6')
response.status == "200 OK"
result = self.session.query(Note).first()
assert result is None
def user_notes_add(username):
""" Show notes add form or handle note to add."""
if session.get("username") != username:
flash("You must be logged in to view!")
return redirect("/")
form = AddNoteForm()
if form.validate_on_submit():
user = User.query.get(username)
title = form.title.data
content = form.content.data
owner = user.username
new_note = Note(
title=title,
content=content,
owner=owner,
)
db.session.add(new_note)
db.session.commit()
return redirect(f"/users/{user.username}")
else:
return render_template("user_notes_add.html", form=form)
def add_new_note(username):
""" display form to add a new note and
adds new note to user notes """
form = NewNoteForm()
if "user_id" not in session:
flash("User access not allowed - must be logged in")
return redirect('/')
else:
if session["user_id"] == username:
if form.validate_on_submit():
title = form.title.data
content = form.content.data
note = Note(title=title, content=content, owner=username)
db.session.add(note)
db.session.commit()
return redirect(f"/users/{username}")
else:
return render_template("note_add_new.html", form=form)
return redirect("/login")
def save():
title = request.form['ntitle']
body = request.form['nbody']
note = Note(title, body, session['uid'])
db.session.add(note)
db.session.commit()
flash('Note saved successfully.')
return redirect("/")
def post(self):
parsed_args = parser.parse_args()
note = Note(title=parsed_args['title'], body=parsed_args['body'],
date= datetime.now().strftime("%a, %d/%m/%Y"),
archived = False)
session.add(note)
session.commit()
return note, 201
def index():
if request.method == 'POST' and request.form.get('content'):
note = Note(content=request.form['content'])
Note.save(note)
return redirect(url_for('index'))
notes = Note.list_public()
return render_template('index.html', notes=notes)
