List<FileNotifyInformation> notifications = response.getNotifyInformation();
        assertEquals(3, notifications.size());

        // Verify first notification
        assertEquals("file1.txt", notifications.get(0).getFileName());
        assertEquals(FileNotifyInformation.FILE_ACTION_ADDED, notifications.get(0).getAction());

        // Verify second notification

  static class QueuingRemovalListener<K, V> extends ConcurrentLinkedQueue<RemovalNotification<K, V>>
      implements RemovalListener<K, V> {

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      add(notification);
    }
  }

  /**
   * {@link RemovalListener} that counts each {@link RemovalNotification} it receives, and provides
   * access to the most-recently received one.
   */

        sendToGoogleChat(cardView, discloser);
    }

    /**
     * Sends a notification to Slack.
     *
     * @param cardView the card view for the notification
     * @param discloser the mail posting discloser
     */
    protected void sendToSlack(final CardView cardView, final SMailPostingDiscloser discloser) {
        // https://api.slack.com/messaging/webhooks#posting_with_webhooks

 */
package jcifs;

/**
 * File notification information
 *
 *
 * @author mbechler
 *
 */
public interface FileNotifyInformation {

    // filter flags

    /**
     * Any file name change in the watched directory or subtree causes a change notification wait operation to return.
     * Changes include renaming, creating, or deleting a file.
     */

  static class QueuingRemovalListener<K, V> extends ConcurrentLinkedQueue<RemovalNotification<K, V>>
      implements RemovalListener<K, V> {

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      add(notification);
    }
  }

  /**
   * {@link RemovalListener} that counts each {@link RemovalNotification} it receives, and provides
   * access to the most-recently received one.
   */

    private int breakReason;
    private int accessMaskHint;
    private int shareAccessHint;

    /**
     * Constructs an SMB2 lease break notification with the given configuration.
     *
     * @param config the configuration for this notification
     */
    public Smb2LeaseBreakNotification(Configuration config) {
        super(config);
    }

    /**
     * Gets the lease key that is being broken

        List<FileNotifyInformation> notifications = response.getNotifyInformation();

        assertNotNull(notifications);
        assertEquals(2, notifications.size());
        assertEquals(mockNotifyInfo1, notifications.get(0));
        assertEquals(mockNotifyInfo2, notifications.get(1));

        // Verify first notification
        FileNotifyInformation info1 = notifications.get(0);

    with open("log.txt", mode="w") as email_file:
        content = f"notification for {email}: {message}"
        email_file.write(content)


@app.post("/send-notification/{email}")
async def send_notification(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(write_notification, email, message="some notification")

    }

    /**
     * Handle a witness event
     *
     * @param notification the witness notification
     */
    private void handleWitnessEvent(WitnessNotification notification) {
        log.info("Handling witness event: {} for resource: {}", notification.getEventType(), notification.getResourceName());

        switch (notification.getEventType()) {
        case RESOURCE_CHANGE:

    * Collect the money from the client.
    * Send a notification back to the API user (the external developer), as a callback.
        * At this point is that the API will somehow send a POST request to the
            external API with the notification of the invoice event
            (e.g. "payment successful").
    """
    # Send the invoice, collect the money, send the notification (the callback)
    return {"msg": "Invoice received"}