intra/xtrasource/pg_paragraph.hpp

Go to the documentation of this file.

/* 
  Page Paragraph Class and list - pg_paragraph.hpp
  ----------------------------------------  
  This class represents 
  an abstraction of a web pages paragraphs.  
*/

// Sentry
#ifndef Web_Page_Paragraph_Hpp
#define Web_Page_Paragraph_Hpp

// includes
#include "cgiTemplates.h"
#include "read_base.hpp"
#include "ocTypes.h"
#include <vector>

// #define DO_OPEN_LOGGING
#include "openLogger.h"
#include "openLogin.h"
using namespace std;
typedef long long identifier;
typedef long long llong;
/*

THE OLD PARAGRAPH

class page_paragraph 
{
protected:
  long long m_id;
  long long m_site_id;
  long long m_page_id;
  long m_place_order;
  string m_template_tag; 
  string m_replace_tag;  
  string m_name;
  string m_content;
  
public:
  page_paragraph()
  :m_id(0),m_site_id(0),m_page_id(0),m_place_order(0)
  {
    ;
  }
  
  virtual ~page_paragraph()
  {
    ;
  }
  
  page_paragraph & operator = ( const page_paragraph & in )
  {
    id(in.id()); 
    site_id(in.site_id());
    page_id(in.page_id());
    place_order(in.place_order());
    template_tag(in.template_tag());
    replace_tag(in.replace_tag());
    name (in.name());
    content(in.content());  
    return *this;
  }
  
  void propset( openRS & rs )
  {
    id(atoll(rs.getField(0).format().c_str()));
    site_id(atoll(rs.getField(1).format().c_str()));
    page_id(atoll(rs.getField(2).format().c_str()));
    place_order(atol(rs.getField(3).format().c_str()));
    template_tag(rs.getField(4).format());
    replace_tag(rs.getField(5).format()); 
    name(rs.getField(6).format());
    content(rs.getField(7).format());
  }
  
  // new emit base on template control
  void emit( paragraphMap & paras, ostream & toBrowser, string replace_tag, string section = "" )
  {
    paragraphMap::iterator pos = paras.find(template_tag());
    if( pos != paras.end() )
    {
      ocString uniqueId = "paragraph_";
      uniqueId.append(place_order());
      ocString output = pos->second;
      toBrowser << 
        output.replace( "$id",uniqueId.c_str() ) 
              .replace( replace_tag.c_str(),
                        content().c_str() ); 
    }
  }
  
  // Property access
  // get
  long long id(void) const {return m_id;}
  long long site_id(void) const {return m_site_id;}
  long long page_id(void) const {return m_page_id;}
  long place_order(void) const {return m_place_order;}
  string template_tag(void) const {return m_template_tag;} 
  string replace_tag(void) const {return m_replace_tag;}  
  string name(void) const {return m_name;}
  string content(void) const {return m_content;}
  // set
  void id(long long in) { m_id=in; }
  void site_id( long long in) { m_site_id=in; }
  void page_id( long long in) { m_page_id=in; }
  void place_order( long in) { m_place_order=in; }
  void template_tag( string in) { m_template_tag=in; } 
  void replace_tag( string in) { m_replace_tag=in; }  
  void name (string in) { m_name=in; }
  void content( string in) { m_content=in; }  
};

END OF THE OLD */

/*
  The new paragraph
  Adding features for approval, author tracking, date entered and date valid
  'section' tells the page where to place the text.
  This allows re-use of paragraph template tags.


*/
class page_paragraph
{
protected:
  // data members
  identifier m_id;
  llong m_site_id;
  llong m_page_id;
  int m_place_order;
  string m_template_tag;
  string m_replace_tag;
  string m_name;
  string m_content;
  
  // all new stuff
  llong m_author;
  time_date m_time_authored;
  time_date m_time_start;
  time_date m_time_end;
  bool m_approved;
  string m_section;
  
public:
  string editIcon;
  
  // constructor
  page_paragraph():
    m_id(0LL),
    m_site_id(0LL),
    m_page_id(0LL),
    m_place_order(0),
    m_template_tag(""),
    m_replace_tag("$content$"),
    m_name(""),
    m_content(""),
    m_author(0LL),
    m_time_authored( ),
    m_time_start( ),
    m_time_end( ),
    m_approved(false),
    m_section("")
  {
    ;
  }
  // destructor
  virtual ~page_paragraph(){;}
  // copy constructor 
  page_paragraph( const page_paragraph & in):
    m_id(in.m_id),
    m_site_id(in.m_site_id),
    m_page_id(in.m_page_id),
    m_place_order(in.m_place_order),
    m_template_tag(in.m_template_tag),
    m_replace_tag(in.m_replace_tag),
    m_name(in.m_name),
    m_content(in.m_content),
    m_author(in.m_author),
    m_time_authored(in.m_time_authored),
    m_time_start(in.m_time_start),
    m_time_end(in.m_time_end),
    m_approved(in.m_approved),
    m_section(in.m_section)
  {
    ;
  }
  // assignment operator
  page_paragraph & operator = ( const page_paragraph & in )
  {
    m_id = in.m_id;
    m_site_id = in.m_site_id;
    m_page_id = in.m_page_id;
    m_place_order = in.m_place_order;
    m_template_tag = in.m_template_tag;
    m_replace_tag = in.m_replace_tag;
    m_name = in.m_name;
    m_content = in.m_content;
    m_author = in.m_author;
    m_time_authored = in.m_time_authored;
    m_time_start = in.m_time_start;
    m_time_end = in.m_time_end;
    m_approved = in.m_approved;
    m_section = in.m_section;
    return *this;
  }

  void propset( openRS & rs )
  {
    id(atoll(rs.getField(0).format().c_str()));
    site_id(atoll(rs.getField(1).format().c_str()));
    page_id(atoll(rs.getField(2).format().c_str()));
    place_order(atol(rs.getField(3).format().c_str()));
    template_tag(rs.getField(4).format());
    replace_tag(rs.getField(5).format()); 
    name(rs.getField(6).format());
    content(rs.getField(7).format());
    author(atoll(rs.getField(8).format().c_str()));
    time_authored(dynamic_cast<dateTimeField&>(rs.getField(9)).get());
    time_start(dynamic_cast<dateTimeField&>(rs.getField(10)).get());
    time_end(dynamic_cast<dateTimeField&>(rs.getField(11)).get());
    approved(rs.getField(12).isNull()||dynamic_cast<longField&>(rs.getField(12)).get()!=0);
    section(rs.getField(13).format());
  }

  string userName( void )
  {
    string name = "";
    if( author() > 0 )
    {
      openLogin tmpLogin;
      ocString ID;
      ID.append(author());
      if( tmpLogin.getUser(ID) )
      {
        name =  tmpLogin.FullName();
      }
    }
    return name;
  }
  // new emit base on template control
  void emit( paragraphMap & paras, ostream & toBrowser, string replace_tag  )
  {
    // Find our template in the Template paragraphs 
    paragraphMap::iterator pos;
    pos = paras.find(template_tag());
    if( pos != paras.end() && approved() )
    {
      ocString uniqueId = "paragraph_";
      uniqueId.append(place_order());
      ocString output = pos->second;
      toBrowser << 
        output.replace( "$id",uniqueId.c_str() ) 
              .replace( replace_tag.c_str(), content().c_str() )
              // The rest of the replacements go by the name of the go by the members
              .replace( "$time_authored$", time_authored().format("%b %d %Y %I:%M %p") )
              .replace( "$author$",  userName() )
              ;
    }
    
  }
  
  // member access operators  
  // get
  identifier  id( void ) { return m_id; }
  // set
  void id( const identifier  in ) { m_id = in; }
  
    // get
  llong  site_id( void ) { return m_site_id; }
  // set
  void site_id( const llong  in ) { m_site_id = in; }
  
    // get
  llong  page_id( void ) { return m_page_id; }
  // set
  void page_id( const llong  in ) { m_page_id = in; }
  
    // get
  int  place_order( void ) { return m_place_order; }
  // set
  void place_order( const int  in ) { m_place_order = in; }
  
    // get
  string & template_tag( void ) { return m_template_tag; }
  // set
  void template_tag( const string & in ) { m_template_tag = in; }
  
    // get
  string & replace_tag( void ) { return m_replace_tag; }
  // set
  void replace_tag( const string & in ) { m_replace_tag = in; }
  
    // get
  string & name( void ) { return m_name; }
  // set
  void name( const string & in ) { m_name = in; }
  
    // get
  string & content( void ) { return m_content; }
  // set
  void content( const string & in ) { m_content = in; }
  
    // get
  llong  author( void ) { return m_author; }
  // set
  void author( const llong  in ) { m_author = in; }
  
    // get
  time_date &  time_authored( void ) { return m_time_authored; }
  // set
  void time_authored( const time_date &  in ) { m_time_authored = in; }
  
    // get
  time_date &  time_start( void ) { return m_time_start; }
  // set
  void time_start( const time_date &  in ) { m_time_start = in; }
  
    // get
  time_date &  time_end( void ) { return m_time_end; }
  // set
  void time_end( const time_date &  in ) { m_time_end = in; }
  
    // get
  bool  approved( void ) { return m_approved; }
  // set
  void approved( const bool  in ) { m_approved = in; }
  
    // get
  string & section( void ) { return m_section; }
  // set
  void section( const string & in ) { m_section = in; }
  
  
};



typedef vector<page_paragraph> paragraph_vector;
  
class page_paragraphs : protected ref_base, public paragraph_vector
{   
public:
  string editIcon;
  
  page_paragraphs(openDB & dbIn):ref_base(dbIn),paragraph_vector()
  {
    ;
  }
  ~page_paragraphs()
  {
    ;
  }
  string getSQL( long long pgid )
  {
    // TODO: Add logic for archive, approved,author filtering.
    ocString sql = "select id,site_id,page_id,place_order,"
                   "template_tag,replace_tag,name,content,author,time_authored,"
                   "time_start,time_end,approved,section  "
                   "from metasite.paragraphs where page_id = ";
    sql.append( pgid );
    sql += " order by section, place_order";
    writelog( sql );
    return sql;
  }

  bool load( long long pgid )
  {
    bool breturn=false;
    bool bData;
    for( bData=rs.open(getSQL(pgid));bData;bData=rs.next() )
    {      
      page_paragraph pp;      
      pp.propset(rs);      
      push_back(pp);
    }    
    rs.close();
    return breturn;
  }

  void emit( paragraphMap & paras, ostream & toBrowser, 
             ocString templateTags, string replace_tag, string section = "" )
  {
    paragraph_vector::iterator pos;
    for( pos=begin(); pos!=end(); ++pos )
    {
      if( section.length() )
      {
        if( section == pos->section() )
        {
          pos->emit(paras,toBrowser,replace_tag);
        }
      }
      else
      { // Have to look through all of the potential (comma seperated) templates in a section; not good, deprecated!
        ocString tags = "," + templateTags + ",";
        string testTag = "," + pos->template_tag() + ",";
        if( tags.regExMatch( testTag.c_str() ) )
        {
          pos->emit(paras,toBrowser,replace_tag);        
        }
      }
    }
  }
};

#endif

---