waengine 1.0.7 → 1.0.9

package/plugins/music-plugin/index.js

@@ -0,0 +1,221 @@
+// 🎵 Music Plugin mit yt-dlp
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export default class MusicPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'music-plugin';
+        this.version = '1.0.0';
+        this.description = 'Music System mit YouTube Download und Spotify Integration';
+    }
+
+    async searchYouTube(query) {
+        try {
+            const { stdout } = await execAsync(`yt-dlp --dump-json "ytsearch5:${query}"`);
+            const results = stdout.trim().split('\n').map(line => JSON.parse(line));
+            
+            return results.map(video => ({
+                id: video.id,
+                title: video.title,
+                duration: video.duration,
+                uploader: video.uploader,
+                url: video.webpage_url,
+                thumbnail: video.thumbnail
+            }));
+        } catch (error) {
+            console.error('YouTube Search Error:', error);
+            return [];
+        }
+    }
+
+    async getVideoInfo(url) {
+        try {
+            const { stdout } = await execAsync(`yt-dlp --dump-json "${url}"`);
+            const info = JSON.parse(stdout);
+            
+            return {
+                id: info.id,
+                title: info.title,
+                duration: info.duration,
+                uploader: info.uploader,
+                description: info.description,
+                thumbnail: info.thumbnail,
+                formats: info.formats
+            };
+        } catch (error) {
+            console.error('Video Info Error:', error);
+            return null;
+        }
+    }
+
+    async downloadAudio(url, quality = 'best') {
+        try {
+            const outputPath = `./downloads/%(title)s.%(ext)s`;
+            const command = `yt-dlp -x --audio-format mp3 --audio-quality ${quality} -o "${outputPath}" "${url}"`;
+            
+            const { stdout } = await execAsync(command);
+            return { success: true, output: stdout };
+        } catch (error) {
+            console.error('Download Error:', error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    formatDuration(seconds) {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+    }
+
+    async createPlaylist(userId, name) {
+        const playlistId = Date.now().toString();
+        this.client.storage.write.in('music').set(`playlists.${playlistId}`, {
+            id: playlistId,
+            name,
+            owner: userId,
+            songs: [],
+            created: Date.now()
+        });
+        
+        return playlistId;
+    }
+
+    async addToPlaylist(playlistId, song) {
+        this.client.storage.write.in('music').push(`playlists.${playlistId}.songs`, song);
+    }
+
+    async getUserPlaylists(userId) {
+        const playlists = this.client.storage.read.from('music').get('playlists') || {};
+        return Object.values(playlists).filter(playlist => playlist.owner === userId);
+    }
+
+    getCommands() {
+        return {
+            'music': this.handleMusic.bind(this),
+            'youtube': this.handleYouTube.bind(this),
+            'download': this.handleDownload.bind(this),
+            'playlist': this.handlePlaylist.bind(this),
+            'lyrics': this.handleLyrics.bind(this),
+            'spotify': this.handleSpotify.bind(this)
+        };
+    }
+
+    async handleMusic(msg, args) {
+        if (args.length === 0) {
+            return msg.reply(`🎵 **Music Plugin Commands:**
+
+🔍 !music search <song> - Musik suchen
+📺 !youtube <query> - YouTube suchen  
+⬇️ !download <url> - Audio downloaden
+📋 !playlist - Playlist verwalten
+📝 !lyrics <song> - Songtexte suchen
+🎧 !spotify - Spotify Features`);
+        }
+
+        const action = args[0].toLowerCase();
+        const query = args.slice(1).join(' ');
+
+        if (action === 'search') {
+            if (!query) return msg.reply('❌ Gib einen Suchbegriff ein!');
+            
+            await msg.reply('🔍 Suche Musik...');
+            const results = await this.searchYouTube(query);
+            
+            if (results.length === 0) {
+                return msg.reply('❌ Keine Ergebnisse gefunden!');
+            }
+
+            let resultText = `🎵 **Suchergebnisse für "${query}":**\n\n`;
+            results.slice(0, 3).forEach((video, index) => {
+                resultText += `${index + 1}. **${video.title}**\n`;
+                resultText += `👤 ${video.uploader}\n`;
+                resultText += `⏱️ ${this.formatDuration(video.duration)}\n`;
+                resultText += `🔗 ${video.url}\n\n`;
+            });
+
+            await msg.reply(resultText);
+        }
+    }
+
+    async handleYouTube(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !youtube <suchbegriff>');
+        }
+
+        const query = args.join(' ');
+        await msg.reply('📺 Suche auf YouTube...');
+        
+        const results = await this.searchYouTube(query);
+        
+        if (results.length === 0) {
+            return msg.reply('❌ Keine YouTube Videos gefunden!');
+        }
+
+        let resultText = `📺 **YouTube Ergebnisse:**\n\n`;
+        results.slice(0, 5).forEach((video, index) => {
+            resultText += `${index + 1}. **${video.title}**\n`;
+            resultText += `👤 ${video.uploader}\n`;
+            resultText += `⏱️ ${this.formatDuration(video.duration)}\n`;
+            resultText += `🔗 ${video.url}\n\n`;
+        });
+
+        resultText += '⬇️ Download mit: !download <url>';
+        await msg.reply(resultText);
+    }
+    async handleDownload(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !download <youtube-url>');
+        }
+
+        const url = args[0];
+        await msg.reply('⬇️ Starte Download...');
+        
+        const result = await this.downloadAudio(url);
+        
+        if (result.success) {
+            await msg.reply('✅ Download erfolgreich! Audio wird verarbeitet...');
+        } else {
+            await msg.reply(`❌ Download fehlgeschlagen: ${result.error}`);
+        }
+    }
+
+    async handlePlaylist(msg, args) {
+        const userId = msg.getSender();
+        
+        if (args.length === 0) {
+            const playlists = await this.getUserPlaylists(userId);
+            
+            if (playlists.length === 0) {
+                return msg.reply('📋 **Keine Playlists gefunden!**\n\n💡 Erstelle eine mit: !playlist create <name>');
+            }
+            
+            let playlistText = '📋 **Deine Playlists:**\n\n';
+            playlists.forEach((playlist, index) => {
+                playlistText += `${index + 1}. **${playlist.name}**\n`;
+                playlistText += `🎵 ${playlist.songs.length} Songs\n`;
+                playlistText += `📅 Erstellt: ${new Date(playlist.created).toLocaleDateString()}\n\n`;
+            });
+            
+            await msg.reply(playlistText);
+        }
+    }
+
+    async handleLyrics(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !lyrics <song title>');
+        }
+
+        const song = args.join(' ');
+        await msg.reply(`🔍 Suche Songtexte für "${song}"...`);
+        
+        // Placeholder - hier würdest du eine Lyrics API verwenden
+        await msg.reply(`📝 **Songtexte für "${song}":**\n\n_Lyrics API Integration folgt..._\n\n💡 Verwende eine Lyrics API wie Genius oder AZLyrics`);
+    }
+
+    async handleSpotify(msg, args) {
+        await msg.reply(`🎧 **Spotify Integration:**\n\n_Spotify API Integration folgt..._\n\n💡 Features:\n• Now Playing\n• Playlists\n• Search\n• Recommendations`);
+    }
+}

package/plugins/travel-plugin/index.js

@@ -0,0 +1,230 @@
+// 🌍 Travel Plugin
+export default class TravelPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'travel-plugin';
+        this.version = '1.0.0';
+        this.description = 'Reise-System mit Wetter, Flügen, Hotels und Währungsrechner';
+    }
+
+    async getWeather(city) {
+        try {
+            // Verwende den HTTP Client für Wetter-API
+            return await this.client.http.getWeather(city);
+        } catch (error) {
+            return {
+                city: city,
+                temperature: Math.floor(Math.random() * 30) + 5,
+                description: 'Teilweise bewölkt',
+                humidity: Math.floor(Math.random() * 40) + 40,
+                windSpeed: Math.floor(Math.random() * 10) + 2
+            };
+        }
+    }
+
+    async searchFlights(from, to) {
+        // Simulierte Flugdaten
+        const airlines = ['Lufthansa', 'Ryanair', 'Eurowings', 'Turkish Airlines', 'Emirates'];
+        const flights = [];
+        
+        for (let i = 0; i < 3; i++) {
+            flights.push({
+                airline: airlines[Math.floor(Math.random() * airlines.length)],
+                departure: `${Math.floor(Math.random() * 12) + 6}:${Math.floor(Math.random() * 6) * 10}`,
+                arrival: `${Math.floor(Math.random() * 12) + 12}:${Math.floor(Math.random() * 6) * 10}`,
+                price: Math.floor(Math.random() * 500) + 100,
+                duration: `${Math.floor(Math.random() * 8) + 2}h ${Math.floor(Math.random() * 6) * 10}m`,
+                stops: Math.floor(Math.random() * 3)
+            });
+        }
+        
+        return flights;
+    }
+
+    async searchHotels(city) {
+        const hotelNames = ['Hotel Central', 'Grand Palace', 'City Inn', 'Comfort Suites', 'Luxury Resort'];
+        const hotels = [];
+        
+        for (let i = 0; i < 4; i++) {
+            hotels.push({
+                name: hotelNames[Math.floor(Math.random() * hotelNames.length)],
+                stars: Math.floor(Math.random() * 3) + 3,
+                price: Math.floor(Math.random() * 200) + 50,
+                rating: (Math.random() * 2 + 3).toFixed(1),
+                amenities: ['WiFi', 'Pool', 'Gym', 'Restaurant'].slice(0, Math.floor(Math.random() * 4) + 1)
+            });
+        }
+        
+        return hotels;
+    }
+
+    async convertCurrency(amount, from, to) {
+        // Simulierte Wechselkurse
+        const rates = {
+            'USD': { 'EUR': 0.85, 'GBP': 0.73, 'JPY': 110 },
+            'EUR': { 'USD': 1.18, 'GBP': 0.86, 'JPY': 130 },
+            'GBP': { 'USD': 1.37, 'EUR': 1.16, 'JPY': 151 }
+        };
+        
+        if (from === to) return amount;
+        
+        const rate = rates[from]?.[to] || 1;
+        const converted = (amount * rate).toFixed(2);
+        
+        return {
+            original: amount,
+            converted: parseFloat(converted),
+            fromCurrency: from,
+            toCurrency: to,
+            rate: rate
+        };
+    }
+
+    async translateText(text, targetLang) {
+        // Verwende AI Integration falls verfügbar
+        try {
+            return await this.client.ai.translate(text, targetLang);
+        } catch (error) {
+            return `[Übersetzung zu ${targetLang}]: ${text}`;
+        }
+    }
+
+    getCommands() {
+        return {
+            'weather': this.handleWeather.bind(this),
+            'flights': this.handleFlights.bind(this),
+            'hotels': this.handleHotels.bind(this),
+            'currency': this.handleCurrency.bind(this),
+            'translate': this.handleTranslate.bind(this),
+            'travel': this.handleTravel.bind(this)
+        };
+    }
+
+    async handleWeather(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !weather <stadt>\n\n🌤️ Beispiel: !weather Berlin');
+        }
+
+        const city = args.join(' ');
+        await msg.reply(`🌤️ Lade Wetterdaten für ${city}...`);
+        
+        const weather = await this.getWeather(city);
+        
+        let weatherText = `🌤️ **Wetter in ${weather.city}:**\n\n`;
+        weatherText += `🌡️ Temperatur: ${weather.temperature}°C\n`;
+        weatherText += `☁️ Bedingungen: ${weather.description}\n`;
+        weatherText += `💧 Luftfeuchtigkeit: ${weather.humidity}%\n`;
+        weatherText += `💨 Windgeschwindigkeit: ${weather.windSpeed} km/h`;
+        
+        await msg.reply(weatherText);
+    }
+
+    async handleFlights(msg, args) {
+        if (args.length < 2) {
+            return msg.reply('❌ Verwendung: !flights <von> <nach>\n\n✈️ Beispiel: !flights Berlin München');
+        }
+
+        const from = args[0];
+        const to = args[1];
+        
+        await msg.reply(`✈️ Suche Flüge von ${from} nach ${to}...`);
+        
+        const flights = await this.searchFlights(from, to);
+        
+        let flightText = `✈️ **Flüge ${from} → ${to}:**\n\n`;
+        
+        flights.forEach((flight, index) => {
+            flightText += `${index + 1}. **${flight.airline}**\n`;
+            flightText += `🕐 ${flight.departure} → ${flight.arrival}\n`;
+            flightText += `⏱️ Dauer: ${flight.duration}\n`;
+            flightText += `🔄 Stops: ${flight.stops === 0 ? 'Direktflug' : `${flight.stops} Stop(s)`}\n`;
+            flightText += `💰 Preis: €${flight.price}\n\n`;
+        });
+        
+        await msg.reply(flightText);
+    }
+
+    async handleHotels(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !hotels <stadt>\n\n🏨 Beispiel: !hotels Paris');
+        }
+
+        const city = args.join(' ');
+        await msg.reply(`🏨 Suche Hotels in ${city}...`);
+        
+        const hotels = await this.searchHotels(city);
+        
+        let hotelText = `🏨 **Hotels in ${city}:**\n\n`;
+        
+        hotels.forEach((hotel, index) => {
+            const stars = '⭐'.repeat(hotel.stars);
+            flightText += `${index + 1}. **${hotel.name}** ${stars}\n`;
+            hotelText += `⭐ Rating: ${hotel.rating}/5.0\n`;
+            hotelText += `💰 Ab €${hotel.price}/Nacht\n`;
+            hotelText += `🎯 Ausstattung: ${hotel.amenities.join(', ')}\n\n`;
+        });
+        
+        await msg.reply(hotelText);
+    }
+
+    async handleCurrency(msg, args) {
+        if (args.length < 3) {
+            return msg.reply('❌ Verwendung: !currency <betrag> <von> <zu>\n\n💱 Beispiel: !currency 100 USD EUR');
+        }
+
+        const amount = parseFloat(args[0]);
+        const from = args[1].toUpperCase();
+        const to = args[2].toUpperCase();
+        
+        if (isNaN(amount)) {
+            return msg.reply('❌ Ungültiger Betrag!');
+        }
+
+        const result = await this.convertCurrency(amount, from, to);
+        
+        let currencyText = `💱 **Währungsrechner:**\n\n`;
+        currencyText += `💰 ${result.original} ${result.fromCurrency}\n`;
+        currencyText += `= ${result.converted} ${result.toCurrency}\n\n`;
+        currencyText += `📊 Wechselkurs: 1 ${result.fromCurrency} = ${result.rate} ${result.toCurrency}`;
+        
+        await msg.reply(currencyText);
+    }
+
+    async handleTranslate(msg, args) {
+        if (args.length < 2) {
+            return msg.reply('❌ Verwendung: !translate <sprache> <text>\n\n🌍 Beispiel: !translate en Hallo Welt');
+        }
+
+        const targetLang = args[0];
+        const text = args.slice(1).join(' ');
+        
+        await msg.reply(`🌍 Übersetze zu ${targetLang}...`);
+        
+        const translation = await this.translateText(text, targetLang);
+        
+        let translateText = `🌍 **Übersetzung:**\n\n`;
+        translateText += `📝 Original: ${text}\n`;
+        translateText += `🔄 ${targetLang}: ${translation}`;
+        
+        await msg.reply(translateText);
+    }
+
+    async handleTravel(msg, args) {
+        const helpText = `🌍 **Travel Plugin Commands:**
+
+🌤️ !weather <stadt> - Wetter abrufen
+✈️ !flights <von> <nach> - Flüge suchen  
+🏨 !hotels <stadt> - Hotels finden
+💱 !currency <betrag> <von> <zu> - Währung umrechnen
+🌍 !translate <sprache> <text> - Text übersetzen
+
+📋 **Beispiele:**
+• !weather Berlin
+• !flights München Hamburg  
+• !hotels Paris
+• !currency 100 USD EUR
+• !translate en Guten Tag`;
+
+        await msg.reply(helpText);
+    }
+}

package/src/ai-integration.js

@@ -0,0 +1,185 @@
+// AI Integration für WAEngine
+import axios from 'axios';
+
+export class AIIntegration {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+        this.baseURL = options.baseURL || 'https://api.openai.com/v1';
+        this.model = options.model || 'gpt-3.5-turbo';
+        this.enabled = !!this.apiKey;
+        
+        if (!this.enabled) {
+            console.log('⚠️ AI Integration deaktiviert - Kein API Key gefunden');
+        } else {
+            console.log('🤖 AI Integration aktiviert');
+        }
+    }
+
+    // ===== CHAT COMPLETION =====
+    
+    async chat(prompt, options = {}) {
+        if (!this.enabled) {
+            throw new Error('❌ AI Integration nicht konfiguriert! Setze OPENAI_API_KEY');
+        }
+
+        try {
+            const response = await axios.post(`${this.baseURL}/chat/completions`, {
+                model: options.model || this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: options.systemPrompt || 'Du bist ein hilfreicher WhatsApp Bot Assistent. Antworte kurz und freundlich auf Deutsch.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                max_tokens: options.maxTokens || 500,
+                temperature: options.temperature || 0.7
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            return response.data.choices[0].message.content.trim();
+        } catch (error) {
+            console.error('❌ AI Chat Fehler:', error.response?.data || error.message);
+            throw new Error(`AI Fehler: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    // ===== SMART RESPONSES =====
+    
+    async smartReply(message, context = {}) {
+        const prompt = `
+Kontext: WhatsApp Bot Nachricht
+User schrieb: "${message}"
+Chat-Type: ${context.isGroup ? 'Gruppe' : 'Privat'}
+${context.userName ? `User: ${context.userName}` : ''}
+
+Antworte natürlich und hilfreich. Maximal 2 Sätze.
+        `.trim();
+
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein freundlicher WhatsApp Bot. Antworte natürlich und kurz.',
+            maxTokens: 200
+        });
+    }
+
+    // ===== TEXT ANALYSIS =====
+    
+    async analyzeMessage(text) {
+        const prompt = `
+Analysiere diese Nachricht:
+"${text}"
+
+Gib zurück als JSON:
+{
+  "sentiment": "positive/negative/neutral",
+  "language": "de/en/es/fr/etc",
+  "category": "question/command/greeting/complaint/other",
+  "toxicity": "low/medium/high",
+  "confidence": 0.0-1.0
+}
+        `.trim();
+
+        try {
+            const response = await this.chat(prompt, {
+                systemPrompt: 'Du bist ein Text-Analyse-Experte. Antworte nur mit gültigem JSON.',
+                maxTokens: 150
+            });
+            
+            return JSON.parse(response);
+        } catch (error) {
+            return {
+                sentiment: 'neutral',
+                language: 'unknown',
+                category: 'other',
+                toxicity: 'low',
+                confidence: 0.5
+            };
+        }
+    }
+
+    // ===== MODERATION =====
+    
+    async moderateContent(text) {
+        try {
+            const response = await axios.post(`${this.baseURL}/moderations`, {
+                input: text
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const result = response.data.results[0];
+            
+            return {
+                flagged: result.flagged,
+                categories: result.categories,
+                scores: result.category_scores,
+                safe: !result.flagged
+            };
+        } catch (error) {
+            console.error('❌ Moderation Fehler:', error.message);
+            return { flagged: false, safe: true };
+        }
+    }
+
+    // ===== TRANSLATION =====
+    
+    async translate(text, targetLang = 'de') {
+        const prompt = `Übersetze folgenden Text nach ${targetLang}. Antworte nur mit der Übersetzung:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein professioneller Übersetzer. Antworte nur mit der Übersetzung.',
+            maxTokens: 300
+        });
+    }
+
+    // ===== SUMMARIZATION =====
+    
+    async summarize(text, maxLength = 100) {
+        const prompt = `Fasse folgenden Text in maximal ${maxLength} Zeichen zusammen:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein Experte für Textzusammenfassungen. Sei präzise und kurz.',
+            maxTokens: Math.ceil(maxLength / 2)
+        });
+    }
+
+    // ===== QUESTION ANSWERING =====
+    
+    async answerQuestion(question, context = '') {
+        const prompt = context ? 
+            `Kontext: ${context}\n\nFrage: ${question}` : 
+            question;
+            
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein hilfreicher Assistent. Beantworte Fragen präzise und verständlich.',
+            maxTokens: 400
+        });
+    }
+
+    // ===== CREATIVE WRITING =====
+    
+    async generateText(prompt, style = 'normal') {
+        const stylePrompts = {
+            funny: 'Schreibe lustig und humorvoll',
+            formal: 'Schreibe formal und professionell',
+            casual: 'Schreibe locker und umgangssprachlich',
+            creative: 'Schreibe kreativ und fantasievoll',
+            normal: 'Schreibe natürlich und verständlich'
+        };
+
+        return await this.chat(prompt, {
+            systemPrompt: `Du bist ein kreativer Schreiber. ${stylePrompts[style] || stylePrompts.normal}.`,
+            maxTokens: 600
+        });
+    }
+}

package/src/client.js

@@ -4,6 +4,11 @@ import { generateQRCode, closeBrowser } from "./qr.js";
 import { Message } from "./message.js";
 import { SessionManager } from "./session-manager.js";
 import { PrefixManager } from "./prefix-manager.js";
+import { getStorage } from "./storage.js";
+import { AIIntegration } from "./ai-integration.js";
+import { HTTPClient } from "./http-client.js";
+import { Scheduler } from "./scheduler.js";
+import { PluginManager } from "./plugin-manager-fixed.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -30,6 +35,38 @@ export class WhatsAppClient {
         this.prefixManager = new PrefixManager('./data');
         this.commands = new Map();
         
+        // Storage System
+        this.storage = getStorage();
+        
+        // AI Integration
+        this.ai = new AIIntegration(options.ai || {});
+        
+        // HTTP Client
+        this.http = new HTTPClient(options.http || {});
+        
+        // Scheduler System
+        this.scheduler = new Scheduler(this);
+        
+        // Waiting System für Messages
+        this.waiting = this.scheduler.createWaiting();
+        
+        // Plugin System
+        this.plugins = new PluginManager(this);
+        
+        // Load API für Plugins
+        this.load = {
+            Plugins: async (pluginName) => {
+                if (pluginName === 'all') {
+                    console.log('🔌 Lade alle Plugins...');
+                    await this.plugins.loadAllPlugins();
+                    console.log('✅ Alle Plugins geladen!');
+                } else {
+                    console.log(`🔌 Lade Plugin: ${pluginName}`);
+                    await this.plugins.load(pluginName);
+                }
+            }
+        };
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);
@@ -172,6 +209,10 @@ export class WhatsAppClient {
                     this.isConnected = true;
                     await closeBrowser(); // QR Browser schließen
                     this.emit('connected');
+                    
+                    // 🔌 Plugins werden NICHT automatisch geladen
+                    // Verwende client.load.Plugins("plugin-name") um Plugins zu laden
+                    
                     resolve(this);
                 }
             });