def save(request, title):
title = normalize_title(title)
body = request.POST['body']
page = Page.upsert(title, body)
comment = request.POST['comment']
edit = Edit(page=page, comment=comment)
edit.save()
return redirect("/wiki/%s" % title)
def UpdatePin(id=0):
pin = Pin.query.get_or_404(id)
user = get_jwt_identity()
if (User.Role(user['role']) not in [User.Role.ADMIN, User.Role.VERIFIED]) and (user['id'] != pin.edits[0].user_id):
return Response('only the creator or an admin can edit a pin', status=403)
try:
json = request.json
details = ''
PROPERTY_LIST = ['position_x', 'position_y', 'symbol', 'resource', 'rank', 'name',
'amount', 'respawn', 'notes', 'x_cord', 'y_cord']
for prop in PROPERTY_LIST:
old_value = getattr(pin, prop)
enum = False
if hasattr(old_value, 'value'):
old_value = old_value.value
enum = True
if old_value != json[prop]:
details += f'{prop} changed from {old_value} to {json[prop]}\n'
if enum is True:
if json[prop] in [item.value for item in Pin.Symbol]:
setattr(pin, prop, Pin.Symbol(json[prop]))
elif json[prop] in [item.value for item in Pin.Resource]:
setattr(pin, prop, Pin.Resource(json[prop]))
else:
setattr(pin, prop, json[prop])
db.session.commit()
newEdit = Edit(details, pin.id, get_jwt_identity()['id'])
db.session.add(newEdit)
db.session.commit()
return jsonify(pin.to_dict())
except IntegrityError as error:
return Response(error.args[0], status=400)
def CreatePin():
json = request.json
try:
newPin = Pin(
json['position_x'],
json['position_y'],
Pin.Symbol(json['symbol']),
Pin.Resource(json['resource']),
json['world_id'] or None,
json['rank'],
json['name'],
json['amount'],
json['respawn'],
json['notes'],
json['x_cord'],
json['y_cord']
)
db.session.add(newPin)
db.session.commit()
newEdit = Edit(json['notes'], newPin.id, get_jwt_identity()['id'])
db.session.add(newEdit)
db.session.commit()
data = jsonify(newPin.to_dict())
data.status_code = 201
return data
except IntegrityError as error:
return Response(error.args[0], status=400)
def post(self):
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
teleUser = TeleUser.get_by_id(user.user_id())
if not teleUser:
teleUser = TeleUser.fromGSI(user=user)
teleUser.put()
thread_id = random.randint(1000000000, 9999999999)
thread = Thread(thread_id=thread_id)
drawingDataUrl = self.request.get("drawing")
img_data = drawingDataUrl.split('data:image/png;base64,')[1]
img = Image.open(BytesIO(base64.b64decode(img_data)))
output = StringIO()
img.save(output, format=img.format)
drawing = output.getvalue()
new_drawing = Drawing(content=drawing)
allDrawings = Drawing.query().fetch()
drawings = []
for drawin in allDrawings:
if drawin.content == new_drawing.content:
drawings.append(drawin)
if drawings:
new_drawing = drawings[0]
threads = Thread.query().fetch()
for threadD in threads:
if new_drawing.key in threadD.drawings:
thread = threads[0]
new_edit = Edit.query().filter(
Edit.addition == new_drawing.key).fetch()[0]
else:
content_key = new_drawing.put()
thread.drawings.append(content_key)
thread_key = thread.put()
new_edit = Edit(user=teleUser.key,
thread=thread_key,
addition=content_key)
new_edit.put()
confirmation_newThread_template = the_jinja_env.get_template(
"confirmation-newthread.html")
self.response.write(
confirmation_newThread_template.render({
"user_info": user,
"thread": thread,
"new_edit": new_edit
}))
def setUp(self):
app = create_app(test_config)
with app.app_context():
db.drop_all()
db.create_all()
self.app = app.test_client()
self.app_context = app.app_context()
self.app_context.push()
guild = Guild('Flames of Exile')
db.session.add(guild)
db.session.commit()
foe_guild = db.session.query(Guild).filter_by(
name='Flames of Exile').first()
admin = User('DiscordBot', sha256_crypt.encrypt('admin'), foe_guild.id,
User.Role.ADMIN)
admin.discord_confirmed = True
db.session.add(admin)
db.session.commit()
campaign = Campaign('campaign_name',
'/mediafiles/campaigns/campaign.png', True)
db.session.add(campaign)
db.session.commit()
world = World('world_name',
'/mediafiles/campaigns/campaign_name/world.png', 1, 1, 1,
1)
db.session.add(world)
db.session.commit()
pin = Pin(1, 1, Pin.Symbol.ANIMAL, Pin.Resource.WOLF, 1, 1, '', 1, 1,
'notes', 1, 1)
db.session.add(pin)
db.session.commit()
edit = Edit("", 1, 1)
db.session.add(edit)
db.session.commit()
event = Event('event', 'game',
datetime.datetime.now().isoformat(), 'note')
db.session.add(event)
db.session.commit()
self.DEFAULT_GUILD = guild
self.DEFAULT_USER = admin
self.DEFAULT_CAMPAIGN = campaign
self.DEFAULT_WORLD = world
self.DEFAULT_PIN = pin
self.DEFAULT_TOKEN = f'Bearer {self.login("DiscordBot", "admin").get_json()["token"]}'
self.DEFAULT_EVENT = event
self.maxDiff = None
self.assertEqual(app.debug, False)
def process_edit(edit_dto, note, editor_id):
try:
if edit_dto.get('change', None):
note.note_text = edit_dto['change']
except:
return None
edit = Edit(editor_id=editor_id, note_id=note.id, edit_timestamp=datetime.today())
session.add(edit)
session.commit()
return note
def get(self):
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
teleUser = TeleUser.get_by_id(user.user_id())
if not teleUser:
teleUser = TeleUser.fromGSI(user=user)
teleUser.put()
thread_key = ndb.Key(Thread, int(self.request.get("key")))
user_bailOuts = [
bailOut_key.get() for bailOut_key in teleUser.bailOuts
]
bailed = False
for bailOut in user_bailOuts:
if thread_key == bailOut.thread:
bailed = True
break
if bailed:
self.redirect("/my-threads")
return
thread = thread_key.get()
edit_entity_list = Edit.query().filter(
Edit.thread == thread_key).fetch()
edit_entity_list.sort(key=lambda x: x.addition.get().date,
reverse=True)
lastEdit = edit_entity_list[0]
if lastEdit.user != teleUser.key:
if (lastEdit.addition.kind() == "Drawing"):
self.redirect("/edit-caption?key=%s" % thread_key.id())
else:
self.redirect("/edit-drawing?key=%s" % thread_key.id())
else:
edit_template = the_jinja_env.get_template("edit.html")
self.response.write(
edit_template.render({
"user_info":
user,
"thread":
thread,
"edit":
lastEdit,
"logout_url":
users.create_logout_url("/welcome"),
}))
def get(self):
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
thread_key = ndb.Key(Thread, int(self.request.get("key")))
thread = thread_key.get()
edit_entity_list = Edit.query().filter(
Edit.thread == thread_key).fetch()
edit_entity_list.sort(key=lambda x: x.addition.get().date,
reverse=True)
lastEdit = edit_entity_list[0]
last_drawing = lastEdit.addition.get()
edit_template = the_jinja_env.get_template("edit-caption.html")
self.response.write(
edit_template.render({
"user_info": user,
"thread": thread,
"last_edit": lastEdit,
"drawing": last_drawing
}))
def get(self):
request = self.request.get("request")
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
teleUser = TeleUser.get_by_id(user.user_id())
if not teleUser:
print "no teleUser"
teleUser = TeleUser.fromGSI(user=user)
teleUser.put()
print teleUser
thread_entity_list = Thread.query().fetch()
user_bailOuts = [
bailOut_key.get() for bailOut_key in teleUser.bailOuts
]
user_open_threads = []
for thread in thread_entity_list:
bailed = False
for bailOut in user_bailOuts:
if thread.key == bailOut.thread:
bailed = True
break
if not bailed:
user_open_threads.append(thread)
# print user_open_threads
edits_by_thread = {}
for thread in user_open_threads:
thread_key = thread.key
edit_entity_list = Edit.query().filter(
Edit.thread == thread_key).fetch()
if edit_entity_list:
edit_entity_list.sort(key=lambda x: x.addition.get().date)
for edit in edit_entity_list:
print edit.thread.id(), ":", edit.thread.get(
).thread_id, ":", edit.addition.kind()
edits_by_thread[str(thread_key.id())] = edit_entity_list
# for thread_id in edits_by_thread:
# print thread_id,":"
# for edit in edits_by_thread[thread_id]:
# print edit
# drawing_entity_list = Drawing.query().order(Drawing.date).fetch()
# # drawing_entity_list.sort(key=lambda x: x.date)
# caption_entity_list = Caption.query().order(Caption.date).fetch()
# # caption_entity_list.sort(key=lambda x: x.date)
home_template = the_jinja_env.get_template("home.html")
self.response.write(
home_template.render({
"request":
request,
"user_info":
teleUser,
"logout_url":
users.create_logout_url("/welcome"),
"threads":
user_open_threads,
"edits_by_thread":
edits_by_thread,
# "drawings":drawing_entity_list,
# "captions":caption_entity_list
}))
def get(self):
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
teleUser = TeleUser.get_by_id(user.user_id())
if not teleUser:
teleUser = TeleUser.fromGSI(user=user)
teleUser.put()
thread_entity_list = Thread.query().fetch()
user_bailOuts = [
bailOut_key.get() for bailOut_key in teleUser.bailOuts
]
bailed_threads = []
user_threads = []
edits_by_thread = {}
for thread in thread_entity_list:
thread_key = thread.key
edit_entity_list = Edit.query().filter(
Edit.thread == thread_key).fetch()
if edit_entity_list:
edit_entity_list.sort(key=lambda x: x.addition.get().date)
bailed = False
for bailOut in user_bailOuts:
if thread_key == bailOut.thread:
bailed = True
bailed_threads.append(thread)
last_edit_before_bail = bailOut.last_edit.get()
for i in range(len(edit_entity_list)):
if edit_entity_list[
i] == last_edit_before_bail:
edit_entity_list = edit_entity_list[0:i +
1]
break
edits_by_thread[str(
thread_key.id())] = edit_entity_list
break
if not bailed:
editedThread = False
for edit in edit_entity_list:
if edit.user == teleUser.key:
editedThread = True
break
if editedThread:
user_threads.append(thread)
edits_by_thread[str(
thread_key.id())] = edit_entity_list
# user_threads.sort(key=lambda x: x.key in teleUser.bailedThreads,reverse=True)
my_threads_template = the_jinja_env.get_template("my-threads.html")
self.response.write(
my_threads_template.render({
"user_info":
teleUser,
"logout_url":
users.create_logout_url("/welcome"),
"bailed_threads":
bailed_threads,
"user_threads":
user_threads,
"edits_by_thread":
edits_by_thread,
}))
def post(self):
user = users.get_current_user()
if not user:
self.redirect("/welcome")
else:
teleUser = TeleUser.get_by_id(user.user_id())
if not teleUser:
teleUser = TeleUser.fromGSI(user=user)
teleUser.put()
edit_type = self.request.get("request_type")
print self.request.get("thread_id")
thread_id = int(self.request.get("thread_id"))
thread_entity_list = Thread.query().filter(Thread.thread_id==thread_id).fetch()
if thread_entity_list:
thread = thread_entity_list[0]
else:
thread = Thread(thread_id=thread_id)
print thread
edit_entity_list = Edit.query().filter(Edit.thread==thread.key).fetch()
edit_entity_list.sort(key=lambda x: x.addition.get().date,reverse=True)
lastEdit = edit_entity_list[0]
if lastEdit.user == teleUser.key:
self.redirect("/edit?key="+str(thread.key.id()))
if edit_type=="caption":
if lastEdit.key.kind() == "Caption":
self.redirect("/home?request=failed")
return
caption = self.request.get("caption")
new_caption = Caption(content=caption)
content_key = new_caption.put()
thread.captions.append(content_key)
elif edit_type=="drawing":
if lastEdit.key.kind() == "Caption":
self.redirect("/home?request=failed")
return
drawingDataUrl = self.request.get("drawing")
img_data = drawingDataUrl.split('data:image/png;base64,')[1]
img = Image.open(BytesIO(base64.b64decode(img_data)))
output = StringIO()
img.save(output, format=img.format)
drawing = output.getvalue()
new_drawing = Drawing(content=drawing)
content_key = new_drawing.put()
thread.drawings.append(content_key)
else:
self.response.write("oof!")
return
thread_key = thread.put()
edit_entity_list = Edit.query().filter(Edit.thread==thread_key).fetch()
edit_entity_list.sort(key=lambda x: x.addition.get().date,reverse=True)
new_edit = Edit(user=teleUser.key,thread=thread_key,addition=content_key)
new_edit.put()
for edit in edit_entity_list:
print edit.thread.id(),":",edit.thread.get().thread_id,":",edit.addition.kind()
last_edit = edit_entity_list[0]
confirmation_template = the_jinja_env.get_template("confirmation.html")
self.response.write(confirmation_template.render({
"user_info":user,
"thread":thread,
"last_edit":last_edit,
"new_edit":new_edit
}))
from datetime import datetime
from models import Session, User, Tag, Note, ForeignEditor, Edit
session = Session()
user = User(user_name="Naruto",
password="******",
email="*****@*****.**")
user2 = User(user_name="Naruto2",
password="******",
email="*****@*****.**")
editor = User(user_name="Sakura",
password="******",
email="*****@*****.**")
tag = Tag(title="anime")
note = Note(note_text="I love anime", owner_id=1, tag_id=1)
edit = Edit(editor_id=2, note_id=1, edit_timestamp=datetime.today())
foreign_editor = ForeignEditor(editor_id=2, note_id=1)
session.add(user)
session.add(user2)
session.add(editor)
session.add(tag)
session.add(note)
session.add(edit)
session.add(foreign_editor)
session.commit()