예제 #1
0
def upload_files(request, id):
    """Upload file to dir with given id"""
    try:
        for the_file in request.FILES.getlist('file'):
            File.upload(the_file, id, request.user,
                        lambda msg: add_message_to_session(request, msg))
    except:
        return HttpResponse(status=404)

    return HttpResponse(status=201)
예제 #2
0
def files_in_folder(gh_access_token,
                    path,
                    username,
                    repo,
                    repo_id,
                    request=None):
    r = requests.get(
        f"https://api.github.com/repos/{username}/{repo}/contents/" + path,
        headers={"Authorization": f"token {gh_access_token}"})
    for i in r.json():
        print(colored(path + "/", "red"))
        subdir = Directory.objects.get(repo_id=repo_id, path=path + "/")
        if i["type"] == "dir":
            Directory(repo_id=repo_id,
                      subdir=subdir.id,
                      name=i["name"],
                      path=path + "/" + i["name"] + "/",
                      branch="master").save()
            files_in_folder(gh_access_token, path + "/" + i["name"], username,
                            repo, repo_id)
        else:
            content = requests.get(i["download_url"]).text
            File(repo_id=repo_id,
                 filename=i["name"],
                 subdir=subdir.id,
                 url=upload_s3(request, data=content, filename=i["name"]),
                 branch="master",
                 path=path + "/" + i["name"] + "/").save()
            print(path + "/" + i["name"])
예제 #3
0
def setup_testing_main(user):
    from main.models import File, SignableDocument, Signature
    File(id=1,
         title='title',
         description='descripption',
         file='sound/bigbox.mp3',
         access='all',
         group='misc').save()
    SignableDocument(id=1,
                     title='unsigned',
                     description='description',
                     file='sound/messagebox.mp3',
                     active=True).save()
    SignableDocument(id=2,
                     title='signed',
                     description='description',
                     file='sound/smallbox.mp3',
                     active=True).save()
    Signature(
        user=user,
        document_id=2,
        ip='127.0.0.1',
        document_sha=
        "e788144a95d952a46536b4731ae4624755aef9133a9e200e99fd2d8022a1795d"
    ).save()
예제 #4
0
def edit(request, username, repo):
    user = User.objects.get(username=username)
    r = Repository.objects.get(user_id=user.id, name=repo)
    f = File.objects.get(path=request.GET["path"], repo_id=r.id)

    if request.method == "POST":
        filename = request.POST["filename"]
        commit = request.POST["commit-message"]
        content = request.POST["content"]

        url = upload_s3(request, data=content, filename=filename)

        f.delete()
        File(repo_id=r.id,
             filename=filename,
             subdir=f.subdir,
             url=url,
             branch=f.branch,
             path=f.path.replace(f.filename, request.POST["filename"])).save()
        file = File.objects.get(repo_id=r.id,
                                filename=filename,
                                subdir=f.subdir,
                                url=url,
                                branch=f.branch,
                                path=f.path.replace(f.filename,
                                                    request.POST["filename"]))

        Commit(commit_id=str(uuid.uuid4()),
               repo_id=r.id,
               user_id=user.id,
               message=commit,
               branch="master",
               timestamp=datetime.datetime.now()).save()
        c = Commit.objects.filter(repo_id=r.id,
                                  user_id=user.id,
                                  message=commit,
                                  branch="master")[::-1][0]
        print(colored(c.commit_id, "magenta"))
        Commit_File(commit_id=c.commit_id, url=file.url, path=file.path).save()

        f = File.objects.get(path=request.GET["path"], repo_id=r.id)
        return HttpResponseRedirect(f"/{username}/{repo}/{f.path}")

    else:
        content = get_s3(f.url)

        if pathlib.Path(f.filename).suffix == ".py":
            language = "python"
        elif pathlib.Path(f.filename).suffix == ".js":
            language = "javascript"
        elif pathlib.Path(f.filename).suffix == ".html":
            language = "html"

        return render(
            request, "repo/edit.html", {
                "content": content.decode("utf-8"),
                "language": language,
                "filename": f.filename
            })
예제 #5
0
def commit(request):
    user = User.objects.get(username=request.POST["username"])
    r = Repository.objects.get(name=request.POST["repo"])
    Commit(commit_id=request.POST["id"], repo_id=r.id, user_id=user.id, message=request.POST["message"], branch=request.POST["branch"]).save()
    c = Commit.objects.get(commit_id=request.POST["id"], repo_id=r.id, user_id=user.id, message=request.POST["message"], branch=request.POST["branch"])
    data = json.loads(request.POST["data"])
    try:
        for i in data["new"]:
            aws_url = i[0]
            dir_path = str(pathlib.Path(i[1]).parent)[1:len(str(pathlib.Path(i[1]).parent))] + "/"
            print(dir_path)
            subdir = upload(r, request.POST["branch"], dir_path)
            print(subdir)
            filename = os.path.split(i[1][1:len(i[1])-1])[1]
            File(repo_id=r.id, filename=filename, subdir=subdir, url=i[0], branch=request.POST["branch"], path=i[1]).save()
            f = File.objects.get(repo_id=r.id, filename=filename, subdir=subdir, url=i[0], branch=request.POST["branch"], path=i[1])
            Commit_File(commit_id=c.commit_id, url=f.url, path=f.path).save()

    except KeyError:
        pass

    try:
        for i in data["changed"]:
            # print(i[1])
            # print(colored(os.path.split(i[1][:-1])[1], "red"))
            f = File.objects.get(repo_id=r.id, path=i[1])
            f.delete()
            File(repo_id=r.id, filename=os.path.split(i[1][:-1])[1], subdir=f.subdir, url=i[0], branch=request.POST["branch"], path=i[1]).save()
            f = File.objects.get(repo_id=r.id, filename=os.path.split(i[1][:-1])[1], subdir=f.subdir, url=i[0], branch=request.POST["branch"], path=i[1])
            Commit_File(commit_id=c.commit_id, url=f.url, path=f.path).save()
    except KeyError:
        pass

    try:
        for i in data["delete"]:
            try:
                f = File.objects.get(repo_id=r.id, path=i)
                print(i)
                f.delete()
                Commit_File(commit_id=c.commit_id, code=0, path=i).save()
            except:
                pass
    except KeyError:
        pass

    return HttpResponse("success")
예제 #6
0
def test_mdtype():
    assert isinstance(load._mdtype(File()), MetadataAppliesToType)
    assert isinstance(load._mdtype(Transfer()), MetadataAppliesToType)
    assert isinstance(load._mdtype(SIP()), MetadataAppliesToType)

    class UnknownClass(object):
        pass

    with pytest.raises(TypeError) as excinfo:
        load._mdtype(UnknownClass())
    assert "Types supported: File, Transfer, SIP" in str(excinfo.value)
예제 #7
0
def add_file(request):

    if request.method == "POST":

        username = request.POST["username"]
        user = User.objects.get(username=username)

        repo = request.POST["repo"]
        repo = Repository.objects.get(name=repo, user_id=user.id)

        path = request.POST["path"]
        filename = request.POST["filename"]
        url = request.POST["url"]

        if path[len(path)-1] == "/" and path[len(path)-2] == "/":
            path = path[0:len(path)-1]

        d = Directory.objects.get(repo_id=repo.id, path=path)
        f = File(repo_id=repo.id, filename=filename, directory_id=d.id, url=url)
        f.save()

        return JsonResponse({"message": "success"})
def crowd_upload_files(request):

    # Handle file delete
    if request.is_ajax():
        file = File.objects.get(id=request.POST.get('file_id'))
        file.delete()
        data = {'res': 'file deleted'}
        # return if it was successful to the client
        return render_to_json_response(data)

    # Handle file upload
    if request.method == 'POST':
        form = DocumentForm(request.POST, request.FILES)
        if form.is_valid():
            filename = request.FILES['docfile'].name
            docfile = request.FILES['docfile']
            new_file = File(filename=filename,
                            uploader=request.user,
                            file=docfile)
            new_file.save()

            # Redirect to the document list after POST
            return HttpResponseRedirect(reverse('crowd_upload_files'))

    # redirect to homepage if they're not logged in
    if (not request.user.is_authenticated()) or UserType.objects.get(
            user_id=request.user.id).type != 'director':
        return redirect('/')
    else:
        user_files = File.objects.filter(uploader=request.user)
        form = DocumentForm()
        fullname = request.user.first_name + ' ' + request.user.last_name  # get user's fullname
        template = loader.get_template('main/upload_files.html')
        context = {
            'fullname': fullname,
            'form': form,
            'user_files': user_files
        }
        return HttpResponse(template.render(context, request))
예제 #9
0
def new(r):
    if r.POST:
        novo = File()
        file = r.FILES['file']
        novo.content = file
        novo.name = file.name
        novo.title = r.POST['title'] or file.name
        novo.save()

        return HttpResponseRedirect(reverse('upload-index'))
    else:
        return render_to_response('main/templates/new.html', context_instance=RequestContext(r))
예제 #10
0
def fork(request, username, repo):
    user = User.objects.get(username=username)
    r = Repository.objects.get(user_id=user.id, name=repo)
    Repository(user_id=request.user.id,
               name=repo,
               description=r.description,
               status=r.status,
               fork=r.id).save()
    user_r = Repository.objects.get(user_id=request.user.id,
                                    name=repo,
                                    description=r.description,
                                    status=r.status)
    Branch(repo_id=user_r.id, name="master").save()

    dirs = Directory.objects.filter(repo_id=r.id)

    for d in dirs:
        if d.path == "/":
            Directory(repo_id=user_r.id,
                      subdir=0,
                      name=d.name,
                      path=d.path,
                      branch=d.branch).save()
        else:
            path = d.path.split("/")
            path.pop(len(path) - 1)
            path.pop(len(path) - 1)
            subdir_path = dirize(path)
            print(
                colored((d.path, d.path.split("/"), path, subdir_path), "red"))
            subdir = Directory.objects.get(repo_id=user_r.id, path=subdir_path)
            Directory(repo_id=user_r.id,
                      subdir=subdir.id,
                      name=d.name,
                      path=d.path,
                      branch=d.branch).save()

        dir = Directory.objects.get(repo_id=user_r.id, path=d.path)
        files = File.objects.filter(repo_id=r.id, subdir=d.id)

        for f in files:
            File(repo_id=user_r.id,
                 filename=f.filename,
                 subdir=dir.id,
                 branch=f.branch,
                 path=f.path,
                 url=f.url).save()

    return HttpResponseRedirect(f"/repo/{request.user.username}/{repo}")
    def create_file(self, pdf):

        common_utils = CommonUtils()
        internal_name = common_utils.create_token() + '.pdf'

        fs = FileSystemStorage(location=settings.BASE_POOL_PDF)
        filename = fs.save(internal_name, pdf)

        file_url = fs.url(filename)
        file_db = File()
        file_db.user_name = pdf.name
        file_db.internal_name = internal_name
        file_db.date = datetime.datetime.now()
        file_db.status = file_db.STARTED
        file_db.save()

        p = Process(target=self.pdf_process, args=(file_db.id, ))
        p.start()
예제 #12
0
파일: views.py 프로젝트: AnomalRoil/truffe2
def file_download_list(request):

    from main.models import File

    group = request.GET.get("group")

    if group not in ("accounting", "cs", "misc"):
        raise Http404

    if not File.static_rights_can("LIST_{}".format(group.upper()), request.user):
        raise Http404

    files = File.objects.filter(deleted=False, group=group).order_by("title")

    if request.user.is_external():
        files = files.filter(access="all")

    return render(request, "main/file/download.html", {"files": files, "group": group})
예제 #13
0
파일: views.py 프로젝트: maltherd/truffe2
def file_download_list(request):

    from main.models import File

    group = request.GET.get('group')

    if group not in ('accounting', 'cs', 'misc'):
        raise Http404

    if not File.static_rights_can('LIST_{}'.format(group.upper()), request.user):
        raise Http404

    files = File.objects.filter(deleted=False, group=group).order_by('title')

    if request.user.is_external():
        files = files.filter(access='all')

    return render(request, 'main/file/download.html', {'files': files, 'group': group})
예제 #14
0
def file_download_list(request):

    from main.models import File

    group = request.GET.get('group')

    if group not in ('accounting', 'cs', 'misc'):
        raise Http404

    if not File.static_rights_can('LIST_{}'.format(group.upper()), request.user):
        raise Http404

    files = File.objects.filter(deleted=False, group=group).order_by('title')

    if request.user.is_external():
        files = files.filter(access='all')

    return render(request, 'main/file/download.html', {'files': files, 'group': group})
예제 #15
0
def multiple_transfer_file_objs(db, transfer, tmp_path, multiple_file_paths):
    relative_paths = [
        "".join([
            transfer.currentlocation,
            six.text_type(path.relative_to(tmp_path).as_posix(), "utf-8"),
        ]) for path in multiple_file_paths
    ]

    file_objs = [
        File(
            uuid=uuid.uuid4(),
            transfer=transfer,
            originallocation=relative_path,
            currentlocation=relative_path,
            removedtime=None,
            size=113318,
            checksum=
            "35e0cc683d75704fc5b04fc3633f6c654e10cd3af57471271f370309c7ff9dba",
            checksumtype="sha256",
        ) for relative_path in relative_paths
    ]
    return File.objects.bulk_create(file_objs)
예제 #16
0
def download(r, id):
    f = get_object_or_404(File(), id=id)
    resp = HttpResponse(FileWrapper(f.content), content_type='application/octet-stream')
    resp['Content-Disposition'] = 'attachment; filename={0}'.format(f.name)
    return resp
예제 #17
0
def upload(request, username, repo):

    try:
        b = request.GET["b"]
    except:
        b = "master"

    user = User.objects.get(username=username)
    r = Repository.objects.get(name=repo, user_id=user.id)

    if request.method == "POST":
        url = request.POST["path"][:-1].split("/")
        path = "/"
        subdir = Directory.objects.get(repo_id=r.id, path="/", branch=b).id
        f_url = upload_s3(request)
        for i in url:
            print(i)
            if i == "":
                break
            else:
                path += f"{i}/"
                try:
                    d = Directory.objects.get(repo_id=r.id,
                                              path=path,
                                              branch=b)
                    print(colored(path + " exist", "red"))
                except Directory.DoesNotExist:
                    Directory(repo_id=r.id,
                              subdir=subdir,
                              name=i,
                              path=path,
                              branch=b).save()
                    print(colored(path + " doesn't exist.", "blue"))
                try:
                    subdir = Directory.objects.get(repo_id=r.id,
                                                   path=path,
                                                   branch=b).id
                    print(colored(path + " is the new subdir", "magenta"))
                except Exception as e:
                    d = Directory.objects.filter(repo_id=r.id,
                                                 path=path,
                                                 branch=b)
                    d[::-1][0].delete()
                    d = Directory.objects.get(repo_id=r.id,
                                              path=path,
                                              branch=b)
                    subdir = d.id

        File(repo_id=r.id,
             filename=request.FILES["file"].name,
             subdir=subdir,
             url=f_url,
             branch=b,
             path=path + request.FILES["file"].name + "/").save()

        try:
            c = Commit.objects.get(commit_id=request.POST["commit_id"],
                                   branch=b)
        except:
            Commit(commit_id=request.POST["commit_id"],
                   repo_id=r.id,
                   user_id=request.user.id,
                   message=request.POST["message"],
                   branch=b).save()
            c = Commit.objects.get(commit_id=request.POST["commit_id"],
                                   branch=b)

        f = File.objects.get(repo_id=r.id,
                             filename=request.FILES["file"].name,
                             subdir=subdir,
                             url=f_url,
                             branch=b,
                             path=path + request.FILES["file"].name + "/")
        Commit_File(commit_id=c.commit_id, url=f.url, path=f.path).save()

        return JsonResponse({"data": "success"})

    else:
        return render(request, "repo/upload.html", {
            "repo": repo,
            "username": username,
            "commit_id": str(uuid.uuid4()),
        })
예제 #18
0
 def save_model(self, request, obj: File, form: Form, change):
     if form.is_valid() and not obj.author:
         user = request.user
         obj.author = user
     super().save_model(request, obj, form, change)
예제 #19
0
파일: views.py 프로젝트: shashisp/cast
def submit(request):
	from main.models import File
	start_time = time.strftime('%x %X %z')
	a = datetime.datetime.now()
	file1 = request.FILES['file']
	data = csv.reader(file1)
	email = request.POST['email']
	global _file_id
	#_file_count+=1
	#print _file_id
	
	detail = File(csvfile=file1, email=email, pid=_file_id)
	
	detail.save()
	
	
	
	account_id = []
	for row in data:
		#print row
		account_id.append(row)
	#print account_id
	x = []
	for i in account_id:
		for k in i:
			print k
			x.append(k)
	
	
	current_acnt_id = []
	for i in x:
		current_acnt_id.append(i.split('_'))
	k = []	
	for j in current_acnt_id:
		k.append(j[1])
	
	print k

	           #list of current account ids as strings
	intlist = []
	for i in k:
		j = int(i)
		intlist.append(j)
		#print j
	#print intlist      # account ids typecasted in to integers

		
	
 
	id_list = []
	for i in x:
		data = requests.get('https://graph.facebook.com/'+i+'/customaudiences?fields=account_id&access_token=CAACcXbmWPQMBAHxPC0pKxsN5jZBzlR9UU1Vj8wMpZBkwwg1om63w4rlCh5oxMbkchL5KTwmWMOQtnSig1pKwoG6V7wuAbQ2mDoiarKglnN9a0CWdebQesJBVCrUO1WmyMmzMk6ZBixPLRzgNDhR4sd8JNrnoU5FsWfDKnls6anNJFjviDVj')
		jsondata = data.json()['data']
		print jsondata
		
		for j in jsondata:
			if j['account_id'] in intlist:
				id_list.append(j['id']) #getting list of ID's
	
	failed_request = 0
	Succeeded_request = 0
	mailresponse = []
	sucess_ids = []
	failed_ids = []
	for i in intlist:
		for j in id_list:
				payload = {'access_token': 'CAACcXbmWPQMBAHxPC0pKxsN5jZBzlR9UU1Vj8wMpZBkwwg1om63w4rlCh5oxMbkchL5KTwmWMOQtnSig1pKwoG6V7wuAbQ2mDoiarKglnN9a0CWdebQesJBVCrUO1WmyMmzMk6ZBixPLRzgNDhR4sd8JNrnoU5FsWfDKnls6anNJFjviDVj' ,'adaccounts': [i]} 
				r = requests.post('https://graph.facebook.com/'+j+'/adaccounts', data=payload)
				#counting the response
				if r.json()==1:
					sucess_ids.append(j)
					Succeeded_request+=1
				else:
					failed_request+=1
					failed_ids.append(j)
				

	x = str(Succeeded_request)
	y = str(failed_request)

	attachment = File.objects.get(pid=_file_id)
	_file_id+=1
	attachfile = attachment.csvfile
	last_time = time.strftime('%x %X %z')
	b = datetime.datetime.now()
	Duration = (b-a)
	email_body = """Submitted  at:"""+start_time+"""
Finished at: """+last_time+"""
Duration : """+str(Duration)+"""
Succeeded : """+x+"""
Failed : """+y
   	"""
   		creating log files of 	
	sucess_ids_str = ''.join(sucess_ids)
	failed_ids_str = ''.join(failed_ids)
	log =open("sucess_logs.txt", "a")
	log.write(sucess_ids_str)
	log.close()
	"""

	mail = EmailMessage('Audience Sharing | File: '+attachfile.name.split('/')[4]+'| '+x+' Succeeded, '+y+' Failed', email_body, to=[email])
	mail.attach(attachfile.name.split('/')[4], attachfile.read(), "text/csv")
	#mail.attach('sucess_ids.txt', 'sucess_ids.txt', 'text')
	mail.send()
	_file_id+=1
	

	return HttpResponseRedirect('/')
예제 #20
0
def upload_file(request):
    authenticated_user = get_authenticated_user(request)
    cloud = Cloud.objects.get(owner=authenticated_user)

    # If request method == POST
    if request.method == 'POST':
        form = FileUploadForm(request.POST, request.FILES)

        # If form valid
        if form.is_valid():
            image = form.cleaned_data['image']
            compress = form.cleaned_data['compress']

            file = File(cloud=cloud, file=image)
            file.save()

            # If user want to compress the image
            if compress is True:
                compress_image(file.file.path)

            # calculate file size
            filesize = file.file.size / 1000
            if filesize < 100:
                filesize = 0.1

            elif filesize < 200:
                filesize = 0.2

            elif filesize < 300:
                filesize = 0.3

            elif filesize < 400:
                filesize = 0.4

            elif filesize < 500:
                filesize = 0.5

            elif filesize < 600:
                filesize = 0.6

            elif filesize < 700:
                filesize = 0.7

            elif filesize < 800:
                filesize = 0.8

            elif filesize < 900:
                filesize = 0.9

            else:
                filesize = round(filesize / 100) / 10

            # Calculate cloud's used space
            cloud.used_space = float(cloud.used_space)
            cloud.used_space = round((cloud.used_space + filesize) * 10) / 10
            cloud.used_percent = round(
                float(cloud.used_space) * 1000 / float(cloud.space)) / 10
            cloud.save()

            # Redirect user to "cloud" page
            return HttpResponseRedirect('/cloud/')

    # If request method == GET
    else:
        form = FileUploadForm()  # Give the form to user

    # Check cloud's available space
    available_space = float(cloud.space) - float(cloud.used_space)
    if available_space >= 10.0:
        available_space = True

    context = {
        'authenticated_user': authenticated_user,
        'new_notifications': get_new_notifications(authenticated_user),
        'form': form,
        'cloud': cloud,
        'available_space': available_space,
    }

    # Show "upload file" page template to user
    return render(request, 'cloud/upload_file.html', context)