package org.paneris.bibliomania;

 import java.io.BufferedOutputStream;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.FileReader;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.Reader;

 import java.io.StringReader;

 import java.net.InetAddress;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.Timestamp;

 import java.util.Enumeration;

 import java.util.Hashtable;

 import java.util.List;

 import java.util.Locale;

 import java.util.Properties;

 import java.util.Vector;

 import org.melati.Melati;

 import org.melati.MelatiConfig;

 import org.melati.poem.AccessToken;

 import org.melati.poem.Capability;

 import org.melati.poem.Group;

 import org.melati.poem.NoSuchRowPoemException;

 import org.melati.poem.PoemTask;

 import org.melati.poem.PoemThread;

 import org.melati.poem.PreparedStatementFactory;

 import org.melati.poem.Setting;

 import org.melati.poem.TableInfo;

 import org.melati.template.webmacro.MelatiFastWriter;

 import org.melati.util.Email;

 import org.melati.util.FileUtils;

 import org.melati.util.IoUtils;

 import org.melati.util.MelatiRuntimeException;

 import org.melati.util.UnexpectedExceptionException;

 import org.paneris.bibliomania.fti.FTIException;

 import org.paneris.bibliomania.fti.IndexOther;

 import org.paneris.bibliomania.fti.Library;

 import org.paneris.bibliomania.fti.Text;

 import org.paneris.bibliomania.generated.BibliomaniaDatabaseBase;

 import org.paneris.bibliomania.metasearch.BookshopBackend;

 import org.paneris.bibliomania.metasearch.BookshopBackendFactory;

 import org.paneris.bibliomania.pagination.Pagination;

 import org.webmacro.Context;

 import org.webmacro.InitException;

 import org.webmacro.WM;

 import org.webmacro.WebMacro;

 import org.webmacro.WebMacroException;

 import org.webmacro.engine.FileTemplate;

 import org.webmacro.engine.StreamTemplate;

 /**

  * Melati POEM generated, programmer modifiable stub.

  */

 public class BibliomaniaDatabase extends BibliomaniaDatabaseBase

                             implements BibliomaniaDatabaseTables {

   // programmer's domain-specific code here

    private IndexOther fti = null, infoFTI = null;

    private Properties ftiConfig;

    private Pagination pagination = null;

    public static final int defaultDefaultSearchHitsPerText = 5,

      defaultSearchHitsPerPage = 20,

      defaultBookStockingsCheckIntervalDays = 7,

      defaultBibBookBookshopSearchTimeoutSeconds = 120,

      defaultBookStockingsCheckConcurrentMax = 2,

      defaultBookStockingsOutputStartOffset = 25,

      defaultBookStockingsCacheSizeMax = 10000;

    public static final String defaultPasswordReminderMessage =

      "defaultPasswordReminderMessage.wm",

      defaultPasswordReminderFrom = "help",

      defaultOrderEmailFrom = "orders@bibliomania.com",

      defaultConfirmationEmailFrom = "customercare@bibliomania.com",

      defaultOrderEmailTo = "purchases@bibliomania.com",

      defaultStratusEmailTo = "info@houseofstratus.com",

      defaultContentEncoding = "ISO-8859-1",

      defaultUploadDir = "/usr/local/bibliomania/books/",

      defaultUploadURL = "/",

      defaultDomainUrl = "www.bibliomania.com";

    //  defaultContentEncoding = "UTF8";

    private Setting workspaceDir,

      contentRootDir,

      staticRootURL,

      contentStaticRootURL,

      cacheRootURL,

      homepageURL,

      orderEmailFrom,

      confirmationEmailFrom,

      orderEmailTo,

      stratusEmailTo,

      defaultSearchHitsPerText,

      searchHitsPerPage,

      paginationTexHeader,

      bookStockingsCheckIntervalDays,

      bookStockingsCheckConcurrentMax,

      bookStockingsInBackground,

      bibBookBookshopSearchTimeoutSeconds,

      smtpServer,

      passwordReminderMessage,

      passwordReminderFrom,

      infoFTIDir,

      bannerURLPath,

      bookStockingsOutputStartOffset,

      bookStockingsCacheDir,

      bookStockingsCacheSizeMax,

      contentEncoding,

      uploadDir,

      uploadURL;

    private Currency UKCurrency;

    //private Currency USCurrency;

    private Group registeredUserGroup;

    private Capability registeredUserCapability,

      contentModificationCapability,

      contentAdditionCapability;

    private User templateRegisterUser;

    private Bookshop[] bookshops = null;

    private SectionGroup readSectionGroup,

      studySectionGroup,

      researchSectionGroup,

      shopSectionGroup,

      searchSectionGroup;

    private boolean bookStockingsInBackgroundAppropriate, openBerkeleyDBs;

    private Section drama;

    private Author shakespeare;

    private Book macbeth;

    public BibliomaniaDatabase() {

      this(false);

    }

    public BibliomaniaDatabase(boolean bookStockingsInBackgroundAppropriate) {

      this(bookStockingsInBackgroundAppropriate, true);  // Turn on BerkeleyDB

    }

    public BibliomaniaDatabase(

        boolean bookStockingsInBackgroundAppropriate,

        boolean openAuxDBs) {

      this(bookStockingsInBackgroundAppropriate, openAuxDBs, null);

    }

    public BibliomaniaDatabase(

        boolean bookStockingsInBackgroundAppropriate,

        boolean openAuxDBs,

        Properties ftiConfig) {

      this.bookStockingsInBackgroundAppropriate =

        bookStockingsInBackgroundAppropriate;

      this.openBerkeleyDBs = openAuxDBs;

      this.ftiConfig = ftiConfig;

    }

    public boolean debug() {

      return false;

    }

    public Capability getCanAdminister() {

      return administerCapability();

    }

    public void connect(

      String name,

      String dbmsclass,

      String url,

      String username,

      String password,

      int maxConnections) {

      super.connect(name, dbmsclass, url, username, password, maxConnections);

      inSession(AccessToken.root, new PoemTask() {

        public void run() {

          String root = "/usr/local/bibliomania";

          ((UserTable)getUserTable()).setBoardManager(

              ((UserTable)getUserTable()).ensure(

                  "_manager_","FIXME",

                  "board_manager@paneris.co.uk",

                  "Bibliomania Board Manager"));

          readSectionGroup =

            getSectionGroupTable().ensure(

              "#ff9900",

              "read",

              "read.gif",

              "readg.gif",

              "1",

              "read",

              "",

              false,

              null);

          studySectionGroup =

            getSectionGroupTable().ensure(

              "#9999ff",

              "study",

              "study.gif",

              "studyg.gif",

              "4",

              "study",

              "",

              false,

              null);

          researchSectionGroup =

            getSectionGroupTable().ensure(

              "#cc9966",

              "research",

              "researchb.gif",

              "researcha.gif",

              "6",

              "research",

              "",

              false,

              null);

          /*

          shopSectionGroup = 

            getSectionGroupTable().ensure(

              "#00cc99", 

              "shop", 

              "shop.gif", 

              "shopg.gif", 

              "3",

              "shop", 

              "<a href=/b/org.paneris.melati.shopping.Trolley/bibliomania/View target=main>Your Basket</a>", 

              false, 

              null);

          */

          searchSectionGroup =

            getSectionGroupTable().ensure(

              "#ff0000",

              "search",

              "search.gif",

              "searchg.gif",

              "2",

              "search",

              "",

              true,

              "/b/Search");

          drama = getSectionTable().ensure("Drama", readSectionGroup);

          shakespeare = getAuthorTable().ensure("William Shakespeare", drama);

          macbeth = getBookTable().ensure("Macbeth", shakespeare, drama);

          registeredUserGroup = getGroupTable().ensure("Registered users");

          registeredUserCapability =

            getCapabilityTable().ensure("Access study material");

          contentModificationCapability =

            getCapabilityTable().ensure("Edit content database");

          contentAdditionCapability =

            getCapabilityTable().ensure("Add to content database");

          getGroupCapabilityTable().ensure(

              getGroupTable().administratorsGroup(),

            contentModificationCapability);

          getGroupCapabilityTable().ensure(

              getGroupTable().administratorsGroup(),

              contentAdditionCapability);

          templateRegisterUser =

            (User)getUserTable().getLoginColumn().firstWhereEq(

              "_registerTemplate_");

          if (templateRegisterUser == null) {

            templateRegisterUser = (User)getUserTable().newPersistent();

            templateRegisterUser.setLogin("_registerTemplate_");

            templateRegisterUser.setPassword("0.804461358580738");

            templateRegisterUser.setEmail("none@bogus");

            templateRegisterUser.setFulltimeeducation(false);

            templateRegisterUser.setWantspam(false);

            templateRegisterUser.setWantemailalerts(false);

            templateRegisterUser.setDodgeyemail(false);

            templateRegisterUser.setName(

              "<Template for newly registering users>");

            getUserTable().create(templateRegisterUser);

          }

          workspaceDir =

            getSettingTable().ensure(

              "WorkspaceDir",

              root + "/workspace",

              "Workspace directory",

              "Where the system should store its working files");

          infoFTIDir =

            getSettingTable().ensure(

              "InfoFTIDir",

              "/infoFTI",

              "Info-FTI directory",

              "Where the system should store the info-page index, relative "

                + "to WorkspaceDir");

          contentRootDir =

            getSettingTable().ensure(

              "ContentRootDir",

              root + "/books",

              "Content root directory",

              "Where (in the local filesystem) the system should look for "

                + "the book content files");

          staticRootURL =

            getSettingTable().ensure(

              "StaticRootURL",

              "/bibliomania-static",

              "Static root URL",

              "Where the browser can find the Bibliomania chrome, "

                + "relative to the server root URL");

          contentStaticRootURL =

            getSettingTable().ensure(

              "ContentStaticRootURL",

              "/bibliomania-content-static",

              "Content static root URL",

              "Where the browser can find the Bibliomania static content, "

                + "relative to the server root URL");

          bannerURLPath =

            getSettingTable().ensure(

              "BannerURLPath",

              "/bibliomania-content-static",

              "Banner URL Path",

              "Where the browser can find the Bibliomania static content, "

                + "relative to the server root URL");

          cacheRootURL =

            getSettingTable().ensure(

              "CacheRootURL",

              "",

              "Cache root URL",

              "Where the web server should look for the banner ad, "

                + "relative to the server root URL");

          homepageURL =

            getSettingTable().ensure(

              "HomepageURL",

              "http://www.bibliomania.com",

              "Home page URL",

              "A full URL for the front page of bibliomania");

          defaultSearchHitsPerText =

            getSettingTable().ensure(

              "DefaultSearchHitsPerText",

              defaultDefaultSearchHitsPerText,

              "Default search hits per text",

              "The default number of search hits to return from each text");

          searchHitsPerPage =

            getSettingTable().ensure(

              "SearchHitsPerPage",

              defaultSearchHitsPerPage,

              "Search hits per page",

              "The number of search hits to return on each results page");

          bookStockingsCheckIntervalDays =

            getSettingTable().ensure(

              "StockingsCheckIntervalDays",

              defaultBookStockingsCheckIntervalDays,

              "Bookshop search refresh days",

              "The number of days for which a cached bookshop search "

                + "remains valid");

          bibBookBookshopSearchTimeoutSeconds =

            getSettingTable().ensure(

              "BibBookSearchTimeoutSecs",

              defaultBibBookBookshopSearchTimeoutSeconds,

              "Timeout for shop search for Bib book",

              "The number of seconds which a bookshop search for a "

                + "Bibliomania book is allowed to continue before being "

                + "cut short");

          bookStockingsInBackground =

            getSettingTable().ensure(

              "StockingsCheckInBackground",

              false,

              "Background bookshop search",

              "Whether to run continual bookshop searches in the background");

          bookStockingsOutputStartOffset =

            getSettingTable().ensure(

              "StockingsOutputStartOffset",

              defaultBookStockingsOutputStartOffset,

              "Start Offset for Shop DHTML",

              "How far down the page to start DHTML output");

          bookStockingsCacheDir =

            getSettingTable().ensure(

              "StockingsCacheDir",

              root + "/stockings",

              "Book stockings cache directory",

              "Where the system should store cached results of bookshop "

                + "searches");

          bookStockingsCacheSizeMax =

            getSettingTable().ensure(

              "StockingsCacheMax",

              defaultBookStockingsCacheSizeMax,

              "Max cached book stockings",

              "How many bookshop search results the system should cache");

          bookStockingsCheckConcurrentMax =

            getSettingTable().ensure(

              "StockingsCheckConcurrentMax",

              defaultBookStockingsCheckConcurrentMax,

              "Max concurrent bookshop searches",

              "The maximum number of bookshop searches to allow "

                + "at once (including the background search)");

          UKCurrency =

            getCurrencyTable().ensure("UK Pound Sterling", 1d, Locale.UK);

          //USCurrency = getCurrencyTable().ensure("US Dollar", 1.43, Locale.US);

          if (openBerkeleyDBs) {

            try {

              fti = new IndexOther(new File(getWorkspaceDir()), ftiConfig);

              infoFTI = new IndexOther(new File(getInfoFTIDir()));

            } catch (Exception e) {

              throw new FTIException(e);

            }

          }

          try{ 

            pagination = new Pagination(new File(getWorkspaceDir()));

          } catch (Exception e) { 

            throw new RuntimeException(e);

          }

          paginationTexHeader =

            (Setting)getSettingTable().getNameColumn().firstWhereEq(

              "PaginationTexHeader");

          if (paginationTexHeader == null) {

            paginationTexHeader =

              getSettingTable().ensure(

                "PaginationTexHeader",

                pagination.defaultTexHeader(),

                "TeX header for pagination",

                "The header to be prepended to the TeX version of a "

                  + "chapter when TeX is run to determine page breaks");

            paginationTexHeader.setWidth(60);

            paginationTexHeader.setHeight(5);

          }

          Vector<Bookshop> bookshopsList = new Vector<Bookshop>();

          Bookshop bol = getBookshopTable().ensure("BOLUK", "BOL UK", "uk.gif");

          if (!Boolean.TRUE.equals(bol.getDisabled())) {

            bol.backend = bookshopBackendNamed("bol");

            bookshopsList.addElement(bol);

          }

          Bookshop bob =

            getBookshopTable().ensure(

              "BOB",

              "Blackwells Online Bookshop",

              "uk.gif");

          if (!Boolean.TRUE.equals(bob.getDisabled())) {

            bob.backend = bookshopBackendNamed("bob");

            bookshopsList.addElement(bob);

          }

          Bookshop amazon =

            getBookshopTable().ensure("AMAZON", "amazon.com", "us.gif");

          if (!Boolean.TRUE.equals(amazon.getDisabled())) {

            amazon.backend = bookshopBackendNamed("amazon");

            bookshopsList.addElement(amazon);

          }

          bookshops = new Bookshop[bookshopsList.size()];

          bookshopsList.copyInto(bookshops);

          String defaultSmtpServer;

          try {

            defaultSmtpServer = InetAddress.getLocalHost().toString();

          } catch (Exception e) {

            defaultSmtpServer = "www.bibliomania.com";

          }

            smtpServer =

              getSettingTable().ensure(Email.SMTPSERVER,

    defaultSmtpServer,

      "SMTP server",

      "The SMTP server through which auto-generated mail " + "should be sent");

          passwordReminderMessage =

            (Setting)getSettingTable().getNameColumn().firstWhereEq(

              "PasswordReminderMessage");

          if (passwordReminderMessage == null) {

            String it;

            try {

              it =

                new String(

                  IoUtils.slurp(

                    this.getClass().getResource(defaultPasswordReminderMessage),

                    4096));

            } catch (Exception e) {

              throw new UnexpectedExceptionException(

                "Didn't find resource " + defaultPasswordReminderMessage,

                e);

            }

            passwordReminderMessage =

              getSettingTable().ensure(

                "PasswordReminderMessage",

                it,

                "Password reminder message",

                "The text of the message sent to users to remind them of "

                  + "their password (actually a WebMacro template)");

            passwordReminderMessage.setWidth(80);

            passwordReminderMessage.setHeight(30);

          }

          passwordReminderFrom =

            getSettingTable().ensure(

              "PasswordReminderFrom",

              defaultPasswordReminderFrom,

              "Password reminder `From:'",

              "The address from whom the emailed password reminders "

                + "should originate");

          confirmationEmailFrom =

            getSettingTable().ensure(

              "ConfirmationEmailFrom",

              defaultConfirmationEmailFrom,

              "Confirmation Email `From:'",

              "The address from whom the confirmation email that is sent on "

                + "registration should originate");

          orderEmailFrom =

            getSettingTable().ensure(

              "OrderEmailFrom",

              defaultOrderEmailFrom,

              "Order Email `From:'",

              "The address from whom the emailed order acknowledgements "

                + "should originate");

          orderEmailTo =

            getSettingTable().ensure(

              "OrderEmailTo",

              defaultOrderEmailTo,

              "Order Email `To:'",

              "The address to send email acknowledgements to (at bibliomania)");

          stratusEmailTo =

            getSettingTable().ensure(

              "StratusEmailTo",

              defaultStratusEmailTo,

              "Stratus Email `To:'",

              "The address to send email orders to (at Stratus)");

          contentEncoding =

            getSettingTable().ensure(

              "Content encoding",

              defaultContentEncoding,

              "Encoding (character set) to use for content",

              "The encoding, or character set, to use for the cached "

                + "content; if you don't know why you need to set this, "

                + "leave it as UTF8.");

          uploadDir =

            getSettingTable().ensure(

              "UploadDir",

              defaultUploadDir,

              "Upload Directory for Product Images",

              "Upload Directory for product images.  This is prepended to the "

                + "path used for the book to which this product relates.");

          uploadURL =

            getSettingTable().ensure(

              "UploadURL",

              defaultUploadURL,

              "URL used when finding uploaded images",

              "The URL used when finding uploaded images.  This is prepended to the "

                + "URL used for the book to which this product relates.");

          /* this is all a bit verbose, but it is nice to ensure these are present

           */

          // Advert table - normal admin permissions

          setDefaultAccessPermissions(

            getAdvertTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // Attachment table - only sys admins can add / change

          // individual users can also change things

          setDefaultAccessPermissions(

            getAttachmentTable().getTableInfo(),

            null,

            administerCapability(),

            administerCapability(),

            null);

          // Attachment type table - only sys admins can add / change

          setDefaultAccessPermissions(

            getAttachmentTypeTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // Author table - normal admin permissions

          setDefaultAccessPermissions(

            getAuthorTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // Author website table - normal admin permissions

          setDefaultAccessPermissions(

            getAuthorWebSiteTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // messageboard table - normal admin permissions

          setDefaultAccessPermissions(

            getBoardTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // messageboard type table - only administrators

          setDefaultAccessPermissions(

            getBoardTypeTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            contentModificationCapability,

            null);

          // book table - normal admin permissions

          setDefaultAccessPermissions(

            getBookTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // book format table - only administrators

          setDefaultAccessPermissions(

            getBookFormatTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // bookshop table - only administrators - but others can edit

          setDefaultAccessPermissions(

            getBookshopTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            contentModificationCapability,

            null);

          // book stocking table - only administrators 

          setDefaultAccessPermissions(

            getBookStockingTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // chapter table - normal admin permissions

          setDefaultAccessPermissions(

            getChapterTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // country table - normal admin permissions

          setDefaultAccessPermissions(

            getCountryTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // currency table - normal admin permissions

          setDefaultAccessPermissions(

            getCurrencyTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // delivery charge table - normal admin permissions

          setDefaultAccessPermissions(

            getDeliveryChargeTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // delivery charge band table - normal admin permissions

          setDefaultAccessPermissions(

            getDeliveryChargeBandTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // download table - normal admin permissions

          setDefaultAccessPermissions(

            getDownloadTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // download event table - only administrator and the relevant user

          setDefaultAccessPermissions(

            getDownloadEventTable().getTableInfo(),

            null,

            administerCapability(),

            administerCapability(),

            administerCapability());

          // layout table - normal admin permissions

          setDefaultAccessPermissions(

            getLayoutTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // membership status table - normal admin permissions

          setDefaultAccessPermissions(

            getMembershipStatusTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // order table - owning user, and admins can modify

          setDefaultAccessPermissions(

            getShopOrderTable().getTableInfo(),

            null,

            administerCapability(),

            null,

            null);

          // order item table - owning user, and admins can modify

          setDefaultAccessPermissions(

            getShopOrderItemTable().getTableInfo(),

            null,

            administerCapability(),

            null,

            null);

          // order status table - anly admins can chnage 

          setDefaultAccessPermissions(

            getOrderStatusTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // product table - normal permissions

          setDefaultAccessPermissions(

            getProductTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // product association table - normal permissions

          setDefaultAccessPermissions(

            getProductAssociationTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // publisher table - normal permissions

          setDefaultAccessPermissions(

            getPublisherTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // publisher table - normal permissions

          setDefaultAccessPermissions(

            getPublisherTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // section table - normal permissions

          setDefaultAccessPermissions(

            getSectionTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // section group table - admin only

          setDefaultAccessPermissions(

            getSectionTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // Sex table - admin only

          setDefaultAccessPermissions(

            getSexTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            null);

          // Stockingssearch table - admin only

          setDefaultAccessPermissions(

            getStockingsSearchTable().getTableInfo(),

            null,

            administerCapability(),

            administerCapability(),

            null);

          // Supplier table - normal permission

          setDefaultAccessPermissions(

            getSupplierTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // Supplier products table - normal permission

          setDefaultAccessPermissions(

            getSupplierProductTable().getTableInfo(),

            contentAdditionCapability,

            administerCapability(),

            contentModificationCapability,

            null);

          // User table - owner and admin only

          setDefaultAccessPermissions(

            getUserTable().getTableInfo(),

            administerCapability(),

            administerCapability(),

            administerCapability(),

            administerCapability());

        }

      });

      if (bookStockingsInBackgroundAppropriate)

        new BackgroundStockingsChecker().start();

      /*

       * Here is a good place to put one off hacks.

       */

    }

    private void setDefaultAccessPermissions(

      TableInfo info,

      Capability add,

      Capability delete,

      Capability write,

      Capability read) {

      if (info.getCancreate() == null)

        info.setCancreate(add);

      if (info.getDefaultcandelete() == null)

        info.setDefaultcandelete(delete);

      if (info.getDefaultcanwrite() == null)

        info.setDefaultcanwrite(write);

      if (info.getDefaultcanread() == null)

        info.setDefaultcanread(read);

    }

    public IndexOther fti() {

      return fti;

    }

    public IndexOther infoFTI() {

      return infoFTI;

    }

    Library infoLibrary = new Library() {

      public Text text(long textID) {

        int a =

          (int) ((textID & ((1l << Chapter.ftiTextID_section_shift) - 1))

            >> Chapter.ftiTextID_author_shift);

        long aMask = (1l << Chapter.ftiTextID_author_shift) - 1;

        if ((textID & aMask) == aMask) {

          // it's an author

          // but be defensive about finding it

          try {

            return getAuthorTable().getAuthorObject(new Integer(a));

          } catch (NoSuchRowPoemException e) {

            // log it

            e.printStackTrace(System.err);

            return null;

          }

        } else {

          // it's a book

          int b = (int) ((textID & aMask) >> Chapter.ftiTextID_book_shift);

          return (Book)getBookTable().firstSelection(

            "author = " + a + " AND " + "authorsequence = " + b);

        }

      }

    };

    public Library infoLibrary() {

      return infoLibrary;

    }

    public boolean openBerkelyDBs() { 

      return openBerkeleyDBs;

    }

    public Pagination pagination() {

      return pagination;

    }

    public String getWorkspaceDir() {

      return workspaceDir.getStringCooked();

    }

    public String getUploadDir() {

      return uploadDir.getStringCooked();

    }

    public String getUploadURL() {

      return uploadURL.getStringCooked();

    }

    public String getInfoFTIDir() {

      return getWorkspaceDir() + infoFTIDir.getStringCooked();

    }

    public String getContentRootDir() {

      return contentRootDir.getStringCooked();

    }

    private WebMacro _wm = null;

    public WebMacro getWebMacro() {

      if (_wm == null) {

        synchronized (this) {

          if (_wm == null) {

            try {

              _wm = new WM();

            } catch (InitException e) {

              throw new UnexpectedExceptionException(

                "Initialising WebMacro for the pagination subsystem",

                e);

            }

          }

        }

      }

      return _wm;

    }

    public void 

      setupContext(Melati melati, Context context, Unit it, Hashtable<String, Object> extras) {

      SectionGroup sectiongroup = it == null ? null : it.getReadArea();

      context.put("sectiongroup", sectiongroup);

      if (sectiongroup != null) {

        context.put("areaColour", sectiongroup.getThemecolour());

      } else {

        context.put("areaColour", "#FF0000");

      }

      Section section = null;

      Author author = null;

      Book book = null;

      Chapter chapter = null;

      if (it != null) {

        context.put("meta_description", it.getMetatag_description());

        context.put("meta_keywords", it.getMetatag_keywords());

        if (it instanceof Chapter) {

          chapter = (Chapter)it;

          book = chapter.getBook();

          author = book.getAuthor();

          section = book.getSection();

        } else if (it instanceof Book) {

          book = (Book)it;

          author = book.getAuthor();

          section = book.getSection();

        } else if (it instanceof Author) {

          author = (Author)it;

        } else if (it instanceof Section) {

          section = (Section)it;

        }

      }

      context.put("object", it);

      context.put("section", section);

      context.put("author", author);

      context.put("book", book);

      context.put("chapter", chapter);

      context.put("bib", getBib());

      context.put("db", this);

      context.put("melati", melati);

      if (extras != null)

        for (Enumeration<String> keys = extras.keys(); keys.hasMoreElements();) {

          String key = keys.nextElement();

          context.put(key, extras.get(key));

        }

    }

    public final void setupContext(Melati melati, Context context, Unit it) {

      setupContext(melati, context, it, null);

    }

    /**

     * Hook to be called when content files are created or changed.  At the

     * moment, this makes the file executable (<TT>chmod</TT> <TT>ugo+x</TT>),

     * because we use mod-include (server-side includes) to serve the ad banners,

     * and Apache will only send a <TT>Last-Modified</TT> in the header if the

     * <TT>XBitHack</TT> option is enabled in <TT>httpd.conf</TT> and the

     * <TT>x</TT> bit is set.  For a while we feared that if Apache doesn't send

     * <TT>Last-Modified</TT>, Google doesn't index us; that seems not to be

     * true, but nevertheless sending <TT>Last-Modified</TT> is a good thing.

     */

    public static void notifyNewContentFile(File file) throws IOException {

      FileUtils.makeExecutable(file);

    }

    public String getWMTemplet(String templetName) {

      return "org/paneris/bibliomania/template/webmacro/templets/html/" + templetName + ".wm";

    }

    public final void interpolateTemplateToStream(

        org.webmacro.Template template,

        OutputStream o,

        Unit object) throws WebMacroException, IOException {

      interpolateTemplateToStream(template, o, object, null);

    }

    public void interpolateTemplateToStream(org.webmacro.Template template,

                               OutputStream o,

                               Unit object,

                               Hashtable extras)

        throws WebMacroException, IOException {

      WebMacro wm = getWebMacro();

      MelatiFastWriter fmw =

        new MelatiFastWriter(wm.getBroker(), o, getContentEncoding());

      Melati m = new Melati(new MelatiConfig(), fmw);

      Context context = wm.getContext();

      setupContext(m, context, object, extras);

      template.write(fmw.getFastWriter(), context);

      fmw.getFastWriter().flush();

      /*

          Melati m = new Melati(new MelatiConfig(),

                                new SimpleMelatiWriter(new OutputStreamWriter(o)));

          m.setBufferingOff(false);

          Context context = wm.getContext();

          setupContext(m, context, object, extras);

          template.write(new FastWriter(o, getContentEncoding()), context);

      */

    }

   public final void interpolateTemplateToFile(

       String templateName, 

       File to,

       Unit object) throws WebMacroException, IOException {

     interpolateTemplateToFile(templateName, to, object, null);

   }

    public void interpolateTemplateToFile(

        String templateName,

        File to,

        Unit object,

        Hashtable<String, Object> extras) throws WebMacroException, IOException {

      org.webmacro.Template template = getWebMacro().getTemplate(templateName);

      OutputStream out = new BufferedOutputStream(new FileOutputStream(to));

      try {

        interpolateTemplateToStream(template, out, object, extras);

      } finally {

        try {

          out.close();

        } catch (Exception e) {

          throw new RuntimeException(e);

        }

      }

      notifyNewContentFile(to);

    }

    public void interpolateAsTemplate(Reader in, OutputStream out, Unit object)

        throws WebMacroException, IOException {

      interpolateTemplateToStream(

          new StreamTemplate(getWebMacro().getBroker(), in), out, object);

    }

    public void interpolateAsTemplate(File from, OutputStream out, Unit object)

        throws WebMacroException, IOException {

      Reader in = new BufferedReader(new FileReader(from));

      try {

        interpolateAsTemplate(in, out, object);

      } finally {

        try {

          in.close();

        } catch (Exception e) {

          throw new RuntimeException(e);

        }

      }

    }

    public void interpolateAsTemplate(File from, File to, Unit object)

        throws WebMacroException, IOException {

      OutputStream out = new BufferedOutputStream(new FileOutputStream(to));

      try {

        interpolateAsTemplate(from, out, object);

      } finally {

        try {

          out.close();

        } catch (Exception e) {

          throw new RuntimeException(e);

        }

      }

    }

    public static class TemplateException extends MelatiRuntimeException {

      private static final long serialVersionUID = 1L;

      public File file;

      public TemplateException(File file, Exception trouble) {

        super(trouble);

        this.file = file;

      }

      public String getMessage() {

        return "Couldn't load templet from " + file + "\n" + subException;

      }

    }

    private org.webmacro.Template template(String source) {

      File file = new File(getContentRootDir(), source);

      org.webmacro.Template it =

        new FileTemplate(getWebMacro().getBroker(), file, getContentEncoding());

      try {

        it.parse();

      } catch (Exception e) {

        throw new TemplateException(file, e);

      }

      return it;

    }

    public void writeContentHeader(OutputStream w, Unit object, String template)

      throws WebMacroException, IOException {

      interpolateTemplateToStream(

        template(template == null ? "header.wm" : template),

        w,

        object);

    }

    public void writeContentFooter(OutputStream w, Unit object, String template)

      throws WebMacroException, IOException {

      interpolateTemplateToStream(

        template(template == null ? "footer.wm" : template),

        w,

        object);

    }

    private org.webmacro.Template footnoteTemplate = null;

    public org.webmacro.Template getFootnoteTemplate() {

      if (footnoteTemplate == null)

        footnoteTemplate = template("footnote.wm");

      return footnoteTemplate;

    }

    public String getPasswordReminderMessage() {

      return passwordReminderMessage.getStringCooked();

    }

    public org.webmacro.Template getPasswordReminderTemplate() {

      return new StreamTemplate(

        getWebMacro().getBroker(),

        new StringReader(getPasswordReminderMessage().trim()));

      //        new StringReader(getPasswordReminderMessage().trim()),getContentEncoding());

    }

    public String getPasswordReminderFrom() {

      return passwordReminderFrom.getStringCooked();

    }

    public String getOrderEmailFrom() {

      return orderEmailFrom.getStringCooked();

    }

    public String getConfirmationEmailFrom() {

      return confirmationEmailFrom.getStringCooked();

    }

    public String getOrderEmailTo() {

      return orderEmailTo.getStringCooked();

    }

    public String getStratusEmailTo() {

      return stratusEmailTo.getStringCooked();

    }

    public String getCachedContentRootDir() {

      return getWorkspaceDir() + "/cached";

    }

    public String getStaticRootURL() {

      return staticRootURL.getStringCooked();

    }

    public String getContentStaticRootURL() {

      return contentStaticRootURL.getStringCooked();

    }

    public String getBannerURLPath() {

      return bannerURLPath.getStringCooked();

    }

    public String getCacheRootURL() {

      String it = cacheRootURL.getStringCooked();

      return it == null ? "" : it;

    }

    public String getHomepageURL() {

      return homepageURL.getStringCooked();

    }

    public String getSmtpServer() {

      return smtpServer.getStringCooked();

    }

    public int getDefaultSearchHitsPerText() {

      Integer it = defaultSearchHitsPerText.getIntegerCooked();

      return it == null ? defaultDefaultSearchHitsPerText : it.intValue();

    }

    public int getSearchHitsPerPage() {

      Integer it = searchHitsPerPage.getIntegerCooked();

      return it == null ? defaultSearchHitsPerPage : it.intValue();

    }

    public String getPaginationTexHeader() {

      return paginationTexHeader.getStringCooked();

    }

    public int getBookStockingsCheckIntervalDays() {

      Integer it = bookStockingsCheckIntervalDays.getIntegerCooked();

      return it == null ? defaultBookStockingsCheckIntervalDays : it.intValue();

    }

    public long getBookStockingsCheckIntervalMillis() {

      return (long)getBookStockingsCheckIntervalDays() * 1000L * 60L * 60L * 24L;

    }

    public int getBibBookBookshopSearchTimeoutSeconds() {

      Integer it = bibBookBookshopSearchTimeoutSeconds.getIntegerCooked();

      return it == null

        ? defaultBibBookBookshopSearchTimeoutSeconds

        : it.intValue();

    }

    public long getBibBookBookshopSearchTimeoutMillis() {

      return (long)getBibBookBookshopSearchTimeoutSeconds() * 1000L;

    }

    public int getBookStockingsOutputStartOffset() {

      Integer it = bookStockingsOutputStartOffset.getIntegerCooked();

      return it == null ? defaultBookStockingsOutputStartOffset : it.intValue();

    }

    public String getBookStockingsCacheDir() {

      return bookStockingsCacheDir.getStringCooked();

    }

    public int getBookStockingsCacheSizeMax() {

      Integer it = bookStockingsCacheSizeMax.getIntegerCooked();

      return it == null ? defaultBookStockingsCacheSizeMax : it.intValue();

    }

    public Integer pageFromAnchor(String anchor) {

      if (anchor.startsWith(Pagination.pageAnchorPrefix))

        try {

          return new Integer(

            Integer.parseInt(

              anchor.substring(Pagination.pageAnchorPrefix.length()))

              + 1);

        } catch (NumberFormatException e) {

          return null;

        } else

        return null;

    }

    public static class BookshopException extends MelatiRuntimeException {

      /**

       * 

       */

      private static final long serialVersionUID = 1L;

      public String which;

      public BookshopException(String which, Exception e) {

        super(e);

        this.which = which;

      }

      public String getMessage() {

        return "Something went wrong starting the "

          + which

          + " subsystem\n"

          + subException.getMessage();

      }

    }

    private BookshopBackend bookshopBackendNamed(String packageComp) {

      try {

        return (

          (BookshopBackendFactory)Class

            .forName(

              "org.paneris.bibliomania.metasearch." + packageComp + ".Factory")

            .newInstance())

            .instance(

          new File(getWorkspaceDir()),

          0);

      } catch (Exception e) {

        throw new BookshopException(packageComp, e);

      }

    }

    public Bookshop[] bookshops() {

      return bookshops;

    }

    public SectionGroup getReadSectionGroup() {

      return readSectionGroup;

    }

    public Currency getUKCurrency() {

      return UKCurrency;

    }

    /** Not used, just for show */

    public List<ShopOrder> getUKCurrentcyShopOrders() { 

      return getUKCurrency().getCurrencyShopOrderList();

    }

    public SectionGroup getStudySectionGroup() {

      return studySectionGroup;

    }