notes-to-strapi-export-article-ai 1.0.119 → 3.0.0

package/src/components/Dashboard.ts

@@ -0,0 +1,184 @@
+import { Setting, Notice } from 'obsidian'
+import StrapiExporterPlugin from '../main'
+
+interface ConfigStatus {
+	key: string
+	status: boolean
+	description: string
+}
+
+interface QuickLink {
+	name: string
+	description: string
+	targetTab: string
+	icon?: string
+}
+
+export class Dashboard {
+	private plugin: StrapiExporterPlugin
+	private containerEl: HTMLElement
+
+	constructor(plugin: StrapiExporterPlugin, containerEl: HTMLElement) {
+		this.plugin = plugin
+		this.containerEl = containerEl
+	}
+
+	display(): void {
+		try {
+			const { containerEl } = this
+			containerEl.empty()
+
+			this.createHeader()
+			this.addSummary()
+			this.addQuickLinks()
+		} catch (error) {
+			new Notice('Error displaying dashboard' + error.message)
+		}
+	}
+
+	private createHeader(): void {
+		const headerEl = this.containerEl.createEl('div', {
+			cls: 'dashboard-header',
+		})
+		headerEl.createEl('h2', {
+			text: 'Strapi Exporter Dashboard',
+			cls: 'dashboard-title',
+		})
+
+		headerEl.createEl('p', {
+			text: 'Overview of your Strapi export configuration and quick access to settings.',
+			cls: 'dashboard-description',
+		})
+	}
+
+	private addSummary(): void {
+		const summaryEl = this.containerEl.createEl('div', {
+			cls: 'dashboard-summary',
+		})
+
+		const configStatus = this.getConfigurationStatus()
+		summaryEl.createEl('h3', {
+			text: 'Configuration Status',
+			cls: 'dashboard-section-title',
+		})
+
+		this.createStatusList(summaryEl, configStatus)
+	}
+
+	private createStatusList(
+		container: HTMLElement,
+		statuses: ConfigStatus[]
+	): void {
+		const statusList = container.createEl('ul', { cls: 'status-list' })
+
+		statuses.forEach(({ key, status, description }) => {
+			const listItem = statusList.createEl('li', { cls: 'status-item' })
+
+			// Status icon
+			listItem.createSpan({
+				text: status ? '✅ ' : '❌ ',
+				cls: `status-icon ${status ? 'status-ok' : 'status-error'}`,
+			})
+
+			// Status text
+			const textContainer = listItem.createSpan({ cls: 'status-text' })
+			textContainer.createSpan({ text: key, cls: 'status-key' })
+			textContainer.createSpan({ text: description, cls: 'status-description' })
+		})
+	}
+
+	private addQuickLinks(): void {
+		const quickLinksEl = this.containerEl.createEl('div', {
+			cls: 'dashboard-quick-links',
+		})
+
+		quickLinksEl.createEl('h3', {
+			text: 'Quick Links',
+			cls: 'dashboard-section-title',
+		})
+
+		this.quickLinks.forEach(link => {
+			this.createQuickLink(quickLinksEl, link)
+		})
+	}
+
+	private createQuickLink(container: HTMLElement, link: QuickLink): void {
+		new Setting(container)
+			.setName(link.name)
+			.setDesc(link.description)
+			.addButton(button => {
+				button
+					.setButtonText(`Go to ${link.name}`)
+					.setCta()
+					.onClick(() => {
+						this.navigateToTab(link.targetTab)
+					})
+			})
+	}
+
+	private navigateToTab(tab: string): void {
+		try {
+			this.plugin.settings.currentTab = tab
+			this.plugin.settingsTab.display()
+		} catch (error) {
+			new Notice(`Failed to navigate to ${tab}` + error.message)
+		}
+	}
+
+	private getConfigurationStatus(): ConfigStatus[] {
+		const { settings } = this.plugin
+		return [
+			{
+				key: 'Strapi URL',
+				status: !!settings.strapiUrl,
+				description: 'Connection to your Strapi instance',
+			},
+			{
+				key: 'Strapi API Token',
+				status: !!settings.strapiApiToken,
+				description: 'Authentication token for Strapi API',
+			},
+			{
+				key: 'ForVoyez API Key',
+				status: !!settings.forvoyezApiKey,
+				description: 'API key for ForVoyez integration',
+			},
+			{
+				key: 'OpenAI API Key',
+				status: !!settings.openaiApiKey,
+				description: 'API key for AI-powered features',
+			},
+			{
+				key: 'Schema Configured',
+				status: settings.routes.some(route => !!route.schema),
+				description: 'Strapi schema configuration',
+			},
+			{
+				key: 'Routes Configured',
+				status: settings.routes.length > 0,
+				description: 'Export route configuration',
+			},
+		]
+	}
+
+	private readonly quickLinks: QuickLink[] = [
+		{
+			name: 'Configuration',
+			description: 'Set up your Strapi schema and field mappings',
+			targetTab: 'configuration',
+			icon: 'settings',
+		},
+		{
+			name: 'API Keys',
+			description: 'Configure your API keys',
+			targetTab: 'apiKeys',
+			icon: 'key',
+		},
+		{
+			name: 'Routes',
+			description: 'Manage your export routes',
+			targetTab: 'routes',
+			icon: 'git-branch',
+		},
+	]
+}

package/src/components/ImageSelectionModal.ts

@@ -0,0 +1,58 @@
+import { App, Modal, Setting } from 'obsidian'
+
+export class ImageSelectionModal extends Modal {
+	private selectedImages: string[] = []
+	private onConfirm: (images: string[]) => void
+	private isMultiple: boolean
+
+	constructor(
+		app: App,
+		isMultiple: boolean,
+		onConfirm: (images: string[]) => void
+	) {
+		super(app)
+		this.isMultiple = isMultiple
+		this.onConfirm = onConfirm
+	}
+
+	onOpen() {
+		const { contentEl } = this
+		contentEl.empty()
+
+		contentEl.createEl('h2', {
+			text: this.isMultiple ? 'Select Images' : 'Select an Image',
+		})
+
+		new Setting(contentEl)
+			.setName('Image Selection')
+			.setDesc(
+				this.isMultiple ? 'Choose one or more images' : 'Choose an image'
+			)
+			.addButton(button =>
+				button
+					.setButtonText('Select Image(s)')
+					.onClick(() => this.openFilePicker())
+			)
+
+		new Setting(contentEl).addButton(button =>
+			button
+				.setButtonText('Confirm')
+				.setCta()
+				.onClick(() => {
+					this.close()
+					this.onConfirm(this.selectedImages)
+				})
+		)
+	}
+
+	private async openFilePicker() {
+		// Implement file picking logic here
+		// This could use Obsidian's file suggestion API or a custom file browser
+		// Update this.selectedImages with the chosen file path(s)
+	}
+
+	onClose() {
+		const { contentEl } = this
+		contentEl.empty()
+	}
+}

package/src/components/Routes.ts

@@ -0,0 +1,279 @@
+import { Notice, Setting, TextComponent } from 'obsidian'
+import StrapiExporterPlugin from '../main'
+import { RouteConfig } from '../types'
+
+interface RouteField {
+	name: string
+	description: string
+	type: 'text' | 'toggle'
+	key: keyof RouteConfig
+	placeholder?: string
+	icon?: string
+}
+
+export class Routes {
+	private plugin: StrapiExporterPlugin
+	private containerEl: HTMLElement
+
+	private routeFields: RouteField[] = [
+		{
+			name: 'Name',
+			description: 'Enter a name for this route',
+			type: 'text',
+			key: 'name',
+			placeholder: 'My Export Route',
+		},
+		{
+			name: 'Icon',
+			description: 'Enter an icon name (e.g., "upload", "link", "star")',
+			type: 'text',
+			key: 'icon',
+			placeholder: 'upload',
+		},
+		{
+			name: 'URL',
+			description: 'Enter the Strapi API endpoint URL for this route',
+			type: 'text',
+			key: 'url',
+			placeholder: '/api/articles',
+		},
+		{
+			name: 'Subtitle',
+			description: 'Enter a brief subtitle for this route',
+			type: 'text',
+			key: 'subtitle',
+			placeholder: 'Export to articles collection',
+		},
+	]
+
+	constructor(plugin: StrapiExporterPlugin, containerEl: HTMLElement) {
+		this.plugin = plugin
+		this.containerEl = containerEl
+	}
+
+	display(): void {
+		const { containerEl } = this
+		containerEl.empty()
+
+		try {
+			this.createHeader()
+			this.createRoutesList()
+			this.addNewRouteButton()
+		} catch (error) {
+			this.showError('Failed to display routes configuration' + error.message)
+		}
+	}
+
+	private createHeader(): void {
+		const headerEl = this.containerEl.createEl('div', { cls: 'routes-header' })
+
+		headerEl.createEl('h2', {
+			text: 'Routes Configuration',
+			cls: 'routes-title',
+		})
+
+		headerEl.createEl('p', {
+			text: 'Configure export routes for different content types.',
+			cls: 'routes-description',
+		})
+	}
+
+	private createRoutesList(): void {
+		const routesContainer = this.containerEl.createDiv('routes-list')
+
+		this.plugin.settings.routes.forEach((route, index) => {
+			this.createRouteConfigSettings(route, index, routesContainer)
+		})
+	}
+
+	private createTextComponent(
+		text: TextComponent,
+		route: RouteConfig,
+		field: keyof RouteConfig
+	): TextComponent {
+		return text.setValue(route[field] as string).onChange(async value => {
+			try {
+				await this.updateRouteField(route, field, value)
+			} catch (error) {
+				this.showError(`Failed to update ${String(field)}` + error.message)
+			}
+		})
+	}
+
+	private createRouteConfigSettings(
+		route: RouteConfig,
+		index: number,
+		container: HTMLElement
+	): void {
+		try {
+			const routeEl = container.createEl('div', {
+				cls: 'route-config',
+			})
+
+			// Route header with toggle
+			this.createRouteHeader(routeEl, route, index)
+
+			// Route fields
+			this.routeFields.forEach(field => {
+				this.createRouteField(routeEl, route, field)
+			})
+
+			// Delete button
+			this.addDeleteButton(routeEl, index)
+		} catch (error) {
+			this.showError(
+				`Failed to create settings for route ${index + 1}` + error.message
+			)
+		}
+	}
+
+	private createRouteHeader(
+		routeEl: HTMLElement,
+		route: RouteConfig,
+		index: number
+	): void {
+		new Setting(routeEl)
+			.setName(`Route ${index + 1}: ${route.name}`)
+			.setDesc('Configure route settings')
+			.addToggle(toggle =>
+				toggle.setValue(route.enabled).onChange(async value => {
+					try {
+						await this.updateRouteEnabled(route, value)
+					} catch (error) {
+						this.showError('Failed to update route state' + error.message)
+					}
+				})
+			)
+	}
+
+	private createRouteField(
+		routeEl: HTMLElement,
+		route: RouteConfig,
+		field: RouteField
+	): void {
+		new Setting(routeEl)
+			.setName(field.name)
+			.setDesc(field.description)
+			.addText(text => {
+				text.setPlaceholder(field.placeholder || '')
+				return this.createTextComponent(text, route, field.key)
+			})
+	}
+
+	private addDeleteButton(routeEl: HTMLElement, index: number): void {
+		new Setting(routeEl).addButton(button =>
+			button
+				.setButtonText('Delete Route')
+				.setWarning()
+				.onClick(async () => {
+					try {
+						await this.deleteRoute(index)
+					} catch (error) {
+						this.showError('Failed to delete route' + error.message)
+					}
+				})
+		)
+	}
+
+	private async updateRouteField(
+		route: RouteConfig,
+		field: keyof RouteConfig,
+		value: string | boolean
+	): Promise<void> {
+		if (field === 'enabled') {
+			route[field] = value as boolean
+		} else {
+			const stringFields: (keyof RouteConfig)[] = [
+				'id',
+				'name',
+				'icon',
+				'url',
+				'contentType',
+				'contentField',
+				'additionalInstructions',
+				'description',
+				'subtitle',
+				'schema',
+				'schemaDescription',
+				'language',
+			]
+
+			if (stringFields.includes(field)) {
+				;(route[field] as string) = value as string
+			}
+		}
+
+		await this.plugin.saveSettings()
+
+		if (field === 'icon' || field === 'enabled') {
+			await this.plugin.debouncedUpdateRibbonIcons()
+		}
+	}
+
+	private async updateRouteEnabled(
+		route: RouteConfig,
+		value: boolean
+	): Promise<void> {
+		route.enabled = value
+		await this.plugin.saveSettings()
+		this.plugin.updateRibbonIcons()
+	}
+
+	private async deleteRoute(index: number): Promise<void> {
+		if (this.plugin.settings.routes.length <= 1) {
+			new Notice('Cannot delete the only route')
+			return
+		}
+
+		this.plugin.settings.routes.splice(index, 1)
+		await this.plugin.saveSettings()
+		this.plugin.updateRibbonIcons()
+		this.display()
+	}
+
+	private addNewRouteButton(): void {
+		new Setting(this.containerEl)
+			.setName('Add New Route')
+			.setDesc('Create a new route configuration')
+			.addButton(button =>
+				button
+					.setButtonText('Add Route')
+					.setCta()
+					.onClick(async () => {
+						try {
+							await this.createNewRoute()
+						} catch (error) {
+							this.showError('Failed to create new route' + error.message)
+						}
+					})
+			)
+	}
+
+	private async createNewRoute(): Promise<void> {
+		const newRoute: RouteConfig = {
+			generatedConfig: '',
+			id: `route-${Date.now()}`,
+			name: 'New Route',
+			icon: 'star',
+			url: '',
+			contentType: '',
+			contentField: '',
+			additionalInstructions: '',
+			enabled: true,
+			description: '',
+			subtitle: '',
+			schema: '',
+			schemaDescription: '',
+			language: '',
+			fieldMappings: {},
+		}
+
+		this.plugin.settings.routes.push(newRoute)
+		await this.plugin.saveSettings()
+		this.display()
+	}
+
+	private showError(message: string): void {
+		new Notice(message)
+	}
+}

package/src/constants.ts

@@ -1,67 +1,28 @@
-import { StrapiExporterSettings } from './types/settings'
+import { StrapiExporterSettings } from './types'
 
-/**
- * The default settings for the plugin
- */
 export const DEFAULT_STRAPI_EXPORTER_SETTINGS: StrapiExporterSettings = {
 	strapiUrl: '',
 	strapiApiToken: '',
+	forvoyezApiKey: '',
 	openaiApiKey: '',
-	jsonTemplate: `{
-    "data": {
-      "title": "string",
-      "seo_title": "string",
-      "seo_description": "string",
-      "slug": "string",
-      "excerpt": "string",
-      "links": [
-        {
-          "id": "number",
-          "label": "string",
-          "url": "string"
-        }
-      ],
-      "subtitle": "string",
-      "type": "string",
-      "rank": "number",
-      "tags": [
-        {
-          "id": "number",
-          "name": "string"
-        }
-      ],
-      "locale": "string"
-    }
-  }`,
-	jsonTemplateDescription: `{
-    "data": {
-      "title": "Title of the item, as a short string",
-      "seo_title": "SEO optimized title, as a short string",
-      "seo_description": "SEO optimized description, as a short string",
-      "slug": "URL-friendly string derived from the title",
-      "excerpt": "A short preview or snippet from the content",
-      "links": "Array of related links with ID, label, and URL",
-      "subtitle": "Subtitle or secondary title, as a short string",
-      "type": "Category or type of the item, as a short string",
-      "rank": "Numerical ranking or order priority, as a number",
-      "tags": "Array of associated tags with ID and name",
-      "locale": "Locale or language code, as a short string"
-    }
-  }`,
-	strapiArticleCreateUrl: '',
-	strapiContentAttributeName: '',
-	additionalPrompt: '',
-	enableAdditionalApiCall: false,
-	additionalJsonTemplate: '',
-	additionalJsonTemplateDescription: '',
-	additionalUrl: '',
-	additionalContentAttributeName: '',
-	mainButtonImageEnabled: false,
-	mainButtonGalleryEnabled: false,
-	additionalButtonImageEnabled: false,
-	additionalButtonGalleryEnabled: false,
-	mainImageFullPathProperty: '',
-	mainGalleryFullPathProperty: '',
-	additionalImageFullPathProperty: '',
-	additionalGalleryFullPathProperty: '',
+	currentTab: 'dashboard',
+	routes: [
+		{
+			id: 'default-route',
+			name: 'Default Route',
+			icon: 'upload',
+			url: '',
+			contentType: 'articles',
+			enabled: true,
+			fieldMappings: {},
+			description: '',
+			subtitle: '',
+			schema: '',
+			schemaDescription: '',
+			language: '',
+			contentField: '',
+			additionalInstructions: '',
+			generatedConfig: '',
+		},
+	],
 }