def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
newdoc = Upload(filePath=request.FILES['docfile'])
newdoc.owner = request.user
#Overwrite file if already exist.
'''documents = Upload.objects.filter(owner=request.user)
if documents:
#print os.path.join(MEDIA_ROOT, documents[0].filePath.name)
os.remove(os.path.join(MEDIA_ROOT, documents[0].filePath.name))
documents.delete()'''
newdoc.save()
# Redirect to the document list after POST
return HttpResponseRedirect(reverse('upload.views.upload'))
else:
form = UploadForm()
documents = Upload.objects.filter(owner=request.user)
return render_to_response('upload/upload.html', {
'form': form,
'documents': documents
},
context_instance=RequestContext(request))
def test_base64(user):
data = BytesIO(b'Hello')
with patch('upload.s3.s3.get', return_value=data.read()):
res = Upload(user=user,
original_filename='blop',
content_type='image/png').to_base64()
assert res == 'image/png;base64,SGVsbG8='
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
path = handle_uploaded_file(request.FILES['file'], request.user)
local_name = request.FILES['file'].name
local_name = local_name.split("/")[-1]
up = Upload(local_name=local_name, remote_path = path, user=request.user, type=request.POST['type'])
up.save()
return HttpResponseRedirect("/upload/")
else:
form = UploadForm()
return render(request, 'upload/upload.html', {'form': form})
def uploadAssignment(request, assignmentID):
if request.method == 'POST':
assignment = get_object_or_404(Assignment, pk=assignmentID)
form = UploadForm(request.POST,
request.FILES,
assignment_model_obj=assignment)
if form.is_valid():
newUpload = Upload(owner=request.user,
assignment=assignment,
filePath=request.FILES['docfile'])
newUpload.save()
else:
return form.errors
def file_upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
username = request.user.username
filename=form.cleaned_data['file_url']
file_url=form.cleaned_data['file_url']
#pdb.set_trace()
efile_upload=Upload()
efile_upload.user_name=username
efile_upload.title_name = filename
efile_upload.file_url = file_url
efile_upload.file_size=request.FILES['file_url'].size # Get the size of uploaded file from file's object
efile_upload.save()
#return HttpResponse(str(filename)+' had uploaded Success')
messages.success(request,'上传成功')
else:
form = UploadForm()
return render(request, 'upload/upload.html', {'form': form})
def profile(request):
if request.method == 'POST':
image_file = request.FILES['image_file']
image_type = request.POST['image_type']
if settings.USE_S3:
if image_type == 'private':
upload = UploadPrivate(file=image_file)
else:
upload = Upload(file=image_file)
upload.save()
image_url = upload.file.url
else:
fs = FileSystemStorage()
ext = image_file.name.split('.')[-1]
_filename = "%s.%s" % (uuid.uuid4(), ext)
filename = fs.save(_filename, image_file)
image_url = fs.url(filename)
return render(request, 'profile.html', {'image_url': image_url})
return render(request, 'profile.html')
def list_file(request):
# file upload view
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
newfile = Upload(upload_file = request.FILES['upload_file'],username=request.user.username)
newfile.save()
# Redirect to the file list after POST
return HttpResponseRedirect('')
else:
form = UploadForm() # A empty, unbound form
# Load documents for the list page
files = Upload.objects.all().filter(username = request.user.username)
# Render list page with the documents and the form
return render_to_response(
'upload/list_file.html',
{'files': files, 'form': form},
context_instance=RequestContext(request)
)
def test_stored_size(user):
with patch('upload.s3.S3.file_size', return_value=1234):
res = Upload(user=user,
original_filename='blop',
content_type='image/png').stored_size
assert res == 1234
def detailsAssignment(request, assignmentID):
assignment = get_object_or_404(Assignment, pk=assignmentID)
course = assignment.course
course_history = CourseHistory.objects.get(course_id=course,
user_id=request.user.id)
course_info = CourseInfo.objects.get(pk=course.course_info_id)
is_creator = isCourseCreator(course, request.user)
is_moderator = isCourseModerator(course, request.user)
has_joined = CourseHistory.objects.filter(course_id=course,
user_id=request.user.id)
if assignment.late_submission_allowed:
submission_allowed = (timezone.now() <=
assignment.hard_deadline) and bool(has_joined)
else:
submission_allowed = (timezone.now() <=
assignment.deadline) and bool(has_joined)
is_due = (timezone.now() >= assignment.deadline) # and bool(has_joined)
if request.method == "POST" and submission_allowed:
form = UploadForm(request.POST,
request.FILES,
assignment_model_obj=assignment)
if form.is_valid():
older_upload = Upload.objects.filter(owner=request.user,
assignment=assignment)
if older_upload:
older_upload[0].delete()
newUpload = Upload(owner=request.user,
assignment=assignment,
filePath=request.FILES['docfile'])
newUpload.save()
return HttpResponseRedirect(
reverse('assignments_details',
kwargs={'assignmentID': assignmentID}))
else:
form = UploadForm()
perror_ctype = ContentType.objects.get_for_model(ProgramErrors)
terror_ctype = ContentType.objects.get_for_model(TestcaseErrors)
program_errors = []
test_errors = []
for error in AssignmentErrors.objects.filter(assignment=assignment,
content_type=terror_ctype):
test_errors.extend(TestcaseErrors.objects.filter(pk=error.object_id))
for error in AssignmentErrors.objects.filter(assignment=assignment,
content_type=perror_ctype):
program_errors.extend(ProgramErrors.objects.filter(pk=error.object_id))
course = assignment.course
programs = Program.objects.filter(assignment=assignment)
#test_cases = Testcase.objects.filter(program__in=programs)
practice_program = [
a_program for a_program in programs
if a_program.program_type == "Practice"
]
programs_with_errors = []
for aprogram in programs:
if not aprogram.is_sane:
try:
p_error = ProgramErrors.objects.get(program=aprogram)
programs_with_errors.append(p_error)
except ProgramErrors.DoesNotExist:
p_error = None
submittedFiles = Upload.objects.filter(owner=request.user,
assignment=assignment)
program_not_ready = False
disable_grading = False
if programs_with_errors or submission_allowed == False:
program_not_ready = True
if (submittedFiles and submittedFiles[0].is_stale):
disable_grading = True
all_assignments = Assignment.objects.filter(
course=course).order_by('-serial_number')
if request.user == assignment.creater:
assignments = all_assignments
else:
assignments = [
a for a in all_assignments if a.publish_on <= timezone.now()
]
total_sumissions = Upload.objects.filter(assignment=assignment).count()
isSubmitted = Upload.objects.filter(assignment=assignment).count() > 0
get_params = {'source': 'assignment', 'id': assignmentID}
return render_to_response(
'assignments/details.html',
{
'assignment': assignment,
'course': course,
'has_joined': has_joined,
'is_moderator': is_moderator,
'programs': programs,
'form': form,
'submission_allowed': submission_allowed,
'submittedFiles': submittedFiles,
'programs_with_errors': programs_with_errors,
'disable_grading': disable_grading,
'program_not_ready': program_not_ready,
'practice_program': practice_program,
'assignments': assignments,
'program_errors': program_errors,
'test_errors': test_errors,
'published': assignment.publish_on <= timezone.now(),
'is_due': is_due,
'isSubmitted': isSubmitted,
'date_time': timezone.now(),
'get_params': get_params,
'total_sumissions': total_sumissions
},
context_instance=RequestContext(request),
)
