uploadFileAPI.py

from django.http import JsonResponse
from django.views.decorators.http import require_POST
from django.shortcuts import get_object_or_404

from core.decorators import api_endpoint
from encoder.forms import VideoForm, VideoStorageOptionsForm
from encoder.models import Video, VideoChunkedUpload
from encoder.tasks import encode_video

from encoder.progress_utils.progress import get_uploading_progress
from encoder.progress_utils.progress import get_encoding_progress
from encoder.progress_utils.progress import get_overall_progress

from utils import flags
from django.shortcuts import render

from chunked_upload.views import ChunkedUploadView, ChunkedUploadCompleteView

import dateutil
import os


@api_endpoint
@require_POST
def create(request):

    form = VideoForm(request.POST, files=request.FILES)
    opts = VideoStorageOptionsForm(request.POST)

    valid = all((form.is_valid(), opts.is_valid()))

    if valid:
        video = form.save()

        # Start video encode task
        encode_video(video, opts.has_user_storage_options())

        response = video.to_dict()
    else:
        response = {
            "errors": dict(form.errors, **opts.errors)
        }

    response.update(success=valid)

    return JsonResponse(response)


@api_endpoint
def status(request, video_ref):

    video = get_object_or_404(Video, ref=video_ref)

    uploading_progress = get_uploading_progress(video_ref)
    encoding_progress = get_encoding_progress(video_ref)
    overall_progress = get_overall_progress(video_ref)
    start_time = flags.encoder_start_time(video)
    end_time = flags.encoder_end_time(video)
    encoding_time = str(dateutil.parser.parse(flags.encoder_end_time(video)) - dateutil.parser.parse(flags.encoder_start_time(video)))

    return JsonResponse({
        "uploading_progress": uploading_progress,
        "encoding_progress": encoding_progress,
        "overall_progress": overall_progress,
        "start_time": start_time,
        "end_time": end_time,
        "encoding_time": encoding_time,
    })


@api_endpoint
def status_all(request):

    vs = Video.objects.order_by('-created')[:5]

    videos = []
    for video in vs:

        uploading_progress = get_uploading_progress(video.ref_str)
        encoding_progress = get_encoding_progress(video.ref_str)
        overall_progress = get_overall_progress(video.ref_str)
        start_time = flags.encoder_start_time(video)
        end_time = flags.encoder_end_time(video)
        encoding_time = str(dateutil.parser.parse(flags.encoder_end_time(video)) - dateutil.parser.parse(flags.encoder_start_time(video)))
        filename = video.filename
        encoder_done = flags.encoder_done(video)
        encoder_success = flags.encoder_success(video)
        encoder_error = flags.encoder_error(video)
        upload_done = flags.upload_done(video)
        ref = video.ref_str

        v = {"ref": ref,
             "filename": filename,
             "encoder_done": encoder_done,
             "encoder_success": encoder_success,
             "encoder_error": encoder_error,
             "upload_done": upload_done,
             "uploading_progress": uploading_progress,
             "encoding_progress": encoding_progress,
             "overall_progress": overall_progress,
             "start_time": start_time,
             "end_time": end_time,
             "encoding_time": encoding_time}

        videos.append(v)

    return render(request, "status_all.html", {"videos": videos})


# TODO: REvisar esta creo que hay borrarla
@api_endpoint
def start(request, video_ref):
    """
    Start video encoder from video manager
    """
    video = get_object_or_404(Video, ref=video_ref)

    encode_video(video)

    return JsonResponse({})


class VideoChunkedUploadView(ChunkedUploadView):

    model = VideoChunkedUpload
    field_name = 'video'

    def check_permissions(self, request):
        # Allow non authenticated users to make uploads
        pass


class VideoChunkedUploadCompleteView(ChunkedUploadCompleteView):

    model = VideoChunkedUpload
    do_md5_check = True

    def check_permissions(self, request):
        # Allow non authenticated users to make uploads
        pass

    def on_completion(self, uploaded_file, request):
        # Do something with the uploaded file. E.g.:
        # * Store the uploaded file on another model:
        # SomeModel.objects.create(user=request.user, file=uploaded_file)
        # * Pass it as an argument to a function:
        # function_that_process_file(uploaded_file)

        # Pass data to VideoForm
        files = {'video': uploaded_file}
        form = VideoForm(request.POST, files=files)

        # Pass data to VideoStorageOptionsForm
        opts = VideoStorageOptionsForm(request.POST)

        # Validates forms.
        valid = all((form.is_valid(), opts.is_valid()))

        if valid:
            video = form.save()
            try:
                os.remove(uploaded_file.file.file.name)
            except Exception:
                pass
            # Start video encode task
            encode_video(video, opts.has_user_storage_options())

            self.response = video.to_dict()
        else:
            self.response = {
                "errors": dict(form.errors, **opts.errors)
            }

        self.response.update(success=valid)

    def get_response_data(self, chunked_upload, request):
        try:
            return self.response
        except AttributeError:
            return {'success': False}

An example of some django API endpoints that allows user to upload of a video file, chunked into several pieces (using a javascript library) and then store it in a Encoder server disk to a later trancode using ffmpeg