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 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 submit_ids(user: User):
"""
Route to create ids upload package.
User must be in `INFO_VERIFIED` state.
Will transition user to `ID_NOT_VERIFIED`
One should call `/v1/ids/<id>/verify` in order to actually start verification process (see docs there)
"""
if user.state != INFO_VERIFIED:
raise InvalidState(user.state)
schema = Schema(
{
'upload1':
Coerce(ObjectId),
'upload2':
Coerce(ObjectId),
'doc_type':
In(DOC_TYPES),
'doc_country':
All(Length(2, 2), str),
Optional('doc_state', default=None):
Any(None, All(Length(2, 20), str)),
},
extra=REMOVE_EXTRA,
required=True)
data = schema(request.json)
upload1 = Upload.objects(user=user, id=data['upload1']).get()
upload2 = Upload.objects(user=user, id=data['upload2']).get()
try:
if not (upload1.stored_size <= 4 * 1024 * 1024):
raise ValidationError('Invalid image size')
if not (upload2.stored_size <= 4 * 1024 * 1024):
raise ValidationError('Invalid image size')
except KeyError as err:
raise MissingFile(str(err))
id_upload = IDUpload.create(
user=user,
upload1=upload1,
upload2=upload2,
doc_country=data['doc_country'],
doc_state=data['doc_state'],
doc_type=data['doc_type'],
)
user.update(doc_type=data['doc_type'])
user.transition(ID_NOT_VERIFIED)
return jsonify(id_upload.to_json()), 201
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 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 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 export_async(update: telegram.Update, state: str):
now = datetime.datetime.utcnow().isoformat()
filename = f'Export.{now}.{ObjectId()}.csv'
signed_url = s3.sign_url(filename, method='GET', expire=1800)
with StringIO() as fh:
export_count = export(fh, state=state)
fh.seek(0)
Upload.upload(fh.read(), filename, 'text/csv')
update.message.reply_text(
f'Exported *{export_count}* users to {signed_url}',
parse_mode=telegram.ParseMode.MARKDOWN,
quote=False,
)
def inner(user: User, **kwargs) -> Upload:
return Upload.create(
user=user,
original_filename=kwargs.get('filename', 'example.jpg'),
content_type=kwargs.get('content_type', 'image/jpg'),
size=kwargs.get('size', 5 * 1024),
)
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 new_upload(user: User):
schema = Schema(
{
'filename': All(Length(3, 250), str),
'content_type': All(Length(5, 20), str),
'size': Range(100, 4 * 1024 * 1024), # 400KB..4MB
},
extra=REMOVE_EXTRA,
required=True)
data = schema(request.json)
try:
ext = data['filename'].split('.')[1].lower()
except:
raise ValidationError('Invalid file')
# if ext not in ['gif', 'jpeg', 'jpg', 'png']:
# raise ValidationError('Invalid file')
upload = Upload.create(
user=user,
original_filename=data['filename'],
content_type=data['content_type'],
size=data['size'],
)
return jsonify({'put_url': upload.put_url, 'id': str(upload.id)})
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_upload(service, user, token):
data = {
'filename': 'blop.jpg',
'content_type': 'image/jpeg',
'size': 500 * 1024,
}
res = service.post('/v1/upload', data, auth=token(user))
assert res.status_code == 200, res.json
upload = Upload.objects().get()
assert upload.user == user
assert upload.filename == f'{user.id}/{upload.id}.jpg'
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 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 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),
)
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),
)
