Creates tasks from a model instance "item" (master)
        Used in the api call

        :param languages:
        :param item:
        :param fields:
        :param trans_instance: determines if we are in bulk mode or not.
        If it has a value we're processing by the signal trigger,
        if not we're processing either by the api or the mixin
        :return:

def create_from_item(self, languages, item, fields, trans_instance=None):
        """
        Creates tasks from a model instance "item" (master)
        Used in the api call

        :param languages:
        :param item:
        :param fields:
        :param trans_instance: determines if we are in bulk mode or not.
        If it has a value we're processing by the signal trigger,
        if not we're processing either by the api or the mixin
        :return:
        """
        if not isinstance(item, TranslatableModel):
            return

        self.log('gonna parse fields: {}'.format(fields))

        with self.lock:
            result = []

            if trans_instance:
                # get the values from the instance that is being saved, values not saved yet
                trans = trans_instance
            else:
                # get the values from the db instance
                trans = self.get_translation_from_instance(item, self.main_language)

            if not trans:
                return

            for field in fields:

                self.log('parsing field: {}'.format(field))

                # for every field
                object_field_label = self.get_field_label(trans, field)
                object_field_value = getattr(trans, field)
                # if object_field_value is None or object_field_value == '':
                #     object_field_value = getattr(self.instance, field, '')

                self.log('object_field_value for {} - .{}.'.format(object_field_label, object_field_value))

                if object_field_value == '' or object_field_value is None:
                    continue

                for lang in languages:
                    # for every language
                    self.log('parsing lang: {}'.format(lang))

                    language = TransLanguage.objects.filter(code=lang).get()
                    users = self.translators.get(lang, [])

                    self.log('gonna parse users')

                    for user in users:
                        # for every user we create a task

                        # check if there is already a value for the destinatation lang
                        # when we are in bulk mode, when we are in signal mode
                        # we update the destination task if it exists
                        if self.bulk_mode and self.exists_destination_lang_value(item, field, lang):
                            continue

                        ob_class_name = item.__class__.__name__

                        self.log('creating or updating object_class: {} | object_pk:{} | object_field: {}'.format(
                            ob_class_name,
                            item.pk,
                            field
                        ))

                        app_label = item._meta.app_label
                        model = ob_class_name.lower()
                        ct = ContentType.objects.get_by_natural_key(app_label, model)

                        try:
                            task, created = TransTask.objects.get_or_create(
                                content_type=ct,
                                object_class=ob_class_name,
                                object_pk=item.pk,
                                object_field=field,
                                language=language,
                                user=user,
                                defaults={
                                    'object_name': '{} - {}'.format(app_label, item._meta.verbose_name),
                                    'object_field_label': object_field_label,
                                    'object_field_value': object_field_value,
                                    'done': False
                                }
                            )
                            if not created:
                                self.log('updating')
                                task.date_modification = datetime.now()
                                task.object_field_value = object_field_value
                                task.done = False
                                task.save()
                            result.append(task)
                        except TransTask.MultipleObjectsReturned:
                            # theorically it should not occur but if so delete the repeated tasks
                            tasks = TransTask.objects.filter(
                                content_type=ct,
                                object_class=ob_class_name,
                                object_pk=item.pk,
                                object_field=field,
                                language=language,
                                user=user
                            )
                            for i, task in enumerate(tasks):
                                if i == 0:
                                    task.date_modification = datetime.now()
                                    task.object_field_value = object_field_value
                                    task.done = False
                                    task.save()
                                else:
                                    task.delete()

        # we return every task (created or modified)
        return result