Changeset 11cf105fe323361072281747558cb61752f33fa8

Timestamp:

09/19/10 22:57:42 (20 months ago)

Author:

Antti-Juhani Kaijanaho <antti-juhani@…>

Children:

383796fa5544ac0c42f5599e6de3d3aa06cde8bb

Parents:

99057e4d73dbb905f06f5ccc4ea49708b8aaa0a8

git-committer:

Antti-Juhani Kaijanaho <antti-juhani@…> (09/19/10 22:57:42)

Message:

#60: Add a footer to email distributed posts

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>

Files:

• db/group.cc (modified) (3 diffs)
• msg/entity.cc (modified) (3 diffs)
• msg/entity.hh (modified) (2 diffs)
• msg/entity_header.cc (modified) (1 diff)
• msg/entity_header.hh (modified) (1 diff)
• msg/multipart.hh (modified) (2 diffs)
• msg/text_plain.hh (modified) (1 diff)

db/group.cc

@@ -25 +25 @@
 #include "../config.hh"
 #include "../msg/entity.hh"
+#include "../msg/multipart.hh"
+#include "../msg/text_plain.hh"
 #include "../smtp_client/smtp_client.hh"
+#include "../tlate/data_model.hh"
+#include "../tlate/group_value.hh"
+#include "../tlate/tlate.hh"
 
 #include "../assert.hh"
@@ -69 +74 @@
                 if (recv.empty()) return rv;
 
-                ::msg::entity::ptr nm = m->get_entity()->clone();
+                ::msg::multipart::ptr nm =
+                          m->get_entity()->clone_as_multipart();
                 {
                         std::string subject = nm->get_field("subject", false);
@@ -86 +92 @@
                                   config["canonical-name"].as<std::string>() +
                                   ">");
+
+                tlate::data_model::ptr mam(new tlate::data_model);
+                mam->insert("group", new tlate::group_value(shared_from_this(),
+                                                            user::ptr()));
+
+                boost::shared_ptr<tlate::tlate> tl =
+                        tlate::tlate::parse("sub_footer.txt");
+                std::ostringstream mos;
+                mos << tl->eval(mam);
+                ::msg::text_plain::ptr sub(new ::msg::text_plain
+                                           (mos.str(),
+                                            ::msg::content_type(DEFAULT_CT)));
+                nm->append_part(sub);
                                   
                 cb.smtpc().send_mail(recv, nm->get_entity());

msg/entity.cc

@@ -20 +20 @@
 #include "content_type.hh"
 #include "entity.hh"
+#include "lexutils.hh"
 #include "message_entity.hh"
 #include "multipart.hh"
@@ -30 +31 @@
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/format.hpp>
+#include <boost/nondet_random.hpp>
 
 #include "../assert.hh"
@@ -87 +89 @@
         }
 
+        multipart::ptr entity::clone_as_multipart() const
+        {
+                static const char *const content_ = "content-";
+                boost::random_device urand;
+
+                entity_header::ptr envh(new entity_header(*hdr));
+                entity_header::ptr subh(new entity_header(DEFAULT_CT));
+
+                for (field_iterator it = hdr->fields_begin();
+                     it != hdr->fields_end(); it++)
+                {
+                        std::string fld = *it;
+                        size_t colon = fld.find(':');
+                        if (colon == std::string::npos) colon = 0;
+                        std::string name = fld.substr(0, colon);
+                        size_t start = colon + 1 < fld.length()
+                                ? (fld[colon+1] == ' ' ? colon + 1 : colon)
+                                : colon;
+                        std::string content = fld.substr(start);
+                        util::strip_crlf(content);
+                        boost::to_lower(name);
+                        if (name.substr(0, sizeof content_) != content_)
+                                continue;
+                        subh->replace_field(name, content);
+                        envh->delete_field(name);
+                }
+
+                std::string body = get_body();
+
+                std::string boundary;
+        redo:
+                {
+                        std::ostringstream ss;
+                        ss << urand() << urand() << urand() << urand();
+                        if (body.find(ss.str()) != std::string::npos)
+                                goto redo;
+                        boundary = ss.str();
+                }
+
+                bool bit8 = false;
+                for (size_t i = 0; i < body.length(); i++)
+                {
+                        if ((unsigned char)body[i] > 0x7f)
+                        {
+                                bit8 = true;
+                                break;
+                        }
+                }
+
+                envh->replace_field("MIME-Version", "1.0");
+                envh->add_field("Content-Type",
+                                std::string("multipart/mixed; boundary=") +
+                                make_phrase(boundary));
+                envh->add_field("Content-Transfer-Encoding",
+                                bit8 ? "8bit" : "7bit");
+
+                std::ostringstream nbss;
+                nbss << "--" << boundary << "\r\n"
+                     << subh->get_header() << "\r\n"
+                     << body
+                     << "\r\n--" << boundary << "--\r\n";
+                
+                multipart::ptr rv(new multipart(envh, nbss.str()));
+                return rv;
+        }
+
 }

msg/entity.hh

@@ -30 +30 @@
 {
         class content_type;
-        class mime_entity;
+        class multipart;
 
         class entity
@@ -46 +46 @@
 
                 virtual ptr clone() const = 0;
+
+                virtual boost::shared_ptr<multipart> clone_as_multipart() const;
 
                 virtual boost::shared_ptr<tlate::value>

msg/entity_header.cc

@@ -231 +231 @@
                                     : default_ct);
         }
+
+        void entity_header::delete_field(std::string the_name)
+        {
+                boost::to_lower(the_name);
+                for (std::list<std::string>::iterator it =
+                             field_content.begin();
+                     it != field_content.end(); /**/)
+                {
+                        std::string fld = *it;
+                        size_t colon = fld.find(':');
+                        if (colon == std::string::npos) colon = 0;
+                        std::string name = fld.substr(0, colon);
+                        boost::to_lower(name);
+                        if (name != the_name) { it++; continue; }
+                        it = field_content.erase(it);
+                }
+                fields.erase(the_name);
+                if (the_name == "date")
+                        the_date = boost::posix_time::not_a_date_time;
+        }
 }

msg/entity_header.hh

@@ -92 +92 @@
                 std::string get_field(std::string s, bool full) const;
 
+                void add_field(std::string name, std::string body) {
+                        field_content.push_front(name + ": " + body + "\r\n");
+                        boost::to_lower(name);
+                        fields[name] = field_content.begin();
+                        if (name == "date")
+                                the_date = boost::posix_time::not_a_date_time;
+                }
                 void replace_field(std::string name, std::string body);
+                void delete_field(std::string name);
 
                 content_type get_content_type() const;

msg/multipart.hh

@@ -30 +30 @@
                 std::vector<entity::ptr> parts;
                 std::string preamble, trailer;
+
+                multipart(const multipart &o)
+                        : entity(o)
+                        , preamble(o.preamble)
+                        , trailer(o.trailer) {
+                        for (size_t i = 0; i < o.parts.size(); i++) {
+                                parts.push_back(o.parts[i]->clone());
+                        }
+                }
+                        
         public:
+                typedef boost::shared_ptr<multipart> ptr;
+                typedef boost::shared_ptr<const multipart> const_ptr;
+
                 multipart(entity_header::ptr hdr, std::string body);
 
                 entity::ptr clone() const {
-                        entity::ptr rv(new multipart(*this));
+                        multipart::ptr rv(new multipart(*this));
                         return rv;
                 }
@@ -41 +54 @@
 
                 boost::shared_ptr<tlate::value> get_tlate_value(bool) const;
+
+                void append_part(entity::const_ptr p) {
+                        entity::ptr np = p->clone(); // FIXME default_ct
+                        parts.push_back(np);
+                }
         };
 }

msg/text_plain.hh

@@ -32 +32 @@
         {
         public:
+                typedef boost::shared_ptr<text_plain> ptr;
+                typedef boost::shared_ptr<const text_plain> const_ptr;
+
                 class para
                 {