def create(self, request, pk=None):
if request.data.__contains__('effect_name'): # validate on server-side
if request.data.__contains__('cut_name'):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is True:
effect = get_effect(
serializer.validated_data['effect_name']
) # sets the effect object
cut = get_cut(serializer.validated_data['cut_name'])
project = get_project(self.request.user,
pk) # get projects to insert task
if project is not None:
instance = self.perform_create(serializer, effect,
project, cut)
return Response(status=status.HTTP_201_CREATED
) # serializer problem
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST) # no effect name
return Response({'errors': 'no cut name'},
status=status.HTTP_400_BAD_REQUEST)
return Response({'errors': 'no effect name'},
status=status.HTTP_400_BAD_REQUEST)
def list(self, request, pk=None):
project = get_project(self.request.user, project_name=pk)
if project is not None:
media = get_media(project=project)
data = []
for media_s in media:
if media_s.proceeded is True:
cut_individual = actoon.models.cutmodel.Cut.objects.filter(
media=media_s).filter(linked=None)
instances = get_list_or_404(cut_individual)
# arrange with cut sequence
instances.sort(key=lambda x: x.sequence)
bubbles = []
cuts = []
full_cuts = []
for instance in instances:
if instance.type == 'SC':
cuts.append(instance)
elif instance.type == 'FC':
full_cuts.append(instance)
elif instance.type == 'BU':
bubbles.append(instance)
# make a empty field
for index, cut in enumerate(cuts):
bubbles_in_cut = []
for bubble in bubbles:
if bubble.sequence is index:
bubbles_in_cut.append(
self.get_serializer(bubble).data)
_data = {
'thumbnail':
self.get_serializer(full_cuts[index]).data,
'background': self.get_serializer(cut).data,
'bubbles': bubbles_in_cut
}
data.append(_data)
else:
print(' [x] %s is not proceeded, skipping...' % media_s)
if len(data) > 0:
return Response(json.dumps(data))
else:
return Response(status=status.HTTP_404_NOT_FOUND)
return Response(status=status.HTTP_400_BAD_REQUEST)
def get_queryset(self, project_name=None, media_id=None):
if project_name is not None:
project_instance = get_project(self.request.user, project_name)
if media_id is not None:
queryset_media_object = self.model.objects.filter(pk=media_id)
if len(queryset_media_object) > 0:
return queryset_media_object[0]
else:
if project_instance is not None:
return self.model.objects.filter(project=project_instance)
return None
def create(self, request, pk=None):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is True:
project = get_project(self.request.user, project_name=pk)
if project is not None:
instance = self.perform_create(serializer, project=project)
return Response(self.get_serializer(instance).data,
status=status.HTTP_201_CREATED)
return Response({'errors': 'no such project'},
status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_queryset(self, project_name=None, task_index=None):
if project_name is not None:
project_instance = get_project(self.request.user, project_name)
if task_index is not None:
queryset_task_object = self.model.objects.filter(project=project_instance) \
.order_by('created_at')
if len(queryset_task_object) > task_index:
return queryset_task_object[task_index]
else:
if project_instance is not None:
return self.model.objects.filter(
project=project_instance).order_by('created_at')
return None
def update(self, request, pk=None, cpk=None):
project_instance = get_project(self.request.user, pk)
media_instance = get_media(project_instance)
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
for media in media_instance:
cuts = Cut.objects.filter(media=media).filter(file=cpk)
if cuts.exists():
cut_original = get_object_or_404(cuts)
uploaded_file = serializer.validated_data['file_upload']
temp_folder = BASE_DIR + '/media/'
random_name = create_random_name(
temp_folder, '.' + uploaded_file.name.split('.')[-1])
new_file = default_storage.save(
random_name, ContentFile(uploaded_file.read()))
instance = Cut(file=new_file,
media=cut_original.media,
type=cut_original.type,
sequence=cut_original.sequence,
sub_sequence=cut_original.sub_sequence,
pos_x=cut_original.pos_x,
pos_y=cut_original.pos_y)
instance.save()
cut_original.linked = instance
cut_original.save()
return Response(self.get_serializer(instance).data,
status=status.HTTP_202_ACCEPTED)
return Response({'errors': 'no such cut'},
status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)