<?xml version="1.0" encoding="UTF-8"?>
<!--
   Licensed 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

       http://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.
 -->
<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="website.xsd">

	<properties>
		<title>Commercial Support</title>
		<author email="sebawagner@apache.org">
			OpenMeetings Team
		</author>
	</properties>

	<body>

		<section name="Commercial Support for OpenMeetings">

			<p>There are few companies offering complex services for OpenMeetings, including code support,
			development, integration and bug fixing
			</p>
			<ul>
				<li>
					<a href="http://www.webbase-design.de/" target="_BLANK">webbase-design.de
					</a>
					owned by Sebastian Wagner
				</li>
				<li>
					<a href="http://www.dataved.ru" target="_BLANK">dataved.ru
					</a>
					run by Alexei Fedotov, Maxim Solodovnik, Timur Tleukenov, Irina Arkhipets, Denis Kandrov, Vasily Degtyarev
				</li>
				<li>
                    <a href="http://www.samoo.es" target="_BLANK" rel="nofollow">samoo.es</a>
                    provides support for the Sakai Plugin
                </li>
			</ul>
			<p>
                            Please write to <a href="mailto:support-om@dataved.ru">support-om@dataved.ru</a> to get WebBase-Design or Dataved support
			</p>
			<p>
			    There are more companies offering installation, customization, hosting, conferencing and support services. You can add 
				yourself to the <a href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Commercial+Support">wiki page</a>.
			</p>
			
			<p>
				Want to get listed here? Become a <a href="http://www.apache.org/dev/committers.html">committer</a>.
			</p>
		</section>

	</body>

</document>