MediaCMS backend, initial commit

uploader/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.0"

uploader/apps.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8
+from django.apps import AppConfig
+
+
+class UploaderConfig(AppConfig):
+    name = "uploader"

uploader/fineuploader.py

@@ -0,0 +1,96 @@
+from os.path import join
+from io import StringIO
+import shutil
+from django.conf import settings
+
+from . import utils
+
+
+class BaseFineUploader(object):
+    def __init__(self, data, *args, **kwargs):
+        self.data = data
+        self.total_filesize = data.get("qqtotalfilesize")
+        self.filename = data.get("qqfilename")
+        self.uuid = data.get("qquuid")
+        self.file = data.get("qqfile")
+        self.storage_class = settings.FILE_STORAGE
+        self.real_path = None
+
+    @property
+    def finished(self):
+        return self.real_path is not None
+
+    @property
+    def file_path(self):
+        return join(settings.UPLOAD_DIR, self.uuid)
+
+    @property
+    def _full_file_path(self):
+        return join(self.file_path, self.filename)
+
+    @property
+    def storage(self):
+        file_storage = utils.import_class(self.storage_class)
+        return file_storage()
+
+    @property
+    def url(self):
+        if not self.finished:
+            return None
+        return self.storage.url(self.real_path)
+
+
+class ChunkedFineUploader(BaseFineUploader):
+    concurrent = True
+
+    def __init__(self, data, concurrent=True, *args, **kwargs):
+        super(ChunkedFineUploader, self).__init__(data, *args, **kwargs)
+        self.concurrent = concurrent
+        self.total_parts = data.get("qqtotalparts")
+        if not isinstance(self.total_parts, int):
+            self.total_parts = 1
+        self.part_index = data.get("qqpartindex")
+
+    @property
+    def chunks_path(self):
+        return join(settings.CHUNKS_DIR, self.uuid)
+
+    @property
+    def _abs_chunks_path(self):
+        return join(settings.MEDIA_ROOT, self.chunks_path)
+
+    @property
+    def chunk_file(self):
+        return join(self.chunks_path, str(self.part_index))
+
+    @property
+    def chunked(self):
+        return self.total_parts > 1
+
+    @property
+    def is_time_to_combine_chunks(self):
+        return self.total_parts - 1 == self.part_index
+
+    def combine_chunks(self):
+        # implement the same behaviour.
+        self.real_path = self.storage.save(self._full_file_path, StringIO())
+        with self.storage.open(self.real_path, "wb") as final_file:
+            for i in range(self.total_parts):
+                part = join(self.chunks_path, str(i))
+                with self.storage.open(part, "rb") as source:
+                    final_file.write(source.read())
+        shutil.rmtree(self._abs_chunks_path)
+
+    def _save_chunk(self):
+        return self.storage.save(self.chunk_file, self.file)
+
+    def save(self):
+        if self.chunked:
+            chunk = self._save_chunk()
+            if not self.concurrent and self.is_time_to_combine_chunks:
+                self.combine_chunks()
+                return self.real_path
+            return chunk
+        else:
+            self.real_path = self.storage.save(self._full_file_path, self.file)
+            return self.real_path

uploader/forms.py

@@ -0,0 +1,19 @@
+from django import forms
+
+
+class FineUploaderUploadForm(forms.Form):
+    qqfile = forms.FileField()
+    qquuid = forms.CharField()
+    qqfilename = forms.CharField()
+    qqpartindex = forms.IntegerField(required=False)
+    qqchunksize = forms.IntegerField(required=False)
+    qqtotalparts = forms.IntegerField(required=False)
+    qqtotalfilesize = forms.IntegerField(required=False)
+    qqpartbyteoffset = forms.IntegerField(required=False)
+
+
+class FineUploaderUploadSuccessForm(forms.Form):
+    qquuid = forms.CharField()
+    qqfilename = forms.CharField()
+    qqtotalparts = forms.IntegerField()
+    qqtotalfilesize = forms.IntegerField(required=False)

uploader/models.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

uploader/urls.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+from django.conf.urls import url
+
+from . import views
+
+app_name = "uploader"
+
+urlpatterns = [
+    url(r"^upload/$", views.FineUploaderView.as_view(), name="upload"),
+]

uploader/utils.py

@@ -0,0 +1,22 @@
+from django.core.exceptions import ImproperlyConfigured
+from importlib import import_module
+
+
+def import_class(path):
+    path_bits = path.split(".")
+
+    if len(path_bits) < 2:
+        message = "'{0}' is not a complete Python path.".format(path)
+        raise ImproperlyConfigured(message)
+
+    class_name = path_bits.pop()
+    module_path = ".".join(path_bits)
+    module_itself = import_module(module_path)
+
+    if not hasattr(module_itself, class_name):
+        message = "The Python module '{}' has no '{}' class.".format(
+            module_path, class_name
+        )
+        raise ImportError(message)
+
+    return getattr(module_itself, class_name)

uploader/views.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import os
+import shutil
+
+from django.http import JsonResponse
+from django.views import generic
+from django.conf import settings
+from django.core.files import File
+from django.core.exceptions import PermissionDenied
+
+from cms.permissions import user_allowed_to_upload
+from files.models import Media
+from files.helpers import rm_file
+from .forms import FineUploaderUploadForm, FineUploaderUploadSuccessForm
+from .fineuploader import ChunkedFineUploader
+
+
+class FineUploaderView(generic.FormView):
+    http_method_names = ("post",)
+    form_class_upload = FineUploaderUploadForm
+    form_class_upload_success = FineUploaderUploadSuccessForm
+
+    @property
+    def concurrent(self):
+        return settings.CONCURRENT_UPLOADS
+
+    @property
+    def chunks_done(self):
+        return self.chunks_done_param_name in self.request.GET
+
+    @property
+    def chunks_done_param_name(self):
+        return settings.CHUNKS_DONE_PARAM_NAME
+
+    def make_response(self, data, **kwargs):
+        return JsonResponse(data, **kwargs)
+
+    def get_form(self, form_class=None):
+        if self.chunks_done:
+            form_class = self.form_class_upload_success
+        else:
+            form_class = self.form_class_upload
+        return form_class(**self.get_form_kwargs())
+
+    def dispatch(self, request, *args, **kwargs):
+        if not user_allowed_to_upload(request):
+            raise PermissionDenied  # HTTP 403
+        return super(FineUploaderView, self).dispatch(request, *args, **kwargs)
+
+    def form_valid(self, form):
+        self.upload = ChunkedFineUploader(form.cleaned_data, self.concurrent)
+        if self.upload.concurrent and self.chunks_done:
+            try:
+                self.upload.combine_chunks()
+            except FileNotFoundError:
+                data = {"success": False, "error": "Error with File Uploading"}
+                return self.make_response(data, status=400)
+        elif self.upload.total_parts == 1:
+            self.upload.save()
+        else:
+            self.upload.save()
+            return self.make_response({"success": True})
+        # create media!
+        media_file = os.path.join(settings.MEDIA_ROOT, self.upload.real_path)
+        with open(media_file, "rb") as f:
+            myfile = File(f)
+            new = Media.objects.create(media_file=myfile, user=self.request.user)
+        rm_file(media_file)
+        shutil.rmtree(os.path.join(settings.MEDIA_ROOT, self.upload.file_path))
+        return self.make_response(
+            {"success": True, "media_url": new.get_absolute_url()}
+        )
+
+    def form_invalid(self, form):
+        data = {"success": False, "error": "%s" % repr(form.errors)}
+        return self.make_response(data, status=400)