def get(self):
template = main.jinja_env.get_template("templates/insert_item.html")
urlsafe_entity_key = self.request.get('item-entity-key')
if "user_info" in self.session:
user_info = json.loads(self.session["user_info"])
if len(urlsafe_entity_key) > 0:
item_key = ndb.Key(urlsafe=urlsafe_entity_key)
item = item_key.get()
self.response.out.write(
template.render({
"user_info":
user_info,
"form_action":
blobstore.create_upload_url('/insert-item'),
"item":
item
}))
else:
self.response.out.write(
template.render({
"user_info":
user_info,
"form_action":
blobstore.create_upload_url('/insert-item')
}))
else:
self.response.out.write(template.render())
def create_challenge_set_donation(request, template_id, state, club_id, club_class):
club = get_object_or_404(club_class, id=club_id)
template = get_object_or_404(ChallengeTemplate, id=template_id)
form = ChallengeConfigureForm()
upload_url = blobstore.create_upload_url('/challenges/create/%s/%s/%s/%s' % (
template_id, state, 'o' if club_class == Club else 't', club_id))
if request.method == 'POST':
form = ChallengeConfigureForm(request.POST)
if form.is_valid():
uploaded_file = None
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file = upload_form.save()
challenge = _create_challenge(club_class, club_id, form, request, template, image=uploaded_file)
redirect_url = '/challenges/%s/share' % challenge.id
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse("%s|%s" % (
blobstore.create_upload_url(upload_url),
'<br/>'.join(['<br/>'.join([_e for _e in e]) for e in form.errors.values()])))
template_data = {
'club': club,
'club_class': club_class.__name__,
'form': form,
'state': state,
'template': template,
'upload_url': upload_url}
return render(
request,
'spudderspuds/challenges/pages/create_challenge_configure.html',
template_data)
def edit_image(request, challenge_id):
"""
Allows the owner of a challenge to change the related image
:param request: any request
:param challenge_id: a valid ID of a Challenge object
:return: a simple form page
"""
challenge = Challenge.objects.get(id=challenge_id)
form = ChallengeImageEditForm()
upload_url = blobstore.create_upload_url('/challenges/edit_image/%s' % challenge_id)
if request.method == 'POST':
form = ChallengeConfigureForm(request.POST)
if form.is_valid():
uploaded_file = None
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file = upload_form.save()
challenge.image = uploaded_file
redirect_url = '/fan'
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse("%s|%s" % (
blobstore.create_upload_url(upload_url),
'<br/>'.join(['<br/>'.join([_e for _e in e]) for e in form.errors.values()])))
return render(request, 'spudderspuds/challenges/pages/edit_image.html', {
'upload_url': upload_url,
'form': form,
'image_url': '/file/serve/%s' % challenge.image if challenge.image else None,
'challenge_name': challenge.name
})
def _state_engine_process_upload(request, challenge, engine, state,
template_data):
response = None
template = challenge.template
beneficiary = EntityController.GetWrappedEntityByTypeAndId(
challenge.recipient_entity_type, challenge.recipient_entity_id,
EntityBase.EntityWrapperByEntityType(challenge.recipient_entity_type))
participation = ChallengeParticipation.objects.get(
challenge=challenge,
participating_entity_id=request.current_role.entity.id,
participating_entity_type=request.current_role.entity_type)
redirect_url = '/challenges/%s/%s/4?just_pledged=True' % (challenge.id,
engine)
action_upload_image = 'upload_image'
image_form = UploadImageForm(initial={'action': action_upload_image})
upload_url = '/challenges/%s/accept' % challenge.id
if request.method == 'POST':
action = request.POST.get('action')
if action == action_upload_image:
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
file = upload_form.save()
participation.image = file
participation.state = ChallengeParticipation.ACCEPTED_STATE
participation.state_engine = engine
participation.save()
if feature_is_enabled('tracking_pixels'):
EventController.RegisterEvent(
request, EventController.CHALLENGE_ACCEPTED)
if request.is_ajax():
response = HttpResponse(redirect_url)
return response, state
response = redirect(redirect_url)
return response, state
if request.is_ajax():
response = HttpResponse(
"%s|%s" %
(blobstore.create_upload_url(upload_url), '<br/>'.join([
'<br/>'.join([_e for _e in e])
for e in image_form.errors.values()
])))
return response, state
template_data['template'] = template
template_data['beneficiary'] = beneficiary
template_data['participation'] = participation
template_data['redirect_url'] = redirect_url
template_data['upload_url'] = blobstore.create_upload_url(upload_url)
response = render(
request,
'spudderspuds/challenges/pages_ajax/challenge_accept_upload.html',
template_data)
return response, state
def challenge_challenge_accept_notice(request,
state=None,
club_entity_type=None,
club_id=None,
participation_id=None):
if state and club_entity_type and club_id:
ccp = ChallengeChallengeParticipation(
participating_entity_id=request.current_role.entity.id,
participating_entity_type=request.current_role.entity_type,
recipient_entity_id=club_id,
recipient_entity_type=club_entity_type)
ccp.save()
return redirect('/challenges/challenge_challenge/%s/upload' % ccp.id)
participation = get_object_or_404(ChallengeChallengeParticipation,
id=participation_id)
form = ChallengeChallengeParticipationForm()
upload_url = '/challenges/challenge_challenge/%s/upload' % participation_id
if request.method == 'POST':
form = ChallengeChallengeParticipationForm(request.POST)
if form.is_valid():
participation.youtube_video_id = form.cleaned_data.get(
'youtube_video_id')
participation.name = form.cleaned_data.get('challenge_name')
participation.description = form.cleaned_data.get(
'challenge_description')
participation.state = ChallengeChallengeParticipation.STATE_COMPLETE
if request.FILES:
file = UploadForm(request.POST, request.FILES).save()
participation.image = file
participation.save()
redirect_url = '/challenges/challenge_challenge/%s/thanks?just_submitted=True' % participation_id
if feature_is_enabled('tracking_pixels'):
EventController.RegisterEvent(
request, EventController.CHALLENGE_ACCEPTED)
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse(
"%s|%s" %
(blobstore.create_upload_url(upload_url), '<br/>'.join([
'<br/>'.join([_e for _e in e])
for e in form.errors.values()
])))
template_data = {
'form': form,
'upload_url': blobstore.create_upload_url(upload_url)
}
return render(
request,
'spudderspuds/challenges/pages/challenge_challenge_accept_upload.html',
template_data)
def get_template_parameters():
values = {}
email = get_user_email()
if email:
values['learner'] = data.is_learner(email)
values['expert'] = data.is_expert(email)
values['logout_url'] = users.create_logout_url('/')
values['upload_url'] = blobstore.create_upload_url('/profile-save')
values['user'] = email
else:
values['login_url'] = users.create_login_url('/welcome')
values['upload_url'] = blobstore.create_upload_url('/profile-save')
return values
def edit_team_page(request, page_id):
team_page = TeamPage.objects.select_related('image').get(pk=page_id)
form = EditTeamForm(initial=team_page.__dict__, image=team_page.image)
if request.method == 'POST':
form = EditTeamForm(request.POST, team_id=team_page.id, image=team_page.image)
if form.is_valid():
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file_model = None
if upload_form.is_valid():
uploaded_file_model = upload_form.save()
data = form.cleaned_data
team_page.name = data.get('name')
team_page.contact_details = data.get('contact_details')
team_page.free_text = data.get('free_text')
if uploaded_file_model:
team_page.image = uploaded_file_model
team_page.save()
return HttpResponseRedirect('/team/%s' % page_id)
return render(request, 'spudderspuds/teams/pages/edit_team.html', {
'page': team_page,
'form': form,
'upload_url': blobstore.create_upload_url('/team/%s/edit' % page_id)
})
def edit_team_page(request, page_id):
team_page = TeamPage.objects.select_related('image').get(pk=page_id)
form = EditTeamForm(initial=team_page.__dict__, image=team_page.image)
if request.method == 'POST':
form = EditTeamForm(request.POST,
team_id=team_page.id,
image=team_page.image)
if form.is_valid():
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file_model = None
if upload_form.is_valid():
uploaded_file_model = upload_form.save()
data = form.cleaned_data
team_page.name = data.get('name')
team_page.contact_details = data.get('contact_details')
team_page.free_text = data.get('free_text')
if uploaded_file_model:
team_page.image = uploaded_file_model
team_page.save()
return HttpResponseRedirect('/team/%s' % page_id)
return render(
request, 'spudderspuds/teams/pages/edit_team.html', {
'page': team_page,
'form': form,
'upload_url': blobstore.create_upload_url(
'/team/%s/edit' % page_id)
})
def get(self):
stream_name = self.request.get('stream_name')
if stream_name:
key = ndb.Key('Stream', stream_name)
stream = key.get()
else:
stream = None
if stream:
increment = self.request.get('increment')
if increment:
stream.views += int(increment)
stream.recent_views.append(datetime.datetime.now())
stream.put()
cursor = self.request.get('cursor')
cursor = int(cursor) if cursor else 0
upload_url = blobstore.create_upload_url('/upload_photo')
template_values = {
'stream': stream,
'cursor': cursor,
'upload_url': upload_url
}
template = JINJA_ENVIRONMENT.get_template('views/view-stream.html')
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
self.response.write(template.render(template_values))
else:
streams = Stream.query().order(Stream.date).fetch()
template_values = {
'streams': streams,
}
template = JINJA_ENVIRONMENT.get_template(
'views/view-streams.html')
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
self.response.write(template.render(template_values))
def addCommon(self):
# get all the guide items from datastore
self.addTemplateValue('items', AppGuide.get_all())
self.addTemplateValue(
'form_action',
blobstore.create_upload_url(success_path='/guide/create',
gs_bucket_name=self.get_gs_bucket()))
def show(self,event_id):
self.template = 'sessions_edit'
user = users.get_current_user()
event = CEvent(event_id).get()
form = SessionsTracksForm()
# check permissions...
if user and event and (user in event.organizers or users.is_current_user_admin()):
# get list of event sessions
sessions = CSessionList(event_id).get()
for s in sessions:
s.session = str(s.key())
# get list of event tracks
tracks = CTrackList(event_id).get()
for t in tracks:
t.track = str(t.key())
# we need to store the event
self.values['event'] = event
form = SessionsTracksForm(sessions=sessions,tracks=tracks)
speakers = CSpeakerList(event_id).get()
SessionFormHelper.add_speakers(form,speakers)
slots = CSlotList(event_id).get()
SessionFormHelper.add_slots(form, slots)
SessionFormHelper.add_tracks(form, tracks)
elif not user:
return self.redirect(
users.create_login_url("/event/sessions/edit/" + event_id))
else:
return self.redirect("/event/create");
self.values['current_navigation'] = 'sessions'
self.values['form_url'] = blobstore.create_upload_url('/event/sessiontrack/upload')
self.values['form'] = form
def get(self):
guestbook_name = self.request.get('guestbook_name',
DEFAULT_GUESTBOOK_NAME)
greetings_query = Greeting.query(
ancestor=guestbook_key(guestbook_name)).order(-Greeting.date)
greetings = greetings_query.fetch(10)
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
template_values = {
'user': user,
'greetings': greetings,
'guestbook_name': urllib.quote_plus(guestbook_name),
'url': url,
'url_linktext': url_linktext,
'upload_url_image': blobstore.create_upload_url('/sign'),
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def fan_profile_edit(request, page_id):
fan_page = get_object_or_404(FanPage, pk=page_id)
profile_form = FanPageForm(initial=fan_page.__dict__, image=fan_page.avatar)
social_accounts_form = BasicSocialMediaForm(initial=fan_page.__dict__)
if request.method == 'POST':
profile_form = FanPageForm(request.POST, image=fan_page.avatar)
social_accounts_form = BasicSocialMediaForm(request.POST)
if profile_form.is_valid() and social_accounts_form.is_valid():
for attr in ('name', 'date_of_birth', 'state', ):
fan_page.__setattr__(attr, profile_form.cleaned_data[attr])
set_social_media(fan_page, social_accounts_form)
upload_form = UploadForm(request.POST, request.FILES)
if upload_form.is_valid():
fan_page.avatar = upload_form.save()
fan_page.save()
redirect_to = request.session.pop('redirect_after_auth', '/fan/%s' % fan_page.id)
return redirect(redirect_to)
return render(request, 'spudderspuds/fans/pages/fan_page_edit.html', {
'profile_form': profile_form,
'social_accounts_form': social_accounts_form,
'page': fan_page,
'new_registration': request.GET.get('new_registration', False),
'upload_url': blobstore.create_upload_url('/fan/%s/edit' % page_id)
})
def dashboard_edit(request):
club = request.current_role.entity.club
club_entity = EntityController.GetWrappedEntityByTypeAndId(
EntityController.ENTITY_CLUB,
club.id,
EntityBase.EntityWrapperByEntityType(EntityController.ENTITY_CLUB))
basic_details_form = ClubProfileBasicDetailsForm(club=club, initial=club.__dict__)
if request.method == 'POST':
if request.FILES:
icon = UploadForm(request.POST, request.FILES).save()
club.thumbnail = icon
club.save()
basic_details_form = ClubProfileBasicDetailsForm(club=club, data=request.POST)
if basic_details_form.is_valid():
for attr in ('name', ):
setattr(club, attr, basic_details_form.cleaned_data.get(attr))
club.save()
messages.success(request, 'Team details updated.')
return redirect('/club/dashboard/edit')
template_data = {
'upload_url': blobstore.create_upload_url('/club/dashboard/edit'),
'club_entity': club_entity,
'basic_details_form': basic_details_form}
return render(request, 'spudderspuds/clubs/pages/dashboard_edit.html', template_data)
def fan_profile_edit(request, page_id):
fan_page = get_object_or_404(FanPage, pk=page_id)
profile_form = FanPageForm(initial=fan_page.__dict__,
image=fan_page.avatar)
social_accounts_form = BasicSocialMediaForm(initial=fan_page.__dict__)
if request.method == 'POST':
profile_form = FanPageForm(request.POST, image=fan_page.avatar)
social_accounts_form = BasicSocialMediaForm(request.POST)
if profile_form.is_valid() and social_accounts_form.is_valid():
for attr in (
'name',
'date_of_birth',
'state',
):
fan_page.__setattr__(attr, profile_form.cleaned_data[attr])
set_social_media(fan_page, social_accounts_form)
upload_form = UploadForm(request.POST, request.FILES)
if upload_form.is_valid():
fan_page.avatar = upload_form.save()
fan_page.save()
redirect_to = request.session.pop('redirect_after_auth',
'/fan/%s' % fan_page.id)
return redirect(redirect_to)
return render(
request, 'spudderspuds/fans/pages/fan_page_edit.html', {
'profile_form': profile_form,
'social_accounts_form': social_accounts_form,
'page': fan_page,
'new_registration': request.GET.get('new_registration', False),
'upload_url': blobstore.create_upload_url('/fan/%s/edit' % page_id)
})
def get(self):
stream_name = self.request.get('stream_name')
if stream_name:
key = ndb.Key('Stream', stream_name)
stream = key.get()
else:
stream = None
if stream:
increment = self.request.get('increment')
if increment:
stream.views += int(increment)
stream.recent_views.append(datetime.datetime.now())
stream.put()
cursor = self.request.get('cursor')
cursor = int(cursor) if cursor else 0
upload_url = blobstore.create_upload_url('/upload_photo')
template_values = {
'stream': stream,
'cursor': cursor,
'upload_url': upload_url
}
template = JINJA_ENVIRONMENT.get_template('views/view-stream.html')
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
self.response.write(template.render(template_values))
else:
streams = Stream.query().order(Stream.date).fetch()
template_values = {
'streams': streams,
}
template = JINJA_ENVIRONMENT.get_template('views/view-streams.html')
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
self.response.write(template.render(template_values))
def admin_index(request):
photos = GramPhoto.query().order(-GramPhoto.add_time)
url = blobstore.create_upload_url(url_for('gram/admin/add'))
return render_to_response(
'gram/admin/index.html', {
'photos': photos,
'url': url
})
def imageStore(self, view, query):
if query.getvalue('imageId'):
view.currentImage = dbImageStore.ImageStore.get_by_id(int(query.getvalue('imageId')))
view.currentImageDescription = dbImageStore.ImageDescription.gql('WHERE imageEntry = :imageEntry', imageEntry = view.currentImage.key())
view.uploadUrl = blobstore.create_upload_url('/edit/action/AddUpdateImageStore')
view.imageList = dbImageStore.ImageStore.all()
view.templateFile = 'edit/' + self.pathList[0] + '.html'
def create_challenge_set_donation(request, template_id, state, club_id,
club_class):
club = get_object_or_404(club_class, id=club_id)
template = get_object_or_404(ChallengeTemplate, id=template_id)
form = ChallengeConfigureForm()
upload_url = blobstore.create_upload_url(
'/challenges/create/%s/%s/%s/%s' %
(template_id, state, 'o' if club_class == Club else 't', club_id))
if request.method == 'POST':
form = ChallengeConfigureForm(request.POST)
if form.is_valid():
uploaded_file = None
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file = upload_form.save()
challenge = _create_challenge(club_class,
club_id,
form,
request,
template,
image=uploaded_file)
redirect_url = '/challenges/%s/share' % challenge.id
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse(
"%s|%s" %
(blobstore.create_upload_url(upload_url), '<br/>'.join([
'<br/>'.join([_e for _e in e])
for e in form.errors.values()
])))
template_data = {
'club': club,
'club_class': club_class.__name__,
'form': form,
'state': state,
'template': template,
'upload_url': upload_url
}
return render(
request,
'spudderspuds/challenges/pages/create_challenge_configure.html',
template_data)
def _state_engine_process_upload(request, challenge, engine, state, template_data):
response = None
template = challenge.template
beneficiary = EntityController.GetWrappedEntityByTypeAndId(
challenge.recipient_entity_type,
challenge.recipient_entity_id,
EntityBase.EntityWrapperByEntityType(challenge.recipient_entity_type))
participation = ChallengeParticipation.objects.get(
challenge=challenge,
participating_entity_id=request.current_role.entity.id,
participating_entity_type=request.current_role.entity_type)
redirect_url = '/challenges/%s/%s/4?just_pledged=True' % (challenge.id, engine)
action_upload_image = 'upload_image'
image_form = UploadImageForm(initial={'action': action_upload_image})
upload_url = '/challenges/%s/accept' % challenge.id
if request.method == 'POST':
action = request.POST.get('action')
if action == action_upload_image:
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
file = upload_form.save()
participation.image = file
participation.state = ChallengeParticipation.ACCEPTED_STATE
participation.state_engine = engine
participation.save()
if feature_is_enabled('tracking_pixels'):
EventController.RegisterEvent(request, EventController.CHALLENGE_ACCEPTED)
if request.is_ajax():
response = HttpResponse(redirect_url)
return response, state
response = redirect(redirect_url)
return response, state
if request.is_ajax():
response = HttpResponse("%s|%s" % (blobstore.create_upload_url(upload_url), '<br/>'.join(
['<br/>'.join([_e for _e in e]) for e in image_form.errors.values()])))
return response, state
template_data['template'] = template
template_data['beneficiary'] = beneficiary
template_data['participation'] = participation
template_data['redirect_url'] = redirect_url
template_data['upload_url'] = blobstore.create_upload_url(upload_url)
response = render(request, 'spudderspuds/challenges/pages_ajax/challenge_accept_upload.html', template_data)
return response, state
def edit_image(request, challenge_id):
"""
Allows the owner of a challenge to change the related image
:param request: any request
:param challenge_id: a valid ID of a Challenge object
:return: a simple form page
"""
challenge = Challenge.objects.get(id=challenge_id)
form = ChallengeImageEditForm()
upload_url = blobstore.create_upload_url('/challenges/edit_image/%s' %
challenge_id)
if request.method == 'POST':
form = ChallengeConfigureForm(request.POST)
if form.is_valid():
uploaded_file = None
if request.FILES:
upload_form = UploadForm(request.POST, request.FILES)
uploaded_file = upload_form.save()
challenge.image = uploaded_file
redirect_url = '/fan'
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse(
"%s|%s" %
(blobstore.create_upload_url(upload_url), '<br/>'.join([
'<br/>'.join([_e for _e in e])
for e in form.errors.values()
])))
return render(
request, 'spudderspuds/challenges/pages/edit_image.html', {
'upload_url':
upload_url,
'form':
form,
'image_url':
'/file/serve/%s' % challenge.image if challenge.image else None,
'challenge_name':
challenge.name
})
def post(self):
rq_cid = self.request.form.get('cid')
rq_token = self.request.form.get('token')
rq_image = self.request.files.get('image')
if rq_token is None or rq_cid is None:
return MissingParams()
else:
profile = Profile.all().filter('token', rq_token).get()
if profile is None:
return InvalidToken()
elif not profile.game.is_on:
return NoGameOn()
else:
point = CheckinPoint.all().filter('cid', int(rq_cid)).get()
if point is None:
return InvalidCid()
else:
ckin = Checkin.all().filter('profile', profile)
if ckin.filter('achieved', False).count() == 0:
return render_json_response({'status':{'code':13,'message':'You have no unachieved checkins.'}})
else:
ckin = ckin.filter('point', point).get()
if ckin is None:
return render_json_response({'status':{'code':11,'message':'You are checked in at another location!'}})
else:
rq_image.seek(0,2)
img_content_length = rq_image.tell()
rq_image.seek(0,0)
if img_content_length == 0:
return render_json_response({'status':{'code':95,'message':'You have not included a picture!'}})
else:
params = []
params.append(
MultipartParam(
"file",
filename=ckin.cid,
value=rq_image.read()
)
)
payloadgen, headers = multipart_encode(params)
payload = str().join(payloadgen)
url = blobstore.create_upload_url('/handle_upload')
try:
result = urlfetch.fetch(
url=url,
payload=payload,
method=urlfetch.POST,
headers=headers,
deadline=10,
follow_redirects=False
)
return render_json_response({'status':{'code':0,'message':'Success'}})
except:
return render_json_response({'status':{'code':81,'message':'There was a server error uploading the image.'}})
def edit_images(key_id):
product = Product.retrieve_by_id(key_id)
if not product:
return redirect('pages.catalogue')
form = AddImageForm()
add_img_url = blobstore.create_upload_url(
url_for('admin.product.add_image', key_id=key_id))
return render_template('product/admin/images_edit.html',
product=product,
form=form,
add_img_url=add_img_url)
def r_info_images(request, uid):
r_info_obj = RetailInfo.get_by_id(uid)
if not r_info_obj:
return render_to_response('empty.html')
images = RetailInfoImage.query(RetailInfoImage.news_ref == r_info_obj.key)
url = blobstore.create_upload_url(url_for('page/admins/r_info/images/add', uid=r_info_obj.key.id()))
return render_to_response('page/admins/r_info/images.html',{
'images': images,
'r_info': r_info_obj,
'url': url
})
def admin_images(request, uid):
showcase = Showcase.get_by_id(uid)
if not showcase:
return render_to_response('empty.html')
images = showcase.images
url = blobstore.create_upload_url(url_for('showcase/admin/images/add', uid=showcase.key().id()))
return render_to_response('showcase/admin/images.html',{
'images': images,
'showcase': showcase,
'url': url
})
def admin_images(request, uid):
news = News.get_by_id(uid)
if not news:
return render_to_response('empty.html')
images = NewsImage.query(NewsImage.news_ref == news.key)
url = blobstore.create_upload_url(url_for('news/admin/images/add', uid=news.key.id()))
return render_to_response('news/admin/images.html',{
'images': images,
'news': news,
'url': url
})
def edit_images(key_id):
product = Product.retrieve_by_id(key_id)
if not product:
return redirect('pages.catalogue')
form = AddImageForm()
add_img_url = blobstore.create_upload_url(url_for('admin.product.add_image', key_id=key_id))
return render_template(
'product/admin/images_edit.html',
product=product,
form=form,
add_img_url=add_img_url
)
def upload_url(self, query=None):
"""Creates a blob upload URL for this endpoint.
For all endpoints, we assume that we have an /__upload URL that is bound
to an blob upload endpoint. This makes implementing upload for an endpoint very easy.
Args:
query: query parameters to add (in URL format)
"""
post_url = self.endpoint_class.construct_relative_url("__upload" + query)
logging.info("constructed upload url: %s" % post_url)
url = blobstore.create_upload_url(post_url)
logging.info("url: %s" % url)
return url
def admin_images(parent_id= -1):
"""
List all images from within a category
"""
category_id = parent_id
form = ImageForm(prefix='image')
if form.validate_on_submit():
is_new = False
if len(form.key_id.data) > 0 and long(form.key_id.data) > 0:
image = ImageModel.get_by_id(long(form.key_id.data))
else:
image = ImageModel()
is_new = True
v2m(form, image)
category_id = long(form.category_id.data)
if type(form.image.data) == FileStorage and (is_new or form.update_image.data):
blob_key = form.image.data.mimetype_params['blob-key']
#create a small
(image.image_thumb_blob_key, image.width, image.height) = create_thumbnail(blob_key, 50, 50)
#and a slightly larger version
(image.image_blob_key, image.width, image.height) = create_thumbnail(blob_key)
#delete the uploaded (possibly 'uge file)
blobstore.delete(blob_key)
elif not is_new and form.update_image.data: # we set to update with an empty image so we delete the one in the db
image.delete_images()
image.image_blob_key = ''
image.image_thumb_blob_key = ''
image.width = 0
image.height = 0
try:
image.put()
image_id = image.key().id()
flash(u'Image %s successfully saved.' % image_id, 'success')
return redirect(url_for('admin_images_in_category', parent_id=category_id))
except CapabilityDisabledError:
image.delete_images()
flash(u'App Engine Datastore is currently in read-only mode.', 'info')
return redirect(url_for('admin_images_in_category', parent_id=category_id))
pass
elif form.is_submitted():
category_id = long(form.category_id.data)
images = sorted(ImageModel.all().filter('category_id', category_id), key=lambda i: i.order)
(categories, category_path, all_categories) = CategoryModel.get_categories_info(category_id)
form.category_id.data = category_path[-1].key().id()
return render_template('image/admin_images.html', images=images,
form=form,
categories=categories,
category_path=category_path,
current_category=category_path[-1],
all_categories=all_categories,
reset_image=ImageModel(category_id=category_id),
upload_url=blobstore.create_upload_url(url_for('admin_images')))
def __init__(self, **kwargs):
View.__init__(self, **kwargs)
self.templateFile = 'imagestore.html'
self.permissionLevel = 1
self.isEdit = True
self.toTemplate.uploadUrl = blobstore.create_upload_url('/edit/AddUpdateImageStore')
self.toTemplate.imageList = PacImageStore.getAll()
query = kwargs['query']
if query.getvalue('item_id'):
self.itemId = str(query.getvalue('item_id'))
self.toTemplate.currentImage = PacImageStore.getByIdForEdit(self.itemId)
def challenge_challenge_accept_notice(request, state=None, club_entity_type=None, club_id=None, participation_id=None):
if state and club_entity_type and club_id:
ccp = ChallengeChallengeParticipation(
participating_entity_id=request.current_role.entity.id,
participating_entity_type=request.current_role.entity_type,
recipient_entity_id=club_id,
recipient_entity_type=club_entity_type)
ccp.save()
return redirect('/challenges/challenge_challenge/%s/upload' % ccp.id)
participation = get_object_or_404(ChallengeChallengeParticipation, id=participation_id)
form = ChallengeChallengeParticipationForm()
upload_url = '/challenges/challenge_challenge/%s/upload' % participation_id
if request.method == 'POST':
form = ChallengeChallengeParticipationForm(request.POST)
if form.is_valid():
participation.youtube_video_id = form.cleaned_data.get('youtube_video_id')
participation.name = form.cleaned_data.get('challenge_name')
participation.description = form.cleaned_data.get('challenge_description')
participation.state = ChallengeChallengeParticipation.STATE_COMPLETE
if request.FILES:
file = UploadForm(request.POST, request.FILES).save()
participation.image = file
participation.save()
redirect_url = '/challenges/challenge_challenge/%s/thanks?just_submitted=True' % participation_id
if feature_is_enabled('tracking_pixels'):
EventController.RegisterEvent(request, EventController.CHALLENGE_ACCEPTED)
if request.is_ajax():
return HttpResponse(redirect_url)
return redirect(redirect_url)
if request.is_ajax():
return HttpResponse("%s|%s" % (
blobstore.create_upload_url(upload_url),
'<br/>'.join(['<br/>'.join([_e for _e in e]) for e in form.errors.values()])))
template_data = {
'form': form,
'upload_url': blobstore.create_upload_url(upload_url)}
return render(request, 'spudderspuds/challenges/pages/challenge_challenge_accept_upload.html', template_data)
def get(self):
user = users.get_current_user()
template_values = {
'xsrf_token': frontend_utils.generate_token(),
'upload_action': blobstore.create_upload_url(
'/upload/',
max_bytes_total=_BUNDLE_MAX_UPLOAD_BYTES),
'x5_networks': sorted(self.x5_networks.values()),
'x5_transforms': list(x5_transform.X5Transform.user_transforms(
user.user_id()
)),
'flashes': self.session.get_flashes(key='index')
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def __init__(self, **kwargs):
View.__init__(self, **kwargs)
self.templateFile = 'imagestore.html'
self.permissionLevel = 1
self.isEdit = True
self.toTemplate.uploadUrl = blobstore.create_upload_url(
'/edit/AddUpdateImageStore')
self.toTemplate.imageList = PacImageStore.getAll()
query = kwargs['query']
if query.getvalue('item_id'):
self.itemId = str(query.getvalue('item_id'))
self.toTemplate.currentImage = PacImageStore.getByIdForEdit(
self.itemId)
def send_into_blobstore(img_data, filename):
r"""
Send data into blobstore.
We need to create our own http request for it.
"""
handler_url = url_for('assets.send_into_blobstore_handler')
post_url = blobstore.create_upload_url(handler_url)
r = crawler().post(post_url, files={'file': (filename, img_data)})
r.raise_for_status()
json = r.json()
app.logger.info("Submitted asset into filestore: %s", repr(json))
return json['blob_key']
def get(self):
user = users.get_current_user()
template_values = {
'xsrf_token':
frontend_utils.generate_token(),
'upload_action':
blobstore.create_upload_url(
'/upload/', max_bytes_total=_BUNDLE_MAX_UPLOAD_BYTES),
'x5_networks':
sorted(self.x5_networks.values()),
'x5_transforms':
list(x5_transform.X5Transform.user_transforms(user.user_id())),
'flashes':
self.session.get_flashes(key='index')
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
values = {}
if not user:
self.redirect("/")
return
if user:
email = user.email().lower()
values["user_email"] = email
values["logout_url"] = users.create_logout_url("/")
values["form_action"] = blobstore.create_upload_url('/insert-trip')
values["states"] = STATE_VALUES
self.update_values(email, values)
template = main.jinja_env.get_template(self.get_template())
self.response.out.write(template.render(values))
def create_showcase(request):
param = {}
if request.method == 'POST':
mode = request.POST['mode']
if mode == "new":
content_text = cgi.escape(request.POST['content'])
showcaseItem = Showcase.objects.create(author=request.user,
content=content_text,slugContent = slugify(content_text))
showcase_dict = convert_showcase_to_dict(request,showcaseItem)
param = {
'result' : showcase_dict,
'entityID' : showcaseItem.id
}
return HttpResponse(simplejson.dumps(param), mimetype="application/json")
elif request.method == 'GET':
param["upload_url"] = blobstore.create_upload_url('/upload')
return direct_to_template(request, 'showcase_editor.html',param)
def change_delivery(request):
url = blobstore.create_upload_url(url_for('partners/admins/change_delivery'))
obj = PartnersPage.all().get()
if obj:
form = PartnersDeliveryForm(instance=obj, action=url)
else:
form = PartnersDeliveryForm(action=url)
form.csrf_protected = False
if request.method == 'POST' and form.validate(request.form):
obj = form.save(commit=False)
upload_files = get_uploads(request, 'delivery')
if len(upload_files):
blob_info = upload_files[0]
if blob_info.size:
obj.delivery = str(blob_info.key())
else:
blob_info.delete()
else:
obj.delete_delivery()
obj.put()
return redirect(url_for('admin/index'))
return render_to_response('partners/admins/change.html',
{'form':form.as_widget()})
def get(self):
is_self = False
if "user_info" not in self.session:
# raise Exception("Missing user!")
self.redirect("/")
return
else:
user_utils.get_user_from_rosefire_user(self.user())
username = self.request.get('username', 'none')
if username == 'none':
user_info = json.loads(self.session.get("user_info"))
user = user_utils.get_user_from_username(user_info["username"])
is_self = True
print("user info", user_info)
else:
userResults = User.query(User.username == username).fetch(
limit=1)
if len(userResults) == 0:
self.redirect(uri="/profile")
return
else:
user = userResults[0]
print("user", user)
query = post_utils.get_query_for_all_nonanonymous_posts_by_user(
user)
values = {"post_query": query, "user": user, "is_self": is_self}
values["form_action"] = blobstore.create_upload_url(
'/update-profile')
template = JINJA_ENV.get_template("templates/profile.html")
self.response.out.write(template.render(values))
def index(request):
url = blobstore.create_upload_url(url_for('price_list/admin'))
form = PriceListForm(action=url)
form.csrf_protected = False
if request.method == 'POST' and form.validate(request.form):
desc = form['description']
upload_files = get_uploads(request, 'file')
if len(upload_files):
blob_info = upload_files[0]
if blob_info.size:
file = File(blob=blob_info.key())
file.name = file.get_name
file.put()
price_list = PriceList(file=file.key, description=desc)
price_list.put()
else:
blob_info.delete()
return redirect(url_for('price_list/admin'))
prices = PriceList.query()
return render_to_response('price_list/admins/index.html',
{'form': form.as_widget(),
'prices': prices})
def update_values(self, email, values):
values["route"] = "/item/view"
values["item_update_url"] = blobstore.create_upload_url('/item/insert')
def update_values(self, email, values):
values["route"] = "/profile/edit"
values["profile_update_url"] = blobstore.create_upload_url(
'/profile/update')
def get(self):
body = {
"upload_url": blobstore.create_upload_url("/sign")
}
self.response.headers.add("Content-Type", "application/json")
self.response.write(json.dumps(body))
'created': datetime.now().isoformat(),
'message': msg,
}
email = request.POST.get('email')
if email:
msg['email'] = email
entry['private_messages'] = [msg]
entry = PhotoEntry(**entry)
entry.put()
logging.debug("Created %r" % entry.key)
# authorize entry updating
request.session['ups'] = request.session.get('ups', []) + [entry.key.id()]
up_url = blobstore.create_upload_url(reverse(blobstore_callback, args=[entry.key.id()]))
return http.HttpResponse(json.dumps({'url': up_url}), 'text/javascript')
@never_cache
def blobstore_callback(request, entry_id):
info = None
key_match = re.search(r"blob-key=([^;\r]+)[;\r]", request.body)
if key_match:
info = BlobInfo.get(key_match.group(1).strip('"'))
if not info:
return render(request, "upload.html", {'err': True})
logging.info("Received file: %r" % ((info.filename, info.content_type, info.size, info.key()),))
def tx(entry_id):
entry = GalleryEntry.get_by_id(int(entry_id))
if not entry:
def show_post(self):
self.template = 'sessions_edit'
user = users.get_current_user()
event_id = self.request.get('event')
event = CEvent(event_id).get()
form = SessionsTracksForm(self.request.POST)
# check permissions...
if user and event and (user in event.organizers or users.is_current_user_admin()):
# add the speakers for validation
speakers = CSpeakerList(event_id).get()
SessionFormHelper.add_speakers(form,speakers)
slots = CSlotList(event_id).get()
SessionFormHelper.add_slots(form, slots)
tracks = CTrackList(event_id).get()
for t in tracks:
t.track = str(t.key())
SessionFormHelper.add_tracks(form, tracks)
if form.validate():
# start with the tracks as they are used by sessions
for i in range(0,1024):
prefix = 'tracks-' + str(i) + '-'
if self.request.get(prefix + 'name'):
# is this a modification of an existing track or a new one?
track_id = self.request.get(prefix + 'track')
if track_id in [t.track for t in tracks]:
track = [t for t in tracks if t.track == track_id][0]
# delete from old_session
tracks = [t for t in tracks if t.track != track_id]
else:
track = Track()
# fill in values for old/new session
track.name = self.request.get(prefix + 'name')
track.color = self.request.get(prefix + 'color')
track.abstract = self.request.get(prefix + 'abstract')
upload_files = self.get_uploads(prefix + 'icon')
if len(upload_files) > 0:
blob_info = upload_files[0]
track.icon = '%s' % blob_info.key()
track.event_key = event_id
# update track
track.put()
# end for
# now delete all tracks not mentioned yet
for t in tracks:
t.delete()
CTrackList.remove_from_cache(event_id)
# now the sessions...
sessions = CSessionList(event_id).get()
for s in sessions:
s.session = s.key()
for i in range(0,1024):
prefix = 'sessions-' + str(i) + '-'
if self.request.get(prefix + 'title'):
# is this a modification of an existing session or a new one?
session_id = self.request.get(prefix + 'session')
if session_id in [s.session for s in sessions]:
session = [s for s in sessions if s.session == session_id][0]
# delete from session
sessions = [s for s in sessions if s.session != session_id]
else:
session = Session()
# fill in values for old/new session
session.title = self.request.get(prefix + 'title')
session.abstract = self.request.get(prefix + 'abstract')
session.slot_key = self.request.get(prefix + 'slot_key')
session.level = self.request.get(prefix + 'level')
session.room = self.request.get(prefix + 'room')
session.track_key = self.request.get(prefix + 'track_key')
session.live_url = self.request.get(prefix + 'live_url')
session.youtube_url = self.request.get(prefix + 'youtube_url')
session.event_key = event_id
session.speakers_key = self.request.get_all(prefix + 'speakers_key')
# update session
session.put()
# end for
# now delete all sessions not mentioned yet
for s in sessions:
s.delete()
# set info that modification was successful
self.values['modified_successful'] = True
# clear the cache for the event
CSessionList.remove_from_cache(event_id)
# set event into form object
self.values['event'] = event
elif not user:
return self.redirect(
users.create_login_url("/event/sessions/edit/" + event_id))
else:
return self.redirect("/event/create");
self.values['current_navigation'] = 'sessions'
self.values['form_url'] = blobstore.create_upload_url('/event/sessiontrack/upload')
self.values['form'] = form
def get(self):
upload_url = blobstore.create_upload_url('/_titan/file/finalizeblob')
self.response.out.write(upload_url)
def get_upload_url(request):
return HttpResponse(
blobstore.create_upload_url('/upload/upload_image_endpoint'))
def get_avatar_upload_url():
return blobstore.create_upload_url('/mobi/profile/avator/post')
def ParseImageListWithDescriptions(self):
self.uploadUrl = blobstore.create_upload_url('/action/addSpot')
for lang in self.pageData:
list = self.pageData[lang]
if 'ImageList' in list:
self.pageData[lang]['ImageList'] = ImageStore.GetImageListDescriptions(self.pageData[lang]['ImageList'], lang)
def get_croppic_upload(request):
return HttpResponse(
blobstore.create_upload_url('/upload/croppic_upload_endpoint'))
def price_add(request):
upload_url = blobstore.create_upload_url(url_for('admin/price_uploader'))
return render_to_response('admin/price_add.html',{
'upload_url': upload_url})
def get(self):
upload_url = blobstore.create_upload_url('/_titan/finalizeblob')
self.response.out.write(upload_url)
def create_upload_url(application_name):
return blobstore.create_upload_url(
"/upload/finish/%s" % application_name,
gs_bucket_name="%s/%s" % (app_identity.get_default_gcs_bucket_name(), application_name))
