= Module Mime =

Voici un exemple qui montre comment faire un module gérant les mimetypes de façon assez basique.
Notez que ce module utilise le [wiki:HowtoGen Module Générique]. Bien sûr ce n'est qu'un exemple vraiment basique.

== mod_mime.hh ==
{{{
#!cpp
#ifndef MOD_MIME_HH_
# define MOD_MIME_HH_

# include <map>

# include "Module.hh"
# include "api/IHttpTransaction.hh"
# include "api/Handlers.hh"

class ModMime : public virtual Zia::Module, virtual public Zia::ITypeCheckHandler
{
public:
  ModMime(Zia::IConfig *config);
  ~ModMime();

  Zia::IModule::ChainStatus onTypeCheck(Zia::IHttpTransaction * trans);
private:
  void configure();
  bool findByExt(Zia::IHttpResponse * resp);

  std::map < std::string, std::string > exts_;
  std::string default_;
};

#endif /* !MOD_MIME_HH_ */

}}}
== mod_mime.cc ==

{{{
#!cpp
#include "Log.hh"

#include "mod_mime.hh"

using namespace Zia;

ZIA_MODULE(mime, ModMime, ZIA_MODULE_VERSION(0, 0, 1))
{
  config_->addIndexing("mime", "ext");
  configure();
}

ModMime::~ModMime()
{
}

void
ModMime::configure()
{
  std::list < std::string > keys = config_->list("|zia|mimes|mime|");

 for (std::list < std::string >::iterator it = keys.begin(); it != keys.end(); ++it)
   {
     std::string key = *it;

     if (key.substr(key.find_last_of("|") + 1, key.size()) == "ext")
       {
         std::string value = key.substr(0, key.find_last_of("|") + 1) + "type";

         exts_[config_->get(key).str()] = config_->get(value).str();
       }
   }
 default_ = config_->get("|zia|modules|module|mime|default").str();
 if (!default_.size())
   default_ = "text/plain";
 zDebug() << default_;
}

bool
ModMime::findByExt(IHttpResponse * resp)
{
  std::string filename = resp->getPhysicalName();
  std::string chunk;

  while (filename.size())
    {
      size_t pos = filename.find_last_of(".");

      if (pos == std::string::npos)
        break ;
      chunk = filename.substr(pos, filename.size());
      filename = filename.substr(0, pos);
      if (exts_.find(chunk) != exts_.end())
        {
          resp->setMimeType(exts_[chunk]);
          return (true);
        }
    }
  return (false);
}

IModule::ChainStatus
ModMime::onTypeCheck(IHttpTransaction * trans)
{
  IHttpResponse *resp = trans->getResponse();
  std::string mime = resp->getMimeType();

  if (mime != default_ && mime.size())
    return IModule::NOTHING;
  if (findByExt(resp))
    return IModule::CONTINUE;
  if (!mime.size())
    resp->setMimeType(default_);
  return IModule::CONTINUE;
}
}}}

== zia.xml ==

{{{
#!xml
<?xml version="1.0" ?>
<zia>
  <modules path=".">
    <module name="mime" load="true" default="text/plain" />
  </modules>
  <mimes>
    <mime ext=".txt" type="text/plain" />
    <mime ext=".html" type="text/html" />
  </mimes>
</zia>
}}}