def pp_imgsource_form(context, nodelist, *args, **kwargs):
'''
This block tag can create or process forms eitfrom genericview.views import HttpRedirectException, namespace_gether to create or to modify arguments.
Usage is as follows:
{% pp_topic_form POST=request.POST path=request.path topic=pp_topic.topic root=some_topic %}
Do stuff with {{ pp_source.form }}.
{% endpp_topic_form %}
'''
context.push()
namespace = get_namespace(context)
POST = kwargs.get('POST', None)
FILE = kwargs.get('FILE', None)
obj = kwargs.get('object', None)
request = kwargs.get('request', None)
content_type = ContentType.objects.get_for_model(obj)
view_url = reverse('pirate_sources.views.upload_handler', args=[obj.pk, content_type.pk])
if POST:
form = IMGSourceForm(POST, FILE)
if form.is_valid():
img = form.save()
img.user = request.user
img.object_pk = obj.pk
img.content_type = ContentType.objects.get(pk=content_type.pk)
img.submit_date = datetime.datetime.now()
img.make(request.FILES['file'], img.file.name)
if img.private != True:
try:
oldimg = IMGSource.objects.get(object_pk=obj.pk, current=True)
oldimg.current = False
oldimg.save()
except:
pass
img.current = True
img.save()
upload_url, upload_data = prepare_upload(request, view_url)
form = IMGSourceForm()
else:
view_url += '?error=Not a valid image'
namespace['errors'] = form.errors
upload_url, upload_data = prepare_upload(request, view_url)
form = IMGSourceForm()
namespace['upload_url'] = upload_url
namespace['upload_data'] = upload_data
namespace['form'] = form
output = nodelist.render(context)
context.pop()
return output
def pp_imgsource_form(context, nodelist, *args, **kwargs):
'''
This block tag can create or process forms eitfrom genericview.views import HttpRedirectException, namespace_gether to create or to modify arguments.
Usage is as follows:
{% pp_topic_form POST=request.POST path=request.path topic=pp_topic.topic root=some_topic %}
Do stuff with {{ pp_source.form }}.
{% endpp_topic_form %}
'''
context.push()
namespace = get_namespace(context)
POST = kwargs.get('POST', None)
FILE = kwargs.get('FILE', None)
obj = kwargs.get('object', None)
request = kwargs.get('request', None)
content_type = ContentType.objects.get_for_model(obj)
view_url = reverse('pirate_sources.views.upload_handler', args=[obj.pk, content_type.pk])
if POST:
form = IMGSourceForm(POST, FILE)
if form.is_valid():
img = form.save()
img.user = request.user
img.object_pk = obj.pk
img.content_type = ContentType.objects.get(pk=content_type.pk)
img.submit_date = datetime.datetime.now()
img.make(request.FILES['file'], img.file.name)
if img.private != True:
try:
oldimg = IMGSource.objects.get(object_pk=obj.pk, current=True)
oldimg.current = False
oldimg.save()
except:
pass
img.current = True
img.save()
upload_url, upload_data = prepare_upload(request, view_url)
form = IMGSourceForm()
else:
view_url += '?error=Not a valid image'
namespace['errors'] = form.errors
upload_url, upload_data = prepare_upload(request, view_url)
form = IMGSourceForm()
namespace['upload_url'] = upload_url
namespace['upload_data'] = upload_data
namespace['form'] = form
output = nodelist.render(context)
context.pop()
return output
def upload_handler(request, lat, lon):
assert(request.method == 'POST')
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect("/home")
upload_url, upload_data = prepare_upload(request, "/upload/")
form = UploadForm()
return render(request, 'upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data,
'uploads': FileUpload.objects.all()})
upload_url, upload_data = prepare_upload(request, view_url)
def detail(request, slug):
inst = get_object_or_404(Institution, slug__exact=slug)
msg_form = MessageForm(inst)
upload_url, upload_data = prepare_upload(request, reverse('portal.messages.views.attach_file'))
ctx = {
'request' : request,
'institution': inst,
'photo_count': 0,
'files' : UploadedFile.objects.for_model(inst).all(),
'next' : reverse('portal.institutions.views.detail', args=[slug,]),
'msg_form' : msg_form,
'attach_form': AttachmentForm(),
'upload_url' : upload_url,
'upload_data': upload_data,
}
albums = Album.objects.for_model(inst)
if albums.exists():
ctx['albums'] = albums.all()
qtd = 0
for album in albums:
qtd += album.picture_album_set.count()
ctx['photo_count'] = qtd
return direct_to_template(request, 'institutions/detail.html', ctx)
def upload_handler(request):
view_url = reverse('image_recognition.views.upload_handler')
recognized = None
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
instance = UploadModel(file=request.FILES['file'])
instance.save()
return HttpResponseRedirect(view_url)
files = UploadModel.objects.all()
if files:
last = UploadModel.objects.latest('file')
file_path = settings.MEDIA_ROOT + last.file.name
recognized = subprocess.check_output(["/usr/bin/gocr", file_path])
files.delete()
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return render_to_response(
'image_recognition/upload.html',
{'form': form, 'upload_url': upload_url,
'upload_data': upload_data, 'recognized': recognized},
context_instance=RequestContext(request)
)
def upload_handler(request):
context = RequestContext(request)
view_url = reverse('handle_requests.views.upload_handler')
username = request.POST['username']
password = request.POST['password']
file_name = request.POST['file_name']
size = request.POST['size']
path = request.POST['path']
user_id = check_auth(username, password, request)
print "USER ID: " + str(user_id)
if (user_id != -1):
view_url = reverse('handle_requests.views.upload_handler')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
file_object = File(name=file_name,
path=path,
user_id=user_id,
size=size)
file_object.save()
mod = Modification(file_id=file_object.pk,
user_id=user_id,
mod_type='add')
mod.save()
return render(request, 'handle_requests/upload.html', {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data
})
else:
return render(request, 'status.html', {'status': 'failure'})
def upload_handler(request,pk=None,entityID=None):
view_url = reverse('google_dependency.blobstore_handler.upload_handler')
absolute_url = '/resource/'
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
entityID = request.POST['entityID']
logger.debug('entityID: ' + entityID)
param={}
if form.is_valid():
obj = form.save()
return HttpResponseRedirect(absolute_url+str(obj.pk) + '/' + entityID)
elif request.method == 'GET':
upload_url, upload_data = prepare_upload(request, view_url)
resource_url ={}
thumbnail_url = {}
if pk != None:
resource_url= generate_resource_URL(request,pk,'440','0')
thumbnail_url= generate_resource_URL(request,pk,'50','1')
param={'upload_url': upload_url,
'upload_data': upload_data,
'resource_url' : resource_url,
'thumbnail_url' : thumbnail_url,
'pk' : pk
}
#form = UploadForm()
return direct_to_template(request, 'filetransferForm.html',param)
def create_montage(request):
if request.method == 'POST':
form = MontageCreateForm(request.POST, request.FILES)
print(dir(form))
if form.is_valid():
print("hello")
montageElementContainer = MontageElementContainer(title = request.POST['title'])
montageElementContainer.save()
for file in request.FILES.getlist('files'):
montageElement = MontageElement(video_file=file, container=montageElementContainer)
montageElement.save()
# contextDict for data to be passed to next view
contextDict = {}
contextDict['title'] = request.POST['title']
contextDict['montageElementContainer'] = montageElementContainer
contextDict['uid'] = montageElementContainer.auto_increment_id
template = loader.get_template('montage_maker/builder.html')
context = RequestContext(request, contextDict)
return HttpResponse(template.render(context))
else:
#view_url = reverse('upload.views.upload_handler')
upload_url, upload_data = prepare_upload(request, 'montage_maker/builder.html')
form = MontageCreateForm()
# Render list page with the documents and the form
return render_to_response(
'montage_maker/create_montage.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data},
context_instance=RequestContext(request)
)
def create_new_user(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
form_profile = CreateProfileForm(request.POST, request.FILES)
if form.is_valid() and form_profile.is_valid():
user = form.save(commit=False)
# user must be active for login to work
user.is_active = True
user.save()
profile = form_profile.save(commit=False)
profile.user = user #User.objects.get(username__exact=request.POST['username'])
profile.save()
return HttpResponseRedirect(reverse('django.contrib.auth.views.login'))
else:
form = UserCreationForm()
form_profile = CreateProfileForm()
view_url = reverse('fotos.views.create_new_user')
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response('user_create_form.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'form_profile': form_profile,
'upload_url': upload_url,
'upload_data': upload_data}))
def create_new_user(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
form_profile = CreateProfileForm(request.POST, request.FILES)
if form.is_valid() and form_profile.is_valid():
user = form.save(commit=False)
# user must be active for login to work
user.is_active = True
user.save()
profile = form_profile.save(commit=False)
profile.user = user #User.objects.get(username__exact=request.POST['username'])
profile.save()
return HttpResponseRedirect(reverse('django.contrib.auth.views.login'))
else:
form = UserCreationForm()
form_profile = CreateProfileForm()
view_url = reverse('my.views.create_new_user')
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response('user_create_form.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'form_profile': form_profile,
'upload_url': upload_url,
'upload_data': upload_data}))
def upload_handler(request):
context = RequestContext(request)
view_url = reverse('handle_requests.views.upload_handler')
username = request.POST['username']
password = request.POST['password']
file_name = request.POST['file_name']
size = request.POST['size']
path = request.POST['path']
user_id = check_auth(username, password, request)
print "USER ID: " + str(user_id)
if(user_id!=-1):
view_url = reverse('handle_requests.views.upload_handler')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
file_object = File(name=file_name, path = path, user_id = user_id, size=size )
file_object.save()
mod = Modification(file_id = file_object.pk, user_id = user_id, mod_type='add')
mod.save()
return render(request, 'handle_requests/upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data})
else:
return render(request, 'status.html', {'status': 'failure'})
def file_upload(request):
view_url = reverse(file_upload)
if request.method == 'POST':
form = File_upload(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
sf = Student_file(course = cd['course'],
owner = request.user,
note = cd['note'],
name = cd['name'],
file_type = cd['file_type'],
year = cd['year']
)
sf.save()
return HttpResponseRedirect(reverse('engsci_conga.views.courses_view',
kwargs = {'course': str(cd['course'])}
))
else:
form = File_upload
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response('upload_form.html', {'form': form, 'upload_url': upload_url, 'upload_data': upload_data},
context_instance = RequestContext(request))
def scripts_page(request):
is_valid = False
is_post = False
exp_id = 0
view_url = '/robot_scripts_page/'
upload_url, upload_data = prepare_upload(request, view_url)
scriptstable = getScriptsTable(_user = request.user)
if scriptstable.willHandle(request):
return scriptstable.handleRequest(request)
if request.method=='POST':
is_post = True
form = RobotScriptForm (request.POST, request.FILES) #bound form to project
if form.is_valid():
is_valid = True
f=form.save(commit= False)
f.user = request.user
f.script_date = request.POST.get('date_0')
f.script_time = request.POST.get('date_1')
f=form.save(commit= True)
script = RobotScript.objects.get(pk= f.id)
#c = RequestContext(request,{'form':form,'messege':'New script submitted successfully','scriptstable':scriptstable ,'upload_url':upload_url,
# 'upload_data':upload_data,})
#c.update(csrf(request))
return HttpResponseRedirect(view_url)
else:
robotScript = RobotScript(user = request.user)
form = RobotScriptForm(instance=robotScript)
form.fields['user'].widget = django.forms.widgets.HiddenInput()
return direct_to_template(request, 'scripts_page.html',
{ 'form':form,
'is_valid':is_valid,
'is_post':is_post,
'upload_url':upload_url,
'upload_data':upload_data,
'scriptstable':scriptstable})
def add_photo(request):
if request.method == 'POST':
form = AddPhotoForm(request.POST, request.FILES)
if form.is_valid():
photo = form.save(commit=False)
blob_key = request.FILES['img'].blobstore_info._BlobInfo__key
data = blobstore.BlobReader(blob_key).read()
try:
img = images.Image(image_data=data)
photo.title = FromTranslit(form.data['title1'])
photo.album = FromTranslit(form.data['album1'])
photo.width = img.width
photo.height = img.height
photo.thumb_url = images.get_serving_url(blob_key)
photo.author = request.user
photo = form.save()
return HttpResponseRedirect(reverse('my.views.list_photos'))
except:
pass
else:
form = AddPhotoForm()
view_url = reverse('my.views.add_photo')
upload_url, upload_data = prepare_upload(request, view_url)
return direct_to_template(request, 'add_photo.html',
{'form': form,
'upload_url': upload_url,
'upload_data': upload_data})
def edit_book(request, **kw):
book_id = ZI(kw.get('id'))
book = get_object_or_404(Book, id=book_id)
if request.method == 'POST':
form = AddBookForm(request.POST, request.FILES, instance=book)
if form.is_valid():
mbook = form.save(commit=False)
if isinstance(request.user, User):
mbook.author = request.user
mbook.date = datetime.datetime.today()
mbook.save(force_update=True)
ClearBookListWrtCache(mbook.writer.id)
ClearBookListSubjCache(mbook.subject.id)
ClearBookCache(mbook.index)
return HttpResponseRedirect(reverse('books.views.read_book', kwargs={'ind': mbook.index, 'part': 0}))
else:
form = AddBookForm(initial={
'id': book.id,
'title': book.title,
'content': book.content })
upload_url, upload_data = prepare_upload(request, reverse('books.views.edit_book', kwargs={'id': book.id}))
return render_to_response('edit_book.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'focus': form['content'].id_for_label}))
def edit_book(request, **kw):
book_id = ZI(kw.get('id'))
book = get_object_or_404(Book, id=book_id)
if request.method == 'POST':
form = AddBookForm(request.POST, request.FILES, instance=book)
if form.is_valid():
mbook = form.save(commit=False)
if isinstance(request.user, User):
mbook.author = request.user
mbook.date = datetime.datetime.today()
mbook.save(force_update=True)
ClearBookListWrtCache(mbook.writer.id)
ClearBookListSubjCache(mbook.subject.id)
ClearBookCache(mbook.index)
return HttpResponseRedirect(reverse('books.views.read_book', kwargs={'ind': mbook.index, 'part': 0}))
else:
form = AddBookForm(initial={
'id': book.id,
'title': book.title,
'content': book.content })
upload_url, upload_data = prepare_upload(request, reverse('books.views.edit_book', kwargs={'id': book.id}))
return render_to_response('edit_book.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'focus': form['content'].id_for_label}))
def upload_handler(request):
view_url = reverse('handle_requests.views.upload_handler')
# print view_url
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user_id = check_auth(username, password, request)
# print "USER ID: " + str(user_id)
if user_id is not -1:
file_name = request.POST['file_name']
size = request.POST['size']
path = request.POST['path']
form = UploadForm(request.POST, request.FILES)
# print request.FILES
# print request.POST
form.save()
file_object = File(name=file_name, path = path, user_id = user_id, size=size )
file_object.save()
mod = Modification(file_id = file_object.pk, user_id = user_id, mod_type='add')
mod.save()
return render(request, 'status.html', {'status': 'upload successful'})
else:
return render(request, 'status.html', {'status': 'login failure'})
form = UploadForm()
upload_url, upload_data = prepare_upload(request, view_url)
# print upload_url
# print upload_data
return render(request, 'handle_requests/upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data})
def upload(request, class_name, id):
form = None
instance = get_class(class_name).objects.get(pk=id)
view_url = reverse('portal.files.views.upload', args=[class_name, id, ])
if request.method == 'POST':
form = UploadedFileForm(request.POST, request.FILES)
if form.is_valid():
file = form.save(commit=False)
file.content_type = ContentType.objects.get_for_model(instance)
file.object_pk = force_unicode(instance._get_pk_val())
file.user = request.user
file.save()
instance.notify_upload(request.user, file)
return HttpResponseRedirect(instance.get_absolute_url())
else:
form = UploadedFileForm()
upload_url, upload_data = prepare_upload(request, view_url)
ctx = {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
}
return direct_to_template(request, 'files/form.html', ctx)
def uploadRobotErrors(request):
view_url = '/upload_robot_errors/'
upload_url, upload_data = prepare_upload(request, view_url)
if request.method=='POST':
form = UploadForm (request.POST, request.FILES) #bound form to project
if form.is_valid():
f=form.save()
f.save()#save for reuse
for line in f.file:
params = line.split(' ### ')
msg_id = params[0]
msg_value = params[1]
time_stamp_script = params[2]
time_stamp_error = params[3].strip()
struct_time_script = datetime.strptime(time_stamp_script, "%Y-%m-%d %H:%M:%S")
try:
time_stamp = datetime.strptime(time_stamp_error, "%Y-%m-%d %H:%M:%S")
except Exception as e:
time_stamp = struct_time_script
try:
robotError ,created = RobotError.objects.get_or_create(msg_id=msg_id,msg_value=msg_value,
script_time=struct_time_script,timeStamp = time_stamp)
except Exception as e:
pass
return HttpResponseRedirect('/')
else:
form = UploadForm()
return direct_to_template(request, 'uploadErrors.html',
{ 'form':form,
'upload_data':upload_data,
})
def experimentpage(request, exp_id,comesFromNewExp=False):
view_url = '/experiments/'+exp_id
#uploadFormForLiquidClasses = UploadForm()
is_valid = False
try:
exp = Experiment.objects.get(pk = exp_id)
except Exception as e:
raise Http404
if not request.user.is_authenticated():
return index(request,message = 'user is not logged in')
if request.method=='POST':
f = ExperimentForm (request.POST,request.FILES,instance=exp)
if f.is_valid() :
is_valid = True
exp = f.save()
else:
f= ExperimentForm(instance=exp)
f.fields["liquidClass"].queryset = LiquidClass.objects.all().order_by('name')
_man = exp.manualFile.file.file
_rob = exp.robotFile.file.file
dilsList,pipetorsCV ,dilsListForLineChart= compareManualToRobotReaderForWebApp(manualExcelFile= _man,robotExcelFile=_rob, experiment=exp)
upload_url, upload_data = prepare_upload(request, view_url)
distance = abs(exp.getMeans()-exp.volume)
c = RequestContext(request,{'exp':exp,'exp_id':exp_id,'form':f,'messege':'New experiment submitted successfully','pipetorsCV':pipetorsCV,'dilsList':dilsList,'dilsListForLineChart':dilsListForLineChart, 'upload_url':upload_url, 'upload_data':upload_data,
'comesFromNewExperiment':False,'distance':distance})
c.update(csrf(request))
return render_to_response('experiment_page.html',c)
def show_gig(request, band_id, entry_id):
context = {}
try:
band = bands_manager.get_band(band_id)
if not band.is_member(request.user):
raise Exception("You have no permission to view this band's events cause you are not a member of it.")
gig = bands_manager.get_gig(entry_id)
# calculates the band diff setlist (band setlist songs minus gig setlist songs)
diff_setlist = []
for song in band.setlist.song_list:
if not gig.setlist.contains(song):
diff_setlist.append(song)
context['diff_setlist'] = diff_setlist
context['band'] = band
context['gig'] = gig
if gig.contract is None:
view_url = reverse('project.views_gig.upload_contract', args=[band.id, gig.id])
upload_url, upload_data = prepare_upload(request, view_url)
context["contract_form"] = UploadBandFileForm()
context['contract_url'] = upload_url
context['contract_data'] = upload_data
context['form'] = True
else:
context["contract"] = gig.contract
context['form'] = False
except Exception as exc:
# 500
context['error_msg'] = "Error ocurred: %s" % exc.message
return render_to_response('band/events/gig/show.html', context, context_instance=RequestContext(request))
def detail(request, inst_slug, course_slug, disc_slug):
institution = get_object_or_404(Institution, slug__exact=inst_slug)
course = institution.course_set.get(slug__exact=course_slug)
disc = course.discipline_set.get(slug__exact=disc_slug)
msg_form = MessageForm(disc)
upload_url, upload_data = prepare_upload(request, reverse("portal.messages.views.attach_file"))
ctx = {
"request": request,
"discipline": disc,
"photo_count": 0,
"course": course,
"institution": institution,
"files": UploadedFile.objects.for_model(disc).order_by("date_published").all(),
"next": reverse("portal.disciplines.views.detail", args=[inst_slug, course_slug, disc_slug]),
"msg_form": msg_form,
"attach_form": AttachmentForm(),
"upload_url": upload_url,
"upload_data": upload_data,
"MODERATE_REGISTRATION": disc.registration_type == MODERATE_REGISTRATION,
"EVERYONE_CAN_REGISTER": disc.registration_type == EVERYONE_CAN_REGISTER,
"PUBLIC_ACCESS": disc.access_type == PUBLIC_ACCESS,
}
albums = Album.objects.for_model(disc)
if albums.exists():
ctx["albums"] = albums.all()
qtd = 0
for album in albums:
qtd += album.picture_album_set.count()
ctx["photo_count"] = qtd
return direct_to_template(request, "disciplines/detail.html", ctx)
def index(request):
"""first page. will show a nice UI and an imagefield."""
# preparing the app engine specific crap.
view_url = reverse('main.views.show_image')
upload_url, upload_data = prepare_upload(request, view_url)
form = forms.UploadForm()
return render_to_response('index.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data},
context_instance=RequestContext(request))
def __prepare_context(request, band):
context = {}
context['band'] = band
view_url = reverse('upload-band-file', args=[band.id])
upload_url, upload_data = prepare_upload(request, view_url)
context['upload_form'] = UploadBandFileForm()
context['upload_url'] = upload_url
context['upload_data'] = upload_data
return context
def upload_handler(request):
view_url = '/upload/'
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return direct_to_template(request, 'upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data})
def get(self, request, *args, **kwargs):
log.debug("in PhotoUploadView.get: args=%s, kwargs=%s"%(args, kwargs))
target_url = reverse('photo-upload-user', kwargs={'pk':kwargs['pk'],'user_id':self.user.id})
log.debug("Target URL: %s"%(target_url,))
upload_url, upload_data = prepare_upload(request, target_url)
log.debug("Upload URL: %s"%(upload_url,))
#upload_url = blobstore.create_upload_url(target_url)
result = {'upload_url':upload_url, 'target_url': target_url}
log.debug("Result: %s"%(result,))
return result
def __prepare_context(request, band, song):
context = {}
context["band"] = band
context["song"] = song
view_url = reverse("upload-song-file", args=[band.id, song.id])
upload_url, upload_data = prepare_upload(request, view_url)
context["song_form"] = UploadBandFileForm()
context["song_url"] = upload_url
context["song_data"] = upload_data
return context
def admin_bg_image(request):
view_url = reverse('cms.views.admin_bg_image')
if request.method == 'POST':
form = BackgroundImageForm(request.POST, request.FILES)
if form.is_valid():
user = users.get_current_user()
bg_image_form = form.save(commit=False)
bg_image_form.author = user
bg_image_form.file_name = request.FILES['image']
bg_image_form.save()
#bg_image_form.content_type = ('image/' + (str(request.FILES['image'])).partition('.')[2]).lower
bg_image = BackgroundImage.objects.get(id=bg_image_form.id)
blob_key = bg_image.image.file.blobstore_info.key()._BlobKey__blob_key
img = images.Image(blob_key=blob_key)
bg_image.blob_key = blob_key
bg_image.url = images.get_serving_url(blob_key)
bg_image.url_thumb = images.get_serving_url(blob_key, 200)
bg_image.save()
#bg_image = BackgroundImage.objects.get(id=bg_image_form.id)
#file_name = files.blobstore.create(mime_type='application/octet-stream')
#with files.open(file_name, 'a') as f:
# f.write(bg_image.image)
#files.finalize(file_name)
#blob_key = files.blobstore.get_blob_key(file_name)
#bg_image.thumb_content_type = ('image/png').lower
#bg_image.save()
return HttpResponseRedirect('/admin/bg_image?message=' + 'Updated')
else:
form = BackgroundImageForm()
upload_url, upload_data = prepare_upload(request, view_url)
form = BackgroundImageForm()
#bg_images = BackgroundImage.objects.all().values('id', 'title', 'author', 'file_name', 'content_type', 'date_inserted' )
bg_images = BackgroundImage.objects.all().values()
return render_to_response('admin_bg_image.html', {
'form': form,
'bg_images': bg_images,
'upload_url': upload_url,
'upload_data': upload_data,
}, context_instance=RequestContext(request))
def add_book(request):
if request.method == 'POST':
form = AddBookForm(request.POST, request.FILES)
form_wrt = AddWrtForm(request.POST)
form_subj = AddSubjForm(request.POST)
if form.is_valid() and form_wrt.is_valid() and form_subj.is_valid():
book = form.save(commit=False)
writer = form_wrt.save(commit=False)
subject = form_subj.save(commit=False)
for f in ['img', 'file']:
if f in request.FILES: # check duplicates
if book.part == 0:
o = request.FILES[f]
for blob in blobstore.BlobInfo.gql("WHERE filename = '%s'" % (o.name.replace("'","''"),)):
if blob.key() != o.blobstore_info.key(): blob.delete()
else:
book.file = None
book.img = None
if isinstance(request.user, User):
book.author = request.user
# uniques
book.index = abs(zlib.crc32(writer.writer.encode('utf-8') + ' ' + book.title.encode('utf-8')))
# writer
book_list = Book.objects.filter(index=book.index)
if len(book_list): # check writer once
wrt = book_list[0].writer
subj = book_list[0].subject
else:
wrt = IncWrtCount(writer=writer.writer)
subj = IncSubjCount(subject=subject.subject)
book.writer = wrt
book.subject = subj
# if unique
book_list = Book.objects.filter(Q(index=book.index)&Q(part=book.part))
if len(book_list) == 0:
book.save()
ClearWrtListCache(wrt.writer[0].capitalize())
ClearBookListWrtCache(wrt.id, wrt.count)
ClearBookListSubjCache(subj.id, subj.count)
ClearBookCache(book.index, book.part)
return HttpResponseRedirect(reverse('books.views.list_books'))
else:
form = AddBookForm()
form_wrt = AddWrtForm()
form_subj = AddSubjForm()
upload_url, upload_data = prepare_upload(request, reverse('books.views.add_book'))
return render_to_response('add_book.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'form_wrt': form_wrt,
'form_subj': form_subj,
'upload_url': upload_url,
'upload_data': upload_data,
'focus': form_wrt['writer'].id_for_label}))
def add_photo(request):
if request.method == 'POST':
form = AddPhotoForm(request.POST, request.FILES)
if form.is_valid():
photo = form.save(commit=False)
try:
if 'thumb_url' in form.data:
photo.thumb_url = form.data['thumb_url']
if request.FILES.get('img'):
blob_key = request.FILES[
'img'].blobstore_info._BlobInfo__key
photo.thumb_url = images.get_serving_url(blob_key)
# data = blobstore.BlobReader(blob_key).read()
# img = images.Image(image_data=data)
o = request.FILES['img']
for blob in blobstore.BlobInfo.gql(
"WHERE filename = '%s'" %
(o.name.replace("'", "''"), )):
if blob.key() != o.blobstore_info.key(
) and blob.md5_hash == o.blobstore_info.md5_hash:
blob.delete()
if 'title1' in form.data:
photo.title = FromTranslit(form.data['title1'])
if 'album1' in form.data:
photo.album = FromTranslit(form.data['album1'])
if 'user' in form.data:
usr = User.objects.filter(username=form.data['user'])
if usr.count():
photo.author = usr[0]
if isinstance(request.user, User):
photo.author = request.user
photo.date = timezone.now()
photo = form.save()
ClearPhotosListCache(photo.album)
UpdateAlbumListCache(photo)
return HttpResponseRedirect(
reverse('my.views.list_photos',
kwargs={'id_album': photo.id}))
except:
pass
else:
form = AddPhotoForm()
view_url = reverse('my.views.add_photo')
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response('add_photo.html',
context_instance=RequestContext(
request, {
'request': request,
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'focus': form['title'].id_for_label
}))
def upload(request):
view_url = reverse('gproject:upload')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return render(request, 'gproject/upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data,
'uploads': UploadModel.objects.all()})
def admin_bg_image_edit(request, bg_image_id=None):
view_url = reverse('cms.views.admin_bg_image') #.'+bg_image_id)
view_url = view_url + 'edit/' + str(bg_image_id) # FFS!
if request.method == 'POST':
bg_image = BackgroundImage.objects.get(id=bg_image_id)
form = BackgroundImageForm(instance=bg_image, data=request.POST, files=request.FILES)
if form.is_valid():
user = users.get_current_user()
bg_image_form = form.save(commit=False)
bg_image_form.author = user
if 'image' in request.FILES: #and request.FILES['image'] is True:
bg_image_form.file_name = request.FILES['image']
bg_image_form.save()
bg_image = BackgroundImage.objects.get(id=bg_image_form.id)
blob_key = bg_image.image.file.blobstore_info.key()._BlobKey__blob_key
img = images.Image(blob_key=blob_key)
bg_image.blob_key = blob_key
bg_image.url = images.get_serving_url(blob_key)
bg_image.url_thumb = images.get_serving_url(blob_key, 200)
bg_image.save()
key = 'bg_image_serve' + '-' + str(bg_image.id)
#### memcache.delete(key)
## TODO memcache.add() here
## Noel 07828 510 920
return HttpResponseRedirect('/admin/bg_image/?message=' + urllib.quote_plus('Image has been updated') )
else:
bg_image = BackgroundImage.objects.get(id=bg_image_id)
form = BackgroundImageForm(instance=bg_image)
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response('admin_bg_image_edit.html', {
'form': form,
'bg_image': bg_image,
'upload_url': upload_url,
'upload_data': upload_data,
}, context_instance=RequestContext(request))
def upload_handler(request):
view_url = reverse('upload.views.upload_handler')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return direct_to_template(request, 'upload/upload.html',
{'form': form, 'upload_url': upload_url, 'upload_data': upload_data,
'uploads': UploadModel.objects.all()})
def add(request):
if request.method == 'POST':
formData = ArticleForm(request.POST, request.FILES)
if formData.is_valid():
edited = formData.save(commit=False)
edited.user = request.user
edited.save()
return redirect("list")
view_url = reverse("add")
upload_url, upload_data = prepare_upload(request, view_url)
return render(request, "add.html", {"form": ArticleForm, "action": "Add new", 'upload_url': upload_url, 'upload_data': upload_data})
def upload_handler(request, obj_pk=None, ctype_pk=None):
view_url = reverse('pirate_sources.views.upload_handler',
args=[obj_pk, ctype_pk])
if request.method == 'POST':
form = IMGSourceForm(request.POST, request.FILES)
if form.is_valid():
img = form.save()
img.user = request.user
img.object_pk = obj_pk
img.content_type = ContentType.objects.get(pk=ctype_pk)
img.submit_date = datetime.datetime.now()
#file_content = ContentFile(request.FILES['file'].read())
#img.file.save(str(img.object_pk) + '_' + str(img.content_type), file_content)
img.make(request.FILES['file'], img.file.name)
#photo_key = str(img.file.file.blobstore_info.key())
url = img.file.path
if img.private != True:
try:
oldimg = IMGSource.objects.get(object_pk=obj_pk,
current=True)
oldimg.current = False
oldimg.save()
except:
pass
img.current = True
img.url = url
img.save()
else:
view_url += '?error=Not a valid image'
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = IMGSourceForm()
uploads = IMGSource.objects.filter(object_pk=obj_pk)
ctypemod = ContentType.objects.get(pk=ctype_pk)
m = ctypemod.model_class()
obj = m.objects.get(pk=obj_pk)
return direct_to_template(
request, 'upload.html', {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'object': obj,
'uploads': uploads,
'obj_pk': obj_pk,
'ctype_pk': ctype_pk,
'error': request.GET.get('error')
})
def upload_handler(request):
view_url = reverse('upload.views.upload_handler')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return render_to_response('upload/upload.html',
{'request': request,
'form': form,
'upload_url': upload_url,
'upload_data': upload_data})
def upload_handler(request):
view_url = reverse('upload.views.upload_handler')
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadForm()
return render_to_response(
'upload/upload.html', {
'request': request,
'form': form,
'upload_url': upload_url,
'upload_data': upload_data
})
def new_experiment(request):
'''experiments = Experiment.objects.all().order_by('-startdate')[:5]
tasks = Task.objects.all().order_by('-startdate')[:5]
reagents = Reagent.objects.all().order_by('-createdate')[:5]
plates = Plate.objects.all().order_by('-timestamp')[:5]'''
is_valid = False
is_post = False
exp_id = 0
view_url = '/new_experiment/'
upload_url, upload_data = prepare_upload(request, view_url)
if request.method=='POST':
is_post = True
form = ExperimentForm (request.POST, request.FILES) #bound form to project
form.fields["liquidClass"].queryset = LiquidClass.objects.all().order_by('name')
if form.is_valid():
is_valid = True
f=form.save(commit= False)
f.user = request.user
f=form.save(commit= True)
exp = Experiment.objects.get(pk= f.id)
exp_id = exp.id
# uploadFileFromWebClient(request,exp,AMAZONE_URL,'manualFile')
_man = f.manualFile.file.file
_rob = f.robotFile.file.file
dilsList,pipetorsCV ,dilsListForLineChart= compareManualToRobotReaderForWebApp(manualExcelFile= _man,robotExcelFile=_rob, experiment=exp)
exp.grade = getAverageCV(pipetorsCV)
exp.means = exp.getMeans()
exp.distance = exp.getDistance()
exp.save()
distance = abs(exp.getMeans()-exp.volume)
c = RequestContext(request,{'exp':exp,'exp_id':exp_id,'form':form,'messege':'New experiment submitted successfully','pipetorsCV':pipetorsCV,'dilsList':dilsList,'dilsListForLineChart':dilsListForLineChart, 'upload_url':upload_url,
'upload_data':upload_data,'comesFromNewExperiment':True,'distance':distance})
c.update(csrf(request))
return render_to_response('experiment_page.html',c)
#return HttpResponseRedirect('experiment_page.html',c)
else:
form = ExperimentForm()
form.fields["liquidClass"].queryset = LiquidClass.objects.all().order_by('name')
return direct_to_template(request, 'new_experiment.html',
{ 'form':form,
'is_valid':is_valid,
'is_post':is_post,
'exp_id':exp_id,
'upload_url':upload_url,
'upload_data':upload_data,
})
def add_book(request):
if request.method == 'POST':
form = AddBookForm(request.POST, request.FILES)
form_wrt = AddWrtForm(request.POST)
form_subj = AddSubjForm(request.POST)
if form.is_valid() and form_wrt.is_valid() and form_subj.is_valid():
book = form.save(commit=False)
writer = form_wrt.save(commit=False)
subject = form_subj.save(commit=False)
for f in ['file']:
if f in request.FILES: # check duplicates
o = request.FILES[f]
for blob in blobstore.BlobInfo.gql("WHERE filename = '%s'" % (o.name.replace("'","''"),)):
if blob.key() != o.blobstore_info.key(): blob.delete()
if isinstance(request.user, User):
book.author = request.user
# uniques
book.index = abs(zlib.crc32(writer.writer.encode('utf-8') + ' ' + book.title.encode('utf-8')))
book_list = Book.objects.filter(Q(index=book.index))
if len(book_list) == 0:
book.writer = IncWrtCount(writer=writer.writer)
book.subject = IncSubjCount(subject=subject.subject)
book.save()
ClearWrtListCache(book.writer.writer[0].capitalize())
ClearBookListWrtCache(book.writer.id)
ClearBookListSubjCache(book.subject.id)
ClearBookCache(book.index)
return HttpResponseRedirect(reverse('books.views.list_books'))
else:
edit_book(request, id=book_list[0].id)
else:
form = AddBookForm()
form_wrt = AddWrtForm()
form_subj = AddSubjForm()
upload_url, upload_data = prepare_upload(request, reverse('books.views.add_book'))
return render_to_response('add_book.html',
context_instance=RequestContext(request,
{'request': request,
'form': form,
'form_wrt': form_wrt,
'form_subj': form_subj,
'upload_url': upload_url,
'upload_data': upload_data,
'focus': form_wrt['writer'].id_for_label}))
def upload_handler(request):
view_url = reverse('up5.upload_test.views.upload_handler')
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url)
form = UploadFileForm()
print(request.user.social_auth.get().extra_data)
return direct_to_template(
request, 'upload2.html', {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'uploads': reversed(UploadFileModel.objects.all()),
'user': request.user.social_auth.all()
})
def upload_handler(request):
extra_data = request.user.social_auth.get()
print(extra_data.extra_data)
view_url = reverse('upload.views.upload_handler')
names = request.user.social_auth.values_list('provider', flat=True)
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
form.save()
return HttpResponseRedirect(view_url)
upload_url, upload_data = prepare_upload(request, view_url, private=True)
form = UploadForm()
return direct_to_template(
request, 'upload.html', {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'uploads': UploadModel.objects.all(),
'names': names
})
def image_upload(request):
view_url = reverse('blog.views.image_upload')
if request.method == 'POST': # If the form has been submitted...
form = ImageForm(request.POST, request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
image = form.save()
return HttpResponseRedirect('/image/info/' + str(image.pk)) # Redirect after POST
else:
form = ImageForm()
upload_url, upload_data = prepare_upload(request, view_url)
t = loader.get_template('image_upload.html')
c = RequestContext(request,{
'form': form,
'title': 'Image Upload',
'upload_url': upload_url,
'upload_data': upload_data
})
return HttpResponse(t.render(c))
def render_change_form(self,
request,
context,
add=False,
change=False,
form_url='',
obj=None,
has_file_field=True):
opts = self.model._meta
app_label = opts.app_label
ordered_objects = opts.get_ordered_objects()
if has_file_field:
if not form_url:
form_url = request.get_full_path()
form_url, upload_data = prepare_upload(request, form_url)
context.update({
'file_upload_data':
self.get_filetransfer_data(upload_data),
})
context.update({
'add':
add,
'change':
change,
'has_add_permission':
self.has_add_permission(request),
'has_change_permission':
self.has_change_permission(request, obj),
'has_delete_permission':
self.has_delete_permission(request, obj),
'has_file_field':
has_file_field,
'has_absolute_url':
hasattr(self.model, 'get_absolute_url'),
'ordered_objects':
ordered_objects,
'form_url':
mark_safe(form_url),
'opts':
opts,
'content_type_id':
ContentType.objects.get_for_model(self.model).id,
'save_as':
self.save_as,
'save_on_top':
self.save_on_top,
'root_path':
self.admin_site.root_path,
})
if add and self.add_form_template is not None:
form_template = self.add_form_template
else:
form_template = self.change_form_template
context_instance = template.RequestContext(
request, current_app=self.admin_site.name)
return render_to_response(form_template or [
"admin/%s/%s/change_form.html" %
(app_label, opts.object_name.lower()),
"admin/%s/change_form.html" % app_label, "admin/change_form.html"
],
context,
context_instance=context_instance)