React-native-onesignal: Wie erhalte ich eine Erstbenachrichtigung?

Ich habe das gleiche Problem und anscheinend haben viele andere auch dieses Problem. Einige verwandte/doppelte Probleme, die ich gefunden habe, sind https://github.com/geektimecoil/react-native-onesignal/issues/206 , https://github.com/geektimecoil/react-native-onesignal/issues/195 , https://github.com/geektimecoil/react-native-onesignal/issues/191 , https://github.com/geektimecoil/react-native-onesignal/issues/336 , https://github.com/geektimecoil/ React-native-onesignal/issues/334 , https://github.com/geektimecoil/react-native-onesignal/issues/264 , https://github.com/geektimecoil/react-native-onesignal/issues/279.

Diese Probleme scheinen sich alle auf dieses Problem zu beziehen, bei dem der Ereignis-Listener opened nicht aufgerufen wird, wenn Sie auf eine Push-Benachrichtigung tippen, um die App zu öffnen, und die App zu diesem Zeitpunkt nicht ausgeführt wird. Nach dem, was ich in diesen Ausgaben gelesen habe, und den Tests, die ich durchgeführt habe, scheint die Ursache dieses Problems die Registrierung des Ereignis-Listeners zu sein, die in irgendeiner Weise verzögert wird (dh OneSignal.addEventListener('opened', this.onOpened); wird kurz nach dem aufgerufen App selbst geladen wird). Dies könnte daran liegen, dass Sie diesen Code in einer React-Komponente haben (z. B. in den Funktionen constructor oder componentWillMount oder componentDidMount ), oder weil er erst aufgerufen wird, nachdem Sie ihn konfiguriert/rehydriert haben Ihr Redux-Speicher usw.. Und aufgrund dieser Verzögerung wird das Ereignis selbst (dass eine Benachrichtigung geöffnet wurde) von React-native-onesignal ausgelöst, bevor der Ereignis-Listener registriert wird, und an diesem Punkt haben Sie das Ereignis verpasst und haben keine Möglichkeit zu wissen, dass es passiert ist. Als Nebenbemerkung betrifft dasselbe Problem andere Ereignis-Listener, zB den ids -Ereignis-Listener.

Wenn Sie diesen Code so verschieben, dass er so früh wie möglich erfolgt, scheint der Ereignis-Listener registriert zu werden, bevor das Ereignis ausgelöst wird, und als solche wird Ihre Ereignishandlerfunktion aufgerufen. Beispielsweise sollten Sie den Ereignis-Listener-Registrierungscode in Ihre index.ios.js -Datei oder an den Anfang Ihrer App.js -Datei verschieben, falls Ihre index.ios.js -Datei einfach nur importiert wird die Komponente App und deren Registrierung (über AppRegistry.registerComponent ).

Sobald Sie diese Einrichtung vorgenommen haben, können Sie jetzt das Ereignis erfassen, dass eine Benachrichtigung geöffnet wurde, und es liegt an Ihnen, wie Sie damit umgehen, was davon abhängt, wie Ihre App eingerichtet ist (z. B. ob Sie verwenden Redux, oder ob Sie redux-persist usw. verwenden).

Meine aktuelle Lösung besteht darin, die Benachrichtigung in einer Variablen zu speichern, die auf der obersten Ebene meiner App.js -Datei selbst definiert ist (bevor ich überhaupt meine App -Komponente deklariere), und dann, sobald ich die Initialisierung von abgeschlossen habe meinem Redux-Speicher (der das Warten auf die Rehydrierung meines Speichers durch redux-persist beinhaltet), schicke ich Aktionen mit der Benachrichtigung als Nutzlast (wenn eine Benachrichtigung geöffnet wurde), und dann entferne ich auch meine Top-Level-Ereignis-Listener und füge ein neues Ereignis hinzu Listener auf meiner App -Komponente selbst (diese Ereignis-Listener senden auch einfach Aktionen an meinen Redux-Speicher mit der Benachrichtigung, den Geräte-IDs usw. als Aktionsnutzlast).

Diese Lösung ist offensichtlich sehr hacky, und es gibt wahrscheinlich einige Grenzfälle, in denen dies nicht so funktionieren würde, wie es sollte. Aber bis eine geeignete Lösung in React-Native-OneSignal implementiert ist, scheint dies eine anständige Problemumgehung zu sein.

Ich denke, was passieren muss, ist, dass „react-native-onesignal“ aktualisiert wird, damit es wartet, bis Sie Ihre Event-Handler eingerichtet haben, bevor es die Events auslöst. Eine mögliche Lösung könnte darin bestehen, dass beim Auftreten von Ereignissen (z. B. dem Ereignis opened ) die Ereignisse in eine Warteschlange gestellt werden und React-native-onesignal dann überprüft, ob derzeit ein entsprechender Ereignis-Listener registriert ist. Ist dies nicht der Fall, bleibt das Ereignis in der Warteschlange. Sobald der Ereignis-Listener registriert ist, werden die Ereignisse, die von diesem Ereignis-Listener empfangen würden, ausgelöst und aus der Warteschlange entfernt. Auf diese Weise können Sie die Ereignis-Listener jederzeit in der App hinzufügen (z. B. nachdem Sie darauf gewartet haben, dass Ihr Redux-Speicher konfiguriert und rehydriert wird, was potenziell 1-2 Sekunden nach dem Laden der App selbst sein kann), und dann sobald Wenn die Ereignis-Listener registriert sind, werden Ihre Ereignishandlerfunktionen aufgerufen und erhalten die aufgetretenen Ereignisse (z. B. das Ereignis, dass eine Benachrichtigung geöffnet wurde).

Eine andere mögliche Lösung, zumindest um zu erkennen, dass die App geöffnet wurde, weil der Benutzer auf eine Push-Benachrichtigung getippt hat, wäre, etwas Ähnliches wie getInitialNotification() von PushNotificationIOS $ aus zu tun, wie Sie vorgeschlagen haben, wo Sie können Rufen Sie diese Funktion jederzeit auf und sie gibt die Push-Benachrichtigung zurück, auf die der Benutzer getippt hat, um die App zu öffnen (oder null , wenn dies nicht der Fall war). Aber selbst wenn dies in respond-native-onesignal implementiert wäre, würde es nichts zur Lösung dieses Problems beitragen, das die anderen Ereignis-Listener betrifft (zB den ids -Ereignis-Listener).

Ich denke also, dass es wirklich eine Lösung geben muss, die dieses Kernproblem angeht, dass Ereignisse ausgelöst werden, bevor ein entsprechender Ereignis-Listener registriert ist, was dazu führt, dass das Ereignis von der App verpasst wird.

Hallo @jordanmkoncz , können Sie den Code der Datei teilen, an die Sie die Aktionen gesendet haben? Ich habe das gleiche React-Native-Setup wie Sie (Redux-Persist usw.)

@ccoeder sicher, hier ist meine aktuelle App.js -Datei.

import React, { Component } from 'react';
import { Provider } from 'react-redux';
import OneSignal from 'react-native-onesignal';
import isNil from 'lodash/isNil';
import configureStore from '../redux/configureStore';
import {
  pushNotificationIdsReceived,
  pushNotificationOpened,
  pushNotificationReceived,
  pushNotificationRegistered,
} from '../redux/actionCreators';
import AppNavigator from './AppNavigator';
import Blank from './Blank';

let openedPushNotificationResult = null;
let receivedPushNotification = null;
let receivedNotificationUserInfo = null;
let receivedIds = null;

const onOpened = openResult => {
  openedPushNotificationResult = openResult;
};

const onReceived = notification => {
  receivedPushNotification = notification;
};

const onRegistered = notificationUserInfo => {
  receivedNotificationUserInfo = notificationUserInfo;
};

const onIds = ids => {
  receivedIds = ids;
};

OneSignal.addEventListener('opened', onOpened);
OneSignal.addEventListener('received', onReceived);
OneSignal.addEventListener('registered', onRegistered);
OneSignal.addEventListener('ids', onIds);

class App extends Component {
  constructor() {
    super();

    this.state = {
      isStoreInitialised: false,
    };

    this.store = null;

    this.onOpened = this.onOpened.bind(this);
    this.onReceived = this.onReceived.bind(this);
    this.onRegistered = this.onRegistered.bind(this);
    this.onIds = this.onIds.bind(this);
  }

  componentDidMount() {
    this.store = configureStore(store => {
      if (!isNil(openedPushNotificationResult)) {
        store.dispatch(pushNotificationOpened(openedPushNotificationResult));
      }

      if (!isNil(receivedPushNotification)) {
        store.dispatch(pushNotificationReceived(receivedPushNotification));
      }

      if (!isNil(receivedNotificationUserInfo)) {
        store.dispatch(pushNotificationRegistered(receivedNotificationUserInfo));
      }

      if (!isNil(receivedIds)) {
        store.dispatch(pushNotificationIdsReceived(receivedIds));
      }

      OneSignal.addEventListener('opened', this.onOpened);
      OneSignal.addEventListener('received', this.onReceived);
      OneSignal.addEventListener('registered', this.onRegistered);
      OneSignal.addEventListener('ids', this.onIds);

      OneSignal.removeEventListener('opened', onOpened);
      OneSignal.removeEventListener('received', onReceived);
      OneSignal.removeEventListener('registered', onRegistered);
      OneSignal.removeEventListener('ids', onIds);

      this.setState({ isStoreInitialised: true });
    });
  }

  componentWillUnmount() {
    OneSignal.removeEventListener('opened', this.onOpened);
    OneSignal.removeEventListener('received', this.onReceived);
    OneSignal.removeEventListener('registered', this.onRegistered);
    OneSignal.removeEventListener('ids', this.onIds);
    OneSignal.removeEventListener('opened', onOpened);
    OneSignal.removeEventListener('received', onReceived);
    OneSignal.removeEventListener('registered', onRegistered);
    OneSignal.removeEventListener('ids', onIds);
  }

  onOpened(openResult) {
    this.store.dispatch(pushNotificationOpened(openResult));
  }

  onReceived(notification) {
    this.store.dispatch(pushNotificationReceived(notification));
  }

  onRegistered(notificationUserInfo) {
    this.store.dispatch(pushNotificationRegistered(notificationUserInfo));
  }

  onIds(ids) {
    this.store.dispatch(pushNotificationIdsReceived(ids));
  }

  render() {
    if (!this.state.isStoreInitialised) {
      return <Blank />;
    }

    return (
      <Provider store={this.store}>
        <AppNavigator />
      </Provider>
    );
  }
}

export default App;

Hinweis: configureStore ist eine Funktion, die meinen Redux-Speicher erstellt (dh sie ruft createStore() ) und dann Redux-Persist einrichtet (dh sie ruft persistStore() ). configureStore nimmt eine Callback-Funktion als Parameter, und im onComplete -Callback der persistStore -Funktion rufe ich die an configureStore übergebene Callback-Funktion auf und übergebe den Store Objekt als Parameter für diesen Callback. Schließlich gibt configureStore das Store-Objekt zurück.

Im Grunde warte ich also, bis mein Geschäft eingerichtet und rehydriert ist, und dann sende ich Aktionen basierend auf Ereignissen, die von meinen anfänglichen Ereignis-Listenern empfangen wurden, füge dann die neuen Ereignis-Listener hinzu und entferne die anfänglichen Ereignis-Listener.

@jordanmkoncz Vielen Dank, dass Sie Ihren Code geteilt haben. Zuerst dachte ich, ich hätte den gleichen Fehler wie Sie, aber mir wurde klar, dass mein Problem mit der stillen Benachrichtigung zusammenhängt. Ich muss handeln, wenn die Benachrichtigung kommt, während die Anwendung geschlossen ist. Ich denke, Ihre Codes funktionieren bei mir nicht.

Keine Sorge @ccoeder. Ja, das Problem, tatsächlich Maßnahmen bei einer Benachrichtigung zu ergreifen, während die App geschlossen ist, ist ein anderes. Dieses Problem bezieht sich speziell auf die Erkennung in der App, dass der Benutzer zum Zeitpunkt des Starts der App auf eine Benachrichtigung getippt hat, um die App zu öffnen (wenn sie zuvor überhaupt nicht ausgeführt wurde).

Schauen Sie sich an, wie es "react-native-fcm" macht, es gibt eine Methode namens "getInitialNotification".

@jordanmkoncz Danke für deinen Beitrag.

Ich hatte das ähnliche Problem. Wenn die App die Push-Benachrichtigung erhalten hat, navigiert der Bildschirm zum gewünschten Bildschirm.
Aber wenn die Benachrichtigung geöffnet wird, funktioniert sie nicht für die Navigations-Push-Funktion.
Beispiel:
KomponenteWillMount() {
OneSignal.addEventListener('received', this._onReceived);
OneSignal.addEventListener('geöffnet', this._onOpened);
}
KomponenteWillUnmount() {
OneSignal.removeEventListener('received', this.__onReceived);
OneSignal.removeEventListener('geöffnet', this._onOpened);
}
_onRecevied(Benachrichtigung) {
console.log('Benachrichtigung erhalten: ', Benachrichtigung); // gut arbeiten
this.props.navigator.push({ pushSreen, passProps : { params } }); // gut arbeiten
}
_onOpened(openResult) {
console.log('Benachrichtigungstext: ', openResult.notification.payload.body); // gut arbeiten
this.props.navigator.push({ pushSreen, passProps : { params } }); // funktioniert nicht
}

Was denkst du darüber? Wenn Sie mir helfen können, hoffen Sie, hier zu antworten. Danke

Hmm.. Ich habe meine PushNotificationHelper Komponente als Kind meiner Redux Provider , die erst gerendert wird, nachdem die store rehydriert wurde.

componentWillMount() {
    AppState.addEventListener("change", this.handleAppStateChange);
    OneSignal.configure({
      onNotificationOpened: this.handleOpenNotification
    });
    OneSignal.addEventListener("received", this.onReceived);
    OneSignal.addEventListener("opened", this.onOpened);
    OneSignal.addEventListener("registered", this.onRegistered);
    OneSignal.addEventListener("ids", this.onIds);

    if (!IOS) {
      OneSignal.inFocusDisplaying(0);
    }
  }

  componentWillUnmount() {
    AppState.removeEventListener("change", this.handleAppStateChange);
    OneSignal.removeEventListener("received", this.onReceived);
    OneSignal.removeEventListener("opened", this.onOpened);
    OneSignal.removeEventListener("registered", this.onRegistered);
    OneSignal.removeEventListener("ids", this.onIds);
  }

handleOpenNotification = (message, data, isActive) => {
    console.log("Notification", message, data, isActive);

    if (isActive) {
      // touchable banner displaying info from push notification
    } else {
      // act on data received from push notification
    }
  };

onReceived = notification => {
    console.log("Notification received: ", notification);
  };

onOpened = openResult => {
    console.log("Message: ", openResult.notification.payload.body);
    console.log("Data: ", openResult.notification.payload.additionalData);
    console.log("isActive: ", openResult.notification.isAppInFocus);
    console.log("openResult: ", openResult);
  };

Selbst wenn meine App geschlossen ist – nicht in einem background AppState, sondern vollständig geschlossen –, wenn ich auf eine Push-Benachrichtigung tippe, wird die onOpened -Methode mit dem openResult aufgerufen Objekt und die dazugehörigen Daten, und es steht mir frei, dispatch entsprechende Redux-Aktionen vorzunehmen.

@wkoutre das ist interessant, könnten Sie posten, welche Versionen von react-native , react-native-onesignal usw. Sie derzeit verwenden? Hast du das sowohl auf iOS als auch auf Android getestet? Haben Sie das Öffnen der App durch Tippen auf eine Push-Benachrichtigung umfassend getestet, wobei die App zum Zeitpunkt des Tippens auf die Push-Benachrichtigung vollständig geschlossen war, und festgestellt, dass Ihre onOpened -Methode zu 100 % aufgerufen wird?

Könnten Sie einige Tests durchführen, um zu sehen, ob es immer noch 100% der Zeit funktioniert, wenn Sie das Laden Ihrer PushNotificationHelper künstlich noch weiter verzögern, zB durch ein setTimeout mit einer Verzögerung von etwa 5 Sekunden, nach dem Sie etwas im Zustand ändern, damit PushNotificationHelper gemountet und seine Ereignis-Listener bei OneSignal registriert werden können?

@jordanmkoncz

"react-native": "0.50.4"
"react-native-onesignal": "^3.0.7"

Ich habe sowohl auf iOS als auch auf Android getestet, ja. Bei beiden 100% der Zeit:

• App ist komplett geschlossen
• Push-Benachrichtigung empfangen wird
• Push-Benachrichtigung angetippt wird
• App lädt
• onOpened wird mit Daten aus der Push-Benachrichtigung aufgerufen und openResult.notification.isAppInFocus === false

Ich übernehme die setTimeout und melde mich bei Ihnen.

EDIT1: Ich habe absolut nichts geändert, und jetzt schlägt es auf Android 100% der Zeit fehl.

EDIT2: Die Verzögerung von setTimeout führte dazu, dass onOpened beim Laden der App nicht ausgelöst wurde, weil auf eine Push-Benachrichtigung getippt wurde. Ich habe jedoch alles in die Lebenszyklusmethoden von App.js verschoben – meine Root-Komponente ist in index.ios.js und index.android.js registriert – und onOpened heißt 100% der Zeit iOS und ~50% der Zeit auf Android.

Ich bin mir nicht sicher, warum Android inkonsistent ist, aber es ist offensichtlich ein Problem. Wenn die App unter Android vollständig geschlossen ist und eine Benachrichtigung eingeht, wird der Debugger gelöscht und alles in meinem App.js wird geladen, bis ich die Klasse selbst erstelle.

const IOSX = HEIGHT === 812 && PLATFORM === "ios";

const wrapperStyle = [Styles.flex1];
if (IOSX) wrapperStyle.push(Styles.backgroundDarkGray);

let SPLASH_TIME;

console.log(`Change to TRUE below to reset store state`);

const PURGE = DEV ? false : false;

if (DEV) SPLASH_TIME = 4000;
else SPLASH_TIME = 4000;

// const composeEnhancers = composeWithDevTools({
//   realtime: true,
//   port: 8000
// });

const composeEnhancers =
  typeof window === "object" &&
  window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ &&
  DEV
    ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
        // Specify extension’s options like name, actionsBlacklist, actionsCreators, serialize...
      })
    : compose;

const middlewares = [ReduxThunk];

// debugging tooling
// if (DEV) {
//   // add logger
// middlewares.push(logger)

//   // middlewares = [...middlewares, logger];
//   middlewares = [...middlewares];

// replace these transient reducers when they've been created

export const store = createStore(
  Reducers,
  {},
  composeEnhancers(
    applyAppStateListener(),
    applyMiddleware(...middlewares),
    autoRehydrate()
  )
);

// if (module.hot) {
//   // Enable hot module replacement for reducers
//   module.hot.accept(() => {
//     const nextRootReducer = require("./reducers/index").default;
//     store.replaceReducer(nextRootReducer);
//   });
// }

console.log(`right before APP`);

// Debugger logs everything before this line.

export default class App extends Component {
    ...
}

@jordanmkoncz Neugierig, ob Sie diese Bibliothek ausprobiert haben: https://github.com/wix/react-native-notifications

Okay, ich habe eine Problemumgehung, die zu 100 % sowohl auf iOS als auch auf Android funktioniert.

In meinem App.js , aber bevor ich meine App-Komponente deklariere, habe ich:

const handleOnOpened = openResult => {
  store.dispatch(setInitialNotification(openResult));
};

OneSignal.configure({});
OneSignal.addEventListener("opened", handleOnOpened);

... wobei setInitialNotification ein Aktionsersteller ist.

Dann, wenn meine (jetzt gemountete) App die Rehydrierung beendet hat, rufe ich:

this.setState({ rehydrated: true }, () => {
          OneSignal.removeEventListener("opened", handleOnOpened);
        });

Meine App – umschlossen mit einem Redux Provider – wird dann in der Methode render zurückgegeben und sieht in etwa so aus …

<Provider store={store}>
        <IphoneXAwareView style={wrapperStyle}>
          <StatusBar hidden={false} barStyle="light-content" />
          <MyAlert />
          <Loading />
          <ConnectedAppWithNavigationState />
          <PushNotificationHelper />
        </IphoneXAwareView>
      </Provider>

Von dort aus übernimmt die PushNotificationHelper -Komponente das Abhören und Verarbeiten aller Push-Benachrichtigungen.

@bhoop Es ist ein paar Monate her, also bin ich mir nicht sicher, ob du immer noch nach einer Lösung suchst, aber ... wenn ja, probiere es aus.

@wkoutre Könnten Sie eine PR mit Aktualisierungen der Readme-Datei einrichten, die diese Problemumgehung für Redux enthält?

@avishayil Sichere Sache. Bis heute Abend komme ich dazu

avishayil PR gemacht.

Ich stehe vor einem Problem, das sich so anhört. Wenn die App geöffnet ist, laufen alle Rückrufe ok, auch wenn die App im Hintergrund ist. Aber wenn ich einen Push erhalte, erhöht sich mein App-Symbol um +1, und das System zeigt sein Banner mit Benachrichtigungsinhalt, ABER wenn ich das Banner ignoriere und die App über das Symbol (nicht über das Benachrichtigungsbanner) öffne, wird der Rückruf ignoriert = [ Anleitung geh damit um ?

• Expo-Detach-App
• reagieren 16.3.1
• Einsignal 3.2.5
• Messe 27.0.1

@brunoandradebr das ist das erwartete Verhalten. Beim Öffnen der App über das App-Symbol werden keine Benachrichtigungen berücksichtigt, die Sie möglicherweise erhalten haben. Es öffnet nur die App.

Wenn Sie das Verhalten Ihrer App beim Start basierend darauf ändern möchten, ob der Benutzer eine Benachrichtigung erhalten hat, müssen Sie dies beim Start selbst überprüfen.

Es ist nicht wahr. Wenn ich die App per Symbol öffne, während die App im Hintergrund läuft, werden Push-Benachrichtigungen wie gewünscht verarbeitet. Nur wenn ich es aus dem Speicher entferne (swipe), dann per Icon öffne, passiert nichts. Ich habe nachgeforscht und ich denke, es ist XCode, der die App stoppt und den oonesignal lib-Link schließt.

@brunoandradebr Ich verstehe das Problem, das Sie haben, möglicherweise falsch und auf welche Rückrufe beziehen Sie sich?
Wenn die App im Hintergrund ausgeführt wird, kann sie received -Ereignisse verarbeiten. Aber wenn die App beendet wird, kann sie auf kein Ereignis lauschen. Die einzige Möglichkeit, wie eine Benachrichtigung mit einer App interagieren kann (zumindest für iOS), besteht darin, auf irgendeine Weise mit der Benachrichtigung zu interagieren.

Wenn ich die App beende und eine Benachrichtigung erhalte, wenn ich die App per Symbol öffne, kann die App keine Callback-Ereignisse verarbeiten, ABER wenn die App im Hintergrund läuft und ich per Symbol öffne, werden Callbacks wie erwartet ausgelöst. Habe es ?

@brunoandradebr Ich glaube, ich habe es verstanden, und wenn ich mich nicht irre, ist das das Verhalten, das ich in meinem vorherigen Kommentar beschrieben habe. Auf jeden Fall denke ich, dass dies kein Thema ist, und wenn Sie glauben, dass Sie ein Problem damit haben, sollten Sie ein separates Problem im Repo eröffnen.

@jordanmkoncz Sie scheinen ein wirklich gutes Verständnis für die Probleme der Reaktionsnativen von Onesignal zu haben. Die Versionen, die ich verwende, „react-native-onesignal“: ^3.2.8 und „react-native: 0.56.0“. Ich konnte die Handhabung von Benachrichtigungen im Hintergrund und Vordergrund implementieren, aber ich habe jetzt ein Problem, wenn die App geschlossen ist und eine Benachrichtigung angetippt wird. Die App zeigt nur einen leeren weißen Bildschirm, der nicht verschwindet, es sei denn, Sie schließen und starten ihn neu. Ich bin mir nicht sicher, wie ich mit dieser Situation umgehen soll, da ich auf der Website von OneSignal keine Dokumentation finden kann. Es ist frustrierend, weil ich Zeit damit verbracht habe, diese Bibliothek zu lernen und zu implementieren, und jetzt bin ich mir nicht sicher, ob sie diesen äußerst wichtigen Anwendungsfall bewältigen kann. Ich habe oben eine mögliche Problemumgehung dafür gelesen, die die Ereignis-Listener in index.js implementiert, aber ich verwende die Reaktionsnavigation und muss eine Referenz von meinem Hauptnavigator abrufen, die in App.js deklariert ist, um zu einem verschachtelten Stack-Bildschirm zu navigieren. Ich würde wirklich jeden Rat schätzen, den man im Umgang mit diesem Problem hat und wie sie es gelöst haben. Vielen Dank im Voraus.