Beispiel #1
0
    def restore_itemtype(self, item_type_id=0):
        """Restore logically deleted item types."""
        if item_type_id > 0:
            record = ItemTypes.get_record(id_=item_type_id, with_deleted=True)
            if record is not None and record.model.is_deleted:
                # Get all versions
                all_records = ItemTypes.get_records_by_name_id(
                    name_id=record.model.name_id, with_deleted=True)
                # Get item type name
                item_type_name = ItemTypeNames.get_record(
                    id_=record.model.name_id, with_deleted=True)
                if all_records and item_type_name:
                    try:
                        # Restore item type name
                        ItemTypeNames.restore(item_type_name)
                        # Restore item typea
                        for k in all_records:
                            k.restore()
                        db.session.commit()
                    except BaseException:
                        db.session.rollback()
                        current_app.logger.error('Unexpected error: ',
                                                 sys.exc_info()[0])
                        return jsonify(code=-1,
                                       msg=_('Failed to restore Item type.'))

                    current_app.logger.debug(
                        'Itemtype restore: {}'.format(item_type_id))
                    return jsonify(code=0,
                                   msg=_('Restored Item type successfully.'))

        return jsonify(code=-1, msg=_('An error has occurred.'))
Beispiel #2
0
    def delete_itemtype(self, item_type_id=0):
        """Soft-delete an item type."""
        if item_type_id > 0:
            record = ItemTypes.get_record(id_=item_type_id)
            if record is not None:
                # Check harvesting_type
                if record.model.harvesting_type:
                    flash(_('Cannot delete Item type for Harvesting.'),
                          'error')
                    return jsonify(code=-1)
                # Get all versions
                all_records = ItemTypes.get_records_by_name_id(
                    name_id=record.model.name_id)
                # Check that item type is already registered to an item or not
                for item in all_records:
                    metaDataRecords = ItemsMetadata.get_by_item_type_id(
                        item_type_id=item.id)
                    if len(metaDataRecords) > 0:
                        flash(
                            _(
                                'Cannot delete due to child'
                                ' existing item types.'),
                            'error')
                        return jsonify(code=-1)
                # Get item type name
                item_type_name = ItemTypeNames.get_record(
                    id_=record.model.name_id)
                if all_records and item_type_name:
                    try:
                        # Delete item type name
                        ItemTypeNames.delete(item_type_name)
                        # Delete item typea
                        for k in all_records:
                            k.delete()
                        db.session.commit()
                    except BaseException:
                        db.session.rollback()
                        current_app.logger.error('Unexpected error: ',
                                                 sys.exc_info()[0])
                        flash(_('Failed to delete Item type.'), 'error')
                        return jsonify(code=-1)

                    current_app.logger.debug(
                        'Itemtype delete: {}'.format(item_type_id))
                    flash(_('Deleted Item type successfully.'))
                    return jsonify(code=0)

        flash(_('An error has occurred.'), 'error')
        return jsonify(code=-1)
Beispiel #3
0
def get_json_schema(item_type_id=0):
    """Get json schema.

    :param item_type_id: Item type ID. (Default: 0)
    :return: The json object.
    """
    try:
        result = None
        json_schema = None
        cur_lang = current_i18n.language

        if item_type_id > 0:
            if item_type_id == 20:
                result = ItemTypes.get_by_id(item_type_id)
                if result is None:
                    return '{}'
                json_schema = result.schema
                properties = json_schema.get('properties')
                for key, value in properties.items():
                    if 'validationMessage_i18n' in value:
                        value['validationMessage'] =\
                            value['validationMessage_i18n'][cur_lang]
            else:
                result = ItemTypes.get_record(item_type_id)
                if 'filemeta' in json.dumps(result):
                    group_list = Group.get_group_list()
                    group_enum = list(group_list.keys())
                    filemeta_group = result.get('properties').get(
                        'filemeta').get('items').get('properties').get(
                            'groups')
                    filemeta_group['enum'] = group_enum

                json_schema = result

        if result is None:
            return '{}'
        return jsonify(json_schema)
    except BaseException:
        current_app.logger.error('Unexpected error: ', sys.exc_info()[0])
    return abort(400)
Beispiel #4
0
def get_json_schema(item_type_id=0):
    """Get json schema.

    :param item_type_id: Item type ID. (Default: 0)
    :return: The json object.
    """
    try:
        result = None
        if item_type_id > 0:
            result = ItemTypes.get_record(item_type_id)
            if 'filemeta' in json.dumps(result):
                group_list = Group.get_group_list()
                group_enum = list(group_list.keys())
                filemeta_group = result.get('properties').get('filemeta').get(
                    'items').get('properties').get('groups')
                filemeta_group['enum'] = group_enum
        if result is None:
            return '{}'
        return jsonify(result)
    except:
        current_app.logger.error('Unexpected error: ', sys.exc_info()[0])
    return abort(400)
Beispiel #5
0
def get_json_schema(item_type_id=0, activity_id=""):
    """Get json schema.

    :param item_type_id: Item type ID. (Default: 0)
    :param activity_id: Activity ID.  (Default: Null)
    :return: The json object.
    """
    try:
        result = None
        cur_lang = current_i18n.language

        if item_type_id > 0:
            result = ItemTypes.get_record(item_type_id)
            properties = result.get('properties')
            if 'filemeta' in json.dumps(result):
                group_list = Group.get_group_list()
                group_enum = list(group_list.keys())
                filemeta_group = properties.get('filemeta').get('items').get(
                    'properties').get('groups')
                filemeta_group['enum'] = group_enum
            for _key, value in properties.items():
                translate_validation_message(value, cur_lang)
        if result is None:
            return '{}'
        if activity_id:
            updated_json_schema = update_json_schema_by_activity_id(
                result, activity_id)
            if updated_json_schema:
                result = updated_json_schema
        json_schema = result
        # Remove excluded item in json_schema
        remove_excluded_items_in_json_schema(item_type_id, json_schema)
        return jsonify(json_schema)
    except BaseException:
        current_app.logger.error('Unexpected error: ', sys.exc_info()[0])
    return abort(400)