httppost.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _NB_HTTPPOST_H
#define _NB_HTTPPOST_H
 
#include <http.h>
#include <json_lexer.h>
#include <nettypes.h>
#include <config_obj.h>
 
 
typedef int(http_posthandler)(int sock, HTTP_Request &httpReqInfo);
 
// To handle posts for a specific URL, build a posthandler object for that URL.
// This is the base class for all post handlers. A NULL name will be a catch all for all posts.
class HtmlPostHandler : public HtmlPageHandler
{
   public:
    HtmlPostHandler(const char *url, int accessGroup = 0) : HtmlPageHandler(url, tPost, accessGroup, false) {}
    // This class will do a callback with data for each post to the specified url
    virtual int ProcessRaw(int sock, HTTP_Request &pd) = 0;
};
 
// This implements the above as a function pointer call back
 
class CallBackFunctionPostHandler : public HtmlPostHandler
{
   protected:
    http_posthandler *m_pf;
 
   public:
    inline virtual int ProcessRaw(int sock, HTTP_Request &pdt) { return m_pf(sock, pdt); };
    inline CallBackFunctionPostHandler(const char *pUrl, http_posthandler *pf, int accessGroup = 0) : HtmlPostHandler(pUrl, accessGroup)
    {
        m_pf = pf;
    };
};
 
struct FilePostStruct
{
    char FileText[5];        //< Has the text FILE\0
    int fd;                  //< File descriptor of the file, only valid during the duration of the callback
    const char *pFileName;   //< Name of file
    const char *pType;       //< Pointer to MIME type of file
};
 
enum PostEvents
{
    eStartingPost,   //< Occurs one time before variables are processed
    eVariable,       //< Occurs for each variable
    eFile,           //< Occurs if a file is being processed
    eEndOfPost       //< Occurs one time at the end of POST processing
};
 
// This class will provide a virtual function call with a list of all variable values.
class HtmlPostVariableListHandler : public HtmlPostHandler
{
    HTTP_Request *m_pCurRequest;
 
   public:
    HTTP_Request *GetCurRequest() { return m_pCurRequest; };
    virtual int ProcessRaw(int sock, HTTP_Request &pd);
 
 
    HtmlPostVariableListHandler(const char *pUrl, int accessGroup = 0) : HtmlPostHandler(pUrl, accessGroup){};
 
    // Called back with each name/value pair.
    // Called back with name="Start" for start.
    // Called back with both name and value null for last post.
 
    virtual int ProcessPostVariables(int sock, PostEvents event, const char *pNames, const char *pValues) = 0;
};
 
// This class implements the above with a function call back.
typedef void(postvarhandler)(int sock, PostEvents event, const char *pNames, const char *pValue);
typedef int(postvarhandler_int)(int sock, PostEvents event, const char *pNames, const char *pValue);
 
class HtmlPostVariableListCallback : public HtmlPostVariableListHandler
{
   protected:
    enum pfType_t {
        pf_void = 0,
        pf_int = 1
    };
    union
    {
        postvarhandler *m_pf;
        postvarhandler_int *m_pfi;
    };
    pfType_t pfType;
 
   public:
    inline int ProcessPostVariables(int sock, PostEvents event, const char *pName, const char *pValue)
    {
        switch (pfType)
        {
            case pf_void:
            default:
                m_pf(sock, event, pName, pValue);
                return 0;
            case pf_int:
                return m_pfi(sock, event, pName, pValue);
        }
    };
 
    inline HtmlPostVariableListCallback(const char *pUrl, postvarhandler *pCallback, int accessGroup = 0)
        : HtmlPostVariableListHandler(pUrl, accessGroup), m_pf(pCallback), pfType(pf_void){};
 
    inline HtmlPostVariableListCallback(const char *pUrl, postvarhandler_int *pCallback, int accessGroup = 0)
        : HtmlPostVariableListHandler(pUrl, accessGroup), m_pfi(pCallback), pfType(pf_int){};
};
 
//----------------------------------------------------------------------------------------------------
// JSON post handlers
//----------------------------------------------------------------------------------------------------
 
// Handle JSON posts, virtual function call back...
class JsonPostHandler : public HtmlPostHandler
{
   protected:
    virtual void HandleJson(int sock, ParsedJsonDataSet &JsonSet) = 0;
 
   public:
    JsonPostHandler(const char *pUrl, int accessGroup = 0) : HtmlPostHandler(pUrl, accessGroup){};
    virtual int ProcessRaw(int sock, HTTP_Request &pd);
};
 
// Handle JSON posts function pointer call back...
typedef void(jsonpostvarhandler)(int sock, ParsedJsonDataSet &JsonSet);
 
class JsonPostCallbackHandler : public JsonPostHandler
{
    jsonpostvarhandler *m_pf;
 
   public:
    inline void HandleJson(int sock, ParsedJsonDataSet &JsonSet)
    {
        m_pf(sock, JsonSet);
        ;
    };
    inline JsonPostCallbackHandler(const char *pUrl, jsonpostvarhandler *pCallback, int accessGroup = 0)
        : JsonPostHandler(pUrl, accessGroup), m_pf(pCallback){};
};
 
// Handle form posts that might contain config items in the form from CONFIGENTRY, FULL or CONFIGTABLE in the html.
// Retuns true if it handled the event and no farther processing is required.
bool HandleConfigFormEvent(PostEvents event, const char *pName, const char *pValue);
 
// This class will process post that ONLY have config variables in them.
class HtmlPostConfigVariableHandler : public HtmlPostVariableListHandler
{
    const char *m_pRedirect_url;
 
   public:
    HtmlPostConfigVariableHandler(const char *pUrl, const char *pRedirect_Url = 0, int accessGroup = 0)
        : HtmlPostVariableListHandler(pUrl, accessGroup)
    {
        m_pRedirect_url = pRedirect_Url;
    };
 
    // Called back with each name/value pair.
    // Called back with name="Start" for start.
    // Called back with both name and value null for last post.
    virtual int ProcessPostVariables(int sock, PostEvents event, const char *pNames, const char *pValues);
};
 
 
class CustomConfigFormHandler
{
static CustomConfigFormHandler * pHead;
CustomConfigFormHandler * pNext;
const char * pTypeName;
protected:
CustomConfigFormHandler(const char * pTypeName);
public:
virtual  void RenderValue(int fd, config_leaf *pl, int len, const char *extra)=0;
virtual  void RenderInput(int fd, config_leaf *pl, int len, const char *extra)=0;
virtual  bool ProcessValue(const char * pValue,config_leaf * pl)=0;
static  CustomConfigFormHandler * Find(const NBString &type_name);
};
 
 
 
#endif