root/db/msg.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010, 2011 Antti-Juhani Kaijanaho

    Alue 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.

    Alue 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 Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_MSG_MSG_HH
#define GUARD_MSG_MSG_HH

#include "../db/article_number_type.hh"
#include "../util.hh"

#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include <list>
#include <map>

namespace msg { class entity; }

namespace db
{

        class group; class user; class thread_node;

        class msg
        {
        public:
                struct moderation
                {
                        const enum kind_type { CLEAR, KILL, SPAM } kind;
                        const boost::shared_ptr<const user> u;
                        const std::string reason;

                        moderation(kind_type k,
                                   boost::shared_ptr<const user> u,
                                   std::string reason)
                                : kind(k)
                                , u(u)
                                , reason(reason)
                                {}

                        bool is_censure() const { return kind != CLEAR; }
                };

                typedef boost::shared_ptr<msg> ptr;
                typedef boost::shared_ptr<const msg> const_ptr;

                typedef std::map<boost::shared_ptr<group>, 
                                 article_number_type>
                xref_type;

                explicit msg(std::string msgid,
                             boost::shared_ptr< ::msg::entity >,
                             boost::shared_ptr<user>);
                explicit msg(boost::shared_ptr< ::msg::entity >,
                             boost::shared_ptr<user>);

                void moderate(moderation m) { mods.push_back(m); }

                bool is_censured() const 
                        { return !mods.empty() && mods.back().is_censure(); }

                boost::shared_ptr<const user> censor() const {
                        boost::shared_ptr<const user> rv;
                        if (!mods.empty()) rv = mods.back().u;
                        return rv;
                }

                const std::list<moderation> &get_moderations() const
                        { return mods; }

                boost::shared_ptr<const ::msg::entity> get_entity() const
                        { return actual; }

                std::list<std::string> get_newsgroups() const;

                const xref_type &get_xref() const
                        { return the_xref; }

                std::string get_xref_field(bool full) const;

                std::string msgid() const { return the_msgid; }

                void xref(boost::shared_ptr<group> gr, 
                          article_number_type n)
                        { the_xref[gr] = n; }

                boost::shared_ptr<const user> get_poster() const {
                        return poster;
                }

                bool reading_authz(boost::shared_ptr<const user> u) const;
                bool posting_authz(boost::shared_ptr<const user> u) const;
        private:
                std::string the_msgid;
                xref_type the_xref;
                boost::shared_ptr< ::msg::entity > actual;
                boost::shared_ptr<user> poster;
                std::list<moderation> mods;
        };
        
};

#endif /* GUARD_MSG_MSG_HH */