<!doctype html>
<!--
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

         https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<html lang="en" prefix="og: https://ogp.me/ns#">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
<title>Website Development</title>
    <!-- Below Meta Tags Generated via https://www.opengraph.xyz -->
    <!-- If you don't care about social media then remove this section -->
    <!-- Values are set in pelicanconf.py -->
    <!-- HTML Meta Tags -->
    <meta name="description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="keywords" content="OpenOffice, Open Office, Apache OpenOffice, Apache Open Office, OpenOffice.org, Developer, Project, Website, Official, Writer, Calc, Impress, Draw, Base, ODF, Open Document Format">
    <!-- Facebook Meta Tags -->
    <meta property="og:url" content="https://openoffice.apache.org">
    <meta property="og:type" content="website">
    <meta property="og:title" content="Apache OpenOffice">
    <meta property="og:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta property="og:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Twitter Meta Tags -->
    <meta name="twitter:card" content="summary_large_image">
    <meta property="twitter:domain" content="openoffice.apache.org">
    <meta property="twitter:url" content="https://openoffice.apache.org">
    <meta name="twitter:title" content="Apache OpenOffice">
    <meta name="twitter:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="twitter:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Above Meta Tags Generated via https://www.opengraph.xyz -->
<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
<link rel="icon" href="/favicon.ico" type="image/x-icon" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body id="index" class="home">
  <div id="banner">
      <div id="bannerleft"><a alt="Apache OpenOffice" href="/">
          <img id="logo" alt="Apache OpenOffice" src="/images/AOO4_website_logo.png" height="60" width="161"/></a></div>
      <div id="bannercenter">The Free and Open Productivity Suite</div>
  </div>
  <div id="clear"></div>
  <nav class="navbar navbar-expand-sm navbar-dark bg-primary">
<button class="navbar-toggler" type="button"
        data-toggle="collapse" data-target="#navbarSupportedContent"
        aria-controls="navbarSupportedContent" aria-expanded="false"
        aria-label="Toggle navigation">
  <span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
  <ul class="navbar-nav mr-auto">
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="generalDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">General</a>
      <ul class="dropdown-menu" aria-labelledby="generalDropdown">
	<li><a class="dropdown-item" href="/index.html">About</a></li>
	<li><a class="dropdown-item" href="/downloads.html">Downloads</a></li>
	<li><a class="dropdown-item" href="/license.html">License</a></li>
	<li><a class="dropdown-item" href="/trademarks.html">Trademarks</a></li>
	<li><a class="dropdown-item" href="/press.html">Press</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/">OpenOffice.org</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="communityDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Community</a>
      <ul class="dropdown-menu" aria-labelledby="communityDropdown">
	<li><a class="dropdown-item" href="/get-involved.html">Get Involved</a></li>
	<li><a class="dropdown-item" href="/orientation/index.html">Orientation</a></li>
	<li><a class="dropdown-item" href="/mailing-lists.html">Mailing Lists</a></li>
	<li><a class="dropdown-item" href="/social.html">Social Networking</a></li>
	<li><a class="dropdown-item" href="/events.html">Events</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/support/">Support</a></li>
	<li><a class="dropdown-item" href="/native-lang.html">Native Language</a></li>
	<li><a class="dropdown-item" href="https://cwiki.apache.org/confluence/display/OOOUSERS/">Planning Wiki</a></li>
	<li><a class="dropdown-item" href="/people.html">People</a></li>
	<li><a class="dropdown-item" href="/community-faqs.html">Community FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="developmentDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Development</a>
      <ul class="dropdown-menu" aria-labelledby="developmentDropdown">
	<li><a class="dropdown-item" href="/source.html">Source Code</a></li>
	<li><a class="dropdown-item" href="/bug-tracking.html">Bug Tracking</a></li>
	<li><a class="dropdown-item" href="/qa.html">Quality Assurance</a></li>
	<li><a class="dropdown-item" href="/translate.html">Translation</a></li>
	<li><a class="dropdown-item" href="/website-local.html">Website</a></li>
	<li><a class="dropdown-item" href="/security.html">Security Reports</a></li>
	<li><a class="dropdown-item" href="/contributing-code.html">Contributing Code</a></li>
	<li><a class="dropdown-item" href="/developer-faqs.html">Developer FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="projectDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Project</a>
      <ul class="dropdown-menu" aria-labelledby="projectDropdown">
	<li><a class="dropdown-item" href="https://blogs.apache.org/OOo/">Project Blog</a></li>
	<li><a class="dropdown-item" href="/pmc-faqs.html">PMC FAQs</a></li>
      </ul>
    </li>
  </ul>
  <div class="navbar-nav" style="padding-top: 0.5rem;">
    <div class="nav-item dropdown dropdown-menu-right active">
      <a class="nav-link dropdown-toggle" href="#"
         role="button" data-toggle="dropdown" aria-haspopup="true"
         aria-expanded="false"><img src="https://www.apache.org/foundation/press/kit/feather.svg"
				    width="32" height="32" class="d-inline-block align-top"
				    alt="Apache Feather">The ASF</a>
      <div class="dropdown-menu dropdown-menu-right">
	<a class="dropdown-item" href="https://www.apache.org/">Website</a>
	<a class="dropdown-item" href="https://www.apache.org/licenses/">License</a>
	<a class="dropdown-item" href="https://www.apache.org/security/">Security</a>
	<a class="dropdown-item" href="https://www.apache.org/events/current-event">Events</a>
	<a class="dropdown-item" href="https://www.openoffice.org/donations.html">Donations</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/thanks.html">Thanks</a>
      </div>
    </div>
  </div>
</div>  </nav>
  <div id="contenta">
    <br/>
    <p>Making updates to the Apache OpenOffice project's websites is simple. It's even easy
for non-committers (new contributors - like you) to create a patch to request that
pages are updated by the project community.</p>
<div id="toc"><ul><li><a class="toc-href" href="#two-websites" title="Two Websites">Two Websites</a></li><li><a class="toc-href" href="#version-control" title="Version Control">Version Control</a></li><li><a class="toc-href" href="#how-to-make-or-request-changes-to-the-websites" title="How To Make or Request Changes to the Websites">How To Make or Request Changes to the Websites</a><ul><li><a class="toc-href" href="#using-svn-directly-for-technical-users" title="Using SVN Directly (for technical users)">Using SVN Directly (for technical users)</a></li><li><a class="toc-href" href="#using-the-apache-cms-bookmarklet-simpler-method" title="Using the Apache CMS Bookmarklet (simpler method)">Using the Apache CMS Bookmarklet (simpler method)</a></li><li><a class="toc-href" href="#more-details" title="More Details">More Details</a></li></ul></li><li><a class="toc-href" href="#publishing-changes-to-the-production-websites" title="Publishing Changes to the Production Websites">Publishing Changes to the Production Websites</a><ul><li><a class="toc-href" href="#for-committers" title="For Committers">For Committers</a></li><li><a class="toc-href" href="#for-contributors-non-committers" title="For Contributors -- non-committers">For Contributors -- non-committers</a></li></ul></li><li><a class="toc-href" href="#complete-local-website-development-for-technical-users-and-committers" title="Complete Local Website Development (for technical users and committers)">Complete Local Website Development (for technical users and committers)</a><ul><li><a class="toc-href" href="#setup" title="Setup">Setup</a><ul><li><a class="toc-href" href="#create-a-directory-on-your-computer-for-the-apache-cms-work-with-both-the-projects" s'="" title="Create a directory on your computer for the Apache CMS work with both the project">Create a directory on your computer for the Apache CMS work with both the project's</a></li><li><a class="toc-href" href="#download-the-svn-repos-for-the-aoo-project-site" title="Download the svn repos for the AOO  project site.">Download the svn repos for the AOO  project site.</a></li><li><a class="toc-href" href="#download-the-svn-repos-for-the-migrated-openofficeorg-website" title="Download the svn repos for the migrated OpenOffice.org website.">Download the svn repos for the migrated OpenOffice.org website.</a></li><li><a class="toc-href" href="#download-the-svn-repos-for-the-apache-cms" title="Download the svn repos for the Apache CMS.">Download the svn repos for the Apache CMS.</a></li><li><a class="toc-href" href="#install-python-dependencies" title="Install Python dependencies.">Install Python dependencies.</a></li><li><a class="toc-href" href="#check-that-your-version-of-python-is-27-or-greater" title="Check that your version of Python is 2.7 or greater">Check that your version of Python is 2.7 or greater</a></li><li><a class="toc-href" href="#follow-the-installation-instructions-for-setuptools" title="Follow the installation instructions for setuptools.">Follow the installation instructions for setuptools.</a></li><li><a class="toc-href" href="#install-dependencies" title="Install dependencies">Install dependencies</a></li></ul></li><li><a class="toc-href" href="#directory-layout" title="Directory Layout">Directory Layout</a><ul><li><a class="toc-href" href="#content-directories" title="Content directories">Content directories</a></li><li><a class="toc-href" href="#templates-directory" title="Templates directory">Templates directory</a></li><li><a class="toc-href" href="#lib-directory" title="Lib directory">Lib directory</a></li><li><a class="toc-href" href="#build-tools" title="Build tools">Build tools</a></li></ul></li><li><a class="toc-href" href="#local-development" title="Local Development">Local Development</a><ul><li><a class="toc-href" href="#edit-the-site" title="Edit the site">Edit the site</a></li><li><a class="toc-href" href="#python-markdown-daemon" title="Python Markdown Daemon">Python Markdown Daemon</a></li><li><a class="toc-href" href="#build-the-sites" title="Build the sites.">Build the sites.</a></li><li><a class="toc-href" href="#copy-the-site-to-an-area-your-computers-web-server" s="" server.'="" title="Copy the site to an area your computer" web="">Copy the site to an area your computer's web server.</a></li></ul></li><li><a class="toc-href" href="#submitting-your-results" title="Submitting your results.">Submitting your results.</a><ul><li><a class="toc-href" href="#committer" title="Committer">Committer</a></li><li><a class="toc-href" href="#contributor" title="Contributor">Contributor</a></li></ul></li></ul></li><li><a class="toc-href" href="#google-analytics" title="Google Analytics">Google Analytics</a></li></ul></div>
<h2 id="two-websites">Two Websites<a class="headerlink" href="#two-websites" title="Permalink">&para;</a></h2>
<p>The Apache OpenOffice project maintains two websites:</p>
<ul>
<li>The <a href="/">project website</a>, primarily for development and technical information (which you're viewing now).
All content for this website uses <a href="http://daringfireball.net/projects/markdown/">Markdown</a> syntax (.mdtext files).</li>
<li>The user portal, <a href="https://www.openoffice.org">www.openoffice.org</a>, primarily for end user information and support.
Content for the user portal primarily uses html, but some content is in
<a href="http://daringfireball.net/projects/markdown/">Markdown</a> syntax (.mdtext files).</li>
</ul>
<blockquote>
<p><strong>The following instructions are obsolete! Both websites have been migrated away from the deprecated Apache CMS!</strong></p>
</blockquote>
<p>Both of these sites use the <a href="https://www.apache.org/dev/cms.html">Apache Content Management System</a> (CMS) to manage editing, submitting changes, and updating the live websites.
In essence, regardless of how you make changes to either web area, the changes first go
the staging sites for these areas, respectively (below), and then are copied to the production websites.</p>
<ul>
<li>The <a href="http://openofficeorg.staging.apache.org/">project staging site</a></li>
<li>The <a href="http://ooo-site.staging.apache.org/">user portal staging site</a></li>
</ul>
<h2 id="version-control">Version Control<a class="headerlink" href="#version-control" title="Permalink">&para;</a></h2>
<p>We use <a href="https://subversion.apache.org">Apache Subversion</a> for version control. You can <a href="https://svn.apache.org/repos/asf/openoffice/site/trunk/">browse the project
repository</a> or <a href="https://svn.apache.org/repos/asf/openoffice/ooo-site/trunk/">browse the user portal repository</a> source files directly in your web browser.</p>
<h2 id="how-to-make-or-request-changes-to-the-websites">How To Make or Request Changes to the Websites<a class="headerlink" href="#how-to-make-or-request-changes-to-the-websites" title="Permalink">&para;</a></h2>
<h3 id="using-svn-directly-for-technical-users">Using SVN Directly (for technical users)<a class="headerlink" href="#using-svn-directly-for-technical-users" title="Permalink">&para;</a></h3>
<p>You can make changes to either site using svn (subversion). This typically involves
doing an svn checkout, making changes to files and --</p>
<ul>
<li>committing your changes
if you are an "Apache committer", or</li>
<li>submitting a "patch" (an svn "diff" file) if you are a contributor but not a "committer".</li>
</ul>
<p>Consult your local svn implementation for how to do commits or create patches. (See also, the <a href="http://svnbook.red-bean.com/">SVN Book</a> ).</p>
<p>Patches, svn "diff" files can be submitted in a variety of ways:</p>
<ul>
<li>
<p>File an issue using <a href="https://bz.apache.org/ooo/">OpenOffice Bugzilla</a> and select the "www"
category to file it. You should then use your saved patch as an attachment to the
issue. Please send a follow-up e-mail to <a href="mailto:dev@openoffice.apache.org">dev</a> and provide the
issue number so we can follow-up.</p>
</li>
<li>
<p>Patches can be submitted as attachments to e-mail to the
<a href="mailto:dev@openoffice.apache.org">Apache OpenOffice developer</a> list.</p>
</li>
</ul>
<p>Changes committed with SVN commit your changes to the "staging area". These changes will need to be published to become active on the "production" site.</p>
<h3 id="using-the-apache-cms-bookmarklet-simpler-method">Using the Apache CMS Bookmarklet (simpler method)<a class="headerlink" href="#using-the-apache-cms-bookmarklet-simpler-method" title="Permalink">&para;</a></h3>
<p>Quick editing of the site is available for committers and contributors using the Apache CMS
<a href="https://cms.apache.org/#bookmark">from your browser.</a> If you are a committer and use the bookmarklet in your web browser, you should use
your Apache credentials to log in, make changes and submit them to staging.
If you are not a committer, you can still use the bookmarklet by signing in to the bookmarklet as <em>anonymous</em>.
See detailed how-to steps in the <a href="https://www.apache.org/dev/cmsref.html#non-committer">Apache CMS Reference</a> for non-committers.</p>
<h3 id="more-details">More Details<a class="headerlink" href="#more-details" title="Permalink">&para;</a></h3>
<p>Additional details on the above methods can be found on  <a href="/docs/edit-cms.html">How to edit the Apache OpenOffice website</a>.</p>
<h2 id="publishing-changes-to-the-production-websites">Publishing Changes to the Production Websites<a class="headerlink" href="#publishing-changes-to-the-production-websites" title="Permalink">&para;</a></h2>
<h3 id="for-committers">For Committers<a class="headerlink" href="#for-committers" title="Permalink">&para;</a></h3>
<p>As previously noted, changes you make, either through an svn commit or using the CMS GUI tool,
are enacted on the staging sites. Once you review your changes on the staging site,
you can "publish" the site -- enacting your changes on the production site. Only Apache "committers" can actually publish sites.</p>
<ul>
<li>You can use the CMS GUI tool to also commit, review, and publish your changes from the
staging site.</li>
<li>Or, you can use the "publish" link for a site from the <a href="https://cms.apache.org/">CMS Web Site</a>
after reviewing it in staging from a "commit" operations.</li>
<li>Or, you can use the command line, <strong>publish.pl "site-name"</strong>. For our purposes,
<strong>"site-name"</strong> will either be <strong>"openofficeorg"</strong> or <strong>"ooo-site"</strong>.</li>
</ul>
<p>Generally speaking, unless you have established a full <strong>Complete Local Website Development</strong> environment as described in the next
section, you will likely be running <strong>publish.pl</strong> from your "people.apache.org" account.</p>
<h3 id="for-contributors-non-committers">For Contributors -- non-committers<a class="headerlink" href="#for-contributors-non-committers" title="Permalink">&para;</a></h3>
<p>If you are not a committer, you will need
to follow the procedures for "contributors" in the
<a href="/developer-faqs.html#im_not_a_committer">Developer FAQ</a>
for getting your changes published by a committer of the project, after you submit a patch.</p>
<h2 id="complete-local-website-development-for-technical-users-and-committers">Complete Local Website Development (for technical users and committers)<a class="headerlink" href="#complete-local-website-development-for-technical-users-and-committers" title="Permalink">&para;</a></h2>
<p>The following information provides instructions on doing website development for either of the OpenOffice websites
on your local computer. If you feel a need to change anything on the websites that effect site processing by the CMS -- e.g. the templates, processing for new file types not included  in /lib/path.pm, additional Django template capabilities, etc. -- you will need to setup a local website development area for testing changes.</p>
<p>These instructions assume you have setup a webserver in your local environment. Details are
provided on setting up the resources needed to process "Markdown" on your local server
and how to publish to the production Apache OpenOffice sites from your local environment.</p>
<ul>
<li><a href="#setup">Setup</a> - How to download the AOO project site repos and setup the Apache CMS.</li>
<li><a href="#directory_layout">Directory Layout</a> - Where to find the content, templates, and scripts.</li>
<li><a href="#local_development">Local Development</a> - How to build and test locally.</li>
<li><a href="#submitting_your_results">Submitting Your Results</a> - How to contribute your edits.</li>
</ul>
<h3 id="setup">Setup<a class="headerlink" href="#setup" title="Permalink">&para;</a></h3>
<h4 id="create-a-directory-on-your-computer-for-the-apache-cms-work-with-both-the-projects">Create a directory on your computer for the Apache CMS work with both the project's<a class="headerlink" href="#create-a-directory-on-your-computer-for-the-apache-cms-work-with-both-the-projects" title="Permalink">&para;</a></h4>
<p>site and the migrating openoffice.org website.</p>
<pre><code>mkdir aoo-web
cd aoo-web
</code></pre>
<h4 id="download-the-svn-repos-for-the-aoo-project-site">Download the svn repos for the AOO  project site.<a class="headerlink" href="#download-the-svn-repos-for-the-aoo-project-site" title="Permalink">&para;</a></h4>
<pre><code>svn co https://svn.apache.org/repos/asf/openoffice/site/trunk site
</code></pre>
<h4 id="download-the-svn-repos-for-the-migrated-openofficeorg-website">Download the svn repos for the migrated OpenOffice.org website.<a class="headerlink" href="#download-the-svn-repos-for-the-migrated-openofficeorg-website" title="Permalink">&para;</a></h4>
<pre><code>svn co https://svn.apache.org/repos/asf/openoffice/ooo-site/trunk ooo-site
</code></pre>
<h4 id="download-the-svn-repos-for-the-apache-cms">Download the svn repos for the Apache CMS.<a class="headerlink" href="#download-the-svn-repos-for-the-apache-cms" title="Permalink">&para;</a></h4>
<pre><code>svn co https://svn.apache.org/repos/infra/websites/cms/ cms
</code></pre>
<p>You will have three sub-directories in your local website directory -- <code>site</code>, <code>ooo-site</code>, and <code>cms</code>.
The "cms" directory will contain scripts needed to build either of the websites using the ASF CMS in a local environment. This is
necessary to see how changes to templates or other ASF CMS internal files will affect the website. See:
<a href="https://www.apache.org/dev/cms.html">https://www.apache.org/dev/cms.html</a> for more information on the
ASF CMS directory structure.</p>
<h4 id="install-python-dependencies">Install Python dependencies.<a class="headerlink" href="#install-python-dependencies" title="Permalink">&para;</a></h4>
<p>Adapted from the <a href="https://www.apache.org/dev/cmsref.html#local-build">Apache CMS Reference</a></p>
<p>The easiest way to install the dependencies is to use Python setuptools.</p>
<h4 id="check-that-your-version-of-python-is-27-or-greater">Check that your version of Python is 2.7 or greater<a class="headerlink" href="#check-that-your-version-of-python-is-27-or-greater" title="Permalink">&para;</a></h4>
<pre><code>python --version
</code></pre>
<h4 id="follow-the-installation-instructions-for-setuptools">Follow the installation instructions for <a href="http://pypi.python.org/pypi/setuptools">setuptools</a>.<a class="headerlink" href="#follow-the-installation-instructions-for-setuptools" title="Permalink">&para;</a></h4>
<h4 id="install-dependencies">Install dependencies<a class="headerlink" href="#install-dependencies" title="Permalink">&para;</a></h4>
<pre><code>sudo easy_install Pygments
sudo easy_install ElementTree
sudo easy_install Markdown
</code></pre>
<h3 id="directory-layout">Directory Layout<a class="headerlink" href="#directory-layout" title="Permalink">&para;</a></h3>
<h4 id="content-directories">Content directories<a class="headerlink" href="#content-directories" title="Permalink">&para;</a></h4>
<p>The <code>site/content/openofficeorg</code> and <code>ooo-site/content/</code> directories contain web content - markdown, html, javascript, css, images and other files. Files that do not fit recognized patterns from <code>site/lib/path.pm</code> or <code>ooo-site/lib/path.pm</code> are copied as is to the web site during the build.</p>
<h4 id="templates-directory">Templates directory<a class="headerlink" href="#templates-directory" title="Permalink">&para;</a></h4>
<p>The <code>site/templates</code> and <code>ooo-site/templates</code> directories contain the html skeletons used during the site build.</p>
<ul>
<li><code>skeleton.html</code> - our current html page template.</li>
<li><code>sidenav.mdtext</code> - markdown of the side navigation panel.</li>
<li><code>html_page.html</code> - wrapping for html pages.</li>
<li><code>single_narrative.html</code> - extends skeleton.html.</li>
</ul>
<p>You may see other template files here as well that are used by Django during the site construction.</p>
<h4 id="lib-directory">Lib directory<a class="headerlink" href="#lib-directory" title="Permalink">&para;</a></h4>
<p>The <code>site/lib</code> and <code>ooo-site/lib</code> directories contain two perl modules that determine how content files are processed during the site build.</p>
<ul>
<li><code>path.pm</code> - maps file patterns like <code>.mdtext</code> into the view building routines. We can expand to cover other patterns.</li>
<li><code>view.pm</code> - a set of python subroutines for converting content into web pages.</li>
</ul>
<h4 id="build-tools">Build tools<a class="headerlink" href="#build-tools" title="Permalink">&para;</a></h4>
<p>You can find the CMS build tools in the <code>cms</code> directory.</p>
<ul>
<li><code>cms/build/</code> - perl scripts for building the site and markdown extensions.</li>
<li><code>cms/conversion-utilities/</code> - scripts used by various projects for conversion including <code>cwiki</code> conversion.</li>
<li><code>cms/webgui/</code> - the webgui behind the <code>bookmarklet</code>.</li>
</ul>
<p>These can be extended locally. Before any changes become part of our process they will need to be cleared with Apache Infrastructure. We'll need to submit patches. These should be additive or be bug fixes.</p>
<p>This area should be updated, via svn update, as changes do take place on these routines.</p>
<h3 id="local-development">Local Development<a class="headerlink" href="#local-development" title="Permalink">&para;</a></h3>
<h4 id="edit-the-site">Edit the site<a class="headerlink" href="#edit-the-site" title="Permalink">&para;</a></h4>
<p>Using your favorite editors edit the site content, templates, and lib scripts.</p>
<h4 id="python-markdown-daemon">Python Markdown Daemon<a class="headerlink" href="#python-markdown-daemon" title="Permalink">&para;</a></h4>
<p>Start the Python Markdown daemon.</p>
<pre><code>export MARKDOWN_SOCKET=`pwd`/markdown.socket PYTHONPATH=`pwd`
python cms/build/markdownd.py
</code></pre>
<h4 id="build-the-sites">Build the sites.<a class="headerlink" href="#build-the-sites" title="Permalink">&para;</a></h4>
<p>Using the directory names from Download sections above --</p>
<pre><code>cms/build/build_site.pl --source-base site --target-base www
cms/build/build_site.pl --source-base ooo-site --target-base www
</code></pre>
<p>This will generate the web content for the project site, "site", or the openoffice site, "ooo-site"
to directory "www".</p>
<h4 id="copy-the-site-to-an-area-your-computers-web-server">Copy the site to an area your computer's web server.<a class="headerlink" href="#copy-the-site-to-an-area-your-computers-web-server" title="Permalink">&para;</a></h4>
<p>On my Mac:</p>
<pre><code>sudo scp -rp www/content /Library/WebServer/Documents/.
</code></pre>
<p>The site is then available with <a href="http://localhost/openofficeorg">http://localhost/openofficeorg/</a> or <a href="http://localhost/">http://localhost/</a></p>
<h3 id="submitting-your-results">Submitting your results.<a class="headerlink" href="#submitting-your-results" title="Permalink">&para;</a></h3>
<h4 id="committer">Committer<a class="headerlink" href="#committer" title="Permalink">&para;</a></h4>
<p>Do the appropriate combination of svn status, svn add, and svn commits. Commits will cause staging rebuilds.
See <a href="https://cms.apache.org/#bookmark">How to Edit the Apache OpenOffice Website</a></p>
<p>Please note that if you have removed any files or directories from your source tree then you must also remove
these from the staging build. The staging for the project site is
<code>https://svn.apache.org/repos/infra/websites/staging/openofficeorg</code>. Check the staging builf out,
svn remove and commit the same files and directories.</p>
<h4 id="contributor">Contributor<a class="headerlink" href="#contributor" title="Permalink">&para;</a></h4>
<p>Use SVN to submit svn "diffs".</p>
<p>For further information see the <a href="https://www.apache.org/dev/version-control.html">Apache Source Code Repository</a> page.</p>
<h2 id="google-analytics">Google Analytics<a class="headerlink" href="#google-analytics" title="Permalink">&para;</a></h2>
<p>We use Google Analytics on key webpages to gather information on website
usage patterns. This information is then used to help us prioritize what
areas of the website should get more attention.</p>
<p>To enable a page for Google Analytics you need to added the following block
of JavaScript immediately before the closing &lt;/head&gt; in the HTML.</p>
<pre><code><script '.google-analytics.com="" 'http:="" 'https:="" 'openoffice.org']);="" 'ua-98607986-1']);="" (function()="" +="" :="" ;="" <="" =="document.location.protocol" ?="" [];="" _gaq="_gaq" _gaq.push(['_setaccount',="" _gaq.push(['_setdomainname',="" _gaq.push(['_trackpageview']);="" code="" ga="document.createElement('script');" ga.async="true;" ga.js';="" ga.src="('https:'" ga.type="text/javascript" s="document.getElementsByTagName('script')[0];" s);="" s.parentnode.insertbefore(ga,="" script&gt;="" ssl'="" type='"text/javascript"&gt;' var="" www')="" {="" ||="" })();=""></script></code></pre>
  </div>

  <footer class="navbar-expand-lg navbar-light bg-light">
    <div class="footer" id="footer">
        <div class="container-fluid">
          Copyright &copy; 2011-2021 The Apache Software Foundation,
          Licensed under the
          <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0.</a> | <a href="/contact.html">Contact Us</a> | <a href="/terms.html">Terms of Use</a> | <a href="/privacy.html">Privacy</a>
          <br/>
          Apache, OpenOffice, OpenOffice.org and the seagull logo are registered trademarks of The Apache Software Foundation.
          The Apache feather logo is a trademark of The Apache Software Foundation.
          Other names appearing on the site may be trademarks of their respective owners.
        </div><!-- #container-fluid -->
        <div class="row container-fluid">
          <div class="col-sm">
            <a href="https://www.apache.org/">
              <img src="https://www.apache.org/img/asf_logo.png" alt="The Apache Software Foundation" style="border: 0; margin-top: 2px" width="200" height="82">
            </a>
          </div>
          <div class="col-sm center-align">
            <a href="https://www.apache.org/foundation/contributing.html">
              <img src="https://www.apache.org/images/SupportApache-small.png" alt="Support The ASF" height="80" width="80">
            </a>
          </div>
          <div class="col-sm right-align">
            <a class="acevent" data-format="wide" data-mode="light" data-event="random"></a>
          </div>
        </div>
    </div>
  </footer>
  <!-- Start load of stylesheets (will need to upgrade periodically) -->
  <link rel="stylesheet"
	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
	crossorigin="anonymous">
  <link rel="stylesheet"
	href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/3.0.1/github-markdown.min.css"
	crossorigin="anonymous">
  <link href="/theme/css/openoffice.css" rel="stylesheet" type="text/css">
  <!-- End stylesheets -->
  <!-- Start the loading of javascript frameworks (will need to upgrade periodically) -->
  <script src="https://www.apachecon.com/event-images/snippet.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.slim.min.js"
	  integrity="sha512-6ORWJX/LrnSjBzwefdNUyLCMTIsGoNP6NftMy2UAm1JBm6PRZCO1d7OHBStWpVFZLO+RerTvqX/Z9mBFfCJZ4A=="
	  crossorigin="anonymous"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
	  integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1"
	  crossorigin="anonymous"></script>
  <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
	  integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
	  crossorigin="anonymous"></script>
  <!-- End the loading of javascript frameworks -->

  <!-- Source: website-local.md; Template: page; Url: website-local.html -->
</body>
</html>