def _test_open_file(self):
self._test_upload_file()
gds = GoogleDriveStorage()
f = gds.open(u'/test4/gdrive_logo.png', "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
def test_list_folder(self):
self._test_upload_file()
gds = GoogleDriveStorage()
(directories, files) = gds.listdir("/test4")
pprint(directories)
pprint(files)
self.assertTrue(len(files) > 0, "Unable to read directory data")
def _test_upload_file(self):
gds = GoogleDriveStorage()
file_name = "{0}{1}{2}".format(os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/gdrive_logo.png")
result = gds.save("/test4/gdrive_logo.png", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
def test_check_root_file_exists(self):
gds = GoogleDriveStorage()
file_data = gds._check_file_exists("How to get started with Drive")
pprint(file_data)
print "\n\n"
self.assertIsNotNone(
file_data, u"Unable to find file 'How to get started with Drive'")
def _test_list_folder(self):
self._test_upload_file()
gds = GoogleDriveStorage()
(directories, files) = gds.listdir("/test4")
pprint(directories)
pprint(files)
self.assertTrue(len(files) > 0, "Unable to read directory data")
def _test_open_file(self):
self._test_list_folder()
gds = GoogleDriveStorage()
f = gds.open(u'/test4/gdrive_logo.png', "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
def test_check_or_create_folder(self):
gds = GoogleDriveStorage()
folder_data = gds._get_or_create_folder("test4/folder")
pprint(folder_data)
print "\n\n"
self.assertIsNotNone(folder_data,
u"Unable to find or create folder 'test4/folder")
def _test_upload_file(self):
gds = GoogleDriveStorage()
file_name = "{0}{1}{2}".format(os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/gdrive_logo.png")
result = gds.save("/test4/gdrive_logo.png", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
def test_open_big_file(self):
self._test_list_folder()
gds = GoogleDriveStorage()
f = gds.open(u'/test5/huge_file', "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
time.sleep(10)
def test_open_big_file(self):
self._test_list_folder()
gds = GoogleDriveStorage()
f = gds.open(u'/test5/huge_file', "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
time.sleep(10)
def test_permission_full_write(self):
full_write_permission = GoogleDriveFilePermission(GoogleDrivePermissionRole.WRITER,
GoogleDrivePermissionType.ANYONE)
gds = GoogleDriveStorage(permissions=(full_write_permission,))
file_name = "{0}{1}{2}".format(os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/gdrive_logo.png")
result = gds.save("/test4/gdrive_logo.png", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
f = gds.open(result, "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
time.sleep(10)
def test_permission_full_write(self):
full_write_permission = GoogleDriveFilePermission(GoogleDrivePermissionRole.WRITER,
GoogleDrivePermissionType.ANYONE)
gds = GoogleDriveStorage(permissions=(full_write_permission,))
file_name = "{0}{1}{2}".format(os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/gdrive_logo.png")
result = gds.save("/test4/gdrive_logo.png", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
f = gds.open(result, "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
time.sleep(10)
def test_upload_big_file(self):
gds = GoogleDriveStorage()
file_name = "{0}{1}{2}".format(os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/huge_file")
with open(file_name, "wb") as out:
out.truncate(1024 * 1024 * 20)
result = gds.save("/test5/huge_file", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
os.remove(file_name)
time.sleep(10)
def test_upload_big_file(self):
gds = GoogleDriveStorage()
file_name = "{0}{1}{2}".format(
os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/huge_file")
with open(file_name, "wb") as out:
out.truncate(1024 * 1024 * 20)
result = gds.save("/test5/huge_file", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
os.remove(file_name)
time.sleep(10)
def delete(request):
""" deletu photo in db """
photo_id = request.POST.get('object_id')
try:
photo = Photo.objects.get(pk=photo_id)
except KeyError:
response = "KeyError for photo id"
else:
if 'TRAVIS' not in os.environ:
from gdstorage.storage import GoogleDriveStorage
gd_storage = GoogleDriveStorage()
# delete image
gd_storage.delete(photo.image.name)
else:
from django.core.files.storage import default_storage
default_storage.delete(photo.image)
photo.delete()
response = "Photo supprimée"
return response
def delete(request):
""" deletu actu in db """
actu_id = request.POST.get('object_id')
try:
actu = Actu.objects.get(pk=actu_id)
except KeyError:
response = "KeyError for actu id"
else:
# delete image
if 'TRAVIS' not in os.environ:
from gdstorage.storage import GoogleDriveStorage
gd_storage = GoogleDriveStorage()
gd_storage.delete(actu.image.name)
else:
from django.core.files.storage import default_storage
default_storage.delete(actu.image)
actu.delete()
response = "Actu supprimée"
return response
def delete(request):
""" deletu video in db """
video_id = request.POST.get('object_id')
try:
video = Video.objects.get(pk=video_id)
except KeyError:
response = "KeyError for video id"
else:
if 'TRAVIS' not in os.environ:
from gdstorage.storage import GoogleDriveStorage
gd_storage = GoogleDriveStorage()
# delete video
gd_storage.delete(video.video.name)
else:
from django.core.files.storage import default_storage
default_storage.delete(video.video)
video.delete()
response = "Vidéo supprimée"
return response
def test_multiple_permission(self):
full_write_to_foo = GoogleDriveFilePermission(
GoogleDrivePermissionRole.WRITER, GoogleDrivePermissionType.USER,
"*****@*****.**")
read_only_to_anyone = GoogleDriveFilePermission(
GoogleDrivePermissionRole.READER, GoogleDrivePermissionType.ANYONE)
gds = GoogleDriveStorage(permissions=(
full_write_to_foo,
read_only_to_anyone,
))
file_name = "{0}{1}{2}".format(
os.path.dirname(os.path.abspath(__file__)), os.path.sep,
"../test/gdrive_logo.png")
result = gds.save("/test4/gdrive_logo.png", open(file_name, 'rb'))
pprint(result)
self.assertIsNotNone(result, u'Unable to upload file to Google Drive')
f = gds.open(result, "rb")
pprint(f)
pprint(len(f))
self.assertIsNotNone(f, "Unable to load data from Google Drive")
def update(request, form, actu_id):
""" update actu """
try:
actu = Actu.objects.get(pk=actu_id)
except KeyError:
pass
else:
form.errors
change_field = False
if form.instance.image != "":
form_image = request.FILES['image']
if 'TRAVIS' not in os.environ:
from gdstorage.storage import GoogleDriveStorage
gd_storage = GoogleDriveStorage()
# storage new and delete old image
gd_storage.delete(actu.image.name)
actu.image = gd_storage.save(
"".join(["actus/", form_image.name]), form_image)
actu.save()
code_img = actu.image.url.split("/")[5]
actu.display_url_img = "".join(
["https://drive.google.com/uc?id=", code_img])
else:
from django.core.files.storage import default_storage
new_image = default_storage.save(
"".join(["actus/", form_image.name]), form_image)
default_storage.delete(actu.image)
actu.image = new_image
change_field = True
if actu.title != form.instance.title:
# title
actu.title = form.instance.title
change_field = True
if actu.text != form.instance.text:
# text
actu.text = form.instance.text
change_field = True
if change_field is True:
actu.change_date = timezone.now()
actu.author = request.user
actu.save()
def read_write_perm_gds():
return GoogleDriveStorage(permissions=(
GoogleDriveFilePermission(
GoogleDrivePermissionRole.WRITER,
GoogleDrivePermissionType.USER,
'*****@*****.**',
),
GoogleDriveFilePermission(
GoogleDrivePermissionRole.READER,
GoogleDrivePermissionType.ANYONE,
),
))
def _test_open_file(self):
gds = GoogleDriveStorage()
self._test_list_folder(gds)
file = gds.open('/test4/gdrive_logo.png', 'rb')
assert file, 'Unable to load data from Google Drive'
from django.db import models
from gdstorage.storage import GoogleDriveStorage
from django.core.files.storage import FileSystemStorage
import os
from uuid import uuid4
from django import forms
USE_GDRIVE = False
if USE_GDRIVE:
storage_backend = GoogleDriveStorage()
else:
storage_backend = FileSystemStorage()
# def path_and_rename(path):
def path_to_file(instance, filename):
ext = filename.split('.')[-1]
# get filename
if instance.pk:
filename = '{}.{}'.format(instance.pk, ext)
else:
# set filename as random string
filename = '{}.{}'.format(uuid4().hex, ext)
# return the whole path to the file
return os.path.join('potholetracker/', filename)
# Create your models here.
class Data(models.Model):
image = models.ImageField(upload_to=path_to_file, storage=storage_backend)
from datetime import date
from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator
from gdstorage.storage import GoogleDriveStorage
from users.models import User
from activities.models import Activity
from workgroups.models import Workgroup
# Define Google Drive Storage
GD_STORAGE = GoogleDriveStorage()
# Create your models here.
class Delivery(models.Model):
NOT_AVALIATED = 'NAV'
AVALIATED_BY_GUEST = 'AGS'
AVALIATED_BY_ADVISOR = 'AAD'
DELIVERY_STATUSES = (
(NOT_AVALIATED, 'Não avaliada'),
(AVALIATED_BY_GUEST, 'Avaliada pelo co-orientador'),
(AVALIATED_BY_ADVISOR, 'Avaliada pelo orientador'),
)
REQUIRED_FIELDS = (
'author',
'submission_date',
'main_file',
'side_file',
'status',
'submission_comments',
def test_check_or_create_folder(self):
gds = GoogleDriveStorage()
folder_data = gds._get_or_create_folder("test4/folder")
pprint(folder_data)
self.assertIsNotNone(folder_data, "Unable to find or create folder 'test4/folder")
time.sleep(10)
def test_check_root_file_exists(self):
gds = GoogleDriveStorage()
file_data = gds._check_file_exists("How to get started with Drive")
pprint(file_data)
self.assertIsNotNone(file_data, "Unable to find file 'How to get started with Drive'")
time.sleep(10)
from gdstorage.storage import GoogleDriveStorage, GoogleDrivePermissionType, \
GoogleDrivePermissionRole, GoogleDriveFilePermission
from django.conf import settings
if settings.GDRIVE_USER_EMAIL:
permission = GoogleDriveFilePermission(GoogleDrivePermissionRole.READER,
GoogleDrivePermissionType.USER,
settings.GDRIVE_USER_EMAIL)
else:
permission = GoogleDriveFilePermission(GoogleDrivePermissionRole.READER,
GoogleDrivePermissionType.ANYONE)
gd_storage = GoogleDriveStorage(permissions=(permission, ))
from django.db import models
import os
from django.db.models.signals import post_delete
from django.dispatch import receiver
from gdstorage.storage import GoogleDriveStorage, GoogleDrivePermissionType, GoogleDrivePermissionRole, GoogleDriveFilePermission
gd_storage = GoogleDriveStorage()
# permission = GoogleDriveFilePermission(
# GoogleDrivePermissionRole.READER,
# GoogleDrivePermissionType.USER,
# "127.0.0.1:8000"
# )
def path_and_rename_cat1(instance, filename):
upload_to = 'cat1/'
ext = filename.split('.')[-1]
filename = '{} {}.{}'.format(instance.course, 'cat1', ext)
return os.path.join(upload_to, filename)
def path_and_rename_cat2(instance, filename):
upload_to = 'cat2/'
ext = filename.split('.')[-1]
filename = '{} {}.{}'.format(instance.course, 'cat2', ext)
return os.path.join(upload_to, filename)
def path_and_rename_fat(instance, filename):
def gds():
return GoogleDriveStorage()
def write_perm_gds():
return GoogleDriveStorage(permissions=(GoogleDriveFilePermission(
GoogleDrivePermissionRole.WRITER,
GoogleDrivePermissionType.ANYONE,
), ))
def upload_file(request):
if request.method == 'POST':
targetDir = "/var/www/fip/SlayFIP/temporary_uploads/" + request.user.username
if not os.path.exists(targetDir):
os.makedirs(targetDir)
if 'ajax_call' in request.POST:
fileName = request.POST[
'fileName'] # you receive the file name as a separate post data
fileSize = request.POST[
'fileSize'] # you receive the file size as a separate post data
fileId = request.POST[
'fileId'] # you receive the file identifier as a separate post data
index = request.POST['chunkIndex'] # the current file chunk index
totalChunks = int(request.POST['chunkCount']
) # the total number of chunks for this file
file_chunk = request.FILES['fileBlob']
target_file = targetDir + "/" + fileName
outfile = targetDir + "/" + fileName
target_file = target_file + "_" + str(index)
if (chunk_handler(file_chunk, target_file)):
chunks = get_chunk_list(targetDir, fileName + "_")
allChunksUploaded = len(chunks) == totalChunks
if allChunksUploaded:
combineChunks(chunks, outfile, cleanup=True)
request.session['fileName'] = fileName
return_values = {
'chunkIndex': index,
'initialPreviewConfig': {
'type': 'other',
'caption': fileName,
'key': fileId,
'fileId': fileId,
'size': fileSize,
},
'append': True
}
return StreamingHttpResponse(json.dumps(return_values))
if "google_drive_upload" in request.POST:
if not request.session["fileName"]:
return redirect("/catinfo/?error=Unable to find file to upload")
fileName = request.session["fileName"]
outfile = targetDir + "/" + fileName
file_blob = ContentFile(open(outfile, 'rb').read())
storage = GoogleDriveStorage()
path = storage.save('FIPlog/' + fileName, file_blob)
cat = Cats.objects.get(id=request.POST["cat_name"])
foo = BloodWork(
bloodname=request.POST["bloodname"],
cat_name=cat,
bloodwork_date=request.POST["bloodwork_date"],
notes=request.POST["notes"],
bloodwork=path,
)
foo.save()
# Cleanup Temp Files in User's upload folder
for filename in os.listdir(targetDir):
file_path = os.path.join(targetDir, filename)
try:
if os.path.isfile(file_path) or os.path.islink(file_path):
os.unlink(file_path)
except Exception as e:
print('Failed to delete %s. Reason: %s' % (file_path, e))
return redirect("/catinfo/?message=success&CatID=" +
request.POST["cat_name"])
else:
form = BloodWorkForm()
return redirect('/catinfo')
def test_check_root_file_exists(self):
gds = GoogleDriveStorage()
file_data = gds._check_file_exists("Getting started")
pprint(file_data)
self.assertIsNotNone(file_data, "Unable to find file 'Getting started'")
time.sleep(10)
def upload_and_save_file_item_2(atributo, file, proyecto, fase, item):
gd_storage = GoogleDriveStorage()
path = f'/PROY-{proyecto.nombre}-ID{proyecto.id}_/FASE-{fase.nombre}-ID{fase.id}_/ITEM-{item}_/ATRIB-{atributo.plantilla.nombre}_/VERS{atributo.version.version}_/FILENAME-{file.name}'
print(path)
gd_storage.save(path, file)
return gd_storage.url(path)
import os
from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models
from django.utils.html import mark_safe
from django.utils.translation import gettext_lazy as _
from gdstorage.storage import GoogleDriveStorage
if settings.PRODUCTION_SERVER or settings.DUMMY_PRODUCTION:
fs = GoogleDriveStorage()
else:
fs = FileSystemStorage()
# Create your models here.
def path_and_rename(instance, filename):
from uuid import uuid4
upload_to = 'profile_pic'
ext = filename.split('.')[-1]
if instance.pk:
filename = '{}.{}'.format(instance.pk, ext)
else:
filename = '{}.{}'.format(uuid4().hex, ext)
return os.path.join(upload_to, filename)
class Student(models.Model):
name = models.CharField(max_length=250,verbose_name=_('Name of the Student'),unique=True)
slug = models.CharField(max_length=250,verbose_name=_('Slug of the Student'),unique=True, blank=True, null=True)
