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)
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"])
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()
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
})
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")
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)
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))
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))
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()
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})
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})
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})
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)
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
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()),
})
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)
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('/')
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)
