Esempio n. 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.'))
Esempio n. 2
0
    def index(self, item_type_id=0):
        """Renders an item type register view.

        :param item_type_id: Item type i. Default 0.
        """
        lists = ItemTypes.get_latest(True)
        # Check that item type is already registered to an item or not
        for item in lists:
            # Get all versions
            all_records = ItemTypes.get_records_by_name_id(name_id=item.id)
            item.belonging_item_flg = False
            for item in all_records:
                metaDataRecords = ItemsMetadata.get_by_item_type_id(
                    item_type_id=item.id)
                item.belonging_item_flg = len(metaDataRecords) > 0
                if item.belonging_item_flg:
                    break
        is_sys_admin = has_system_admin_access()

        return self.render(
            current_app.config['WEKO_ITEMTYPES_UI_ADMIN_REGISTER_TEMPLATE'],
            lists=lists,
            id=item_type_id,
            is_sys_admin=is_sys_admin,
            lang_code=session.get('selected_language', 'en')  # Set default
        )
Esempio n. 3
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)