def ExpandLinkedDict(aSourceDict):
aTarget = {}
aTarget["key"] = aSourceDict["key"]
llinkkeyid = aSourceDict["key"]
aLinksList.append(llinkkeyid)
llinkobj = None
if llinkkeyid:
llinkkey = Key(GDSDocument, llinkkeyid)
llinkobj = llinkkey.get()
if llinkobj:
# we have a linked object. Populate aTarget with values from the linked object.
llinkdict = llinkobj.to_dict()
# do transform if ther is one
ltransform = GDSDocument.GetbOTLTransform(lkey)
if ltransform:
llinkdict = bOTL.Transform(llinkdict, ltransform)
if "key" in llinkdict:
del llinkdict["key"]
aTarget.update(llinkdict)
else:
aTarget["link_missing"] = True
return aTarget
def decorated_view(*args, **kwargs):
if request.method=='POST':
code=request.form['code']
message=request.form['message']
url=request.form['url']
time=request.form['time']
# sign=request.form['sign']
else:
code=request.args['code']
message=request.args['message']
url=request.args['url']
time=request.args['time']
# sign=request.args['sign']
logging.info(url)
m = re.match(r'/(.*)/(.*)\.(.*)', url)
if m:
key=m.group(2)
v=memcache.get(key)
if v and v==url:
logging.info('bump')
else:
campaign=Key(urlsafe=m.group(1)).get()
qrcode=Key(urlsafe=key).get()
suffix=m.group(3)
qrcode.redirect=UPYUN_URL.format(UPYUN_BUCKET, m.group(1), m.group(2), suffix)
qrcode.target=TARGET_CDN
qrcode.put()
memcache.set(key, url)
kwargs['key']=key
return func(*args, **kwargs)
class ConferenceRoom:
def __init__(self, kwargs):
self.args = kwargs
# self.room = getModel('conferencerooms', kwargs)
Id = kwargs.get('id', None)
if (Id == None) or (len(Id.strip()) == 0):
self.room = conferencerooms()
else:
self.room = Key("conferencerooms", int(Id)).get()
def create(self):
room = self.args.get('room', None)
if (room != None) or (len(room.strip()) > 0):
self.room.room = room
self.room.put()
return {'id' : str(self.room.key.id())}
else:
return {'error' : 'room name cannot be null / empty'}
def list(self):
return self.room.query()
def update(self):
self.room.room = self.args.get('roomname', self.room.room)
self.room.put()
def delete(self):
self.room.key.delete()
def get_user(user_id):
user_key = Key(User, user_id)
user = user_key.get()
if not user:
return 'User not found!', 404
return jsonify(_to_dict(user))
def fetch_page(self):
key = Key(urlsafe=self.request.get('key'))
page = key.get()
fetch_feed(page)
fetch_threads(page)
page.last_fetched = datetime.now()
page.put()
def get(email):
"""
Obtiene la autorización pendiente correspondiente al buzón dado.
:param email: Usuario del buzón.
:return: La aurotización obtenido.
"""
entity = Key(PendingAuthorizationDao, str(email)).get()
return None if entity is None else entity.to_dict()
def _get_profile(self, params):
try:
profile_name = params.get("profile_name").lower()
if not profile_name:
raise ValueError()
key = Key(models.Profile, profile_name)
model = key.get()
if not model:
raise ValueError()
return model
except (KeyError, ValueError):
raise webapp2.abort(404, "Profile not found")
def get(self, test_key):
survey = Key(urlsafe=test_key).get()
self.response.out.write(json.dumps({'code': survey.key.urlsafe(),
'script': survey.script,
'text': yaml.safe_dump(survey.to_json(),
encoding='utf-8',
allow_unicode=True,
default_flow_style=False),
'resources': yaml.safe_dump(survey.resource,
encoding='utf-8',
allow_unicode=True, default_flow_style=False)
}))
def test_normalization_wit_kind(self):
class ModelMock(Model):
pass
key = Key(ModelMock, 1)
field = KeyField(ModelMock)
self.assertIsNone(field.normalize(None))
self.assertIsNone(field.normalize(''))
self.assertEqual(key, field.normalize(key))
self.assertEqual(key, field.normalize(key.urlsafe()))
self.assertEqual(key, field.normalize('1'))
self.assertRaises(Exception, field.normalize, 'abcd')
def test_validation_with_kind(self):
class ModelMock(Model):
pass
key = Key(ModelMock, 1)
field = KeyField(ModelMock)
self.assertIsNone(field.validate(None))
self.assertIsNone(field.validate(''))
self.assertIsNone(field.validate(key))
self.assertIsNone(field.validate(key.urlsafe()))
self.assertIsNone(field.validate('1'))
self.assertEqual('Invalid key', field.validate('abcd'))
def post(self):
"""
Find the best matching song id in response to POST requests containing
a file-like object with valid WAV encoding in the request body by
correlating hashes and relative offsets from the WAV data with
previously-computed hash records.
"""
request_file = self.request.body_file.file
rate, src_audio = wavfile.read(request_file)
votes = defaultdict(lambda: 0)
hashes = list(resound.hashes(src_audio, rate))
keys = [Key(Hashes, h_id) for h_id, _ in hashes]
futures = ndb.get_multi_async(keys)
for (h_id, offset), future in zip(hashes, futures):
entity = future.get_result() # wait for response from each key
if not entity:
continue
for song_id, abs_offset in entity.song_list:
delta = abs_offset - offset
votes[(song_id, delta)] += 1
# Find the best match
max_votes, best_id = 0, None
p_votes, prev = 0, None
s_votes, prev_2 = 0, None
for (song_id, _), vote_count in votes.iteritems():
if max_votes < vote_count:
max_votes, p_votes, s_votes = vote_count, max_votes, p_votes
best_id, prev, prev_2 = song_id, best_id, prev
elif p_votes < vote_count:
p_votes, s_votes = vote_count, p_votes
prev, prev_2 = song_id, prev
elif s_votes < vote_count:
s_votes = vote_count
prev_2 = song_id
msg = "Best ids:\n1. {} - {}\n2. {} - {}\n3. {} - {}"
logging.debug(msg.format(best_id, max_votes,
prev, p_votes,
prev_2, s_votes))
if max_votes > MIN_MATCH_THRESHOLD:
key = Key(Songs, best_id)
song = key.get()
self.response.write(json.dumps({'artist': song.artist,
'title': song.title,
'year': song.year}))
def post(self, category_key):
form = self.get_form(category_key)
if form.validate_on_submit():
for changed in set(form.activities.default).symmetric_difference(set(form.activities.data)):
activity = Key(urlsafe=changed).get()
if changed in form.activities.data:
activity.tracked = True
else:
activity.tracked = False
activity.put()
flash('Update successful', category='success')
return redirect(api.url_for(Activities, category_key=category_key))
flash('Update not successful', category='warning')
return self.response('track/track_activity.html', form, category_key)
def delete(self, trailId):
try:
trail = Key("Trail", long(trailId)).get()
if(trail is not None):
trail.delete()
self.response.clear()
self.response.set_status(200)
else:
self.error(404)
except:
logging.exception("An exception occurred when removing the trail")
self.error(500)
def post(self):
user = self.validate_user()
if user is not None:
self.redirect('/')
return
form = RegisterForm(self.request.params)
# validate form
if not form.validate():
self.r(form)
return
# validate csrf
if not self.validate_csrf(form.csrf_token.data):
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash('Please submit the form again'))
return
# check for an existing account
# using the lowercase username as a key
# to ensure users are unique
username = form.username.data
username = re.sub(r'[\!\@\#\$\%\^\&\*\-_=\+\?<>,\.\"\':;\{\}\[\]|\\~\/`]', '', username)
try:
user = Key("User", lower(username)).get()
except:
user = None
if user is not None:
self.r(form, flashes=flash('That username is taken'))
return
# create the user
try:
user = User(
username=username,
password=pw.gen_hash(form.password.data),
)
user.key = Key("User", lower(user.username))
user.put()
# create a hash with our secret so we know the cookie is legit later
self.generate_sig(user.username)
self.redirect('/?welcome=%s' % user.username)
return
except: # guess something happened eh?
self.r(form, flashes=flash())
return
def __init__(self, currentUser, Id = None):
self.currentUser = currentUser
if (Id == None) or (len(Id.strip()) == 0):
self.identity = identities()
else:
self.identity = Key('identities',int(Id)).get()
self.history = identityHistory()
def addposproduct():
form = request.json
if request.method == "POST":
try:
pos = PosProduct(price=form["price"],
scan_id=form.get("scan_id", ""),
keycode=form.get("keycode", ""))
if 'product' in form:
prd = Key("Product",
form['product'],
parent=TypeGroup.product_ancestor()).get()
if prd is None:
raise BadValueError("Product does not exist.")
pos.product = prd.key
pos.name = prd.contenttype
elif 'name' in form:
if len(form['name']) < 1:
raise BadValueError("Name too short!")
pos.name = form['name']
else:
raise BadValueError("Need to specify either product or name!")
pos.put()
except (BadValueError, KeyError) as e:
return jsonify({"messages": [e.message]}, 400)
return jsonify(pos)
return render_template(
'tantalus_posproduct.html',
products=Product.query(Product.hidden == False).order(
Product.contenttype).fetch())
def _objectToGDSDocument(aSource, aBaseGDSDocument = None):
retval = None
if IsDict(aSource):
if aBaseGDSDocument:
retval = aBaseGDSDocument
else:
retval = GDSDocument()
for lkey, lvalue in aSource.iteritems():
if lkey == "key":
retval.key = Key(GDSDocument, lvalue)
else:
lchildBaseDocument = None
if aBaseGDSDocument and IsDict(aBaseGDSDocument) and lkey in aBaseGDSDocument:
lchildBaseDocument = aBaseGDSDocument[lkey]
lconvertedValue = _objectToGDSDocument(lvalue, lchildBaseDocument)
retval.populate(**{lkey: lconvertedValue})
elif IsList(aSource):
if IsListOfSimpleValues(aSource):
retval = aSource
else:
retval = GDSJson(json = aSource)
else:
lneedTextBlob = isinstance(aSource, (str, unicode)) and sys.getsizeof(aSource) >= 500
if lneedTextBlob:
retval = GDSTextBlobWrapper(text = aSource)
else:
retval = aSource
return retval
def update_user(user_id):
user_key = Key(User, user_id)
user = user_key.get()
lat = random.random() * 180 - 90
lng = random.random() * 360 - 180
if not user.location:
user.location = Location()
user.location.lat = lat
user.location.lng = lng
user.put()
return jsonify(_to_dict(user))
def ConstructFromDict(cls, aDict, aReplace=True):
aDenormalizedDict = UpdateDenormalizedObjectLinking(aDict)
if aReplace:
retval = DictToGDSDocument(aDenormalizedDict)
else:
lgdsDocument = None
if aDict and IsDict(aDict) and "key" in aDict:
lkeyid = aDict["key"]
lkey = Key(GDSDocument, lkeyid)
lgdsDocument = lkey.get()
retval = DictToGDSDocument(aDenormalizedDict, lgdsDocument)
return retval
def post(self, username):
fields = self.get_params_dict((
'real_name',
'email',
'short_about',
'dob',
'tools',
'password',
'password_confirm',
'notify_on_msg'
))
iclasses = self.request.get_all('classes_inprog')
cclasses = self.request.get_all('classes_completed')
fields['iclasses'] = iclasses
fields['cclasses'] = cclasses
fields['username'] = username
user = Key(User, username).get()
errors = self.clean_user_data(user, **fields)
context = {
'errors': errors,
'user': user
}
if not errors:
user.update(**fields)
self.redirect('/{}'.format(username))
else:
if user.dob:
dob = user.dob.strftime('%m/%d/%Y')
else:
dob = None
all, ic, cc = self.organize_courses_for(user)
context['courses_all'] = Course.courses_to_dict()
context['courses_completed'] = cc
context['courses_incomplete'] = ic
context['dob'] = dob
context['username'] = username
context['gravatar'] = user.avatar_url
context['friends'] = []
context['friend_btn'] = False
context['errors'] = errors
self.render('profile/edit.html'.format(username), context)
def post(self):
response = self.request.get('response')
question = Key(urlsafe = self.session.get('question_key')).get()
accountname = self.session.get('account')
accounttype = self.session.get('accounttype')
classname = self.session.get('class')
categoryname = self.request.get('cname')
new_cname = self.request.get('new_cname')
if self.validate_user(accountname, accounttype = ADMIN):
#user is logged in as accountname qand accounttype is ADMIN
user = User.query(User.username == accountname).fetch()[0]
classes = Class.query(Class.classname == classname).fetch()
if len(classes) == 1:
classy = classes[0]
if self.request.get('add_to_category') == '1' and categoryname != '':
if categoryname == 'Default' and new_cname != '':
categoryname = new_cname
category = Category.query(Category.name == categoryname, ancestor=classy.key).fetch()
if len(category) == 1:
category = category[0]
elif len(category) == 0:
category = Category(name=categoryname, parent=classy.key)
category.put()
time.sleep(2)
else:
category = None
if category != None:
question.category = category.key
if question.respond_question(user.key, response)==1:
self.session.pop('class')
self.session.pop('question_key')
super(ResponseHandler, self).success_redirect('RSUBMIT_SUCCESS', '/instructorhomepage')
else:
super(ResponseHandler, self).error_redirect('RSUBMIT_FAIL', '/instructorhomepage')
else:
super(ResponseHandler, self).error_redirect('CLASS_NOT_FOUND', '/instructorhomepage')
else:
super(ResponseHandler, self).error_redirect('INVALID_LOGIN_STATE', '/')
# def respond_question_wrapper(self, response, question, accountname, accounttype, classname, categoryname, new_cname):
# return 0
def __init__(self, kwargs):
self.args = kwargs
# self.skejule = getModel('schedule', kwargs)
Id = kwargs.get('id', None)
if (Id == None) or (len(Id.strip()) == 0):
self.skejule = schedule()
else:
self.skejule = Key("schedule" ,int(Id)).get()
def __init__(self, kwargs):
self.args = kwargs
# self.room = getModel('conferencerooms', kwargs)
Id = kwargs.get('id', None)
if (Id == None) or (len(Id.strip()) == 0):
self.room = conferencerooms()
else:
self.room = Key("conferencerooms", int(Id)).get()
def get(self, request, key):
text = Key(urlsafe=key).get()
if not text:
return HttpResponseNotFound()
if not text.password and self._has_read_permission(text):
return self._render_image(text)
return HttpResponseForbidden()
def post(self):
user_key = Key('User', self.session.get('user_key_id'))
user_obj = user_key.get()
self.session['dp_url'] = self.request.get('dp_url')
self.session['email'] = self.request.get('email')
self.session['f_name'] = self.request.get('first_name')
self.session['l_name'] = self.request.get('last_name')
user_obj.dp_url = self.request.get('dp_url')
user_obj.email = self.request.get('email')
user_obj.first_name = self.request.get('first_name')
user_obj.last_name = self.request.get('last_name')
user_obj.put()
time.sleep(0.1)
self.redirect('/profile')
def addActivity(self, request):
#todo refactor , try optimize
if (request.id):
activityKey = Key(urlsafe=request.id)
activity = activityKey.get()
oldActivityCode = activity.code
activity.code = request.code
activity.name = request.name
activity.tags = request.tags
activity.defaultEventValue = request.defaultEventValue
activity.thumbUrl = request.thumbUrl
activity.put()
#update existed items
if (oldActivityCode != request.code):
deferred.defer(update_events.UpdateEventActivityName,
users.get_current_user(), oldActivityCode,
request.code)
return activityToMessage(activity)
else:
activityIter = Activity.query(
ndb.AND(Activity.actor == users.get_current_user(),
Activity.code == request.code), ).iter(keys_only=True)
if (activityIter.has_next()):
activity = activityIter.next()
activity.code = request.code
activity.name = request.name
activity.tags = request.tags
activity.defaultEventValue = request.defaultEventValue
activity.thumbUrl = request.thumbUrl
activity.put()
return activityToMessage(activity)
else:
activity = Activity(
actor=users.get_current_user(),
defaultEventValue=request.defaultEventValue,
name=request.name,
code=request.code,
tags=request.tags,
thumbUrl=request.thumbUrl)
activity.put()
return activityToMessage(activity)
def update(self, request):
startedEvent = Key(urlsafe=request.id).get()
startedEvent.startTime = parseMsgTime(request.startTime)
startedEvent.eventValue = request.eventValue
startedEvent.activityCode = request.activityCode
startedEvent.put()
return (request)
def tween(request):
branch = None
m = match("/sede/([a-z]+)/.*", request.path)
if m:
branch = Key("Branch", m.group(1)).get()
if not branch:
return HTTPNotFound()
request.branch = _session.branch = branch
return handler(request)
def addproduct():
form = request.json
if request.method == "POST":
group = Group.query(Group.name == form['group']).fetch(1)
if len(group) == 0:
if form.get('group', '') != '':
group = Group(name=form['group'])
group.put()
else:
return abort(403)
else:
group = group[0]
try:
name = form.get('name') or form.get('contenttype')
if len(Product.query(Product.contenttype == name).fetch()):
raise BadValueError("A product with this name already exists.")
losemods = [Key("Mod", id, parent=TypeGroup.product_ancestor()) for id in (form.get('losemods') or [])]
for mod in losemods:
if mod.get() is None:
raise BadValueError("Mod {} does not exists.".format(mod))
gainmods = [Key("Mod", id, parent=TypeGroup.product_ancestor()) for id in (form.get('gainmods') or [])]
for mod in gainmods:
if mod.get() is None:
raise BadValueError("Mod {} does not exists.".format(mod))
product = Product(
contenttype=name,
tag=form.get('tag', ''),
group=group.key,
amount=form.get('amount', 0),
value=form.get('value', 0),
hidden=False,
losemods=losemods,
gainmods=gainmods
).put()
except (BadValueError, KeyError) as e:
return jsonify({"messages": [e.message]}, 400)
return jsonify(product)
return render_template('tantalus_product.html', mods=Mod.query().fetch())
def roll_history(self, request):
"""
JWT required. Retrieves user's roll history for the provided game
"""
game_key = request.game_key
payload = token.decode_jwt(request.jwt_token)
try:
game = Key(urlsafe=game_key)
user = Key(urlsafe=payload.get('user_key'))
except TypeError:
raise endpoints.BadRequestException(
'key was unable to be retrieved')
except ProtocolBufferDecodeError:
raise endpoints.BadRequestException(
'key was unable to be retrieved')
except Exception as e:
raise endpoints.InternalServerErrorException(
'An error occurred when retrieving roll history')
turncard = TurnCard.query(TurnCard.owner == user,
TurnCard.game == game).get()
if turncard is None:
raise endpoints.BadRequestException(
'There are no turns associated with that turncard')
turns = []
for turn in turncard.turns:
turn = turn.get()
turns.append({
"roll_one": turn.roll_one,
"roll_two": turn.roll_two,
"roll_three": turn.roll_three,
"allocated_to": turn.allocated_to,
"date_completed": turn.date_completed.isoformat()
})
return UserRollHistoryResponseForm(rolls=[
UserRollHistory(roll_one=turn['roll_one'],
roll_two=turn['roll_two'],
roll_three=turn['roll_three'],
allocated_to=turn['allocated_to'],
date_completed=turn['date_completed'])
for turn in turns
])
def get_person_info(self):
try:
key = Key(urlsafe=self.request.get("key"))
person = key.get()
# get total spend
months = list(Month.query().filter(Month.people == key).fetch())
total_spend = sum(month.average for month in months) * 1000
# get payments made for every one
money_usages = list(
MoneyUsage.query().filter(MoneyUsage.person == key).fetch())
payment = sum(money_usage.money_spend
for money_usage in money_usages) * 1000
# last month
if person.last_money_usage:
last_money_usage = person.last_money_usage.get()
last_month = last_money_usage.month.get()
last_month_str = last_month.to_string_long()
next_month_left = last_money_usage.next_month_left * 1000
in_current_month = last_month.key == Month.get_current_month_key(
)
else:
last_month_str = next_month_left = in_current_month = "N/A"
# write
s = ";".join(
map(unicode, [
person.name,
key.id(), total_spend,
len(months), payment, last_month_str, next_month_left,
in_current_month
]))
self.write(s)
except Exception as e:
print(e)
self.response.status = 409
self.write(
"Can not resolve this buyer's key. Please reload this page or try again later"
)
def read(self, request):
if (request.id):
return activityToMessage(Key(urlsafe=request.id).get())
else:
if (request.code):
activity = Activity.query(
Activity.code == request.code,
Activity.actor == users.get_current_user()).fetch(1)[0]
return activityToMessage(activity)
return None #todo throw error
def sell():
sale = request.json
if not sale:
return jsonify({"messages": ["No JSON supplied."]}, 400)
try:
prd = Key("PosProduct",
sale["product"],
parent=TypeGroup.product_ancestor())
if prd.get() is None:
raise BadValueError("Product does not exist")
possale = PosSale(user=current_user.key,
product=prd,
amount=sale.get('amount', 1))
possale.put()
except (BadValueError, KeyError) as e:
return jsonify({"messages": [e.message]}, 400)
return jsonify(possale)
def resend(transaction_id):
transaction = Key("Transaction", transaction_id, parent=TypeGroup.transaction_ancestor()).get()
if transaction is None:
return abort(404)
taskqueue.add(url='/invoice',
target='worker',
params={'transaction': transaction.key.id()})
return redirect(url_for(".showtransaction", transaction_id=transaction_id))
def get(self, month_key):
"""Get month info and render html"""
try:
month = Key(urlsafe=month_key).get()
if month is None:
raise ValueError
except:
self.error(404)
else:
self.render_month(month)
def get(self, request, key):
text = Key(urlsafe=key).get()
if not text:
return HttpResponseNotFound()
if not text.password and self._has_read_permission(text):
return self._render_to_plane_text_response(text.text)
elif not self._is_public(text):
return self._to_login(urllib.quote_plus('plaintext/' + key))
return HttpResponseForbidden()
def post(self, user):
# grab the form
form = PostDeleteForm(self.request.params)
# validate csrf
if not self.validate_csrf(form.csrf_token.data):
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash('Please submit the form again.'))
return
# get the post please
try:
post = Key(urlsafe=form.key.data).get()
except:
post = None
# as usual, this really shouldn't
# be None unless unnatural navigation
if post is None:
self.redirect('/')
return
# the post exists, is it owned by the user?
if post.author != user:
self.redirect('/')
return
# check if the user is the owner or not
if post.author != user:
self.redirect('/')
return
# everything checks out so let's remove the post
# first though, we need to remove the comments
# assoc with the post and the likes
# TODO query these entities to make sure they are removed
comments = Comment.query(ancestor=post.key).fetch()
ks = put_multi(comments)
delete_multi(ks)
likes = Like.query(Like.post == post.key).fetch()
ks = put_multi(likes)
delete_multi(ks)
# got everything else removed, let's
# remove the post
try:
post.key.delete()
self.redirect('/')
return
except Exception as e:
# let them try again
form.csrf_token.data = self.generate_csrf()
self.r(form, post, flashes=flash())
return
def recreate_api_user(self, api_user):
auth.ensure_recognized_user(require_admin=True)
if not api_user.email:
raise Error("recreate_api_user: E-mail cannot be blank")
db_key = Key(models.ApiUserModel, api_user.email)
api_user_model = db_key.get()
if api_user_model:
if (api_user.secret and
api_user_model.msg.secret != api_user.secret):
raise Error("Can't set a custom secret. If you want a new one, just clear it and the server will generate a new one for you.")
else:
api_user_model = models.ApiUserModel(msg=api_user)
api_user_model.key = db_key
secret = api_user.secret
if not api_user.secret:
print("ckck: temp new token=" + auth.create_secret_token())
api_user_model.msg.secret = auth.create_secret_token()
print("ckck: new secret = " + api_user_model.msg.secret)
api_user_model.put()
return api_user_model.msg
def post(self, user):
# grab the form
form = CommentForm(self.request.params)
if not form.validate():
form.csrf_token.data = self.generate_csrf()
self.r(form)
return
# get the comment
try:
comment = Key(urlsafe=form.key.data).get()
except:
# invalid key
comment = None
if comment is None:
self.redirect('/')
return
if comment.author != user:
self.redirect('/')
return
# better be a post here or else!
post = comment.key.parent().get()
if post is None:
self.redirect('/')
return
# update the comment
try:
comment.content = form.comment.data
comment.put()
self.redirect('/post/view?key=%s' % post.key.urlsafe())
return
except:
# let's give them another chance
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash())
return
def editrelation(relation_id):
form = request.json or request.form
relation = Key("Relation",
relation_id,
parent=TypeGroup.relation_ancestor()).get()
if request.method == "POST":
relation.name = form.get('name', relation.name)
relation.email = form.get('email', relation.email)
relation.budget = form.get('budget', relation.budget)
relation.has_budget = form.get('has_budget', relation.has_budget)
relation.send_mail = form.get('send_mail', relation.send_mail)
relation.put()
return jsonify(relation)
return render_template('tantalus_relation.html', relation=relation)
def post(self, user):
# grab the form
form = CommentForm(self.request.params)
if not form.validate():
form.csrf_token.data = self.generate_csrf()
self.r(form)
return
# get the comment
try:
comment = Key(urlsafe=form.key.data).get()
except:
# invalid key
comment = None
if comment is None:
self.redirect('/')
return
if comment.author != user:
self.redirect('/')
return
# better be a post here or else!
post = comment.key.parent().get()
if post is None:
self.redirect('/')
return
# update the comment
try:
comment.content = form.comment.data
comment.put()
self.redirect('/post/view?key=%s' % post.key.urlsafe())
return
except:
# let's give them another chance
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash())
return
def get(self, song_id=None):
"""
Render the song lookup response page based on the urlsafe id parameter
"""
template = JINJA_ENV.get_template('song.html')
params = {}
logging.info("Get song: {}".format(song_id))
if not song_id:
logging.debug("Blank id parameter.")
params = {"msg": "Sorry! No match found."}
else:
song_key = Key(urlsafe=song_id)
if song_key.id():
params = {"song": song_key.get()}
logging.debug("song key: {}\nsong: {}".format(
str(song_key), params["song"]))
else:
params = {"msg": "Invalid song ID."}
self.response.write(template.render(**params))
def get(self, trailId):
trail = Key("Trail", long(trailId)).get()
if(trail is not None):
if(self.request.get("remote") and self.request.get("callback")):
#If the client provides a "callback" argument, then we assume we have a JSONP call.
jsonpContent = self.request.get("callback") + "(" + trail.toJson() + ")"
self.response.headers["Content-Type"] = "text/javascript"
self.response.out.write(jsonpContent)
elif(self.request.headers['accept'] in ["application/json", "text/json"]):
#If the client requests json them encode the trail as JSON and send it over the wire
self.response.headers["Content-Type"] = "application/json"
self.response.out.write(trail.toJson())
else:
#otherwise, render the default view
path = os.path.join('default/', 'trail.html')
uploadUrlStr = '/trail/' + str(trail.key.id)
uploadUrl = blobstore.create_upload_url(uploadUrlStr)
context = {'trail': trail, 'jsonTrail': trail.toJson(), 'logoutUrl': users.create_logout_url("/"), 'uploadUrl': uploadUrl}
self.render_template(path, **context)
else:
self.error(404)
def add_course(self, **kwargs):
source = kwargs['source']
parent = Key(Source, source)
kwargs['source'] = parent
kn = self.centid(source, kwargs['dept'], kwargs['number'])
kwargs['number'] = int(kwargs['number'])
# remove if a new course added
memcache.delete('courses_by_level_cid', namespace='udacityplus')
return Course.get_or_insert(kn, **kwargs)
def get(self, song_id=None):
"""
Render the song lookup response page based on the urlsafe id parameter
"""
template = JINJA_ENV.get_template('song.html')
params = {}
logging.info("Get song: {}".format(song_id))
if not song_id:
logging.debug("Blank id parameter.")
params = {"msg": "Sorry! No match found."}
else:
song_key = Key(urlsafe=song_id)
if song_key.id():
params = {"song": song_key.get()}
logging.debug("song key: {}\nsong: {}".format(str(song_key),
params["song"]))
else:
params = {"msg": "Invalid song ID."}
self.response.write(template.render(**params))
def post(self, user):
# grab the form
form = LikeForm(self.request.params)
username = user
# grab the user (for their key)
user = User.query(User.username == username).get()
if user is None:
self.redirect('/user/login')
return
# grab the post via what should be it's key
try:
post = Key(urlsafe=form.key.data).get()
except Exception as e:
post = None
if post is None:
self.redirect('/')
return
if user.username == post.author:
error = 'you can\'t like or unlike you own post'
self.render("index.html", error=error)
return
# is the post liked by this user already?
try:
liked = Like.query(Like.owner == user.key,
Like.post == Key(urlsafe=form.key.data)).get()
except Exception as e:
print e.message
liked = None
# let's set the Like entity up and like the post
try:
if liked is None: # hasn't been liked yet
liked = Like(owner=user.key,
post=Key(urlsafe=form.key.data),
liked=True)
liked.put()
else:
liked.liked = True if liked.liked is False else False
liked.put()
# inc/dec the post likes
if liked.liked is True:
post.likes += 1
else:
post.likes -= 1
post.put()
# go back to the post!
self.redirect('/post/view?key=%s' % post.key.urlsafe())
return
except Exception as e:
# go back to the post even if we fail to like it
self.redirect('/post/view?key=%s' % post.key.urlsafe())
return
def update(self, request):
startedEvent = Key(urlsafe = request.id).get()
startedEvent.startTime = parseMsgTime(request.startTime)
startedEvent.eventValue = request.eventValue
startedEvent.activityCode = request.activityCode
startedEvent.put()
return (request)
def delete_items(self):
try:
month = Key(urlsafe=self.request.get("key")).get()
items_to_del = set(map(int, self.request.get("items").split(",")))
items = [
month.items[i]
for i in set(range(len(month.items))) - items_to_del
]
month.items = items
month.update()
# write
self.write(month.key.urlsafe())
except Exception as e:
print(e)
self.response.status = 409
self.write(
"Can not delete item(s) in this month. Please reload this page or try again later"
)
def parse_model_path(path):
""" Parses different values of path into a list of tuples """
if isinstance(path, ndbkey):
rule = path.pairs()
elif isinstance(path, dbkey):
rule = ndbkey.from_old_key(path).pairs()
elif all(isinstance(p, (tuple, list)) for p in path):
rule = tuple(path)
else:
raise ValueError("Path should be a list of tuples (Model, id/name): {}".format(path))
return rule
def add(self, request):
if (request.id):
eventKey = Key(urlsafe=request.id)
event = eventKey.get()
event.actor = users.get_current_user()
event.activityCode = (request.activity)
event.comment = (request.comment)
event.startTime = parseMsgTime(request.startTime)
event.endTime = parseMsgTime(request.endTime)
event.value = request.value
event.put()
else:
event = Event(actor=users.get_current_user(),
activityCode=(request.activity),
comment=(request.comment),
startTime=parseMsgTime(request.startTime),
endTime=parseMsgTime(request.endTime),
value=request.value)
event.put()
return eventToMessage(event)
def add(self, request):
if (request.id):
eventKey = Key(urlsafe = request.id)
event = eventKey.get()
event.actor = users.get_current_user()
event.activityCode = (request.activity)
event.comment = (request.comment)
event.startTime = parseMsgTime(request.startTime)
event.endTime = parseMsgTime(request.endTime)
event.value = request.value
event.put()
else:
event = Event(
actor = users.get_current_user(),
activityCode = (request.activity),
comment = (request.comment),
startTime = parseMsgTime(request.startTime), endTime = parseMsgTime(request.endTime),
value = request.value)
event.put()
return eventToMessage(event)
def recreate_api_user(self, api_user):
auth.ensure_recognized_user(require_admin=True)
if not api_user.email:
raise Error("recreate_api_user: E-mail cannot be blank")
db_key = Key(models.ApiUserModel, api_user.email)
api_user_model = db_key.get()
if api_user_model:
if (api_user.secret
and api_user_model.msg.secret != api_user.secret):
raise Error(
"Can't set a custom secret. If you want a new one, just clear it and the server will generate a new one for you."
)
else:
api_user_model = models.ApiUserModel(msg=api_user)
api_user_model.key = db_key
secret = api_user.secret
if not api_user.secret:
print("ckck: temp new token=" + auth.create_secret_token())
api_user_model.msg.secret = auth.create_secret_token()
print("ckck: new secret = " + api_user_model.msg.secret)
api_user_model.put()
return api_user_model.msg
def initialize(request):
key = Key(Branch, "caba")
if not key.get():
Branch(key=key, name=u"Capital").put()
u_roles = [roles.SECRETARY, roles.ADVISOR]
User(parent=key,
name=u"Juan Prueba",
email="*****@*****.**",
roles=u_roles).put()
User(parent=key,
name=u"Augusto D'Amario",
email="*****@*****.**",
roles=u_roles).put()
User(parent=key,
name=u"Julio Veronelli",
email="*****@*****.**",
roles=u_roles).put()
User(parent=key,
name=u"Hernán Acosta",
email="*****@*****.**",
roles=u_roles).put()
return "OK"
def addActivity(self, request):
#todo refactor , try optimize
if (request.id):
activityKey = Key(urlsafe = request.id)
activity = activityKey.get()
oldActivityCode = activity.code
activity.code = request.code
activity.name = request.name
activity.tags = request.tags
activity.defaultEventValue = request.defaultEventValue
activity.thumbUrl = request.thumbUrl
activity.put()
#update existed items
if (oldActivityCode != request.code):
deferred.defer(update_events.UpdateEventActivityName, users.get_current_user(), oldActivityCode, request.code)
return activityToMessage(activity)
else:
activityIter = Activity.query(ndb.AND(
Activity.actor == users.get_current_user(),
Activity.code == request.code),
).iter(keys_only=True)
if (activityIter.has_next()):
activity = activityIter.next()
activity.code = request.code
activity.name = request.name
activity.tags = request.tags
activity.defaultEventValue = request.defaultEventValue
activity.thumbUrl = request.thumbUrl
activity.put()
return activityToMessage(activity)
else:
activity = Activity(actor = users.get_current_user(), defaultEventValue = request.defaultEventValue, name = request.name, code = request.code, tags = request.tags, thumbUrl = request.thumbUrl)
activity.put()
return activityToMessage(activity)
def post(self, username):
fields = self.get_params_dict(
('real_name', 'email', 'short_about', 'dob', 'tools', 'password',
'password_confirm', 'notify_on_msg'))
iclasses = self.request.get_all('classes_inprog')
cclasses = self.request.get_all('classes_completed')
fields['iclasses'] = iclasses
fields['cclasses'] = cclasses
fields['username'] = username
user = Key(User, username).get()
errors = self.clean_user_data(user, **fields)
context = {'errors': errors, 'user': user}
if not errors:
user.update(**fields)
self.redirect('/{}'.format(username))
else:
if user.dob:
dob = user.dob.strftime('%m/%d/%Y')
else:
dob = None
all, ic, cc = self.organize_courses_for(user)
context['courses_all'] = Course.courses_to_dict()
context['courses_completed'] = cc
context['courses_incomplete'] = ic
context['dob'] = dob
context['username'] = username
context['gravatar'] = user.avatar_url
context['friends'] = []
context['friend_btn'] = False
context['errors'] = errors
self.render('profile/edit.html'.format(username), context)
def post(self, params):
try:
model = self._get_model(params)
except Exception:
pass
else:
if model:
raise webapp2.abort(400, "Profile already exists")
profile_name = params.get("profile_name").lower()
email = params.get("email").lower()
if not profile_name or not email:
raise ValueError("Please specify 'profile_name' and 'email'.")
key = Key(models.Profile, profile_name)
if key.get() is not None:
raise ValueError("Profile already exists.")
profile = models.Profile(key=key, owner_email=email, edit_key=uuid4().hex)
mail.send_mail(sender="Benjamin Kampmann <*****@*****.**>",
to=email,
subject="Your miHats Admin Link",
body="""
Hi there,
thanks for signing up for the miHats Hat-Sharing Webservice.
You can administer it at:
http://amasoeany.appspot.com/#/{0}/{1}
DON'T share this link!
Best
Ben
""".format(profile_name, profile.edit_key))
profile.put()
return {"profile_name": profile_name, "key": profile.edit_key}
def post(self, user):
# grab the form
form = PostForm(self.request.params)
# check if the person exists in the db or not
try:
user = Key("User", lower(user)).get()
except:
user = None
# shouldn't be None if we got this far
# but check anyway
if user is None:
self.invalidate_sig()
self.redirect('/user/login')
return
# validate form
if not form.validate():
self.r(form)
return
# validate csrf
if not self.validate_csrf(form.csrf_token.data):
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash('Please submit the form again.'))
return
t = form.title.data
try:
# let's create the post
post = Post(
title=t,
author=user.username,
author_lower=lower(user.username),
subject=form.subject.data,
content=form.content.data
)
post.put()
# maybe they want to create another post?
self.r(PostForm(data={'csrf_token': self.generate_csrf()}),
flashes=flash('Your new post can be viewed <a href="/post/view?key=%s">here</a>.' % post.key.urlsafe(), 'success'))
return
except Exception as e:
# give them another chance
form.csrf_token.data = self.generate_csrf()
self.r(form)
return
def get(self, request, key):
if key:
try:
text = Key(urlsafe=key).get()
if not text.password and self._has_read_permission(text):
return self._render_to_json_response(self._text2dict(text))
elif not self._is_public(text):
return HttpResponseUnauthorized()
except:
return HttpResponseBadRequest()
email = self._get_current_user_email()
if not email:
return HttpResponseUnauthorized()
return self._render_to_json_response({'user': email})
class MySelfProvider(Provider):
def __init__(self, *args, **kwargs):
Provider.__init__(self, *args, **kwargs)
self.app_access = Key(urlsafe=self.key).get()
def _set_memcache(self, *args, **kwargs):
# ignore internal memcache
pass
def _signin(self, user):
state = self.app_access.compile_profile_state(user.user_id, user.device_id)
user.load_state(state)
def did(self, user, action, change, **kwargs):
LogEntry.make(self.app_access.key, user.user_id, user.device_id,
action=action, quantity=change, **kwargs).put()
