示例#1
0
def edit_person(slug):
    try:
        p = Person.objects.get(site=g.site.domain, slug=slug)
    except Person.DoesNotExist:
        abort(404)

    if not g.site.domain == g.user:
        abort(403)

    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(
                reqfile, request.config["UPLOAD_FOLDER"])
            f.save()

        p.name = request.form.get("name")
        p.title = request.form.get("title")
        p.phone = request.form.get("phone")
        p.email = request.form.get("email")
        p.twitter = request.form.get("twitter")
        p.description = request.form.get("description")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(url_for(".show_person", slug=p.slug))

    return render_template("edit_person.html", person=p)
示例#2
0
def edit_post(year, month, day, slug):
    try:
        p = Post.objects.get(site=g.site.domain,
                             year=year,
                             month=month,
                             day=day,
                             slug=slug)
    except Post.DoesNotExist:
        abort(404)

    if not g.site.domain == g.user:
        abort(403)

    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(
                reqfile, current_app.config["UPLOAD_FOLDER"])
            f.save()

        p.name = request.form.get("name")
        p.text = request.form.get("text")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(
            url_for("post", year=p.year, month=p.month, day=p.day,
                    slug=p.slug))

    return render_template("edit_post.html", post=p)
示例#3
0
文件: blog.py 项目: sigurdga/samklang
def edit_post(year, month, day, slug):
    try:
        p = Post.objects.get(site=g.site.domain, year=year, month=month, day=day, slug=slug)
    except Post.DoesNotExist:
        abort(404)

    if not g.site.domain == g.user:
        abort(403)

    if request.method == "POST":
        reqfile = request.files.get("file")
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(reqfile, current_app.config["UPLOAD_FOLDER"])
            f.save()

        p.name = request.form.get("name")
        p.text = request.form.get("text")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(url_for("post", year=p.year, month=p.month, day=p.day, slug=p.slug))

    return render_template("edit_post.html", post=p)
示例#4
0
def RegisterFile(Service=None, FileName=None, ProvisionedSpace="10G"):

    if Service  is None:
	raise StorageError('RegisterFile(): Service can not be None')

    if FileName is None:
	raise StorageError('RegisterFile(): FileName can not be None')

    vfilespace = StringSizeToBytes(ProvisionedSpace)
    
    if Service.freespace - vfilespace > 0:
	NewFile = File()
	NewFile.vfilename 	= FileName
        NewFile.ufid		= GetUniqueFileID(FileName)
	NewFile.pfilesize	= 0
        NewFile.vfilesize	= vfilespace
	NewFile.service		= Service
	NewFile.pfilename	= GetPhysicalFileName(Service.localpath, FileName)
	NewFile.status		= 'O'
	NewFile.save()
	
	SFreeSpace = CalculateFreeSpace(Service)
	Service.freespace = SFreeSpace
	Service.save()

	return NewFile
    else:
	raise StorageError('RegisterFile(): No have left space')
示例#5
0
def handle_new_file(user, uploaded, bulletin_id, encryption_key=None, rand=Random.new()):
    if encryption_key == '':
        encryption_key = None

    r, c, ep, iv, encryption_key = create_encryption_params(encryption_key, rand)

    file = File(
        author=user,
        bulletin=Bulletin.objects.get(pk=bulletin_id),
        name=uploaded.name,
        content=uploaded,
        rand=r,
        check=c,
        encryption_params=ep,
        date_created=datetime.now(),
        date_modified=datetime.now(),
    )

    if encryption_key is not None:
        with tempfile.NamedTemporaryFile() as temp:
            cipher = AES.new(encryption_key, AES.MODE_CFB, iv)
            for chunk in uploaded.chunks():
                encrypted_chunk = cipher.encrypt(chunk)
                temp.write(encrypted_chunk)
            temp.seek(0)
            file.content = DFile(temp)
            file.save()
            give_file_access(user, user, file, encryption_key)
    else:
        file.save()
示例#6
0
文件: views.py 项目: Jiang-Le/WeLearn
def upload(request, uri):
    if request.POST:
        _uri = request.POST.get("uri")
        _md5_hash = request.POST.get("hash")
        _name = request.POST.get("name")
        _description = request.POST.get("description")
        _time = datetime.datetime.now()
        _directory = request.POST.get("directory")
        if _directory != "":
            _rank = 2
            # 判断文件夹是否存在,若存在,则其中文件数加一,否则创建新的文件夹
            try:
                d = Directory.objects.get(uri=uri + "/" + _directory)
            except Directory.DoesNotExist:
                d = None
            if d:
                d.file_num += 1
                d.save()
            else:
                d = Directory(uri=uri + "/" + _directory, file_num=1, time=_time, name=_directory)
                d.save()
        else:
            _rank = 1
        pd = PrimaryDirectory.objects.get(uri=uri)
        pd.file_num += 1
        pd.save()
        file = File(uri=_uri, md5_hash=_md5_hash, name=_name,
                    description=_description, time=_time,
                    url=getDownloadUrl(_uri), download_num=0, rank=_rank)
        file.save()
        return HttpResponse("ok")
    return render_to_response("upload.html", {"uri": uri}, context_instance=RequestContext(request))
示例#7
0
def upload_flash(request):
    """
    Helper function that processes the file upload.  Used by flash player.
    
    :Return: HttpResponse of 0 or 1
    """

    try:
        if (request.method == 'POST' and 'file_upload' in request.FILES
                and 'slug' in request.GET):
            upload = File()
            upload.file_upload = request.FILES['file_upload']
            upload.submission = Submission.objects.get(
                slug=request.GET['slug'])
            upload.save()
            return HttpResponse(1)

        else:
            return HttpResponse(0)

    except StopUpload:
        raise

    except:
        return HttpResponse(0)
示例#8
0
文件: views.py 项目: antofik/meimew
def upload(request, name):
    if request.method == 'POST':
        if request.FILES is None:
            return HttpResponseBadRequest('No file[] found')

        file = request.FILES[u'files[]']
        wrapped_file = UploadedFile(file)
        filename = wrapped_file.name
        file_size = wrapped_file.file.size

        entry = File()
        entry.filename = unicode(filename)
        entry.username = unicode(name)
        entry.size = file_size
        entry.slug = generate_slug(8)
        entry.data = file
        entry.save()

        uploaded = [{
            'name': filename,
            'size': filesizeformat(file_size),
            'slug': entry.slug,
            'date': entry.created.date().isoformat()
        }]

        return HttpResponse(json.dumps({'files': uploaded}))
    else:
        raise Http404
示例#9
0
def edit_person(slug):
    try:
        p = Person.objects.get(site=g.site.domain, slug=slug)
    except Person.DoesNotExist:
        abort(404)

    if not g.site.domain == g.user:
        abort(403)

    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(reqfile, request.config["UPLOAD_FOLDER"])
            f.save()

        p.name = request.form.get("name")
        p.title = request.form.get("title")
        p.phone = request.form.get("phone")
        p.email = request.form.get("email")
        p.twitter = request.form.get("twitter")
        p.description = request.form.get("description")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(url_for(".show_person", slug=p.slug))

    return render_template("edit_person.html", person=p)
示例#10
0
 def test_model_file(self):
     """Test File Model"""
     folder = Folder(name='test')
     folder.save()
     obj = File(name='test', folder=folder)
     obj.save()
     self.assertEquals(folder, obj.folder)
     self.assertNotEquals(obj.id, None)
     obj.delete()
示例#11
0
文件: pep8.py 项目: Bryukh/spygit
def parse_pep8(run, git_path, output):
    """Parse the pep8 output, store the results"""

    errfiles_set = set()
    errortype_set = set()
    lineno_set = set()

    # Add all files in the project to the db
    allfiles = set()
    os.path.walk(git_path, add_file_to_set, allfiles)
    for filename in allfiles:
        filename = filename.replace(git_path + '/', '', 1)
        runfile = File(filename=filename, run=run)
        runfile.save()

    # Generate a set of error types, error files, and lines
    for line in output.readlines():
        filename, lineno, errnum, errtext = string.split(line, ':', 3)
        lineno = int(lineno)
        filename = filename.replace(git_path + '/', '', 1)

        # Create sets to remove duplicates
        errfiles_set.add(filename)

        # Add new err types to the db
        if (errnum, errtext) not in errortype_set:
            errortype_set.add((errnum, errtext))
            if not Error.objects.filter(error_type=errnum):
                err = Error(error_type=errnum, short_descr=errtext)
                err.save()

        # Create a set of line numbers for each file
        for ln in range(max(1, lineno - 3), lineno + 4):
            lineno_set.add((filename, ln))

        # Add err instances to the db
        runfile = File.objects.get(run=run, filename=filename)
        errtype = Error.objects.get(error_type=errnum)
        runerr = RunError(error=errtype, file=runfile, line_number=lineno,
                          error_descr=errtext)
        runerr.save()

    # Add lines to the db
    for filename in errfiles_set:
        runfile = File.objects.get(run=run, filename=filename)

        f = open(git_path + '/' + filename, 'r')
        lineno = 1
        for line in f:
            if (filename, lineno) in lineno_set:
                linetext = Line(file=runfile, line_number=lineno, text=line)
                linetext.save()
            lineno = lineno + 1
        f.close()
示例#12
0
文件: files.py 项目: helscn/flask-vue
 def post(self):
     for name in request.files:
         file = request.files.get(name)
         filename = path.basename(file.filename)
         ext = path.splitext(filename)[1]
         mimetype = file.mimetype
         user_id = g.current_user.id
         attachment = File(
             name=filename, ext=ext, mimetype=mimetype, user_id=user_id)
         attachment.save()
         file.save(path.join(Setting.UPLOAD_FOLDER, attachment.save_name))
     return {'success': True}, 201
示例#13
0
def save_file(mime, base64):
    '''
    Calculate hash of the file, look up in the database,
    save if it's a new one and return its hash.  The hash
    can the be used as URL.
    '''
    hash_ = file_keeper_hash(mime, base64)
    objects = File.objects.filter(hash=hash_)
    if not objects:
        file_ = File(hash=hash_, mime=mime, base64=base64)
        file_.save()
    return hash_
示例#14
0
def save_file(mime, base64):
    '''
    Calculate hash of the file, look up in the database,
    save if it's a new one and return its hash.  The hash
    can the be used as URL.
    '''
    hash_ = file_keeper_hash(mime, base64)
    objects = File.objects.filter(hash=hash_)
    if not objects:
        file_ = File(hash=hash_, mime=mime, base64=base64)
        file_.save()
    return hash_
示例#15
0
def post_object(request):

    if request.method == "POST":

        upload = request.FILES['file']
        parent = request.POST.get('parent') if 'parent' in request.POST.keys() else None

        f = File(name=upload.name, file=upload, owner=request.user, parent=parent, bytes=request.POST.get('size'), mime=request.POST.get('type'))
        f.save()

        return JsonResponse(f.get_client_inode(), safe=False)
    return JsonResponse({'message':'Invalid file..'}, status=400, safe=False)
示例#16
0
文件: app.py 项目: sigurdga/samklang
def files():
    if request.method == "POST" and g.site.domain == g.user:
        reqfile = request.files["file"]
        f = File()
        f.site = g.site.domain
        f.name = reqfile.filename
        f.slug = secure_filename(f.name)
        f.content_type = reqfile.mimetype
        f.slug, f.content_length = save_file(reqfile, app.config["UPLOAD_FOLDER"])
        f.save()

    files = File.objects(site=g.site.domain)
    return render_template("files.html", files=files)
示例#17
0
文件: app.py 项目: abal09/samklang
def files():
    if request.method == "POST" and g.site.domain == g.user:
        reqfile = request.files['file']
        f = File()
        f.site = g.site.domain
        f.name = reqfile.filename
        f.slug = secure_filename(f.name)
        f.content_type = reqfile.mimetype
        f.slug, f.content_length = save_file(reqfile,
                                             app.config["UPLOAD_FOLDER"])
        f.save()

    files = File.objects(site=g.site.domain)
    return render_template('files.html', files=files)
示例#18
0
def fileRead(request):
    if request.method == 'POST':
        myfile = request.FILES['myfile']
        fs = FileSystemStorage()
        filename = fs.save(myfile.name, myfile)
        uploaded_file_url = fs.url(filename)
        ob = File(path="/home/divum/Desktop/django/myproject" +
                  uploaded_file_url)
        ob.save()
        dic = {}
        dic['status'] = 200
        dic['message'] = "File Stored"
        dic['url'] = "/home/divum/Desktop/django/myproject" + uploaded_file_url
        return JsonResponse(dic, status=200)
def create_file(name, folder_id):
	root = MEDIA_ROOT
	folder = Folder.objects.get(id=folder_id)
	# Open a file
	f = open(folder.path + "/" + name, "w")
	# Close opend file
	f.close()

	file = File()
	file.name = name
	file.folder = folder
	file.active = True
	file.save()

	return file.id
示例#20
0
def upload_html(request, submission):
    """
    Helper function that processes the file upload.  Used by the 'no flash' version.
    
    :Return: Void
    """
    
    if request.FILES:
        for file in request.FILES:
            upload = File()
            upload.submission = submission
            upload.file_upload = request.FILES[file]
            upload.save()
            
    return
def upload_file(name, folder_id, f):
	root = MEDIA_ROOT
	folder = Folder.objects.get(id=folder_id)
	# create a file
	with open(folder.path + "/" + name, 'w') as destination:
		for chunk in f.chunks():
			destination.write(chunk)

	file = File()
	file.name = name
	file.folder = folder
	file.active = True
	file.save()

	return file.id
示例#22
0
def add_file(request,prop_id, event_id, note_id):
	if request.method == 'POST':
		form = FileUploadForm(request.POST, request.FILES)
		note = Note.objects.get(pk=note_id)
		if form.is_valid():
			newdoc = File(docfile=request.FILES['docfile'] )
			newdoc.note = note
			newdoc.save()
			return HttpResponse("added file")
		else:
			form = FileUploadForm()
		documents = File.objects.all()
		context={'form':form, 'documents': documents,'event_id':event_id,
		'prop_id':prop_id,"note_id":note_id}
		return HttpResponseBadRequest(render (request,'main/note.html',context))
示例#23
0
def upload_html(request, submission):
    """
    Helper function that processes the file upload.  Used by the 'no flash' version.
    
    :Return: Void
    """

    if request.FILES:
        for file in request.FILES:
            upload = File()
            upload.submission = submission
            upload.file_upload = request.FILES[file]
            upload.save()

    return
示例#24
0
def upload(request):
    if request.POST:
        userid = request.POST.get('userid')
        
        # Queries all non-expired sessions
        sessions = Session.objects.filter(expire_date__gte=datetime.now())

        # Checks if session is active
        for session in sessions:
            data = session.get_decoded()
            found_userid=data.get('_auth_user_id')

            # Prceeds when user id is validated
            if found_userid!=None and long(userid)==found_userid:
                user = User.objects.filter(id=userid)[0]
                faculty=None
                faculty=Faculty.objects.filter(id=request.POST.get('fid'))[0]
                transaction = Transaction.objects.get(id=request.POST.get('transaction'))
                document = Dokument()
                document.faculty= faculty
                document.transaction= transaction
                document.save()

                #Generates a random alphanum string for filename template
                while True:
                    fnameTemplate=''
                    fnameTemplate = ''.join(random.choice(string.ascii_lowercase))
                    fnameTemplate += ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(4)) + '_'
                    if len(File.objects.filter(filename__startswith = fnameTemplate))==0: break

                #Processes uploaded files, page by page
                for key in request.FILES:
                    files = request.FILES[key]
                    filename = fnameTemplate + key.split('_')[1] + '.bmp'
                    with open('DCSArchivingSystem/testapp/media/files/' + filename, 'wb+') as destination:
                        for chunk in files.chunks():
                            destination.write(chunk)
                        file = File()
                        file.filename = filename
                        file.file = 'files/' + filename
                        file.save()                    
                        document.files.add(file)
                    Log.create(user, "Uploaded file", file, document).save()    
                Log.create(user, "Created Document", None, document).save()    
                return HttpResponseRedirect("/dashboard/")
            
    else:
        return render_to_response('upload.html', context_instance=RequestContext(request))
def compile_java(file_id):
    #first traslate
    traslate_java(file_id)

    file = File.objects.get(id=file_id)
    folder = file.folder
    user = folder.user
    galatea_code = GALATEA + "galatea.jar "
    code = "javac -cp "+ galatea_code + folder.path + "/*.java"
    #print code
    value = subprocess.check_output([code], shell=True)
    #print value

    #get all the file in this folder
    for root, dirs, files in os.walk(folder.path):
        root_folder = Folder.objects.get(path=root, name = os.path.basename(root))
        for dir in dirs:
            folders = Folder.objects.filter(father=root_folder.id)
            esta = False
            for folder in folders:
                if folder.name == dir:
                    esta = True
            if not esta:
                folder = Folder()
                folder.name = dir
                folder.path = root_folder.path + "/" + dir
                folder.user = user
                folder.father = root_folder.id
                folder.active = True
                folder.save()
        #print dirs
        for file in files:
            files_folder = File.objects.filter(folder = root_folder.id)
            esta = False
            for f in files_folder:
                if f.name == file:
                    esta = True
            if not esta:
                if (os.path.splitext(file)[1] != ".class"):
                    f = File()
                    f.name = file
                    f.folder = root_folder
                    f.active = True
                    f.save()

    return value
示例#26
0
def new_post():
    if not g.site.domain == g.user:
        abort(403)

    p = Post()
    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(reqfile,
                                                 blog.config["UPLOAD_FOLDER"])
            f.save()

        import datetime
        p.site = g.site.domain
        p.name = request.form.get("name")
        p.created = datetime.datetime.utcnow()
        p.year = p.created.year
        p.month = p.created.month
        p.day = p.created.day
        slugs = [
            __j.slug for __j in Post.objects.filter(site=g.site.domain,
                                                    year=p.year,
                                                    month=p.month,
                                                    day=p.day,
                                                    slug=p.slug)
        ]
        counter = 1
        slug = slugify(p.name)
        __slug = slug
        while __slug in slugs:
            counter += 1
            __slug = "%s_%d" % (slug, counter)
        p.slug = __slug
        p.text = request.form.get("text")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(
            url_for("post", year=p.year, month=p.month, day=p.day,
                    slug=p.slug))
    return render_template("edit_post.html", post=p)
示例#27
0
def add_file(file_name, description=None):
    """Adds a file name to the catalog"""

    file_name = file_name.strip()

    try:
        date_created = datetime.datetime.fromtimestamp(os.path.getctime(file_name)).strftime('%Y-%m-%d %H:%M:%S')
        current_file = File(file_name=file_name,
                            description=description,
                            date_created=date_created)

        current_file.save()
        print "'%s' added!" % file_name

    except IntegrityError:
        current_file = File.get(File.file_name == file_name)

    return current_file
示例#28
0
def upload(request, json=False):
    if request.method == 'GET':
        form = UploadForm()

    if request.method == 'POST':
        form = UploadForm(request.POST, request.FILES)
        if form.is_valid():
            data = request.FILES['file']
            size = form.cleaned_data['file'].size
            expire_date = form.cleaned_data['expire_date'] or one_week_later()
            message = form.cleaned_data['message']
            receiver = form.cleaned_data['receiver']

            if form.cleaned_data['filename_overwrite']:
                name = form.cleaned_data['filename_overwrite']
            else:
                name = form.cleaned_data['file'].name

            file = File(name=name, owner=request.user,
                        expire_date=expire_date, message=message, size=size)

            md5 = handle_uploaded_file(name, file.secret, data)
            file.md5 = md5
            file.save()

            if receiver:
                downloader = Downloader(email=receiver, file=file)
                downloader.save()
                url = 'http://%s/files/download/%s/%s' % \
                    (Site.objects.get_current().domain, file.id, file.secret)
                from_ = request.user.email
                mailit([receiver], from_, message, url)

            if json:
                response = {'status': 'ok', 'fileid': file.id}
                return HttpResponse(simplejson.dumps(response))
            else:
                return HttpResponseRedirect('/files/list/')

    if json:
        response = {'status': 'error', 'message': 'form not valid'}
        return HttpResponse(simplejson.dumps(response))
    else:
        return render_to_response('files/upload.html', {'form': form, }, context_instance=RequestContext(request))
示例#29
0
	def add(self, request, *args, **kwargs):
		form = SubmitFileForm(request.POST or None, request.FILES or None)

		if form.is_valid():
			docfile = request.FILES['docfile']
			docfile_ext = docfile.name.split(".")[-1]

			if docfile_ext == "pdf" or docfile_ext == "txt":
				field_starts_at = request.POST['starts_at'] or 0
				field_ends_at = request.POST['ends_at'] or 0

				file = File(
					title = request.POST['title'],
					docfile = request.FILES['docfile'],
					is_summarized = request.POST.get('is_summarized', False),
					starts_at = field_starts_at,
					ends_at = field_ends_at,
					user = request.user
				)

				# cleaned data
				title = form.cleaned_data["title"]
				docfile = form.cleaned_data["docfile"]
				is_summarized = form.cleaned_data["is_summarized"]
				starts_at = form.cleaned_data["starts_at"]
				ends_at = form.cleaned_data["ends_at"]

				if (int(field_starts_at) <= int(field_ends_at)):
					if file.save():
						if docfile_ext == "pdf":
							messages.success(request, "O arquivo " + docfile.name +
								" foi convertido para txt e adicionado com sucesso!")
						else:
							messages.success(request, "O arquivo " + docfile.name +
								" foi adicionado com sucesso!")
					else:
						messages.error(request, "O arquivo " + docfile.name + " está protegido."
							" Verifique as permissões de acesso ao conteúdo do arquivo.")
				else:
					messages.error(request, "Range de conversão inválido. "
						"Verfique se as páginas inseridas estão corretas.")

				return redirect('/')
			else:
				messages.error(request, "Formato do arquivo ." + docfile_ext +
					u" inválido! Apenas .pdf e .txt são permitidos.")

		files = File.objects.filter(user=request.user).all()
		template = "converter/index.html"
		context = {
			"title": "Conversor",
			"form": form,
			"files": files
		}
		return render(request, template, context)
示例#30
0
def new_person():
    if not g.site.domain == g.user:
        abort(403)

    p = Person()
    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(
                reqfile, current_app.config["UPLOAD_FOLDER"])
            f.save()

        p.site = g.site.domain
        p.name = request.form.get("name")
        p.title = request.form.get("title")
        p.phone = request.form.get("phone")
        p.email = request.form.get("email")
        p.twitter = request.form.get("twitter")
        p.description = request.form.get("description")
        slugs = [__p.slug for __p in Person.objects.filter(site=g.site.domain)]
        slug = slugify(p.name)
        counter = 1
        __slug = slug
        while __slug in slugs:
            counter += 1
            __slug = "%s_%d" % (slug, counter)
        p.slug = __slug

        if reqfile:
            p.image_slug = f.slug
        p.save()

        pl = Personnel.objects.get(site=g.site.domain)
        pl.people.append(p.slug)
        pl.save()

        return redirect(url_for(".show_personnel"))
    return render_template("edit_person.html", person=p)
示例#31
0
def new_person():
    if not g.site.domain == g.user:
        abort(403)

    p = Person()
    if request.method == "POST":
        reqfile = request.files.get('file')
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(reqfile, current_app.config["UPLOAD_FOLDER"])
            f.save()

        p.site = g.site.domain
        p.name = request.form.get("name")
        p.title = request.form.get("title")
        p.phone = request.form.get("phone")
        p.email = request.form.get("email")
        p.twitter = request.form.get("twitter")
        p.description = request.form.get("description")
        slugs = [ __p.slug for __p in Person.objects.filter(site=g.site.domain) ]
        slug = slugify(p.name)
        counter = 1
        __slug = slug
        while __slug in slugs:
            counter += 1
            __slug = "%s_%d" % (slug, counter)
        p.slug = __slug

        if reqfile:
            p.image_slug = f.slug
        p.save()

        pl = Personnel.objects.get(site=g.site.domain)
        pl.people.append(p.slug)
        pl.save()

        return redirect(url_for(".show_personnel"))
    return render_template("edit_person.html", person=p)
示例#32
0
def TakeOwnership(Service=None, FileName=None):
    if Service is None:
	raise StorageError('TakeOwnership(): Service can not be None')

    if FileName is None:
	raise StorageError('TakeOwnership(): FileName can not be None')

    if FileExist(Service.localpath,FileName,True):
	NewFile = File()
	NewFile.vfilename	= FileName
	NewFile.pfilename	= FileName
	NewFile.ufid		= GetUniqueFileID(FileName)
	NewFile.service		= Service
	NewFile.status		= 'O'
	NewFile.vfilesize	= 0
	NewFile.pfilesize	= 0
	NewFile.save()
	CloseFile(NewFile.ufid)
	return NewFile
    else:
	raise StorageError('TakeOwnership(): File not exit [%s%s]' % (Service.localpath+FileName))
示例#33
0
文件: blog.py 项目: sigurdga/samklang
def new_post():
    if not g.site.domain == g.user:
        abort(403)

    p = Post()
    if request.method == "POST":
        reqfile = request.files.get("file")
        if reqfile:
            f = File()
            f.site = g.site.domain
            f.name = reqfile.filename
            f.content_type = reqfile.mimetype
            f.slug, f.content_length = save_file(reqfile, blog.config["UPLOAD_FOLDER"])
            f.save()

        import datetime

        p.site = g.site.domain
        p.name = request.form.get("name")
        p.created = datetime.datetime.utcnow()
        p.year = p.created.year
        p.month = p.created.month
        p.day = p.created.day
        slugs = [
            __j.slug
            for __j in Post.objects.filter(site=g.site.domain, year=p.year, month=p.month, day=p.day, slug=p.slug)
        ]
        counter = 1
        slug = slugify(p.name)
        __slug = slug
        while __slug in slugs:
            counter += 1
            __slug = "%s_%d" % (slug, counter)
        p.slug = __slug
        p.text = request.form.get("text")
        if reqfile:
            p.image_slug = f.slug
        p.save()
        return redirect(url_for("post", year=p.year, month=p.month, day=p.day, slug=p.slug))
    return render_template("edit_post.html", post=p)
示例#34
0
文件: views.py 项目: antofik/meimew
def upload(request, name):
    if request.method == 'POST':
        if request.FILES is None:
            return HttpResponseBadRequest('No file[] found')

        file = request.FILES[u'files[]']
        wrapped_file = UploadedFile(file)
        filename = wrapped_file.name
        file_size = wrapped_file.file.size

        entry = File()
        entry.filename = unicode(filename)
        entry.username = unicode(name)
        entry.size = file_size
        entry.slug = generate_slug(8)
        entry.data = file
        entry.save()

        uploaded = [{'name': filename, 'size': filesizeformat(file_size), 'slug': entry.slug,
                     'date': entry.created.date().isoformat()}]

        return HttpResponse(json.dumps({'files': uploaded}))
    else:
        raise Http404
示例#35
0
def upload_flash(request):
    """
    Helper function that processes the file upload.  Used by flash player.
    
    :Return: HttpResponse of 0 or 1
    """
    
    try:
        if (request.method == 'POST' and 'file_upload' 
            in request.FILES and 'slug' in request.GET):
            upload = File()
            upload.file_upload = request.FILES['file_upload']
            upload.submission = Submission.objects.get(slug=request.GET['slug'])
            upload.save()
            return HttpResponse(1)
        
        else:
            return HttpResponse(0)
    
    except StopUpload:
        raise

    except:
        return HttpResponse(0)
示例#36
0
def api_upload(request):
    reader = yield from request.multipart()
    field = yield from reader.next()
    filename = field.filename
    size = 0
    path = 'E:/upload/'
    id = next_id()
    if not os.path.exists(path):
        os.mkdir(path)
    with open(os.path.join(path, filename), 'wb') as f:
        while True:
            chunk = yield from field.read_chunk()  # 8192 bytes by default.
            if not chunk:
                break
            size += len(chunk)
            f.write(chunk)
    file = File(id=id, filename=filename, filepath=filename, filesize=size)
    affected = yield from file.save()
    return {'affected': affected}
示例#37
0
文件: views.py 项目: thinmanj/Demo
def csvUpload(request):
    global messages
    messages = []
    try:
        template = 'fileupload.html'
        form = SimpleFileForm()
     
        if request.method == 'POST':
            if 'file' in request.FILES:


                #
                # Final counters
                #
                numberWeeks = 0
                numberTeamMembers = 0
                numberActuals = 0

                #
                # Preprossesing file 
                #
                csvfile = request.FILES['file']

                fileName = csvfile.name
                fileSize = csvfile.size
                rawData = csvfile.read()
                csvfile.seek(0)
                csvData = csv.reader(csvfile)
                fileDate = datetime.datetime.now()

                #
                # create file record
                #

                try:
                    f = File(name=fileName, uploadDate=fileDate, data=rawData, 
                        status="This message means an internal error...")
                    f.save()
                    messages.append('Loaded file: "%s" [%d] on %s '% (fileName, fileSize, fileDate))
                except:
                    messages.append('Error while saving csv file')
                    raise
                #
                # parse csv data
                #

                teamHead = []
                teamData = {}

                teamMemberHead = []

                for row in csvData:
                    if not teamData:
                        if not teamHead:
                            #
                            # Working on Team and Metric Header
                            #

                            teamHead = row
                            
                            #
                            # Testing team data 
                            #
                            if len(teamHead)<2:
                                messages.append('Team Header row 1 has less than  expected data')

                            if teamHead[teamName] != "Team Name":
                                messages.append('Expected Team Name Header not found')

                            if teamHead[metricName] != "Metric Name":
                                messages.append('Expected Metric Name Header not found')


                        else:
                            #
                            # Working on Team and Metric names
                            #

                            #
                            # testing team data 
                            #
                            if len(row)<2:
                                messages.append('Error, Team Data has less than expected data')
                                raise 
                            #
                            # Get Team and Metric objects
                            #

                            try:
                                team, created = Team.objects.get_or_create(name=row[0])
                                #team.save()
                            except:
                                messages.append('Error with team information')
                                raise
                            try:
                                metric, created = Metric.objects.get_or_create(team=team, name=row[1])
                                #metric.save()
                            except:
                                messages.append('Error with metric information')
                                raise

                            teamData['team'] = team
                            teamData['metric'] = metric
                    else:
                        #
                        # Working on member an metrics data
                        #

                        if not teamMemberHead:
                            #
                            # Testing second Header
                            #

                            teamMemberHead = row

                            if len(teamMemberHead)<dateStart+1:
                                messages.append('Team Member row 3 has less than expected data')

                            if teamMemberHead[oDeskName] != "oDesk ID":
                                messages.append('Expected oDesk ID Header not found')

                            if teamMemberHead[memberName] != "Member Name":
                                messages.append('Expected Member Name Header not found')

                            #
                            # Processing dates from header
                            #

                            try:
                                metricDates = map(datetime_from_str, teamMemberHead[dateStart:])
                                numberWeeks = len(metricDates)
                            except:
                                messages.append('Some dates could not be parsed or are not sundays')
                                raise
                        else:
                            # 
                            # Processing each memeber data
                            #

                            numberTeamMembers += 1
                            try:
                                teamMember, created = TeamMember.objects.get_or_create(team=team, oId = row[oDeskName], 
                                    defaults={'name': row[memberName]})
                            except:
                                messages.append('Erro while getting Team member.')
                                raise

                            #
                            # Processing members metrics
                            #

                            try:
                                for metricDate, metricValue in zip(metricDates, row[dateStart:]):
                                    metdef ={'fileLoaded':f}
                                    if not metricValue:
                                        metdef['value'] = 0
                                        metdef['status'] = False
                                    else:
                                        metdef['value'] = int(metricValue)
                                    MetricData.objects.get_or_create(member=teamMember, metric=metric, metricDate=metricDate,
                                        defaults=metdef)
                                    numberActuals +=1
                            except:
                                messages.append('Erro while inserting Metric.')
                                raise


                #
                # Saving final file status 
                #
                messages.append("team='%s' metric='%s' processed %d actuals. %d members by %d weeks."%
                    (team.name, metric.name, numberActuals, numberTeamMembers, numberWeeks))
                f.status = "\n".join(messages)
                f.save()
            else:

                messages.append('No file attached')
     
            return render_to_response(template, RequestContext(request, {
                'form': form,
                'processMessages': messages,
                }))
        else:
            #
            # Display the form
            #

            return render_to_response(template, RequestContext(request, {
                'form': form,
                'processMessages': messages,
                }))
    except:
        #
        # Here we hold every problem genenrated on parsing
        #
        try:
            if f:
                f.status = "\n".join(messages)
                f.save()
        except:
            #
            #  Let's display them......
            #
            pass
        return render_to_response(template, RequestContext(request, {
            'form': form,
            'processMessages': messages,
            }))
示例#38
0
def store(request):
	"""
	This view recieves a chunck of a file and saves it. When all the chunks are
	uploaded, they are joined together to make a complete file.

	This is gonna be pretty sketch for a while
	"""
	guid = File.sanitize_filename(request.POST['resumableIdentifier'])
	if not guid:
		return HttpResponseNotFound("Invalid file identifier")

	dir_path = os.path.join(settings.TMP_ROOT, str(request.user.pk) + "-" + guid)
	try:
		os.makedirs(dir_path)
	except OSError as e:
		# directory exists, dude!
		pass

	# each file will be named 1.part, 2.part etc. and stored inside the dir_path
	file_path = os.path.join(dir_path, str(int(request.POST['resumableChunkNumber'])) + '.part')
	file = request.FILES['file']

	# dont let that chunk be too big
	if file.size > (settings.CHUNK_SIZE*2):
		shutil.rmtree(dir_path)
		return HttpResponseNotFound("Too many chunks")

	with open(file_path, 'wb') as dest:
		for chunk in file.chunks():
			dest.write(chunk)

	total_number_of_chunks = int(request.POST['resumableTotalChunks'])
	total_number_of_uploaded_chunks = len(os.listdir(dir_path))
	if total_number_of_chunks != total_number_of_uploaded_chunks:
		return HttpResponse("OK")

	total_size = 0
	for i in range(1, total_number_of_chunks + 1):
		chunk_path = os.path.join(dir_path, str(i) + '.part')
		total_size += os.path.getsize(chunk_path)
		if total_size > settings.MAX_UPLOAD_SIZE:
			shutil.rmtree(dir_path)
			return HttpResponseNotFound("File too big")

	if total_size != int(request.POST['resumableTotalSize']):
		# All files present and accounted for, 
		# just slow as balls when it comes to getting written
		return HttpResponse("OK")

	try:
		f = File(
			name=request.POST['resumableFilename'],
			type=FileType.UNKNOWN,
			status=FileStatus.UPLOADED,
			uploaded_by=request.user,
			tmp_path=dir_path,
		)
		f.save()
	except DatabaseError as e:
		# that file was already taken care of, dude
		return HttpResponse("OK")

	process_uploaded_file.delay(total_number_of_chunks, f)
	return HttpResponse("COMPLETE")
示例#39
0
 def create(self, file):
     file = File()
     file.save(file, file.name)
     return file
示例#40
0
def multiuploader(request):
    """
    Main Multiuploader module.
    Parses data from jQuery plugin and makes database changes.
    """
    if request.method == 'POST':
        log.info('received POST to main multiuploader view')
        if request.FILES == None:
            return HttpResponseBadRequest('Must have files attached!')

        #getting file data for farther manipulations
        file = request.FILES[u'files[]']
        wrapped_file = UploadedFile(file)
        filename = wrapped_file.name
        file_size = wrapped_file.file.size
        log.info ('Got file: "%s"' % filename)

        #writing file manually into model
        #because we don't need form of any type.
        image = File()
        image.filename= filename
        image.image=file
        image.key_data = image.key_generate
        image.save()
        log.info('File saving done')

        #settings imports
        try:
            file_delete_url = settings.MULTI_FILE_DELETE_URL+'/'
            # file_url = settings.MULTI_IMAGE_URL+'/'+image.key_data+'/'
        except AttributeError:
            file_delete_url = 'multi_delete/'
            # file_url = 'multi_image/'+image.key_data+'/'

        file_url = image.image.url;

        #generating json response array
        result = []
        context = {"name":filename, 
            "size":file_size, 
            "url":file_url,
            "file_id": image.id,
            "delete_url":file_delete_url+str(image.pk)+'/', 
            "delete_type":"POST",
        }
        #getting thumbnail url using sorl-thumbnail
        print image.is_image
        if image.is_image:
            im = get_thumbnail(image, "80x80", quality=50)
            context['thumbnail_url'] = im.url

        result.append(context)
        response_data = simplejson.dumps(result)
        
        #checking for json data type
        #big thanks to Guy Shapiro
        if "application/json" in request.META['HTTP_ACCEPT_ENCODING']:
            mimetype = 'application/json'
        else:
            mimetype = 'text/plain'
        return HttpResponse(response_data, mimetype=mimetype)
    else: #GET
        return HttpResponse('Only POST accepted')
示例#41
0
class DocumentsViewsTest(TestCase):
    username = "******"
    password = "******"

    def setUp(self):
        self.group, created = Group.objects.get_or_create(name='test')
        self.user, created = DjangoUser.objects.get_or_create(username=self.username)
        self.user.set_password(self.password)
        self.user.save()
        perspective, created = Perspective.objects.get_or_create(
            name='default')
        perspective.set_default_user()
        perspective.save()

        ModuleSetting.set('default_perspective', perspective.id)

        self.folder = Folder(name='test')
        self.folder.set_default_user()
        self.folder.save()

        self.document = Document(title='test_document', folder=self.folder)
        self.document.set_default_user()
        self.document.save()

        self.file = File(name='test_file', folder=self.folder)
        self.file.set_default_user()
        self.file.save()

        self.link = WebLink(title='test', folder=self.folder, url='test')
        self.link.set_default_user()
        self.link.save()

    ######################################
    # Testing views when user is logged in
    ######################################
    def test_index_login(self):
        "Test index page with login at /documents/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('document_index'))
        self.assertEquals(response.status_code, 200)

    def test_index_documents_login(self):
        "Test index page with login at /documents/documents/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('index_documents'))
        self.assertEquals(response.status_code, 200)

    def test_index_files_login(self):
        "Test index page with login at /documents/files/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('index_files'))
        self.assertEquals(response.status_code, 200)

    def test_index_weblinks_login(self):
        "Test index page with login at /documents/weblinks/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('index_weblinks'))
        self.assertEquals(response.status_code, 200)

    # Folders

    def test_folder_add(self):
        "Test index page with login at /documents/folder/add/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('documents_folder_add'))
        self.assertEquals(response.status_code, 200)
        # form
        self.assertEqual(Folder.objects.count(), 1)
        post_data = {'name': 'test'}
        response = self.client.post(reverse('documents_folder_add'), post_data)
        self.assertEquals(response.status_code, 302)  # redirect somewhere
        self.assertEquals(Folder.objects.count(), 2)

    def test_folder_view_login(self):
        "Test index page with login at /documents/folder/view/<folder_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_folder_view', args=[self.folder.id]))
        self.assertEquals(response.status_code, 200)

    def test_folder_edit_login(self):
        "Test index page with login at /documents/folder/edit/<folder_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_folder_edit', args=[self.folder.id]))
        self.assertEquals(response.status_code, 200)

    def test_folder_delete_login(self):
        "Test index page with login at /documents/folder/delete/<folder_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_folder_delete', args=[self.folder.id]))
        self.assertEquals(response.status_code, 200)

    # Documents

    def test_document_add(self):
        "Test index page with login at /documents/add"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('documents_document_add'))
        self.assertEquals(response.status_code, 200)
        # form
        self.assertEqual(Document.objects.count(), 1)
        response = self.client.get(reverse('documents_document_add'))
        post_data = {'title': 'test',
                     'folder': self.folder,
                     }
        response = self.client.post(
            reverse('documents_document_add'), post_data)
        #self.assertEqual(Document.objects.count(), 2)

    def test_document_add_typed(self):
        "Test index page with login at /documents/add/folder/<folder_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_document_add_typed', args=[self.folder.id]))
        self.assertEquals(response.status_code, 200)

    def test_document_view_login(self):
        "Test index page with login at /documents/view/<document_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_document_view', args=[self.document.id]))
        self.assertEquals(response.status_code, 200)

    def test_document_edit_login(self):
        "Test index page with login at /documents/edit/<document_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_document_edit', args=[self.document.id]))
        self.assertEquals(response.status_code, 200)

    def test_document_delete_login(self):
        "Test index page with login at /documents/delete/<document_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_document_delete', args=[self.document.id]))
        self.assertEquals(response.status_code, 200)

    # Files

    def test_file_view_login(self):
        "Test index page with login at /file/view/<file_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_file_view', args=[self.file.id]))
        self.assertEquals(response.status_code, 200)

    def test_file_edit_login(self):
        "Test index page with login at /file/edit/<file_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_file_edit', args=[self.file.id]))
        self.assertEquals(response.status_code, 200)

    def test_file_delete_login(self):
        "Test index page with login at /file/view/<file_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_file_delete', args=[self.file.id]))
        self.assertEquals(response.status_code, 200)

    # Web Links
    def test_weblink_add_typed(self):
        "Test index page with login at /documents/weblink/add/<folder_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_weblink_add_typed', args=[self.folder.id]))
        self.assertEquals(response.status_code, 200)

    def test_weblink_add(self):
        "Test index page with login at /documents/weblink/add/"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(reverse('documents_weblink_add'))
        self.assertEquals(response.status_code, 200)
        # form
        self.assertEqual(WebLink.objects.count(), 1)
        response = self.client.get(reverse('documents_weblink_add'))
        post_data = {'title': 'test',
                     'folder': self.folder,
                     'url': 'test',
                     }
        response = self.client.post(
            reverse('documents_weblink_add'), post_data)
        # self.assertEqual(WebLink.objects.count(), 2)

    def test_weblink_view_login(self):
        "Test index page with login at /documents/view/<weblink_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_weblink_view', args=[self.link.id]))
        self.assertEquals(response.status_code, 200)

    def test_weblink_edit_login(self):
        "Test index page with login at /documents/edit/<weblink_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_weblink_edit', args=[self.link.id]))
        self.assertEquals(response.status_code, 200)

    def test_weblink_delete_login(self):
        "Test index page with login at /documents/delete/<weblink_id>"
        response = self.client.post('/accounts/login',
                                    {'username': self.username, 'password': self.password})
        self.assertRedirects(response, '/')
        response = self.client.get(
            reverse('documents_weblink_delete', args=[self.link.id]))
        self.assertEquals(response.status_code, 200)

    ######################################
    # Testing views when user is not logged in
    ######################################
    def test_index(self):
        "Test index page at /documents/"
        response = self.client.get('/documents/')
        # Redirects as unauthenticated
        self.assertRedirects(response, reverse('user_login'))

    def test_index_documents_out(self):
        "Testing /documents/documents/"
        response = self.client.get(reverse('index_documents'))
        self.assertRedirects(response, reverse('user_login'))

    def test_index_files_out(self):
        "Testing /documents/files/"
        response = self.client.get(reverse('index_files'))
        self.assertRedirects(response, reverse('user_login'))

    def test_index_weblinks_out(self):
        "Testing /documents/weblinks/"
        response = self.client.get(reverse('index_weblinks'))
        self.assertRedirects(response, reverse('user_login'))

    # Folders

    def test_folder_add_out(self):
        "Testing /documents/folder/add/"
        response = self.client.get(reverse('documents_folder_add'))
        self.assertRedirects(response, reverse('user_login'))

    def test_folder_view_out(self):
        "Testing /documents/folder/view/<folder_id>"
        response = self.client.get(
            reverse('documents_folder_view', args=[self.folder.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_folder_edit_out(self):
        "Testing /documents/folder/edit/<folder_id>"
        response = self.client.get(
            reverse('documents_folder_edit', args=[self.folder.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_folder_delete_out(self):
        "Testing /documents/folder/delete/<folder_id>"
        response = self.client.get(
            reverse('documents_folder_delete', args=[self.folder.id]))
        self.assertRedirects(response, reverse('user_login'))

    # Documents

    def test_document_add_out(self):
        "Testing /documents/add"
        response = self.client.get(reverse('documents_document_add'))
        self.assertRedirects(response, reverse('user_login'))

    def test_document_add_typed_out(self):
        "Testing /documents/add/folder/<folder_id>"
        response = self.client.get(
            reverse('documents_document_add_typed', args=[self.folder.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_document_view_out(self):
        "Testing /documents/view/<document_id>"
        response = self.client.get(
            reverse('documents_document_view', args=[self.document.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_document_edit_out(self):
        "Testing /documents/edit/<document_id>"
        response = self.client.get(
            reverse('documents_document_edit', args=[self.document.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_document_delete_out(self):
        "Testing /documents/delete/<document_id>"
        response = self.client.get(
            reverse('documents_document_delete', args=[self.document.id]))
        self.assertRedirects(response, reverse('user_login'))

    # Files

    def test_file_view_out(self):
        "Testing /file/view/<file_id>"
        response = self.client.get(
            reverse('documents_file_view', args=[self.file.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_file_edit_out(self):
        "Testing /file/edit/<file_id>"
        response = self.client.get(
            reverse('documents_file_edit', args=[self.file.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_file_delete_out(self):
        "Testing /file/view/<file_id>"
        response = self.client.get(
            reverse('documents_file_delete', args=[self.file.id]))
        self.assertRedirects(response, reverse('user_login'))

    # Web Links

    def test_weblink_add_typed_out(self):
        "Testing /documents/weblink/add/<folder_id>"
        response = self.client.get(
            reverse('documents_weblink_add_typed', args=[self.folder.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_weblink_add_out(self):
        "Testing /documents/weblink/add/"
        response = self.client.get(reverse('documents_weblink_add'))
        self.assertRedirects(response, reverse('user_login'))

    def test_weblink_view_out(self):
        "Testing /documents/view/<weblink_id>"
        response = self.client.get(
            reverse('documents_weblink_view', args=[self.link.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_weblink_edit_out(self):
        "Testing /documents/edit/<weblink_id>"
        response = self.client.get(
            reverse('documents_weblink_edit', args=[self.link.id]))
        self.assertRedirects(response, reverse('user_login'))

    def test_weblink_delete_out(self):
        "Testing /documents/delete/<weblink_id>"
        response = self.client.get(
            reverse('documents_weblink_delete', args=[self.link.id]))
        self.assertRedirects(response, reverse('user_login'))
示例#42
0
def Upload(request):
	if request.method != "POST":
		raise Http404
	if not request.FILES:
		if "cliptext" not in request.POST:
			raise Http404
	
	token = utils.gentoken()
	while os.path.isdir("/var/www/synchy.org/main/synchy-django/media/%s" % token):
		token = utils.gentoken()
	os.mkdir("/var/www/synchy.org/main/synchy-django/media/%s" % token)
	os.mkdir("/var/www/synchy.org/main/synchy-django/media/%s/files" % token)

	if not request.FILES:
		if 'cliptext' in request.POST:
			group = Group()
			group.token = token
			group.multi = False
			group.save()

			file = File()
			file.group = group
			file.name = "clipboard.txt"
			file.mime = "text/plain"
			file.save()

			data = request.POST['cliptext']
			handle = open("/var/www/synchy.org/main/synchy-django/media/%s/files/%s" % (token, file.name), 'w+')
			handle.write(data)
			handle.close()
		else:
			os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s/files" % token)
			os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s" % token)
			return Http404
	else:
		if len(request.FILES) != 1:
			os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s/files" % token)
			os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s" % token)
			raise Http404
		else:
			if 'file' in request.FILES:
				group = Group()
				group.token = token
				group.multi = False
				group.save()

				file = File()
				file.group = group
				file.name = request.FILES['file'].name
				file.mime = request.FILES['file'].content_type
				file.save()

				data = request.FILES['file'].read()
				handle = open("/var/www/synchy.org/main/synchy-django/media/%s/files/%s" % (token, file.name), 'w+')
				handle.write(data)
				handle.close()
			elif 'zip' in request.FILES:
				group = Group()
				group.token = token
				group.multi = True
				group.save()

				if request.FILES['zip'].content_type != "application/octet-stream":
					os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s/files" % token)
					os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s" % token)
					raise Http404

				data = request.FILES['zip'].read()
				handle = open("/var/www/synchy.org/main/synchy-django/media/%s/%s%s%s%s" % (token, "files-", token[:2], token[-2:], ".zip"), 'w+')
				handle.write(data)
				handle.close()

				os.system('cd "%s/var/www/synchy.org/main/synchy-django/media/%s/files/"; sudo jar -xf %s/var/www/synchy.org/main/synchy-django/media/%s/files-%s%s.zip' % (os.getcwd(), token, os.getcwd(), token, token[:2], token[-2:]))
				
				zfile = Zip()
				zfile.group = group
				zfile.name = "%s%s%s%s" % ("files-", token[:2], token[-2:], ".zip")
				zfile.save()

				mime = magic.Magic(mime=True)
				for name in os.listdir("/var/www/synchy.org/main/synchy-django/media/%s/files/" % token):
					file = File()
					file.group = group
					file.name = name
					file.mime = mime.from_file("/var/www/synchy.org/main/synchy-django/media/%s/files/%s" % (token, name))
					file.save()
			else:
				os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s/files" % token)
				os.rmdir("/var/www/synchy.org/main/synchy-django/media/%s" % token)
				raise Http404
	
	return HttpResponse(token)
示例#43
0
def copy_folder(request, folder_id):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('existing_user'), {
                'logged_in': False,
                'form': forms.LoginForm(),
                })

    if request.method == 'POST':
        form = forms.FolderForm(request.POST)
        filterargs = {'author': request.user, 'name': request.POST['name']}
        if Folder.objects.filter(**filterargs):
            return render(request, 'secure_witness/copy_folder.html', {
                'folder_taken': True,
                'folder': Folder.objects.get(pk = folder_id),
                'folder_id': folder_id,
                'user': request.user,
                'form': form,
                'logged_in': request.user.is_authenticated(),
            })
        if form.is_valid():
            original_folder = Folder.objects.get(pk = folder_id)
            folder = Folder(
                author = original_folder.author,
                name = request.POST['name'],
                date_created = original_folder.date_created,
                date_modified = original_folder.date_modified,
                location = request.POST['location'],
                description = request.POST['description']
                )
            folder.save()
            for original_bulletin in Bulletin.objects.filter(folder = original_folder):
                bulletin = Bulletin(
                    author = original_bulletin.author,
                    name = original_bulletin.name,
                    folder = folder,
                    date_created = original_bulletin.date_created,
                    date_modified = original_bulletin.date_modified,
                    location = original_bulletin.location,
                    description = original_bulletin.description
                    )
                bulletin.save()
                for original_file in File.objects.filter(bulletin = original_bulletin):
                    newFile = File(
                        author = original_file.author,
                        bulletin = bulletin,
                        content = original_file.content,
                        name = original_file.name,
                        rand = original_file.rand,
                        check = original_file.check,
                        encryption_params = original_file.encryption_params,
                        date_created = original_file.date_created,
                        date_modified = original_file.date_modified
                        )
                    newFile.save()
            return HttpResponseRedirect(reverse('home'), {
                    'logged_in': request.user.is_authenticated(),
                    'form': forms.LoginForm(),
                    })
    else:
        f = get_object_or_404(Folder, pk = folder_id)
        form = forms.FolderForm(instance = f)
    return render(request, 'secure_witness/copy_folder.html', {
            'folder_id': folder_id,
            'form': form,
            'folder': Folder.objects.get(pk = folder_id),
            'logged_in': request.user.is_authenticated(),
    })
示例#44
0
def copy_bulletin(request, bulletin_id):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('existing_user'), {
                'logged_in': request.user.is_authenticated(),
                'form': forms.LoginForm(),
                })

    if request.method == 'POST':
        form = forms.BulletinForm(request.POST)
        original_bulletin = Bulletin.objects.get(pk = bulletin_id)
        f = original_bulletin.folder
        filterargs = {'author': request.user, 'name': request.POST['name'], 'folder': f}
        if Bulletin.objects.filter(**filterargs):
            return render(request, 'secure_witness/copy_bulletin.html', {
                'bulletin_taken': True,
                'bulletin_id': bulletin_id,
                'bulletin': original_bulletin,
                'user': request.user,
                'form': form,
                'folder': f,
                'folder_id': f.pk,
                'logged_in': request.user.is_authenticated(),
            })
        if form.is_valid():
            bulletin = Bulletin(
                author = original_bulletin.author,
                name = request.POST['name'],
                folder = original_bulletin.folder,
                date_created = datetime.now(),
                date_modified = datetime.now(),
                location = request.POST['location'],
                description = request.POST['description']
                )
            bulletin.save()
            for original_file in File.objects.filter(bulletin = original_bulletin):
                newFile = File(
                    author = original_file.author,
                    bulletin = bulletin,
                    content = original_file.content,
                    # name = original_file.name,
                    name = 'test',
                    rand = original_file.rand,
                    check = original_file.check,
                    encryption_params = original_file.encryption_params,
                    date_created = datetime.now(),
                    date_modified = datetime.now(),
                    )
                newFile.save()
            return HttpResponseRedirect(reverse('get_folder', kwargs={'folder_id': bulletin.folder.pk}), {
                        'folder_id': bulletin.folder.pk,
                        'folder': bulletin.folder,
                        'logged_in': request.user.is_authenticated(),
                        })
    else:
        b = get_object_or_404(Bulletin, pk = bulletin_id)
        f = b.folder
        form = forms.BulletinForm(instance = b)
    return render(request, 'secure_witness/copy_bulletin.html', {
            'bulletin_id': bulletin_id,
            'form': form,
            'bulletin': Bulletin.objects.get(pk = bulletin_id),
            'logged_in': request.user.is_authenticated(),
            'folder': f,
            'folder_id': f.pk,
    })
def upload_file(request, folder_id):
	#import pdb; pdb.set_trace()
	if request.method=='POST':
		handle_uploaded_file(request.FILES['file'], request.FILES['file'].name)		
		f = File(file_name = request.FILES['file'].name, file_path = request.FILES['file'].name, parent_folder = folder_id, created_on = '2011-1-1 12:00', created_by = 1, last_updated_on = '2011-1-1 12:00', last_updated_by = 1)
		f.save()
示例#46
0
def convert(request):
	if request.method=='POST':

		exfile = str(request.FILES['excelfile'].name)
		f = File()
		f.excel = request.FILES['excelfile']
		f.save()
		sheet = pyexcel.get_sheet(file_name=f.excel.name)
		h=0
		while h<3:
			
			i=4
			if h==0:
				x=0
			else:
				x=(h*80)
			while i<124:
				if h == 0:
					st=Student2()
				if h == 1:
					st=Student3()
				if h == 2:
					st=Student4()
	
				
				st.name = sheet[i,x+3]
				print st.name
				
				st.sap_id = sheet[i,x+2]
				
				st.s1_name = sheet[1,x+4]
			
				st.s1_t_c = sheet[i,x+7]
				st.s1_t_g = sheet[i,x+9]
				st.s1_p_c = sheet[i,x+12]
				st.s1_p_g = sheet[i,x+13]
				st.s1_l = 4
			
				st.s1_t = 1

				st.s2_name = sheet[1,x+15]
				st.s2_t_c = sheet[i,x+18]
				st.s2_t_g = sheet[i,x+20]
				st.s2_p_c = sheet[i,x+23]
				st.s2_p_g = sheet[i,x+24]
				st.s2_l = 3
				st.s2_p = 1
				st.s3_name = sheet[1,x+26]
				st.s3_t_c = sheet[i,x+29]
				st.s3_t_g = sheet[i,x+31]
				st.s3_p_c = sheet[i,x+34]
				st.s3_p_g = sheet[i,x+35]
				st.s3_l = 3
				st.s3_p = 1




				st.s4_name = sheet[1,x+37]

				st.s4_t_c = sheet[i,x+40]
				st.s4_t_g = sheet[i,x+42]
				st.s4_p_c = sheet[i,x+47]
				st.s4_p_g = sheet[i,x+49]
				st.s4_l = 5
				st.s4_p = 2


				st.s5_name = sheet[1,x+51]
				st.s5_t_c = sheet[i,x+54]
				st.s5_t_g = sheet[i,x+56]
				st.s5_p_c = sheet[i,x+61]
				st.s5_p_g = sheet[i,x+63]
				st.s5_l = 4
				st.s5_p = 2



				st.s6_name = sheet[1,x+65]
				st.s6_t_c = sheet[i,x+68]
				st.s6_t_g = sheet[i,x+70]
				st.s6_l = 2


				st.s7_name = sheet[1,x+72]
				st.s7_t_c = sheet[i,x+73]
				st.s7_t_g = sheet[i,x+74]

				st.s7_p = 4


				st.totalc = 27
				st.totalg = sheet[i,x+78]
				st.gpa = sheet[i,x+79]
				st.save()

				
				i+=1
			h+=1
		f.delete()



	return render(request,"convert.html")
示例#47
0
def upload(request):
    if request.method == 'POST':
        # 上传到本地目录
        try:
            path = request.POST.get('path')
            proxy = request.POST.get('proxy')
            proxy_host = request.POST.getlist('proxy_host')
            # 上传到本地
            f = request.FILES['file']
            df = handle_uploaded_file(f)
            files = {'file': (f.name, open(df, 'rb'))}
            params = {'action': 'upload'}
            # 通过proxy处理文件
            proxy_obj = Proxy.objects.get(id=proxy)
            tnow = datetime.datetime.now()

            # 调用proxy接口,上传文件
            api = API('{0}/v1.0/upload'.format(proxy_obj.url), proxy_obj.username,
                      CRYPTOR.decrypt(proxy_obj.password))

            result, code = api.req_post(data=params, files=files)
            if code != 200:
                file = File(path=path, proxy=proxy_obj, create_time=tnow, status='01',
                            result="上传文件失败")
                file.save()
                raise ServerError(result['messege'])
                # 上传文件成功之后,调用proxy接口,进行文件上传任务
            hosts = []
            if not proxy_host:
                hosts = Asset.objects.all().filter(proxy=proxy_obj)
                if not hosts:
                    # 没有可执行主机
                    file = File(path=path, proxy=proxy_obj, create_time=tnow, status='01',
                                result="没有可执行主机")
                    file.save()
                    raise RuntimeError("没有可执行主机")

            else:
                for host_id in proxy_host:
                    hosts.append(Asset.objects.get(id=host_id))

            host_list = []
            resource = []
            params = {}
            trigger_kwargs = {}
            trigger_kwargs['year'] = tnow.year
            trigger_kwargs['month'] = tnow.month
            trigger_kwargs['day'] = tnow.day
            trigger_kwargs['hour'] = tnow.hour
            trigger_kwargs['minute'] = tnow.minute+1
            trigger_kwargs['second'] = tnow.second
            params['trigger_kwargs'] = trigger_kwargs
            params['task_name'] = 'ansible'
            task_kwargs = {}
            task_kwargs['module_name'] = 'copy'
            task_kwargs['module_args'] = 'src={0} dest={1}'.format(result.get('fp'), path)

            # 构建inventory 和 构建主机list
            for host in hosts:
                host_list.append(host.networking.all()[0].ip_address)
                tmp_d = dict()
                tmp_d['hostname'] = host.networking.all()[0].ip_address
                tmp_d['port'] = host.port
                tmp_d['username'] = host.username
                tmp_d['password'] = CRYPTOR.decrypt(host.password)
                # 用于前端确定选择的asset
                tmp_d['id'] = host.id
                resource.append(tmp_d)
            task_kwargs['host_list'] = host_list
            task_kwargs['resource'] = resource
            params['task_kwargs'] = task_kwargs
            # 调用proxy接口,创建任务
            api = APIRequest('{0}/v1.0/job'.format(proxy_obj.url), proxy_obj.username,
                             CRYPTOR.decrypt(proxy_obj.password))
            result, code = api.req_post(json.dumps(params))
            if code != 200:
                file = File(path=path, proxy=proxy_obj, create_time=tnow,
                            status='01', result="上传文件失败")
                file.save()
            else:
                file = File(path=path, proxy=proxy_obj, task_uuid=result['job']['job_id'],
                            create_time=tnow)
                file.save()
        except Exception, e:
            logger.error(traceback.format_exc())
        return HttpResponseRedirect(reverse('file_upload'))