dynamicbible/DynamicBibleIonic/src/pages/search/search.ts

import { Type, Component, OnInit } from '@angular/core';
import { Loading, LoadingController, ModalController, NavParams, AlertController, MenuController } from 'ionic-angular';
import { Storage } from '@ionic/storage';

import { StrongsModal } from '../../components/strongs-modal/strongs-modal';
import { PagesService } from "../../services/pages-service";

import { UserProfile } from '../../libs/UserProfile';
import { Reference } from '../../libs/Reference';

@Component({
    templateUrl: 'search.html'
})
export class SearchPage implements OnInit
{
    searchQuery = '';
    userProfile: UserProfile;
    last: CardItem;
    loader: Loading;
    title: string;

    constructor(
        private pagesService: PagesService
        , private alertCtrl: AlertController
        , private menu: MenuController
        , public loadingCtrl: LoadingController
        , public modalCtrl: ModalController
        , public local: Storage
        , public params: NavParams
    )
    {
        this.userProfile = new UserProfile(UserProfile.createDefaultUser());
    }

    ngOnInit(): void
    {
        // Check if there is a profile saved in local storage
        this.local.get('profile').then(profile =>
        {
            let t = this.userProfile;

            if (profile !== null)
                t = JSON.parse(profile);

            this.loader = this.loadingCtrl.create({ content: 'Loading Page...' });
            this.loader.present().then(
                () =>
                {
                    this.userProfile.update(t, this.local);

                    this.initializeItems(this.userProfile);

                    this.loader.dismiss();
                });
        }).catch(error =>
        {
            console.log(error);
        });
    }
    initializeItems(u: UserProfile)
    {
        // migrate old way of storing card items to the new.
        let has_migrated = false;
        for (let i in u.user.items)
        {
            let ci = u.user.items[i];
            if (ci["data"] !== undefined)
            {
                if (ci["data"].qry !== undefined)
                    u.user.items[i] = { qry: ci["data"].qry, dict: ci.dict, type: ci.type };
                else if (ci["data"].ref !== undefined)
                    u.user.items[i] = { qry: ci["data"].ref, dict: ci.dict, type: ci.type };
                else if (ci["data"].word !== undefined)
                    u.user.items[i] = { qry: ci["data"].word, dict: ci.dict, type: ci.type };
                else if (ci["data"].sn !== undefined)
                    u.user.items[i] = { qry: ci["data"].sn, dict: ci["prefix"] === 'G' ? 'grk' : 'heb', type: ci.type };

                has_migrated = true;
            }
        }

        for (let pg of u.user.saved_pages)
        {
            for (let i in pg.queries)
            {
                let ci = pg.queries[i];
                if (ci["data"] !== undefined)
                {
                    if (ci["data"].qry !== undefined)
                        pg.queries[i] = { qry: ci["data"].qry, dict: ci.dict, type: ci.type };
                    else if (ci["data"].ref !== undefined)
                        pg.queries[i] = { qry: ci["data"].ref, dict: ci.dict, type: ci.type };
                    else if (ci["data"].word !== undefined)
                        pg.queries[i] = { qry: ci["data"].word, dict: ci.dict, type: ci.type };
                    else if (ci["data"].sn !== undefined)
                        pg.queries[i] = { qry: ci["data"].sn, dict: ci["prefix"] === 'G' ? 'grk' : 'heb', type: ci.type };

                    has_migrated = true;
                }
            }
        }
        // initialize the pages.
        this.pagesService.initializePages(u.user.saved_pages);
        if (this.params.data.queries !== undefined)
            this.userProfile.user.items = this.params.data.queries.slice();
        if (this.params.data.title === undefined)
            this.title = "Search";
        else
            this.title = this.params.data.title;

        if (has_migrated)
            this.userProfile.save(this.local);
    }

    actionsMenu()
    {
        this.menu.open('actions');
    }

    addPage()
    {
        let alert = this.alertCtrl.create({
            title: 'Save Search as Page',
            inputs: [
                {
                    name: 'title',
                    placeholder: 'Page Title'
                }
            ],
            buttons: [
                {
                    text: 'Cancel',
                    role: 'cancel',
                    handler: data =>
                    {
                        console.log('Cancel clicked');
                    }
                },
                {
                    text: 'Save',
                    handler: data =>
                    {
                        let p = { queries: this.userProfile.user.items.slice(), title: data.title };
                        this.userProfile.user.saved_pages.push(p);
                        this.userProfile.save(this.local);
                        this.pagesService.addPage(p);
                    }
                }
            ]
        });
        alert.present();
    }
    updatePage()
    {
        let page = this.userProfile.user.saved_pages.find(
            i =>
                i.title == this.params.data.title
        );
        page.queries = this.userProfile.user.items.slice();
        this.userProfile.save(this.local);
    }

    setQuery(searchbar)
    {
        this.searchQuery = searchbar.target.value;
    }
    getQuery(searchbar)
    {
        this.updateUIwithItems(this.searchQuery, true);
    }

    isError(t: string)
    {
        return t === 'Error';
    }
    isPassage(t: string)
    {
        return t === 'Passage';
    }
    isStrongs(t: string)
    {
        return t === 'Strongs';
    }
    isWords(t: string)
    {
        return t === 'Words';
    }

    removeItem(item)
    {
        let idx = this.userProfile.user.items.indexOf(item);
        this.userProfile.user.items.splice(idx, 1);

        // save the users settings.
        this.userProfile.save(this.local);
    }
    addItemToList(item: CardItem)
    {
        if (this.userProfile.user.append_to_bottom)
        {
            if (this.last != null && this.userProfile.user.insert_next_to_item)
            {
                let idx = this.userProfile.user.items.indexOf(this.last);
                this.userProfile.user.items.splice(idx + 1, 0, item);
            }
            else
                this.userProfile.user.items.push(item);
        }
        else
        {
            if (this.last != null && this.userProfile.user.insert_next_to_item)
            {
                let idx = this.userProfile.user.items.indexOf(this.last);
                this.userProfile.user.items.splice(idx, 0, item);
            }
            else
                this.userProfile.user.items.unshift(item);
        }
        this.last = null;
    }
    getItemsNextToCard(data: OpenData)
    {
        this.last = data.card;
        this.updateUIwithItems(data.qry, data.from_search_bar);
    }

    getItemList(search: string): Promise<CardItem[]>
    {
        return new Promise((resolve, reject) =>
        {
            let list: CardItem[] = [];

            try
            {
                let qs = search.split(';');
                for (let x in qs)
                {
                    if (qs.hasOwnProperty(x))
                    {
                        let q = qs[x].trim();
                        if (q !== '')
                        {
                            // its a search term.
                            if (q.search(/[0-9]/i) === -1)
                                list.push({ qry: q, dict: 'na', type: 'Words' });
                            else if (q.search(/(H|G)[0-9]/i) !== -1)
                            {
                                // its a strongs lookup
                                let dict = q.substring(0, 1);

                                if (dict.search(/h/i) !== -1)
                                    dict = 'heb';
                                else
                                    dict = 'grk';

                                q = q.substring(1, q.length);
                                list.push({ qry: q, dict: dict, type: 'Strongs' });
                            }
                            else
                            {
                                // its a verse reference.
                                if (q.trim() !== '')
                                {
                                    let myref = new Reference(q.trim());
                                    list.push({ qry: myref.toString(), dict: myref.Section.start.book > 39 ? 'G' : 'H', type: 'Passage' });
                                }
                            }
                        }
                    }
                }
                if (this.userProfile.user.clear_search_after_query)
                    $('.searchbar-input').val('');

                this.userProfile.save(this.local);
            }
            catch (error)
            {
                list.push({ qry: error, type: 'Error', dict: 'na' });
                console.log(error);
            }

            resolve(list);
        });
    }

    updateUIwithItems(search: string, from_search_bar: boolean)
    {
        this.getItemList(search).then(lst =>
        {
            this.loader = this.loadingCtrl.create({ content: 'Looking up Query...' });
            this.loader.present().then(
                () =>
                {
                    for (let item of lst)
                    {
                        if (item.type == "Strongs" && this.userProfile.user.strongs_modal && !from_search_bar)
                        {
                            let modal = this.modalCtrl.create(StrongsModal, { sn: parseInt(item.qry), dict: item.dict, onItemClicked: this });
                            modal.present();
                        }
                        else
                            this.addItemToList(item);
                    }
                    this.loader.dismiss();
                }
            );
        });
    }
}

export type OpenData = { card: CardItem, qry: string, from_search_bar: boolean }

export type CardItem = { qry: string, type: string, dict: string }

class Item
{
    id: number;
    data: any;
    type: Type<any>;
    dict: string;
}