Page.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>
#endif
 
#include <dcl/Charset.h>
#include <dcl/URI.h>
#include <dcl/ArrayT.h>
 
#include "HtmlPage.h"
#include "LinkUtility.h"
#include "Page.h"
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("fastpage/Page.cpp");
#endif
 
#define CM_INSERT   1
#define CM_UPDATE   2
#define CM_DELETE   3
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO_EX(ClassListView, HtmlView)
 
ClassListView::ClassListView(HtmlPage* pPage)
    : HtmlView(pPage)
{
}
 
void ClassListView::onPrint(Session& session)
    __DCL_THROWS1(Exception*)
{
    session.__ctx.addHeader(HttpHeader(L"Cache-Control", L"no-cache"));
 
    assign(L"TITLE", __pPage->__strTitle);
 
    TextTemplate& CLASS = (*this)[L"CLASS"];
    SQLQuery& q = session.__query;
 
    for(int i = 0; i < HtmlView::__nClassCount; i++)    {
        CLASS.assign(L"DS_TYPE", String::valueOf(HtmlView::__aClasses[i].nDsType));
        CLASS.assign(L"CLASS_ID", String::valueOf(HtmlView::__aClasses[i].nClassID));
        CLASS.assign(L"CLASS_NAME", HtmlView::__aClasses[i].pszClassName);
        CLASS.assign(L"COMMENT", HtmlView::__aClasses[i].pszDesc);
        append(L"CLASS", CLASS);
    }
 
    HtmlView::onPrint(session);
}
 
IMPLEMENT_CLASSINFO_EX(PageCategoryForm, FormView)
 
PageCategoryForm::PageCategoryForm(HtmlPage* pPage)
    : FormView(pPage)
{
}
 
void PageCategoryForm::onPrint(Session& session)
    __DCL_THROWS1(Exception*)
{
    SQLQuery& q = session.__query;
 
    TextTemplate& CATEGORY = (*this)[L"CATEGORY"];
    q.execute(L"SELECT * FROM DCL_PAGE_CATEGORY ORDER BY CATEGORY_ID");
    q.fetch();
    while(!q.eof()) {
        CATEGORY.assign(q.fields(), L"");
        CATEGORY.assign(L"VNO", VNO());
        append(L"CATEGORY", CATEGORY);
        q.fetch();
    }
 
    FormView::onPrint(session);
}
 
void PageCategoryForm::onPost(Session& session)
    __DCL_THROWS1(Exception*)
{
//  HtmlView::dump(session);
 
    ListedStringToStringArrayMap& mapForm = session.__ctx.__formMap;
    StringArray& vCategoryID = mapForm[L"CATEGORY_ID"];
    StringArray& vCategoryName = mapForm[L"CATEGORY_NAME"];
    StringArray& vDescription = mapForm[L"COMMENT"];
    StringArray& vDeleteID = mapForm[L"DELETE_ID"];
 
    if (vCategoryID.size() <= 1) {
        // 스킨 템플릿에서 마지막 CATEGORY_ID는 사용하지 않는다.
        __pPage->refresh(session, session.__ctx.getHttpHeader(L"Referer"));
        return;
    }
 
    // vCategoryID와 vDeleteID가 숫자문자열인지 검사한다.
    // 숫자가 아닌 값이 있는경우에는 예외 발생하여 처리 중단됨
    Array<int> vnCategoryID(vCategoryID.size() - 1);
    for(size_t i = 0; i < vCategoryID.size() - 1; i++)
        vnCategoryID[i] = (unsigned int)Integer::parse(vCategoryID[i], 10);
 
    for(size_t i = 0; i < vDeleteID.size(); i++)
        Integer::parse(vDeleteID[i], 10);
 
    SQLQuery& q = session.__query;
    SQLQuery qInsert(q.connection());
    SQLQuery qUpdate(q.connection());
 
    qInsert.prepare(L""
        "INSERT INTO DCL_PAGE_CATEGORY (CATEGORY_ID, CATEGORY_NAME, COMMENT"
            ", UPDATE_TIME)"
        "\n VALUES(:CATEGORY_ID, :CATEGORY_NAME, :COMMENT, CURRENT_TIMESTAMP)"
    );
    qUpdate.prepare(L""
        "UPDATE DCL_PAGE_CATEGORY"
        "\n SET CATEGORY_NAME = :CATEGORY_NAME"
            ", COMMENT = :COMMENT, UPDATE_TIME = CURRENT_TIMESTAMP"
        "\n WHERE CATEGORY_ID = :CATEGORY_ID"
    );
 
    int iDelete = 0;
    for(size_t i = 0; i < vCategoryID.size() - 1; i++) {
        if (iDelete < (ssize_t) vDeleteID.size() && vCategoryID[i] == vDeleteID[iDelete]) {
            q.execute(L""
                "SELECT COUNT(*) FROM DCL_PAGE "
                "\n WHERE CATEGORY_ID = " + vDeleteID[iDelete]
            );
            q.fetch();
            if (q.fields()[0].asInteger() == 0) {
                q.execute(L""
                    "DELETE FROM DCL_PAGE_CATEGORY"
                    "\n WHERE CATEGORY_ID = " + vDeleteID[iDelete]
                );
            }
            iDelete++;
        }
        else {
            String& strID = vCategoryID[i];
            String& strName = vCategoryName[i];
            String& strDesc = vDescription[i];
 
            q.execute(L""
                "SELECT COUNT(*) FROM DCL_PAGE_CATEGORY"
                "\n WHERE CATEGORY_ID = " + strID
            );
            q.fetch();
 
            SQLQuery* pQuery = &qInsert;
            if (q.fields()[0].asInteger() != 0)   // then UPDATE
                pQuery = &qUpdate;
 
            pQuery->params().byName(L"CATEGORY_ID").setValue(vnCategoryID[i]);
            pQuery->params().byName(L"CATEGORY_NAME").setValue(strName);
            if (strDesc.isEmpty())
                pQuery->params().byName(L"COMMENT").setNull();
            else
                pQuery->params().byName(L"COMMENT").setValue(strDesc);
 
            pQuery->execute();
        }
    }
 
    __pPage->refresh(session, session.__ctx.getHttpHeader(L"Referer"));
}
 
IMPLEMENT_CLASSINFO_EX(PageListView, HtmlView)
 
PageListView::PageListView(HtmlPage* pPage)
    : HtmlView(pPage)
{
    __nParts = 5;
    __nRows = 20;
    __nShortComment = 10;
}
 
void PageListView::init(SQLFields& fields)
    __DCL_THROWS1(Exception*)
{
    HtmlView::init(fields);
 
    __mapParams.lookup(L"DETAIL", __strDetailPage);
    __mapParams.lookup(L"WRITE", __strWritePage);
 
    String rValue;
 
    if (__mapParams.lookup(L"PARTS", rValue) && !rValue.isEmpty()) {
        __nParts = Integer::parse(rValue, 10, __nParts);
        if (__nParts < 5 || __nParts > 20)
            __nParts = 5;
    }
 
    if (__mapParams.lookup(L"ROWS", rValue) && !rValue.isEmpty()) {
        __nRows = Integer::parse(rValue, 10, __nRows);
        if (__nRows <= 0)
            __nRows = 20;
    }
 
    if (__mapParams.lookup(L"SHORT_COMMENT", rValue) && !rValue.isEmpty()) {
        int n = Integer::parse(rValue, 10, __nShortComment);
        if (n > 0)
            __nShortComment = n;
    }
}
 
void PageListView::onPrint(Session& session)
    __DCL_THROWS1(Exception*)
{
    SQLQuery& q = session.__query;
    ListedStringToStringArrayMap& mapQuery = session.__ctx.__queryMap;
 
    int nCurrentPart = Integer::parse(getDefault(mapQuery, L"part"), 10, 1);
    int nRows = __nRows;
 
    String strDetailPage = __strDetailPage;
    String strWritePage = __strWritePage;
    StringBuilder strThisPage = __pPage->__strPageID;
    String strThisPageEnc;
 
    String strCategoryID = getDefault(mapQuery, L"category");
 
    TextTemplate& CATEGORY = (*this)[L"CATEGORY"];
    q.execute(L""
        "SELECT CATEGORY_ID, CATEGORY_NAME"
        "\n FROM DCL_PAGE_CATEGORY"
        "\n ORDER BY CATEGORY_ID"
    );
    q.fetch();
    while(!q.eof()) {
        CATEGORY.assign(q.fields(), L"");
        append(L"CATEGORY", CATEGORY);
 
        q.fetch();
    }
 
    String strWhere;
    if (!strCategoryID.isEmpty()) {
        strWhere = L"\n WHERE P.CATEGORY_ID = " + strCategoryID;
        strThisPage += L"&category=" + strCategoryID;
    }
 
    assign(L"DETAIL", strDetailPage);
    assign(L"WRITE", strWritePage);
    assign(L"_THIS", URLEncoder::encode(strThisPage));
    assign(L"CATEGORY_ID", strCategoryID);
 
    int nUsingRecord = nRows;
    int nTotalRecord = nUsingRecord;
    int nTotalPart = 1;
 
    // nNo를 표시하기 위해서 조건에 만족하는 전체레코드의 개수가 항상 필요하다.
    q.execute(L""
        "SELECT COUNT(*) "
        "\n FROM DCL_PAGE AS P"
        + strWhere
    );
    q.fetch();
    nTotalRecord = q.fields()[0].asInteger();
    if (nTotalRecord == 0) {
        assign(L"EMPTY", (*this)[L"EMPTY"]);
        HtmlView::onPrint(session);
        return;
    }
 
    __DCL_VERIFY(nTotalRecord > 0);
 
    nTotalPart = nTotalRecord / nUsingRecord;
    if (nTotalRecord % nUsingRecord)
        nTotalPart++;
 
    if (nCurrentPart <= 0 || nCurrentPart > nTotalPart)
        nCurrentPart = nTotalPart;
 
    StringBuilder strThisPageEx = strThisPage;
    if (nCurrentPart > 1)
        strThisPageEx += L"&part=" + String::valueOf(nCurrentPart);
 
    strThisPageEnc = URLEncoder::encode(strThisPageEx);
    assign(L"_THIS", strThisPageEnc);
 
    int nOffset = (nCurrentPart - 1) * nUsingRecord;
 
    int nNo = nTotalRecord - ((nCurrentPart - 1) * nUsingRecord);
    int nRow = 1;
    TextTemplate& PAGE = (*this)[L"PAGE"];
 
    q.execute(L""
        "SELECT P.PAGE_ID, P.TYPE, P.CHARSET, P.LANGUAGE, P.TITLE, P.COMMENT"
            ", P.UPDATE_TIME, R.ROLE_NAME, C.CATEGORY_NAME"
        "\n FROM DCL_PAGE AS P"
        "\n  INNER JOIN DCL_ROLE AS R ON (P.PERM_ID = R.ROLE_ID)"
        "\n  INNER JOIN DCL_PAGE_CATEGORY AS C ON (P.CATEGORY_ID = C.CATEGORY_ID)"
        + strWhere + L""
        "\n ORDER BY P.PAGE_ID DESC"
        "\n LIMIT " + String::valueOf(nUsingRecord) + L""
        "\n  OFFSET " + String::valueOf(nOffset)
    );
 
    q.fetch();
    if (q.eof())
        assign(L"EMPTY", (*this)[L"EMPTY"]);
    else {
        do {
            PAGE.assign(q.fields(), L"&nbsp;");
            SQLField& field = q.fields().byName(L"COMMENT");
            if (field.isNull()) {
                PAGE.assign(L"COMMENT", L"");
                PAGE.assign(L"SHORT_COMMENT", L"&nbsp;");
            }
            else {
                String strDesc = field.asString();
                if ((ssize_t) strDesc.length() > __nShortComment)
                    PAGE.assign(L"SHORT_COMMENT", strDesc.left(__nShortComment) + L"...");
                else
                    PAGE.assign(L"SHORT_COMMENT", strDesc);
            }
 
            PAGE.assign(L"NO", String::valueOf(nNo--));
            PAGE.assign(L"DETAIL", strDetailPage);
            PAGE.assign(L"WRITE", strWritePage);
            PAGE.assign(L"_THIS", strThisPageEnc);
 
            append(L"PAGE", PAGE);
 
            q.fetch();
        } while(!q.eof());
 
        TextTemplate* pPART_LINK = atP(L"PART_LINK");
        if (pPART_LINK && nTotalPart > 1) {
            PartLink pl(pPART_LINK, strThisPage, String());
            pl.assign(this, nTotalPart, nCurrentPart, __nParts);
        }
    }
 
    HtmlView::onPrint(session);
}
 
IMPLEMENT_CLASSINFO_EX(PageWriteForm, FormView)
 
PageWriteForm::PageWriteForm(HtmlPage* pPage)
    : FormView(pPage)
{
}
 
void PageWriteForm::init(SQLFields& fields)
    __DCL_THROWS1(Exception*)
{
    FormView::init(fields);
 
    __mapParams.lookup(L"DETAIL", __strDetailPage);
    __mapParams.lookup(L"LIST", __strListPage);
}
 
void PageWriteForm::onPrint(Session& session)
    __DCL_THROWS1(Exception*)
{
    SQLQuery& q = session.__query;
 
    TextTemplate& CATEGORY = (*this)[L"CATEGORY"];
    q.execute(L""
        "SELECT CATEGORY_ID, CATEGORY_NAME FROM DCL_PAGE_CATEGORY"
        "\n ORDER BY CATEGORY_ID"
    );
    q.fetch();
    while(!q.eof()) {
        CATEGORY.assign(q.fields(), L"");
        append(L"CATEGORY", CATEGORY);
        q.fetch();
    }
 
    TextTemplate& ROLE = (*this)[L"ROLE"];
    q.execute(L""
        "SELECT ROLE_ID, ROLE_NAME FROM DCL_ROLE"
        "\n WHERE ROLE_ID > 0"
        "\n ORDER BY ROLE_ID"
    );
    q.fetch();
    while(!q.eof()) {
        ROLE.assign(q.fields(), L"");
        append(L"ROLE", ROLE);
        q.fetch();
    }
 
    ListedStringToStringArrayMap& mapQuery = session.__ctx.__queryMap;
 
    String strListPage = getDefault(mapQuery, L"list");
    if (!strListPage.isEmpty()) {
        String strListPageEnc = URLEncoder::encode(strListPage);
        assign(L"_LIST", strListPageEnc);
    }
    else
        strListPage = __strListPage;
 
    assign(L"LIST", strListPage);
 
    String strPageID = getDefault(mapQuery, L"_page");
    if (strPageID.isEmpty())
        strPageID = L"-1";
 
    q.execute(L""
        "SELECT * FROM DCL_PAGE WHERE PAGE_ID = " + strPageID
    );
    q.fetch();
    if (q.eof()) {
        // insert NEW
        q.execute(L"SELECT MAX(PAGE_ID) AS PAGE_ID FROM DCL_PAGE");
        q.fetch();
        if (q.eof() || q.fields()[0].isNull())
            strPageID = L"1";
        else {
            int nPageID = q.fields()[0].asInteger();
            if (nPageID < 201)
                nPageID = 201;
            else
                nPageID++;
 
            strPageID = String::valueOf(nPageID);
        }
        assign(L"PAGE_ID", strPageID);
    }
    else {
        // modify
        assign(q.fields(), L"");
        assign(L"ACTION", L"&_page=" + strPageID);
 
        q.execute(L""
            "SELECT V.NO, V.CLASS_ID, V.USER_ID, V.DS_ID, V.SKIN_FILE"
                ", V.PARAMETERS, D.DS_TYPE, D.DS_NAME"
            "\n FROM DCL_VIEW AS V"
            "\n  INNER JOIN DCL_DATA_SOURCE AS D"
            "\n   ON(V.USER_ID = D.USER_ID AND V.DS_ID = D.DS_ID)"
            "\n WHERE V.PAGE_ID = " + strPageID + L""
            "\n ORDER BY V.NO"
        );
        q.fetch();
        TextTemplate& VIEW = (*this)[L"VIEW"];
        while(!q.eof()) {
            VIEW.assign(q.fields(), L"");
            const HtmlView::CLASS_INFO* pInfo = 
                HtmlView::getClassInfo(q.fields().byName(L"CLASS_ID").asInteger());
            if (pInfo) {
                VIEW.assign(L"CLASS_NAME", pInfo->className());
                VIEW.assign(L"CLASS_DS_TYPE", String::valueOf(pInfo->nDsType));
            }
            else {
                VIEW.assign(L"CLASS_NAME", L"Invalid ClassID");
                VIEW.assign(L"CLASS_DS_TYPE", L"0");
            }
 
            VIEW.assign(L"VNO", VNO());
            append(L"VIEW", VIEW);
            q.fetch();
        }
    }
 
    FormView::onPrint(session);
}
 
void PageWriteForm::onPost(Session& session)
    __DCL_THROWS1(Exception*)
{
//  dump(session);
//  return;
 
    ListedStringToStringArrayMap& mapQuery = session.__ctx.__queryMap;
    ListedStringToStringArrayMap& mapForm = session.__ctx.__formMap;
 
    int nOldPageID = Integer::parse(
        getDefault(mapQuery, L"_page"),
        10,
        -1
    );
    int nPageID = Integer::parse(
        getDefault(mapForm, L"PAGE_ID"),
        10,
        -1
    );
    int nCategoryID = Integer::parse(getDefault(mapForm, L"CATEGORY_ID"), 10, 0);
    int nPermID = Integer::parse(getDefault(mapForm, L"PERM_ID"), 10, 1);
    String strType = getDefault(mapForm, L"TYPE");
    String strCharset = getDefault(mapForm, L"CHARSET");
    String strLanguage = getDefault(mapForm, L"LANGUAGE");
    String strTitle = getDefault(mapForm, L"TITLE");
    String strDesc = getDefault(mapForm, L"COMMENT");
 
    if (strType.isEmpty())
        strType = L"text/html";
 
    if (nPageID <= 0 ) {
        // data error
        return;
    }
 
    int nCM = CM_INSERT;
    if (nOldPageID > 0)
        nCM = CM_UPDATE;
 
    SQLQuery& q = session.__query;
    if (nCM == CM_INSERT) {
        // insert
        q.prepare(L""
            "INSERT INTO DCL_PAGE (PAGE_ID, PERM_ID, CATEGORY_ID,"
                " TYPE, CHARSET, LANGUAGE, TITLE,"
                " COMMENT, UPDATE_TIME)\n"
            "\n VALUES (:PAGE_ID, :PERM_ID, :CATEGORY_ID,"
                " :TYPE, :CHARSET, :LANGUAGE, :TITLE,"
                " :COMMENT, CURRENT_TIMESTAMP)"
        );
    }
    else {
        q.execute(L""
            "DELETE FROM DCL_VIEW WHERE PAGE_ID = " + String::valueOf(nOldPageID)
        );
 
        q.prepare(L""
            "UPDATE DCL_PAGE SET "
            "\n PAGE_ID = :PAGE_ID,"
                " PERM_ID = :PERM_ID,"
                " CATEGORY_ID = :CATEGORY_ID,"
                " TYPE = :TYPE, CHARSET = :CHARSET,"
                " LANGUAGE = :LANGUAGE, TITLE = :TITLE,"
                " COMMENT = :COMMENT,"
                " UPDATE_TIME = CURRENT_TIMESTAMP"
            "\n WHERE PAGE_ID = :OLD_PAGE_ID"
        );
    }
 
    SQLParams& params = q.params();
    params.byName(L"PAGE_ID").setValue(nPageID);
    params.byName(L"PERM_ID").setValue(nPermID);
    params.byName(L"CATEGORY_ID").setValue(nCategoryID);
    params.byName(L"TYPE").setValue(strType);
    if (strCharset.isEmpty())
        params.byName(L"CHARSET").setNull();
    else
        params.byName(L"CHARSET").setValue(strCharset);
 
    if (strLanguage.isEmpty())
        params.byName(L"LANGUAGE").setNull();
    else
        params.byName(L"LANGUAGE").setValue(strLanguage);
 
    if (strTitle.isEmpty())
        params.byName(L"TITLE").setNull();
    else
        params.byName(L"TITLE").setValue(strTitle);
 
    if (strDesc.isEmpty())
        params.byName(L"COMMENT").setNull();
    else
        params.byName(L"COMMENT").setValue(strDesc);
 
    if (nCM == CM_UPDATE)
        params.byName(L"OLD_PAGE_ID").setValue(nOldPageID);
 
    q.execute();
 
    /*
        try {
            q.execute();
        }
        catch(SQLException* e) {
            // insert 때 중복값이 발생하거나... 또는, ..
            e->destroy();
            return false;
        }
    */
 
    StringArray& vCLASS = mapForm[L"CLASS_ID"];
    StringArray& vUSER = mapForm[L"USER_ID"];
    StringArray& vDS = mapForm[L"DS_ID"];
    StringArray& vSKIN = mapForm[L"SKIN_FILE"];
    StringArray& vPARAMS = mapForm[L"PARAMETERS"];
 
    q.prepare(L""
        "INSERT INTO DCL_VIEW "
        "\n VALUES(:PAGE_ID, :NO, :CLASS_ID, :USER_ID, :DS_ID, :SKIN_FILE, :PARAMETERS)"
    );
    for(size_t i = 0; i < vCLASS.size(); i++) {
        int nClassID = Integer::parse(vCLASS[i], 10, -1);
        if (nClassID < 0) {
            // error
            break;
        }
        q.params().byName(L"PAGE_ID").setValue(nPageID);
        q.params().byName(L"NO").setValue((int)(i + 1));
        q.params().byName(L"CLASS_ID").setValue(nClassID);
        q.params().byName(L"USER_ID").setValue(Integer::parse(vUSER[i], 10, -1));
        q.params().byName(L"DS_ID").setValue(Integer::parse(vDS[i], 10, -1));
        if (vSKIN[i].isEmpty())
            q.params().byName(L"SKIN_FILE").setNull();
        else
            q.params().byName(L"SKIN_FILE").setValue(vSKIN[i]);
 
        if (vPARAMS[i].isEmpty())
            q.params().byName(L"PARAMETERS").setNull();
        else
            q.params().byName(L"PARAMETERS").setValue(vPARAMS[i]);
 
        q.execute();
    }
 
    StringBuilder strNext = getDefault(mapQuery, L"next");
    if (strNext.isEmpty()) {
        strNext = __strDetailPage;
        strNext += L"&_page=" + String::valueOf(nPageID);
    }
 
    String strListPage = getDefault(mapQuery, L"list");
    if (!strListPage.isEmpty())
        strNext += L"&list=" + URLEncoder::encode(strListPage);
 
    __pPage->refresh(session, L"?page=" + strNext.toString());
}
 
IMPLEMENT_CLASSINFO_EX(PageDetailView, HtmlView)
 
PageDetailView::PageDetailView(HtmlPage* pPage)
    : HtmlView(pPage)
{
}
 
void PageDetailView::init(SQLFields& fields)
    __DCL_THROWS1(Exception*)
{
    HtmlView::init(fields);
 
    __mapParams.lookup(L"LIST", __strListPage);
    __mapParams.lookup(L"WRITE", __strWritePage);
}
 
void PageDetailView::onPrint(Session& session)
    __DCL_THROWS1(Exception*)
{
    ListedStringToStringArrayMap& mapQuery = session.__ctx.__queryMap;
    SQLQuery& q = session.__query;
 
    String strListPage = getDefault(mapQuery, L"list");
    String strListPageEnc;
    String strWritePage = __strWritePage;
    String strPageIDs = String::join(mapQuery[L"_page"], L',', false);
 
    if (strListPage.isEmpty())
        strListPage = __strListPage;
 
    strListPageEnc = URLEncoder::encode(strListPage);
 
    assign(L"LIST", strListPage);
    assign(L"_LIST", strListPageEnc);
    assign(L"WRITE", strWritePage);
 
    TextTemplate& PAGE = (*this)[L"PAGE"];
    TextTemplate& EMPTY = (*this)[L"EMPTY"];
 
    if (strPageIDs.isEmpty()) {
        EMPTY.assign(L"LIST", strListPage);
        assign(L"EMPTY", EMPTY);
        HtmlView::onPrint(session);
        return;
    }
 
    q.execute(L""
        "SELECT P.PAGE_ID, P.TYPE, P.CHARSET, P.LANGUAGE,"
            " P.TITLE, P.COMMENT, P.UPDATE_TIME, C.CATEGORY_NAME, R.ROLE_NAME"
        "\n FROM DCL_PAGE AS P"
        "\n  INNER JOIN DCL_PAGE_CATEGORY AS C ON (P.CATEGORY_ID = C.CATEGORY_ID)"
        "\n  INNER JOIN DCL_ROLE AS R ON (P.PERM_ID = R.ROLE_ID)"
        "\n WHERE P.PAGE_ID IN (" + strPageIDs + L")"
        "\n ORDER BY P.PAGE_ID ASC"
    );
 
    q.fetch();
    if (q.eof())
        assign(L"EMPTY", EMPTY);
    else {
        TextTemplate& VIEW = PAGE[L"VIEW"];
        TextTemplate& V_EMPTY = PAGE[L"EMPTY"];
        SQLQuery qV(q.connection());
        qV.prepare(L""
            "SELECT V.NO, V.CLASS_ID, V.USER_ID, V.DS_ID, V.SKIN_FILE"
                ", V.PARAMETERS, D.DS_TYPE, D.DS_NAME"
            "\n FROM DCL_VIEW AS V"
            "\n  INNER JOIN DCL_DATA_SOURCE AS D"
            "\n   ON(V.USER_ID = D.USER_ID AND V.DS_ID = D.DS_ID)"
            "\n WHERE V.PAGE_ID = :PAGE_ID"
            "\n ORDER BY V.NO"
        );
 
        while(!q.eof())
        {
            PAGE.assign(q.fields(), L"&nbsp;");
            PAGE.assign(L"LIST", strListPage);
            PAGE.assign(L"_LIST", strListPageEnc);
            PAGE.assign(L"WRITE", strWritePage);
 
            StringBuilder strContentType = q.fields().byName(L"TYPE").asString();
            if (!q.fields().byName(L"CHARSET").isNull()) {
                strContentType += L"; charset=";
                strContentType += q.fields().byName(L"CHARSET").asString();
            }
            PAGE.assign(L"CONTENT_TYPE", strContentType);
 
            qV.params()[0].setValue(q.fields().byName(L"PAGE_ID").asInteger());
            qV.execute();
            qV.fetch();
            if (qV.eof())
                PAGE.assign(L"EMPTY", V_EMPTY);
            else {
                while(!qV.eof()) {
                    VIEW.assign(qV.fields(), L"&nbsp;");
                    VIEW.assign(L"CLASS_NAME", HtmlView::className(
                            qV.fields().byName(L"CLASS_ID").asInteger()
                        )
                    );
                    PAGE.append(L"EMPTY", VIEW);
                    qV.fetch();
                }
 
            }
            append(L"EMPTY", PAGE);
            PAGE.reset();
            q.fetch();
        }
    }
 
    HtmlView::onPrint(session);
}
 
__DCL_END_NAMESPACE