<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE module [
  <!ELEMENT module (dtdversion,name,version,description*,help*,about*,requires*,file+)>
  <!ELEMENT dtdversion (#PCDATA)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT version (#PCDATA)>
  <!ELEMENT mincmsversion (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT help (#PCDATA)>
  <!ELEMENT about (#PCDATA)>
  <!ELEMENT requires (requiredname,requiredversion)>
  <!ELEMENT requiredname (#PCDATA)>
  <!ELEMENT requiredversion (#PCDATA)>
  <!ELEMENT file (filename,isdir,data)>
  <!ELEMENT filename (#PCDATA)>
  <!ELEMENT isdir (#PCDATA)>
  <!ELEMENT data (#PCDATA)>
]>
<module>
	<dtdversion>1.3</dtdversion>
	<name>Uploads</name>
	<version>1.2.3</version>
  <mincmsversion>1.0-svn</mincmsversion>
	<help>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</help>
	<about><br />Author: calguy1000 &lt;rob@techcom.dyndns.org&gt;<br /><br />Version: 1.2.3<br /><br />Change History:<br /><ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added "summarylink", and "category" to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added "random" sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering on the frontend, and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to enter a blank path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
</li>
<li>
<p>Version 1.2.1 - April, 2006</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
<p>Added the upload_template, summary_template, and detail_template (optional) parameter</p>
<p>Added the noauthor parameter, and the key parameter.  The key parameter allows the uploads module to be embedded into other modules</p>
<p>Moved to under the content menu, and entitled 'Files (Upload Module)'</p>;
</li>
<li>
<p>Version 1.2.2 - June, 2006
<p>Added the ability to have multiple database templates, and to select one on the tag with the template parameter.</p>
<p>Fixed an issue where files were getting corrupted on download</p>
</li>
<li>
<p>Version 1.2.3 - June, 2006
<p>Fixes to use adodb-lite proper, rather than teds hack</p>
<p>Detail link now displays inline</p>
<p>Other minor tweaks that I cant remember</p>
</li>
</ul><br /></about>
	<description>A module that allows users to upload files, and allows you to manage them.</description>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Uploads -= allow users to upload stuff, a pseudo file manager" module
# Author: Robert Campbell <rob@techcom.dyndns.org>
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2005 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http:	//www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
$tmp_params = array();
if (isset ($params['hidden_params']) )
  {
    $tmp_params = $this->explode_with_key($params['hidden_params']);
  }
$params = array_merge( $params, $tmp_params );
// check for required arguments
if (!isset ($params['mode']) )
  {
    // if mode or category isn't set... we don't display anything
    $this->_DisplayErrorPage ($id, $params, $returnid,
			      $this->Lang ('error_insufficientparams'));
    return;
  }
        
// setup
$template = '';
$filetemplate = false;
$db =& $this->GetDb();
$rowarray = array ();

// mode is set, now decide what to do
// handle sthe simple stuff (one single link)
if ($params['mode'] == 'upload')
  {
    if( !isset( $params['category'] ) )
      {
	// if mode or category isn't set... we don't display anything
	$this->_DisplayErrorPage ($id, $params, $returnid,
				  $this->Lang ('error_insufficientparams'));
	return;
      }

    // display a form to allow the user to upload a file.... but may have to have permission first
    // hmmm, I'll think about the permission stuff later.
    $template = 'uploadform_default';
    if( isset( $params['template'] ) )
      {
	$template = 'uploadform_'.$params['template'];
      }

    $this->smarty->assign ('startform',
			   $this->CreateFormStart ($id, 'do_upload',$returnid,'post', 'multipart/form-data'));
    $this->smarty->assign ('prompt_upload', $this->Lang ('upload'));

    // is there a key
    if( isset( $params['key'] ) )
      {
	$this->smarty->assign('input_key',
			      $this->CreateInputHidden($id, 'input_key', $params['key']));
      }

    // attempt to get an author
    $author = '';
    $userid = $this->GetModuleInstance('FrontEndUsers');
    if( $userid )
      {
	$author = $userid->LoggedInName();
      }

    if( isset( $params['noauthor'] ) )
      {
	$this->smarty->assign('input_author',
			      $this->CreateInputHidden($id, 'input_author', $author));
	$this->smarty->assign('noauthor',1);
						       
      }
    else
      {
	$this->smarty->assign ('prompt_author', $this->Lang ('author'));
	$this->smarty->assign ('input_author',
			       $this->CreateInputText ($id, 'input_author', 
						       $author, 20, 255));
      }
    $this->smarty->assign ('prompt_summary',
			   $this->Lang ('summary'));
    $this->smarty->assign ('input_summary',
			   $this->CreateInputText ($id, 'input_summary',
						   '', 40, 255));
    $this->smarty->assign ('prompt_destname',
			   $this->Lang ('destname'));
    $this->smarty->assign ('input_destname',
			   $this->CreateInputText ($id, 'input_destname',
						   '', 40, 255));
    $this->smarty->assign ('info_destname',
			   $this->Lang ('info_destname'));

    $this->smarty->assign ('prompt_description',
			   $this->Lang ('description'));
    $this->smarty->assign ('input_description',
			   $this->CreateTextArea(false, $id, '', 'input_description' ));
    $hidden = 
      $this->CreateInputHidden ($id, 'MAX_FILE_SIZE',
				$this->GetPreference('max_uploadsize','1000000')).
      $this->CreateInputHidden( $id, 'category',
				$params['category']); 
    if( isset( $params['file_extensions'] ) )
      {
	$hidden .= 
	  $this->CreateInputHidden( $id, 'file_extensions',
				    $params['file_extensions'] );
      }
    $this->smarty->assign ('hidden', $hidden );
    $this->smarty->assign ('input_browse',
			   $this->CreateFileUploadInput ($id,'input_browse'));
    $this->smarty->assign('prompt_replace', $this->Lang('prompt_replace'));
    $this->smarty->assign('input_replace', 
			  $this->CreateInputCheckbox( $id, 'input_replace', 1 ));
    $this->smarty->assign('info_replace',
			  $this->Lang('info_replace'));
    $this->smarty->assign ('prompt_thumbnail',
			   $this->Lang ('thumbnail'));
    $this->smarty->assign ('info_thumbnail',
			   $this->Lang ('info_thumbnail'));
    $this->smarty->assign ('input_thumbnail',
			   $this->CreateFileUploadInput ($id,'input_thumbnail'));
    $this->smarty->assign ('input_submit',$this->CreateInputSubmit ($id, 'do_uploadfile',
								    $this->Lang ('submit')));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());
  }
 else
   {
     $key = null;
     if( isset( $params['key'] ) )
       {
	 $key = $params['key'];
       }

     if( !isset( $params['category'] ) )
       {
	 // if mode or category isn't set... we don't display anything
	 $this->_DisplayErrorPage ($id, $params, $returnid,
				   $this->Lang ('error_insufficientparams'));
	 return;
       }

     // try to figure out a sort order
     $sortorder = "ORDER BY upload_date ASC";
     if( isset($params['sortorder']) ) {
       switch( $params['sortorder'] ) {
       case "date_asc":
	 // ascending date
	 $sortorder = "ORDER BY upload_date ASC";
	 break;
       case "date_desc":
	 // descending date
	 $sortorder = "ORDER BY upload_date DESC";
	 break;
       case "name_asc":
	 // ascending name
	 $sortorder = "ORDER BY upload_name ASC";
	 break;
       case "name_desc":
	 // descending name
	 $sortorder = "ORDER BY upload_name DESC";
	 break;
       case "size_asc":
	 // ascending size
	 $sortorder = "ORDER BY upload_size ASC";
	 break;
       case "size_desc":
	 // descending size
	 $sortorder = "ORDER BY upload_size DESC";
	 break;
       case "summ_asc":
	 // ascending summary
	 $sortorder = "ORDER BY upload_summary ASC";
	 break;
       case "summ_desc":
	 // descending summary
	 $sortorder = "ORDER BY upload_summary DESC";
	 break;
       case "author_asc":
	 // ascending author
	 $sortorder = "ORDER BY upload_author ASC";
	 break;
       case "author_desc":
	 // descending author
	 $sortorder = "ORDER BY upload_author DESC";
	 break;
       case "ip_asc":
	 // ascending ip
	 $sortorder = "ORDER BY upload_ip ASC";
	 break;
       case "ip_desc":
	 // descending ip
	 $sortorder = "ORDER BY upload_ip DESC";
	 break;
       case "random":
	 // random
	 $sortorder = "ORDER BY rand()";
       }
     }
     $sortorder = " ".$sortorder;

     // determine how many we're going to display
     $count = "";
     if( isset( $params['count'] ) )
       {
	 $count = " LIMIT 0,".$params['count'];
       }

     // get the category id
     $category = array();
     if( $params['category'] != 'all' )
       {
	 $category = $this->getCategoryFromName( $params['category'] );
	 if( !$category )
	   {
	     $this->_DisplayErrorPage ($id, $params, $returnid,
				       $this->Lang ('error_categorynotfound'));
	     return;
	   }
       }

     // get the filter string
     $filter = '';
     if( isset($params['input_filter']) && $params['input_filter'] != '' )
       {
	 $filter = $params['input_filter'];
       }
     if( $filter == '' )
       {
	 unset($params['hidden_params']);
       }
     
     if( (isset($params['filter']) && $params['filter'] == 'yes') )
       {
	 // optionally display the filter form
	 $this->smarty->assign('startform', $this->CreateFormStart($id,'default',$returnid,
								   $method='post', '', true));
	 $this->smarty->assign('prompt_filter',$this->Lang('filter'));
	 $this->smarty->assign('input_filter',
			       $this->CreateInputText($id,'input_filter',$filter,15));
	 $this->smarty->assign('input_submit',
			       $this->CreateInputSubmit($id,'input_submit',
							$this->Lang('submit')));
	 unset( $params['input_filter'] );
	 $this->smarty->assign('hidden_params',
			       $this->CreateInputHidden($id,'hidden_params',
							$this->implode_with_key($params)));
	 $this->smarty->assign('endform',$this->CreateFormEnd());
       }

     $do_query = true;
     if( (isset( $params['no_initial'] ) && $params['no_initial'] != '') &&
	 (isset( $params['hidden_params']) == false) )
       {
	 $do_query = false;
       }

     // adjust the filter
     $adjusted_filter = $filter;
     if( $filter != '' && !isset($params['use_strict_regex']) )
       {
	 $adjusted_filter = str_replace( ' ', '.*', $adjusted_filter );
       }

     // get ready for array processing
     $rowarray = array();
     $query = '';
     $dbresult = $false;
     
     if( $params['category'] == 'all' )
       {
	 // handle display all listable categories
	 $qparms = array();
	 $query = "SELECT upload_id, A.upload_category_id AS 
                  upload_category_id, upload_name, upload_author, upload_summary, upload_description,
                  upload_ip, upload_size, upload_date, upload_category_name FROM ".cms_db_prefix()."module_uploads_categories AS A,".
	   cms_db_prefix()."module_uploads AS B WHERE upload_category_listable = 1";
	 if( $key != null )
	   {
	     $query .= " AND upload_key = ?";
	     $qparms[] = $key;
	   }
	 if( $adjusted_filter != '' )
	   {
	     $query .= "AND upload_name REGEXP ? ";
	     $qparms[] = $adjusted_filter;
	   }
	 $query .= "AND A.upload_category_id = B.upload_category_id".$sortorder.$count;     
	 
	 switch( $params['mode'] )
	   {
	   case 'detailed':
	     $template = 'detailrpt_default';
             if( isset( $params['template'] ) )
	       {
		 $template = 'detailrpt_'.$params['template'];
	       }
	     break;
	     
	   case 'summary':
 	     $template = 'upload_displaysummary';
             if( isset( $params['template'] ) )
	       {
		 $template = 'summaryrpt_'.$params['template'];
	       }
	     break;
	   }
	 $dbresult = $db->Execute( $query, $qparms );
       }
     else {
       // if the category isn't listable, we can stop here
       if( $category['upload_category_listable'] == 0 ) {
	 return;
       }
       $category_id = $category['upload_category_id'];
       $catpath1 = $this->getCategoryPathFromID($category_id);

       // we're gonna scan the directory and see if anybody uploaded
       // any files via ftp or scp or anything silly.
       $this->SmartScanDirectory( $category_id, $catpath1 );

       if ($params['mode'] == 'detailed')
	 {
	   // a brief listing of all the files in the category
	   $qparms = array();
	   $qparms[] = $category_id;
	   $template = 'detailrpt_default';
	   if( isset( $params['template'] ) )
	     {
	       $template = 'detailrpt_'.$params['template'];
	     }
	   $query =
	     "SELECT * FROM ".cms_db_prefix ().
	     "module_uploads WHERE upload_category_id = ?";
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   if( $adjusted_filter != '' )
	     {
	       $query .= " AND upload_name REGEXP ?";
	       $qparms[] = $adjusted_filter;
	     }
	   $query .= $sortorder.$count;
	   $dbresult = $db->Execute ($query, $qparms);
	 }
       else if ($params['mode'] == 'single')
	 {
	   // display info about a single file, in expanded form
	   if( !isset($params['upload_id']) ) {
	     $this->_DisplayErrorPage ($id, $params, $returnid,
				       $this->Lang ('error_insufficientparams'));
	     return;
	   }
	       
	   $template = 'detailrpt_default';
	   if( isset( $params['template'] ) )
	     {
	       $template = 'detailrpt_'.$params['template'];
	     }
	   $query =
	     "SELECT * FROM ".cms_db_prefix().
	     "module_uploads WHERE upload_category_id = ?"." AND upload_id = ?";
	   $qparms = array( $category_id, $params['upload_id'] );
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   $dbresult =
	     $db->Execute ($query, $qparms );
	 }
       else if ($params['mode'] == 'singlesummary')
	 {
	   if( !isset($params['upload_id']) ) {
	     $this->_DisplayErrorPage ($id, $params, $returnid,
				       $this->Lang ('error_insufficientparams'));
	     return;
	   }
	       
	   $template = 'summaryrpt_default';
	   if( isset( $params['template'] ) )
	     {
	       $template = 'summaryrpt_'.$params['template'];
	     }
	   $query =
	     "SELECT * FROM ".cms_db_prefix().
	     "module_uploads WHERE upload_category_id = ?"." AND upload_id = ? AND";
	   $qparms = array($category_id, $params['upload_id']);
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   $dbresult = $db->Execute ($query, $qparms );
	 }
       else if ($params['mode'] == "link")
	 {
	   $template = '';
	   $query = 
	     "SELECT * FROM ".cms_db_prefix().
	     "module_uploads WHERE upload_category_id = ?"." AND upload_id = ?";
	   $qparms = array( $category_id, $params['upload_id'] );
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   $dbresult = $db->Execute ($query, $qparms );
	   $row = $dbresult->FetchRow();
	   echo $this->CreateFrontendLink ($id, $returnid, 'getfile', $row['upload_name'],
					   array ('showtemplate' => 'false', 'upload_id' => $row['upload_id']));
	 }
       else if ($params['mode'] == 'url')
	 {
	   // output just a url
	   if( !isset($params['upload_id']) ) {
	     $this->_DisplayErrorPage ($id, $params, $returnid,
				       $this->Lang ('error_insufficientparams'));
	     return;
	   }
	       
	   $template = '';
	   $query = 
	     "SELECT * FROM ".cms_db_prefix().
	     "module_uploads WHERE upload_category_id = ?"." AND upload_id = ?";
	   $qparms = array( $category_id, $params['upload_id'] );
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   $dbresult = $db->Execute ($query, $qparms );
	   $row = $dbresult->FetchRow();
	   echo $this->CreateLink ($id, 'getfile', $returnid, '', 
				   array ('showtemplate'=>'false', 'upload_id' => $row['upload_id']), '', true);
	 }
       else if ($params['mode'] == 'summary')
	 {
	   // display info about all of the files in the category
	   $template = 'summaryrpt_default';
	   if( isset( $params['template'] ) )
	     {
	       $template = 'summaryrpt_'.$params['template'];
	     }
	   $qparms = array($category_id);
	   $query =
	     "SELECT * FROM ".cms_db_prefix().
	     "module_uploads WHERE upload_category_id = ?";
	   if( $key != null )
	     {
	       $query .= " AND upload_key = ?";
	       $qparms[] = $key;
	     }
	   if( $adjusted_filter != '' )
	     {
	       $query .= " AND upload_name REGEXP ?";
	       $qparms[] = $adjusted_filter;
	     }
	   $query .= $sortorder.$count;
	   $dbresult = $db->Execute ($query, $qparms);
	 }
     }

     $this->smarty->assign('matchestext',$this->Lang('matchesfound'));

     $matches = 0;

     if( $do_query == true )
       {
       if( $dbresult && $dbresult->RecordCount() )
         {
  	   $matches = $dbresult->RecordCount();
         }

	 // setup strings
	 $this->smarty->assign('category',$this->Lang('category'));
	 $this->smarty->assign('id',$this->Lang('id'));
	 $this->smarty->assign('name',$this->Lang('name'));
	 $this->smarty->assign('date',$this->Lang('date'));
	 $this->smarty->assign('author',$this->Lang('author'));
	 $this->smarty->assign('size',$this->Lang('sizekb'));
	 $this->smarty->assign('details',$this->Lang('details'));
	 $this->smarty->assign('summary',$this->Lang('summary'));
	 $this->smarty->assign('description',$this->Lang('description'));
	 $this->smarty->assign('thumbnail',$this->Lang('thumbnail'));

	 if (!$dbresult)
	   {
	     // maybe there are no files in this category
	     $this->smarty->assign ('message', $this->Lang ('error_nofiles'));
	   }
	 else if( $template != '' ) 
	   {
	     // do the list
	     $rowclass = 'row1';
	     while ($row = $dbresult->FetchRow ())
	       {
		 $onerow = new stdClass ();
		 $onerow->id = $row['upload_id'];
		 if( $params['category'] == 'all' )
		   {
		     $onerow->category = $row['upload_category_name'];
		   }
		 else 
		   {
		     $onerow->category = $params['category'];
		   }
		 $onerow->download_url =
		   $this->CreateLink ($id, 'getfile', $returnid, '', 
				      array ('showtemplate'=>'false','upload_id' => $row['upload_id']), '', true );
		 $onerow->name =
		   $this->CreateLink ($id, 'getfile', $returnid, $row['upload_name'],
				      array ('showtemplate'=>'false','upload_id' => $row['upload_id']));
		 $onerow->author = $row['upload_author'];
		 $onerow->detaillink =
		   $this->CreateFrontendLink ($id, $returnid, 'default', $this->Lang('details'),
				      array('mode' => 'single',
					    'upload_id' => $row['upload_id'],
					    'category' => $params['category']));
		 $onerow->summary = $row['upload_summary'];
		 if( isset( $row['upload_summary'] ) && $row['upload_summary'] != "" )
		   {
		     $onerow->summarylink =
		       $this->CreateLink ($id, 'getfile', $returnid, $row['upload_summary'],
					  array ('showtemplate'=>'false','upload_id' => $row['upload_id']));
		   }
		     
		 // thumbnail
		 $catpath = $this->getCategoryPathFromFileID($row['upload_id']);
		 $tnfile = $this->_categoryPath( $catpath.DIRECTORY_SEPARATOR.
						 '.thumbs'.DIRECTORY_SEPARATOR.$row['upload_id'].'_thumb');
		 if( file_exists( $tnfile ) )
		   {
		     $tnurl = $this->cms->config['uploads_url']."/".$catpath.'/.thumbs/'.$row['upload_id'].'_thumb';
		     $onerow->thumbnail_url = $tnurl;
		   }

		 $onerow->description = $row['upload_description'];
		 $onerow->ip = $row['upload_ip'];
		 $onerow->size = intval($row['upload_size'] / 1024.0 + 0.5);
		 $onerow->date = $row['upload_date'];
		 $onerow->rowclass = $rowclass;
		     
		 array_push ($rowarray, $onerow);
		 ($rowclass == "row1" ? $rowclass = "row2" : $rowclass = "row1");
	       }
		 
	     $this->smarty->assign ('items', $rowarray);
	     $this->smarty->assign ('itemcount', count($rowarray));
	   }
       }
   }

   $this->smarty->assign( 'matches', $matches );

   // Display the populated template
   echo $this->ProcessTemplateFromDatabase ($template);


?>
]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.deletetemplate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCiAgaWYoICEgJHRoaXMtPkNoZWNrUGVybWlzc2lvbignTW9kaWZ5IFRlbXBsYXRlcycpICkKICAgIHsKICAgICAgLy8gdG9kbywgcGVybWlzc2lvbnMgbWVzc2FnZSBoZXJlCiAgICAgIHJldHVybjsKICAgIH0KCiAgaWYoICEoaXNzZXQoJHBhcmFtc1sndGVtcGxhdGUnXSkpICkKICAgIHsKICAgICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwgCgkJCQkkdGhpcy0+TGFuZygnZXJyb3JfaW5zdWZmaWNpZW50cGFyYW1zJykpOwogICAgICByZXR1cm47CiAgICB9CgogICR0aGlzLT5EZWxldGVUZW1wbGF0ZSgkcGFyYW1zWyd0ZW1wbGF0ZSddKTsKICAkdGhpcy0+bXlSZWRpcmVjdFRvVGFiKCRpZCwgJ3VwbG9hZGZvcm1fdGVtcGxhdGUnKTsKCj8+]]></data>
	</file>
	<file>
	  <filename>/action.do_addcategory.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.do_addtemplate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCiAgaWYoIGlzc2V0KCAkcGFyYW1zWydjYW5jZWwnXSApICkKICAgIHsKICAgICAgJHRoaXMtPm15UmVkaXJlY3RUb1RhYigkaWQsICd1cGxvYWRmb3JtX3RlbXBsYXRlJyk7CiAgICB9CgogIGlmKCAhICR0aGlzLT5DaGVja1Blcm1pc3Npb24oJ01vZGlmeSBUZW1wbGF0ZXMnKSApCiAgICB7CiAgICAgIC8vIHRvZG8sIHBlcm1pc3Npb25zIG1lc3NhZ2UgaGVyZQogICAgICByZXR1cm47CiAgICB9CgogICR0ZW1wbGF0ZSA9ICIiOwogIGlmKCBpc3NldCggJHBhcmFtc1sndGVtcGxhdGUnXSApICkKICAgIHsKICAgICAgJHRlbXBsYXRlID0gdHJpbSgkcGFyYW1zWyd0ZW1wbGF0ZSddKTsKICAgIH0KICAKICAkcHJlZml4ID0gIiI7CiAgaWYoIGlzc2V0KCAkcGFyYW1zWydwcmVmaXgnXSApICkKICAgIHsKICAgICAgJHByZWZpeCA9IHRyaW0oJHBhcmFtc1sncHJlZml4J10pOwogICAgfQoKICBpZiggIWlzc2V0KCAkcGFyYW1zWyd0ZW1wbGF0ZWNvbnRlbnQnXSApICkKICAgIHsKICAgICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwgCgkJCQkkdGhpcy0+TGFuZygnZXJyb3JfaW5zdWZmaWNpZW50cGFyYW1zJykpOwogICAgICByZXR1cm47CiAgICB9CgogIGlmKCAkdGVtcGxhdGUgPT0gIiIgfHwgJHByZWZpeCA9PSAiIiApCiAgICB7CiAgICAgICR0aGlzLT5fRGlzcGxheUVycm9yUGFnZSggJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQsIAoJCQkJJHRoaXMtPkxhbmcoJ2Vycm9yX2luc3VmZmljaWVudHBhcmFtcycpKTsKICAgICAgcmV0dXJuOwogICAgfQoKICAkbmV3dGVtcGxhdGUgPSAkcHJlZml4IC4gJHRlbXBsYXRlOwoKICAvLyBjaGVjayBpZiB0aGlzIHRlbXBsYXRlIGFscmVhZHkgZXhpc3RzCiAgJHR4dCA9IHRyaW0oJHRoaXMtPkdldFRlbXBsYXRlKCRuZXd0ZW1wbGF0ZSkpOwogIGlmKCAkdHh0ICE9ICIiICkKICAgIHsKICAgICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwgCgkJCQkkdGhpcy0+TGFuZygnZXJyb3JfdGVtcGxhdGVuYW1lZXhpc3RzJykpOwogICAgICByZXR1cm47CiAgICB9CgogIC8vIHdlJ3JlIHJlYWR5IHRvIHNldCBpdAogICR0aGlzLT5TZXRUZW1wbGF0ZSgkbmV3dGVtcGxhdGUsJHBhcmFtc1sndGVtcGxhdGVjb250ZW50J10pOwogICR0aGlzLT5teVJlZGlyZWN0VG9UYWIoJGlkLCAndXBsb2FkZm9ybV90ZW1wbGF0ZScpOwo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.do_edittemplate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCiAgaWYoIGlzc2V0KCAkcGFyYW1zWydjYW5jZWwnXSApICkKICAgIHsKICAgICAgJHRoaXMtPm15UmVkaXJlY3RUb1RhYigkaWQsICd1cGxvYWRmb3JtX3RlbXBsYXRlJyk7CiAgICB9CgogIGlmKCAhICR0aGlzLT5DaGVja1Blcm1pc3Npb24oJ01vZGlmeSBUZW1wbGF0ZXMnKSApCiAgICB7CiAgICAgIC8vIHRvZG8sIHBlcm1pc3Npb25zIG1lc3NhZ2UgaGVyZQogICAgICByZXR1cm47CiAgICB9CgogIGlmKCAhaXNzZXQoICRwYXJhbXNbJ3RlbXBsYXRlY29udGVudCddICkgKQogICAgewogICAgICAkdGhpcy0+X0Rpc3BsYXlFcnJvclBhZ2UoICRpZCwgJHBhcmFtcywgJHJldHVybmlkLCAKCQkJCSR0aGlzLT5MYW5nKCdlcnJvcl9pbnN1ZmZpY2llbnRwYXJhbXMnKSk7CiAgICAgIHJldHVybjsKICAgIH0KCiAgaWYoICFpc3NldCggJHBhcmFtc1sndGVtcGxhdGUnXSApICkKICAgIHsKICAgICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwgCgkJCQkkdGhpcy0+TGFuZygnZXJyb3JfaW5zdWZmaWNpZW50cGFyYW1zJykpOwogICAgICByZXR1cm47CiAgICB9CgogICR0aGlzLT5TZXRUZW1wbGF0ZSggJHBhcmFtc1sndGVtcGxhdGUnXSwgJHBhcmFtc1sndGVtcGxhdGVjb250ZW50J10gKTsKICAkdGhpcy0+bXlSZWRpcmVjdFRvVGFiKCRpZCwgJ3VwbG9hZGZvcm1fdGVtcGxhdGUnKTsKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.edittemplate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.getfile.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBNb2R1bGU6IFVwbG9hZHMgLT0gYWxsb3cgdXNlcnMgdG8gdXBsb2FkIHN0dWZmLCBhIHBzZXVkbyBmaWxlIG1hbmFnZXIiIG1vZHVsZQojIEF1dGhvcjogUm9iZXJ0IENhbXBiZWxsIDxyb2JAdGVjaGNvbS5keW5kbnMub3JnPgojCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiMgQ01TIC0gQ01TIE1hZGUgU2ltcGxlIGlzIChjKSAyMDA1IGJ5IFRlZCBLdWxwICh3aXNoeUBjbXNtYWRlc2ltcGxlLm9yZykKIyBUaGlzIHByb2plY3QncyBob21lcGFnZSBpczogaHR0cDovL3d3dy5jbXNtYWRlc2ltcGxlLm9yZwojCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiMKIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQojIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKIyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgojCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiMgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKIyBPciByZWFkIGl0IG9ubGluZTogaHR0cDoJLy93d3cuZ251Lm9yZy9saWNlbnNlcy9saWNlbnNlcy5odG1sI0dQTAojCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgogICAgaWYoICFpc3NldCggJHBhcmFtc1sndXBsb2FkX2lkJ10gKSApCiAgICAgIHsKCS8vIHRvZG8gZGlzcGxheSBlcnJvcgoJJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlICgkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwKCQkJCSAkdGhpcy0+TGFuZyAoJ2Vycm9yX2luc3VmZmljaWVudHBhcmFtcycpKTsKICAgICAgfQoKICAgIC8vIGdldCB0aGUgaWQKICAgICRmaWxlX2lkID0gJHBhcmFtc1sndXBsb2FkX2lkJ107CiAgICAKICAgIC8vIGdldCB0aGUgZGV0YWlscwogICAgJGZpbGVfZGV0YWlscyA9ICR0aGlzLT5fZ2V0VXBsb2FkRmlsZURldGFpbHMoICRmaWxlX2lkICk7CiAgICBpZiggISRmaWxlX2RldGFpbHNbJ3VwbG9hZF9uYW1lJ10gKSAKICAgICAgewoJLy8gdG9kbyBkaXNwbGF5IGVycm9yCgkkdGhpcy0+X0Rpc3BsYXlFcnJvclBhZ2UoICRpZCwgJHBhcmFtcywgJHJldHVybmlkLAoJCQkJICAkdGhpcy0+TGFuZyggJ2Vycm9yX2ZpbGVub3Rmb3VuZCcsICRmaWxlX2lkICkgKTsKCXJldHVybjsKICAgICAgfQogICAgJGNhdGVnb3J5X2RldGFpbHMgPSAkdGhpcy0+X2dldFVwbG9hZENhdGVnb3J5RGV0YWlscyggJGZpbGVfZGV0YWlsc1sndXBsb2FkX2NhdGVnb3J5X2lkJ10gKTsKICAgICRwYXRoID0gJy8nOwogICAgaWYoICEkY2F0ZWdvcnlfZGV0YWlsc1sndXBsb2FkX2NhdGVnb3J5X3BhdGgnXSApIAogICAgICB7CgkvLyB0b2RvIGRpc3BsYXkgZXJyb3IKCSR0aGlzLT5fRGlzcGxheUVycm9yUGFnZSggJGlkLCAkcGFyYW1zLCAkcmV0dXJuaWQsCgkJCQkgJHRoaXMtPkxhbmcoICdlcnJvcl9kYmVycm9yJyApICk7CglyZXR1cm47CiAgICAgIH0KCiAgICAKICAgICRmaWxlID0gJHRoaXMtPl91cGxvYWRQYXRoKCAkY2F0ZWdvcnlfZGV0YWlsc1sndXBsb2FkX2NhdGVnb3J5X3BhdGgnXSwKCQkJICAgICAgIHN0cl9yZXBsYWNlKCBhcnJheSgnICcsJyUyMCcpLGFycmF5KCdfJywnXycpLCRmaWxlX2RldGFpbHNbJ3VwbG9hZF9uYW1lJ10gKSApOwogICAgCiAgICBpZiggIWZpbGVfZXhpc3RzKCAkZmlsZSApIHx8ICFpc19yZWFkYWJsZSggJGZpbGUgKSApCiAgICAgIHsKCS8vIHRvZG8gZGlzcGxheSBlcnJvcgoJJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwKCQkJCSAkdGhpcy0+TGFuZyggJ2Vycm9yX2ZpbGVub3Rmb3VuZCcsICRmaWxlICkgKTsKCXJldHVybjsKICAgICAgfQoKICAgIC8vIHR1cm4gb2ZmIHpsaWIgY29tcHJlc3Npb24gCiAgICBpZihpbmlfZ2V0KCd6bGliLm91dHB1dF9jb21wcmVzc2lvbicpKQogICAgICAgIHsKICAgICAgICBpbmlfc2V0KCd6bGliLm91dHB1dF9jb21wcmVzc2lvbicsICdPZmYnKTsKICAgICAgICB9CgogICAgQG9iX2NsZWFuKCk7CiAgICBAb2JfY2xlYW4oKTsKICAgIGhlYWRlcignUHJhZ21hOiBwdWJsaWMnKTsKICAgIGhlYWRlcignRXhwaXJlczogMCcpOwogICAgaGVhZGVyKCdDYWNoZS1Db250cm9sOiBtdXN0LXJldmFsaWRhdGUsIHBvc3QtY2hlY2s9MCwgcHJlLWNoZWNrPTAnKTsKICAgIGhlYWRlcignQ2FjaGUtQ29udHJvbDogcHJpdmF0ZScsZmFsc2UpOwogICAgaGVhZGVyKCdDb250ZW50LURlc2NyaXB0aW9uOiBGaWxlIFRyYW5zZmVyJyk7CiAgICBoZWFkZXIoJ0NvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vZm9yY2UtZG93bmxvYWQnKTsKICAgIGhlYWRlcignQ29udGVudC1MZW5ndGg6ICcgLiBmaWxlc2l6ZSgkZmlsZSkpOwogICAgaGVhZGVyKCdDb250ZW50LURpc3Bvc2l0aW9uOiBhdHRhY2htZW50OyBmaWxlbmFtZT0nIC4gYmFzZW5hbWUoJGZpbGUpKTsKICAgIHJlYWRmaWxlKCRmaWxlKTsgIAoKICAgIC8vIG5vdyB0byBhZGQgdGhlIGRvd25sb2FkIHNodHVmZiB0byB0aGUgZGF0YWJhc2UKICAgIC8vIGlmIHdlIGFyZSBub3QgZXhjbHVkaW5nIHRoaXMgc3VibmV0CiAgICAkc3VibmV0cyA9IHNwbGl0KCIsIiwkdGhpcy0+R2V0UHJlZmVyZW5jZSgic3VibmV0X2V4Y2x1c2lvbiIpKTsKICAgICR0ZXN0ID0gMDsKICAgIGZvcmVhY2goJHN1Ym5ldHMgYXMgJHN1Ym5ldCkKICAgIHsKICAgICAgJHRlc3QgPSAkdGhpcy0+X3Rlc3RpcCggJHN1Ym5ldCwgZ2V0ZW52KCJSRU1PVEVfQUREUiIgKSApOwogICAgICBpZiggJHRlc3QgKQoJewoJICAvLyBkb24ndCBhbGxvdyBhbnkgbW9yZSBwcm9jZXNzaW5nCgkgIGV4aXQoKTsKCX0KICAgIH0KICAgIAogICAgLy8gZ2V0IGEgbmV3IHZhbHVlIGZyb20gdGhlIHNlcXVlbmNlIGRhdGFiYXNlCiAgICAkZGIgPSYgJHRoaXMtPkdldERiKCk7CiAgICAkbmV3aWQgPSAkZGItPkdlbklEKCBjbXNfZGJfcHJlZml4KCkuIm1vZHVsZV91cGxvYWRzX2Rvd25sb2Fkc19zZXEiICk7CiAgICAkcXVlcnkgPSAiSU5TRVJUIElOVE8gIi5jbXNfZGJfcHJlZml4KCkuIm1vZHVsZV91cGxvYWRzX2Rvd25sb2FkcyBWQUxVRVMgKD8sPyw/LD8sPykiOwogICAgJGRicmVzdWx0ID0gJGRiLT5FeGVjdXRlKCAkcXVlcnksIAoJCQkgICAgICBhcnJheSggJG5ld2lkLCAkZmlsZV9pZCwgCgkJCQkgICAgIHRyaW0oJGRiLT5EQlRpbWVTdGFtcCh0aW1lKCkpLCInIiksCgkJCQkgICAgICBnZXRlbnYoIlJFTU9URV9BRERSIiksICJ1bmtub3duIiAvKiBUT0RPLCBmaWxsIHRoaXMgaW4gbGF0ZXIgKi8gKSApOwogICAgLyogSSB3b3VsZCBub3JtYWxseSBkaXNwbGF5IGFuIGVycm9yIG1lc3NhZ2UsIGJ1dCBkb24ndCB3YW50IHBlb3BsZSB0byBuZWNlc3NhcmlseSBrbm93IEkgYW0gdHJhY2tpbmcgdGhlbSAqLwogICAgJHRoaXMtPkF1ZGl0KCAwLCAkdGhpcy0+bGFuZygnZnJpZW5kbHluYW1lJyksCgkJICAkdGhpcy0+bGFuZygnZG93bmxvYWRlZCcsICRmaWxlKSApOwoKICAgIC8vIHNlbmQgYW4gZXZlbnQKICAgICRwYXJtcyA9IGFycmF5KCk7CiAgICAkcGFybXNbJ2lkJ10gPSAkZmlsZV9pZDsKICAgICRwYXJtc1snbmFtZSddID0gJGZpbGU7CiAgICAkcGFybXNbJ2lwJ10gPSBnZXRlbnYoIlJFTU9URV9BRERSIik7CiAgICAkdGhpcy0+U2VuZEV2ZW50KCAnT25Eb3dubG9hZCcsICRwYXJtcyApOwoKICAgIC8vIGRvbid0IGFsbG93IGFueSBtb3JlIHByb2Nlc3NpbmcKICAgIGV4aXQoKTsKPz4=]]></data>
	</file>
	<file>
	  <filename>/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lang/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/en_US.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_nocategoryid'] = 'No Category id was supplied';
$lang['error_nocategory'] = 'No Category id was supplied';
$lang['error_templatenameexists'] = 'A template by that name already exists';
$lang['prompt_templatename'] = 'Template Name';
$lang['prompt_template'] = 'Template';
$lang['prompt_newtemplate'] = 'Create a new template';
$lang['help_OnDownload'] = '
<p>An event generated when a user finishes downloading a file</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - Upload ID</li>
<li><em>name</em> - File name</li>
<li><em>ip</em> - The IP Address of the downloader</li>
</ul>
';
$lang['help_OnDeleteCategory'] = '
<p>An event generated when a category is Deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - Category name</li>
<li><em>path</em> - Category path</li>
</ul>
';
$lang['help_OnCreateCategory'] = '
<p>An event generated when a category is Created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the category</li>
<li><em>description</em> - The category description</li>
<li><em>path</em> - The category path</li>
<li><em>path</em> - A flag indicating if the category is listable</li>
</ul>
';
$lang['help_OnRemove'] = '
<p>An event generated when a file is removed via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the removed file</li>
<li><em>id</em> - The id of the removed file</li>
<li><em>category_id</em> - The id of the category</li>
</ul>
';
$lang['help_OnUpload'] = '
<p>An event generated when a new file is uploaded via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>category</em> - The category name</li>
<li><em>name</em> - The name of the uploaded file</li>
<li><em>size</em> - The size of the uploaded file</li>
<li><em>summary</em> - The short description for the uploaded file (may be empty)</em></li>
<li><em>description</em> - The long description for the uploaded file (may be empty)</em></li>
<li><em>author</em> - The author of the uploaded file (if available)</em></li>
<li><em>ip_address</em> - The internet address of the client that uploaded the file</li>
</ul>
';
$lang['info_event_ondeletecategory'] = 'Event generated when a category is deleted';
$lang['info_event_oncreatecategory'] = 'Event generated when a category is created';
$lang['info_event_ondownload'] = 'Event generated when a file is downloaded';
$lang['info_event_onupload'] = 'Event generated when a new file is uploaded';
$lang['info_event_onremove'] = 'Event generated when a file is removed';
$lang['title_usertag_onupload'] = 'User defined tag to call after upload is complete';
$lang['none'] = 'None';
$lang['matchesfound'] = 'Matches found';
$lang['filter'] = 'Filter';
$lang['title_redirectonupload'] = 'Redirect to page id/alias on user upload';
$lang['details'] = 'Details';
$lang['confirm_preferences'] = 'Are you sure you want to adjust the preferences?';
$lang['error_nofilesuploaded'] = 'No files were uploaded.';
$lang['prompt_replace'] = 'Allow Overwrite';
$lang['info_replace'] = 'Replace any file with the same name (does not change id)';
$lang['no_initial'] = 'Do not display any initial results when the filter is on';
$lang['param_key'] = 'Provide an additional key to the module for further organizing uploads.  This key could be an encoded string like: \'feusers:uid\', etc.  This parameter is usually only needed when embedding the uploads module into another module';
$lang['param_noauthor'] = 'Hide the author field from the upload form.  This parameter is only valid when mode=\'upload\'.  If The FrontendUsers module is present, and a user is currently logged in, a hidden field will hold the currently logged in username';
$lang['param_upload_id'] = '
upload_id="id" - specify a single file for the url/link or single modes (above)';
$lang['param_use_strict_regexp'] = 'The filter field is used as a strict regexp without preprocessing of spaces';
$lang['param_template'] = 'Use a template with this name for this report or form.  This template automatically pulls a template with the matching name from the appropriate list based on the specified mode';
$lang['param_filter'] = 'Display the filtering form';
$lang['param_no_intitial'] = 'Only useful when the filter parameter is supplied, or on by default, this parameter indicates wether initial results should be returned';
$lang['param_sortorder'] = '
  <p>Sort Orders
  <ul>
  <li><em>date_asc</em> - Sort by ascending date</li>
  <li><em>date_desc</em> - Sort by descending date</li>
  <li><em>name_asc</em> - Sort by ascending name</li>
  <li><em>name_desc</em> - Sort by descending name</li>
  <li><em>size_asc</em> - Sort by ascending size</li>
  <li><em>size_desc</em> - Sort by descending size</li>
  <li><em>desc_asc</em> - Sort by ascending description</li>
  <li><em>desc_desc</em> - Sort by descending description</li>
  <li><em>author_asc</em> - Sort by ascending author</li>
  <li><em>author_desc</em> - Sort by descending author</li>
  <li><em>ip_asc</em> - Sort by ascending ip address</li>
  <li><em>ip_desc</em> - Sort by descending ip address</li>
  <li><em>random</em> - Random sort order</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = ' 
file_extensions="ext1,ext2,ext3"
<p>valid only when mode=upload, this parameter limits the types of files that can be uploaded.  It overrides any settings in the module preferences.</p>';
$lang['param_count'] = '
count="N"
<p>A parameter to list only the first N results of the query.  Pagination would be better, but this will do the trick for now</p>';
$lang['param_category'] = '
category="name"
<p><b>Note:</b> Category can be "all", which will list all of the uploads from all <em>listable</em> categories</p>';
$lang['param_mode'] = '
  <ul>
  <li><em>detailed</em> - Display a detailed list of all files in the category</li>
  <li><em>upload</em> - Display a form to allow a frontend user to upload a file</li>
  <li><em>url <i>or</i> link</em> - Display a link to a file</li>
  <li><em>summary</em> - Display a summarized list of all files in the category</li>
  <li><em>single</em> - Display a detailed report about a single upload</li>
  <li><em>singlesummary</em> - Display a summarized report about a single upload/li>
  </ul>';

$lang['returntomodule'] = 'Return to module panel';
$lang['error_nocategories'] = 'There are no defined categories';
$lang['title_enforceextensions'] = 'Require extensions on all uploaded files';
$lang['restoredefaultsconfirm'] = 'This operation will restore the template to system defaults.  Any changes you have made will be lost.  Are you sure you want to proceed?';
$lang['info_thumbnail'] = 'An optional thumbnail file';
$lang['thumbnail'] = 'Thumbnail';
$lang['info_summary'] = 'A brief description of the file (if empty, the file name is used without the extension)';
$lang['info_categoryname'] = 'A brief name for your category (human readable)';
$lang['info_categorydesc'] = 'A description for your category';
$lang['info_categorypath'] = 'The directory name inside the uploads directory that will be used to store files in this category.  If the directory of this name does not already exist, it may be created';
$lang['info_destname'] = 'Use the \'Upload As\' field to change the name of the file on upload.  Leave blank to preserve the filename as-is.';
$lang['error_cantcreatedirectory'] = 'Could not create directory';
$lang['error_nomailermodule'] = 'The CMSMailer module could not be instantiated';
$lang['upload_notification'] = 'A new file has been uploaded';
$lang['title_email_on_upload'] = 'Send upload notification to:';
$lang['email_template'] = 'Email Template';
$lang['title_dummy_index_html'] = 'Create dummy index.html files in each directory?<br/><em>Any existing index.html files will remain</em>';
$lang['about'] = 'About';
$lang['error_permissiondenied'] = 'Access Denied. Please check your permissions.';
$lang['error_couldnotwrite'] = 'Could not write';
$lang['addcategory'] = 'Add Category';
$lang['all'] = 'All';
$lang['areyousure'] = 'Are You Sure?';
$lang['author'] = 'Author';
$lang['cancel'] = 'Cancel';
$lang['cannotmodifypath'] = '(The path cannot be modified)';
$lang['categories'] = 'Categories';
$lang['category'] = 'Category';
$lang['message_categoryadded'] = 'Category successfully added';
$lang['changelog'] = '<ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added "summarylink", and "category" to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added "random" sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering on the frontend, and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to enter a blank path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
</li>
<li>
<p>Version 1.2.1 - April, 2006</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
<p>Added the upload_template, summary_template, and detail_template (optional) parameter</p>
<p>Added the noauthor parameter, and the key parameter.  The key parameter allows the uploads module to be embedded into other modules</p>
<p>Moved to under the content menu, and entitled \'Files (Upload Module)\'</p>;
</li>
<li>
<p>Version 1.2.2 - June, 2006
<p>Added the ability to have multiple database templates, and to select one on the tag with the template parameter.</p>
<p>Fixed an issue where files were getting corrupted on download</p>
</li>
<li>
<p>Version 1.2.3 - June, 2006
<p>Fixes to use adodb-lite proper, rather than teds hack</p>
<p>Detail link now displays inline</p>
<p>Other minor tweaks that I cant remember</p>
</li>
</ul>';
$lang['date'] = 'Date';
$lang['dateuploaded'] = 'Date Uploaded';
$lang['default'] = 'Defaults';
$lang['delete'] = 'Delete';
$lang['description'] = 'Description';
$lang['destname'] = 'Upload As';
$lang['detail_template'] = 'Detail Template';
$lang['downloaded'] = 'File %s was downloaded.';
$lang['downloads'] = 'Downloads';
$lang['edit'] = 'Edit';
$lang['editcategory'] = 'Edit Category';
$lang['editupload'] = 'Edit Upload';
$lang['error'] = 'Error!';
$lang['error_pathinuse'] = 'A category using that path already exists';
$lang['error_categoryexists'] = 'Error: Category already exists';
$lang['error_categorynotempty'] = 'Error! Cannot delete a category that is not empty';
$lang['error_categorynotfound'] = 'Error: Category not found!';
$lang['error_dberror'] = 'Error: Database error!';
$lang['error_emptycategory'] = 'Error: Empty Category!';
$lang['error_emptypath'] = 'Error: Empty Path!';
$lang['error_fileexists'] = 'Error! File %s already exists.';
$lang['error_filenotfound'] = 'Error! File %s was not found.';
$lang['error_insufficientparams'] = 'Error: Insufficient parameters supplied to module!';
$lang['error_invalidauthor'] = 'Error: Invalid (or empty) author.';
$lang['error_invalidcategory'] = 'Error: Invalid (or empty) category.';
$lang['error_invaliddescription'] = 'Error: Invalid (or empty) description.';
$lang['error_invalidfile'] = 'Error: Invalid (or empty) filename.';
$lang['error_invaliduploadfilename'] = 'Error: Files with that name (probably extension) are not allowed (%s).';
$lang['error_invaliduploadid'] = 'Error: Invalid upload id';
$lang['error_nofiles'] = 'Error: No Matching Files!';
$lang['files'] = 'Files';
$lang['fixme'] = 'Fix Spaces';
$lang['friendlyname'] = 'Files (Uploads Module)';
$lang['help'] = '
<h3>What Does This Do?</h3>
<p>It is a module for allowing people to upload and download files to and from your site.  It keeps track of who uploaded a file, and who has downloaded it.  As well, you can sort files into categories, and manage the files that were uploaded like every administrator would do</p> 
<h3>How Do I Use It</h3>
<p>To use this module, to allow users to upload files to your site, you should install the module, and then create one or more categories (a.k.a) directories for the uploaded files to go into. Then add a tag into a page or template somewhere like {cms_module module="Uploads" category="somecategory" mode="somemode"}.  Where mode matches one of the modes listed below.  The output will differ depending upon which mode you select.</p>
<p>This module can use the FrontendUsers module (optional) to get information about any currently logged in users to partly fill in the form when uploading files;</p>
<h3>Permissions</h3>
<ul>
<li><em>Manage Uploads</em> permission is needed to manage categories, and the files within them.</li>
<li><em>Modify Templates</em> permission is needed edit any of the templates.</li>
<li><em>Modify Site Preferences/em> permission is needed any of the file settings.</li>
</ul>
<h3>Emailing</h3>
<p>This module is capable of sending an email whenever a file is uploaded, see the preferences tab.  However, to do this the <b>CMSMailer</b> package must be installed and configured.  This is an <em>optional</em> step, and if the CMSMailer module is not installed, nothing will be displayed to the user, only a log message will be placed into the admin log</p>
<h3>System Settings</h3>
<p><b>Note:</b> This module does not bypass or get past any file size limitations in php.  It works in conjunction with them.  Therefore you may need to modify your php.ini file and/or your httpd.conf file(s) to allow you to upload files as large as what you have set in the uploads module preferences.</p>
<h3>Apache Notes</h3>
<p>In order to allow large file uploads, you may need to modify the upload_max_filesize parameter in your php.ini  In addition, the LimitRequestBody parameter in your apache configuration, may need to be adjusted to match the upload_max_filesize parameter</p>
<p>Note:  the upload_max_filesize parameter can be specified in bytes, kilobytes, or megabytes, however the LimitRequetBody parameter is only specified in bytes</p>
';
$lang['id'] = 'Id';
$lang['installed'] = 'Module version %s installed.';
$lang['ip_address'] = 'IP Address';
$lang['moddescription'] = 'A module that allows users to upload files, and allows you to manage them.';
$lang['name'] = 'Name';
$lang['renamemessage'] = 'Change the name here to execute a rename';
$lang['path'] = 'Path';
$lang['pathmessage'] = 'Change the category here to move the file to another directory';
$lang['pathinuploads'] = '(Relative to the uploads directory)';
$lang['postinstall'] = 'The uploads module has been successfully installed. Be sure to set "Manage Uploads" permissions to use this module!';
$lang['postuninstall'] = 'The Uploads module has been successfully removed.  No files have been removed from your uploads directory, and file integrity is intact';
$lang['preferences'] = 'Preferences';
$lang['prefsupdated'] = 'Module preferences updated.';
$lang['prompt_categorydesc'] = 'Description';
$lang['prompt_categorylistable'] = 'Files in this directory can be listed';
$lang['prompt_categoryname'] = 'Category Name';
$lang['prompt_categorypath'] = 'Server Path';
$lang['prompt_deletedirectory'] = 'Delete category directory?';
$lang['prompt_max_uploadsize'] = 'Maximum file size allowed (Kb)';
$lang['prompt_valid_uploadextensions'] = 'Valid upload extensions';
$lang['scan'] = 'Scan';
$lang['selectcategory'] = 'Select Category';
$lang['size'] = 'Size';
$lang['sizekb'] = 'Size (Kb)';
$lang['submit'] = 'Submit';
$lang['summary_template'] = 'Summary Template';
$lang['summary'] = 'Summary';
$lang['title_admin_panel'] = 'Uploads Module';
$lang['title_mod_admin'] = 'Module Admin Panel';
$lang['title_mod_prefs'] = 'Module Preferences';
$lang['title_sing_loudly'] = 'Sing Loudly?';
$lang['title_subnet_exclusions'] = 'Exclude subnets from statistics';
$lang['title_valid_uploadextensions'] = 'Valid Extensions';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['upload'] = 'Upload';
$lang['uploaded'] = 'File %s was uploaded by %s.';
$lang['replaced'] = 'File %s was replaced by %s.';
$lang['deleted'] = 'File %s was deleted.';
$lang['uploadform_template'] = 'Upload Template';
$lang['username'] = 'Username';
$lang['warning_deletecategory'] = 'WARNING: Use caution when deleting categories.  Files may be lost';
$lang['welcome_text'] = '<p>Welcome to the Uploads Module admin section. Something else would probably go here if the module actually did something.</p>';
?>
]]></data>
	</file>
	<file>
	  <filename>/lang/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/cs_CZ.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['help_OnDownload'] = '<h3>OnDownload</h3>
<ul>
<li><em>id</em> - Upload ID</li>
<li><em>name</em> - File name</li>
<li><em>ip</em> - The IP Address of the downloader</li>
</ul>
';
$lang['help_OnDeleteCategory'] = '<h3>OnDeleteCategory</h3>
<ul>
<li><em>name</em> - Category name</li>
<li><em>path</em> - Category path</li>
</ul>
';
$lang['help_OnCreateCategory'] = '<h3>OnCreateCategory</h3>
<p>An event generated when a category is removed</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the category</li>
<li><em>description</em> - The category description</li>
<li><em>path</em> - The category path</li>
<li><em>path</em> - A flag indicating if the category is listable</li>
</ul>
';
$lang['help_OnRemove'] = '<h3>OnRemove</h3>
<p>An event generated when a file is removed via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the removed file</li>
<li><em>id</em> - The id of the removed file</li>
<li><em>category_id</em> - The id of the category</li>
</ul>
';
$lang['help_OnUpload'] = '<h3>OnUpload</h3>
<p>An event generated when a new file is uploaded via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>category</em> - The category name</li>
<li><em>name</em> - The name of the uploaded file</li>
<li><em>size</em> - The size of the uploaded file</li>
<li><em>summary</em> - The short description for the uploaded file (may be empty)</em></li>
<li><em>description</em> - The long description for the uploaded file (may be empty)</em></li>
<li><em>author</em> - The author of the uploaded file (if available)</em></li>
<li><em>ip_address</em> - The internet address of the client that uploaded the file</li>
</ul>
';
$lang['info_event_ondeletecategory'] = 'Ud&aacute;lost generovan&aacute; když je smaz&aacute;na kategorie';
$lang['info_event_oncreatecategory'] = 'Ud&aacute;lost generovan&aacute;, když je vytvořena kategorie';
$lang['info_event_ondownload'] = 'Ud&aacute;lost generovan&aacute;, když je stažen soubor';
$lang['info_event_onupload'] = 'Ud&aacute;lost generovan&aacute;, když je nahr&aacute;n nov&yacute; soubor';
$lang['info_event_onremove'] = 'Ud&aacute;lost generovan&aacute;, když je odebr&aacute;n soubor';
$lang['title_usertag_onupload'] = 'Uživatelsk&yacute; tag, kter&yacute; m&aacute; b&yacute;t vol&aacute;n po dokončen&iacute; nahr&aacute;n&iacute;';
$lang['none'] = 'Ž&aacute;dn&yacute;';
$lang['matchesfound'] = 'Z&aacute;znamy nalezeny';
$lang['filter'] = 'Filtr';
$lang['title_redirectonupload'] = 'Redirect to page id/alias on user upload';
$lang['details'] = 'Detaily';
$lang['confirm_preferences'] = 'Jste si jisti &uacute;pravou preferenc&iacute;?';
$lang['error_nofilesuploaded'] = 'Ž&aacute;dn&eacute; soubory nebyly nahr&aacute;ny.';
$lang['prompt_replace'] = 'Povolit přeps&aacute;n&iacute;';
$lang['info_replace'] = 'N&aacute;hrada jak&eacute;hokoliv souboru t&iacute;m sam&yacute;m (id se nezměn&iacute;)';
$lang['no_initial'] = 'Nezobraz&iacute; se ž&aacute;dn&eacute; vstupn&iacute; v&yacute;sledky, pokud je filtr zapnut&yacute;';
$lang['param_upload_id'] = 'upload_id=&quot;id&quot; - specify a single file for the url/link or single modes (above)';
$lang['param_use_strict_regexp'] = 'The filter field is used as a strict regexp without preprocessing of spaces';
$lang['param_detail_filetemplate'] = 'Použ&iacute;v&aacute; .tpl soubor z adres&aacute;ře Uploads/templates/ m&iacute;sto datab&aacute;ze při zobrazov&aacute;n&iacute; detailn&iacute; zpr&aacute;vy';
$lang['param_upload_filetemplate'] = 'Use a .tpl file from the Uploads/templates/ folder instead of using the database template when displaying an upload form';
$lang['param_summary_filetemplate'] = 'Use a .tpl file from the Uploads/templates/ folder instead of using the database template when displaying a summary report';
$lang['param_filter'] = 'Display the filtering form';
$lang['param_no_intitial'] = 'Only useful when the filter parameter is supplied, or on by default, this parameter indicates wether initial results should be returned';
$lang['param_sortorder'] = '  <p>Sort Orders
  <ul>
  <li><em>date_asc</em> - Sort by ascending date</li>
  <li><em>date_desc</em> - Sort by descending date</li>
  <li><em>name_asc</em> - Sort by ascending name</li>
  <li><em>name_desc</em> - Sort by descending name</li>
  <li><em>size_asc</em> - Sort by ascending size</li>
  <li><em>size_desc</em> - Sort by descending size</li>
  <li><em>desc_asc</em> - Sort by ascending description</li>
  <li><em>desc_desc</em> - Sort by descending description</li>
  <li><em>author_asc</em> - Sort by ascending author</li>
  <li><em>author_desc</em> - Sort by descending author</li>
  <li><em>ip_asc</em> - Sort by ascending ip address</li>
  <li><em>ip_desc</em> - Sort by descending ip address</li>
  <li><em>random</em> - Random sort order</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = ' 
file_extensions=&quot;ext1,ext2,ext3&quot;
<p>valid only when mode=upload, this parameter limits the types of files that can be uploaded.  It overrides any settings in the module preferences.</p>';
$lang['param_count'] = 'count=&quot;N&quot;
<p>A parameter to list only the first N results of the query.  Pagination would be better, but this will do the trick for now</p>';
$lang['param_category'] = 'category=&quot;name&quot;
<p><b>Note:</b> Category can be &quot;all&quot;, which will list all of the uploads from all <em>listable</em> categories</p>';
$lang['param_mode'] = '  <ul>
  <li><em>detailed</em> - Display a detailed list of all files in the category</li>
  <li><em>upload</em> - Display a form to allow a frontend user to upload a file</li>
  <li><em>url <i>or</i> link</em> - Display a link to a file</li>
  <li><em>summary</em> - Display a summarized list of all files in the category</li>
  <li><em>single</em> - Display a detailed report about a single upload</li>
  <li><em>singlesummary</em> - Display a summarized report about a single upload/li>
  </ul>';
$lang['returntomodule'] = 'Return to module panel';
$lang['error_nocategories'] = 'There are no defined categories';
$lang['title_enforceextensions'] = 'Require extensions on all uploaded files';
$lang['restoredefaultsconfirm'] = 'This operation will restore the template to system defaults.  Any changes you have made will be lost.  Are you sure you want to proceed?';
$lang['info_thumbnail'] = 'An optional thumbnail file';
$lang['thumbnail'] = 'Thumbnail';
$lang['info_summary'] = 'A brief description of the file (if empty, the file name is used without the extension)';
$lang['info_categoryname'] = 'A brief name for your category (human readable)';
$lang['info_categorydesc'] = 'A description for your category';
$lang['info_categorypath'] = 'The directory name inside the uploads directory that will be used to store files in this category.  If the directory of this name does not already exist, it may be created';
$lang['info_destname'] = 'Use the &#039;Upload As&#039; field to change the name of the file on upload.  Leave blank to preserve the filename as-is.';
$lang['error_cantcreatedirectory'] = 'Could not create directory';
$lang['error_nomailermodule'] = 'The CMSMailer module could not be instantiated';
$lang['upload_notification'] = 'A new file has been uploaded';
$lang['title_email_on_upload'] = 'Send upload notification to:';
$lang['email_template'] = 'Email Template';
$lang['title_dummy_index_html'] = 'Create dummy index.html files in each directory?<br/><em>Any existing index.html files will remain</em>';
$lang['about'] = 'About';
$lang['error_permissiondenied'] = 'Access Denied. Please check your permissions.';
$lang['error_couldnotwrite'] = 'Could not write';
$lang['addcategory'] = 'Add Category';
$lang['all'] = 'All';
$lang['areyousure'] = 'Are You Sure?';
$lang['author'] = 'Author';
$lang['cancel'] = 'Cancel';
$lang['cannotmodifypath'] = '(The path cannot be modified)';
$lang['categories'] = 'Categories';
$lang['category'] = 'Category';
$lang['message_categoryadded'] = 'Category successfully added';
$lang['changelog'] = '<ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added &quot;summarylink&quot;, and &quot;category&quot; to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added &quot;random&quot; sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering on the frontend, and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to enter a blank path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
<p>Version 1.2.0. - April, 2006</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
<p>Added the upload_template, summary_template, and detail_template (optional) parameter</p>
</li>
</ul>';
$lang['date'] = 'Date';
$lang['dateuploaded'] = 'Date Uploaded';
$lang['default'] = 'Defaults';
$lang['delete'] = 'Delete';
$lang['description'] = 'Description';
$lang['destname'] = 'Upload As';
$lang['detail_template'] = 'Detail Template';
$lang['downloaded'] = 'File %s was downloaded.';
$lang['downloads'] = 'Downloads';
$lang['edit'] = 'Edit';
$lang['editcategory'] = 'Edit Category';
$lang['editupload'] = 'Edit Upload';
$lang['error'] = 'Error!';
$lang['error_pathinuse'] = 'A category using that path already exists';
$lang['error_categoryexists'] = 'Error: Category already exists';
$lang['error_categorynotempty'] = 'Error! Cannot delete a category that is not empty';
$lang['error_categorynotfound'] = 'Error: Category not found!';
$lang['error_dberror'] = 'Error: Database error!';
$lang['error_emptycategory'] = 'Error: Empty Category!';
$lang['error_emptypath'] = 'Error: Empty Path!';
$lang['error_fileexists'] = 'Error! File %s already exists.';
$lang['error_filenotfound'] = 'Error! File %s was not found.';
$lang['error_insufficientparams'] = 'Error: Insufficient parameters supplied to module!';
$lang['error_invalidauthor'] = 'Error: Invalid (or empty) author.';
$lang['error_invalidcategory'] = 'Error: Invalid (or empty) category.';
$lang['error_invaliddescription'] = 'Error: Invalid (or empty) description.';
$lang['error_invalidfile'] = 'Error: Invalid (or empty) filename.';
$lang['error_invaliduploadfilename'] = 'Error: Files with that name (probably extension) are not allowed (%s).';
$lang['error_invaliduploadid'] = 'Error: Invalid upload id';
$lang['error_nofiles'] = 'Error: No Matching Files!';
$lang['files'] = 'Files';
$lang['fixme'] = 'Fix Spaces';
$lang['friendlyname'] = 'Upload Module';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>It is a module for allowing people to upload and download files to and from your site.  It keeps track of who uploaded a file, and who has downloaded it.  As well, you can sort files into categories, and manage the files that were uploaded like every administrator would do</p> 
<h3>How Do I Use It</h3>
<p>To use this module, to allow users to upload files to your site, you should install the module, and then create one or more categories (a.k.a) directories for the uploaded files to go into. Then add a tag into a page or template somewhere like {cms_module module=&quot;Uploads&quot; category=&quot;somecategory&quot; mode=&quot;somemode&quot;}.  Where mode matches one of the modes listed below.  The output will differ depending upon which mode you select.</p>
<p>This module can use the FrontendUsers module (optional) to get information about any currently logged in users to partly fill in the form when uploading files;</p>
<h3>Permissions</h3>
<ul>
<li><em>Manage Uploads</em> permission is needed to manage categories, and the files within them.</li>
<li><em>Modify Templates</em> permission is needed edit any of the templates.</li>
<li><em>Modify Site Preferences/em> permission is needed any of the file settings.</li>
</ul>
<h3>Emailing</h3>
<p>This module is capable of sending an email whenever a file is uploaded, see the preferences tab.  However, to do this the <b>CMSMailer</b> package must be installed and configured.  This is an <em>optional</em> step, and if the CMSMailer module is not installed, nothing will be displayed to the user, only a log message will be placed into the admin log</p>
<h3>System Settings</h3>
<p><b>Note:</b> This module does not bypass or get past any file size limitations in php.  It works in conjunction with them.  Therefore you may need to modify your php.ini file and/or your httpd.conf file(s) to allow you to upload files as large as what you have set in the uploads module preferences.</p>
<h3>Apache Notes</h3>
<p>In order to allow large file uploads, you may need to modify the upload_max_filesize parameter in your php.ini  In addition, the LimitRequestBody parameter in your apache configuration, may need to be adjusted to match the upload_max_filesize parameter</p>
<p>Note:  the upload_max_filesize parameter can be specified in bytes, kilobytes, or megabytes, however the LimitRequetBody parameter is only specified in bytes</p>
';
$lang['id'] = 'Id';
$lang['installed'] = 'Module version %s installed.';
$lang['ip_address'] = 'IP Address';
$lang['moddescription'] = 'A module that allows users to upload files, and allows you to manage them.';
$lang['name'] = 'Name';
$lang['renamemessage'] = 'Change the name here to execute a rename';
$lang['path'] = 'Path';
$lang['pathmessage'] = 'Change the category here to move the file to another directory';
$lang['pathinuploads'] = '(Relative to the uploads directory)';
$lang['postinstall'] = 'The uploads module has been successfully installed. Be sure to set &quot;Manage Uploads&quot; permissions to use this module!';
$lang['postuninstall'] = 'The Uploads module has been successfully removed.  No files have been removed from your uploads directory, and file integrity is intact';
$lang['preferences'] = 'Preferences';
$lang['prefsupdated'] = 'Module preferences updated.';
$lang['prompt_categorydesc'] = 'Description';
$lang['prompt_categorylistable'] = 'Files in this directory can be listed';
$lang['prompt_categoryname'] = 'Category Name';
$lang['prompt_categorypath'] = 'Server Path';
$lang['prompt_deletedirectory'] = 'Delete category directory?';
$lang['prompt_max_uploadsize'] = 'Maximum file size allowed (Kb)';
$lang['prompt_valid_uploadextensions'] = 'Valid upload extensions';
$lang['scan'] = 'Scan';
$lang['selectcategory'] = 'Select Category';
$lang['size'] = 'Size';
$lang['sizekb'] = 'Size (Kb)';
$lang['submit'] = 'Submit';
$lang['summary_template'] = 'Summary Template';
$lang['summary'] = 'Summary';
$lang['title_admin_panel'] = 'Uploads Module';
$lang['title_mod_admin'] = 'Module Admin Panel';
$lang['title_mod_prefs'] = 'Module Preferences';
$lang['title_sing_loudly'] = 'Sing Loudly?';
$lang['title_subnet_exclusions'] = 'Exclude subnets from statistics';
$lang['title_valid_uploadextensions'] = 'Valid Extensions';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['upload'] = 'Upload';
$lang['uploaded'] = 'File %s was uploaded by %s.';
$lang['replaced'] = 'File %s was replaced by %s.';
$lang['deleted'] = 'File %s was deleted.';
$lang['uploadform_template'] = 'Upload Template';
$lang['username'] = 'Username';
$lang['warning_deletecategory'] = 'WARNING: Use caution when deleting categories.  Files may be lost';
$lang['welcome_text'] = '<p>Welcome to the Uploads Module admin section. Something else would probably go here if the module actually did something.</p>';
$lang['utmz'] = '156861353.1148485141.8.3.utmccn=(referral)|utmcsr=wiki.cmsmadesimple.org|utmcct=/index.php/User_Handbook|utmcmd=referral';
$lang['utma'] = '156861353.1117961117.1147346668.1148906620.1148996831.13';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['help_OnUpload'] = '<h3>OnUpload</h3>
<p>An event generated when a new file is uploaded via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>category</em> - The category name</li>
<li><em>name</em> - The name of the uploaded file</li>
<li><em>size</em> - The size of the uploaded file</li>
<li><em>summary</em> - The short description for the uploaded file (may be empty)</em></li>
<li><em>description</em> - The long description for the uploaded file (may be empty)</em></li>
<li><em>author</em> - The author of the uploaded file (if available)</em></li>
<li><em>ip_address</em> - The internet address of the client that uploaded the file</li>
</ul>
';
$lang['info_event_onupload'] = 'Event generated when a new file is uploaded';
$lang['info_event_onremove'] = 'Event generated when a file is removed';
$lang['title_usertag_onupload'] = 'Benutzerdefinierter Tag, der aufgerufen werden soll, wenn die Datei vollst&auml;ndig hochgeladen ist';
$lang['none'] = 'Nichts';
$lang['matchesfound'] = '&Uuml;bereinstimmungen gefunden';
$lang['filter'] = 'Filter';
$lang['title_redirectonupload'] = 'Des User nach dem Hochladen einer Datei weiterleiten auf Seite (id/alias)';
$lang['details'] = 'Details';
$lang['confirm_preferences'] = 'Sind sie sicher, dass sie die Einstellungen anpassen m&ouml;chten?';
$lang['error_nofilesuploaded'] = 'Es wurden keine Dateien hochgeladen.';
$lang['prompt_replace'] = '&Uuml;berschreiben erlauben';
$lang['info_replace'] = 'Ersetzt eine Datei mit dem gleichen Namen (ohne &Auml;nderung der ID)';
$lang['no_initial'] = 'Wenn dieser Filter aktiviert ist, werden keine einleitenden Ergebnisse angezeigt.';
$lang['param_upload_id'] = '
upload_id=&quot;id&quot; - definiert eine einzelne Datei f&uuml;r einen Link oder f&uuml;r den Single-Modus</li>';
$lang['param_use_strict_regexp'] = 'Die Eingaben im Filter-Feld werden als strikt regul&auml;re Ausdr&uuml;cke ohne Verarbeitung der Leerzeichen verwendet, um The filter field is used as a strict regexp without preprocessing of spaces';
$lang['param_detail_filetemplate'] = 'Ein .tpl-Datei aus dem Verzeichnis Uploads/templates/ anstatt des Datenbank-Templates verwenden, wenn ein detailierter Bericht angezeigt wird';
$lang['param_upload_filetemplate'] = 'Ein .tpl-Datei aus dem Verzeichnis Uploads/templates/ anstatt des Datenbank-Templates verwenden, wenn das Formular zum Hochladen von Dateien angezeigt wird';
$lang['param_summary_filetemplate'] = 'Ein .tpl-Datei aus dem Verzeichnis Uploads/templates/ anstatt des Datenbank-Templates verwenden, wenn eine zusammenfassender Bericht angezeigt wird';
$lang['param_filter'] = 'Das Filter-Formular anzeigen';
$lang['param_no_intitial'] = 'Nur n&uuml;tzlich, wenn der Filter-Parameter gesetzt wurde. Standardm&auml;&szlig;ig zeigt dieser Parameter an, welche einleitenden Ergebnisse zur&uuml;ckgegeben werden sollen.';
$lang['param_sortorder'] = '  
<p>Sortierreihenfolge
  <ul>
  <li><em>date_asc</em> - sortiert aufsteigend nach Datum</li>
  <li><em>date_desc</em> - sortiert absteigend nach Datum</li>
  <li><em>name_asc</em> - sortiert aufsteigend nach Name</li>
  <li><em>name_desc</em> - sortiert absteigend nach Name</li>
  <li><em>size_asc</em> - sortiert aufsteigend nach Gr&ouml;&szlig;e</li>
  <li><em>size_desc</em> - sortiert absteigend nach Gr&ouml;&szlig;e</li>
  <li><em>desc_asc</em> - sortiert aufsteigend nach Beschreibung</li>
  <li><em>desc_desc</em> - sortiert absteigend nach Beschreibung</li>
  <li><em>author_asc</em> - sortiert aufsteigend nach Autor</li>
  <li><em>author_desc</em> - sortiert absteigend nach Autor</li>
  <li><em>ip_asc</em> - sortiert aufsteigend nach IP-Adresse</li>
  <li><em>ip_desc</em> - sortiert absteigend nach IP-Adresse</li>
  <li><em>random</em> - zuf&auml;llige Reihenfolge</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = '
file_extensions=&quot;ext1,ext2,ext3&quot;
<p>ist nur g&uuml;ltig, wenn mode=upload ist, dieser Parameter beschr&auml;nkt die Dateitypen, die hochgeladen werden k&ouml;nnen.  Die Voreinstellungen des Moduls werden dabei &uuml;berschrieben.</p>';
$lang['param_count'] = '
count=&quot;N&quot;
<p>Ein Parameter zur Darstellung einer Liste den ersten &quot;N&quot; Ergebnissen einer Abfrage. Ein Seitenumbruch w&auml;re sicherlich besser, aber bis dahin gibts diesen Trick.</p>';
$lang['param_category'] = '
category=&quot;name&quot;
<p><b>Hinweis:</b> category kann auch den Wert &quot;all&quot; haben. Dann werden alle hochgeladenen Dateien in allen <em>gelisteten</em> Kategorien angezeigt.</p>';
$lang['param_mode'] = ' 
 <ul>
  <li><em>detailed</em> - zeigt eine detaillierte Liste aller Dateien dieser Kategorie</li>
  <li><em>upload</em> - zeigt ein Formular, um Besuchern der Site das Hochladen einer Datei zu erm&ouml;glichen</li>
  <li><em>url <i>or</i> link</em> - zeigt einen Link zu einer Datei</li>
  <li><em>summary</em> - zeigt eine zusammengefasste Liste aller Dateien dieser Kategorie</li>
  <li><em>single</em> - zeigt einen detaillierten Bericht &uuml;ber eine bestimmte, hochgeladene Datei</li>
  </ul>';
$lang['returntomodule'] = 'Zur&uuml;ck zur Moduloberfl&auml;che';
$lang['error_nocategories'] = 'Es wurden keine Kategorien definiert.';
$lang['title_enforceextensions'] = 'Erforderliche Namenserweiterungen f&uuml;r alle hochgeladenen Dateien';
$lang['restoredefaultsconfirm'] = 'Dies setzt das Template auf den Systemstandard zur&uuml;ck. Alle &Auml;nderungen gehen dabei verloren. Wollen sie wirklich fortfahren?';
$lang['info_thumbnail'] = 'Eine optionale Thumbnail-Datei';
$lang['thumbnail'] = 'Thumbnail';
$lang['info_summary'] = 'Eine kurze Beschreibung der Datei (wird dies leer gelassen, wird der Dateiname ohne Erweiterung verwendet)';
$lang['info_categoryname'] = 'Ein kurzer Name f&uuml;r ihre Kategorie';
$lang['info_categorydesc'] = 'Eine Beschreibung f&uuml;r ihre Kategorie';
$lang['info_categorypath'] = 'Das Unterverzeichnis im Verzeichnis Uploads, welches f&uuml;r die Speicherung der Dateien dieser Kategorie genutzt werden soll. Falls ein Verzeichnis mit diesem Namen noch nicht existiert, wird es erzeugt.';
$lang['info_destname'] = 'Verwenden sie das Feld &#039;Hochladen als&#039;, um den Namen der hochgeladenen Datei zu ver&auml;ndern. Wenn das Feld leer bleibt, wird der Dateiname nicht ver&auml;ndert.';
$lang['error_cantcreatedirectory'] = 'Das Verzeichnis konnte nicht erstellt werden.';
$lang['error_nomailermodule'] = 'Die Verbindung zum CMSMailer-Module konnte nicht hergestellt werden.';
$lang['upload_notification'] = 'Eine neue Datei wurde hochgeladen.';
$lang['title_email_on_upload'] = 'Die Benachrichtigung &uuml;ber eine hochgeladene Datei soll gesandt werden an';
$lang['email_template'] = 'Email-Template';
$lang['title_dummy_index_html'] = 'Soll in jedem Verzeichnis eine index.html-Datei erstellt werden?<br/><em>Bereits existierende index.html-Dateien bleiben erhalten</em>';
$lang['about'] = '&uuml;ber';
$lang['error_permissiondenied'] = 'Zugriff verweigert. Bitte &uuml;berpr&uuml;fen sie ihre Berechtigungen.';
$lang['error_couldnotwrite'] = 'Konnte nicht geschrieben werden.';
$lang['addcategory'] = 'Kategorie hinzuf&uuml;gen';
$lang['all'] = 'Alle';
$lang['areyousure'] = 'Sind Sie sicher?';
$lang['author'] = 'Autor';
$lang['cancel'] = 'Abbrechen';
$lang['cannotmodifypath'] = '(Dieser Pfad kann nicht ver&auml;ndert werden.)';
$lang['categories'] = 'Kategorien';
$lang['category'] = 'Kategorie';
$lang['message_categoryadded'] = 'Die Kategorie wurde erfolgreich hinzugef&uuml;gt.';
$lang['changelog'] = '<ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added &quot;summarylink&quot;, and &quot;category&quot; to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added &quot;random&quot; sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
</li>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to not enter a path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
<p>Version 1.2.0. - April, 2006</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
<p>Added the upload_template, summary_template, and detail_template (optional) parameter</p>
</li>
</ul>';
$lang['date'] = 'Datum';
$lang['dateuploaded'] = 'Hochgeladen am';
$lang['default'] = 'Voreinstellungen';
$lang['delete'] = 'L&ouml;schen';
$lang['description'] = 'Beschreibung';
$lang['destname'] = 'Hochladen als';
$lang['detail_template'] = 'Detail-Template';
$lang['downloaded'] = 'Die Datei %s wurde heruntergeladen.';
$lang['downloads'] = 'Heruntergeladene Dateien';
$lang['edit'] = 'Bearbeiten';
$lang['editcategory'] = 'Kategorie bearbeiten';
$lang['editupload'] = 'Hochgeladene Datei bearbeiten';
$lang['error'] = 'Fehler!';
$lang['error_pathinuse'] = 'Es existiert bereits eine Kategorie mit diesem Pfad.';
$lang['error_categoryexists'] = 'Fehler: Die Kategorie existiert bereits!';
$lang['error_categorynotempty'] = 'Fehler: Die Kategorie kann nicht gel&ouml;scht werden, da sie nicht leer ist!';
$lang['error_categorynotfound'] = 'Fehler: Kategorie wurde nicht gefunden!';
$lang['error_dberror'] = 'Fehler: Datenbankfehler!';
$lang['error_emptycategory'] = 'Fehler: Leere Kategorie!';
$lang['error_emptypath'] = 'Fehler: Leerer Pfad!';
$lang['error_fileexists'] = 'Fehler: Die Datei %s existiert bereits!';
$lang['error_filenotfound'] = 'Fehler: Die Datei %s konnte nicht gefunden werden!';
$lang['error_insufficientparams'] = 'Fehler: Das Modul wurde mit nicht ausreichenden Parametern aufgerufen!';
$lang['error_invalidauthor'] = 'Fehler: Autor ung&uuml;ltig (oder leer)!';
$lang['error_invalidcategory'] = 'Fehler: Kategorie ung&uuml;ltig (oder leer)!';
$lang['error_invaliddescription'] = 'Fehler: Beschreibung ung&uuml;ltig (oder leer)!';
$lang['error_invalidfile'] = 'Fehler: Dateiname ung&uuml;ltig (oder leer)!';
$lang['error_invaliduploadfilename'] = 'Fehler: Dateien mit dieser Namenserweiterung sind nicht erlaubt!';
$lang['error_invaliduploadid'] = 'Fehler: ID ung&uuml;ltig!';
$lang['error_nofiles'] = 'Fehler: Keine Dateien gefunden!';
$lang['files'] = 'Dateien';
$lang['fixme'] = 'Leerzeichen entfernen';
$lang['friendlyname'] = 'Upload-Modul';
$lang['help'] = '<h3>Was macht dieses Modul?</h3>
<p>Das Modul erlaubt den Besuchern Ihrer Homepage, auf Ihrer Seite Dateien hoch- und runterzuladen. Dabei wird protokolliert, wer eine Datei hochgeladen und wer eine Datei heruntergeladen hat. Desweiteren k&ouml;nnen die Dateien kategorisiert werden. Die hochgeladenen Dateien k&ouml;nnen so verwaltet werden, wie dies ein Administrator k&ouml;nnte.</p> 
<h3>Wie wird es eingesetzt ?</h3>
<p>Um den Usern ihrer Seite das Hochladen von Dateien zu erlauben, sollten Sie das Modul zun&auml;chst installieren und dann eine oder mehrere Kategorien (=Verzeichnisse) f&uuml;r die hochzuladenden Dateien erstellen. Dann f&uuml;gen Sie den Tag {cms_module module=&quot;Uploads&quot; category=&quot;somecategory&quot; mode=&quot;somemode&quot;} in eine Seite oder ein Template ein. Die verf&uuml;gbaren Modi sind nachfolgend aufgelistet. Je nach dem ausgew&auml;hlten Modus werden sich die ausgegebenen Daten voneinander unterscheiden.</p>
<p>Dieses Modul kann das UserID-Mmodul verwenden (optional), um Informationen &uuml;ber die aktuell eingeloggten User zu erhalten. Diese Informationen werden dann teilweise zum Ausf&uuml;llen des Formulars beim Hochladen von Dateien verwendet.</p>
<h3>Berechtigungen</h3>
<ul>
<li><em>Manage Uploads</em> diese Berechtigung wird ben&ouml;tigt, um Kategorien und die darin befindlichen Dateien zu verwalten.</li>
<li><em>Modify Templates</em> diese Berechtigung wird ben&ouml;tigt, um Templates zu bearbeiten.</li>
<li><em>Modify Site Preferences</em> diese Berechtigung wird ben&ouml;tigt, um dateibezogene Einstellungen zu ver&auml;ndern.</li>
</uL>
<h3>Emailversand</h3>
<p>Mit diesem Modul ist es m&ouml;glich, immer dann eine Email zu versenden, wenn eine Datei hochgeladen wurde. Schauen sie hierzu in die Einstellungen. Daf&uuml;r muss das <b>CMSMailer</b>-Modul installiert und konfiguriert sein. Diese M&ouml;glichkeit ist nur <em>optional</em>. Wenn das CMSMailer-Modul nicht installiert ist, wird dem User nichts angezeigt. Nur im Logbuch des Administrators wird ein Eintrag vorgenommen.</p>
<h3>Systemeinstellungen</h3>
<p><b>Hinweis:</b> Das Modul umgeht nicht die Beschr&auml;nkungen hinsichtlich der Dateigr&ouml;&szlig;e in PHP. Es funktioniert nur in Verbindung mit diesem. Wenn Sie gr&ouml;&szlig;ere Dateien zum Hochladen zulassen m&ouml;chten, m&uuml;ssen Sie Ihre php.ini-Datei und/oder httpd.conf Datei(en) sowie die Voreinstellungen des Moduls entsprechend bearbeiten.
<h4>Hinweise f&uuml;r Apache</h4>
<p>Um das Hochladen von gr&ouml;&szlig;eren Dateien zu erlauben, m&uuml;ssen sie den Parameter upload_max_filesize in ihrere php.ini bearbeiten. Zus&auml;tzlich muss der Parameter LimitRequestBody in ihrer Apache-Konfiguration an den Parameter upload_max_filesize angepasst werden.</p>
<p>Hinweis:  der Parameter upload_max_filesize kann in Bytes, Kilobytes oder Megabytes angegeben werden, w&auml;hrenddessen der Parameter LimitRequestBody nur in Bytes festgelegt werden kann.</p>';
$lang['id'] = 'ID';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['ip_address'] = 'IP-Adresse';
$lang['moddescription'] = 'Ein Modul, welches den Usern das Hochladen und die Verwaltung von Dateien erm&ouml;glicht.';
$lang['name'] = 'Name';
$lang['renamemessage'] = '&Auml;ndern Sie den Namen hier, um eine Umbenennung durchzuf&uuml;hren.';
$lang['path'] = 'Pfad';
$lang['pathmessage'] = '&Auml;ndern Sie die Kategorie hier, um die Datei in ein anderes Verzeichnis zu verschieben.';
$lang['pathinuploads'] = '(relativ zum Uploads-Verzeichnis)';
$lang['postinstall'] = 'Stellen Sie sicher, dass User, welche die hochgeladenen Dateien verwalten d&uuml;rfen, die Berechtigung &quot;Manage Uploads&quot; haben!';
$lang['postuninstall'] = '&quot;So ein Mist! Wieder nichts!&quot;';
$lang['preferences'] = 'Einstellungen';
$lang['prefsupdated'] = 'Moduleinstellungen aktualisiert.';
$lang['prompt_categorydesc'] = 'Beschreibung';
$lang['prompt_categorylistable'] = 'Die Dateien in diesem Verzeichnis k&ouml;nnen angezeigt werden.';
$lang['prompt_categoryname'] = 'Name der Kategorie';
$lang['prompt_categorypath'] = 'Serverpfad';
$lang['prompt_deletedirectory'] = 'Kategorieverzeichnis l&ouml;schen?';
$lang['prompt_max_uploadsize'] = 'Maximal erlaubte Dateigr&ouml;&szlig;e (Kb)';
$lang['prompt_valid_uploadextensions'] = 'G&uuml;ltige Dateierweiterungen';
$lang['scan'] = 'Scannen';
$lang['selectcategory'] = 'Kategorie ausw&auml;hlen';
$lang['size'] = 'Gr&ouml;&szlig;e';
$lang['sizekb'] = 'Gr&ouml;&szlig;e (Kb)';
$lang['submit'] = 'Abschicken';
$lang['summary_template'] = 'Zusammenfassungs-Template';
$lang['summary'] = 'Zusammenfassung';
$lang['title_admin_panel'] = 'Uploads-Modul';
$lang['title_mod_admin'] = 'Modul-Administration';
$lang['title_mod_prefs'] = 'Moduleinstellungen';
$lang['title_sing_loudly'] = 'Laut singen?';
$lang['title_subnet_exclusions'] = 'Subnets von der Statistik ausschlie&szlig;en';
$lang['title_valid_uploadextensions'] = 'G&uuml;ltige Namenserweiterungen';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['upload'] = 'Hochladen';
$lang['uploaded'] = 'Die Datei %s wurde hochgeladen.';
$lang['replaced'] = 'Die Datei %s wurde durch %s ersetzt.';
$lang['deleted'] = 'Die Datei %s wurde gel&ouml;scht.';
$lang['uploadform_template'] = 'Template hochladen';
$lang['username'] = 'Username';
$lang['warning_deletecategory'] = 'WARNUNG: Seien Sie vorsichtig, wenn Sie Kategorien l&ouml;schen. Die Dateien k&ouml;nnen dabei verloren gehen.';
$lang['welcome_text'] = '<p>Willkommen in der Aministration des Uploads-Moduls. Wenn das Modul gerade in Benutzung w&auml;re, w&uuml;rde hier wahrscheinlich etwa anderes stehen.</p>';
$lang['utma'] = '156861353.717462736.1147511856.1147511856.1147511856.1';
$lang['utmz'] = '156861353.1147511856.1.1.utmccn=(referral)|utmcsr=wikidev.cmsmadesimple.org|utmcct=/de:installation:upgrading|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fi_FI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['help_OnDownload'] = '<h3>OnDownload</h3>
<p>An event generated when a user finishes downloading a file</p>
<ul>
<li><em>id</em> - Upload ID</li>
<li><em>name</em> - File name</li>
<li><em>ip</em> - The IP Address of the downloader</li>
</ul>
';
$lang['help_OnDeleteCategory'] = '<h3>OnDeleteCategory</h3>
<p>An event generated when a category is Deleted</p>
<ul>
<li><em>name</em> - Category name</li>
<li><em>path</em> - Category path</li>
</ul>
';
$lang['help_OnCreateCategory'] = '<h3>OnCreateCategory</h3>
<p>An event generated when a category is Created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the category</li>
<li><em>description</em> - The category description</li>
<li><em>path</em> - The category path</li>
<li><em>path</em> - A flag indicating if the category is listable</li>
</ul>
';
$lang['help_OnRemove'] = '<h3>OnRemove</h3>
<p>An event generated when a file is removed via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The name of the removed file</li>
<li><em>id</em> - The id of the removed file</li>
<li><em>category_id</em> - The id of the category</li>
</ul>
';
$lang['help_OnUpload'] = '<h3>OnUpload</h3>
<p>An event generated when a new file is uploaded via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>category</em> - The category name</li>
<li><em>name</em> - The name of the uploaded file</li>
<li><em>size</em> - The size of the uploaded file</li>
<li><em>summary</em> - The short description for the uploaded file (may be empty)</em></li>
<li><em>description</em> - The long description for the uploaded file (may be empty)</em></li>
<li><em>author</em> - The author of the uploaded file (if available)</em></li>
<li><em>ip_address</em> - The internet address of the client that uploaded the file</li>
</ul>
';
$lang['info_event_ondeletecategory'] = 'Event generated when a category is deleted';
$lang['info_event_oncreatecategory'] = 'Event generated when a category is created';
$lang['info_event_ondownload'] = 'Event generated when a file is downloaded';
$lang['info_event_onupload'] = 'Event generated when a new file is uploaded';
$lang['info_event_onremove'] = 'Event generated when a file is removed';
$lang['title_usertag_onupload'] = 'User defined tag to call after upload is complete';
$lang['none'] = 'None';
$lang['matchesfound'] = 'Osumaa l&ouml;ydetty';
$lang['filter'] = 'Suodata';
$lang['title_redirectonupload'] = 'Ohjaa sivulle (id / alias) latauksen j&auml;lkeen';
$lang['details'] = 'Lis&auml;tiedot';
$lang['confirm_preferences'] = 'Haluatko varmasti muuttaa asetuksia';
$lang['error_nofilesuploaded'] = 'Tiedostoa ei ladattu';
$lang['prompt_replace'] = 'Saali ylikirjoitus';
$lang['info_replace'] = 'Korvaa tiedosto samannimisella (ei vaihda ID:ta)';
$lang['no_initial'] = '&Auml;l&auml; n&auml;yt&auml; oletuksena mit&auml;&auml;n jos filtter&ouml;inti on p&auml;&auml;ll&auml;';
$lang['param_key'] = 'Provide an additional key to the module for further organizing uploads.  This key could be an encoded string like: &#039;feusers:uid&#039;, etc.  This parameter is usually only needed when embedding the uploads module into another module';
$lang['param_noauthor'] = 'Hide the author field from the upload form.  This parameter is only valid when mode=&#039;upload&#039;.  If The FrontendUsers module is present, and a user is currently logged in, a hidden field will hold the currently logged in username';
$lang['param_upload_id'] = 'upload_id=&quot;id&quot; - specify a single file for the url/link or single modes (above)';
$lang['param_use_strict_regexp'] = 'Suodatus k&auml;ytt&auml;&auml; tiukkaa s&auml;&auml;nn&ouml;nmukaistalausetta';
$lang['param_detail_filetemplate'] = 'Use a .tpl file from the Uploads/templates/ folder instead of using the database template when displaying a detail report';
$lang['param_upload_filetemplate'] = 'Use a .tpl file from the Uploads/templates/ folder instead of using the database template when displaying an upload form';
$lang['param_summary_filetemplate'] = 'Use a .tpl file from the Uploads/templates/ folder instead of using the database template when displaying a summary report';
$lang['param_filter'] = 'N&auml;yt&auml; suodatus kaavake';
$lang['param_no_intitial'] = 'K&auml;yt&auml;nn&ouml;llinen vain jos suodatus parametri on annettu, Vaikuttaa tuloksiin ilman suodatusta
';
$lang['param_sortorder'] = '  <p>Sort Orders
  <ul>
  <li><em>date_asc</em> - Sort by ascending date</li>
  <li><em>date_desc</em> - Sort by descending date</li>
  <li><em>name_asc</em> - Sort by ascending name</li>
  <li><em>name_desc</em> - Sort by descending name</li>
  <li><em>size_asc</em> - Sort by ascending size</li>
  <li><em>size_desc</em> - Sort by descending size</li>
  <li><em>desc_asc</em> - Sort by ascending description</li>
  <li><em>desc_desc</em> - Sort by descending description</li>
  <li><em>author_asc</em> - Sort by ascending author</li>
  <li><em>author_desc</em> - Sort by descending author</li>
  <li><em>ip_asc</em> - Sort by ascending ip address</li>
  <li><em>ip_desc</em> - Sort by descending ip address</li>
  <li><em>random</em> - Random sort order</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = ' 
file_extensions=&quot;ext1,ext2,ext3&quot;
<p>Mit&auml; tiedosto p&auml;&auml;tteit&auml; voidaan ladata, vaatii mode=&quot;upload&quot; parametrin. Ylikirjoittaa modulin perusasetukset</p>';
$lang['param_count'] = 'count=&quot;N&quot;
<p>N&auml;ytt&auml;&auml; N kappaletta tuloksia</p>';
$lang['param_category'] = 'category=&quot;name&quot;
<p><b>Huomaa:</b> Voi olla my&ouml;s &quot;all&quot;, joka n&auml;ytt&auml;&auml; kaikki <em>listattavissa olevat</em> kategoriat</p>';
$lang['param_mode'] = '  <ul>
  <li><em>detailed</em> - Display a detailed list of all files in the category</li>
  <li><em>upload</em> - Display a form to allow a frontend user to upload a file</li>
  <li><em>url <i>or</i> link</em> - Display a link to a file</li>
  <li><em>summary</em> - Display a summarized list of all files in the category</li>
  <li><em>single</em> - Display a detailed report about a single upload</li>
  <li><em>singlesummary</em> - Display a summarized report about a single upload/li>
  </ul>';
$lang['returntomodule'] = 'Palaa moduuliin';
$lang['error_nocategories'] = 'Ei yht&auml;&auml;n m&auml;&auml;ritelty&auml; kategoriaa';
$lang['title_enforceextensions'] = 'Vaadi p&auml;&auml;te kaikille ladatuille tiedostoille';
$lang['restoredefaultsconfirm'] = 'Oletko varma ett&auml; haluat palauttaa kaikki pohjat oletus pohjiksi. Kaikki muutokset joita olet tehnyt h&auml;vi&auml;v&auml;t!';
$lang['info_thumbnail'] = 'Vapaaehtoinen peukalokuva tiedosto';
$lang['thumbnail'] = 'Peukalokuva';
$lang['info_summary'] = 'A brief description of the file (if empty, the file name is used without the extension)';
$lang['info_categoryname'] = 'A brief name for your category (human readable)';
$lang['info_categorydesc'] = 'A description for your category';
$lang['info_categorypath'] = 'The directory name inside the uploads directory that will be used to store files in this category.  If the directory of this name does not already exist, it may be created';
$lang['info_destname'] = 'Use the &#039;Upload As&#039; field to change the name of the file on upload.  Leave blank to preserve the filename as-is.';
$lang['error_cantcreatedirectory'] = 'Ei voida luoda hakemistoa';
$lang['error_nomailermodule'] = 'CMSMailer modulia ei voitu alustaa';
$lang['upload_notification'] = 'A new file has been uploaded';
$lang['title_email_on_upload'] = 'Send upload notification to:';
$lang['email_template'] = 'Email Template';
$lang['title_dummy_index_html'] = 'Create dummy index.html files in each directory?<br/><em>Any existing index.html files will remain</em>';
$lang['about'] = 'About';
$lang['error_permissiondenied'] = 'P&auml;&auml;sy ev&auml;tty, tarkista oikeutesi.';
$lang['error_couldnotwrite'] = 'Ei voitu kirjoittaa';
$lang['addcategory'] = 'Lis&auml;&auml; kategoria';
$lang['all'] = 'Kaikki';
$lang['areyousure'] = 'Oletko varma?';
$lang['author'] = 'Tekij&auml;';
$lang['cancel'] = 'Peruuta';
$lang['cannotmodifypath'] = '(Polkua ei voida muuttaa)';
$lang['categories'] = 'Kategoriat';
$lang['category'] = 'Kategoria';
$lang['message_categoryadded'] = 'Kategoria lis&auml;tty';
$lang['changelog'] = '<ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added &quot;summarylink&quot;, and &quot;category&quot; to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added &quot;random&quot; sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering on the frontend, and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to enter a blank path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
</li>
</ul>';
$lang['date'] = 'P&auml;iv&auml;m&auml;&auml;r&auml;';
$lang['dateuploaded'] = 'Date Uploaded';
$lang['default'] = 'Oletukset';
$lang['delete'] = 'Poista';
$lang['description'] = 'Kuvaus';
$lang['destname'] = 'Upload As';
$lang['detail_template'] = 'Detail Template';
$lang['downloaded'] = 'File %s was downloaded.';
$lang['downloads'] = 'Downloads';
$lang['edit'] = 'Muokkaa';
$lang['editcategory'] = 'Mukkaa kategoriaa';
$lang['editupload'] = 'Edit Upload';
$lang['error'] = 'Virhe!';
$lang['error_pathinuse'] = 'Kategoria samalla polulla on jo olemassa.';
$lang['error_categoryexists'] = 'Virhe: Kategoria on jo olemassa!';
$lang['error_categorynotempty'] = 'Virhe: Ei voida tuhota kategoriaa joka ei ole tyhj&auml;!';
$lang['error_categorynotfound'] = 'Virhe: Kategoriaa ei l&ouml;ydy!';
$lang['error_dberror'] = 'Virhe: Tietokanta virhe!';
$lang['error_emptycategory'] = 'Virhe: Tyhj&auml; kategoria!';
$lang['error_emptypath'] = 'Virhe: Tyhj&auml; polku!';
$lang['error_fileexists'] = 'Virhe: Tiedosto %s on jo olemassa!';
$lang['error_filenotfound'] = 'Virhe: Tiedostoa %s ei l&ouml;ydy!';
$lang['error_insufficientparams'] = 'Virhe: Kaikkia parametreja ei ole m&auml;&auml;ritelty moduli kutsussa!';
$lang['error_invalidauthor'] = 'Virhe: virheellinen (tai tyhj&auml;) tekij&auml;';
$lang['error_invalidcategory'] = 'Virhe: virheellinen (tai tyhj&auml;) kategoria';
$lang['error_invaliddescription'] = 'Virhe: virheellinen (tai tyhj&auml;) kuvaus';
$lang['error_invalidfile'] = 'Virhe: virheellinen (tai tyhj&auml;) tiedostonimi';
$lang['error_invaliduploadfilename'] = 'Virhe: virheellinen tiedostonimi (tai p&auml;&auml;te) (%s)';
$lang['error_invaliduploadid'] = 'Virhe: virheellinen lataus id';
$lang['error_nofiles'] = 'Error: No Matching Files!';
$lang['files'] = 'Tiedostot';
$lang['fixme'] = 'Korjaa v&auml;lily&ouml;nnit';
$lang['friendlyname'] = 'Files (Uploads Module)';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>It is a module for allowing people to upload and download files to and from your site.  It keeps track of who uploaded a file, and who has downloaded it.  As well, you can sort files into categories, and manage the files that were uploaded like every administrator would do</p> 
<h3>How Do I Use It</h3>
<p>To use this module, to allow users to upload files to your site, you should install the module, and then create one or more categories (a.k.a) directories for the uploaded files to go into. Then add a tag into a page or template somewhere like {cms_module module=&quot;Uploads&quot; category=&quot;somecategory&quot; mode=&quot;somemode&quot;}.  Where mode matches one of the modes listed below.  The output will differ depending upon which mode you select.</p>
<p>This module can use the FrontendUsers module (optional) to get information about any currently logged in users to partly fill in the form when uploading files;</p>
<h3>Permissions</h3>
<ul>
<li><em>Manage Uploads</em> permission is needed to manage categories, and the files within them.</li>
<li><em>Modify Templates</em> permission is needed edit any of the templates.</li>
<li><em>Modify Site Preferences/em> permission is needed any of the file settings.</li>
</ul>
<h3>Emailing</h3>
<p>This module is capable of sending an email whenever a file is uploaded, see the preferences tab.  However, to do this the <b>CMSMailer</b> package must be installed and configured.  This is an <em>optional</em> step, and if the CMSMailer module is not installed, nothing will be displayed to the user, only a log message will be placed into the admin log</p>
<h3>System Settings</h3>
<p><b>Note:</b> This module does not bypass or get past any file size limitations in php.  It works in conjunction with them.  Therefore you may need to modify your php.ini file and/or your httpd.conf file(s) to allow you to upload files as large as what you have set in the uploads module preferences.</p>
<h3>Apache Notes</h3>
<p>In order to allow large file uploads, you may need to modify the upload_max_filesize parameter in your php.ini  In addition, the LimitRequestBody parameter in your apache configuration, may need to be adjusted to match the upload_max_filesize parameter</p>
<p>Note:  the upload_max_filesize parameter can be specified in bytes, kilobytes, or megabytes, however the LimitRequetBody parameter is only specified in bytes</p>';
$lang['id'] = 'Id';
$lang['installed'] = 'Moduli versio %s asennettu.';
$lang['ip_address'] = 'IP osoite';
$lang['moddescription'] = 'Moduli joka sallii k&auml;ytt&auml;jien ladata tiedostoja sivustolle ja yll&auml;pit&auml;j&auml;n hallita n&auml;it&auml; tiedostoja ';
$lang['name'] = 'Nimi';
$lang['renamemessage'] = 'Vaihda nimi tai tee uudelleennime&auml;minen';
$lang['path'] = 'Polku';
$lang['pathmessage'] = 'Vaihda kategorian nimi tai siirr&auml; tiedosto toiseen hakemistoon';
$lang['pathinuploads'] = '(Relative to the uploads directory)';
$lang['postinstall'] = 'Post Install Message, e.g., Be sure to set &quot;Manage Uploads&quot; permissions to use this module!';
$lang['postuninstall'] = 'The Uploads module has been successfully removed.  No files have been removed from your uploads directory, and file integrity is intact';
$lang['preferences'] = 'Asetukset';
$lang['prefsupdated'] = 'Modulin asetukset p&auml;ivitetty';
$lang['prompt_categorydesc'] = 'Kuvaus';
$lang['prompt_categorylistable'] = 'Tiedostoa t&auml;ss&auml; hakemistossa voidaan listata';
$lang['prompt_categoryname'] = 'Kategorian nimi';
$lang['prompt_categorypath'] = 'Palvelimen polku';
$lang['prompt_deletedirectory'] = 'Tuhoa kategorian hakemisto?';
$lang['prompt_max_uploadsize'] = 'Maksimi tiedostokoko (Kb)';
$lang['prompt_valid_uploadextensions'] = 'Hyv&auml;ksytyt tiedostop&auml;&auml;tteet';
$lang['scan'] = 'Skannaa';
$lang['selectcategory'] = 'Valitse kategoria';
$lang['size'] = 'Koko';
$lang['sizekb'] = 'Koko (Kb)';
$lang['submit'] = 'L&auml;het&auml;';
$lang['summary_template'] = 'Kooste pohja';
$lang['summary'] = 'Kooste';
$lang['title_admin_panel'] = 'Uploads Module';
$lang['title_mod_admin'] = 'Modulin hallintapaneeli';
$lang['title_mod_prefs'] = 'Modulin asetukset';
$lang['title_sing_loudly'] = 'Sing Loudly?';
$lang['title_subnet_exclusions'] = '&Auml;l&auml; ker&auml;&auml; statistiikka aliverkoista';
$lang['title_valid_uploadextensions'] = 'Hyv&auml;ksytyt tiedostop&auml;&auml;tteet';
$lang['uninstalled'] = 'Moduli poistettu';
$lang['upgraded'] = 'Moduli p&auml;ivitetty versioon %s.';
$lang['upload'] = 'Lataa';
$lang['uploaded'] = 'File %s was uploaded by %s.';
$lang['replaced'] = 'File %s was replaced by %s.';
$lang['deleted'] = 'File %s was deleted.';
$lang['uploadform_template'] = 'Upload Template';
$lang['username'] = 'K&auml;ytt&auml;j&auml;nimi';
$lang['warning_deletecategory'] = 'VAROITUS: Kategorioiden tuhoaminen saattaa kadottaa tiedostoja';
$lang['welcome_text'] = '<p>Welcome to the Uploads Module admin section. Something else would probably go here if the module actually did something.</p>';
$lang['utma'] = '156861353.1775561005.1147781292.1149599393.1149699476.9';
$lang['utmz'] = '156861353.1148675318.5.5.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,4829.0/topicseen.html|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['help_OnDownload'] = '<h3>VedNedlasting</h3>
<ul>
<li><em>id</em> - Last-opp ID</li>
<li><em>navn</em> - Filnavn</li>
<li><em>ip</em> - IP Adressen til nedlasteren</li>
</ul>
';
$lang['help_OnDeleteCategory'] = '<h3>VedSlettKategori</h3>
<ul>
<li><em>navn</em> - Kategori navn</li>
<li><em>sti</em> - Kategori sti</li>
</ul>
';
$lang['help_OnCreateCategory'] = '<h3>VedOpprettKategori</h3>
<p>En hendelse generert n&aring;r en kategori er fjernet</p>
<h4>Parametere</h4>
<ul>
<li><em>navn</em> - Navnet p&aring; kategorien</li>
<li><em>beskrivelse</em> - Kategori beskrivelsen</li>
<li><em>sti</em> - Kategori stien</li>
<li><em>sti</em> - Et flagg som indikerer om kategorien er utlistbar</li>
</ul>
';
$lang['help_OnRemove'] = '<h3>VedFjern</h3>
<p>En hendelse generert n&aring;r en fil er fjernet via Admin eller Frontend grensesnittene</p>
<h4>Parametere</h4>
<ul>
<li><em>navn</em> - NAvnet p&aring; den fjernede fila</li>
<li><em>id</em> - ID&#039;en p&aring; den fjernede fila</li>
<li><em>kategori_id</em> - ID&#039;en p&aring; kategorien</li>
</ul>
';
$lang['help_OnUpload'] = '<h3>OnUpload</h3>
<p>An event generated when a new file is uploaded via the admin or frontend interfaces</p>
<h4>Parameters</h4>
<ul>
<li><em>kategori</em> - Kategori navnet</li>
<li><em>navn</em> - Navnet p&aring; den opplastede fila</li>
<li><em>st&oslash;rrelse</em> - St&oslash;rrelsen p&aring; den opplastede fila</li>
<li><em>sammendrag</em> - Den korte beskrivelsen for den opplastede fila (kan v&aelig;re blank)</em></li>
<li><em>beskrivelse</em> - Den fulle beskrivelsen for den opplastede fila (kan v&aelig;re blank)</em></li>
<li><em>opphavsmann</em> - Opphavsmannen for den opplastede fila (if available)</em></li>
<li><em>ip_adresse</em> - Internett adressen for klienten som lastet opp fila</li>
</ul>
';
$lang['info_event_ondeletecategory'] = 'Hendelse generert n&aring;r en kategori er slettet';
$lang['info_event_oncreatecategory'] = 'Hendelse generert n&aring;r en kategori er laget';
$lang['info_event_ondownload'] = 'Hendelse generert n&aring;r en fil er lastet ned';
$lang['info_event_onupload'] = 'Hendelse generert n&aring;r en fil er lastet opp';
$lang['info_event_onremove'] = 'Hendelse generert n&aring;r en fil er fjernet';
$lang['title_usertag_onupload'] = 'Bruker definert tagg &aring; kj&oslash;re etter opplasting er ferdig';
$lang['none'] = 'Ingen';
$lang['matchesfound'] = 'Treff funnet';
$lang['filter'] = 'Filter ';
$lang['title_redirectonupload'] = 'Videresend til side id/alias ved bruker-opplasting';
$lang['details'] = 'Detaljer';
$lang['confirm_preferences'] = 'Er du sikker p&aring; du vil endre innstillingene';
$lang['error_nofilesuploaded'] = 'Ingen filer ble lastet opp.';
$lang['prompt_replace'] = 'Tillat overskriving';
$lang['info_replace'] = 'Erstatt enhver fil med samme navn (endrer ikke id&#039;en)';
$lang['no_initial'] = 'Ikke vis noen innledende resultater n&aring;r filteret er p&aring;';
$lang['param_key'] = 'Tilf&oslash;y en ekstra n&oslash;kkel til modulen for enda bedre organisering av upplastinger.  Denne n&oslash;kkel kan v&aelig;re en kodet streng som: &#039;feusers:uid&#039;, osv.  Denne parameter er vanligvis kun n&oslash;dvendig n&aring;r du inneslutter uploads modulen i en annen modul';
$lang['param_noauthor'] = 'Gjem opphavsmann/author feltet fra opplastings skjemaet.  Denne parameter er kun virksom n&aring;r mode=&#039;upload&#039;.  Om FrontendUsers modulen er tilstede, og en bruker er innlogget, et skjult felt vil inneholde den n&aring;v&aelig;rende innloggedes brukernavn';
$lang['param_upload_id'] = 'upload_id=&quot;id&quot; - spesifiserer en enkelt fil for url&#039;en/linken eller enkel-mode (over)';
$lang['param_use_strict_regexp'] = 'Filter feltet er brukt som (strict regexp) uten for prossessering av mellomrom';
$lang['param_detail_filetemplate'] = 'Bruk en .tpl fil fra Uploads/templates/ mappen i stedet  for &aring; bruke database malen ved visning av detalj rapport';
$lang['param_upload_filetemplate'] = 'Bruk en .tpl fil fra Uploads/templates/ mappen i stedet  for &aring; bruke database malen ved visning av et opplastings skjema';
$lang['param_summary_filetemplate'] = 'Bruk en .tpl fil fra Uploads/templates/ mappen i stedet  for &aring; bruke database malen ved visning av en sammendrags rapport';
$lang['param_filter'] = 'Vis filter skjemaet';
$lang['param_no_intitial'] = 'Kun brukelig n&aring;r filter parameter er gitt, eller p&aring; som standard, denne parameter indikerer om innledende reslutater skal vises';
$lang['param_sortorder'] = '  <p>Sort Orders
  <ul>
  <li><em>date_asc</em> - Sorter dato stigende</li>
  <li><em>date_desc</em> - Sorter dato synkende</li>
  <li><em>name_asc</em> - Sorter navn stigende</li>
  <li><em>name_desc</em> - Sorter navn synkende</li>
  <li><em>size_asc</em> - Sorter st&oslash;rrelse stigende</li>
  <li><em>size_desc</em> - Sorter st&oslash;rrelse synkende</li>
  <li><em>desc_asc</em> - Sorter beskrivelse stigende</li>
  <li><em>desc_desc</em> - Sorter beskrivelse synkende</li>
  <li><em>author_asc</em> - Sorter opphavsmann/author stigende</li>
  <li><em>author_desc</em> - Sorter opphavsmann/author synkende</li>
  <li><em>ip_asc</em> - Sorter ip-adresse stigende</li>
  <li><em>ip_desc</em> - Sorter ip-adresse synkende</li>
  <li><em>random</em> - Tilfeldig sortering</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = ' 
file_extensions=&quot;ext1,ext2,ext3&quot;
<p>gyldig kun om mode=upload, denn eparameteren begrenser filtypene som kan lastes opp.  Overstyrer enhver verdi i modul innstillingene.</p>';
$lang['param_count'] = 'count=&quot;N&quot;
<p>En parameter for &aring; utliste kun de f&oslash;rste N svar fra sp&oslash;rringen.  Sideformatering ville v&aelig;re bedre, men dette for holde n&aring;</p>';
$lang['param_category'] = 'category=&quot;name&quot;
<p><b>Notat:</b> Kategori kan v&aelig;re &quot;all&quot;, som vil utliste alle opplastinger fra alle <em>utlistbare</em> kategorier</p>';
$lang['param_mode'] = '  <ul>
  <li><em>detailed</em> - Vis en detaljert liste over alle filer i kategorien</li>
  <li><em>upload</em> - Viser et skjema som tillater en frontend bruker &aring; laste opp en fil</li>
  <li><em>url <i>eller</i> link</em> - Viser en link til en fil</li>
  <li><em>summary</em> - Viser en summert liste over alle filer i kategorien</li>
  <li><em>single</em> - Viser en detaljert rapport om en enkelt opplasting</li>
  <li><em>singlesummary</em> - Viser en summert rapport om en enkelt opplasting</li>
  </ul>';
$lang['returntomodule'] = 'Tilbake til Modul panelet';
$lang['error_nocategories'] = 'Det er ingen definerte kategorier';
$lang['title_enforceextensions'] = 'Krever fil-endelse p&aring; alle opplastede filer';
$lang['restoredefaultsconfirm'] = 'Denne handling vil resette malen til system standard.  Enhver endring du har gjort vil bli borte.  Er du sikker p&aring; at du vil fortsette?';
$lang['info_thumbnail'] = 'En valgfri thumbnail fil';
$lang['thumbnail'] = 'Thumbnail ';
$lang['info_summary'] = 'En kort beskrivelse (om blank, blir filnavnet brukt uten fil-endelse)';
$lang['info_categoryname'] = 'Et kort navn p&aring; din kategori (forst&aring;elig for hvermansen)';
$lang['info_categorydesc'] = 'En beskrivelse av din kategori';
$lang['info_categorypath'] = 'Katalognavnet inne i opplastings katalogen som vil bli brukt for &aring; lagre filer i denne kategori.  Om katalogen med dette navnet ikke eksisterer, vil den bli opprettet';
$lang['info_destname'] = 'Bruk &#039;Upload As&#039; feltet for &aring; endre navnet p&aring; fila ved opplasting.  La v&aelig;re blankt for &aring; beholde navnet som det er.';
$lang['error_cantcreatedirectory'] = 'Kunne ikke opprette katalog';
$lang['error_nomailermodule'] = 'CMSMailer modulen kunne ikke startes';
$lang['upload_notification'] = 'En ny fil har blitt lastet opp';
$lang['title_email_on_upload'] = 'Send opplastings-melding til:';
$lang['email_template'] = 'Email mal';
$lang['title_dummy_index_html'] = 'Opprett dummy index.html filer i hver katalog?<br/><em>Ingen eksisterende index.html filer vil bli igjen</em>';
$lang['about'] = 'Om';
$lang['error_permissiondenied'] = 'Adgang nektet. Vennligst sjekk dine rettigheter.';
$lang['error_couldnotwrite'] = 'Kan ikke skrive';
$lang['addcategory'] = 'Legg til kategori';
$lang['all'] = 'Alt';
$lang['areyousure'] = 'Er du sikker?';
$lang['author'] = 'Opphavsmann';
$lang['cancel'] = 'Avbryt';
$lang['cannotmodifypath'] = '(Stien kan ikke endres)';
$lang['categories'] = 'Kategorier';
$lang['category'] = 'Kategori';
$lang['message_categoryadded'] = 'Kategori opprettet';
$lang['changelog'] = '<ul>
<li>
<p>Version 1.0. - September 2005.</p>
<p> Initial Release.</p>
</li>
<li>
<p>Version 1.01. - September 2005</p>
<p>Minor fixes.</p></li>
<li>
<p>Version 1.02. - September 2005</p>
<p>Added ability to specify sort order</p>
</li>
<li>
<p>Version 1.03. - September 2005</p>
<p>Fix regarding conflict in template names</p>
</li>
<li>
<p>Version 1.04. - September 2005</p>
<p>Added ability to re-scan a directory, and to upload files from the admin page</p>
</li>
<li>
<p>Version 1.05. - September 2005</p>
<p>Fixed some PHP variable issues</p>
</li>
<li>
<p>Version 1.06. - September 2005</p>
<p>Added author field to the admin panel upload form, added a summary field, and made description a text area, and allow the user to specify a destination file name</p>
</li>
<li>
<p>Version 1.07. - September 2005</p>
<p>Added the ability to rename files and fixed a scan error</p>
</li>
<li>
<p>Version 1.08. - September 2005</p>
<p>Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</p></li>
<li>
<p>Version 1.1.0. - October 2005</p>
 <ul>
   <li>Modified AttemptUpload function so it could be called externally</li>
   <li>Added GetUploadDetails function that returns all of the details about a module, including a link</li>
   <li>Added Redirects so that working with the module is alot nicer, it returns to the right tab</li>
   <li>Changed the front template to look a little better and make more sense</li>
   <li>Fixes to the uploads stuff so that the description is set, and name and summary are put in the right place</li>
   <li>Fixes to even better handle spaces in names</li>
   <li>Optionaly place dummy index.html files in each upload directory</li>
   <li>If specifying a destination name, and no extension is given, the extension of the originating file (if any exists is used</li>
 </ul>
 <p><em><b>Important!</b></em><br/>It is not possible to upgrade from any other version of the Uploads module to 1.1.0.  This is due to some errors that were made in the database routines, and even in the upgrade routine in 1.0.6.  You must de-install the old version, and then re-install the new veresion. This will cause significant difficulty if you have dscriptions, etc, in your tables</p>
</li>
<li>
<p>Version 1.1.1. - October, 2005</p>
<p>Fixed a couple of minor bugs in the GetUploadDetails and added another link (or a url) to the uploaded file.</p>
</li>
<li>
<p>Version 1.1.2. - October, 2005</p>
<p>Fixed the URL field in GetUploadDetails to return a download link and added an absurl field which returns the absolute path to the file on the webserver.  Clicks on this link will not be counted</p>
</li>
<li>
<p>Version 1.1.3. - October, 2005</p>
<p>Fixed the upgrade problem from the 1.0.x series.  Users of the 1.0.x series should be able to upgrade to 1.1.3 now with no difficulty. <b>Those are famous last words, please backup first</b>. Fixed the content redirect things that were irritating me.  Also added category=all to list all of the uploads in all listable categories <em>(lets all hope I got the sql figured out properly)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - October, 2005</p>
<p>Added the count parameter to list only the first N records, and added &quot;summarylink&quot;, and &quot;category&quot; to the templates for westis.  For examples on how to use them reset your templates back to default.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>Added email notification and some bug fixes</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>Added an api function and fixed some redirection stuff</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>More API functions, and now ignore dot files when scanning.  Email notification is now in.</p>
</li>
<li>
<p>Version 1.1.8. - January, 2006</p>
<p>* Improved docs wrt apache and php configs.</p>
<p>* Fixed problem where filesize was showing up as 0.</p>
<p>* Modified permissions to be more granular</p>
<p>* Added some comments and verbosity to the category and uploads forms in the admin section</p>
<p>* Added &quot;random&quot; sort order</p>
<p>* Some PHP5 fixes</p>
</li>
<li>
<p>Version 1.1.9. - January, 2006</p>
<p>* Added the ability to upload a thumbnail image</p>
<p>* Some improved auditing</p>
<p>* xml now added to the default file types (new installs only)</p>
<p>* Added a confirmation message to the reset to defaults buttons of the template pages.</p>
<p>* Added the file_extensions parameter for the upload form</p>
<p>* The current category selected in the files filter is sticky.
<p>* Added a preference to enforice filename extensions (defaults to on)</p>
<p>* Added a link to the edit page, in the name column of the files list.</p>
<p>* Minor changes to the layout and text to add clarity.</p>
<p>* Added download_url as an available smarty tag in the templates</p>
<li>
<p>Version 1.1.10. - February, 2006</p>
<p>* Summary now defaults to the filename (without the extension) if none is specified</p>
<p>* Now correctly handle if the thumbnail extension is not in the accepted extension list</p>
<p>* No longer display any content in the files tab if there are no categories defined</p>
<p>* Display a link in the error page that takes you back to the main admin panel</p>
<p>* Allow for replacing of uploaded files</p>
</li>
<li>
<p>Version 1.1.11. - March, 2006</p>
<p>Added the ability for a link to a detailed page when in summary mode.</p>
<p>Split the default action and defaultadmin actions into separate files, for a bit of memory improvement, hopefully</p>
<p>Add the ability to redirect to another page after a frontend user uploaded a file</p>
</li>
<li>
<p>Version 1.1.12. - March, 2006</p>
<p>Added the singlesummary mode to display a single upload in summary mode</P>
</li>
<li>
<p>Version 1.1.13. - April, 2006</p>
<p>Added optional filtering on the frontend, and a couple of extra parameters to go with it</p>
<p>Fixed a problem where it would allow you to enter a blank path when creating a category</p>
<p>Split stuff into (some) separate action files for some hopeful performance increases</p>
<p>Added copyright notices</p>
<p>Changed (optional) dependency from UserID to FrontEndUsers Module.</p>
<p>Version 1.2.1. - April, 2006</p>
<p>Changed _scanDirectory to an API function ScanDirectory and then added SmartScanDirectory to scan the directory before displaying the summary or detail listing to handle the
case where somebody uploaded files via FTP or something and did not go into the admin section to update the categories.</p>
<p>Correction to all db access stuff. Hopefully provides a performance increase.</p>
<p>Fixes to the about stuff, now use CreateParameter</p>
<p>Added the upload_template, summary_template, and detail_template (optional) parameter</p>
<p>Added the noauthor parameter, and the key parameter.  The key parameter allows the uploads module to be embedded into other modules</p>
<p>Moved to under the content menu, and entitled &#039;Files (Upload Module)&#039;</p>;
</li>
</ul>';
$lang['date'] = 'Dato';
$lang['dateuploaded'] = 'Dato opplastet';
$lang['default'] = 'Standard';
$lang['delete'] = 'Slett';
$lang['description'] = 'Beskrivelse';
$lang['destname'] = 'Last opp som';
$lang['detail_template'] = 'Detalj mal';
$lang['downloaded'] = 'Fil %s ble lastet ned.';
$lang['downloads'] = 'Nedlastinger';
$lang['edit'] = 'Rediger';
$lang['editcategory'] = 'REdiger kategori';
$lang['editupload'] = 'Rediger opplasting';
$lang['error'] = 'Feil!';
$lang['error_pathinuse'] = 'En kategori som bruker den stien eksisterer allerede';
$lang['error_categoryexists'] = 'Feil: Kategori eksisterer allerede';
$lang['error_categorynotempty'] = 'Feil! Kan ikke slette kategori da den ikke er tom';
$lang['error_categorynotfound'] = 'Feil: Kategori ikke funnet!';
$lang['error_dberror'] = 'Feil: Database feil!';
$lang['error_emptycategory'] = 'Feil: Tom kategori!';
$lang['error_emptypath'] = 'Feil: Blank sti!';
$lang['error_fileexists'] = 'Feil! Fil %s eksisterer allerede.';
$lang['error_filenotfound'] = 'Feil! Fil %s ble ikke funnet.';
$lang['error_insufficientparams'] = 'Feil: Mangelfulle parametre gitt til modulen!';
$lang['error_invalidauthor'] = 'Feil: Ugyldig (eller blank) opphavsmann.';
$lang['error_invalidcategory'] = 'Feil: Ugyldig (eller blank) kategori.';
$lang['error_invaliddescription'] = 'Feil: Ugyldig (eller blank) beskrivelse.';
$lang['error_invalidfile'] = 'Feil: Ugyldig (eller blank) filnavn.';
$lang['error_invaliduploadfilename'] = 'Feil: Filer med dette navnet (sansynlig fil-endelsen) er ikke tilllatt (%s).';
$lang['error_invaliduploadid'] = 'Feil: Ugyldig opplastingsID';
$lang['error_nofiles'] = 'Feil: Ingen passende filer!';
$lang['files'] = 'Filer';
$lang['fixme'] = 'Fiks mellomrom';
$lang['friendlyname'] = 'Filer (Uploads Modulen)';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>It is a module for allowing people to upload and download files to and from your site.  It keeps track of who uploaded a file, and who has downloaded it.  As well, you can sort files into categories, and manage the files that were uploaded like every administrator would do</p> 
<h3>How Do I Use It</h3>
<p>To use this module, to allow users to upload files to your site, you should install the module, and then create one or more categories (a.k.a) directories for the uploaded files to go into. Then add a tag into a page or template somewhere like {cms_module module=&quot;Uploads&quot; category=&quot;somecategory&quot; mode=&quot;somemode&quot;}.  Where mode matches one of the modes listed below.  The output will differ depending upon which mode you select.</p>
<p>This module can use the FrontendUsers module (optional) to get information about any currently logged in users to partly fill in the form when uploading files;</p>
<h3>Permissions</h3>
<ul>
<li><em>Manage Uploads</em> permission is needed to manage categories, and the files within them.</li>
<li><em>Modify Templates</em> permission is needed edit any of the templates.</li>
<li><em>Modify Site Preferences/em> permission is needed any of the file settings.</li>
</ul>
<h3>Emailing</h3>
<p>This module is capable of sending an email whenever a file is uploaded, see the preferences tab.  However, to do this the <b>CMSMailer</b> package must be installed and configured.  This is an <em>optional</em> step, and if the CMSMailer module is not installed, nothing will be displayed to the user, only a log message will be placed into the admin log</p>
<h3>System Settings</h3>
<p><b>Note:</b> This module does not bypass or get past any file size limitations in php.  It works in conjunction with them.  Therefore you may need to modify your php.ini file and/or your httpd.conf file(s) to allow you to upload files as large as what you have set in the uploads module preferences.</p>
<h3>Apache Notes</h3>
<p>In order to allow large file uploads, you may need to modify the upload_max_filesize parameter in your php.ini  In addition, the LimitRequestBody parameter in your apache configuration, may need to be adjusted to match the upload_max_filesize parameter</p>
<p>Note:  the upload_max_filesize parameter can be specified in bytes, kilobytes, or megabytes, however the LimitRequetBody parameter is only specified in bytes</p>
';
$lang['id'] = 'ID';
$lang['installed'] = 'Modul versjon %s installert.';
$lang['ip_address'] = 'IP Addresse';
$lang['moddescription'] = 'En modul som tillater brukere &aring; laste opp filer, og tillater deg &aring; h&aring;ndtere dem.';
$lang['name'] = 'Navn';
$lang['renamemessage'] = 'Rediger navnet her for &aring; gj&oslash;re en navneendring';
$lang['path'] = 'Sti';
$lang['pathmessage'] = 'Endre kategori her for &aring; flytte filen til en annen kategori';
$lang['pathinuploads'] = '(Relativ til opplastings katalogen)';
$lang['postinstall'] = 'Uploads modulen har blitt installert. V&aelig;r sikker p&aring; &aring; sette &quot;Manage Uploads&quot; rettigheter for &aring; kunne bruke modulen!';
$lang['postuninstall'] = 'Uploads modulen har blitt fjernet.  Ingen filer har blitt fjernet fra din opplastings katalog, og fil integriteten er intakt';
$lang['preferences'] = 'Innstillinger';
$lang['prefsupdated'] = 'Modul innstillinger oppdatert.';
$lang['prompt_categorydesc'] = 'Beskrivelse';
$lang['prompt_categorylistable'] = 'Filer i denne kategorien kan listes ut';
$lang['prompt_categoryname'] = 'Kategori navn';
$lang['prompt_categorypath'] = 'Server sti';
$lang['prompt_deletedirectory'] = 'Slett kategori mappe?';
$lang['prompt_max_uploadsize'] = 'Maksimum tillatte filst&oslash;rrelse (Kb)';
$lang['prompt_valid_uploadextensions'] = 'Gyldig opplastings fil-endelse';
$lang['scan'] = 'Skann';
$lang['selectcategory'] = 'Velg kategori';
$lang['size'] = 'St&oslash;rrelse';
$lang['sizekb'] = 'St&oslash;rrelse (Kb)';
$lang['submit'] = 'Utf&oslash;r';
$lang['summary_template'] = 'Sammendrags mal';
$lang['summary'] = 'Sammendrag';
$lang['title_admin_panel'] = 'Uploads Modulen';
$lang['title_mod_admin'] = 'Modul Administrasjonspanel';
$lang['title_mod_prefs'] = 'Modul Innstillinger';
$lang['title_sing_loudly'] = 'Syng h&oslash;yt?';
$lang['title_subnet_exclusions'] = 'Utelukk subnett fra statistikker';
$lang['title_valid_uploadextensions'] = 'Gyldige fil-endelser';
$lang['uninstalled'] = 'Modul avinnstallert.';
$lang['upgraded'] = 'Modul oppgradert til versjon %s.';
$lang['upload'] = 'Last opp';
$lang['uploaded'] = 'Fil %s ble lastet opp av %s.';
$lang['replaced'] = 'Fil %s ble erstattet %s.';
$lang['deleted'] = 'Fil %s ble slettet.';
$lang['uploadform_template'] = 'LAst opp mal';
$lang['username'] = 'Brukernavn';
$lang['warning_deletecategory'] = 'ADVARSEL: Forsiktig n&aring;r du sletter kategorier.  Filer kan bli borte';
$lang['welcome_text'] = '<p>Velkommen til Uploads Modulens admin seksjon. Noe anne kunne st&aring; her om modulen virkelig gjorde noe.</p>';
$lang['utma'] = '156861353.469342802.1148076752.1149420075.1149426566.9';
$lang['utmz'] = '156861353.1149426566.9.6.utmccn=(referral)|utmcsr=helminsen.no|utmcct=/admin/editcontent.php|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['help_OnDownload'] = '<h3>VidNedladdning</h3>
<p>En h&auml;ndelse som utf&ouml;rs n&auml;r en anv&auml;ndare slutf&ouml;r nedladdning av en fil</p>
<ul>
<li><em>id</em> - Uppladdnings-ID</li>
<li><em>name</em> - Filnamn</li>
<li><em>ip</em> - Nedladdarens IP-adress</li>
</ul>
';
$lang['help_OnDeleteCategory'] = '<h3>VidTaBortKategori</h3>
<p>En h&auml;ndelse som utf&ouml;rs n&auml;r en kategori tas bort</p>
<ul>
<li><em>name</em> - Kategorinamn</li>
<li><em>path</em> - S&ouml;kv&auml;g f&ouml;r kategori</li>
</ul>
';
$lang['help_OnCreateCategory'] = '<h3>VidSkapaKategori</h3>
<p>En h&auml;ndelse som utf&ouml;rs n&auml;r en kategori skapas</p>
<h4>Parametrar</h4>
<ul>
<li><em>name</em> - Kategorins namn</li>
<li><em>description</em> - Kategorins beskrivning</li>
<li><em>path</em> - Kategorins s&ouml;kv&auml;g</li>
<li><em>path</em> - En flagga som indikerar om kategorin kan listas</li>
</ul>
';
$lang['help_OnRemove'] = '<h3>VidTaBort</h3>
<p>En h&auml;ndelse som utf&ouml;rs n&auml;r en fil tas bort via administrationen eller frontend-gr&auml;nssnittet</p>
<h4>Parametrar</h4>
<ul>
<li><em>name</em> - Namnet p&aring; den borttagna filen</li>
<li><em>id</em> - Den borttagna filens ID</li>
<li><em>category_id</em> - Kategorins ID</li>
</ul>
';
$lang['help_OnUpload'] = '<h3>VidUppladdning</h3>
<p>En h&auml;ndelse som utf&ouml;rs n&auml;r en fil laddas upp via administrationen eller frontend-gr&auml;nssnittet</p>
<h4>Parametrar</h4>
<ul>
<li><em>category</em> - Kategorins namn</li>
<li><em>name</em> - Den uppladdade filens namn</li>
<li><em>size</em> - Storleken p&aring; den uppladdade filen</li>
<li><em>summary</em> - Den uppladdade filens kortfattade beskrivning (kan vara tom)</em></li>
<li><em>description</em> - Den uppladdade filens l&aring;nga beskrivning (kan vara tom)</em></li>
<li><em>author</em> - Den uppladde filens f&ouml;rfattare (om n&aring;gon)</em></li>
<li><em>ip_address</em> - Internet-adressen f&ouml;r den klient som laddade upp filen</li>
</ul>
';
$lang['info_event_ondeletecategory'] = 'H&auml;ndelse som utf&ouml;rs n&auml;r en kategori tas bort';
$lang['info_event_oncreatecategory'] = 'H&auml;ndelse som utf&ouml;rs n&auml;r en kategori skapas';
$lang['info_event_ondownload'] = 'H&auml;ndelse som utf&ouml;rs n&auml;r en fil laddas ner';
$lang['info_event_onupload'] = 'H&auml;ndelse som utf&ouml;rs n&auml;r en ny fil laddas upp';
$lang['info_event_onremove'] = 'H&auml;ndelse som utf&ouml;rs n&auml;r en fil tas bort';
$lang['title_usertag_onupload'] = 'Anv&auml;ndardefinierade taggar som kallas efter att uppladdningen &auml;r komplett';
$lang['none'] = 'Inga';
$lang['matchesfound'] = 'Tr&auml;ffar hittade';
$lang['filter'] = 'Filter';
$lang['title_redirectonupload'] = 'Omdirigera till sid-ID/-alias n&auml;r anv&auml;ndare laddar upp';
$lang['details'] = 'Detaljer';
$lang['confirm_preferences'] = '&Auml;r du s&auml;ker p&aring; att du vill &auml;ndra inst&auml;llningarna?';
$lang['error_nofilesuploaded'] = 'Inga filer laddades upp.';
$lang['prompt_replace'] = 'Till&aring;t att skriva &ouml;ver';
$lang['info_replace'] = 'Ers&auml;tt alla filer med samma namn (&auml;ndrar inte id-numret)';
$lang['no_initial'] = 'Visa inte n&aring;gra inledande resultat n&auml;r filtret &auml;r p&aring;';
$lang['param_key'] = 'Provide an additional key to the module for further organizing uploads.  This key could be an encoded string like: &#039;feusers:uid&#039;, etc.  This parameter is usually only needed when embedding the uploads module into another module';
$lang['param_noauthor'] = 'Hide the author field from the upload form.  This parameter is only valid when mode=&#039;upload&#039;.  If The FrontendUsers module is present, and a user is currently logged in, a hidden field will hold the currently logged in username';
$lang['param_upload_id'] = 'upload_id=&quot;id&quot; - specify a single file for the url/link or single modes (above)';
$lang['param_use_strict_regexp'] = 'Filterf&auml;ltet anv&auml;nds som ett strikt regexp-uttryck utan att f&ouml;rbehandla mellanslag';
$lang['param_detail_filetemplate'] = 'Anv&auml;nd en .tpl-fil fr&aring;n mappen Uploads/templates/folder ist&auml;llet f&ouml;r att anv&auml;nda databasmallen n&auml;r en detaljerad rapport visas';
$lang['param_upload_filetemplate'] = 'Anv&auml;nd en .tpl-fil fr&aring;n mappen Uploads/templates/folder ist&auml;llet f&ouml;r att anv&auml;nda databasmallen n&auml;r ett uppladdningsformul&auml;r visas';
$lang['param_summary_filetemplate'] = 'Anv&auml;nd en .tpl-fil fr&aring;n mappen Uploads/templates/folder ist&auml;llet f&ouml;r att anv&auml;nda databasmallen n&auml;r en sammanfattningsrapport visas';
$lang['param_filter'] = 'Visa filterformul&auml;ret';
$lang['param_no_intitial'] = 'Bara anv&auml;ndbar n&auml;r filterparametern anv&auml;nds, eller n&auml;r den &auml;r p&aring; som standard. Den h&auml;r parametern indikerar om inledande resultat ska returneras';
$lang['param_sortorder'] = '  <p>Sorteringsordningar
  <ul>
  <li><em>date_asc</em> - Sortera efter datum, stigande</li>
  <li><em>date_desc</em> - Sortera efter datum, fallande</li>
  <li><em>name_asc</em> - Sortera efter namn, stigande</li>
  <li><em>name_desc</em> - Sortera efter namn, fallande</li>
  <li><em>size_asc</em> - Sortera efter storlek, stigande</li>
  <li><em>size_desc</em> - Sortera efter storlek, fallande</li>
  <li><em>desc_asc</em> - Sortera efter beskrivning, stigande</li>
  <li><em>desc_desc</em> - Sortera efter beskrivning, fallande</li>
  <li><em>author_asc</em> - Sortera efter f&ouml;rfattare, stigande</li>
  <li><em>author_desc</em> - Sortera efter f&ouml;rfattare, fallande</li>
  <li><em>ip_asc</em> - Sortera efter IP-adress, stigande</li>
  <li><em>ip_desc</em> - Sortera efter IP-adress, fallande</li>
  <li><em>random</em> - Slumpvis sorteringsordning</li>
  </ul>
  </p>';
$lang['param_fileextensions'] = ' 
file_extensions=&quot;ext1,ext2,ext3&quot;
<p>g&auml;ller enbart n&auml;r mode=upload. Den h&auml;r parametern begr&auml;nsar vilka filtyper som kan laddas upp. Den upph&auml;ver inst&auml;llningarna i modulinst&auml;llningar.</p>';
$lang['param_count'] = 'count=&quot;N&quot;
<p>En parameter f&ouml;r att lista enbart de N f&ouml;rsta resultaten i en fr&aring;ga. Sidindelning (pagination) skulle vara b&auml;ttre, men det h&auml;r funkar tills vidare</p>';
$lang['param_category'] = 'category=&quot;name&quot;
<p><b>Notera:</b> Kategori kan vara &quot;all&quot; (alla), vilket listar alla uppladdningar fr&aring;n alla <em>listbara</em> kategorier</p>';
$lang['param_mode'] = '  <ul>
  <li><em>detailed</em> - Visa en detaljerad lista &ouml;ver alla filer i kategorin</li>
  <li><em>upload</em> - Visa ett formul&auml;r f&ouml;r att l&aring;ta en anv&auml;ndare ladda upp filer via hemsidan</li>
  <li><em>url <i>or</i> link</em> - Visa en l&auml;nk till en fil</li>
  <li><em>summary</em> - Visa en sammanfattad lista &ouml;ver alla filer i en kategori</li>
  <li><em>single</em> - Visa en detaljerad rapport om en enskild uppladdning</li>
  </ul>';
$lang['returntomodule'] = 'Tillbaka till modulpanelen';
$lang['error_nocategories'] = 'Det finns inga definierade kategorier';
$lang['title_enforceextensions'] = 'Kr&auml;ver filtill&auml;gg f&ouml;r alla uppladdade filer';
$lang['restoredefaultsconfirm'] = 'Detta &aring;terst&auml;ller mallarna till systemstandard. Alla f&ouml;r&auml;ndringar som du har gjort kommer att f&ouml;rloras. &Auml;r du s&auml;ker p&aring; att du vill forts&auml;tta?';
$lang['info_thumbnail'] = 'En valfri fil med tumnagelbild';
$lang['thumbnail'] = 'Tumnagelbild';
$lang['info_summary'] = 'En kort beskrivning av filen (om tom anv&auml;nds filnamnet utan dess filtill&auml;gg)';
$lang['info_categoryname'] = 'En kort beskrivning av din kategori (f&ouml;r allm&auml;nheten)';
$lang['info_categorydesc'] = 'En beskrivning av din kategori';
$lang['info_categorypath'] = 'Namnet p&aring; katalogen under katalogen uploads, som ska anv&auml;ndas f&ouml;r att spara filer i den h&auml;r kategorin. Om katalogen med det h&auml;r namnet inte finns, s&aring; kan den skapas.';
$lang['info_destname'] = 'Anv&auml;nd det h&auml;r f&auml;ltet f&ouml;r att &auml;ndra namnet p&aring; filen vid uppladdning';
$lang['error_cantcreatedirectory'] = 'Kunde inte skapa katalog';
$lang['error_nomailermodule'] = 'Modulen CMSMailer kunde inte skapa en instans';
$lang['upload_notification'] = 'En ny fil har laddats upp';
$lang['title_email_on_upload'] = 'Skicka epost vid uppladdning till:';
$lang['email_template'] = 'Epostmall';
$lang['title_dummy_index_html'] = 'Skapa index.html-filer i varje mapp?<br/><em>Alla befintliga index.html-filer kommer att finnas kvar</em>';
$lang['about'] = 'Om';
$lang['error_permissiondenied'] = '&Aring;tkomst nekad. Kontrollera dina r&auml;ttigheter.';
$lang['error_couldnotwrite'] = 'Kunde inte skriva';
$lang['addcategory'] = 'L&auml;gg till kategori';
$lang['all'] = 'Alla';
$lang['areyousure'] = '&Auml;r du s&auml;ker?';
$lang['author'] = 'F&ouml;rfattare';
$lang['cancel'] = '&Aring;ngra';
$lang['cannotmodifypath'] = '(S&ouml;kv&auml;gen kan inte &auml;ndras)';
$lang['categories'] = 'Kategorier';
$lang['category'] = 'Kategori';
$lang['message_categoryadded'] = 'Kategorin har lagts till';
$lang['changelog'] = '<ul>
<li>Version 1.0.  - September 2005. F&ouml;rsta versionen.</li>
<li>Version 1.01. - September 2005. Mindre korrigeringar.</li>
<li>Version 1.02. - September 2005. La till m&ouml;jlighet att v&auml;lja sorteringsordning</li>
<li>Version 1.03. - September 2005. Korrigering r&ouml;rande konflikt i mallnamn</li>
<li>Version 1.04. - September 2005. La till m&ouml;jlighet att &aring;terscanna en mapp, och att ladda upp filer fr&aring;n admin-sidan</li>
<li>Version 1.05. - September 2005. Korrigering av n&aring;gra felaktiga PHP-variabler</li>
<li>Version 1.06. - September 2005. La till f&ouml;rfattarf&auml;lt i uppladdningsformul&auml;ret i admin-panelen, la till sammanfattningsf&auml;lt, och gjorde om beskrivning till text area, och till&aring;t anv&auml;ndaren att v&auml;lja namn p&aring; destinationsfilen</li>
<li>Version 1.07. - September 2005. La till m&ouml;jlighet att &auml;ndra filnamn, och korrigerade ett mindre fel f&ouml;r scanning av mapp</li>
<li>Version 1.08. - September 2005. Better handling of names with spaces, and a few minor errors fixed.  Added swedish translation (thanks westis)</li>
<li>Version 1.1.0. - Oktober 2005
 <ul>
   <li>Modifierade AttemptUpload-funktionen s&aring; att den kunde kallas utifr&aring;n</li>
   <li>La till GetUploadDetails-funktionen som returnerar alla detaljer om en modul, inklusive en l&auml;nk</li>
   <li>La till Redirects s&aring; att det &auml;r mycket trevligare att arbeta med modulen, den omdirigerar till den r&auml;tta fliken</li>
   <li>&Auml;ndrade front-mallen f&ouml;r att se b&auml;ttre ut och fungera vettigare</li>
   <li>Fixar f&ouml;r uppladdningen, s&aring; att beskrivningen st&auml;lls in och namn och sammanfattning hamnar p&aring; r&auml;tt st&auml;lle</li>
   <li>Fixar f&ouml;r att hantera mellanslag i namn &auml;nnu b&auml;ttre<li>
   <li>M&ouml;jlighet att v&auml;lja att l&auml;gga index.html-filer i varje uppladdningsmapp</li>
   <li>Om man specificerar ett m&aring;lnamn, och inget filtill&auml;gg anges, anv&auml;nds filtill&auml;gget f&ouml;r originalfilen</li>
 </ul>
 <p><em><b>Viktigt!</b></em><br/>Det &auml;r inte m&ouml;jligt att uppgradera fr&aring;n n&aring;gon annan version av Uploadsmodulen till 1.1.0.  Detta pga n&aring;gra fel som gjordes i databasrutinerna, och &auml;ven i uppgraderingsrutinen i 1.0.6. Du m&aring;ste avinstallera den gamla versionen och sedan ominstallera den nya versionen. Detta orsakar stora sv&aring;righeter om du har beskrivningar och annat i dina tabeller</p>
</li>
<li>Version 1.1.1. - Oktober, 2005. Fixade n&aring;gra mindre buggar i GetUploadDetails och la till ytterligare en l&auml;nk (eller en url) till de uppladdade filerna.</li>
<li>Version 1.1.2. - Oktober, 2005. Fixade URL-f&auml;ltet i GetUploadDetails f&ouml;r att returnera en nedladdningsl&auml;nk, och la till ett absurl-f&auml;lt som returnerar den absoluta s&ouml;kv&auml;gen till filen p&aring; webbservern. Klick p&aring; denna l&auml;nk kommer inte att r&auml;knas.</li>
<li>
<p>Version 1.1.3. - Oktober, 2005</p>
<p>Fixade uppgraderingsproblemen fr&aring;n 1.0.x-serien. De som anv&auml;nder 1.0.x b&ouml;r kunna uppgradera till 1.1.3. nu utan problem. <strong>De ber&ouml;mda sista orden, gl&ouml;m inte att ta backup f&ouml;rst!</strong>. Fixade content redirect-grejor som irriterade mig. La ocks&aring; till category=all f&ouml;r att lista alla uppladdningen i alla listbara kaegorier <em>(l&aring;t oss hoppas att fick ordning p&aring; sql-anropen)</em>.</p>
</li>
<li>
<p>Version 1.1.4. - Oktober, 2005</p>
<p>La till count-parametern f&ouml;r att lista de f&ouml;rsta X posterna, och la till &quot;summarylink&quot; och &quot;category&quot; i mallarna f&ouml;r westis. F&ouml;r exempel om hur de anv&auml;nds, &aring;terst&auml;ll dina mallar till standard.</p></li>
<li>
<p>Version 1.1.5. - November, 2005</p>
<p>La till e-postnotifiering och fixade n&aring;gra buggar</p>
</li>
<li>
<p>Version 1.1.6. - November, 2005</p>
<p>La till en API-funktion och fixade n&aring;gra redirection-grejor</p>
</li>
<li>
<p>Version 1.1.7. - November, 2005</p>
<p>Fler API-funktioner och ignorerar nu dot-filer vid scanning. E-postnotifiering &auml;r nu tillagt.</p>
</li>
<li>
<p>Version 1.1.8. - Januari, 2006</p>
<p>F&ouml;rb&auml;ttrade dokumentationen med Apache- och PHP-konfiguration.</p>
<p>&Auml;ndrade r&auml;ttigheterna, s&aring; att de &auml;r mer uppdelade.</p>
<p>La till n&aring;gra kommentarer och fler ord till kategori- och uppladdningsformul&auml;ren i administrationen</p>
<p>La till &quot;random&quot; (slumpvis) sorteringsordning</p>
</li>
<p>Version 1.1.9. - Januari, 2006</p>
<p>* La till m&ouml;jligheten att ladda upp en tumnagelbild</p>
<p>* B&auml;ttre granskning</p>
<p>* XML tillagt till standardfiltyperna (enbart vid ny installation)</p>
<p>* La till ett bekr&auml;ftelsemeddelande f&ouml;r att &aring;terst&auml;lla standardknapparna f&ouml;r mallsidorna.</p>
<p>* La till parametern fil_extensions f&ouml;r uppladdningsforul&auml;ret</p>
<p>* Den valda kategorin i filfiltret fastnar (g&aring;r inte tillbaka till f&ouml;rsta kategorin).
<p>* La till en inst&auml;llning f&ouml;r att alltid l&auml;gga till filtill&auml;gg (standard &auml;r on (p&aring;) )</p>
<p>* La till en l&auml;nk till att redigera sidan, i namnkolumnen i listan &ouml;ver filer.</p>
<p>* Mindre &auml;ndringar i layouten och texten f&ouml;r att g&ouml;ra det tydligare.</p>
<p>* LA till download_url som en smartytagg som kan anv&auml;ndas i mallen</p>
<li>
<p>Version 1.1.10. - Februari, 2006</p>
<p>* Sammanfattning &auml;r nu filnamnet (utan filtill&auml;gg) om ingen sammanfattning har specificerats</p>
<p>* Nu korrekt beteende om tumnagelstill&auml;gget inte finns i listan &ouml;ver accepterade filtill&auml;gg</p>
<p>* Visar inte l&auml;ngre n&aring;got inneh&aring;ll i filtabben om inte n&aring;gon kategori har definierats</p>
<p>* Visar en l&auml;nk p&aring; felsidan som tar dig tillbaka till administrationspanelen</p>
<p>* M&ouml;jligt att ers&auml;tta uppladdade filer</p>
</li>
</ul>';
$lang['date'] = 'Datum';
$lang['dateuploaded'] = 'Datum uppladdad';
$lang['default'] = 'Standardinst&auml;llningar';
$lang['delete'] = 'Ta bort';
$lang['description'] = 'Beskrivning';
$lang['destname'] = 'Ladda upp som';
$lang['detail_template'] = 'Detaljmall';
$lang['downloaded'] = 'Filen %s &auml;r nedladdad.';
$lang['downloads'] = 'Nedladdningar';
$lang['edit'] = 'Redigera';
$lang['editcategory'] = 'Redigera kategori';
$lang['editupload'] = 'Redigera uppladdning';
$lang['error'] = 'Fel!';
$lang['error_pathinuse'] = 'En kategori med den s&ouml;kv&auml;gen finns redan';
$lang['error_categoryexists'] = 'Fel: Kategorin finns redan';
$lang['error_categorynotempty'] = 'Fel! Kan inte ta bort en kategori som inte &auml;r tom';
$lang['error_categorynotfound'] = 'Fel: Kategorin hittas inte!';
$lang['error_dberror'] = 'Fel: Databasfel!';
$lang['error_emptycategory'] = 'Fel: Tom kategori!';
$lang['error_emptypath'] = 'Fel: Tom s&ouml;kv&auml;g!';
$lang['error_fileexists'] = 'Fel! En fil med detta namnet finns redan.';
$lang['error_filenotfound'] = 'Fel! Filen %s hittades inte.';
$lang['error_insufficientparams'] = 'Fel: Otillr&auml;ckliga parametrar angivna f&ouml;r modulen!';
$lang['error_invalidauthor'] = 'Fel: Felaktig (eller tom) f&ouml;rfattare.';
$lang['error_invalidcategory'] = 'Fel: Felaktig (eller tom) kategori.';
$lang['error_invaliddescription'] = 'Fel: Felaktig (eller tom) beskrivning.';
$lang['error_invalidfile'] = 'Fel: Felaktigt (eller tomt) filnamn.';
$lang['error_invaliduploadfilename'] = 'Fel: Filer med det namnet (troligen med det filtill&auml;gget) &auml;r inte till&aring;tna.';
$lang['error_invaliduploadid'] = 'Fel: Ogiltigt uppladdnings-id';
$lang['error_nofiles'] = 'Fel: Inga matchande filer!';
$lang['files'] = 'Filer';
$lang['fixme'] = 'Fixa mellanslag';
$lang['friendlyname'] = 'Uppladdning';
$lang['help'] = '<h3>Vad g&ouml;r den h&auml;r modulen?</h3>
<p>Det &auml;r en modul som g&ouml;r det m&ouml;jligt att ladda upp och ladda ner filer till och fr&aring;n din webbsida. Den h&aring;ller reda p&aring; vem som laddade upp en fil och vem som har laddat ner den.
Dessutom kan du dela in filer i kategorier och hantera filerna som &auml;r uppladdade p&aring; samma s&auml;tt som alla administrat&ouml;rer ska kunna g&ouml;ra.</p> 

<h3>Hur anv&auml;nder jag modulen?</h3>
<p>F&ouml;r att anv&auml;nda den h&auml;r modulen - allts&aring; att till&aring;ta anv&auml;ndare att ladda upp filer till din webbsida - m&aring;ste du installera modulen och d&auml;refter skapa en eller flera kategorier/mappar
som de uppladdade filerna kan l&auml;ggas i (i modulinst&auml;llningarna). L&auml;gg sedan till en tagg p&aring; en sida eller mall ungef&auml;r s&aring; h&auml;r {cms_module module=&quot;Uploads&quot; category=&quot;enkategori&quot; mode=&quot;stil&quot;}. 
Stilen ska d&aring; matcha n&aring;gon av stilarna nedan. Vad som skrivs ut skiljer sig beroende p&aring; vilken stil du v&auml;ljer.</p>

<p>Den h&auml;r modulen kan anv&auml;nda UserID-modulen (valfritt) f&ouml;r att f&aring; information om alla inloggade anv&auml;ndare f&ouml;r att delvis fylla i formul&auml;ret n&auml;r filer laddas upp;</p>

<h3>R&auml;ttigheter</h3>
<ul>
<li><em>Manage Uploads</em> - beh&ouml;vs f&ouml;r att hantera kategorier och dess filer.</li>
<li><em>Modify Templates</em> - beh&ouml;vs f&ouml;r att &auml;ndra n&aring;gon av mallarna.</li>
<li><em>Modify Site Preferences</em> - beh&ouml;vs f&ouml;r att f&ouml;r att &auml;dnra filinst&auml;llningar.</li>
</ul>

<h3>Epost</h3>
<p>Den h&auml;r modulen kan skicka e-post n&auml;r en fil har laddats upp (se tabben Inst&auml;llningar). Men f&ouml;r att g&ouml;ra detta kr&auml;vs att modulen <strong>CMSMailer</strong> har installerats och konfigurerats. Detta &auml;r <em>valfritt</em> och om CMSMailer-modulen inte &auml;r installerad visas ingenting f&ouml;r anv&auml;ndaren, bara ett loggmeddelande kommer att l&auml;ggas till admin-loggen.</p>

<h3>Systeminst&auml;llningar</h3>
<p><strong>Notera:</strong> Den h&auml;r modulen kommer inte runt eller f&ouml;rbi n&aring;gra filstorleksbegr&auml;nsningar i php. Den fungerar tillsammans med dem. 
D&auml;rf&ouml;r m&aring;ste du eventuellt &auml;ndra i din php.ini-fil f&ouml;r att till&aring;ta uppladdning av filer s&aring; stora som du har st&auml;llt in i inst&auml;llningarna f&ouml;r uppladdningsmodulen.</p>

<h3>Not f&ouml;r Apache</h3>
<p>F&ouml;r att till&aring;ta st&ouml;rre filuppladdningar kan du beh&ouml;va &auml;ndra parametern upload_max_filesize i din php.ini-fil. Dessutom, parametern LimitRequestBody in din Apache-konfiguration kan beh&ouml;va &auml;ndras f&ouml;r att matcha parametern upload_max_filesize</p>
<p>Notera: parametern upload_max_filesize kan specificeras i bytes, kilobytes eller megabytes. Parameterna LimitRequestBody d&auml;remot, kan bara specificeras i bytes</p>';
$lang['id'] = 'Id';
$lang['installed'] = 'Modulversion %s installerad.';
$lang['ip_address'] = 'IP-address';
$lang['moddescription'] = 'En modul som l&aring;ter anv&auml;ndare ladda upp filer och l&aring;ter dig hantera dem.';
$lang['name'] = 'Namn';
$lang['renamemessage'] = '&Auml;ndra namnet h&auml;r f&ouml;r att g&ouml;ra en namn&auml;ndring';
$lang['path'] = 'S&ouml;kv&auml;g';
$lang['pathmessage'] = '&Auml;ndra kategorin h&auml;r f&ouml;r att flytta filen till en annan mapp';
$lang['pathinuploads'] = '(relativ till uppladdningsmappen)';
$lang['postinstall'] = 'Meddelande efter installation, t.ex. Gl&ouml;m inte att st&auml;lla in r&auml;ttigheter f&ouml;r &quot;Manage Uploads&quot; f&ouml;r att anv&auml;nda den h&auml;r modulen!';
$lang['postuninstall'] = 'Meddelande efter avinstallation, t.ex. &quot;Skit ocks&aring;! Besegrad igen!&quot;';
$lang['preferences'] = 'Inst&auml;llningar';
$lang['prefsupdated'] = 'Modulinst&auml;llningar uppdaterade.';
$lang['prompt_categorydesc'] = 'Beskrivning';
$lang['prompt_categorylistable'] = 'Filerna i den h&auml;r mappen kan listas';
$lang['prompt_categoryname'] = 'Kategorinamn';
$lang['prompt_categorypath'] = 'Server-s&ouml;kv&auml;g';
$lang['prompt_deletedirectory'] = 'Ta bort kategorimapp?';
$lang['prompt_max_uploadsize'] = 'Maximal filstorlek till&aring;ten (Kb)';
$lang['prompt_valid_uploadextensions'] = 'Till&aring;tna filtill&auml;gg f&ouml;r uppladdade filer';
$lang['scan'] = 'Scanna';
$lang['selectcategory'] = 'V&auml;lj kategori';
$lang['size'] = 'Storlek';
$lang['sizekb'] = 'Storlek (Kb)';
$lang['submit'] = 'L&auml;gg till';
$lang['summary_template'] = 'Sammanfattningsmall';
$lang['summary'] = 'Sammanfattning';
$lang['title_admin_panel'] = 'Uppladdningsmodul';
$lang['title_mod_admin'] = 'Admin-panel f&ouml;r modul';
$lang['title_mod_prefs'] = 'Inst&auml;llningar f&ouml;r modul';
$lang['title_sing_loudly'] = 'Sjung h&ouml;gt?';
$lang['title_subnet_exclusions'] = 'Exkludera subn&auml;t fr&aring;n statistik';
$lang['title_valid_uploadextensions'] = 'Till&aring;tna filtill&auml;gg';
$lang['uninstalled'] = 'Modul avinstallerad.';
$lang['upgraded'] = 'Modul uppgraderad till version %s.';
$lang['upload'] = 'Ladda upp';
$lang['uploaded'] = 'Filen %s &auml;r uppladdad.';
$lang['replaced'] = 'Filen %s ersattes av %s.';
$lang['deleted'] = 'Filen %s &auml;r borttagen.';
$lang['uploadform_template'] = 'Uppladdningsmall';
$lang['username'] = 'Anv&auml;ndarnamn';
$lang['warning_deletecategory'] = 'VARNING: Var f&ouml;rsiktig n&auml;r du tar bort kategorier. Filer kan g&aring;r f&ouml;rlorade';
$lang['welcome_text'] = '<p>V&auml;lkommen till admin-sektionen f&ouml;r Uppladdningsmodulen. H&auml;r skulle det s&auml;kert st&aring; n&aring;got annat om modulen faktiskt gjorde n&aring;got.</p>';
$lang['utmz'] = '156861353.1149619132.18.9.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/admin/approve-pending.php|utmcmd=referral';
$lang['utma'] = '156861353.566397030.1147555099.1149619132.1149700038.19';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.uninstall.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.upgrade.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/addcategory.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyR0aXRsZX0Ke2lmICRtZXNzYWdlICE9ICcnfQogIHtpZiAkZXJyb3IgIT0gJyd9CiAgICA8cD48Zm9udCBjb2xvcj0icmVkIj57JG1lc3NhZ2V9PC9mb250PjwvcD4KICB7ZWxzZX0KICAgIDxwPnskbWVzc2FnZX08L3A+CiAgey9pZn0Ke2Vsc2V9Cnskc3RhcnRmb3JtfQogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2NhdGVnb3J5bmFtZX08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2NhdGVnb3J5bmFtZX08YnIvPnskaW5mb19jYXRlZ29yeW5hbWV9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2NhdGVnb3J5ZGVzY308L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2NhdGVnb3J5ZGVzY308YnIvPnskaW5mb19jYXRlZ29yeWRlc2N9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2NhdGVnb3J5cGF0aH08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2NhdGVnb3J5cGF0aH08YnIvPnskaW5mb19jYXRlZ29yeXBhdGh9PGJyLz57JHBhdGhtZXNzYWdlfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9jYXRlZ29yeWxpc3RhYmxlfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfY2F0ZWdvcnlsaXN0YWJsZX08YnIvPnskaW5mb19jYXRlZ29yeWxpc3RhYmxlfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGhpZGRlbn17JHNjYW59eyRzdWJtaXR9eyRjYW5jZWx9PC9wPgogIDwvZGl2Pgp7JGVuZGZvcm19CnsvaWZ9Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/adminpanel.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskdGl0bGVfc2VjdGlvbn08L2gzPgo8cD57JGFkbWluX25hdn08L3A+Cnskd2VsY29tZV90ZXh0fQ==]]></data>
	</file>
	<file>
	  <filename>/templates/adminprefs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlIT0nJ308cD57JG1lc3NhZ2V9PC9wPnsvaWZ9Cnskc3RhcnRmb3JtfQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfbWF4X3VwbG9hZHNpemV9OjwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X21heF91cGxvYWRzaXplfTwvcD4KCTwvZGl2PgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfdmFsaWRfdXBsb2FkZXh0ZW5zaW9uc306PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfdmFsaWRfdXBsb2FkZXh0ZW5zaW9uc308L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHRpdGxlX3N1Ym5ldF9leGNsdXNpb25zfTo8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9zdWJuZXRfZXhjbHVzaW9uc308L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHRpdGxlX2R1bW15X2luZGV4X2h0bWx9OjwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2R1bW15X2luZGV4X2h0bWx9PC9wPgoJPC9kaXY+Cgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJCTxwIGNsYXNzPSJwYWdldGV4dCI+eyR0aXRsZV9lbmZvcmNlZXh0ZW5zaW9uc306PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZW5mb3JjZWV4dGVuc2lvbnN9PC9wPgoJPC9kaXY+Cgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJCTxwIGNsYXNzPSJwYWdldGV4dCI+eyR0aXRsZV9lbWFpbF9vbl91cGxvYWR9OjwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2VtYWlsX29uX3VwbG9hZH08L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHRpdGxlX3JlZGlyZWN0X29uX3VwbG9hZH06PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfcmVkaXJlY3Rfb25fdXBsb2FkfTwvcD4KCTwvZGl2PgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfdXNlcnRhZ19vbnVwbG9hZH06PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfdXNlcnRhZ19vbnVwbG9hZH08L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9PC9wPgoJPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/brieflist.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRpdGVtY291bnQgPiAwfQ0KPHRhYmxlIGNlbGxzcGFjaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4NCgk8dGhlYWQ+DQoJCTx0cj4NCgkJCTx0aD57JG5hbWV0ZXh0fTwvdGg+DQoJCQk8dGg+eyRhdXRob3J0ZXh0fTwvdGg+DQoJCSAgICAgICAgPHRoPnskZGF0ZXRleHR9PC90aD4NCgkJCTx0aD57JHNpemV0ZXh0fTwvdGg+CQ0KCQk8L3RyPg0KCTwvdGhlYWQ+DQoJPHRib2R5Pg0KCXtmb3JlYWNoIGZyb209JGl0ZW1zIGl0ZW09ZW50cnl9DQoJCTx0ciBjbGFzcz0ieyRlbnRyeS0+cm93Y2xhc3N9Ij4NCgkJCTx0ZD57JGVudHJ5LT5uYW1lfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+YXV0aG9yfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+ZGF0ZX08L3RkPg0KCQkJPHRkPnskZW50cnktPnNpemV9PC90ZD4NCgkJPC90cj4NCgkJPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iPg0KICAgICAgICAgICAgICAgCQk8dGQgY29sc3Bhbj0iNCI+eyRlbnRyeS0+ZGVzY3JpcHRpb259PC90ZD4gDQoJCTwvdHI+DQoJey9mb3JlYWNofQ0KCTwvdGJvZHk+DQo8L3RhYmxlPg0Key9pZn0NCg==]]></data>
	</file>
	<file>
	  <filename>/templates/categorylist.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0icGFnZW9wdGlvbnMiPjxwIGNsYXNzPSJwYWdlb3B0aW9ucyI+eyRpdGVtY291bnR9IENhdGVnb3JpZXMgRm91bmQ8L3A+PC9kaXY+DQp7aWYgJGl0ZW1jb3VudCA+IDB9DQo8dGFibGUgY2VsbHNwYWNpbmc9IjAiIGNsYXNzPSJwYWdldGFibGUiPg0KCTx0aGVhZD4NCgkJPHRyPg0KCQkJPHRoIHdpZHRoPSIxNSUiPnskY2F0ZWdvcnl0ZXh0fTwvdGg+DQoJCQk8dGg+eyRuYW1ldGV4dH08L3RoPg0KCQkJPHRoPnskcGF0aHRleHR9PC90aD4NCgkJCTx0aCBjbGFzcz0icGFnZWljb24iPiZuYnNwOzwvdGg+DQoJCQk8dGggY2xhc3M9InBhZ2VpY29uIj4mbmJzcDs8L3RoPg0KCQk8L3RyPg0KCTwvdGhlYWQ+DQoJPHRib2R5Pg0Ke2ZvcmVhY2ggZnJvbT0kaXRlbXMgaXRlbT1lbnRyeX0NCgkJPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iPg0KCQkJPHRkPnskZW50cnktPmlkfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+bmFtZX08L3RkPg0KCQkJPHRkPnskZW50cnktPnBhdGh9PC90ZD4NCgkJCTx0ZD57JGVudHJ5LT5lZGl0bGlua308L3RkPg0KCQkJPHRkPnskZW50cnktPmRlbGV0ZWxpbmt9PC90ZD4NCgkJPC90cj4NCgkJPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iPiANCgkJCTx0ZD4mbmJzcDs8L3RkPg0KCQkJPHRkIGNvbHNwYW49IjQiPnskZW50cnktPmRlc2NyaXB0aW9ufTwvdGQ+DQoJCTwvdHI+DQoJIA0Key9mb3JlYWNofQ0KCTwvdGJvZHk+DQo8L3RhYmxlPg0Key9pZn0NCjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj48cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskYWRkbGlua308L3A+PC9kaXY+DQo=]]></data>
	</file>
	<file>
	  <filename>/templates/deletecategory.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19Cgk8cD57JHdhcm5pbmdfZGVsZXRlY2F0ZWdvcnl9PC9wPgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2RlbGV0ZWRpcmVjdG9yeX06PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZGVsZXRlZGlyZWN0b3J5fTwvcD4KCTwvZGl2PgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGhpZGRlbn17JHN1Ym1pdH08L3A+Cgk8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/edittemplate.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRmb3Jtc3RhcnR9eyRoaWRkZW59CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF90ZW1wbGF0ZW5hbWV9OjwvcD4KICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHRlbXBsYXRlbmFtZX08L3A+CjwvZGl2Pgo8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdGVtcGxhdGV9OjwvcD4KICA8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskdGVtcGxhdGV9PC9wPgo8L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICA8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KICA8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskc3VibWl0fXskY2FuY2VsfTwvcD4KPC9kaXY+CnskZm9ybWVuZH0K]]></data>
	</file>
	<file>
	  <filename>/templates/edittemplates.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KPHRhYmxlIGNlbGxzcGFjaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4KICA8dGhlYWQ+CiAgICA8dHI+CiAgICAgIDx0aD57JG5hbWVwcm9tcHR9PC90aD4KICAgICAgPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KICAgICAgPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KICAgIDwvdHI+CiAgPC90aGVhZD4Ke2ZvcmVhY2ggZnJvbT0kaXRlbXMgaXRlbT1lbnRyeX0KICAgPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iPgogICAgIDx0ZD57JGVudHJ5LT5uYW1lfTwvdGQ+CiAgICAgPHRkPnskZW50cnktPmVkaXRsaW5rfTwvdGQ+CiAgICAgPHRkPnskZW50cnktPmRlbGV0ZWxpbmt9PC90ZD4KICAgPC90cj4Key9mb3JlYWNofQo8L3RhYmxlPgo8L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICA8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskbmV3dGVtcGxhdGVsaW5rfTwvcD4KPC9kaXY+Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/editupload.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/error.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskdGl0bGVfZXJyb3J9PC9oMz4KPHA+eyRhZG1pbl9uYXZ9PC9wPgp7aWYgJG1lc3NhZ2UhPScnfTxwPnskbWVzc2FnZX08L3A+ey9pZn0Ke2lmICRsaW5rIT0nJ308cD57JGxpbmt9PC9wPnsvaWZ9Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/expandedlist.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19DQo8ZGl2IGNsYXNzPSJwYWdlb3B0aW9ucyI+DQogIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRjYXRlZ29yeX08L3A+DQogIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfY2F0ZWdvcnl9eyRpbnB1dF9zZWxlY3R9eyRpbnB1dF9oaWRkZW59PC9wPg0KPC9kaXY+DQp7JGVuZGZvcm19DQp7aWYgJGl0ZW1jb3VudCA+IDB9DQo8dGFibGUgY2VsbHNwYWNpbmc9IjAiIGNsYXNzPSJwYWdldGFibGUiPg0KCTx0aGVhZD4NCgkJPHRyPg0KCQkJPHRoPnskdGl0bGV0ZXh0fTwvdGg+DQoJCQk8dGg+eyRwb3N0ZGF0ZXRleHR9PC90aD4NCgkJCTx0aCBjbGFzcz0icGFnZWljb24iPiZuYnNwOzwvdGg+DQoJCQk8dGggY2xhc3M9InBhZ2VpY29uIj4mbmJzcDs8L3RoPg0KCQk8L3RyPg0KCTwvdGhlYWQ+DQoJPHRib2R5Pg0KCXtmb3JlYWNoIGZyb209JGl0ZW1zIGl0ZW09ZW50cnl9DQoJCTx0ciBjbGFzcz0ieyRlbnRyeS0+cm93Y2xhc3N9IiBvbm1vdXNlb3Zlcj0idGhpcy5jbGFzc05hbWU9J3skZW50cnktPnJvd2NsYXNzfWhvdmVyJzsiIG9ubW91c2VvdXQ9InRoaXMuY2xhc3NOYW1lPSd7JGVudHJ5LT5yb3djbGFzc30nOyI+DQoJCQk8dGQ+eyRlbnRyeS0+aWR9PC90ZD4NCgkJCTx0ZD57JGVudHJ5LT5uYW1lfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+YXV0aG9yfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+aXB9PC90ZD4NCgkJCTx0ZD57JGVudHJ5LT5kYXRlfTwvdGQ+DQoJCQk8dGQ+eyRlbnRyeS0+ZGVsZXRlbGlua308L3RkPg0KCQk8L3RyPg0KCQk8dHIgY2xhc3M9InskZW50cnktPnJvd2NsYXNzfSIgb25tb3VzZW92ZXI9InRoaXMuY2xhc3NOYW1lPSd7JGVudHJ5LT5yb3djbGFzc31ob3Zlcic7IiBvbm1vdXNlb3V0PSJ0aGlzLmNsYXNzTmFtZT0neyRlbnRyeS0+cm93Y2xhc3N9JzsiPg0KCSAgICAgICAgCTx0ZD4mbmJzcDs8L3RkPg0KICAgICAgICAgICAgICAgCQk8dGQgY29sc3Bhbj0iNSI+eyRlbnRyeS0+ZGVzY3JpcHRpb259PC90ZD4gDQoJCTwvdHI+DQoJey9mb3JlYWNofQ0KCTwvdGJvZHk+DQo8L3RhYmxlPg0Ke2Vsc2V9DQo8L2JyPg0KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCiAgIDxwIGNsYXNzPSJwYWdlb3B0aW9ucyI+Tm8gRmlsZXMgRGV0ZWN0ZWQ8L3A+DQo8L2Rpdj4NCnsvaWZ9DQo=]]></data>
	</file>
	<file>
	  <filename>/templates/uploadform.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e3N0YXJ0Zm9ybX0KPHA+eyRwcm9tcHRfdXBsb2FkfXskaGlkZGVufXskaW5wdXRfc3VibWl0fTwvcD4Ke2VuZGZvcm19Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/uploadlist.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/Uploads.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Uploads -= allow users to upload stuff, a pseudo file manager" module
# Version: 1.2.3, calguy1000
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2005 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http:	//www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------

class Uploads extends CMSModule
{
 /**
  * The default template used in email notifications
  */
  var $dflt_emailnotifytemplate = '
<!-- Email form template -->
<p>This message is to notify you that a file has been uploaded to your website.  The details of this upload are as follows:</p>
<p>Name: {$name}</p>
<p>Size: {$size}</p>
<p>Summary: {$summary}</p>
<p>Description: {$description}</p>
<p>Author: {$author}</p>
<p>IP Address: {$ip_address}</p>
<!-- Email form template -->
    ';
 /**
   * The default template used for the upload form
   */
  var $dflt_uploadformtemplate = '
<!-- Upload form template -->
{$startform}{$input_key}
{if $noauthor } 
{$input_author}
{else}
<p>{$prompt_author}&nbsp;{$input_author}</p>
{/if}
<p>{$prompt_summary}&nbsp;{$input_summary}</p>
<p>{$prompt_description}&nbsp;{$input_description}</p>
<p>{$prompt_destname}&nbsp;{$input_destname}&nbsp;{$info_destname}</p>
<p>{$prompt_thumbnail}&nbsp;{$input_thumbnail}&nbsp;{$info_thumbnail}</p>
<p>{$prompt_replace}&nbsp;{$input_replace}&nbsp;{$info_replace}</p>
<p>{$prompt_upload}{$hidden}{$input_browse}{$input_submit}</p>
{$endform}
<!-- Upload form template -->'
;

  /*
   * The default template used for the summary report
   */
  var $dflt_summarytemplate = '
<!-- Start Upload Display Template -->
{if $input_filter != \'\'}
{$startform}
{$prompt_filter}{$input_filter}{$hidden_params}{$input_submit}
{$endform}
<br/>
{$matches}&nbsp;{$matchestext}
{/if}
<table>
  <tr>
    <th>{$category}</th>
    <th>{$name}</th>
    <th>{$author}</th>
    <th>{$date}</th>
    <th>{$size}</th>
    <th>{$details}</th>
    <th>{$summary}</th>
    <th>{$description}</th>
  </tr>
{foreach from=$items item=entry}
  <tr class="{$entry->rowclass}"> 
    <th>{$entry->category}</td>
    <td>
      {$entry->name}
      <br/>
      {$entry->download_url}
      {if $entry->thumbnail_url}
        <br/>{$thumbnail}&nbsp;<img src="{$entry->thumbnail_url}" border=0>
      {/if}
    </td>
    <td>{$entry->author}</td>
    <td>{$entry->date}</td>
    <td>{$entry->size}</td>
    <td>{$entry->detaillink}</td>
    <td>{$entry->summary}</td>
    <td>{$entry->summarylink}</td>
  </tr>
{/foreach}
</table>
<!-- End Upload Display Template -->
';

  /**
   * The default template used for the detail report
   */
  var $dflt_detailtemplate = '
<!-- Detail template -->
{if $input_filter != \'\'}
{$startform}
{$prompt_filter}{$input_filter}{$hidden_params}{$input_submit}
{$endform}
<br/>
{$matches}&nbsp;{$matchestext}<br/>
{/if}
{foreach from=$items item=entry}
<table>
  {if $entry->thumbnail_url}
    <tr>
       <td>{$thumbnail}</td>
       <td><img src="{$entry->thumbnail_url}" border=0></td>
     </tr>
  {/if}
  <tr>
    <td>{$category}</td>
    <td>{$entry->category}</td>
  </tr>
  <tr>
    <td>{$id}</td>
    <td>{$entry->id}</td>
  </tr>
  <tr>
    <td>{$name}</td>
    <td>{$entry->name}<br/>{$entry->download_url}</td>
  </tr>
  <tr>
    <td>{$date}</td>
    <td>{$entry->date}</td>
  </tr>
  <tr>
    <td>{$author}</td>
    <td>{$entry->author}</td>
  </tr>
  <tr>
    <td>{$size}</td>
    <td>{$entry->size}</td>
  </tr>
  <tr>
    <td>{$summary}</td>
    <td>{$entry->summary}</td>
  </tr>
  <tr>
    <td>{$summary}</td>
    <td>{$entry->summarylink}</td>
  </tr>
  <tr>
    <td>{$description}</td>
    <td>{$entry->description}</td>
  </tr>
</table>
<br/>
<br/>
{/foreach}
<!-- Detail template -->
';

  var $upload_extensions = '';

  /*---------------------------------------------------------
    _explode_with_key( $Str, $inglue='=', $outglug='&');
    NOT PART OF THE MODULE API

    Explode a string into an associative array
    ---------------------------------------------------------*/
  function explode_with_key($str, $inglue='=', $outglue='&')
  {
    $ret = array();
    $a1 = split($outglue,$str);
    foreach( $a1 as $a2 )
    {
      list( $k, $v ) = split( $inglue, $a2 );
      $ret[ $k ] = $v;
    }
    return $ret;
  }


  /*---------------------------------------------------------
    _implode_with_key( $Str, $inglue='=', $outsglug='&');
    NOT PART OF THE MODULE API

    Implode an associative array into a string
    ---------------------------------------------------------*/
  function implode_with_key($assoc, $inglue = '=', $outglue = '&')
  {
     $return = null;
     foreach ($assoc as $tk => $tv) $return .= $outglue.$tk.$inglue.$tv;
     return substr($return,strlen($outglue));
  }

  /*---------------------------------------------------------
    _categoryPath( $categorypath )
    NOT PART OF THE MODULE API

    Generate a path to a certain category
    ---------------------------------------------------------*/
  function _categoryPath( $categorypath )
  {
    return $this->cms->config['uploads_path'].DIRECTORY_SEPARATOR.
               $categorypath;
  }


  /*---------------------------------------------------------
    UploadPath( $categorypath, $filename )
    NOT PART OF THE MODULE API

    Generate a file specification to a file in a certain 
    category.
    ---------------------------------------------------------*/
  function _uploadPath( $categorypath, $filename )
  {
    return $this->_categoryPath( $categorypath ).DIRECTORY_SEPARATOR.$filename;
  }


  /*---------------------------------------------------------
   _testip($range,$ip)
   NOT PART OF THE MODULE API

   This is a function to match an IP address against an 
   address range specification.
   ---------------------------------------------------------*/
  function _testip($range,$ip) 
  {
    $result = 1;

    # IP Pattern Matcher
    # J.Adams <jna@retina.net>
    #
    # Matches:
    #
    # xxx.xxx.xxx.xxx        (exact)
    # xxx.xxx.xxx.[yyy-zzz]  (range)
    # xxx.xxx.xxx.xxx/nn    (nn = # bits, cisco style -- i.e. /24 = class C)
    #
    # Does not match:
    # xxx.xxx.xxx.xx[yyy-zzz]  (range, partial octets not supported)
 
    if (ereg("([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/([0-9]+)",$range,$regs)) {
      # perform a mask match
      $ipl = ip2long($ip);
      $rangel = ip2long($regs[1] . "." . $regs[2] . "." . $regs[3] . "." . $regs[4]);
      
      $maskl = 0;
      
      for ($i = 0; $i< 31; $i++) {
	if ($i < $regs[5]-1) {
          $maskl = $maskl + pow(2,(30-$i));
	}
      }
      
      if (($maskl & $rangel) == ($maskl & $ipl)) {
	      return 1;
      } else {
	      return 0;
      }
    } else {
      
      # range based
      $maskocts = split("\.",$range);
      $ipocts = split("\.",$ip);
      
      # perform a range match
      for ($i=0; $i<4; $i++) {
	      if (ereg("\[([0-9]+)\-([0-9]+)\]",$maskocts[$i],$regs)) {
	  			if ( ($ipocts[$i] > $regs[2]) || ($ipocts[$i] < $regs[1])) {
	    			$result = 0;
	  			}
				}
				else
	  		{
	    		if ($maskocts[$i] <> $ipocts[$i]) {
	      		$result = 0;
	    	}
	  	}
      }
    }
    return $result;
  }


  /*---------------------------------------------------------
    getCategoryFromName()
    PUBLIC
  
    return the category id given a name, or false
   ---------------------------------------------------------*/
  function getCategoryFromName($name)
  {
    $db =& $this->GetDb();
    $query =
      "SELECT * FROM ".cms_db_prefix ().
      "module_uploads_categories WHERE upload_category_name = ?";
    $dbresult = $db->Execute ($query, array ($name));
    $row = $dbresult->FetchRow();
    if( !$row ) 
      {
	return false;
      }
    return $row;
  }


  /*---------------------------------------------------------
    getCategoryList()
    PUBLIC
  
    return a list of category names and id's
   ---------------------------------------------------------*/
  function getCategoryList()
  {
    $db =& $this->GetDB();
    $categorylist = array();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories";
    $dbresult = $db->Execute( $query );
    if( !$dbresult )
      {
        return $categorylist;
      }

    while( $row = $dbresult->FetchRow() )
      {
	$categorylist[$row['upload_category_name']] = 
	  $row['upload_category_id'];
      }
    return $categorylist;
  }


  /*---------------------------------------------------------
   getCategoryPathFromID()
   PUBLIC
  
   return the category path given a category id
   ---------------------------------------------------------*/
   function getCategoryPathFromID( $category_id )
   {
     $db =& $this->GetDb();
     $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories WHERE ".
       "upload_category_id = ?";
     $dbresult = $db->Execute( $query, array( $category_id ) );
     if( !$dbresult )
       {
	 return;
       }
     $row = $dbresult->FetchRow();
     if( !$row )
       {
	 return;
       }
     
     return $row['upload_category_path'];
   }


  /*---------------------------------------------------------
    getCategoryPathFromFileID()
    PUBLIC
  
    return the category path given a file id
   ---------------------------------------------------------*/
  function getCategoryPathFromFileID( $file_id )
  {
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $file_id) );
    if( !$dbresult )
      {
        return;
      }

    $row = $dbresult->FetchRow();
    if( !$row )
      {
	return;
      }
    $cat = $row['upload_category_id'];
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories WHERE ".
      "upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $cat ) );
    if( !$dbresult )
      {
	return;
      }
    $row = $dbresult->FetchRow();
    if( !$row )
      {
	return;
      }

    return $row['upload_category_path'];
  }


  /*---------------------------------------------------------
    getFileList( $category_id )
    PUBLIC
  
    return a list of files in the given category
   ---------------------------------------------------------*/
  function getFileList( $category_id )
  {
    $db =& $this->GetDb();
    $filelist = array();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads".
      " WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $category_id ) );
    if( !$dbresult )
      {
        return $filelist;
      }

    while( $row = $dbresult->FetchRow() )
      {
	$filelist[$row['upload_name']] = 
	  $row['upload_id'];
      }
    return $filelist;
  }


  /*---------------------------------------------------------
    getFileName( $file_id )
    PUBLIC
  
    return a list of files in the given category
   ---------------------------------------------------------*/
  function getFileName( $file_id )
  {
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads".
      " WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $file_id ) );
    $row = $dbresult->FetchRow();
    return $row['upload_name'];
  }

  
  /*---------------------------------------------------------
    getFileDetails( $file_id )
    PUBLIC
  
    return a list of files in the given category
   ---------------------------------------------------------*/
  function getFileDetails( $file_id )
  {
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads".
      " WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $file_id ) );
    $row = $dbresult->FetchRow();
    return $row;
  }

  
  /*---------------------------------------------------------
   _fixToAdjustTableStructure1()
   NOT PART OF THE MODULE API

   // move the description field, etc, into the proper place.
   ---------------------------------------------------------*/
   function _fixToAdjustTableStructure1()
   {
     $db =& $this->GetDb();

     // table schema description
     $flds = "upload_id I KEY,
             upload_category_id I,
             upload_name C(255),
             upload_author C(255),
             upload_summary C(255), 
             upload_description X,
             upload_ip C(255),
             upload_size I,
             upload_date T
	    ";

     // create it. This should do error checking, but I'm a lazy sod.
     $taboptarray = array ('mysql' => 'TYPE=MyISAM');
     $dict = NewDataDictionary ($db);
     $sqlarray = $dict->CreateTableSQL (cms_db_prefix()."module_uploads_new",
					$flds, $taboptarray);
     $dict->ExecuteSQLArray ($sqlarray);
     
     // now have to transfer the data
     $q = "INSERT INTO ".cms_db_prefix()."module_uploads_new 
              SELECT upload_id, upload_category_id, upload_name, upload_author, upload_description, '',
              upload_ip, upload_size, upload_date FROM ".cms_db_prefix()."module_uploads";
     $dbresult = $db->Execute( $q );
     if( !$dbresult ) {
       $this->SetError( $db->ErrorMsg() );
       return false;
     }
     
     // and drop the original table
     $sqlarray =
       $dict->DropTableSQL (cms_db_prefix ()."module_uploads",
			    $flds, $taboptarray);
     $dict->ExecuteSQLArray( $sqlarray );
     
     // and rename the new table
     $sqlarray =
       $dict->RenameTableSQL( cms_db_prefix()."module_uploads_new",
			      cms_db_prefix()."module_uploads" );
     $dict->ExecuteSQLArray( $sqlarray );
   }  


  /*---------------------------------------------------------
   _fixToAdjustTableStructure2()
   NOT PART OF THE MODULE API

   // move the description field, etc, into the proper place.
   ---------------------------------------------------------*/
   function _fixToAdjustTableStructure2()
   {
     $db =& $this->GetDb();

     // table schema description
     $flds = "upload_id I KEY,
             upload_category_id I,
             upload_name C(255),
             upload_author C(255),
             upload_summary C(255), 
             upload_description X,
             upload_ip C(255),
             upload_size I,
             upload_date T
	    ";

     // create it. This should do error checking, but I'm a lazy sod.
     $taboptarray = array ('mysql' => 'TYPE=MyISAM');
     $dict = NewDataDictionary ($db);
     $sqlarray = $dict->CreateTableSQL (cms_db_prefix()."module_uploads_new",
					$flds, $taboptarray);
     $dict->ExecuteSQLArray ($sqlarray);
     
     // now have to transfer the data
     $q = "INSERT INTO ".cms_db_prefix()."module_uploads_new 
              SELECT upload_id, upload_category_id, upload_name, upload_author, upload_summary, 
              upload_description,
              upload_ip, upload_size, upload_date FROM ".cms_db_prefix()."module_uploads";
     $dbresult = $db->Execute( $q );
     if( !$dbresult ) {
       $this->SetError( $db->ErrorMsg() );
       return false;
     }
     
     // and drop the original table
     $sqlarray =
       $dict->DropTableSQL (cms_db_prefix ()."module_uploads",
			    $flds, $taboptarray);
     $dict->ExecuteSQLArray( $sqlarray );
     
     // and rename the new table
     $sqlarray =
       $dict->RenameTableSQL( cms_db_prefix()."module_uploads_new",
			      cms_db_prefix()."module_uploads" );
     $dict->ExecuteSQLArray( $sqlarray );

     
   }  


  /*---------------------------------------------------------
   _getUploadCategoryDetails( $category_id )
   NOT PART OF THE MODULE API

   returns an associative array representing the specific
   row of the categories database matching the supplied 
   category id
   ---------------------------------------------------------*/
  function _getUploadCategoryDetails( $category_id )
  {
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $category_id ) );
    if( !$dbresult ) {
      return;
    }

    $row = $dbresult->FetchRow();
    if( !$row ) {
      return;
    }

    return $row;
  }


  /*---------------------------------------------------------
   _getUploadFileDetails( $category_id )
   NOT PART OF THE MODULE API

   returns an associative array matching the specific row of
   the uploads table matching the specified upload id
   ---------------------------------------------------------*/
  function _getUploadFileDetails( $file_id )
  {
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $file_id ) );
    if( !$dbresult ) {
      return;
    }
    $row = $dbresult->FetchRow();
    if( !$row ) {
      return;
    }

    return $row;
  }


  /*---------------------------------------------------------
    _scandir( $dir, $sort )
    NOT PART OF THE MODULE API

    Scan a directory and return a sorted list.
    ---------------------------------------------------------*/
  function _scandir($dir = './', $sort = 0)
  {
    $dir_open = @opendir($dir);
  
    if (! $dir_open)
       return false;
      
    $files = array();
    while (($dir_content = readdir($dir_open)) != false)
      {
	// we ignore index.html files if the preference is set
	if( $dir_content == 'index.html' && $this->GetPreference('create_dummy_index_html'))
	  {
	    continue;
	  }

	// ignore dot files
	if( preg_match( "/^\./", $dir_content ) )
	  {
	    continue;
	  }

	$files[] = $dir_content;
      }
  
    if( is_array( $files ) )
      {
	if ($sort == 1)
	  rsort($files, SORT_STRING);
	else
	  sort($files, SORT_STRING);
      }
  
    return $files;
  }


  /*---------------------------------------------------------
    _mkdirr( $pathname, $mode )
    NOT PART OF THE MODULE API

    Make a directory recursively
    ---------------------------------------------------------*/
  function _mkdirr ($pathname, $mode = 0777)
  {
    // Check if directory already exists
    if (is_dir ($pathname) || empty ($pathname))
    {
      return true;
    }

    // Ensure a file does not already exist with the same name
    if (is_file ($pathname))
    {
      // RC: Modification such that this isn't an error
      return true;
    }

    // Crawl up the directory tree
    $next_pathname =
      substr ($pathname, 0, strrpos ($pathname, DIRECTORY_SEPARATOR));
    if ($this->_mkdirr ($next_pathname, $mode))
    {
      if (!file_exists ($pathname))
      {
				return mkdir ($pathname, $mode);
      }
    }

    return false;
  }


  /*---------------------------------------------------------
   _isValidFilename( $filename )
   NOT PART OF THE MODULE API

   Test a string to see if it is a valid filename (i.e) the
   extension falls in our allowed extensions, and there are
   no invalid characters.
   ---------------------------------------------------------*/
  function _isValidFilename ($filename)
  {
    $file_name = trim ($filename);
    $extension = strtolower (strrchr ($file_name, "."));

    // array of files we don't allow
    $ext_str = $this->upload_extensions;
    if( $ext_str == '' )
      {
	$ext_str = $this->GetPreference ("valid_uploadextensions");
      }
    $ext_array = split (",", $ext_str);
    $ext_count = count ($ext_array);

    if (!$file_name)
    {
      return false;
    }
    else
    {
      if (!$ext_array)
      {
	return true;
      }
      else
      {
	foreach ($ext_array as $value)
	{
	  $first_char = substr ($value, 0, 1);
	  if ($first_char <> ".")
	  {
	    $extensions[] = ".".strtolower ($value);
	  }
	  else
	  {
	    $extensions[] = strtolower ($value);
	  }
	}

	$valid_extension = false;
	foreach ($extensions as $value)
	{
	  if ($value == $extension)
	  {
	    $valid_extension = true;
	    break;
	  }
	}

	return $valid_extension;
      }
    }
  }


  /*-----------------------------------------------------------
    END OF UTILITY FUNCTIONS
    ---------------------------------------------------------*/


  /*---------------------------------------------------------
   GetName()
   ---------------------------------------------------------*/
  function GetName ()
  {
    return 'Uploads';
  }


  /*---------------------------------------------------------
   GetFriendlyName()
   ---------------------------------------------------------*/
  function GetFriendlyName ()
  {
    return $this->Lang ('friendlyname');
  }


  /*---------------------------------------------------------
   GetEventDescription( $name )
   ---------------------------------------------------------*/
  function GetEventDescription( $name )
  {
    switch ( $name )
      {
      case 'OnUpload':
	return $this->Lang('info_event_onupload');
	break;
      case 'OnRemove':
	return $this->Lang('info_event_onremove');
	break;
      case 'OnDownload':
	return $this->Lang('info_event_ondownload');
	break;
      case 'OnCreateCategory':
	return $this->Lang('info_event_oncreatecategory');
	break;
      case 'OnDeleteCategory':
	return $this->Lang('info_event_ondeletecategory');
	break;
      }
    return "";
  }

  
  /*---------------------------------------------------------
   GetVersion()
   ---------------------------------------------------------*/
  function GetVersion ()
  {
    return '1.2.3';
  }


  /*---------------------------------------------------------
   GetEventHelp( $eventname )
   ---------------------------------------------------------*/
  function GetEventHelp ( $eventname )
  {
    return $this->Lang ('help_'.$eventname);
  }

  /*---------------------------------------------------------
   GetHelp()
   ---------------------------------------------------------*/
  function GetHelp ()
  {
    return $this->Lang ('help');
  }


  /*---------------------------------------------------------
   GetAuthor()
   ---------------------------------------------------------*/
  function GetAuthor ()
  {
    return 'calguy1000';
  }


  /*---------------------------------------------------------
   GetAuthorEmail()
   ---------------------------------------------------------*/
  function GetAuthorEmail ()
  {
    return 'rob@techcom.dyndns.org';
  }


  /*---------------------------------------------------------
   GetChangeLog()
   ---------------------------------------------------------*/
  function GetChangeLog ()
  {
    return $this->Lang ('changelog');
  }


  /*---------------------------------------------------------
   IsPluginModule()
   ---------------------------------------------------------*/
  function IsPluginModule ()
  {
    return true;
  }


  /*---------------------------------------------------------
   HasAdmin()
   ---------------------------------------------------------*/
  function HasAdmin ()
  {
    return true;
  }


  /*---------------------------------------------------------
   GetAdminSection()
   ---------------------------------------------------------*/
  function GetAdminSection ()
  {
    return 'content';
  }


  /*---------------------------------------------------------
   MinimumCMSVersion()
   ---------------------------------------------------------*/
  function MinimumCMSVersion ()
  {
    return '1.0-svn';
  }


  /*---------------------------------------------------------
   SetParameters()
   ---------------------------------------------------------*/
  function SetParameters ()
  {
    $this->CreateParameter('key', 'null', $this->Lang('param_key'));
    $this->CreateParameter('noauthor', 'false', $this->Lang('param_noauthor'));
    $this->CreateParameter('upload_id','id',$this->Lang('param_upload_id'));
    $this->CreateParameter('count','N',$this->Lang('param_count'));
    $this->CreateParameter('sortorder','sortorder',$this->Lang('param_sortorder'));
    $this->CreateParameter('file_extensions','ext1,ext2,ext3',$this->Lang('param_fileextensions'));
    $this->CreateParameter('category','upload_category',$this->Lang('param_category'),false);
    $this->CreateParameter('filter','filter',$this->Lang('param_filter'));
    $this->CreateParameter('no_initial','no_initial',$this->Lang('param_no_initial'));
    $this->CreateParameter('mode','mode',$this->Lang('param_mode'),false);
    $this->CreateParameter('use_strict_regexp','use_strict_regexp',$this->Lang('param_use_strict_regexp'));
    $this->CreateParameter('template','template',$this->Lang('param_template'));
  }

  /*---------------------------------------------------------
   GetAdminDescription()
   ---------------------------------------------------------*/
  function GetAdminDescription ()
  {
    return $this->Lang ('moddescription');
  }


  /*---------------------------------------------------------
   VisibleToAdminUser()
   ---------------------------------------------------------*/
  function VisibleToAdminUser ()
  {
    return $this->CheckPermission ('Manage Uploads') ||
      $this->CheckPermission('Modify Templates') ||
      $this->CheckPermission('Modify Site Preferences');
  }


  /*---------------------------------------------------------
   GetDependencies()
   ---------------------------------------------------------*/
  function GetDependencies ()
  {
    return array ();
  }


  /*---------------------------------------------------------
   InstallPostMessage()
   ---------------------------------------------------------*/
  function InstallPostMessage ()
  {
    return $this->Lang ('postinstall');
  }


  /*---------------------------------------------------------
   UninstallPostMessage()
   ---------------------------------------------------------*/
  function UninstallPostMessage ()
  {
    return $this->Lang ('postuninstall');
  }


  /*---------------------------------------------------------
   DoAction($action, $id, $params, $returnid)
   ---------------------------------------------------------*/
  function DoAction ($action, $id, $params, $returnid = -1)
  {
    switch ($action)
      {
      case 'do_upload':
	{
	  // a user is trying to upload something
	  $ret = $this->AttemptUpload ($id, $params, $returnid);
	  if( $ret[0] == FALSE )
	    {
	      $this->_DisplayErrorPage( $id, $params, $returnid,
				       $ret[1] );
	      return;
	    }
	  $str = $this->GetPreference('redirect_on_upload');
	  $id = $returnid;
	  if( $str != '' )
	    {
	      $id = ContentManager::GetPageIDFromAlias( $str );
	      if( !$id )
		{
		  // page not found, ignore it
		  $id = $returnid;
		}
	    }
	  $this->RedirectContent( $id );
	  break;
	}

      case 'save_admin_prefs':
	{
	  // only let people save module preferences if they have permission
	  if ($this->CheckPermission ('Modify Site Preferences'))
	    {
	      $this->_SaveAdminPrefs ($id, $params, $returnid);
	    }
	  break;
	}

      case 'addcategory':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminAddCategory ($id, $params, $returnid);
	    }
	  break;
	}

      case 'editcategory':
	{
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminEditCategory ($id, $params, $returnid);
	    }
	  break;
	}

      case 'do_editcategory':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminDoEditCategory ($id, $params, $returnid);
	    }
	  break;
	}

      case 'deletecategory':
	{
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminDeleteCategory ($id, $params, $returnid);
	    }
	  break;
	}

      case 'do_deletecategory':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminDoDeleteCategory ($id, $params, $returnid);
	    }
	  break;
	}

      case 'editupload':
	{
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminEditUpload ($id, $params, $returnid);
	    }
	  break;
	}

      case 'do_editupload':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminDoEditUpload ($id, $params, $returnid);
	    }
	  break;
	}

      case 'do_deleteupload':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Manage Uploads'))
	    {
	      $this->_AdminDoDeleteUpload ($id, $params, $returnid);
	    }
	  break;
	}

      case 'uploadformtemplate':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Modify Templates'))
	    {
	      if (isset ($params['defaultbutton']))
		{
		  $this->SetTemplate ('upload_uploadform', $this->dflt_uploadformtemplate);
		}
	      else
		{
		  $this->SetTemplate ('upload_uploadform', $params['templatecontent']);
		}
	      $this->myRedirectToTab($id, 'uploadform_template');
	    }
	  break;
	}

      case 'updateemailtemplate':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Modify Templates'))
	    {
	      if (isset ($params['defaultbutton']))
		{
		  $this->SetTemplate ('upload_emailtemplate',
				      $this->dflt_emailnotifytemplate);
		}
	      else
		{
		  $this->SetTemplate ('upload_emailtemplate', $params['templatecontent']);
		}
	      $this->myRedirectToTab($id, 'email_template');
	    }
	}

      case 'updatesummarytemplate':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Modify Templates'))
	    {
	      if (isset ($params['defaultbutton']))
		{
		  $this->SetTemplate ('upload_displaysummary',
				      $this->dflt_summarytemplate);
		}
	      else
		{
		  $this->SetTemplate ('upload_displaysummary', $params['templatecontent']);
		}
	      $this->myRedirectToTab($id, 'summary_template');
	    }
	  break;
	}

      case 'updatedetailtemplate':
	{
	  // check permissions again
	  if ($this->CheckPermission ('Modify Templates'))
	    {
	      if (isset ($params['defaultbutton']))
		{
		  $this->SetTemplate ('upload_displaydetail', $this->dflt_detailtemplate);
		}
	      else
		{
		  $this->SetTemplate ('upload_displaydetail', $params['templatecontent']);
		}
	      $this->myRedirectToTab($id, 'detail_template');
	    }
	  break;
	}

      default:
	parent::DoAction( $action, $id, $params, $returnid );
	break;
      }
  }

function SearchResult($returnid, $articleid, $attr = '')
  {
    $db =& $this->GetDb();
    $result = array();
    if( $attr == 'upload')
      {
	// get the category id for an upload id
	$details = $this->GetUploadDetails($articleid,'');
	
	// now get the category name instead of the category id, god 
	// was I stupid.
	$q = "SELECT upload_category_name AS name FROM ".cms_db_prefix()."module_uploads_categories
              WHERE upload_category_id = ?";
	$dbresult = $db->Execute( $q, array($details['upload_category_id']) );
	if( !$dbresult || !$dbresult->RecordCount() )
	  {
	    die( 'error' );
	    // todo, audit
	    return;
	  }
	$row = $dbresult->FetchRow();
	$result[0] = $this->GetFriendlyName();
	$result[1] = $details['upload_name'];
	$result[2] = $this->CreateLink( $articleid, 'default', $returnid, $details['upload_name'],
					array('mode'=>'single',
					      'upload_id' => $articleid,
					      'category' => $row['name'] ), '', true);
	return $result;
      }
  }

  function SearchReIndex(&$module)
  {
    $db =& $this->GetDb();

    $query = "SELECT upload_id, upload_name, upload_author, upload_summary, upload_description, upload_ip, upload_date FROM cms_module_uploads A, cms_module_uploads_categories B WHERE A.upload_category_id = B.upload_category_id AND B.upload_category_listable = ?";
    $dbresult = $db->Execute( $query, array( 1 ) );
    if( !$dbresult )
      {
	die( $db->ErrorMsg() );
      }
    while( $row = $dbresult->FetchRow() )
      {
	$str = $row['upload_name'].' '.$row['upload_author'].' '.
	  $row['upload_summary'].' '.$row['upload_description'];
	$module->AddWords( $this->GetName(), $row['upload_id'], 'upload', $str );
      }
  }

  /*---------------------------------------------------------
   BEGIN OF UI SUPPORT FUNCTIONS
   ---------------------------------------------------------*/

  /*---------------------------------------------------------
   _AdminCreateTemplateList( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   A function that provides a list of templates matching
   a prefix, and the appropriate edit, add, and delete links.
   ---------------------------------------------------------*/
   function _AdminCreateTemplateList( $id, $returnid, $prefix )
    {
      // we're gonna allow multiple templates here
      // but we're gonna prefix them all with uploadform_
      global $gCms;

      $alltemplates = $this->ListTemplates();
      $rowarray = array();
      $rowclass = 'row1';
      foreach( $alltemplates as $onetemplate )
	{
	  if( !preg_match("/^$prefix/", $onetemplate ) )
	    {
	      continue;
	    }
	  
	  $tmp = substr($onetemplate,strlen($prefix));
	  $row = new StdClass();
	  $row->name = $this->CreateLink( $id, 'edittemplate', $returnid,
					  $tmp, array('template' => $onetemplate ));
	  $row->rowclass = $rowclass;
	  $row->editlink = $this->CreateLink( $id, 'edittemplate', $returnid,
					      $gCms->variables['admintheme']->
					      DisplayImage ('icons/system/edit.gif',
							    $this->Lang ('edit'), '', '', 'systemicon'),
					      array ('template' => $onetemplate),
					      $this->Lang ('areyousure'));

	  $tmp = $prefix."default";
	  if( $onetemplate == $tmp )
	    {
	      $row->deletelink = '&nbsp;';
	    }
	  else
	    {
	      $row->deletelink = $this->CreateLink( $id, 'deletetemplate', $returnid,
						    $gCms->variables['admintheme']->
						    DisplayImage ('icons/system/delete.gif',
								  $this->Lang ('delete'), '', '', 'systemicon'),
						    array ('template' => $onetemplate),
						    $this->Lang ('areyousure'));
	    }
	      
	  array_push ($rowarray, $row);
	  ($rowclass == "row1" ? $rowclass = "row2" : $rowclass = "row1");
	}

      $this->smarty->assign('items', $rowarray );
      $this->smarty->assign('nameprompt', $this->Lang('name'));
      $this->smarty->assign('newtemplatelink',
			    $this->CreateLink( $id, 'edittemplate', $returnid,
					       $this->Lang('prompt_newtemplate'),
					       array('prefix' => $prefix )));
      $this->smarty->assign($this->CreateFormEnd());
      echo $this->ProcessTemplate('edittemplates.tpl');
    }


  /*---------------------------------------------------------
   _AdminEditCategory( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   A function that provides the form for the user to edit
   category details.
   ---------------------------------------------------------*/
  function _AdminEditCategory ($id, &$params, $returnid)
  {
    $db =& $this->GetDb();
    $this->smarty->assign ('title', $this->Lang ('editcategory'));
    
    // check things out
    if (!isset ($params['category_id']))
      {
	$this->smarty->assign ('message', $this->Lang ('error_nocategory'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('addcategory.tpl');
	return;
      }

    // get the category info from the database (for this category)
    $query =
      "SELECT * FROM ".cms_db_prefix ().
      "module_uploads_categories WHERE upload_category_id = ?";
    $dbresult = $db->Execute ($query, array($params['category_id']));
    if (!$dbresult)
      {
	$this->smarty->assign ('message', $this->Lang ('error_dberror'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('addcategory.tpl');
	return;
      }
    $row = $dbresult->FetchRow ();
    if (!$row)
      {
	$this->smarty->assign ('message', $this->Lang ('error_dberror'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('addcategory.tpl');
	return;
      }

    // populate the template
    $this->smarty->assign ("startform",
				  $this->CreateFormStart ($id, 'do_editcategory', $returnid));
    $this->smarty->assign ('submit',
				  $this->CreateInputSubmit ($id, 'submit', $this->Lang('submit')));
    $this->smarty->assign ('cancel',
				  $this->CreateInputSubmit ($id, 'cancel', $this->Lang('cancel')));    
    $this->smarty->assign ('scan',
	    $this->CreateInputSubmit( $id, 'scan', $this->Lang('scan')));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());

    $this->smarty->assign ('prompt_categoryname', $this->Lang ('prompt_categoryname'));
    $this->smarty->assign ('input_categoryname', $this->CreateInputText ($id, 'input_categoryname',
									 $row['upload_category_name'], 20, 80));
    $this->smarty->assign ('info_categoryname', $this->Lang('info_categoryname'));
    $this->smarty->assign ('prompt_categorydesc', $this->Lang ('prompt_categorydesc'));
    $this->smarty->assign ('input_categorydesc',
			   $this->CreateInputText ($id, 'input_categorydesc',
						   $row['upload_category_description'], 80, 255));
    $this->smarty->assign ('info_categorydesc', $this->Lang('info_categorydesc'));
    $this->smarty->assign ('prompt_categorypath',$this->Lang ('prompt_categorypath'));
    $this->smarty->assign ('input_categorypath',
			   $this->CreateInputText ($id, 'input_categorypath',$row['upload_category_path'],
						   80, 255, "readonly"));
    $this->smarty->assign ('info_categorypath', $this->Lang('info_categorypath'));
    $this->smarty->assign ('prompt_categorylistable', $this->Lang ('prompt_categorylistable'));
    $this->smarty->assign ('input_categorylistable',
			   $this->CreateInputCheckbox ($id,
						       'input_categorylistable', 1, $row['upload_category_listable']));
    $this->smarty->assign ('pathmessage', $this->Lang ('cannotmodifypath'));
    $this->smarty->assign ('hidden',
				  $this->CreateInputHidden ($id, 'category_id',
							    $params['category_id']));
    
    echo $this->ProcessTemplate ('addcategory.tpl');
  }


  /*---------------------------------------------------------
   _AdminDeleteCategory( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   Function that provides a form to allow the user to delete
   a category from the database.
   ---------------------------------------------------------*/
  function _AdminDeleteCategory ($id, &$params, $returnid)
  {
    if( !isset( $params['category_id'] ) )
      {
	$this->_DisplayErrorPage ($id, $params, $returnid,
				 $this->Lang ('error_insufficientparams'));
	return;
      }

    // test to see if there are still files left in this category, if there are, then puke
    // otherwise delete the directory too (maybe)
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $params['category_id'] ) );
    $c = $dbresult->RecordCount();
    if( $dbresult->RecordCount() )
      {
	$this->_DisplayErrorPage ($id, $params, $returnid,
				 $this->Lang ('error_categorynotempty'));
	return;
      }

    // display something to allow the user to delete the category.... will (optionally) delete
    // all of the (managed) files in the directory too.
    $this->smarty->assign( 'warning_deletecategory',
			   $this->Lang('warning_deletecategory') );
    $this->smarty->assign( 'startform' ,
			   $this->CreateFormStart( $id, 'do_deletecategory', $returnid));
    $this->smarty->assign( 'hidden',
			   $this->CreateInputHidden( $id, 'category_id', $params['category_id']) );
    $this->smarty->assign( 'prompt_deletedirectory',
			   $this->Lang('prompt_deletedirectory') );
    $this->smarty->assign( 'input_deletedirectory',
			   $this->CreateInputCheckbox( $id,
						       'input_deletedirectory',
						       1,0 ) );					
    $this->smarty->assign ('submit', $this->CreateInputSubmit ($id, 'submit', $this->Lang('submit')));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());
    echo $this->ProcessTemplate('deletecategory.tpl');
  }


  /*---------------------------------------------------------
   _AdminDoDeleteCategory( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   A function that actually does the deletion of the category
   given the category id in the parameters, and a few other
   necessary details.  This function also will optionally
   remove all files from the directory... though I am not
   certain if this is good code
   ---------------------------------------------------------*/
  function _AdminDoDeleteCategory ($id, &$params, $returnid)
  {
    if( !isset( $params['category_id'] ) )
      {
	$this->_DisplayErrorPage ($id, $params, $returnid,
				 $this->Lang ('error_insufficientparams'));
	return;
      }

    // get the category details
    $category = $this->_getUploadCategoryDetails( $params['category_id'] );
    if( !$category ) {
	$this->_DisplayErrorPage ($id, $params, $returnid,
				 $this->Lang ('error_dberror'));
	return;
    }

    if( isset( $params['input_deletedirectory']) && $params['input_deletedirectory'] )
      {
	$p = $this->_categoryPath( $category['upload_category_path'] );
	$dir_open = @opendir( $p );
	if( !$dir_open ) {
	  $this->_DisplayErrorPage ($id, $params, $returnid,
				   $this->Lang ('error_patherror'));
	  return;
	}

	while(($dir_content = readdir($dir_open)) != false)
	  {
	    if( is_file( $p.DIRECTORY_SEPARATOR.$dir_content ) ) {
	      unlink( $p.DIRECTORY_SEPARATOR.$dir_content );
	    }
	  }

	// now try to unlink the directory itself
	// but ignore any errors.
	rmdir( $p );
      }


    // delete the directory category
    $db =& $this->GetDb();
    $query = "DELETE FROM ".cms_db_prefix()."module_uploads_categories WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $params['category_id'] ) );

    // send an event
    $parms[] = array();
    $parms['name'] = $category['upload_category_name'];
    $parms['path'] = $category['upload_category_path'];
    $this->SendEvent('OnDeleteCategory',$parms);

    // and we're done
    $this->myRedirectToTab( $id, 'categories' );
  }


  /*---------------------------------------------------------
   _AdminEditUpload( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   A function that provides a form to allow the user to edit
   the parameters or details of an uploaded file.
   ---------------------------------------------------------*/
  function _AdminEditUpload ($id, &$params, $returnid)
  {
    $db =& $this->GetDb();
    $this->smarty->assign ('title', $this->Lang ('editupload'));
    
    // check things out
    if (!isset ($params['upload_id']))
      {
	$this->smarty->assign ('message', $this->Lang ('error_noid'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('editupload.tpl');
	return;
      }

    // get the info from the database (for this file)
    $query =
      "SELECT * FROM ".cms_db_prefix ().
      "module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute ($query, array($params['upload_id']));
    if (!$dbresult)
      {
	$this->smarty->assign ('message', $this->Lang ('error_dberror'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('editupload.tpl');
	return;
      }
    $row = $dbresult->FetchRow ();
    if (!$row)
      {
	$this->smarty->assign ('message', $this->Lang ('error_dberror'));
	$this->smarty->assign ('error', 1);
	echo $this->ProcessTemplate ('editupload.tpl');
	return;
      }

    // and the category info for this category
    $catpath = $this->getCategoryPathFromID($row['upload_category_id']);

    // get the category list
    $categorylist = array ();
    $query =
      "SELECT * FROM ".cms_db_prefix ().
      "module_uploads_categories ORDER BY upload_category_name ASC";
    $dbresult = $db->Execute ($query);
    if (!$dbresult)
      {
	$this->smarty->assign ('error', 1);
	$this->smarty->assign ('message', $this->Lang ('error_nocategories'));
      }
    else
      {
	// this could probably be done with a for_each, but what the hell
	while ($row2 = $dbresult->FetchRow ())
	  {
	    $categorylist[$row2['upload_category_name']] =
	      $row2['upload_category_id'];
	  }
      }

    // populate the template
    $this->smarty->assign ("startform",
				  $this->CreateFormStart ($id, 'do_editupload', $returnid));
	  // todo check this to see if there are spaces in the name
    $this->smarty->assign ('fix',
		      $this->CreateInputSubmit ($id, 'fix', $this->Lang('fixme')));
    $this->smarty->assign ('submit',
				  $this->CreateInputSubmit ($id, 'submit', $this->Lang('submit')));
    $this->smarty->assign ('cancel',
				  $this->CreateInputSubmit ($id, 'cancel', $this->Lang('cancel')));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());
    

    $this->smarty->assign ('prompt_uploadname', $this->Lang('name'));
    $this->smarty->assign ('input_uploadname', 
			   $this->CreateInputText($id,'input_uploadname',
						  $row['upload_name'], 20, 255 ));
    // thumbnail?
    $tnfile = $this->_categoryPath( $catpath.DIRECTORY_SEPARATOR.
				    '.thumbs'.DIRECTORY_SEPARATOR.$params['upload_id'].'_thumb');
    if( file_exists( $tnfile ) )
      {
	$tnurl = $this->cms->config['uploads_url']."/".$catpath.'/.thumbs/'.$params['upload_id'].'_thumb';
	$this->smarty->assign ('prompt_thumbnail', $this->Lang('thumbnail').':');
	$this->smarty->assign ('pic_thumbnail', '<img src="'.$tnurl.'" border="0"/>');
      }
    $this->smarty->assign ('namemessage', $this->Lang('renamemessage'));
    $this->smarty->assign ('prompt_uploaddate', $this->Lang('dateuploaded'));
    $this->smarty->assign ('data_uploaddate', $row['upload_date']);
    $this->smarty->assign ('prompt_uploadsize', $this->Lang('sizekb'));
    $this->smarty->assign ('data_uploadsize', intval($row['upload_size'] / 1024.0 + 0.5));
    $this->smarty->assign ('prompt_uploadauthor', $this->Lang('author'));
    $this->smarty->assign ('input_uploadauthor', 
			   $this->CreateInputText($id, 'input_uploadauthor',
						  $row['upload_author'], 20, 255));
    $this->smarty->assign ('prompt_movecategory', $this->Lang ('prompt_categoryname'));
    $this->smarty->assign ('input_movecategory',
			   $this->CreateInputDropDown ($id, "input_movecategory", $categorylist, -1,
						       $row['upload_category_id']));
    $this->smarty->assign ('pathmessage', $this->Lang('pathmessage'));

    $this->smarty->assign ('prompt_uploadsummary', $this->Lang ('summary'));
    $this->smarty->assign ('input_uploadsummary',
			   $this->CreateInputText ($id, 'input_uploadsummary',
						   $row['upload_summary'], 80, 255));

    $this->smarty->assign ('prompt_uploaddesc', $this->Lang ('description'));
    $this->smarty->assign ('input_uploaddesc',
			   $this->CreateTextArea (false, $id, $row['upload_description'], 'input_uploaddesc' ));

    $this->smarty->assign ('hidden',
			   $this->CreateInputHidden ($id, 'upload_id',$params['upload_id']).
			   $this->CreateInputHidden ($id, 'category_id',$params['category_id']));
    
    // populate the rows of download information
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_downloads WHERE file_id = ?";
    $dbresult = $db->Execute( $query, array( $params['upload_id'] ) );

    $this->smarty->assign('datetext', $this->Lang('date'));
    $this->smarty->assign('iptext', $this->Lang('ip_address'));
    $this->smarty->assign('usertext', $this->Lang('username'));
    $rowarray = array();
    $rowclass = 'row1';
    while( $row = $dbresult->FetchRow() )
      {
	$onerow = new stdClass();
	$onerow->date = $row['download_date'];
	$onerow->ip   = $row['download_ip'];
	$onerow->user = $row['download_user'];
	$onerow->rowclass = $rowclass;			     

	array_push( $rowarray, $onerow);
	($rowclass == "row1" ? $rowclass = "row2" : $rowclass = "row1");
      }

    $this->smarty->assign ('items', $rowarray);
    $this->smarty->assign ('itemcount', count($rowarray));

    echo $this->ProcessTemplate ('editupload.tpl');
  }


  /*---------------------------------------------------------
   _AdminDoEditUpload( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   Actually perform the database updates requested in the
   _AdminEditUpload form.
   ---------------------------------------------------------*/
  function _AdminDoEditUpload ($id, &$params, $returnid)
  {
    // make sure we have all the parameters we need
    if( !isset($params['upload_id']) ||
	!isset($params['input_uploaddesc']) ||
	!isset($params['input_movecategory']) ) 
      {
	$this->_DisplayErrorPage ($id, $params, $returnid,
				 $this->Lang ('error_insufficientparams'));
	return;
      }
  
	  // todo, are we fixing it?
 
    // now see if we can find the details about this upload
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $params['upload_id'] ) );
    if( !$dbresult ) {
      $this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
      return;
    }
    $row = $dbresult->FetchRow();
    if( !$row ) {
      $this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
      return;
    }

    // wow we did... now all we have to do is compare comments, and the categories, and off we go.
    $do_update = false;
    $newname = $row['upload_name'];
    $newcategory = $row['upload_category_id'];
    $newauthor = $row['upload_author'];
    $newdesc = $row['upload_description'];
    $newsummary = $row['upload_summary'];
    if( $params['input_movecategory'] != $row['upload_category_id'] ||
	$params['input_uploadname'] != $row['upload_name'] ) {
      // looks like we have to move it
      // get the info for the new category
      $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories WHERE upload_category_id = ?";
      $dbresult = $db->Execute( $query, array( $params['input_movecategory'] ) );
      $cat1row = $dbresult->FetchRow();
      if( !$cat1row ) {
	$this->_DisplayErrorPage ($id, $params, $returnid, $this->Lang ('error_dberror'));
	return;
      }

      // and the old category
      $dbresult = $db->Execute( $query, array( $row['upload_category_id'] ) );
      $cat2row = $dbresult->FetchRow();
      if( !$cat2row ) {
	$this->_DisplayErrorPage ($id, $params, $returnid, $this->Lang ('error_dberror'));
	return;
      }
      
      // now we can move the file from directory one to two.
      // if it doesn't already exist in the destination directory
      $fromfile = $this->_uploadPath( $cat2row['upload_category_path'], trim($row['upload_name']) );
      $tofile   = $this->_uploadPath( $cat1row['upload_category_path'], trim($params['input_uploadname']) );

      // move the file
      if( file_exists( $tofile ) ) {
	$this->_DisplayErrorPage ($id, $params, $returnid, $this->Lang ('error_fileexists',$tofile));
	return;
      }
      if( !rename( $fromfile, $tofile ) ) {
	$this->_DisplayErrorPage ($id, $params, $returnid, $this->Lang ('error_cannotrename'));
	return;
      }

      // and move any thumbnail
      $tn_fromfile = $this->_categoryPath( $cat2row['upload_category_path'].DIRECTORY_SEPARATOR.
					   '.thumbs'.DIRECTORY_SEPARATOR.$params['upload_id'].'_thumb');
      $tn_tofile   = $this->_categoryPath( $cat1row['upload_category_path'].DIRECTORY_SEPARATOR.
					   '.thumbs'.DIRECTORY_SEPARATOR.$params['upload_id'].'_thumb');
      if( file_exists( $tn_fromfile ) )
	{
	  // yep, we gotta move the thumbnail too
	  $todir = dirname( $tn_tofile );
	  if( !file_exists( $todir ) )
	    {
	      $result = $this->_mkdirr( $todir );
	      if( $result == false )
		{
		  // uh-oh, the rename failed, put the old file back
		  rename( $tofile, $fromfile );
		  // and display an error
		  $this->_DisplayErrorPage ($id, $params, $returnid, $this->Lang ('error_cannotcreatedirectory')
					    .': '.$todir);
		  return;
		}

	      // woohoo, directory created
	      // now create the .index.html
	      if( $this->GetPreference('create_dummy_index_html') )
		{
		  touch( $todir.DIRECTORY_SEPARATOR."index.html" );
		}

	    }

	  // and rename the thumbnail
	  rename( $tn_fromfile, $tn_tofile );
	}

      $do_update = true;
      $newcategory = $params['input_movecategory'];
      $this->Audit( 0, $this->Lang('friendlyname'),
		    $this->Lang('movedfile', $fromfile, $tofile ));
    }

    if( $params['input_uploaddesc'] != $row['upload_description'] ) {
      $do_update = true;
      $newdesc = trim($params['input_uploaddesc']);
    }
    if( $params['input_uploadname'] != $row['upload_name'] ) {
      $do_update = true;
      $newname = trim($params['input_uploadname']);
    }
    if( $params['input_uploadsummary'] != $row['upload_summary'] ) {
      $do_update = true;
      $newsummary = trim($params['input_uploadsummary']);
    }
    if( $params['input_uploadauthor'] != $row['upload_author'] ) {
      $do_update = true;
      $newauthor = trim($params['input_uploadauthor']);
    }

    if( $do_update ) {
      $query = "UPDATE ".cms_db_prefix()."module_uploads SET
                  upload_name = ?, upload_author = ?,
                  upload_summary = ?, upload_description = ?,
                  upload_category_id = ? WHERE upload_id = ?";
      $dbresult = $db->Execute( $query, array( $newname, $newauthor, $newsummary, $newdesc, $newcategory, $params['upload_id'] ) );
    }

    // done.
    $this->myRedirectToTab($id, 'files', array( 'curcategory' => $params['category_id']) );
  }


  /*---------------------------------------------------------
   _AdminDoDeleteUpload( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   Actually delete an upload from the filesystem and
   from the database.
   ---------------------------------------------------------*/
  function _AdminDoDeleteUpload ($id, &$params, $returnid)
  {
    // we're gonna put some thought into this... the user
    // has already answered, Yep, We're sure the file exists, don't really care anyways
    // so all we have to do is remove the file, and remove the record from the database.

    if( !isset( $params['upload_id'] ) ) 
      {
	$this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_insufficientparams'));
	return;
      }

    // get the info about the upload we're gonna delete
    $db =& $this->GetDb();
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $params['upload_id'] ) );
    if( !$dbresult ) {
	$this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
	return;
    }
    $uploadrow = $dbresult->FetchRow();
    if( !$uploadrow ) {
	$this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
	return;
    }
    
    // and the info about it's category
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $uploadrow['upload_category_id'] ) );
    if( !$dbresult ) {
	$this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
	return;
    }
    $categoryrow = $dbresult->FetchRow();
    if( !$categoryrow ) {
	$this->_DisplayErrorPage ($id, $params, $returnid,
			       $this->Lang ('error_dberror'));
	return;
    }
    
    // now build the path
    $file = $this->_uploadPath( $categoryrow['upload_category_path'], $uploadrow['upload_name'] );

    // and delete the file
    @unlink( $file );

    // and the thumbnail if one exists
    $tnfile = $this->_categoryPath( $categoryrow['upload_category_path'] ).DIRECTORY_SEPARATOR.'.thumbs';
    $tnfile .= DIRECTORY_SEPARATOR.$params['upload_id'].'_thumb';
    @unlink( $tnfile );

    // and the downloads
    $query = "DELETE FROM ".cms_db_prefix()."module_uploads_downloads WHERE file_id = ?";
    $dbresult = $db->Execute( $query, array( $uploadrow['upload_id'] ) );

    // and the record itself.
    $query = "DELETE FROM ".cms_db_prefix()."module_uploads WHERE upload_id = ?";
    $dbresult = $db->Execute( $query, array( $uploadrow['upload_id'] ) );

    // and we're done
    $this->Audit( 0, $this->lang('friendlyname'),
		  $this->lang('deleted', $destname) );

    // delete the search stuff
    $module =& $this->GetModuleInstance('Search');
    if ($module != FALSE)
      {
	$module->DeleteWords($this->GetName(), $uploadrow['upload_id'], 'upload');
      }
    

    // send an event
    $parms = array();
    $parms['id'] = $uploadrow['upload_id'];
    $parms['name'] = $uploadrow['upload_name'];
    $parms['category_id'] = $uploadrow['upload_category_id'];
    $this->SendEvent('OnRemove', $parms );

    $this->myRedirectToTab($id, 'files', array( 'input_category' => $uploadrow['upload_category_id']));
  }


  /*---------------------------------------------------------
   _AdminDoEditCategory($id, $params, $returnid)
   NOT PART OF THE MODULE API

   Actually edit a category given the information given
   in the edit category form.
   ---------------------------------------------------------*/
  function _AdminDoEditCategory ($id, &$params, $returnid)
  {
    $db =& $this->GetDb();
    
    // are we cancelling
    if (isset ($params['cancel']))
      {
	$this->myRedirectToTab($id, 'categories');
      }
    
    // make sure we have something to work with
    if (!isset ($params['category_id']) || $params['category_id'] == "")
      {
	$this->smarty->assign ('error', "1");
	$this->smarty->assign ('message', $this->Lang ("error_nocategoryid"));
      }
    else if (!isset ($params['input_categoryname'])
	     || $params['input_categoryname'] == "")
      {
	$this->smarty->assign ('error', "1");
	$this->smarty->assign ('message', $this->Lang ("error_emptycategory"));
      }
    else if (!isset ($params['input_categorypath'])
	     || $params['input_categorydesc'] == "")
      {
	$this->smarty->assign ('error', "1");
	$this->smarty->assign ('message', $this->Lang ("error_emptypath"));
      }
    else if (isset( $params['scan'] ) )
      {
         $query = "SELECT * FROM ".cms_db_prefix()."module_uploads_categories
            WHERE upload_category_id = ?";
         $dbresult = $db->Execute( $query, array($params['category_id']) );
         if( !$dbresult )
           {
	     $this->smarty->assign ('error', "1");
	     $this->smarty->assign ('message', $this->Lang ("error_dberror"));
           } 
         else 
           {
             $row = $dbresult->FetchRow();
             if( !$row ) 
               {
   	         $this->smarty->assign ('error', "1");
 	         $this->smarty->assign ('message', $this->Lang ("error_dberror"));
               } 
             else 
               {
                 $dir = $this->_categoryPath( $row['upload_category_path'] );
                 $this->ScanDirectory( $params['category_id'], $dir );
		 $this->myRedirectToTab($id, 'files', array('input_category' => $params['category_id']) );
		 return;
               } 
          }
      }
    else
      {
	// now prepare to update the record
	$query =
	  "UPDATE ".cms_db_prefix ().
	  "module_uploads_categories SET upload_category_name = ?,".
	  "upload_category_description = ?, upload_category_listable = ? WHERE upload_category_id = ?";
	$dbresult =
	  $db->Execute ($query,
			array ($params['input_categoryname'],
			       $params['input_categorydesc'],
			       $params['input_categorylistable'],
			       $params['category_id']));
	if (!$dbresult)
	  {
	    $this->smarty->assign ('error', "1");
	    $this->smarty->assign ('message', $this->Lang ("error_dberror"));
	  }
	else
	  {
	    $this->myRedirectToTab($id,'categories');
	    return;
	  }
      }
    
    $this->ProcessTemplate ("addcategory.tpl");
  }


  /*---------------------------------------------------------
   _AdminAddCategory( $id, $params, $returnid )
   NOT PART OF THE MODULE API

   Provide a form to allow users to add a category.
   ---------------------------------------------------------*/
  function _AdminAddCategory ($id, &$params, $returnid)
  {
    // populate the template
    $this->smarty->assign ('title', $this->Lang ('addcategory'));
    $this->smarty->assign ('startform',
				  $this->CreateFormStart ($id,
							  'do_addcategory',
							  $returnid));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());
    $this->smarty->assign ('submit',
				  $this->CreateInputSubmit ($id, 'submit',
							    $this->Lang('submit')));
    $this->smarty->assign ('cancel',
				  $this->CreateInputSubmit ($id, 'cancel',
							    $this->Lang('cancel')));

    $this->smarty->assign ('prompt_categoryname',
			   $this->Lang ('prompt_categoryname'));
    $this->smarty->assign ('input_categoryname',
			   $this->CreateInputText ($id, 'input_categoryname',
						   "", 20, 80));
    $this->smarty->assign ('info_categoryname', $this->Lang('info_categoryname'));
    $this->smarty->assign ('prompt_categorydesc',  $this->Lang ('prompt_categorydesc'));
    $this->smarty->assign ('input_categorydesc',
			   $this->CreateInputText ($id, 'input_categorydesc',
						   "", 80, 255));
    $this->smarty->assign ('info_categorydesc', $this->Lang('info_categorydesc'));
    $this->smarty->assign ('prompt_categorypath',
			   $this->Lang ('prompt_categorypath'));
    $this->smarty->assign ('input_categorypath',
			   $this->CreateInputText ($id, 'input_categorypath',
						   "", 80, 255));
    $this->smarty->assign ('info_categorypath', $this->Lang('info_categorypath'));
    $this->smarty->assign ('pathmessage', $this->Lang ('pathinuploads'));
    
    $this->smarty->assign ('prompt_categorylistable',
			   $this->Lang ('prompt_categorylistable'));
    $this->smarty->assign ('input_categorylistable',
			   $this->CreateInputCheckbox ($id,
						       'input_categorylistable',
						       1,0));
    // Display the populated template
    echo $this->ProcessTemplate ('addcategory.tpl');
  }


  /*---------------------------------------------------------
   _DisplayAdminPanelCategoriesTab($id, $params, $returnid)
   NOT PART OF THE MODULE API
   
   A private method for displaying the contents of the 
   categories tab in the admin panel
   ---------------------------------------------------------*/
  function _DisplayAdminPanelCategoriesTab( $id, &$params, $returnid )
  {
    global $gCms;
    $db =& $this->GetDb();
    
    $rowarray = array ();
    $query = '';
    $dbresult = '';
    
    $query = "SELECT * FROM ".cms_db_prefix ()."module_uploads_categories";
    $dbresult = $db->Execute ($query);
    $rowclass = 'row1';
    
    while ($row = $dbresult->FetchRow ())
      {
	$onerow = new stdClass ();
	$onerow->id = $row["upload_category_id"];
	$onerow->name = 
	  $this->CreateLink( $id, 'editcategory', $returnid, 
			     $row["upload_category_name"],
			     array('category_id'=>$row['upload_category_id']));

	$onerow->description = $row["upload_category_description"];
	$onerow->path = $row["upload_category_path"];
	$onerow->rowclass = $rowclass;

	$onerow->editlink =
	  $this->CreateLink ($id, 'editcategory', $returnid,
			     $gCms->variables['admintheme']->
			     DisplayImage ('icons/system/edit.gif',
					   $this->Lang ('edit'), '', '', 'systemicon'),
			     array ('category_id' => $row['upload_category_id']));
	$onerow->deletelink =
	  $this->CreateLink ($id, 'deletecategory', $returnid,
			     $gCms->variables['admintheme']->
			     DisplayImage ('icons/system/delete.gif',
					   $this->Lang ('delete'), '', '', 'systemicon'),
			     array ('category_id' => $row['upload_category_id']),
			     $this->Lang ('areyousure'));

	array_push ($rowarray, $onerow);
	($rowclass == "row1" ? $rowclass = "row2" : $rowclass = "row1");
      }

    $this->smarty->assign ('categorytext', $this->Lang ('category'));
    $this->smarty->assign ('nametext', $this->Lang ('name'));
    $this->smarty->assign ('pathtext', $this->Lang ('path'));
    $this->smarty->assign ('items', $rowarray);
    $this->smarty->assign ('itemcount', count ($rowarray));

    $this->smarty->assign ('addlink',
			   $this->CreateLink ($id, 'addcategory',
					      $returnid,
					      $this->
					      Lang ('addcategory'),
					      array (), '', false,
					      false,
					      'class="pageoptions"'));

    echo $this->ProcessTemplate ('categorylist.tpl');
  }

  
  /*---------------------------------------------------------
   _DisplayAdminPanelCategoriesTab($id, $params, $returnid)
   NOT PART OF THE MODULE API
   
   A private method for displaying the contents of the 
   files tab in the admin panel
   ---------------------------------------------------------*/
  function _DisplayAdminPanelFilesTab( $id, &$params, $returnid )
  {
    global $gCms;
    $db =& $this->GetDb();

    // get the current category for the filter
    if (isset ($params['submitcategory']))
      {
	$this->SetPreference('current_category',
	  (isset ($params['input_category']) ? $params['input_category'] :
	   ''));
      }
    $curcategory = $this->GetPreference('current_category','');
        
    // get the categories for the filter
    $categorylist = array ();
    $query =
      "SELECT * FROM ".cms_db_prefix ().
      "module_uploads_categories ORDER BY upload_category_name ASC";
    $dbresult = $db->Execute ($query);
    if (!$dbresult)
      {
	$this->smarty->assign ('error', 1);
	$this->smarty->assign ('message', $this->Lang ('error_nocategories'));
      }
    else
      {
	while ($row = $dbresult->FetchRow ())
	  {
	    if( $curcategory == '' ) {
	      $curcategory = $row['upload_category_id'];
	    }
	    $categorylist[$row['upload_category_name']] =
	      $row['upload_category_id'];
	  }
      }
	  
    // if there are no categories, put a message out, and
    // nothing else
    if( !count( $categorylist ) ) 
      {
	$this->smarty->assign('error',1);
	$this->smarty->assign('noform',1);
	$this->smarty->assign('message',$this->Lang('error_nocategories'));
	echo $this->ProcessTemplate('uploadlist.tpl');
	return;
      }

    // setup the form part of the template
    $this->smarty->assign ('startform',
			   $this->CreateFormStart ($id, 'defaultadmin', $returnid, 'post', 'multipart/form-data'));
    $this->smarty->assign ('category', $this->Lang ('category'));
    $this->smarty->assign ('input_category',
			   $this->CreateInputDropDown ($id, "input_category", $categorylist, -1,
						       $curcategory));
    $this->smarty->assign ('input_select',
			   $this->CreateInputSubmit ($id, 'submitcategory',
						     $this->Lang('selectcategory')));
    $this->smarty->assign ('input_hidden',
			   $this->CreateInputHidden ($id, 'curcategory',
						     $curcategory));
    $this->smarty->assign('prompt_browse', $this->Lang('upload'));
    $this->smarty->assign( 'input_browse',
			   $this->CreateFileUploadInput ($id,'input_browse'));
    $this->smarty->assign('prompt_replace', $this->Lang('prompt_replace'));
    $this->smarty->assign('input_replace', 
			  $this->CreateInputCheckbox( $id, 'input_replace', 1 ));
    $this->smarty->assign('info_replace',
			  $this->Lang('info_replace'));
    $this->smarty->assign('prompt_thumbnail', $this->Lang('thumbnail'));
    $this->smarty->assign( 'input_thumbnail',
			   $this->CreateFileUploadInput ($id,'input_thumbnail'));
	  
    $this->smarty->assign ('prompt_destname',
			   $this->Lang ('destname'));
    $this->smarty->assign ('input_destname',
			   $this->CreateInputText ($id, 'input_destname',
						   '', 40, 255));
    $this->smarty->assign ('info_destname',
			   $this->Lang('info_destname'));
	  
    $this->smarty->assign ('prompt_summary',
			   $this->Lang ('summary'));
    $this->smarty->assign ('input_summary',
			   $this->CreateInputText ($id, 'input_summary',
						   '', 80, 255));
    $this->smarty->assign ('info_summary',
			   $this->Lang('info_summary'));
    $this->smarty->assign('prompt_author',$this->Lang('author'));
    $this->smarty->assign( 'input_author',
			   $this->createInputText( $id, 'input_author', $_SESSION["cms_admin_username"],
						   20, 255));
	  
    $this->smarty->assign( 'input_submit',
			   $this->CreateInputSubmit( $id, 'submitupload', $this->Lang('upload')));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());
	  
    $dbresult = '';
    $rowarray = array ();
    if ($curcategory == '')
      {
	$query = "SELECT * FROM ".cms_db_prefix ().
	  "module_uploads ORDER BY upload_date";
	$dbresult = $db->Execute ($query);
      }
    else
      {
	$query =
	  "SELECT * FROM ".cms_db_prefix ().
	  "module_uploads WHERE upload_category_id = ? ORDER BY upload_date";
	$dbresult = $db->Execute ($query, array ($curcategory));
      }
	  
    // now setup the rest                                                 
    $rowclass = 'row1';
	  
    if ($dbresult)
      {
	$this->smarty->assign('idtext',$this->Lang('name'));
	$this->smarty->assign('titletext',$this->Lang('name'));
	$this->smarty->assign('summarytext',$this->Lang('summary'));
	$this->smarty->assign('desctext',$this->Lang('description'));
	$this->smarty->assign('sizetext',$this->Lang('sizekb'));
	$this->smarty->assign('authortext',$this->Lang('author'));
	$this->smarty->assign('iptext',$this->Lang('ip_address'));
	$this->smarty->assign('dltext',$this->Lang('downloads'));
	$this->smarty->assign('postdatetext',$this->Lang('date'));
	while ($row = $dbresult->FetchRow ())
	  {
	    $onerow = new stdClass ();
	    $onerow->id = $row['upload_id'];
	    $onerow->name = $row['upload_name'];
	    $onerow->size = intval($row['upload_size'] / 1024.0 + 0.5);
	    $onerow->author = $row['upload_author'];
	    $onerow->ip = $row['upload_ip'];
	    $onerow->summary = $row['upload_summary'];
	    $onerow->description = $row['upload_description'];
	    $onerow->date = $row['upload_date'];
	    $onerow->rowclass = $rowclass;
		
	    // how many times has this item been downloaded
	    $query = "SELECT COUNT(download_id) as count FROM ".
	      cms_db_prefix()."module_uploads_downloads WHERE file_id = ?";
	    $dbresult2 = $db->Execute( $query, array( $row['upload_id'] ) );
	    $row2 = $dbresult2->FetchRow();
	    $onerow->downloads = 0;
	    if( $row2 ) {
	      $onerow->downloads = $row2['count'];
	    }
		
	    $onerow->editurl =
	      $this->CreateLink ($id, 'editupload', $returnid, '', 
				 array ('upload_id' => $row['upload_id'],
					'category_id' => $curcategory),
				 '', true );

	    $onerow->editlink =
	      $this->CreateLink ($id, 'editupload', $returnid,
				 $gCms->variables['admintheme']->DisplayImage('icons/system/edit.gif',
									      $this->Lang ('edit'), '', '', 'systemicon'),
				 array ('upload_id' => $row['upload_id'],
					'category_id' => $curcategory));
		
	    $onerow->deletelink = $this->CreateLink ($id,'do_deleteupload',$returnid,
						     $gCms->variables['admintheme']->DisplayImage('icons/system/delete.gif',
												  $this->Lang ('delete'), '', '', 'systemicon'),
						     array ('upload_id' => $row['upload_id'],
							    'category_id' => $curcategory),
						     $this->Lang ('areyousure'));
	    array_push ($rowarray, $onerow);
	    ($rowclass == "row1" ? $rowclass = "row2" : $rowclass = "row1");
	  }
      }

    $this->smarty->assign ('items', $rowarray);
    $this->smarty->assign ('itemcount', count ($rowarray));
    echo $this->ProcessTemplate ('uploadlist.tpl');
  }


  /*---------------------------------------------------------
   _DisplayAdminPrefs($id, $params, $returnid, $message)
   NOT PART OF THE MODULE API

   Display a form to allow the administrator to edit
   preferences that apply to the entire module.
   ---------------------------------------------------------*/
  function _DisplayAdminPrefs ($id, &$params, $returnid, $message = '')
  {
    // CreateFormStart sets up a proper form tag that will cause the submit to
    // return control to this module for processing.
    $this->smarty->assign ('startform',
				  $this->CreateFormStart ($id,
							  'save_admin_prefs',
							  $returnid));
    $this->smarty->assign ('endform', $this->CreateFormEnd ());

    $this->smarty->assign ('submit',
				  $this->CreateInputSubmit ($id, 'submit',
							    $this->Lang('submit'), '','',
							    $this->Lang('confirm_preferences')));    
    
    // it's good practice to set even static titles using smarty, so localization is
    // easier.
    $this->smarty->assign ('title_max_uploadsize',
				  $this->Lang ('prompt_max_uploadsize'));
    $this->smarty->assign ('title_valid_uploadextensions',
				  $this->Lang ('title_valid_uploadextensions'));
    $this->smarty->assign ('title_subnet_exclusions',
				  $this->Lang ('title_subnet_exclusions'));
    $this->smarty->assign ('title_section',
				  $this->Lang ('title_mod_prefs'));
    $this->smarty->assign ('title_dummy_index_html',
				  $this->Lang ('title_dummy_index_html'));
    $this->smarty->assign ('title_email_on_upload',
				  $this->Lang ('title_email_on_upload'));
    $this->smarty->assign ('title_enforceextensions',
			   $this->Lang('title_enforceextensions'));
    $this->smarty->assign ('title_redirect_on_upload',
			   $this->Lang('title_redirectonupload'));

    // you'll often want to do things like this to provide feedback:
    if ($message != '')
      {
	$this->smarty->assign ('message', $message);
      }
    
    $this->smarty->assign ('input_max_uploadsize',
			   $this->CreateInputText ($id, 'max_uploadsize',
						   $this->GetPreference('max_uploadsize',
									'1000000'), '12', '12'));
    $this->smarty->assign ('input_valid_uploadextensions',
       $this->CreateInputText ($id, 'valid_uploadextensions',
	      $this->GetPreference ('valid_uploadextensions',
				    "zip,gz,tar"), '30', '255'));

    $this->smarty->assign ('input_enforceextensions',
			   $this->CreateInputCheckbox( $id, 'input_enforceextensions',
						       1, $this->GetPreference('requirefilename_extensions',1)));
    $this->smarty->assign ('input_subnet_exclusions',
			   $this->CreateInputText( $id, 'subnet_exclusions',
						   $this->GetPreference('subnet_exclusions',""),50,255));
    $this->smarty->assign ('input_dummy_index_html',
			   $this->CreateInputCheckbox( $id, 'input_dummy_index_html',
						       1, $this->GetPreference('create_dummy_index_html')));
    $this->smarty->assign ('input_email_on_upload',
			   $this->CreateInputText( $id, 'email_on_upload',
						   $this->GetPreference('send_upload_notifications_to'),
						   30, 80 ));
    $this->smarty->assign ('input_redirect_on_upload',
			   $this->CreateInputText( $id, 'redirect_on_upload',
						   $this->GetPreference('redirect_on_upload',''),30,80));

    $usertags = array( $this->Lang('none') => '' );
    $this->smarty->assign ('title_usertag_onupload',
			   $this->Lang('title_usertag_onupload'));
    $tmp = $this->ListUserTags();
    $pref = $this->GetPreference('usertag_onupload');
    foreach( $tmp as $k => $v )
      {
	$usertags[$k] = $v;
      }
    $this->smarty->assign( 'input_usertag_onupload',
			   $this->CreateInputDropDown($id, 'input_usertag_onupload', $usertags, -1, $pref ));
				  

    // Display the populated template
    echo $this->ProcessTemplate ('adminprefs.tpl');
  }


  /*---------------------------------------------------------
   _SaveAdminPrefs($id, $params, $returnid, $message)
   NOT PART OF THE MODULE API

   Save the preferences as specified in the preferences form.
   ---------------------------------------------------------*/
  function _SaveAdminPrefs ($id, &$params, $returnid)
  {
    $this->SetPreference ('max_uploadsize',
			  isset ($params['max_uploadsize']) ?
			  $params['max_uploadsize'] : '0');
    $this->SetPreference ('valid_uploadextensions',
			  isset ($params['valid_uploadextensions']) ?
			  $params['valid_uploadextensions'] : '0');
    $this->SetPreference ('subnet_exclusions',
			  isset ($params['subnet_exclusions']) ?
			  $params['subnet_exclusions'] : '0');
    $this->SetPreference ('requirefilename_extensions',
			  isset ($params['input_enforceextensions']) ?
			  $params['input_enforceextensions'] : '0');
    $this->SetPreference ('create_dummy_index_html',
			  isset ($params['input_dummy_index_html']) ?
			  $params['input_dummy_index_html'] : '0');
    $this->setPreference ('send_upload_notifications_to',
			  isset ($params['email_on_upload']) ?
			  $params['email_on_upload'] : '' );    
    $this->SetPreference ('redirect_on_upload',
			  isset ($params['redirect_on_upload']) ?
			  $params['redirect_on_upload'] : '' );    
    $this->SetPreference ('usertag_onupload',
			  isset ($params['input_usertag_onupload']) ?
			  $params['input_usertag_onupload'] : '' );			  
    $this->myRedirectToTab( $id, 'admin_prefs' );
  }


  /*---------------------------------------------------------
   _DisplayErrorPage($id, $params, $returnid, $message)
   NOT PART OF THE MODULE API
   
   This is a method to display
   error information on the admin side.
   ---------------------------------------------------------*/
  function _DisplayErrorPage ($id, &$params, $returnid, $message = '')
  {
    $this->smarty->assign ('title_error', $this->Lang ('error'));
    if ($message != '')
      {
	$this->smarty->assign ('message', $message);
      }
    if( $returnid == '' )
      {
	$this->smarty->assign('link',
			      $this->CreateLink($id,'defaultadmin',$returnid,
						$this->Lang('returntomodule')));
      }
    
    // Display the populated template
    echo $this->ProcessTemplate ('error.tpl');
  }


  /*---------------------------------------------------------
   GetUploadDetails($id,$returnid)
   
   Return the details about a specific upload
      upload_id
      upload_category_id
      upload_name
      upload_author
      upload_summary
      upload_description
      upload_ip
      upload_size
      upload_date
      url
      absurl
      link
   or an array (FALSE,ERRORMSG)
   ---------------------------------------------------------*/
  function GetUploadDetails( $id, $returnid )
  {
    $db =& $this->GetDb();
    $q = "SELECT * FROM ".cms_db_prefix()."module_uploads
          WHERE upload_id = ?";
    $dbresult = $db->Execute( $q, array( $id ) );
    if( !$dbresult )
      {
	return array( FALSE, $db->ErrorMsg() );
      }
    if( !$dbresult->RecordCount() )
      {
	return array( FALSE, $this->Lang('error_invaliduploadid'));
      }
    $row = $dbresult->FetchRow();
	  if( !$row )
    {
	    return array(FALSE, $db->ErrorMsg());
    }

    // have details from the table, now
    // have to add something such that a link can be generated
    // that will still count the number of downloads, etc
    $row['url'] = $this->CreateLink ($id, 'getfile', $returnid, '',
				     array ('upload_id' => $row['upload_id']), '', true);
    $row['link'] = $this->CreateLink ($id, 'getfile', $returnid, $row['upload_name'],
				      array ('upload_id' => $row['upload_id']));
    $row['absurl'] = $this->cms->config['uploads_url']."/".
      $this->getCategoryPathFromFileID( $row['upload_id'] )."/".
      $row['upload_name'];
    return $row;
  }


  /*---------------------------------------------------------
   AttemptUpload($id, $params, $returnid, $message)
   NOT PART OF THE MODULE API
   
   This is a method to actually try uploading the file
   ensuring it is valid, and then adding the stuff to
   the database.

   Returns an array, first element is success (true/false)
   second element is (if first element is false) an error message,
   or the id of the uploaded file.
   ---------------------------------------------------------*/
  function AttemptUpload ($id, &$params, $returnid)
  {
    // check for the filetypes param
    if (isset( $params['file_extensions'] ) )
      {
	$this->upload_extensions = $params['file_extensions'];
      }

    // check the author
    if (!isset ($params['input_author']))
      {
	return array( FALSE, $this->Lang('error_invalidauthor') );
      }
    
    // see if there's a key
    $key = null;
    if( isset( $params['input_key'] ) )
      {
	$key = $params['input_key'];
      }

    // validate the upload name
    $destname = $_FILES[$id.'input_browse']['name'];
    if( isset($params['input_destname']) && $params['input_destname'] != '')
      {
	$destname = trim(basename($params['input_destname']));
      }

    $replace_existing = false;
    if( isset( $params['input_replace']) && $params['input_replace'] == 1 )
      {
	$replace_existing = true;
      }

    // check the description
    if ( !isset($params['input_summary']) || $params['input_summary'] == '' )
      {
	// we'll cheat, if the summary is left as empty
	// we'll use the upload name
	$p = strpos( $destname, '.' );
	if( $p )
	  {
	    $params['input_summary'] = substr( $destname, 0, $p );
	  }
	else
	  {
	    $params['input_summary'] = $destname;
	  }
	//return array( FALSE, $this->Lang('error_invalidsummary') );
      }

    // check the category
    $db =& $this->GetDb();
    $dbresult = "";
    $row = array();
    $category_id = 0;
    if (isset( $params['category_id'] ) )
      {
        $category_id = $params['category_id'];
        $query =
          "SELECT * FROM ".cms_db_prefix().
          "module_uploads_categories WHERE upload_category_id = ?";
        $dbresult = $db->Execute ($query, array ($category_id));
      }
    else if (isset ($params['category']))
      {
        // get the category info given it's name
        $query =
          "SELECT * FROM ".cms_db_prefix().
          "module_uploads_categories WHERE upload_category_name = ?";
        $dbresult = $db->Execute ($query, array ($params['category']));
      }
    if (!$dbresult)
      {
	return array( FALSE, $this->Lang('error_invalidcategory') );
      }
    $row = $dbresult->FetchRow ();
    if( !$row )
      {
	return array( FALSE, $this->Lang('error_invalidcategory') );
      }
    $category_id = $row['upload_category_id'];
    $category_name = $row['upload_category_name'];
 
    // now do the upload, hopefully
    // first the file itself.
    $dir = $this->_categoryPath($row['upload_category_path']);
    $result =
      $this->_handleUpload ($dir,
			    $this->GetPreference ('max_uploadsize', 1000000) * 1024, 
			    $id.'input_browse',
			    false,
			    $destname,
			    true,
			    $replace_existing);
    if (!$result[0])
      {
	return array( FALSE, $result[1] );
      }
    $destname = $result[1]['name'];


    // check for an existing database entry
    $query = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE upload_name = ? AND
			upload_category_id = ?";
    $dbresult = $db->Execute( $query, array( $destname, $category_id ) );
    if( !$dbresult ) 
      {
	return array( FALSE, $this->Lang('error_dberror') );
      }
    $row2 = $dbresult->FetchRow();

    $fileid = '';
    if( $replace_existing == 0 )
      {
	// were not allowing overwrite
	if( $row2 ) 
	  {
	    // this ia redundant error, as it should have happened in the _handleUpload
	    // but oh well
	    return array( FALSE, $this->Lang('error_fileexists') );
	  }
      }
    else
      {
	// we're allowing overwrite
	$fileid = $row2['upload_id'];
	$replace_existing = true;
      }
 	       

    # create the thumbs directory if it isn't there already
    $tndir = $this->_categoryPath($row['upload_category_path']).DIRECTORY_SEPARATOR.'.thumbs';
    if( !file_exists( $tndir ) )
      {
	$result2 = $this->_mkdirr( $tndir );
	if ($result2 == false) 
	  {
	    $msg = $this->Lang('error_cantcreatedirectory').': '.$tndir;
	    return array( FALSE, $msg );
	  }
	// create an index.html file (empty)
	if( $this->GetPreference('create_dummy_index_html') )
	  {
	    @touch( $tndir.DIRECTORY_SEPARATOR."index.html" );
	  }
      }

    // create a new upload id here.
    if( $fileid == '' )
      {
	$newid = $db->GenID (cms_db_prefix ()."module_uploads_seq");
      }

    // and then maybe the thumbnail
    if( isset( $_FILES[$id.'input_thumbnail']['name'] ) &&
	$_FILES[$id.'input_thumbnail']['name'] != '' && 
	$_FILES[$id.'input_thumbnail']['size'] > 0)
      {
	$fid = $fileid;
	if( $fid == '' )
	  {
	    $fid = $newid;
	  }
	$result2 =
	  $this->_handleUpload ($tndir,$this->GetPreference ('max_uploadsize', 1000000) * 1024, 
				$id.'input_thumbnail',false,$fid.'_thumb',false,
				$replace_existing);
	if (!$result2[0])
	  {
	    // uh-oh, the second upload failed.... now we've gotta 
	    // delete the first file to avoid any corruption
	    // todo
	    unlink( $result[1]['dir'].DIRECTORY_SEPARATOR.$result[1]['name'] );
	    return array( FALSE, $result2[1] );
	  }
      }

    // apparently the upload succeeded, now we have to log it
    $desc = "";
    if( isset( $params['input_description'] ) )
      {
	$desc = $params['input_description'];
      }

    if( $fileid == '' )
      {
	$query =
	  "INSERT INTO ".cms_db_prefix ().
	  "module_uploads VALUES (?,?,?,?,?,?,?,?,?,?)";
	$dbresult =
	  $db->Execute ($query,
			array ($newid,
			       $row['upload_category_id'],
			       $destname, 
			       $params['input_author'],
			       $params['input_summary'],
			       $desc,
			       getenv ("REMOTE_ADDR"), 
			       $result[1]['size'],
			       trim($db->DBTimeStamp (time ()),"'"),
			       $key
			       ));
	$this->Audit( 0, $this->lang('friendlyname'),
		      $this->lang('uploaded', array($destname, $params['input_author'])) );

      }
    else
      {
	$query = "UPDATE ".cms_db_prefix()."module uploads
           SET upload_name = ?, upload_author = ?,
               upload_summary = ?, upload_description = ?,
               upload_ip = ?, upload_size = ?, upload_date = ?
           WHERE upload_id = ?";
	$dbresult =
	  $db->Execute( $query,
			array( $destname,
			       $params['input_author'],
			       $params['input_summary'],
			       $desc,
			       getenv( "REMOTE_ADDR" ),
			       $result[1]['size'],
			       trim($db->DBTimeStamp(time()),"'"),
			       $fileid ));
	$newid = $fileid;
	$this->Audit( 0, $this->lang('friendlyname'),
		      $this->lang('replaced', $destname, $params['input_author']) );
      }


    // that should do the trick
    // now maybe we'll send an email
    $to_address = $this->GetPreference('send_upload_notifications_to');
    if( $to_address && $to_address != '' )
      {
	// fill out the template, and send an email
	$cmsmailer = $this->GetModuleInstance( 'CMSMailer' );
	if( !$cmsmailer )
	  {
	    // we're not gonna return an error, but put
	    // a message into the admin log
	    $this->Audit( 0, $this->Lang('friendlyname'),
			  $this->Lang('error_nomailermodule'));
	  }
	else
	  {
	    $this->smarty->assign('name', $destname );
	    $this->smarty->assign('size', $result[1]['size'] );
	    $this->smarty->assign('summary', $params['input_summary'] );
	    $this->smarty->assign('description', $desc );
	    $this->smarty->assign('author', $params['input_author'] );
	    $this->smarty->assign('ip_address', getenv ("REMOTE_ADDR") );
	    $body = $this->ProcessTemplateFromDatabase('upload_emailtemplate');
	    $cmsmailer->AddAddress( $to_address );
	    $cmsmailer->SetBody( $body );
	    $cmsmailer->IsHTML(true);
	    $cmsmailer->SetSubject($this->Lang('upload_notification'));
	    $cmsmailer->Send();
	  }
      }


    // update search words
    $search =& $this->GetModuleInstance('Search');
    if ($search != FALSE)
      {
	$str = $destname.' '.$params['input_author'].' '.
	  $params['input_summary'].$desc;
	$search->AddWords( $this->GetName(), $newid, 'upload', $str );
      }

    // send an event
    $parms = array();
    $parms['category'] = $category_name;
    $parms['name'] = $destname;
    $parms['size'] = $result[1]['size'];
    $parms['summary'] = $params['input_summary'];
    $parms['description'] = $desc;
    $parms['author'] = $params['input_author'];
    $parms['ip_address'] = getenv("REMOTE_ADDR");
    $this->SendEvent( "OnUpload", $params );

    if( $fileid == '' )
      {
	return array( TRUE, $newid );
      }
    return array( TRUE, $fileid );
  }


  function myRedirectToTab( $id, $tab, $params = '' )
  {
    $parms = array();
    if( is_array( $params ) )
      {
	$parms = $params;
      }
    $parms = array('active_tab' => $tab );
    $this->myRedirect( $id, 'defaultadmin', $parms );
  }

  function myRedirect( $id, $action, $params = '' )
  {
    unset( $params['action'] );
    $this->Redirect( $id, $action, '', $params );
  }


  /*---------------------------------------------------------
   _handleUpload( $destDir, $maxFileSize, $fieldName, $nameCallbac )
   NOT PART OF THE MODULE API

   This method handles validating the upload parameters, and copying
   the file from it's temporary location to it's permanent location.
   ---------------------------------------------------------*/
  function _handleUpload ($destDir, $maxFileSize =
			  false, $fieldName = '_upload', $nameCallback = false,
			  $destname = '',$enforceextension = true,
			  $replace_existing = false)
  {
    //make sure something is there
    if (!isset ($_FILES[$fieldName]) || !isset ($_FILES)
	|| !is_array ($_FILES[$fieldName]) || !$_FILES[$fieldName]['name'])
      {
	return array (false, $this->Lang('error_nofilesuploaded'));
      }

    //normalize the file variable
    $file = $_FILES[$fieldName];
    if (!isset ($file['type']))
      $file['type'] = '';
    if (!isset ($file['size']))
      $file['size'] = '';
    if (!isset ($file['tmp_name']))
      $file['tmp_name'] = '';
    $file['name'] =
      preg_replace('/[^a-zA-Z0-9\.\$\%\'\`\-\@\{\}\~\!\#\(\)\&\_\^]/', '',
       str_replace (array (' ', '%20'), array ('_', '_'), $file['name']));

    // validate the filename
    if (!$this->_isValidFilename ($file['name']))
      {
	return array (false, $this->Lang ('error_invaliduploadfilename',$file['name']));
      }

    //was it to big?
    if ($maxFileSize && ($file['size'] > ($maxFileSize * 1024)))
      return array (false, $this->Lang ('error_filetoolarge'));

    //normalize destDir
    if (strlen ($destDir) > 0 && $destDir[strlen ($destDir) - 1] != "/")
      $destDir = $destDir.'/';

    // get the destination name
    if( $destname == '' ) {
      $destname = $file['name'];
    }
    
    //should we change the filename via a callback?
    if ($nameCallback)
      {
	$destname =
	  call_user_func_array ($nameCallback, array ($file, $destDir));
      }

    if( $enforceextension == true && $this->GetPreference('requirefilename_extensions',1))
      {
	// make sure it has an extension
	// if it doesn't have one, we give it one (the one off the input file)
	if( strpos($destname,'.') == false )
	  {
	    if( ($p = strpos( $file['name'], '.' ) ) != false )
	      {
		$destname = $destname . substr( $file['name'], $p );
	      }
	  }
      }

    // and clean it up
    $destname = 
      preg_replace('/[^a-zA-Z0-9\.\$\%\'\`\-\@\{\}\~\!\#\(\)\&\_\^]/', '',
		   str_replace (array (' ', '%20'), array ('_', '_'), $destname));

    if( $replace_existing == false )
      {
	if( file_exists( $destDir.$destname ) && $replace_existing == false ) {
	  return array( false, $this->Lang( 'error_fileexists', $destDir.$destname ));
	}
      }

    //and now the big moment
    if (!@copy ($file['tmp_name'], $destDir.$destname))
      {
	return array (false,
		      $this->Lang ('error_couldnotwrite').
		      ':&nbsp'.$file['name']." -> ".$destDir." ".
		      $this->Lang ('error_permissiondenied'));
      }
    else
      {
	return array (true, array('name' => $destname, 'size' => $file['size'],
				  'dir' => $destDir ));
      }
  }


  /*---------------------------------------------------------
   ScanDirectory($category_id, $dir )
   NOT PART OF THE MODULE API

   A utility to insert records into the uploads database
   for all files that currently exist in a directory.
   ---------------------------------------------------------*/
  function ScanDirectory($category_id, $dir )
  {
    $db =& $this->GetDb();
    $desc = "Pre-existing file";

    $files = $this->_scandir( $dir );
    if( $this->GetPreference('creae_dummy_index_html') )
      {
	@touch( $dir.DIRECTORY_SEPARATOR."index.html" );
      }
    foreach( $files as $file ) {
      // ignore directories . and ..
      if( $file == "." || $file == ".." ) {
	      continue;
      }

      // ignore any directories
      $srcp = $dir.DIRECTORY_SEPARATOR.$file;
      if( is_dir( $srcp ) ) {
	      continue;
      }

      // got the file, now need it's size
      $size = filesize($srcp);

      // now we need to maybe rename the file...
      // cuz it may have spaces in it, and http may not like that
      // we use an (optional) counter to make sure that we
      // can have numerous files with similar names
      $postfix = "";
      while( $postfix < 100 )
	{
	  $destfile = str_replace (array (' ', '%20'), array ('_', '_'), $file );
	  if( $postfix != "" )
	    {
	      $destfile .= "_" . $postfix;
	    }

	  if( $destfile != $file )
	    {
	      $destp = $dir.DIRECTORY_SEPARATOR.$destfile;
	      
	      // yep, we gotta rename it
	      // but make sure the file doesn't already exist first
	      if( file_exists( $destp ) )
		{
		  // uh-oh it exists
		  // increment the postfix
		  if( $postfix == "" )
		    {
		      $postfix = 1;
		    }
		  else
		    {
		      $postfix++;
		    }
		  continue;
		}
	      
	      rename( $srcp, $destp );
	      $file = $destfile;
	    }

	  break; // get out of this while statement
	}

      if( $postfix >= 100 )
	{
	  // for some odd reason, we could not find a reasonable
	  // filename to rename to.
	  // we'll just skip this file
	  continue;
	}

      // next check to make sure its not already in the database
      $q = "SELECT * FROM ".cms_db_prefix()."module_uploads WHERE
            upload_name = ? AND upload_category_id = ?";
      $dbresult = $db->Execute( $q, array( $file, $category_id) );
      if( !$dbresult ) {
        echo $db->ErrorMsg()."<br/>";
	return;
      }
      else {
        $row = $dbresult->FetchRow();
        if( $row ) {
          // file exists
          continue;
        }
      } 

      // and add it to the database
      $query = "INSERT INTO ".cms_db_prefix()."module_uploads VALUES (?,?,?,?,?,?,?,?,?,null)";
      $userid = get_userid();
      $username = $_SESSION["cms_admin_username"];
      $newid = $db->GenID (cms_db_prefix ()."module_uploads_seq");
      $parms =	array( $newid, 
		       $category_id,
		       $file, 
		       $username, 
		       $desc, 
		       "", 
		       "localhost", 
		       $size,
		       trim($db->DBTimeStamp(time()),"'") );
      $dbresult = $db->Execute( $query, $parms );
      if( !$dbresult ) {
	echo $db->ErrorMsg()."<br/>";
	return;
      }
    }
  }


  /*---------------------------------------------------------
   SendFile($id, $params, $returnid)
   NOT PART OF THE MODULE API
   
   This method actually sends the requested file to the
   user.
   ---------------------------------------------------------*/
  function SendFile ($id, &$params, $returnid)
  {
  }


  /*---------------------------------------------------------
   SmartScanDirectory($category_id, $dir )
   NOT PART OF THE MODULE API

   A method to perform a scan directory if the count of the
   files in the directory does not match the count of the files
   in the database
   ---------------------------------------------------------*/
  function SmartScanDirectory($category_id, $dir )
  {
    $db =& $this->GetDb();
    $query = "SELECT COUNT(*) AS count FROM ".cms_db_prefix()."module_uploads
              WHERE upload_category_id = ?";
    $dbresult = $db->Execute( $q, array( $category_id ) );
    if( !$dbresult )
      {
        echo $db->ErrorMsg()."<br/>";
	return;
      }
    $row = $dbresult->FetchRow();
    $rowcount = $row['count'];

    // get the number of files
    $files = $this->_scandir( $dir );
    $count = 0;
    foreach( $files as $file )
      {
	// ignore directories . and ..
	if( $file == "." || $file == ".." ) {
	  continue;
	}

	// ignore any directories
	$srcp = $dir.DIRECTORY_SEPARATOR.$file;
	if( is_dir( $srcp ) ) {
	  continue;
	}

	$count++;
      }

    if( $count != $rowcount )
      {
	$this->ScanDirectory( $category_id, $dir );
      }
  }

}

# vim:ts=2 sw=2 noet
?>
]]></data>
	</file>
</module>
