Beispiel #1
0
// Constructor adapted for use as a wrapper around that other Request Parameter
// thing (the one outside of the OgcFramework) since that bad boy is case
// sensitive, and we don't want it to be.
// We adapt this from the NameValueCollection class that came from the OgcFramework.
MgHttpRequestParameters::MgHttpRequestParameters(MgHttpRequestParam* pParams)
: m_pParams(pParams)
{
    MgStringPropertyCollection* p = m_pParams->GetParameters();
    SetCount(p->GetCount());

    for(int i=0; i< Count(); i++) {
      STRING sName = p->GetName(i);
      STRING sValue = p->GetValue(i);

      VPSZ pszName = szdup(sName.c_str());
      VPSZ pszValue = szdup(sValue.c_str());
      SetName(i,pszName);
      SetValue(i,pszValue);
    }
}
void c_FeatureReaderToHtml::ToTemplate(bool IsKml,c_RestDataReader* Reader, c_RestRequest* RestRequest
                            , const string& FullUri,const string& UriBase
                            ,string& HtmlStr,int StartIndex,int MaxCount)
{

  Ptr<MgClassDefinition> classdef;
  // classdef =  if( FeatureReader ) FeatureReader->GetClassDefinition() ;
  classdef = RestRequest->m_DataClassDef;
  if( !classdef ) return;
  
 
  
  //const c_CfgDataLayer* cfgdata = MgRest_MapNameToResourceId::GetCfgDataForClass(classfullname);
  const c_CfgDataResource* cfgresource = RestRequest->m_CfgDataResource;
  
  if( !cfgresource ) return; // error ; class has to be in configuration file
  
  const c_CfgRepTemplate* templatedata;
  if( RestRequest->m_CfgRepresentation->GetType() != c_CfgRepresentation::e_Template )
  {
    return;  
  }
  
  templatedata = (c_CfgRepTemplate*)RestRequest->m_CfgRepresentation;
    
  
  string rest_uri_part;
  if( cfgresource->m_RestUriPart.length() > 0 )
  {
    MgUtil::WideCharToMultiByte(cfgresource->m_RestUriPart,rest_uri_part);
    
  }
  else
  {
    rest_uri_part = "/rest/data/";
  }
  
  //ctemplate::Template::SetTemplateRootDirectory(g_HtmlTemplatePath);
  ctemplate::Template::SetTemplateRootDirectory(RestRequest->m_CfgDataResource->m_TemplateFolder);
  
  
  
   // get identity property name;
  STRING identname;      
  if( classdef )
  {
    Ptr<MgPropertyDefinitionCollection> idents = classdef->GetIdentityProperties();
    if( idents->GetCount() == 1) 
    {
      int ind=0;  
      Ptr<MgPropertyDefinition> identprop = idents->GetItem(ind);
      identname = identprop->GetName();
    }
    else
    {
      identname = L"";
    }
  }
  
  ctemplate::TemplateDictionary dict_main("KING.MGREST");
  
  // now fill in request parameters
  if( RestRequest )
  {
    Ptr<c_RestUriRequestParam> req_param = RestRequest->GetRequestParam();
    MgStringPropertyCollection* params = req_param->GetParameters();
    
    if( params && (params->GetCount()>0) )
    {
      string dictkey;
      string param_name,param_val;        
      string keyprefix = "REST_PARAM_";
      for(int ind=0;ind<params->GetCount();ind++)
      {
        Ptr<MgStringProperty> param = params->GetItem(ind);
        MgUtil::WideCharToMultiByte(param->GetName(),param_name);
        ReplaceSpaces(param_name); // google ctemplate doesn't allow spaces
        MgUtil::WideCharToMultiByte(param->GetValue(),param_val);
      
        
        dict_main.SetValue(keyprefix+param_name,param_val);
      }
    }
  }
  
  string resturiparam;
  bool ismorerecords=false;
  int featurecount=0;
  if( (classdef != NULL) && (Reader!=NULL) )
  {
    
    STRING wresturiparam = cfgresource->m_UriTag;
    
    MgUtil::WideCharToMultiByte(wresturiparam,resturiparam);
    
    
      bool isnext=true;
      int skipstart = StartIndex;
      if( skipstart > 0 )
      {
        
        while ( (skipstart>0) && (isnext=Reader->ReadNext())==true  )
        {
          skipstart--;
        }
        
      }
      if( isnext )
      {
        
        string dictname; // = mb_classname;
        MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Section,dictname);
        string nameprefix; // = mb_classname + "_";
        MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Prefix,nameprefix);
        
        while ( Reader->ReadNext() )
        {
          
          if( MaxCount >= 0 )
          {
            
            if( featurecount >= MaxCount ) 
            {
              ismorerecords=true;
              break; // go out
            }
          }
          ctemplate::TemplateDictionary* dict_section = dict_main.AddSectionDictionary(dictname);
          FillDictionary(dict_section,nameprefix,Reader);
          
          if( identname.length() > 0 )
          {
            STRING strval;
            string mb_strval;
            GetPropertyAsString(Reader,identname,strval);
            MgUtil::WideCharToMultiByte(strval,mb_strval);
            
            
            //
            string dictkey = nameprefix + "REST_PNG";  
            string val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".png";                
            dict_section->SetValue(dictkey,val);
              
            dictkey = nameprefix + "REST_HTML";  
            val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".html";  
            dict_section->SetValue(dictkey,val);
            
            dictkey = nameprefix + "REST_KML";  
            val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".kml";  
            dict_section->SetValue(dictkey,val);
            
            dictkey = nameprefix + "REST_KMZ";  
            val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".kmz";  
            dict_section->SetValue(dictkey,val);
            
            dictkey = nameprefix + "REST_XML";  
            val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".xml";  
            dict_section->SetValue(dictkey,val);
            
            dictkey = nameprefix + "REST_JSON";  
            val = UriBase + rest_uri_part + resturiparam + "/" + mb_strval + ".json";  
            dict_section->SetValue(dictkey,val);
            
            // create feature identifier value as base64 coded
            string ident_base64;
            GetPropertyAsBase64(Reader,identname,ident_base64);
            dictkey = nameprefix + "REST_IDENT_BASE64";  
            dict_section->SetValue(dictkey,ident_base64);
            
          }
          
          featurecount++;
        }
        
      }
    
  
    
    // Now check additional data to be fetched for html template
    // it applies only to single feature templates
    if( featurecount==1 && templatedata->GetCountHtmlExtraData() > 0 )
    {
      int count = templatedata->GetCountHtmlExtraData();
      for(int ind=0;ind<count;ind++)
      {
        const c_CfgRepTemplateExtraData* extradata = templatedata->GetHtmlExtraData(ind);
        
        if( extradata->m_FetchUri.length() > 0 )
        {
        
          // generate template unique name
          std::string filename,mb_str;
          MgUtil::WideCharToMultiByte(cfgresource->m_UriTag,filename);        
          MgUtil::WideCharToMultiByte(extradata->m_HtmlTemp_Prefix,mb_str);        
          filename += mb_str;
          
          
          MgUtil::WideCharToMultiByte(extradata->m_FetchUri,mb_str);
          filename="";
          ctemplate::Template * temp = ctemplate::Template::StringToTemplate(mb_str,ctemplate::STRIP_WHITESPACE);
          /*
          ctemplate::Template * temp = ctemplate::Template::RegisterStringAsTemplate(filename,        
                                               ctemplate::STRIP_WHITESPACE,ctemplate::TC_MANUAL,mb_str);
          */          
                    
          std::string uristr;                  
          temp->Expand(&uristr,&dict_main);     
          
          // Now use uristr to fetch data
          std::string mb_str2,mb_str3,mb_str4;
          
          MgUtil::WideCharToMultiByte(extradata->m_HtmlTemp_Section,mb_str2);
          MgUtil::WideCharToMultiByte(extradata->m_HtmlTemp_DataSection,mb_str3);
          MgUtil::WideCharToMultiByte(extradata->m_HtmlTemp_Prefix,mb_str4);
          c_RestFetchSource::FetchFeaturesToDictionary( uristr,&dict_main,mb_str2,mb_str3,mb_str4 );                                             
          
          delete temp;
        }
        
      }
    }
    
    // now add in dictionary values for next and previous
    if( ismorerecords || StartIndex>0 )
    {    
      Poco::URI uri_parser(FullUri);    
      
      std::string query = uri_parser.getQuery();
          
      c_RestUriRequestParam params;
      c_RestUri::ParseQuery(query.c_str(),&params);
      
      
      
      if( StartIndex>0 )
      {
        int newstart = StartIndex - MaxCount;
        if( newstart < 0 ) newstart=0;
        
        newstart++;        
        wchar_t strstart[20];
        ::swprintf(&strstart[0],L"%d",newstart);
        
        if( params.ContainsParameter(L"Start") )
        {
          params.SetParameterValue(L"Start",strstart);
        }
        else
        {
          params.AddParameter(L"Start",strstart);
        }
        
        wstring wuriquery;
        params.GetAsUriQuery(wuriquery);
        
        string uriquery;
        MgUtil::WideCharToMultiByte(wuriquery,uriquery);
        
        //string prev_uri = UriBase + rest_uri_part + resturiparam + "/" + ".html" + "?" + uriquery;
        string prev_uri = "?" + uriquery; // use only query part so link will be correct in case of url rewrites
        
        ctemplate::TemplateDictionary* dict_section = dict_main.AddSectionDictionary("PREVIOUS_PAGE_SECTION");
        string dictkey = "PREVIOUS_PAGE";  
        dict_section->SetValue(dictkey,prev_uri);
      }
      else
      {
        // no previous link
        //string dictkey = nameprefix + "PREVIOUS_PAGE";  
        //dict_main.SetEscapedValue(,);
      }
      
      
      if( ismorerecords>0 )
      {
        int newstart = StartIndex + MaxCount;
        if( newstart < 0 ) newstart=0;
        
        newstart++;        
        wchar_t strstart[20];
        ::swprintf(&strstart[0],L"%d",newstart);
        
        if( params.ContainsParameter(L"Start") )
        {
          params.SetParameterValue(L"Start",strstart);
        }
        else
        {
          params.AddParameter(L"Start",strstart);
        }
        
        wstring wuriquery;
        params.GetAsUriQuery(wuriquery);
        
        string uriquery;
        MgUtil::WideCharToMultiByte(wuriquery,uriquery);
        
        
        
        
        
        //string next_uri = UriBase + rest_uri_part + resturiparam + "/" + ".html" + "?" + uriquery;
        string next_uri = "?" + uriquery; // use only query part so link will be correct in case of url rewrites
        
        ctemplate::TemplateDictionary* dict_section = dict_main.AddSectionDictionary("NEXT_PAGE_SECTION");
        string dictkey = "NEXT_PAGE";          
        dict_section->SetValue(dictkey,next_uri);
                
      }
      else
      {
        // no previous link
        //string dictkey = nameprefix + "NEXT_PAGE";  
        //dict_main.SetEscapedValue(,);
      }

    }
  }
  
  
    string tmpl; // name of template to use    
  
  if(Reader)
  {
    
    if( featurecount == 1 )
      MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Single,tmpl);
    else
    {  
      if( featurecount == 0 )  
        MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Zero,tmpl);
      else
        MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Many,tmpl);
    }
  }
  else
  {
    // if there was no feature reader
    MgUtil::WideCharToMultiByte(templatedata->m_HtmlTemp_Error,tmpl);    
    if(RestRequest->m_RestResultObjectStatus  == c_RestRequest::e_BBox_OutOfRange )
      dict_main.ShowSection("EXCEPTION_BBOX_LIMIT");
    if(RestRequest->m_RestResultObjectStatus  == c_RestRequest::e_Count_OutOfRange )
      dict_main.ShowSection("EXCEPTION_COUNT_LIMIT");
  }    
    /*      
    string tmpl = mb_classname;
    // if there is only one feature then use different template
    // name of that template for class "parcel" is parcel.tpl , added "1" to end of class name
    if( count <= 1 )
    {
      tmpl.append("1");
    }
    
    tmpl.append(".tpl");
    */
    ctemplate::Template::ReloadAllIfChanged();
    
    ctemplate::TemplateContext tc;
    if( IsKml )
      tc = ctemplate::TC_XML;
    else
      tc = ctemplate::TC_HTML;
    
    //ctemplate::Template* tpl = ctemplate::Template::GetTemplateWithAutoEscaping(tmpl,ctemplate::DO_NOT_STRIP,tc);
    ctemplate::Template* tpl = ctemplate::Template::GetTemplate(tmpl,ctemplate::DO_NOT_STRIP);
    if( !tpl )
    {
      //Ptr<MgStringCollection> scol = new MgStringCollection();
      std::wstring wsarg;
      MgUtil::MultiByteToWideChar(tmpl,wsarg);
      //scol->Add(wsarg);
      
      std::wstring errmsg = L"Unable to load Template file '";
      errmsg = errmsg.append(wsarg);
      errmsg = errmsg.append(L"'. Check config file and template file location!");
      
      throw new MgRuntimeException(L"c_FeatureReaderToHtml::ToTemplate",__LINE__, __WFILE__, NULL, errmsg, NULL);
    }
    
    tpl->Expand(&HtmlStr,&dict_main);



}//end of c_FeatureReaderToHtml::ToTemplate