/home/frank/projects/kitlist/src/service.cpp

Go to the documentation of this file.

/*

    This file is part of Kitlist, a program to maintain a simple list
    of items and assign items to one or more categories.

    Copyright (C) 2008,2009 Frank Dean

    Kitlist is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Kitlist is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Kitlist.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "service.hpp"
#include <algorithm>
#include <cassert>
#include <iostream>

using namespace std;

class FilterItem : public ItemFunctor {
    KitModel& m_model;
public:
    FilterItem(KitModel& model) : ItemFunctor(), m_model(model) {}
    bool operator()(Item& item) {
        return m_model.filter(item.get_checked());
    }

};


Service::Service(KitListDao& dao) : m_dao(dao), m_model(0) {
    m_model = load_model();
}


Service::~Service() {
    if (m_model)
        delete m_model;
}


KitModel* Service::load_model() {
    return m_dao.get_model();
}


void Service::open_as_xml(const Glib::ustring& filename) {
#ifdef XML_DAO
    delete m_model;
    m_model = ((XmlDao&) m_dao).get_model(filename);
#endif
}


void Service::create_default_model() {
    delete m_model;
#ifdef XML_DAO
    ((XmlDao&) m_dao).set_filename("");
    m_model = m_dao.get_model();
#else
    m_model = new KitModel();
    m_model->reset();
#endif
}


void Service::save() {
    assert(m_model);
    m_dao.save_model(m_model);
}


void Service::save_as_xml(const Glib::ustring& filename) {
#ifdef XML_DAO
    ((XmlDao&) m_dao).save_model(m_model, filename);
#else
    // Only want a new DAO when the current DAO isn't XmlDao
    XmlDao xmldao;
    xmldao.save_model(m_model, filename);
#endif
}


ModelItem* Service::find_item(long id) {
    return m_model->find_item(id);
}


ModelCategory* Service::find_category(long cat_id) {
    return m_model->find_category(cat_id);
}


void Service::copy_items(const ModelItemContainer& items, long cat_id) {
    assert(m_model);
    m_model->set_dirty(true);
    m_model->copy_items(items, cat_id);
}


Item* Service::create_item(long cat_id) {
    assert(m_model);
    m_model->set_dirty(true);
    ModelItem* item = new ModelItem;
    item->set_id(get_next_item_id());
    item->set_new_flag(true);
    item->set_dirty(true);
    if (cat_id < 0)
        m_model->add_item(item);
    else
        m_model->add_item(item, cat_id);
    return item;
}


bool Service::delete_item(long id) {
    bool retval = false;
    assert(m_model);
    ModelItem* item = m_model->find_item(id);
    if (item) {
        m_model->set_dirty(true);
        item->set_dirty(true);
        item->set_deleted(true);
        retval = true;
    }
    return retval;
}


bool Service::delete_category(long cat_id) {
    bool retval = false;
    assert(m_model);
    ModelCategory* category = m_model->find_category(cat_id);
    if (category) {
        m_model->set_dirty(true);
        category->set_dirty(true);
        category->set_deleted(true);
        retval = true;
    }
    return retval;
}


Category* Service::create_category() {
    assert(m_model);
    m_model->set_dirty(true);
    ModelCategory* category = new ModelCategory;
    category->set_id(get_next_category_id());
    category->set_new_flag(true);
    category->set_dirty(true);
    m_model->add_category(category);
    return category;
}


void Service::select_items(ModelItemContainer* items, bool checked) {
    m_model->set_dirty();
    for (ModelItemIter i = items->begin(); i != items->end(); ++i) {
        (*i)->set_dirty();
        (*i)->set_checked(checked);
    }
}


void Service::toggle_selected_items(ModelItemContainer* items) {
    m_model->set_dirty();
    for (ModelItemIter i = items->begin(); i != items->end(); ++i) {
        (*i)->set_dirty();
        (*i)->set_checked(!(*i)->get_checked());
    }
}


void Service::set_model_dirty(bool flag) {
    assert(m_model);
    if (m_model)
        m_model->set_dirty(flag);
}


bool Service::update_item(long id, const string description, bool checked) {
    bool retval = false;
    assert(m_model);
    ModelItem* item = m_model->find_item(id);
    if (item) {
        item->set_description(description);
        item->set_checked(checked);
        item->set_dirty(true);
        retval = true;
    }
    return retval;
}


ItemContainer* Service::get_items(long cat_id) {
    assert(m_model);
    ItemContainer* retval = 0;
    if (cat_id == -1) {
        retval = m_model->get_all_items();
    } else {
        ModelCategory* cat = m_model->find_category(cat_id);
        if (cat) {
            retval = cat->get_items();
        }
    }
    return retval;
}


ItemContainer* Service::get_filtered_items(long cat_id) {
    assert(m_model);
    ItemContainer* retval = 0;
    FilterItem fi = FilterItem(*m_model);
    if (cat_id == -1) {
        retval = m_model->get_all_items(fi);
    } else {
        ModelCategory* cat = m_model->find_category(cat_id);
        if (cat) {
            retval = cat->get_items(fi);
        }
    }
    if (retval)
        sort(retval->begin(), retval->end(), ItemCompareName());
    return retval;
}


CategoryContainer* Service::get_categories() {
    assert(m_model);
    CategoryContainer* retval = m_model->get_categories();
    return retval;
}


long Service::get_next_item_id() {
    return m_dao.get_next_item_id();
}


long Service::get_next_category_id() {
    return m_dao.get_next_category_id();
}

---