def get(self, username):
events = []
old_events = []
user_to_view = None
user_is_me = False
#decode username from params
username = username.replace("%20", " ")
self.FirstInit()
logging.info("username: " + username)
user_to_view = models.get_user_by_username(username)
if user_to_view:
events = user_to_view.get_events(False)
user = models.get_current_user()
if user and user_to_view.user_id() == user.user_id():
user_is_me = True
old_events = user_to_view.get_events(
True
) # Security - don't let people see each other's histories
template_values = {
'user_to_view': user_to_view,
'events': events,
'old_events': old_events,
'user_is_me': user_is_me
}
self.AddUserInfo(template_values)
path = os.path.join(os.path.dirname(__file__), 'templates/user.htm')
self.response.out.write(template.render(path, template_values))
def add_category_handler(catalog_id):
"""Adds a category to a catalog
Parameters:
- catalog_id: integer id of catalog to which category belongs
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render add category form
return flask.render_template('addcategory.html',
user=user,
catalog=catalog_entity,
category=None)
elif flask.request.method == 'POST':
# Handle new category submission from form
new_category = models.Category(
name=flask.request.form.get('name'),
description=flask.request.form.get('description'),
catalog=catalog_entity.key)
new_category.put()
models.wait_for(new_category)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def post(self):
send_to_username = self.request.get('username')
target_user = models.get_user_by_username(send_to_username)
# how to send an email?
user = models.get_current_user()
if (user):
message = mail.EmailMessage(
sender=user.email,
subject="Message via WorkWithMe from " + user.username)
message.to = target_user.email #"Albert Johnson <*****@*****.**>"
message.body = self.request.get('message')
m = models.CMessage(parent=user,
user_to=target_user,
content=message.body)
m.put()
message.send()
logging.info("sender: " + message.sender)
logging.info("subject: " + message.subject)
logging.info("to: " + message.to)
logging.info("body: " + message.body)
self.response.out.write("OK")
else:
self.response.out.write("User Not Logged In")
def edit_item_handler(catalog_id, item_id):
"""Edits an item in a catalog
Parameters:
- catalog_id: integer id of catalog to which item belongs
- item_id: integer id of item to edit
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog_entity = models.Catalog.get_by_id(catalog_id)
item_id = int(item_id)
item_entity = models.get_item_by_id(catalog_id, item_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not (item_entity):
raise BadRequest('Could not find item with id %d!' % item_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render edit item form
categories = models.get_categories(catalog_id)
return flask.render_template('edititem.html',
user=user,
catalog=catalog_entity,
categories=categories,
category_id=item_entity.category.id(),
item=item_entity)
elif flask.request.method == 'POST':
# Handle item edit from form
picture_obj = flask.request.files.get('picture')
picture_url = uploadfile.save_file(picture_obj)
try:
price = float(flask.request.form.get('price'))
except:
price = 0.00
# Update entity
item_entity.name = flask.request.form.get('name')
item_entity.description = flask.request.form.get('description')
item_entity.price = price
item_entity.picture = picture_url
# Allow possibility of item without category
category_id = flask.request.form.get('category_id')
if category_id:
category_id = int(category_id)
category_entity = models.get_category_by_id(catalog_id, category_id)
if category_entity:
item_entity.category = category_entity.key
item_entity.put()
models.wait_for(item_entity)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def delete_category_handler(catalog_id, category_id):
"""Deletes a category in a catalog
Parameters:
- catalog_id: integer id of catalog to which category belongs
- category_id: integer id of category to delete
Returns:
- HTTP response redirecting to catalog page
"""
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
category_id = int(category_id)
category_entity = models.get_category_by_id(catalog_id, category_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not (category_entity):
raise BadRequest('Could not find category with id %d!' % category_id)
if not catalog_entity.user_can_edit(models.get_current_user()):
raise Unauthorized
models.delete_category(catalog_id, category_id)
models.wait_for(category_entity)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def add_catalog_handler():
"""Adds a catalog
Returns:
- HTTP response
"""
user = models.get_current_user()
if flask.request.method == 'GET':
# Render add catalog form
return flask.render_template('addcatalog.html',
user=user,
catalog=None)
elif flask.request.method == 'POST':
# Handle new catalog submission from form
try:
cover_picture_obj = flask.request.files.get('cover_picture')
cover_picture_url = uploadfile.save_file(cover_picture_obj)
new_catalog = models.Catalog(
name=flask.request.form.get('name'),
description=flask.request.form.get('description'),
cover_picture=cover_picture_url,
owner=user.key)
new_catalog.put()
models.wait_for(new_catalog)
return flask.redirect('/catalog/%d' % new_catalog.key.id())
except IOError:
return ('Failed to add new catalog', 401)
def render_admin_template(self, end_point, template_values): user = models.get_current_user(self) template_values['user'] = user if not user: template_values['title'] = "log in now please" render_response(self, render_template(self, "adminviews/notpermitted.html", template_values)) else: render_response(self, render_template(self, end_point, template_values))
def post(self):
n = self.request.get('who_name')
if len(n) == 0:
self.response.out.write('Please enter your name')
return
user = models.get_current_user()
event = models.Event(parent=user)
if user:
event.user = user
old_event = models.Event.all().ancestor(user).filter(
"when_end >=", datetime.now(tz)).get()
if old_event:
old_event.when_end = datetime.now(tz)
old_event.put()
logging.info("incoming date_start: " + self.request.get('when_start'))
date_start = fixDate(self.request.get('when_start'))
date_end = fixDate(self.request.get('when_end'))
if date_end < date_start:
date_end = date_end + timedelta(days=1)
event.who_name = self.request.get('who_name')
event.what = self.request.get('what')
event.when_start = date_start
event.when_end = date_end
event.skill = self.request.get('skill')
event.skill_neighbor = self.request.get('skill_neighbor')
lat = 0
lon = 0
if self.request.get('loc_geopt_lat') and self.request.get(
'loc_geopt_lng'):
lat = round(float(self.request.get('loc_geopt_lat')), 6)
lon = round(float(self.request.get('loc_geopt_lng')), 6)
event.lat = lat
event.lon = lon
place = models.get_place(lat, lon, self.request.get('where_name'))
event.place = place
event.place_name = self.request.get('where_name')
event.where_addr = self.request.get('where_addr')
event.where_detail = self.request.get('where_detail')
logging.info("Computing Geoboxes for the Event")
event.init_geoboxes()
logging.info("OK")
logging.info("Depositing Event into DB")
event.put()
logging.info("OK")
logging.info("Sending OK Response")
self.response.out.write('OK')
logging.info("OK")
def get(self):
self.FirstInit()
template_values = {}
lat = self.request.get('lat')
old_event = None
temp_place = None
user = models.get_current_user()
if user:
if not user.username:
self.redirect('/profile')
return
old_event = models.Event.all().filter(
"user ="******"-when_end").get()
if old_event == None:
old_event = models.Event()
temp_place = models.Place()
temp_place.put()
old_event.place = temp_place.key()
if len(lat) > 0:
old_event.place.place_name = self.request.get('name')
old_event.place.lat = float(lat)
old_event.place.lon = float(self.request.get('lon'))
old_event.lat = float(lat)
old_event.lon = float(self.request.get('lon'))
old_event.where_addr = self.request.get('addr')
if old_event.who_name == "None" or old_event.who_name == None:
old_event.who_name = ""
if old_event.what == "None" or old_event.what == None:
old_event.what = ""
if old_event.skill == "None" or old_event.skill == None:
old_event.skill = ""
if old_event.skill_neighbor == "None" or old_event.skill_neighbor == None:
old_event.skill_neighbor = ""
if old_event.where_detail == "None" or old_event.where_detail == None:
old_event.where_detail = ""
logging.info("----> %s " % old_event.what)
if old_event:
template_values.update({"old_event": old_event})
self.AddUserInfo(template_values)
path = os.path.join(os.path.dirname(__file__),
'templates/add_event2.htm')
self.response.out.write(template.render(path, template_values))
if temp_place:
temp_place.delete()
def logout_handler():
"""Logs a user out by clearing the session"""
user = models.get_current_user()
if not user:
logging.info('Already logged out!')
return flask.redirect(flask.url_for('main_page_handler'))
# Reset the user's session.
flask.session.clear()
flask.flash('Logged out!')
return flask.redirect(flask.url_for('main_page_handler'))
def get(self):
self.FirstInit()
template_values = {}
user = models.get_current_user()
if (user):
my_events = user.get_events(False)
template_values.update({"my_events": my_events})
self.AddUserInfo(template_values)
path = os.path.join(os.path.dirname(__file__), 'templates/browse2.htm')
self.response.out.write(template.render(path, template_values))
def post(self):
user = models.get_current_user()
un = self.request.get("username")
existing_user = models.get_user_by_username(un)
if existing_user and (existing_user.user_id() != user.user_id()):
self.response.out.write('A user with this username already exists')
return
user.username = un
user.put()
output = simplejson.dumps([user.username, "UpdateComplete"])
self.response.out.write(output)
def post(self, username, action):
if action == "closeout":
user = models.get_current_user()
target_user = models.get_user_by_username(username)
if user.user_id() != target_user.user_id():
self.response.out.write("You ain't got no right!")
return False
if user:
events = models.Event.all().ancestor(target_user).filter(
"when_end >=", datetime.now(tz)).fetch(50)
for event in events:
event.when_end = datetime.now(tz)
event.put()
self.redirect("/user/" + username)
def catalog_view_handler(catalog_id):
"""Renders a catalog page
Parameters:
- catalog_id: integer id of catalog to be rendered
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog = models.get_catalog_by_id(catalog_id)
if not catalog:
raise BadRequest('Could not find catalog with id %d!' % catalog_id)
categories = models.get_categories(catalog_id)
return flask.render_template('catalog.html',
user=user,
catalog=catalog,
categories=categories)
def delete_catalog_handler(catalog_id):
"""Deletes a catalog
Parameters:
- catalog_id: integer id of catalog to delete
Returns:
- HTTP response redirecting to index
"""
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
# Check parameteres
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d!' % catalog_id)
if not catalog_entity.user_can_edit(models.get_current_user()):
raise Unauthorized
models.delete_catalog(catalog_id)
return flask.redirect('/')
def get(self, username):
user_to_view = None
user_is_me = False
user_to_view = models.get_user_by_username(username)
if user_to_view:
events = user_to_view.get_events(False)
old_events = user_to_view.get_events(True)
user = models.get_current_user()
if user and user_to_view.user_id() == user.user_id():
user_is_me = True
template_values = {
'user_to_view': user_to_view,
'user_is_me': user_is_me
}
self.AddUserInfo(template_values)
path = os.path.join(os.path.dirname(__file__),
'templates/conversation.htm')
self.response.out.write(template.render(path, template_values))
def edit_catalog_handler(catalog_id):
"""Edits a catalog
Parameters:
- catalog_id: integer id of catalog to edit
Returns:
- HTTP response
"""
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
user = models.get_current_user()
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d!' % catalog_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render edit catalog form
return flask.render_template('editcatalog.html',
user=user,
catalog=catalog_entity)
elif flask.request.method == 'POST':
# Handle catalog edit from form
try:
cover_picture_obj = flask.request.files.get('cover_picture')
cover_picture_url = uploadfile.save_file(cover_picture_obj)
# TODO: delete old picture
catalog_entity.cover_picture = uploadfile.save_file(
cover_picture_url)
catalog_entity.name = flask.request.form.get('name')
catalog_entity.description = flask.request.form.get('description')
catalog_entity.put()
models.wait_for(catalog_entity)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
except IOError:
return ('Failed to edit catalog', 401)
def edit_category_handler(catalog_id, category_id):
"""Edits a category in a catalog
Parameters:
- catalog_id: integer id of catalog to which category belongs
- category_id: integer id of category to edit
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
category_id = int(category_id)
category_entity = models.get_category_by_id(catalog_id, category_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not (category_entity):
raise BadRequest('Could not find category with id %d!' % category_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render edit category form
return flask.render_template('editcategory.html',
user=user,
catalog=catalog_entity,
category=category_entity)
elif flask.request.method == 'POST':
# Handle category edit from form
category_entity.name = flask.request.form.get('name')
category_entity.description = flask.request.form.get('description')
category_entity.put()
models.wait_for(category_entity)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def AddUserInfo(self, template_vars):
user = models.get_current_user()
greeting = ""
if user:
user_str = ""
if user.username:
user_str = " " + user.username
if user.username == None:
user.username = ""
user.put()
greeting = "<li><a href='%s'> Log Out</a></li>" % (
users.create_logout_url(self.request.uri))
template_vars.update({"username": user.username, "user": user})
else:
#for name, uri in providers.items():
# greeting += ('[<a href="%s">%s</a>]' % (
# users.create_login_url(federated_identity=uri), name))
greeting = "<li><a href='%s'>Log In</a></li>" % users.create_login_url(
self.request.uri)
template_vars.update(
{"login_url": users.create_login_url(self.request.uri)})
template_vars.update({"greeting": greeting})
def delete_item_handler(catalog_id, item_id):
"""Deletes an item in a catalog
Parameters:
- catalog_id: integer id of catalog to which item belongs
- item_id: integer id of item to delete
Returns:
- HTTP response redirecting to catalog page
"""
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
item_id = int(item_id)
item_entity = models.get_item_by_id(catalog_id, item_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not (item_entity):
raise BadRequest('Could not find item with id %d!' % item_id)
if not catalog_entity.user_can_edit(models.get_current_user()):
raise Unauthorized
models.delete_item(catalog_id, item_id)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def main_page_handler():
"""Renders the main page, a list of the available catalogs"""
user = models.get_current_user()
catalogs = models.get_catalogs()
logging.info(user)
return flask.render_template('index.html', user=user, catalogs=catalogs)
def FirstInit(self):
user = models.get_current_user()
if user and user.username == None:
self.redirect("/profile")
def add_item_handler(catalog_id):
"""Adds an item to a catalog
Parameters:
- catalog_id: integer id of catalog to which item belongs
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render add item form
# Category_id may be passed in if adding item from category edit page
category_id = flask.request.args.get('category_id')
if category_id:
category_id = int(category_id)
categories = models.get_categories(catalog_id)
return flask.render_template('additem.html',
user=user,
catalog=catalog_entity,
category_id=category_id,
categories=categories,
item=None)
elif flask.request.method == 'POST':
# Handle new item submission from form
picture_obj = flask.request.files.get('picture')
picture_url = uploadfile.save_file(picture_obj)
try:
price = float(flask.request.form.get('price'))
except:
price = 0.00
new_item = models.Item(
name=flask.request.form.get('name'),
description=flask.request.form.get('description'),
price=price,
picture=picture_url,
owner=user.key,
catalog=catalog_entity.key)
# Allow possibility of putting items without category
category_id = flask.request.form.get('category_id')
if category_id:
category_id = int(category_id)
category_entity = models.get_category_by_id(catalog_id, category_id)
if category_entity:
new_item.category = category_entity.key
new_item.put()
models.wait_for(new_item)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())