constructor(instrumentation: BotFrameworkInstrumentation) {
     this.instrumentation = instrumentation;
     this.library = new Library('faq');
     this.library.localePath(path.join(__dirname, '../../../src/bots/faq/locale'));
     this.library.dialog('/', faq.createDialog(this));
     this.library.dialog('qna', qna.createDialog(this));
 }

export function createLibrary(): builder.Library {
    return lib.clone();
}

import * as builder from 'botbuilder';
import openmedicament from "../services/api-openmedicaments";
import openfda from "../services/api-openfda";

let lib = new builder.Library('medication-prompt');

interface ISearchStoredData {
    source: string
    search: any
};

interface IFdaSearch {
    brand_name: string,
    id: string,
    set_id: string,
    version: string
}

const MAX_RESULTS = 10;

/**
 * medication-prompt dialog - search into openfda and openmedicament data source
 */
lib.dialog('prompt', [
    async (session: builder.Session, args: any, next?: (results?: builder.IDialogResult<any>) => void) => {

        let query = args;
        let medications = new Array<string>();

        try {

export function createLibrary() {
    return lib.clone();
}

import * as builder from 'botbuilder';
import { SiteUrl } from '../helpers/helper-siteurl';

let lib = new builder.Library('greetings');

lib.dialog('start',
    (session: builder.Session, args: any) => {
        let cards = getCardsAttachments(session);

        if (args === 'default') {
            session.send("greetings_lost");
        } else {
            session.send("greetings_details_firstline");
            session.send("greetings_details_secondline");
        }

        // Create reply with Carousel AttachmentLayout
        var message = new builder.Message(session)
            .text("greetings_welcome")
            .attachmentLayout(builder.AttachmentLayout.carousel)
            .attachments(cards);

        session.send(message);
        session.endDialog(); // <---  DON'T FORGET TO END THE DIALOG
    });

export function getCardsAttachments(session: builder.Session) {
    return [
        new builder.HeroCard(session)
            .title(session.localizer.gettext(session.preferredLocale(), 'greetings_menu_title_findplace', "greetings"))
            .subtitle(session.localizer.gettext(session.preferredLocale(), 'greetings_menu_subtitletitle_findplace', "greetings"))

import * as builder from 'botbuilder';
import { ListStyle, IEntity } from 'botbuilder'
import spatialData, { EntityType, SpatialData } from "../services/api-bingspatialdata";

let locationDialog = require('botbuilder-location');
let lib = new builder.Library('places');

// Extends IEntity interface to support entity resolution.
declare interface IEntityEx extends builder.IEntity {
    resolution: any;
}

// Data interface that will be saved in the dialog states
interface IStoredData {
    type: string
    location: any
}

// Dialog triggered on Intent.FindPlace (ex. Find a Pharmacy in Paris)
lib.dialog('findplace', [
    (session: builder.Session, args: any, next?: (results?: builder.IDialogResult<any>) => void) => {
        let place: IStoredData;
        let heathplace: boolean = false

        if (args && args.intent) {
            let intent = args.intent;
            // Get Place.Type and Place.Location entities
            let typeEntity: IEntityEx = builder.EntityRecognizer.findEntity(intent.entities, 'Place.Type') as IEntityEx;
            let locationEntity: IEntityEx = builder.EntityRecognizer.findEntity(intent.entities, 'Place.Location') as IEntityEx;

            place = session.dialogData.place = {

import * as builder from 'botbuilder';
import openmedicament, { Medication, MedicationCode } from "../services/api-openmedicaments";
import openfda, { Result } from "../services/api-openfda";
import translator from "../services/cognitive-translator";
import medicationcard from "../cards/medication-card";
import countrydata from '../helpers/helper-countrydata';

let turndownService = require('turndown');
let languages = require('country-data').languages;

let lib = new builder.Library('medication');

// Extends IEntity interface to support entity resolution.
declare interface IEntityEx extends builder.IEntity {
    resolution: any;
}

interface IInformationStoredData {
    name: string,
    type: string
}

interface ITranslateStoredData {
    name: string
    language?: string
    languageCode?: string
    country?: string,
    countryCode?: string,
    drugdetails?: any
}

import * as builder from 'botbuilder';
import {ListStyle} from 'botbuilder';
import vision from '../services/cognitive-Vision';
import custom from '../services/cognitive-CustomVision';
import attachment from "../helpers/helper-attachment";
import translator from "../services/cognitive-translator";
import countrydata from '../helpers/helper-countrydata';

let lib = new builder.Library('image');
let image: Buffer | undefined = undefined;

lib.dialog('detection', [
    async (session: builder.Session, args: any, next?: (results?: builder.IDialogResult<any>) => void) => {
        session.send("Image received. Analysis in progress.");

        session.sendTyping();

        if (attachment.hasImageAttachment(session.message)) {

            image = undefined;
            image = await attachment.getImageFromMessageAsync(session.message, session.connector);

            if (!image) {
                return session.endDialog("Not able to get the image you sent, sorry :(");
            }

            let isMedicineImage = await custom.isMedicineImage(image);

            if (!isMedicineImage) {
                let caption = await vision.getCaptionFromImageAsync(image);
                return session.endDialog(`This image is not medicine package. It seems ${caption}.`);

import * as builder from 'botbuilder';
import countrydata from '../helpers/helper-countrydata';

let lib = new builder.Library('country-prompt');
let languages = require('country-data').languages;

lib.dialog('prompt', [
    (session: builder.Session, results: any, next?: (results?: builder.IDialogResult<any>) => void) => {
        // Prompt the user for a country
        builder.Prompts.text(session, "drugs_country_prompt");
    },
    (session: builder.Session, results: any, next?: (results?: builder.IDialogResult<any>) => void) => {

        if (results && results.response) {
            let searchCountry = countrydata.getCountryByName(results.response);
            if (searchCountry) {
                let result = {
                    country: searchCountry.name,
                    countryCode: searchCountry.alpha2
                };
                return session.endDialogWithResult({ response: result });
            }
        }

        session.send("drugs_default_country");
        return session.replaceDialog("prompt");
    }
]);

export function createLibrary(): builder.Library {
    return lib.clone();