@windward/integrations 0.20.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## Release [0.23.0] - 2026-02-23
+
+* Merged in feature/LE-2217/activity-transform-3 (pull request #133)
+* Merged in feature/LE-2217/activity-transform-2 (pull request #132)
+* Merged in feature/LE-2217/activity-transform (pull request #130)
+* Merged in bugfix/LE-2202-lti-integration-block-not-workin (pull request #125)
+* Merged in feature/LE-2215-clickable-icon-default-settings- (pull request #131)
+* Merged in feature/LE-2208-translate-course (pull request #119)
+* Merge remote-tracking branch 'origin/feature/LE-2208-translate-course' into feature/LE-2208-translate-course
+* Merge remote-tracking branch 'origin/feature/LE-2208-translate-course' into feature/LE-2208-translate-course
+
+
+## Release [0.21.0] - 2026-01-12
+
+* Merged in feature/LE-221/block-transform-additions (pull request #127)
+* Merged in feature/LE-2218/endless-spinner (pull request #126)
+* Merge branch 'feature/LE-2218/endless-spinner' into feature/LE-221/block-transform-additions
+* Merged in feature/LE-2155-consistent-ui-for-adding-new-blo (pull request #124)
+
+
 ## Release [0.20.0] - 2025-12-03
 
 * Merged in feature/LE-2177-switch-block-type-for-text-heavy (pull request #118)

package/components/Content/Blocks/ActionPanel/TransformActivity.vue

@@ -0,0 +1,386 @@
+<template>
+    <v-list-item-group v-if="canTransformActivity" :disabled="isTransforming">
+        <v-list-group v-model="showMenu" @click="onClickShowTransforms">
+            <template #activator>
+                <v-list-item-icon>
+                    <v-progress-circular
+                        v-if="isTransforming"
+                        indeterminate
+                    ></v-progress-circular>
+                    <v-icon v-if="!isTransforming">mdi-shape</v-icon>
+                </v-list-item-icon>
+                <v-list-item-title>
+                    {{
+                        $t(
+                            'windward.integrations.components.content.blocks.action_panel.transform_activity.change_block_type'
+                        )
+                    }}
+                </v-list-item-title>
+            </template>
+
+            <v-list-item
+                v-for="action in availableActions"
+                :key="action.tag"
+                :disabled="isTransforming"
+                @click="performActivityTransform($event, action.tag)"
+            >
+                <v-list-item-title>
+                    <v-icon>mdi-arrow-right</v-icon> {{ action.label }}
+                </v-list-item-title>
+            </v-list-item>
+        </v-list-group>
+    </v-list-item-group>
+</template>
+
+<script>
+import _ from 'lodash'
+import { mapGetters } from 'vuex'
+import Organization from '~/models/Organization'
+import Course from '~/models/Course'
+
+const DEFAULT_INSTRUCTIONS_BY_TAG = {
+    'plugin-games-flash-card':
+        'windward.games.components.settings.flashcard.form.instructions',
+    'plugin-games-matching-game':
+        'windward.games.components.settings.matching_game.form.default_instructions',
+    'plugin-games-bucket':
+        'windward.games.components.settings.bucket_game.form.default_instructions',
+    'plugin-games-seven-strikes-game':
+        'windward.games.components.settings.seven_strikes.instructions',
+    'plugin-games-wordjumble-game':
+        'windward.games.components.content.blocks.word_jumble.instructions',
+    'plugin-games-crossword-puzzle-game':
+        'windward.games.components.settings.crossword.instructions',
+    'plugin-games-multiple-choice':
+        'windward.games.components.settings.multiple_choice.default_instructions',
+}
+
+const DEFAULT_TITLE_BY_TAG = {
+    'plugin-games-flash-card':
+        'windward.games.components.content.blocks.flashcard.title',
+    'plugin-games-matching-game':
+        'windward.games.components.settings.matching_game.form.title',
+    'plugin-games-bucket':
+        'windward.games.components.content.blocks.bucket_game.game_title',
+    'plugin-games-seven-strikes-game':
+        'windward.games.components.settings.seven_strikes.title',
+    'plugin-games-wordjumble-game':
+        'windward.games.components.settings.word_jumble.title',
+    'plugin-games-crossword-puzzle-game':
+        'windward.games.components.content.blocks.crossword.crossword',
+    'plugin-games-multiple-choice':
+        'windward.games.components.content.blocks.multiple_choice.game_title',
+}
+
+const SUPPORTED_ACTIVITY_ACTIONS = [
+    {
+        tag: 'plugin-games-flash-card',
+        labelKey: 'windward.games.shared.content_blocks.title.flashcards',
+    },
+    {
+        tag: 'plugin-games-matching-game',
+        labelKey: 'windward.games.shared.content_blocks.title.matching_game',
+    },
+    {
+        tag: 'plugin-games-bucket',
+        labelKey: 'windward.games.shared.content_blocks.title.bucket',
+    },
+    {
+        tag: 'plugin-games-seven-strikes-game',
+        labelKey: 'windward.games.shared.content_blocks.title.seven_strikes',
+    },
+    {
+        tag: 'plugin-games-wordjumble-game',
+        labelKey: 'windward.games.shared.content_blocks.title.word_jumble',
+    },
+    {
+        tag: 'plugin-games-crossword-puzzle-game',
+        labelKey: 'windward.games.shared.content_blocks.title.crossword_puzzle',
+    },
+    {
+        tag: 'plugin-games-multiple-choice',
+        labelKey: 'windward.games.shared.content_blocks.title.multiple_choice',
+    },
+]
+
+export default {
+    props: {
+        value: { type: Object, required: false, default: null },
+        index: { type: Number, required: false, default: 0 },
+        length: { type: Number, required: false, default: 0 },
+        bindElement: { type: null, required: false, default: null },
+        draggable: { type: Boolean, required: false, default: true },
+        savable: { type: Boolean, required: false, default: true },
+        editable: { type: Boolean, required: false, default: true },
+        deletable: { type: Boolean, required: false, default: true },
+        editMode: { type: Boolean, required: false, default: null },
+        saving: { type: Boolean, required: false, default: null },
+        btnGroupId: { type: String, required: false, default: '' },
+    },
+
+    data() {
+        return {
+            showMenu: false,
+            isTransforming: false,
+        }
+    },
+
+    computed: {
+        ...mapGetters({
+            organization: 'organization/get',
+            course: 'course/get',
+        }),
+        sourceTag() {
+            return _.get(this.value, 'tag', '')
+        },
+        isSupportedSource() {
+            return SUPPORTED_ACTIVITY_ACTIONS.some(
+                (action) => action.tag === this.sourceTag
+            )
+        },
+        availableActions() {
+            if (!this.value || !this.isSupportedSource) {
+                return []
+            }
+
+            return SUPPORTED_ACTIVITY_ACTIONS.filter(
+                (action) => action.tag !== this.sourceTag
+            ).map((action) => ({
+                tag: action.tag,
+                label: this.$t(action.labelKey),
+            }))
+        },
+        canTransformActivity() {
+            return this.availableActions.length > 0
+        },
+    },
+
+    methods: {
+        onClickShowTransforms(e) {
+            e.stopPropagation()
+        },
+        getDefaultInstructions(tag) {
+            const key = DEFAULT_INSTRUCTIONS_BY_TAG[tag] || ''
+            if (!key) {
+                return ''
+            }
+
+            const translated = this.$t(key)
+
+            if (!translated || translated === key) {
+                return ''
+            }
+
+            return translated
+        },
+        getDefaultTitle(tag) {
+            const key = DEFAULT_TITLE_BY_TAG[tag] || ''
+            if (!key) {
+                return ''
+            }
+
+            const translated = this.$t(key)
+
+            if (!translated || translated === key) {
+                return ''
+            }
+
+            return translated
+        },
+        buildNewBlockBase(sourceBlock) {
+            const baseOrderRaw = _.get(sourceBlock, 'order', 0)
+            const baseOrder = Number(baseOrderRaw)
+            const normalizedOrder = Number.isFinite(baseOrder)
+                ? Math.trunc(baseOrder)
+                : 0
+
+            const newBlock = {
+                id: _.uniqueId('create_content_block_'),
+                content_id: null,
+                tag: '',
+                body: '',
+                status: 'draft',
+                order: normalizedOrder,
+                type: {
+                    save_state: false,
+                    trackable: false,
+                    completable: false,
+                },
+                assets: _.cloneDeep(_.get(sourceBlock, 'assets', [])),
+                metadata: {
+                    config: {},
+                },
+            }
+
+            const display = _.cloneDeep(_.get(sourceBlock, 'metadata.display', null))
+            if (display) {
+                newBlock.metadata.display = display
+            }
+
+            return newBlock
+        },
+        buildSourceBlockPayload(sourceBlock) {
+            return {
+                tag: _.get(sourceBlock, 'tag', ''),
+                body: _.get(sourceBlock, 'body', ''),
+                metadata: _.cloneDeep(_.get(sourceBlock, 'metadata', {})),
+                assets: _.cloneDeep(_.get(sourceBlock, 'assets', [])),
+            }
+        },
+        async requestActivityTransform(targetTag) {
+            const organizationId = _.get(this.organization, 'id', null)
+            const courseId = _.get(this.course, 'id', null)
+
+            if (!organizationId || !courseId) {
+                throw new Error('missing_context')
+            }
+
+            const request = new Course()
+            request.custom(
+                new Organization({ id: organizationId }),
+                new Course({ id: courseId }),
+                'llm-activity-transform'
+            )
+
+            const resourcePath = request._customResource
+            if (!resourcePath) {
+                throw new Error('missing_resource')
+            }
+
+            const payload = {
+                source_block: this.buildSourceBlockPayload(this.value),
+                target_tag: targetTag,
+                language: this.$i18n.locale,
+            }
+
+            const requestConfig = request._reqConfig(
+                {
+                    method: 'POST',
+                    url: `${request.baseURL()}/${resourcePath}`,
+                    data: payload,
+                },
+                { forceMethod: true }
+            )
+
+            const response = await request.request(requestConfig)
+            const responseData = response?.data ?? response
+
+            const wrapKey = typeof request.wrap === 'function' ? request.wrap() : ''
+            const looksLikeBlock = (value) => {
+                return (
+                    value &&
+                    typeof value === 'object' &&
+                    !Array.isArray(value) &&
+                    typeof value.tag === 'string' &&
+                    value.metadata &&
+                    typeof value.metadata === 'object'
+                )
+            }
+
+            let parsed = responseData
+
+            // Handle Laravel JsonResource wrapping (and occasional double-wrapping)
+            for (let i = 0; i < 2; i++) {
+                if (looksLikeBlock(parsed)) {
+                    break
+                }
+
+                if (
+                    parsed &&
+                    typeof parsed === 'object' &&
+                    !Array.isArray(parsed) &&
+                    wrapKey &&
+                    Object.prototype.hasOwnProperty.call(parsed, wrapKey)
+                ) {
+                    parsed = parsed[wrapKey]
+                    continue
+                }
+
+                break
+            }
+
+            return parsed
+        },
+        async performActivityTransform(e, targetTag) {
+            e.stopPropagation()
+
+            if (this.isTransforming) {
+                return
+            }
+
+            if (!this.value || !this.isSupportedSource) {
+                return
+            }
+
+            this.isTransforming = true
+
+            let transformed = null
+
+            try {
+                transformed = await this.requestActivityTransform(targetTag)
+
+                if (
+                    !transformed ||
+                    typeof transformed.tag !== 'string' ||
+                    !transformed.metadata ||
+                    typeof transformed.metadata !== 'object'
+                ) {
+                    throw new Error('invalid_response')
+                }
+
+                const newBlock = this.buildNewBlockBase(this.value)
+                newBlock.tag = transformed.tag
+                newBlock.body = transformed.body || ''
+                newBlock.metadata = _.merge(
+                    {},
+                    newBlock.metadata,
+                    _.cloneDeep(transformed.metadata)
+                )
+                _.set(
+                    newBlock,
+                    'metadata.config.instructions',
+                    this.getDefaultInstructions(targetTag)
+                )
+                _.set(
+                    newBlock,
+                    'metadata.config.title',
+                    this.getDefaultTitle(targetTag)
+                )
+
+                this.$eb.$emit('create:content-block', newBlock)
+
+                const activeBlock = _.cloneDeep(newBlock)
+                this.$ContentService.setContentBlock(activeBlock)
+                this.$eb.$emit('block:focus', activeBlock)
+            } catch (error) {
+                // eslint-disable-next-line no-console
+                console.error('Activity transform failed', error)
+                if (process.env.NODE_ENV !== 'production') {
+                    // eslint-disable-next-line no-console
+                    console.error('Activity transform response payload', transformed)
+                }
+
+                const messageKey = _.get(error, 'response.data.error.message', '')
+
+                if (this.$toast) {
+                    if (messageKey === 'activity_transform.error.content_mismatch') {
+                        this.$toast.error(
+                            this.$t(
+                                'windward.integrations.components.content.blocks.action_panel.transform_activity.change_block_type_insufficient_items'
+                            )
+                        )
+                    } else {
+                        this.$toast.error(
+                            this.$t(
+                                'windward.integrations.components.content.blocks.action_panel.transform_activity.change_block_type_error'
+                            )
+                        )
+                    }
+                }
+            } finally {
+                this.isTransforming = false
+            }
+        },
+    },
+}
+</script>