source: mainline/uspace/app/contacts/contacts.c@ efe0881

/*
 * Copyright (c) 2018 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup contacts
 * @{
 */

/**
 * @file Contact list application.
 *
 * Maintain a contact list / address book. The main purpose of this
 * trivial application is to serve as an example of using SIF.
 */

#include <adt/list.h>
#include <errno.h>
#include <nchoice.h>
#include <sif.h>
#include <stdio.h>
#include <stdlib.h>
#include <str.h>

/** Contacts */
typedef struct {
        /** Open SIF repository */
        sif_sess_t *repo;
        /** Entries SIF node */
        sif_node_t *nentries;
        /** Entries list (of contacts_entry_t) */
        list_t entries;
} contacts_t;

/** Contact entry */
typedef struct {
        /** Containing contacts */
        contacts_t *contacts;
        /** Link to contacts->entries */
        link_t lentries;
        /** SIF node for this entry */
        sif_node_t *nentry;
        /** Contact name */
        char *name;
} contacts_entry_t;

/** Actions in contact menu */
typedef enum {
        /** Create new contact */
        ac_create_contact,
        /** Delete contact */
        ac_delete_contact,
        /** Exit */
        ac_exit
} contact_action_t;

static errno_t contacts_load(sif_node_t *, contacts_t *);
static contacts_entry_t *contacts_first(contacts_t *);
static contacts_entry_t *contacts_next(contacts_entry_t *);
static void contacts_entry_delete(contacts_entry_t *);

/** Open contacts repo or create it if it does not exist.
 *
 * @param fname File name
 * @param rcontacts Place to store pointer to contacts object.
 *
 * @return EOK on success or error code
 */
static errno_t contacts_open(const char *fname, contacts_t **rcontacts)
{
        contacts_t *contacts = NULL;
        sif_sess_t *repo = NULL;
        sif_trans_t *trans = NULL;
        sif_node_t *node;
        const char *ntype;
        errno_t rc;

        contacts = calloc(1, sizeof(contacts_t));
        if (contacts == NULL)
                return ENOMEM;

        list_initialize(&contacts->entries);

        /* Try to open an existing repository. */
        rc = sif_open(fname, &repo);
        if (rc != EOK) {
                /* Failed to open existing, create new repository */
                rc = sif_create(fname, &repo);
                if (rc != EOK)
                        goto error;

                /* Start a transaction */
                rc = sif_trans_begin(repo, &trans);
                if (rc != EOK)
                        goto error;

                /* Create 'entries' node container for all entries */
                rc = sif_node_append_child(trans, sif_get_root(repo), "entries",
                    &contacts->nentries);
                if (rc != EOK)
                        goto error;

                /* Finish the transaction */
                rc = sif_trans_end(trans);
                if (rc != EOK)
                        goto error;

                trans = NULL;
        } else {
                /*
                 * Opened an existing repository. Find the 'entries' node.
                 * It should be the very first child of the root node.
                 * This is okay to do in general, as long as we don't
                 * require forward compatibility (which we don't).
                 */
                node = sif_node_first_child(sif_get_root(repo));
                if (node == NULL) {
                        rc = EIO;
                        goto error;
                }

                /* Verify it's the correct node type(!) */
                ntype = sif_node_get_type(node);
                if (str_cmp(ntype, "entries") != 0) {
                        rc = EIO;
                        goto error;
                }

                rc = contacts_load(node, contacts);
                if (rc != EOK)
                        goto error;
        }

        contacts->repo = repo;
        *rcontacts = contacts;

        return EOK;
error:
        if (trans != NULL)
                sif_trans_abort(trans);
        if (repo != NULL)
                (void) sif_close(repo);
        if (contacts != NULL)
                free(contacts);
        return rc;
}

/** Load contact entries from SIF repository.
 *
 * @param nentries Entries node
 * @param contacts Contacts object to load to
 * @return EOK on success or error code
 */
static errno_t contacts_load(sif_node_t *nentries, contacts_t *contacts)
{
        sif_node_t *nentry;
        contacts_entry_t *entry;
        const char *name;

        contacts->nentries = nentries;

        nentry = sif_node_first_child(nentries);
        while (nentry != NULL) {
                if (str_cmp(sif_node_get_type(nentry), "entry") != 0)
                        return EIO;

                entry = calloc(1, sizeof(contacts_entry_t));
                if (entry == NULL)
                        return ENOMEM;

                name = sif_node_get_attr(nentry, "name");
                if (name == NULL) {
                        free(entry);
                        return EIO;
                }

                entry->name = str_dup(name);
                if (entry->name == NULL) {
                        free(entry);
                        return ENOMEM;
                }

                entry->contacts = contacts;
                entry->nentry = nentry;
                list_append(&entry->lentries, &contacts->entries);

                nentry = sif_node_next_child(nentry);
        }

        return EOK;
}

/** Interaction to create new contact.
 *
 * @param contacts Contacts
 */
static errno_t contacts_create_contact(contacts_t *contacts)
{
        tinput_t *tinput;
        sif_trans_t *trans = NULL;
        sif_node_t *nentry;
        contacts_entry_t *entry = NULL;
        errno_t rc;
        char *cname = NULL;

        tinput = tinput_new();
        if (tinput == NULL)
                return ENOMEM;

        printf("Contact name:\n");

        rc = tinput_set_prompt(tinput, "?> ");
        if (rc != EOK)
                goto error;

        rc = tinput_read(tinput, &cname);
        if (rc != EOK)
                goto error;

        entry = calloc(1, sizeof(contacts_entry_t));
        if (entry == NULL) {
                rc = ENOMEM;
                goto error;
        }

        rc = sif_trans_begin(contacts->repo, &trans);
        if (rc != EOK)
                goto error;

        rc = sif_node_append_child(trans, contacts->nentries, "entry", &nentry);
        if (rc != EOK)
                goto error;

        rc = sif_node_set_attr(trans, nentry, "name", cname);
        if (rc != EOK)
                goto error;

        rc = sif_trans_end(trans);
        if (rc != EOK)
                goto error;

        trans = NULL;
        entry->contacts = contacts;
        entry->nentry = nentry;
        entry->name = cname;
        list_append(&entry->lentries, &contacts->entries);

        tinput_destroy(tinput);
        return EOK;
error:
        if (trans != NULL)
                sif_trans_abort(trans);
        if (cname != NULL)
                free(cname);
        if (entry != NULL)
                free(entry);
        return rc;
}

/** Interaction to delete contact.
 *
 * @param contacts Contacts
 */
static errno_t contacts_delete_contact(contacts_t *contacts)
{
        nchoice_t *choice = NULL;
        contacts_entry_t *entry;
        sif_trans_t *trans = NULL;
        errno_t rc;
        void *sel;

        rc = nchoice_create(&choice);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_set_prompt(choice, "Select contact to delete");
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        entry = contacts_first(contacts);
        while (entry != NULL) {
                rc = nchoice_add(choice, entry->name, (void *)entry, 0);
                if (rc != EOK) {
                        assert(rc == ENOMEM);
                        printf("Out of memory.\n");
                        goto error;
                }

                entry = contacts_next(entry);
        }

        rc = nchoice_add(choice, "Cancel", NULL, 0);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_get(choice, &sel);
        if (rc != EOK) {
                printf("Error getting user selection.\n");
                return rc;
        }

        if (sel != NULL) {
                entry = (contacts_entry_t *)sel;

                rc = sif_trans_begin(contacts->repo, &trans);
                if (rc != EOK)
                        goto error;

                sif_node_destroy(trans, entry->nentry);

                rc = sif_trans_end(trans);
                if (rc != EOK)
                        goto error;

                trans = NULL;

                list_remove(&entry->lentries);
                contacts_entry_delete(entry);
        }

        nchoice_destroy(choice);
        return EOK;
error:
        if (trans != NULL)
                sif_trans_abort(trans);
        if (choice != NULL)
                nchoice_destroy(choice);
        return rc;
}

/** Close contacts repo.
 *
 * @param contacts Contacts
 */
static void contacts_close(contacts_t *contacts)
{
        contacts_entry_t *entry;

        sif_close(contacts->repo);

        entry = contacts_first(contacts);
        while (entry != NULL) {
                list_remove(&entry->lentries);
                contacts_entry_delete(entry);
                entry = contacts_first(contacts);
        }

        free(contacts);
}

/** Get first contacts entry.
 *
 * @param contacts Contacts
 * @return First entry or @c NULL if there is none
 */
static contacts_entry_t *contacts_first(contacts_t *contacts)
{
        link_t *link;

        link = list_first(&contacts->entries);
        if (link == NULL)
                return NULL;

        return list_get_instance(link, contacts_entry_t, lentries);
}

/** Get next contacts entry.
 *
 * @param cur Current entry
 * @return Next entry or @c NULL if there is none
 */
static contacts_entry_t *contacts_next(contacts_entry_t *cur)
{
        link_t *link;

        link = list_next(&cur->lentries, &cur->contacts->entries);
        if (link == NULL)
                return NULL;

        return list_get_instance(link, contacts_entry_t, lentries);
}

/** Delete entry structure from memory.
 *
 * @param entry Contacts entry
 */
static void contacts_entry_delete(contacts_entry_t *entry)
{
        if (entry == NULL)
                return;

        if (entry->name != NULL)
                free(entry->name);

        free(entry);
}

/** List all contacts.
 *
 * @param contacts Contacts
 */
static void contacts_list_all(contacts_t *contacts)
{
        contacts_entry_t *entry;

        entry = contacts_first(contacts);
        while (entry != NULL) {
                printf(" * %s\n", entry->name);
                entry = contacts_next(entry);
        }
}

/** Run contacts main menu.
 *
 * @param contacts Contacts
 * @return EOK on success or error code
 */
static errno_t contacts_main(contacts_t *contacts)
{
        nchoice_t *choice = NULL;
        errno_t rc;
        bool quit = false;
        void *sel;

        rc = nchoice_create(&choice);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_set_prompt(choice, "Select action");
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_add(choice, "Create contact",
            (void *)ac_create_contact, 0);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_add(choice, "Delete contact",
            (void *)ac_delete_contact, 0);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        rc = nchoice_add(choice, "Exit",
            (void *)ac_exit, 0);
        if (rc != EOK) {
                assert(rc == ENOMEM);
                printf("Out of memory.\n");
                goto error;
        }

        while (!quit) {
                contacts_list_all(contacts);

                rc = nchoice_get(choice, &sel);
                if (rc != EOK) {
                        printf("Error getting user selection.\n");
                        return rc;
                }

                switch ((contact_action_t)sel) {
                case ac_create_contact:
                        (void) contacts_create_contact(contacts);
                        break;
                case ac_delete_contact:
                        (void) contacts_delete_contact(contacts);
                        break;
                case ac_exit:
                        quit = true;
                        break;
                }
        }

        nchoice_destroy(choice);
        return EOK;
error:
        if (choice != NULL)
                nchoice_destroy(choice);
        return rc;
}

int main(void)
{
        errno_t rc;
        contacts_t *contacts = NULL;

        rc = contacts_open("contacts.sif", &contacts);
        if (rc != EOK)
                return 1;

        rc = contacts_main(contacts);
        contacts_close(contacts);

        if (rc != EOK)
                return 1;

        return 0;
}