Пример #1
0
def upload_view(request):
    message = None
    if request.method == "POST":
        try:
            form = UploadImageForm(request.POST, request.FILES)
            if form.is_valid():
                cd = form.cleaned_data
                uploadImage = UploadImage(image=cd['image'],
                                          category=cd['category'],
                                          title=cd['title'],
                                          user=request.user)

                uploadImage.save()
                return HttpResponseRedirect("/")
            else:
                message = str(form.errors)
        except:
            if os.path.exists(
                    os.path.join(settings.MEDIA_ROOT, cd['image'].path)):
                os.remove(os.path.join(settings.MEDIA_ROOT, cd['image'].path))
            message = str(sys.exc_info()[1])

    form = UploadImageForm()
    return render_to_response(
        register_path,
        RequestContext(request, {
            "message": message,
            "form": form
        }))
Пример #2
0
def images(request):
    """
    view untuk menampilkan daftar images
    yang diupload user & mekanisme upload
    """
    if request.POST:
        form = UploadImageForm(request.POST, request.FILES,
            initial={'user': request.user})
        if form.is_valid():
            if not request.user.has_perm('accounts.add_imageitem'):
                messages.error(request,
                _("Unvalidated user can not upload any images"))
                return HttpResponseRedirect(reverse('images'))
            title = form.cleaned_data['title']
            image = form.cleaned_data['image']
            ImageItem.objects.create(user=request.user, title=title,
                image=image)
            messages.info(request, _('Image Uploaded'))
            return HttpResponseRedirect(reverse('images'))
    else:
        form = UploadImageForm(initial={'user': request.user})
    images_list = ImageItem.objects.filter(user=request.user)
    return render_to_response('accounts/images.html',
            {'form': form,
                'images': images_list},
            context_instance=RequestContext(request))
Пример #3
0
def process_image(request):
    if request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            img = form.cleaned_data['file']
            tf = transformImage()
            data = tf.pre_process_img(img)
            results = tf.greyscale_to_ascii(data)  # results contain result_white and result_black
            display_white = "\n"
            display_black = "\n"
            #convert the whole array into a string to avoid re-formatting
            for row in results[0]:  # result_white
                for char in row:
                    display_white += char
                display_white += "\n"
            request.session["display_white"] = display_white  # store display_white into request session

            for row in results[1]:  # result_black
                for char in row:
                    display_black += char
                display_black += "\n"
            request.session["display_black"] = display_black # store display_black into request session

            request.session['display'] = display_white  # by default, display white ascii art
            request.session["color"] = "white"
        else:
            print "uploading image failed"
    else:
        form = UploadImageForm() 
    return render(request, 'asciiart/success.html')
Пример #4
0
def add_new_action(request, experience_id):
    """
    Handle the file upload for a new action
    :param request:
    :param exp_id: The experience id linked to the action
    :return:
    """
    user = get_object_or_404(User, id=request.user.id)
    exp = get_object_or_404(Experience, id=experience_id)
    action = Action(experience=exp, date_performed=datetime.now().strftime("%Y-%m-%d %H:%M"))
    if request.method == "POST":
        image_form = UploadImageForm(request.POST, request.FILES)
        comment_form = UploadCommentForm(request.POST)
        if not image_form.is_valid() and not comment_form.is_valid():
            return render(request, 'webinator/error.html', {'error_id': "2"})
        if image_form.is_valid():
            image = image_form.save()
            action.photo = image
        if comment_form.is_valid():
            comment = comment_form.save()
            action.comment = comment

        action.save()
        #return HttpResponseRedirect(reverse('action_list', args=[experience_id]))
        return HttpResponseRedirect(reverse('index'))

    else:
        return render(request, 'webinator/new_action.html', {
            'image_form': UploadImageForm(),
            'comment_form': UploadCommentForm()
        }
        )
def upload_file1(request):
    form = UploadImageForm(request.POST, request.FILES)
    if form.is_valid():
        img = request.POST.get("imageData", "")
        base64Image1 = base64.b64encode(form.cleaned_data['image'].read())
        # print(base64Image)

    return render(request, 'app.html', {'form': UploadImageForm, 'image1': displayImage(base64Image1), 'ops': OperationsForm, 'imageData':img, 'imageData1':base64Image1})
Пример #6
0
 def post(self, request):
     image_form = UploadImageForm(request.POST,
                                  request.FILES,
                                  instance=request.user)
     if image_form.is_valid():
         request.user.save()
         return HttpResponse('{"status":"success","msg":"修改成功"}',
                             content_type='application/json')
     else:
         return HttpResponse('{"status":"fail","msg":"修改失败"}',
                             content_type='application/json')
Пример #7
0
 def post(self, request):
     imageForm = UploadImageForm(request.POST, request.FILES, instance=request.user)
     res = {}
     if imageForm.is_valid():
         imageForm.save()
         res['status'] = 'success'
         res['msg'] = '头像修改成功!'
     else:
         res['status'] = 'fail'
         res['msg'] = '头像修改失败!'
     return HttpResponse(json.dumps(res), content_type='application/json')
Пример #8
0
 def post(self, request):
     image_form = UploadImageForm(request.POST,
                                  request.FILES,
                                  instance=request.user)  # 文件类型需要第二个参数
     if image_form.is_valid():
         image_form.save()
         return HttpResponse('{"status":"success"}',
                             content_type="application/json")
     else:
         return HttpResponse('{"status":"fail"}',
                             content_type="application/json")
Пример #9
0
def upload_img():
    form = UploadImageForm()
    if form.validate_on_submit():
        pic = form.file.data
        filename = generate_filename(Image, secure_filename(pic.filename))
        mimetype = pic.mimetype
        img = Image(filename=filename, img=pic.read(), mimetype=mimetype)
        db.session.add(img)
        db.session.commit()
        return redirect(f"{request.url_root}/admin/image/")
    return render_template("upload-img.html", form=form, logged_in=True)
Пример #10
0
 def post(self, request):
     image_form = UploadImageForm(request.POST,
                                  request.FILES,
                                  instance=request.user)  # 文件类型须传递这两个参数
     if image_form.is_valid():
         # image = image_form.cleaned_data['image']
         # request.user.image = image
         # request.user.save()
         image_form.save()  # 添加一个instance=request.user能够直接保存对象
         return JsonResponse({"status": "success"})
     else:
         return JsonResponse({"status": "fail"})
Пример #11
0
def index(request):
    if request.method == "POST":
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
    else:
        form = UploadImageForm()        
    images = EditorImage.objects.all().order_by("-created")[:10]
    return render_to_response('manager_index.html',
                              {'form': form,
                               'images': images},
                              RequestContext(request))
Пример #12
0
 def post(self, request):
     image_form = UploadImageForm(request.POST,
                                  request.FILES,
                                  instance=request.user)
     if image_form.is_valid():
         # image = image_form.cleaned_data['image']
         # request.user.image = image
         request.user.save()
         return HttpResponse('{"status":"success"}',
                             content_type='application/json')
     else:
         return HttpResponse('{"status":"fail"}',
                             content_type='application/json')
Пример #13
0
def upload_photo_ajax(request):
    """View for Uploading a photo."""
    logger.info('Single image upload called by="'+str(request.user)+', ip='+str(request.META['REMOTE_ADDR']))
    if request.user.is_authenticated():
        if request.method == 'POST':
            form = UploadImageForm(request.POST, request.FILES or None)
            if form.is_valid():
                image = form.save(commit=False)
                image.user=request.user
                image.save()
                form.save_m2m()
                try:
                    default_album = get_object_or_404(Album, title="User's Posted")
                    image.albums.add(default_album)
                except:
                    logger.info('Error adding photo pk='+str(image.pk)+' to default album.')
                    pass
                logger.info('Uploaded an image title="'+str(image.title)+', by user="******"')
                if notification:
                    notification.send(User.objects.filter(is_superuser=True), "photo_add", {"ph_title":image.title,})

                return HttpResponse(unicode("Uploaded success!"))
            else: #form errors
                return render_to_response("photo/upload_photo_form_for_ajax.html", {'form': form})
        else: #get received
            form = UploadImageForm()
            return render_to_response("photo/upload_photo_form_for_ajax.html", {'form': form})
    else:
        return HttpResponse(unicode('<div class="phtitle">Please log in to upload photos!</div>'))
Пример #14
0
def search(request):
    if request.method != 'POST':
        return render_ajax(request, 'GET is not supported')

    form = UploadImageForm(request.POST, request.FILES)
    if not form.is_valid():
        return render_ajax(request, 'validate form failed')

    f = request.FILES['image']
    if f.content_type not in [ 'image/jpeg', 'image/jpg', 'image/bmp', 'image/png' ]:
        return render_ajax(request, 'format not supported')

    filename = handle_uploaded_file(f)    
    result = SearchService.search(filename, 0)

    return render_ajax(request, result=result)
Пример #15
0
def histogram(request):
    if request.method == 'GET':
        form = UploadImageForm
        return render(request, 'histogram.html', {'form': form})
    elif request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            base64Image = base64.b64encode(form.cleaned_data['image'].read())
            from histogram import Image2Histogram
            res = Image2Histogram(base64Image)
            return render(
                request, 'histogram.html', {
                    'form': UploadImageForm,
                    'image': displayImage(base64Image),
                    'result': res
                })
Пример #16
0
def negative(request):
    if request.method == 'GET':
        form = UploadImageForm
        return render(request, 'image_negative.html', {'form': form})
    elif request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            base64Image = base64.b64encode(form.cleaned_data['image'].read())
            from negative import negativeImage
            res = negativeImage(base64Image)
            return render(
                request, 'image_negative.html', {
                    'form': UploadImageForm,
                    'image': displayImage(base64Image),
                    'result': displayImage(res)
                })
Пример #17
0
def power(request):
    if request.method == 'GET':
        form = UploadImageForm
        return render(request, 'power-gamma.html', {'form': form})
    elif request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            base64Image = base64.b64encode(form.cleaned_data['image'].read())
            gamma = request.POST.get("gamma", "")
            from power_gamma import adjust_gamma
            res = adjust_gamma(base64Image, float(gamma))
            return render(
                request, 'power-gamma.html', {
                    'form': UploadImageForm,
                    'image': displayImage(base64Image),
                    'result': displayImage(res)
                })
Пример #18
0
def submit(request):
    if request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        newImage = None
        if form.is_valid():
            newImage = form.save(commit=False)
            newImage.img_hash = getHash()
            if request.user.is_authenticated():
                newImage.uploaded_by = request.user
            newImage.save()
            request.session[newImage.img_hash] = True
            return redirect(reverse('images.views.view', kwargs={'img_hash': newImage.img_hash}))
        return render(request, "submit_post.html", {'newImage': newImage})
    form = UploadImageForm()
    if request.GET.get('ref') == 'modal':
        return render(request, 'modal_form.html', {'title': 'Upload an Image', 'form': form})
    else:
        return render(request, 'submit.html', {'form': form})
Пример #19
0
def equilisation(request):
    if request.method == 'GET':
        form = UploadImageForm
        return render(request, 'hist_equilisation.html', {'form': form})
    elif request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            base64Image = base64.b64encode(form.cleaned_data['image'].read())
            from hist_eq import histogram_equalization
            res, hist, eq_hist = histogram_equalization(base64Image)
            return render(
                request, 'hist_equilisation.html', {
                    'form': UploadImageForm,
                    'image': displayImage(base64Image),
                    'result': displayImage(res),
                    'hist': hist,
                    'eq': eq_hist
                })
Пример #20
0
def admin_edit_competition_page(id):
    form = EditCompetitionForm()
    imageForm = UploadImageForm()
    imageFolderPath = os.path.join(os.getcwd(), 'static/images/competitions')

    if (request.method == 'POST' and form.submit_competition.data
            or form.validate()):
        name = form.name.data
        date = form.date.data
        country = form.country.data
        description = form.description.data
        reward = form.reward.data
        image = imageForm.image.data
        filename = select("logo", "competition", "id={}".format(id))
        if (image):
            extension = image.filename.split('.')[1]
            current_date = time.gmtime()
            filename = secure_filename("{}_{}.{}".format(
                id, current_date[0:6], extension))
            filePath = os.path.join(imageFolderPath, filename)
            images = os.listdir(imageFolderPath)
            digits = int(math.log(int(id), 10)) + 1
            for im in images:
                if (im[digits] == '_' and im[0:digits] == str(id)):
                    os.remove(os.path.join(imageFolderPath, im))
            image.save(filePath)
        elif (image):
            flash('Please upload a file in JPG format', "danger")
        print("Before update: ", date)
        update(
            "competition",
            "name='{}', date=DATE('{}'), country='{}', description='{}', reward='{}',logo='{}'"
            .format(name, date, country, description, reward,
                    filename), "id={}".format(id))
        return redirect(
            url_for('admin_edit.admin_edit_competition_page', id=id))
    else:
        if (session.get('auth_type') != 'Team leader'):
            flash('No admin privileges...', 'danger')
            return redirect(url_for('home.home_page'))
        result = select('id,name,date,country,description,reward',
                        'competition, logo', 'id={}'.format(id))[0]
        form.description.data = result[4]
        return render_template('admin_edit_competition_page.html',
                               form=form,
                               result=result,
                               imgName=result[5],
                               uploadImg=imageForm)
    return render_template('admin_edit_competition_page.html',
                           form=form,
                           result=result,
                           imgName=result[5],
                           uploadImg=imageForm)
Пример #21
0
def upload_image():
	form = UploadImageForm()

	if form.validate_on_submit():
		image = form.image.data

		current_app.logger.debug(image)

		image_name = save_file(image,Path(current_app.instance_path).parent.joinpath('static/img') )

		img = Image()
		img.name = image_name
		db.session.add(img)
		db.session.commit()

		current_app.logger.info(f'{image.name} saved to /static/images/')
		flash('image successfully uploaded', category='alert alert-success')
		return	 redirect(url_for('admin.homepage'))


	return render_template('admin/upload_image.html',form=form)
Пример #22
0
def equilisation(request):
    if request.method == 'GET':
        form = UploadImageForm
        return render(request, 'hist_equilisation.html', {'form': form})
    elif request.method == 'POST':
        form = UploadImageForm(request.POST, request.FILES)
        if form.is_valid():
            base64Image = base64.b64encode(form.cleaned_data['image'].read())
            from hist_eq1 import histogram_equalization
            res, x, y, z, x1, y1, z1 = histogram_equalization(base64Image)
            return render(
                request, 'hist_equilisation.html', {
                    'form': UploadImageForm,
                    'image': displayImage(base64Image),
                    'result': displayImage(res),
                    'x': x,
                    'y': y,
                    'z': z,
                    'x1': x1,
                    'y1': y1,
                    'z1': z1
                })
Пример #23
0
def upload_view(request):
    message = None
    if request.method == "POST":
        try:
            form = UploadImageForm(request.POST, request.FILES)
            if form.is_valid():
                cd = form.cleaned_data
                uploadImage = UploadImage(image = cd['image'],
                                                     category = cd['category'], 
                                                     title = cd['title'],
                                                     user = request.user)
                
                uploadImage.save()
                return HttpResponseRedirect("/")
            else:
                message = str(form.errors)
        except:
            if os.path.exists(os.path.join(settings.MEDIA_ROOT, cd['image'].path)):
                os.remove(os.path.join(settings.MEDIA_ROOT, cd['image'].path))
            message = str(sys.exc_info()[1])
            
    form = UploadImageForm()
    return render_to_response(register_path, RequestContext(
                request, { "message": message, "form": form } ) )
Пример #24
0
def admin_edit_team_page(id):
    auth = session.get('auth_type')
    if (auth != 'admin'
            and (auth != 'Team leader' and id != session.get('team_id'))):
        flash('No admin privileges...', 'danger')
        return redirect(url_for('home.home_page'))
    form = EditTeamForm()
    competitions = select("id,name", "competition")
    form.competition.choices = competitions
    imgForm = UploadImageForm()
    imgFolder = os.path.join(os.getcwd(), 'static/images/team')
    if (request.method == 'POST' and form.submit_team.data or form.validate()):
        name = form.name.data
        members = form.memberCtr.data
        year = form.year.data
        email = form.email.data
        address = form.address.data
        competition = form.competition.data
        image = imgForm.image.data
        if (image and '.jpg' in image.filename or '.jpeg' in image.filename
                or '.png' in image.filename):
            date = time.gmtime()
            extension = image.filename.split('.')[1]
            filename = secure_filename("{}_{}.{}".format(
                id, date[0:6], extension))
            filePath = os.path.join(imgFolder, filename)
            images = os.listdir(imgFolder)
            digits = int(math.log(int(id), 10)) + 1
            for im in images:
                if (im[digits] == '_' and im[0:digits] == str(id)):
                    os.remove(os.path.join(imgFolder, im))
            image.save(filePath)
            update("team", "logo='{}'".format(filename), "id={}".format(id))
        elif (image):
            flash("Please upload a file in JPG format", 'danger')

        update(
            "team",
            "name='{}', num_members={}, found_year='{}', email='{}', adress='{}', competition_id={}"
            .format(name, members, year, email, address, competition),
            where="id={}".format(id))
        return redirect(url_for('admin_edit.admin_edit_team_page', id=id))
    else:
        result = select(
            columns=
            "team.name,team.num_members,team.found_year,team.email,team.adress,team.logo,competition.id",
            table=
            "team left outer join competition on team.COMPETITION_ID=competition.id",
            where="team.id={}".format(id))
        print("EDIT TEAM RESULT", result)
        form.name.data = result[0]
        form.memberCtr.data = result[1]
        form.year.data = result[2]
        form.email.data = result[3]
        form.address.data = result[4]
        img_name = result[5]
        form.competition.data = result[6]
        return render_template('admin_edit_team_page.html',
                               form=form,
                               result=result,
                               uploadImg=imgForm,
                               imgName=img_name)
    return render_template('admin_edit_team_page.html',
                           form=form,
                           result=result,
                           uploadImg=imgForm,
                           imgName=img_name)
Пример #25
0
def admin_edit_member_page(person_id):
    # TODO:: Alter table to include social accounts links in person database.
    auth = session.get('auth_type')
    if (auth != 'admin'):
        flash("No admin", 'danger')
        return redirect(url_for("home.home_page"))
    form = EditMemberForm()
    subteams = select(
        "subteam.id,subteam.name",
        "subteam join team on subteam.team_id=team.id join person on person.team_id=team.id",
        "person.id={}".format(person_id))
    form.subteam.choices = subteams
    majors = select("major.id,major.name", "major")
    form.major.choices = majors
    auth_types = select("id,name", "auth_type")
    form.auth_type.choices = auth_types
    cvForm = UploadCVForm()
    cvPath = None
    cvFolder = os.path.join(os.getcwd(), 'static/cv')
    imgForm = UploadImageForm()
    imgPath = None
    imgFolder = os.path.join(os.getcwd(), 'static/images/person')
    member_id = select("member.id",
                       "member join person on person.id=member.person_id",
                       where="person.id={}".format(person_id))[0]
    if form.validate_on_submit():
        team = form.team.data
        subteam = form.subteam.data
        role = form.role.data
        auth_type = form.auth_type.data
        email = form.email.data
        name = form.name.data
        address = form.address.data
        active = form.active.data
        age = form.age.data
        phone = form.phone.data
        clas = form.clas.data
        major = form.major.data
        cv = cvForm.cv.data
        image = imgForm.image.data
        if (cv and '.pdf' in cv.filename):
            date = time.gmtime()
            filename = secure_filename("{}_{}.pdf".format(
                person_id, date[0:6]))
            cvPath = os.path.join(cvFolder, filename)
            cvs = os.listdir(cvFolder)
            digits = int(math.log(int(person_id), 10)) + 1
            for c in cvs:
                if (c[digits] == '_' and c[0:digits] == str(person_id)):
                    os.remove(os.path.join(cvFolder, c))
            cv.save(cvPath)
            update("person", "cv='{}'".format(filename),
                   "id={}".format(person_id))
            session['person_id'] = person_id

        elif (cv):
            flash("Upload a PDF file.", 'danger')

        if (image and '.jpg' in image.filename or '.jpeg' in image.filename
                or '.png' in image.filename):
            date = time.gmtime()
            extension = image.filename.split('.')[1]
            filename = secure_filename("{}_{}.{}".format(
                person_id, date[0:6], extension))
            imgPath = os.path.join(imgFolder, filename)
            images = os.listdir(imgFolder)
            digits = int(math.log(int(person_id), 10)) + 1
            for im in images:
                if (im[digits] == '_' and im[0:digits] == str(person_id)):
                    os.remove(os.path.join(imgFolder, im))
            image.save(imgPath)
            update("member", "picture='{}'".format(filename),
                   "id={}".format(member_id))
        elif (image):
            flash("Please upload a file in JPG format", 'danger')

        teamID = select(columns="id",
                        table="team",
                        where="name='{}'".format(team))[0]
        majorID = select(columns="id",
                         table="major",
                         where="id='{}'".format(major))[0]

        update("member",
               "role='{}', active={}, address='{}'".format(
                   role, active, address),
               where="id={}".format(member_id))

        update("person",
               "name='{}', age='{}', phone='{}',email='{}', \
					class={}, auth_type={}, team_id={}, subteam_id={}, major_id={}".format(
                   name, age, phone, email, clas, auth_type, teamID, subteam,
                   majorID),
               where="id={}".format(person_id))

        return redirect(
            url_for('admin_edit.admin_edit_member_page',
                    person_id=person_id,
                    cvPath=person_id))
    else:

        result = select(
            "person.name,person.email,team.name,subteam.id,member.role,member.active, \
					member.entrydate,auth_type.id,member.address,person.phone,major.id, \
					person.class,person.age,person.cv,member.picture",
            "person join member on member.person_id=person.id \
					join team on person.team_id=team.id \
					join subteam on person.subteam_id=subteam.id \
					join auth_type on person.auth_type=auth_type.id \
					join major on person.major_id=major.id	",
            "person.id={}".format(person_id))
        form.name.data = result[0]
        form.email.data = result[1]
        form.team.data = result[2]
        form.subteam.data = result[3]
        form.role.data = result[4]
        form.active.data = result[5]
        form.entry.data = result[6]
        form.auth_type.data = result[7]
        form.address.data = result[8]
        form.phone.data = result[9]
        form.major.data = result[10]
        form.clas.data = result[11]
        form.age.data = result[12]
        cvPath = result[13]
        img_name = result[14]

        return render_template('admin_edit_member_page.html',
                               form=form,
                               uploadImg=imgForm,
                               uploadCV=cvForm,
                               cvPath=cvPath,
                               imgName=img_name)