<?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>NMS</name>
	<version>1.0.3</version>
  <mincmsversion>1.0.2</mincmsversion>
	<help>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</help>
	<about>PGJyIC8+QXV0aG9yOiBQYXVsIExlbWtlICZsdDtsZW1rZXBmQGdteC5uZXQmZ3Q7PGJyIC8+PGJyIC8+VmVyc2lvbjogMS4wLjM8YnIgLz48YnIgLz5DaGFuZ2UgSGlzdG9yeTo8YnIgLz4KPHVsPgo8bGk+VG9kbzoKPHVsPgo8bGk+VXBncmFkaW5nPC9saT4KPGxpPkxpc3RzIFRhYiAtIHNob3cgZGlzYWJsZWQgdnMgYWN0aXZlIGxpc3RzPC9saT4KPGxpPkxpc3RzIC0gYWJpbGl0eSB0byBNYXJrIGEgbGlzdCBhcyBpbmFjdGl2ZTwvbGk+CjxsaT5Vc2VycyAtIEFiaWxpdHkgdG8gZmlsdGVyIG9uIGNvbmZpcm1lZCBvciB1bmNvbmZpcm1lZAo8cD5BZG1pbiBzaG91bGQgYmUgYWJsZSB0byBjaGVjayBhbGwgdW5jb25maXJtZWQgdXNlcnMgYW5kIGVpdGhlciBjb25maXJtIHRoZW0gYWxsLCBvciBzZW5kIHRoZW0gYW5vdGhlciBjb25maXJtYXRpb24gZW1haWwgbWVzc2FnZTwvcD4KPGxpPlVzZXJzIC0gQWJpbGl0eSB0byBtYXJrIGEgdXNlciBhcyBkaXNhYmxlZDwvbGk+CjxsaT5Vc2VycyAtIEFiaWxpdHkgdG8gcHJlZmVyIHRleHQgb3IgaHRtbCBtYWlsIChtdWNoIGxhdGVyKTwvbGk+CjxsaT5QcmVmZXJlbmNlcyAtIEFiaWxpdHkgdG8gbWFyayBvdXRwdXQgbWVzc2FnZXMgYXMgYnVsayBvciBub3Q8L2xpPgo8bGk+U29tZXRoaW5nIHRvIGFsbG93IGEgdXNlciB0byByZS1nZXQgdGhlIGNvbmZpcm1hdGlvbiBlbWFpbDwvbGk+CjxsaT5Eb2NzLCBkb2NzLCBhbmQgbW9yZSBkb2NzPC9saT4KPGxpPjxiPlRoZSBmcm9udGVuZDwvYj48L2xpPgo8dWw+CiAgPGxpPmNvbXBsZXRlIHRoZSB0d28gc3RhZ2UgdW5zdWJzY3JpYmUgcHJvY2VzczwvbGk+CiAgPGxpPmNvbXBsZXRlIHRoZSB0d28gc3RhZ2UgY2hhbmdlIHByZWZlcmVuY2VzIHByb2Nlc3M8L2xpPgogIDxsaT5BZGQgYSBwcmVmZXJlbmNlIGFzIHRvIHdldGhlciBvciBub3QgdXNlcnMgc2hvdWxkIGdldCBhIGNvbmZpcm1hdGlvbiBlbWFpbCBhZnRlciBzdWJzY3JpYmluZyBhbmQgdW5zdWJzY3JpYmluZzwvcD4KPC91bD4KPGxpPlN0eWxpbmcgdGhlIHByb2dyZXNzIHBhZ2U8L2xpPgo8bGk+Q2hlY2sgZm9yIGhhcmRjb2RlZCBzdHJpbmdzPC9saT4KPGxpPkhUTUwgdnMgTm9uIEhUTUwgbWFpbDwvbGk+CjxsaT5FeHBvcnQgdXNlcnM8bGk+CjwvdWw+CjwvbGk+CjxsaT5WZXJzaW9uIDEuMC4zIC0gSmFudWFyeSwgMjAwODwvbGk+CjxwPkZpeGVzIGV4cG9ydCBmdW5jdGlvbmFsaXR5PC9wPgo8L2xpPgo8bGk+VmVyc2lvbiAxLjAuMiAtIEF1Z3VzdCwgMjAwNzwvbGk+CjxwPkFsbG93IGltcG9ydGluZyB1c2VycyBmcm9tIEZFVSA8ZW0+KG9yaWdpbmFsbHkgZG9uZSBieSBza3lwYW50aGVyLCByZS1pbXBsZW1lbnRlZCBieSBjYWxndXkxMDApLjwvZW0+PC9wPgo8cD5OdW1lcm91cyBidWcgZml4ZXM8L3A+CjxsaT5WZXJzaW9uIDEuMC4xIC0gRGVjZW1iZXIsIDIwMDY8L2xpPgo8cD5GaXhlcyB0byBpbXBvcnQgdXNlcnMsIGFuZCB0byBhIHRlcm5lcnkgZXhwcmVzc2lvbiB3aGVuIGNyZWF0aW5nIGEgbWVzc2FnZS4gSSBhbHNvIGZpeGVkIHNvbWUgc3R1cGlkIHByb2JsZW1zIHdpdGggcHJvY2Vzc19xdWV1ZSByZXN1bHRpbmcgZnJvbSBtZSBkb2luZyB0aGlzIHRvbyBxdWlja2x5LjwvcD4KPGxpPlZlcnNpb24gMS4wIC0gRGVjZW1iZXIsIDIwMDY8L2xpPgo8cD5UaGlzIDxiPmlzPC9iPiBlc3NlbnRpYWxseSBhIGNvbXBsZXRlIHJld3JpdGUgb2YgdGhlIG9sZCBOTVMgbW9kdWxlLiAgRXZlcnl0aGluZyBoYXMgYmVlbiBjbGVhbmVkIHVwIGFuZCBhdHRlbXRwdHMgaGF2ZSBiZWVuIG1hZGUgdG8gYnJpbmcgaXQgdXAgdG8gcHJvcGVyIHN0YW5kYXJkcywgYW5kIGxvdHMgb2YgbmV3IGZlYXR1cmVzIGFkZGVkLiBoZXJlIGlzIGEgbGlzdCBvZiB0aGUgbWFqb3IgaW1wcm92ZW1lbnRzOjwvcD4KPHVsPgo8bGk+Q2xlYW51cCBvZiB0aGUgbGFuZyBzdHJpbmdzLCBldGMuPC9saT4KPGxpPlBhcmFtLWl6ZSB0aGUgcXVlcmllcyBmb3Igc2VjdXJpdHk8L2xpPgo8bGk+QWRkZWQgdGhlIGNvbmNlcHQgb2YgSm9icywgc28gdGhhdCBtZXNzYWdlcyBjYW4gYmUgcmUtdXNlZDwvbGk+CjxsaT5BZGRlZCB0aGUgY29uY2VwdCBvZiB1c2VybmFtZSAob3B0aW9uYWwpPC9saT4KPGxpPkFkZGVkIHNtYXJ0eSBwcm9jZXNzaW5nIG9uIHRlbXBsYXRlczwvbGk+CjxsaT5BZGRlZCBidWxrIGltcG9ydDwvbGk+CjxsaT5BZGRlZCB0aGUgY29uY2VwdCBvZiBhICdwcml2YXRlIGxpc3QnPC9wPgo8bGk+RGV2aWRlZCB0aGUgYWRtaW4gcGFuZWwgaW50byB0YWJzPC9saT4KPGxpPlNob3cgcHJvZ3Jlc3MgbmljZWx5IHdoZW4gcHJvY2Vzc2luZyBsYXJnZSBqb2JzPC9saT4KPGxpPlVzZXMgQ01TTWFpbGVyIG1vZHVsZTwvbGk+CjxsaT5FdmVudHMgdGhhdCBjYW4gYmUgdHJhcHBlZCB0byBhZGQgYWRkaXRpb25hbCBiZWhhdmlvdXI8L2xpPgo8L3VsPgo8cD48c3Ryb25nPk5vdGU8L3N0cm9uZz4sIHVwZ3JhZGUgZnJvbSB0aGUgcHJldmlvdXMgdmVyc2lvbiA8ZW0+KEluY2x1ZGluZyBwcmV2aW91cyBiZXRhcyk8L2VtPmlzIG5vdCBwb3NzaWJsZS4gIEEgY29tcGxldGUgdW5pbnN0YWxsIG9mIHRoZSBvbGQgdmVyc2lvbiBpcyByZXF1aXJlZCBiZWZvcmUgaW5zdGFsbGluZyB0aGlzIHZlcnNpb24gb2YgTk1TLjwvcD4KPC9saT4KPGxpPlZlcnNpb24gLjc0IDI3IE5vdmVtYmVyIDIwMDUuIEFscGhhIDMgUmVsZWFzZS4gRml4ZWQgYnVnIHdpdGggY29uZmlybWF0aW9uIG1lc3NhZ2UgcmV0dXJuaWQsIGltYWdlIHVybHMsIHdpbmRvd3MgcGhwLCBhbmQgYSBmZXcgb3RoZXIgc21hbGwgaXNzdWVzLjwvbGk+CjxsaT5WZXJzaW9uIC43MyAyMyBOb3ZlbWJlciAyMDA1LiBBbHBoYSAyIFJlbGVhc2UuIEZpeGVkIGJ1ZyB3aXRoIGFkZGluZyBtZXNzYWdlcy48L2xpPgo8bGk+VmVyc2lvbiAuNzEgMjIgTm92ZW1iZXIgMjAwNS4gQWxwaGEgMSBSZWxlYXNlLjwvbGk+CjxsaT5WZXJzaW9uIC41LiAxNyBTZXB0ZW1iZXIgMjAwNS4gSW50ZXJuYWwgUmVsZWFzZS48L2xpPgo8L3VsPjxiciAvPg==</about>
	<description>This module is a module that allows you to create a newsletter system.</description>
	<requires>
	  <requiredname>CMSMailer</requiredname>
	  <requiredversion>1.73.8</requiredversion>
	</requires>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.cleantemptable.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBNb2R1bGU6IE5NUyAtIE5ld3NsZXR0ZXIgTWFkZSBTaW1wbGUKIyBWZXJzaW9uOiAxLjAtQmV0YTEsIFJvYmVydCBDYW1wYmVsbCA8cm9iQHRlY2hjb20uZHluZG5zLm9yZz4KIyAtIEJhc2VkIG9uIHRoZSBvcmlnaW5hbCBtb2R1bGUgb2YgdGhlIHNhbWUgbmFtZSBieSBQYXVsIExlbWtlCiMgKiBUaGlzIHZlcnNpb24gaXMgbm90IHJlYWR5IGZvciBwcmltZSB0aW1lLgojCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQojIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCiMgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KIwojIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAojIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiMgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQojIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCiMgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCiMgT3IgcmVhZCBpdCBvbmxpbmU6IGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy9saWNlbnNlcy5odG1sI0dQTAojCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIAoKJHRhYmxlbmFtZSA9IGNtc19kYl9wcmVmaXgoKS4kdGhpcy0+dGFibGVfcHJlZml4LiJ0ZW1wX2pvYnN0YXR1cyI7CgovLyBEcm9wIHRoZSB0ZW1wb3JhcnkgdGFibGUKJGRiID0mICR0aGlzLT5HZXREYigpOwokZGljdCA9IE5ld0RhdGFEaWN0aW9uYXJ5KCAkZGIgKTsKJHNxbGFycmF5ID0gJGRpY3QtPkRyb3BUYWJsZVNRTCggJHRhYmxlbmFtZSApOwokZGljdC0+RXhlY3V0ZVNRTEFycmF5KCRzcWxhcnJheSk7CQkJCQoKLy8gUmVkaXJlY3QgYmFjayB0byB0aGUgTk1TIGFkbWluIHBhbmVsCiR0aGlzLT5teVJlZGlyZWN0VG9UYWIoJGlkLCdqb2JzJywkcmV0dXJuaWQpOwoKLy8gRU9GCj8+]]></data>
	</file>
	<file>
	  <filename>/action.confirm_email.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.create_edit_job.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.create_new_list.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCEkdGhpcy0+Q2hlY2tQZXJtaXNzaW9uKCdNYW5hZ2UgTk1TIExpc3RzJykpCgl7CgkJJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCRpZCwgJHBhcmFtcywgJHJldHVybmlkLCAKCQkJCQkJCQkgJHRoaXMtPkxhbmcoJ2FjY2Vzc2RlbmllZCcpKTsKCQlyZXR1cm47Cgl9CgokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlJywgJHRoaXMtPkxhbmcoJ2NyZWF0ZW5ld2xpc3RfdGV4dCcpKTsKJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdwcm9tcHRfbmFtZScsICR0aGlzLT5MYW5nKCduYW1lJykpOwokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3Byb21wdF9kZXNjcmlwdGlvbicsICR0aGlzLT5MYW5nKCdkZXNjcmlwdGlvbicpKTsKJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdwcm9tcHRfcHVibGljJywgJHRoaXMtPkxhbmcoJ3Byb21wdF9wdWJsaWMnKSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbignc3RhcnRmb3JtJywJJHRoaXMtPkNyZWF0ZUZvcm1TdGFydCgkaWQsICdzYXZlX25ldycsICRyZXR1cm5pZCkpOwokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2VuZGZvcm0nLCAkdGhpcy0+Q3JlYXRlRm9ybUVuZCgpKTsKJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdzdWJtaXQnLCAgJHRoaXMtPkNyZWF0ZUlucHV0U3VibWl0KCRpZCwgJ3N1Ym1pdCcsIAoJCQkJCQkJCQkJCQkJCSAgJHRoaXMtPkxhbmcoJ3N1Ym1pdCcpKSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbignaGlkZGVuJywgJHRoaXMtPkNyZWF0ZUlucHV0SGlkZGVuKCRpZCwnb3JpZ19hY3Rpb24nLCRwYXJhbXNbJ2FjdGlvbiddKSk7CgppZiAoaXNzZXQoICRwYXJhbXNbJ2Vycm9yJ10gKSAmJiAkcGFyYW1zWydlcnJvciddICE9ICcnKXsKCSR0aGlzLT5zbWFydHktPmFzc2lnbignZXJyb3InLCAkcGFyYW1zWydlcnJvciddKTsKIH0KaWYgKGlzc2V0KCAkcGFyYW1zWydtZXNzYWdlJ10gKSAmJiAkcGFyYW1zWydtZXNzYWdlJ10gIT0gJycpewoJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdtZXNzYWdlJywgJHBhcmFtc1snbWVzc2FnZSddKTsKIH0KCiR0aGlzLT5zbWFydHktPmFzc2lnbignbmFtZScsICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnbmFtZScsIAoJCQkJCQkJCQkJCQkJIGlzc2V0KCRwYXJhbXNbJ25hbWUnXSk/JHBhcmFtc1snbmFtZSddOicnLDQwKSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbignZGVzY3JpcHRpb24nLCAkdGhpcy0+Q3JlYXRlSW5wdXRUZXh0KCRpZCwgJ2Rlc2NyaXB0aW9uJywgCgkJCQkJCQkJCQkJCQkJCWlzc2V0KCRwYXJhbXNbJ2Rlc2NyaXB0aW9uJ10pPyRwYXJhbXNbJ2Rlc2NyaXB0aW9uJ106JycsIDU1KSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbigncHVibGljJywkdGhpcy0+Q3JlYXRlSW5wdXRDaGVja2JveCgkaWQsJ3B1YmxpYycsJzEnKSk7CgovLyBEaXNwbGF5IHRoZSBwb3B1bGF0ZWQgdGVtcGxhdGUKZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlKCdjcmVhdGVuZXcudHBsJyk7Cj8+]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
    $message = '';
    if( isset($params['message']) )
      {
	$message = $params['message'];
      }
 
    $this->smarty->assign('prompt_email',$this->Lang('emailaddress'));
    if( isset( $params['error'] ) )  $this->smarty->assign('error',$params['error']);
    $this->smarty->assign('submitbtn', 
			  $this->CreateInputSubmit($id, 'submit', 
						   $this->Lang('submit')));
    $template = 'nms_subscribeform';

    $mode = 'subscribe';
    if(isset($params['mode']) && $params['mode'] != '')
      {
	$mode = $params['mode'];
      }

    if(isset($params['msgID']))
      {
		$mode = 'showmessage';
      }


    switch( $mode ) {
    case 'usersettings':
      {
	$this->smarty->assign('formstart',
			      $this->CreateFrontendFormStart($id, $returnid, 'usersettings_email' ));
	$this->smarty->assign('formend',$this->CreateFormEnd());
	$this->smarty->assign('email', $this->CreateInputText($id, 'email','',30, 150 ));
	$this->smarty->assign('formhidden', $this->CreateInputHidden($id, 'usersettings'));
	$template = 'usersettings_form';
      }
      break;

    case 'unsubscribe':
      {
	$this->smarty->assign('formstart',$this->CreateFrontendFormStart($id, $returnid, 'unsubscribe_email'));
	$this->smarty->assign('formend',$this->CreateFormEnd());
	$this->smarty->assign('email', $this->CreateInputText($id, 'email','',30, 150 ));
	$this->smarty->assign('formhidden', $this->CreateInputHidden($id, 'unsubscribe'));
	$template = 'nms_unsubscribeform';
      }
      break;

    case 'subscribe':
      {
	if( isset( $params['displayform'] ) && $params['displayform'] == 0 )
	  {
	    // nothing
	  }
	else
	  {
	    $lists = "";
	    if( isset( $params['select'] ) && $params['select'] != "" )
	      {
		$ar = explode(",",$params['select']);
		$lists = '("'.implode('","',$ar).'")';
	      }
	    $email = '';
	    if( isset( $params['email'] ) && $params['email'] != "" )
	      {
		$email = $params['email'];
	      }
	    $username = '';
	    if( isset( $params['username'] ) && $params['username'] != "" )
	      {
		$username = $params['username'];
	      }

	    $db = &$this->cms->db;
	    $result = array();
	    $temparray = array();
	
	    $query = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."list 
                       WHERE active = ? 
                         AND public = ?";
	    if( $lists != "" )
	      {
		$query .= " AND name IN ".$lists;
	      }
	    $query .= " ORDER BY listid";

	    $dbresult = $db->Execute($query,array(1,1));
	
	    if ($dbresult && $dbresult->RecordCount() > 0)
	      {
		$hidden = '';
		$oneonly = ($dbresult->RecordCount() == 1);
		while ($row = $dbresult->FetchRow())
		  {
		    $extratext = '';
		    if( $oneonly )
		      {
			$hidden .= $this->CreateInputHidden($id,"lists[]",$row['listid']);
			$extratext = 'checked="checked" disabled="disabled"';
		      }
		    $temparray[] = "<label>" . 
		      $this->CreateInputCheckbox($id, "lists[]",$row['listid'],"",$extratext).
		      $row['name'] . " - " . $row['description'] . "</label>";
		  }
		$this->smarty->assign('listids',$temparray);
		$this->smarty->assign('formstart',$this->CreateFrontendFormStart($id, $returnid, 'do_create_new_user','post','',true,'',$params));
		$this->smarty->assign('formend',$this->CreateFormEnd());
		$this->smarty->assign('email', $this->CreateInputText($id, 'email',$email,30, 150 ));
		$this->smarty->assign('prompt_username',$this->Lang('name'));
		$this->smarty->assign('username', $this->CreateInputText($id, 'username', $username, 30, 150 ));
		$this->smarty->assign('formhidden', $hidden );
	      }
	    else
	      {
		$message = $this->Lang('nolists');
	      }
	  }
      }
      break;
	  
	  case 'archive':
		// display list of archived newsletters
	    $db = &$this->cms->db;
		$limit = '';
		if(isset($params['show'])) {
			$limit = ' LIMIT 0,'.intval($params['show']);
		}
		// specify the field to sort by
		$sortby = (isset($params['sortby'])) ? $params['sortby'] : 'entered';
		$orderby = ' entered ';
		switch (strtolower($sortby)) {
			case 'msgid':
			case 'id':
				$orderby = ' messageid ';
			break;
			case 'subject':
				$orderby = ' subject ';
			break;
			case 'date':
			case 'entered':
			default:
				$orderby = ' entered ';
			break;
		}
		
		
		// specify the sort order for archived messages
		$sortorder = 'DESC';
		if(isset($params['sortorder']) && (strtolower($params['sortorder'])=='asc')) $sortorder = 'ASC';
		// specify the date output format
		$dateformat = (isset($params['dateformat'])) ? $params['dateformat'] : '%Y-%m-%d' ;
		$archiveQ = 'SELECT messageid, subject, entered FROM '.cms_db_prefix().$this->table_prefix.'messages ORDER BY '.$orderby.$sortorder.' '.$limit;
	    $archiveQRes = $db->Execute($archiveQ);
		$archived_messages = array();
		while ($archiveQRow = $archiveQRes->FetchRow()) {
			$archiveParams['msgID'] = $archiveQRow['messageid'];
			$archivedMessages[] = $this->CreateLink($id, 'default', $returnid, $archiveQRow['subject'], $archiveParams);
			
			// array to hold this message
			$archived_messages[] = array(
				'msgID'=> $archiveQRow['messageid'],
				'subject' => $archiveQRow['subject'],
				'fullurl' => $this->CreateLink($id, 'default', $returnid, $archiveQRow['subject'], $archiveParams),
				'href' => $this->CreateLink($id, 'default', $returnid, $archiveQRow['subject'], $archiveParams, false, true),
				'date' => strftime($dateformat,strtotime($archiveQRow['entered'])));
			
		} // end while

	  	$smarty->assign('archive_heading',$this->Lang('archive_heading'));
	  	$smarty->assign('archive_tbl_msgID',$this->Lang('archive_tbl_msgID'));
	  	$smarty->assign('archive_tbl_subject',$this->Lang('archive_tbl_subject'));
	  	$smarty->assign('archive_tbl_fullurl',$this->Lang('archive_tbl_fullurl'));
	  	$smarty->assign('archive_tbl_href',$this->Lang('archive_tbl_href'));
	  	$smarty->assign('archive_tbl_date',$this->Lang('archive_tbl_date'));
	    $smarty->assign('archived_messages',$archived_messages);
		echo $this->ProcessTemplate('archive.tpl');
	  break;
	  
	  case 'showmessage':
		// display a particular archived newsletters
	    $db = &$this->cms->db;
		$archiveQ = 'SELECT subject, message FROM '.cms_db_prefix().$this->table_prefix.'messages WHERE messageid='.$params['msgID'];
		$archiveQRes = $db->Execute($archiveQ);
		$archiveQRow = $archiveQRes->FetchRow();
		$smarty->assign('archivedmessage',$this->Lang('archivedmessage'));
		$smarty->assign('subject',$archiveQRow['subject']);
		// NEED TO FIGURE OUT WHAT TO DO WITH TEMPLATE PLACEHOLDERS (ie. {$username})
		$smarty->assign('messagebody',$archiveQRow['message']);
		echo $this->ProcessTemplate('archivedmessage.tpl');
	  break;

    default:
      $this->_DisplayErrorPage($id,$params,$returnid,
			       $this->Lang('invalidparam'));
      return;
    }

    // Display the populated template
	if($mode != 'archive' && $mode != 'showmessage') {
		$smarty->assign('message',$message);
		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.do_create_new_user.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
{
  // this action is called from the admin or the frontend when the subscribe form
  // is completed.
  $action = 'default';
  $confirmed = 0;
  $admin = false;
  if($returnid=='')
    {
      // we're an admin
      $action = 'create_new_user';
      $confirmed=1;
      $admin = true;
    }

  if( !isset( $params['email'] ) || $params['email'] == '' )
    {
      $params['message'] = $this->Lang('error_invalidemail');
      $params['error'] = 1;
      $this->Redirect( $id, $action, $returnid, $params, !$admin );
      return;
    }
  if( !isset($params['lists']) || count($params['lists']) == 0 )
    {
      $params['message'] = $this->Lang('error_selectonelist');
      $params['error'] = 1;
      $this->Redirect( $id, $action, $returnid, $params, !$admin );
      return;
    }

  $error = '';
  if (!check_email_mx($params['email']) )
    {
      $params['message'] = $this->Lang('error_invalidemail')." 2 ";
      $params['error'] = 1;
      $this->Redirect( $id, $action, $returnid, $params, !$admin );
      return;
    }

  $uniqueid = md5(uniqid(rand(),1));
  $db = &$this->cms->db;

  # Set the values for the fields in the record
  $record = array(); 
  $record["email"] = trim($params['email']);
  $record["username"] = trim($params['username']);
  $record["uniqueid"] = $uniqueid;
  $record["disabled"] = (isset($params['disabled'])) ? $params['disabled'] : 0;
  $record["confirmed"] = $confirmed;
  $record["htmlemail"] = 1;
  $record["dateadded"] = trim($db->DBTimeStamp(time()),"'");
    
  $query = "SELECT email from ".cms_db_prefix().$this->table_prefix."users where email = ?";
  $dbresult = $db->Execute($query,array($record['email']));
  if ($dbresult && $dbresult->RecordCount() > 0)
    {
      $params['message'] = $this->Lang('error_emailexists');
      $params['error'] = 1;
      $this->Redirect( $id, $action, $returnid, $params, !$admin );
      return;
    }

  // insert the user
  $query = "INSERT INTO ".cms_db_prefix().$this->table_prefix."users (email, username, uniqueid, disabled, confirmed, htmlemail, dateadded) VALUES (?,?,?,?,?,?,?)";
  $dbresult = $db->Execute($query, $record); 
  if( !$dbresult ) 
    {
      echo $db->ErrorMsg();
      return;
    }
    
  // get user id back from the table
  $query = "SELECT userid from ".cms_db_prefix().$this->table_prefix."users where uniqueid = ?";
  $dbresult = $db->Execute($query,array($uniqueid));
    
  if ($dbresult && $dbresult->RecordCount() > 0)
    {
      $row = $dbresult->FetchRow();
      $userid = $row['userid'];

      if( isset($params['lists']) && count($params['lists']) > 0 )
	{
	  // add him to his member lists
	  foreach ($params['lists'] as $listid){
	    // add to list/user table
	    $query = "SELECT name from ".cms_db_prefix().$this->table_prefix."list where listid = ?";
	    $dbresult = $db->Execute($query,array($listid));
	      
	    if ($dbresult && $dbresult->RecordCount() > 0){
	      $row = $dbresult->FetchRow();
	      $record = array();
	      $record["userid"] = $userid;
	      $record["listid"] = $listid;
	      $record["active"] = 1;
	      $record["entered"] = trim($db->DBTimeStamp(time()),"'");
		
	      $query = "INSERT INTO ".cms_db_prefix().$this->table_prefix."listuser (userid, listid, active, entered) VALUES (?,?,?,?)";
	      $dbresult = $db->Execute($query, $record); 	
	    }				
	  }
	}
	
      $send_email = 1;
      $pref = $this->GetPreference('email_user_on_admin_subscribe',0);
      $pref = ($pref == false ) ? 0 : $pref;
      $disabled = isset($params['disabled']) ? $params['disabled'] : 0;
      if( $admin )
	{
	  if( $pref == 0 || $disabled == 0 )
	    {
	      $send_email = 0;
	    }
	}

      // ***************send Confirm e-mail
      if( $send_email )
	{
	  // get the names of the lists matching the listid's
	  $listnames = array();
	  $q = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."list WHERE listid = ?";
	  foreach( $params['lists'] as $listid )
	    {
	      $dbresult = $db->Execute( $q, array($listid) );
	      if( $dbresult && $dbresult->RecordCount() )
		{
		  $row = $dbresult->FetchRow();
		  $listnames[] = $row['name'];
		}
	    }
	    
	  $mailer =& $this->GetModuleInstance('CMSMailer');
	  $mailer->reset();
	  $mailer->SetSubject($this->GetPreference('confirm_subject'));

	  $this->smarty->assign('lists', $listnames );
	  $this->smarty->assign('email', trim($params['email']));
	  $this->smarty->assign('username', trim($params['username']));
	  $this->smarty->assign('unsubscribe',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'unsubscribe',
							  $this->Lang('unsubscribe'))));
	  $this->smarty->assign('unsubscribeurl',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'unsubscribe',
							  $this->Lang('unsubscribe'), array(), '', true)));
	  $this->smarty->assign('preferences',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'preferences',
							  $this->Lang('preferences'))));
	  $this->smarty->assign('preferencesurl',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'preferences',
							  $this->Lang('preferences'), array(), '', true)));

	  $this->smarty->assign('confirm',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'confirm_email',
							  $this->Lang('confirm'), 
							  array('uniqueid' => $uniqueid))));
	  $this->smarty->assign('confirmurl',
				$this->_cleanLink(
				$this->CreateFrontendLink($id,$returnid,'confirm_email',
							  $this->Lang('confirm'), 
							  array('uniqueid' => $uniqueid), '', true)));
	  $bodytext = $this->ProcessTemplateFromDatabase('subscribe_email_body');
	  $mailer->SetBody($bodytext);
	  $mailer->AddAddress($params['email']);
	  $mailer->SetCharSet($this->GetPreference('message_charset'));
	  $mailer->SetFromName($this->GetPreference('admin_name'));
	  $mailer->SetFrom($this->GetPreference('admin_email'));
	  $mailer->Send();
	}

      // Send an event
      $parms = array();
      $parms['email'] = trim($params['email']);
      $parms['username'] = trim($params['username']);
      $parms['lists'] = $listnames;
      $this->SendEvent('OnNewUser',$parms);
    }

  if( $admin )
    {
      $this->myRedirectToTab( $id, 'users', $returnid );
    }
  else
    {
      echo $this->GetPreference('subscribe_posttext');
    }
}
?>]]></data>
	</file>
	<file>
	  <filename>/action.do_feu_import_users.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.do_import_users.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
  if (!$this->CheckPermission('Manage NMS Users')) {
      $this->_DisplayErrorPage($id, $params, $returnid, $this->Lang('accessdenied'));
      return;
  }
  
  $db = $this->GetDb();
  
  if (!isset($_FILES[$id . 'input_filename']) || !isset($_FILES) || !is_array($_FILES[$id . 'input_filename']) || !$_FILES[$id . 'input_filename']['name']) {
      $params['message'] = $this->Lang('error_nofilesuploaded');
      $params['error'] = 1;
      $this->Redirect($id, 'import_users', $returnid, $params);
      return;
  }
  
  // normalize the file variable
  $file = $_FILES[$id . 'input_filename'];
  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']));
  
  // we can now open the file, and read it's contents
  $alllines = file($file['tmp_name']);
  if (count($alllines) == 0) {
      $params['message'] = $this->Lang('error_emptyfile');
      $params['error'] = 1;
      $this->Redirect($id, 'import_users', $returnid, $params);
      return;
  }
  
  // now process the lines
  $errors = array();
  $errorcount = 0;
  $linenum = 0;
  $usersadded = 0;
  $membershipsadded = 0;
  foreach ($alllines as $line) {
      $linenum++;
      
      // strip off extra whitespace
      $line = trim($line);
      
      // strip off comments
      $p = strrpos($line, '//');
      if ($p) {
          $line = trim(substr($line, 0, $p));
      }
      
      // skip empty lines
      if ($line == '') {
          continue;
      }
      
      $fields = explode(',', $line);
      if (count($fields) < 5) {
          $errors[] = $this->Lang('importerror_nofields', $linenum);
          $errorcount++;
          continue;
      }
      
      // woohoo, we have at least 6 columns
      // we only need 6
      
      // check the email address to make sure it's valid (should have an @ sign in it)
      // todo
      $uniqueid = trim($fields[0]);
      $email = trim($fields[1]);
      $username = trim($fields[2]);
      // now lookup the id of the list in the column (cache the results)
      $listname = trim($fields[3]);
      $active = trim($fields[4]);
      if (!isset($cached_lists[$listname])) {
          $q = "SELECT listid FROM " . cms_db_prefix() . $this->table_prefix . "list WHERE name = ?";
          $dbresult = $db->Execute($q, array($listname));
          if (!$dbresult || $dbresult->RecordCount() == 0) {
              $errors[] = $this->Lang('importerror_nosuchlist', $linenum, $listname);
              $errorcount++;
              continue;
          }
          
          $row = $dbresult->FetchRow();
          $cached_lists[$listname] = $row['listid'];
      }
      // Lets see if this is a record update rather than a new user.
      // Use the uniqueid and or email to find the record
      $query = "SELECT * FROM " . cms_db_prefix() . $this->table_prefix . "users WHERE email = ? or uniqueid = ?";
      $dbresult = $db->Execute($query, array($email, $uniqueid));
      if (!$dbresult || $dbresult->RecordCount() == 0) {
	      // New user, add the user
          $query = "INSERT INTO " . cms_db_prefix() . $this->table_prefix . "users (email, username, uniqueid, disabled, confirmed, htmlemail, dateadded) VALUES (?,?,?,?,?,?,?)";
          $dbresult = $db->Execute($query, array($email, $username, $uniqueid, 0, 1, 1, trim($db->DBTimeStamp(time()), "'")));
          if (!$dbresult) {
              $errors[] = $this->Lang('importerror_cantcreateuser', $linenum, $email);
              $errorcount++;
              continue;
          }
	      $q = "SELECT userid FROm " . cms_db_prefix() . $this->table_prefix . "users WHERE email = ?";
          $dbresult = $db->Execute($q, array($email));
	      $row = $dbresult->FetchRow();
      	  $userid = $row['userid'];
          $usersadded++;
      } else {
      	  // Update the user
      	  $record = $dbresult->FetchRow();
      	  $userid = $record['userid'];
      	  $query = "UPDATE " . cms_db_prefix() . $this->table_prefix . "users SET email=?, username=?, uniqueid=?, disabled=?, confirmed=?, htmlemail=?, dateadded=? WHERE userid=?";
          $dbresult = $db->Execute($query, array($email, $username, $uniqueid, 0, 1, 1, trim($db->DBTimeStamp(time()), "'"), $record['userid']));
          if (!$dbresult) {
              $errors[] = $this->Lang('importerror_cantcreateuser', $linenum, $email);
              $errorcount++;
              continue;
          }
      }
      // a little error check
      if ($userid == '') {
          $errors[] = $this->Lang('importerror_cantgetuserid', $linenum, $email);
          $errorcount++;
          continue;
      }
      // and add him to the list
      // if he's already in the list, update it with the new setting
      $q = "SELECT * FROM " . cms_db_prefix() . $this->table_prefix . "listuser WHERE userid = ? AND listid = ?";
      $dbresult = $db->Execute($q, array($userid, $cached_lists[$listname]));
      if (!$dbresult || $dbresult->RecordCount() == 0) {
          // add list membership here
          $q = "INSERT INTO " . cms_db_prefix() . $this->table_prefix . "listuser VALUES (?,?,?,?)";
          $record = array($userid, $cached_lists[$listname], 1, trim($db->DbTimeStamp(time()), "'"));
          $dbresult = $db->Execute($q, $record);
          
          // we ignore any errors here, as otherwise we don't know what lists
          // we've added this user to in this session, and wether or not he already
          // existed, and it would be too hard to back out of.
          $membershipsadded++;
      } else {
      	  // remove the list membership
      	  if ($active == false) {
      	  	$q = "DELETE FROM " . cms_db_prefix() . $this->table_prefix . "listuser WHERE listid=? and userid=?";
      	  	$record = array($cached_lists[$listname], $userid);
      	  	$dbresult = $db->Execute($q, $record);
      	  }
          // we ignore any errors here, as otherwise we don't know what lists
          // we've added this user to in this session, and wether or not he already
          // existed, and it would be too hard to back out of.
          $membershipsadded++;
      }
      
      // and go around again
  }
  
  // all done
  if ($errorcount > 0) {
      $this->smarty->assign('errorcountmsg', $this->Lang('error_importerrorcount'));
      $this->smarty->assign('linesmsg', $this->Lang('lines'));
      $this->smarty->assign('usersaddedmsg', $this->Lang('users_added'));
      $this->smarty->assign('membershipsmsg', $this->Lang('memberships'));
      
      $this->smarty->assign('errors', $errors);
      $this->smarty->assign('errorcount', $errorcount);
      $this->smarty->assign('lines', $linenum);
      $this->smarty->assign('usersadded', $usersadded);
      $this->smarty->assign('memberships', $membershipsadded);
      echo $this->ProcessTemplate('import_errors.tpl');
      return;
  } else {
      $params['lines'] = $linenum;
      $params['usersadded'] = $usersadded;
      $params['membershipsadded'] = $membershipsadded;
      $this->Redirect($id, 'import_users', $returnid, $params);
  }
?>]]></data>
	</file>
	<file>
	  <filename>/action.do_usersettings.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.edit_list.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.export_users.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.feu_import_users.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.import_users.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.process_queue.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
// ABANDON HOPE ALL YEE WHO ENTER HERE
// this code is in serious need of a rewrite

if (!$this->CheckPermission('Manage NMS Jobs'))
  {
    $this->_DisplayErrorPage($id, $params, $returnid, 
			     $this->Lang('accessdenied'));
    return;
  }

   // Page header... note that all styles, etc. are inline
echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
          <html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="en">
          <head>
            <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
            <title>'.$this->GetFriendlyName().' Processing Job</title>
            <style type="text/css">
            body {
             background-color: #395D73;
             font: 0.8em/1 Geneva, Verdana, Arial, sans-serif;
            }
            #wrap {
             background-color: #FFF;
             border-right: 1px solid #CCC;
             border-bottom: 1px solid #333;
             border-left: 1px solid #333;
             padding: 2em;
             margin: 5em;
             position: relative;
             text-align: left;
             width: 760px !important;
             width /**/: 752px;
            }
            div.error {
                color: #F00;
                fint-size: 1.2em;
                font-weight: bold;
            }
            div.header {
                color:#000;
                font-size: 1.2em;
                font-weight: bold;
            }
            div.progress {
                color: 666;
            }
            .close {
                text-decoration: underline;
                color: #00F;
            }
            </style>
            </head>
          <body>
          <div id="wrap">
          <div class="header">'.$this->GetFriendlyName().' '.$this->Lang('msg_jobprocessing').'</div><br/>
          <div class="progress" align="center">';

global $config;
$start_time = time();
$db = $this->GetDb();
$tablename = cms_db_prefix().$this->table_prefix."temp_jobstatus";
$first = isset($params['start_record'])?false:true;
if( ($first == false) && 
    (!isset($params['thejob']) || $params['thejob'] == '' ||
     !isset($params['start_time']) || $params['start_time'] == '') )
  {
    $this->_DisplayErrorPage($id, $params, $returnid, 
			     $this->Lang('error_insufficientparams'));
    return;
  }

$num_emails = 0;
if( isset( $params['num_emails'] ) )
  {
    $num_emails = $params['num_emails'];
  }
if( isset( $params['start_time'] ) && $params['start_time'] != '' )
  {
    $start_time = $params['start_time'];
  }
if( isset( $params['alldone'] ) )
  {
    // we're all done, spit out some nice information
    // and clean up.
    if( isset( $params['error'] ) )
      {
	echo '<div class="error">'.$params['error'].'</div>';
      }
    echo "<p><string>".$this->Lang('queuefinished')."</strong></p>";
    $totaltime = time() - $start_time;
    echo "<p>".$this->Lang('totaltime')." ".$totaltime." <strong>".$this->Lang('seconds')."</strong></p>";
    echo "<p>".$this->Lang('totalmails')." <strong>".$num_emails."</strong></p>";
    echo "<p>".$this->Lang('okclosewindow')."</p></div></body></html>";
    @ob_flush(); flush();
    return;
  }

// keep window open message
echo "<p><strong>".$this->Lang('keepwindowopen')."</strong></p>";

// just in case, set the time_limit of this page to unlimited
// though ideally we should set this to some formula like
// message_per_batch * sleep_per_message + some forgiveness
// NOTE: some servers may not let this happen
set_time_limit(0);

if( $first )
  {
    //
    // we're initializing a job
    //

    // get the first job that has a status of 0
    $q = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."jobs WHERE status = ? LIMIT 1";
    $dbresult = $db->Execute( $q, array( 0 ) );
    if( !$dbresult || $dbresult->RecordCount() == 0 )
      {
	// no further jobs to process
	$parms = array();
	$parms['alldone'] = 1;
	$parms['disable_buffer'] = 1;
	$parms['disable_theme'] = 1;
	$parms['start_time'] = $start_time;
	$parms['num_emails'] = $num_emails;
	$parms['thejob'] = $jobrow['jobid'];
	$this->Redirect( $id, 'process_queue', $returnid, $parms );
	return;
      }
    $jobrow = $dbresult->FetchRow();
	
    // next check the message, make sure it still exists
    $messageid = '';
    {
      $q = "SELECT DISTINCT messageid 
                FROM ".cms_db_prefix().$this->table_prefix."job_parts
               WHERE jobid = ?";
      $dbresult = $db->Execute($q,array($jobrow['jobid']));
      if( !$dbresult )
	{
	  // process error - could not find job part
	  $parms = array();
	  $parms['alldone'] = 1;
	  $parms['disable_buffer'] = 1;
	  $parms['disable_theme'] = 1;
	  $parms['start_time'] = $start_time;
	  $parms['error'] = $this->Lang('error_couldnotfindjobpart');
	  $parms['num_emails'] = $num_emails;
	  $parms['thejob'] = $jobrow['jobid'];
	  $this->Redirect( $id, 'process_queue', $returnid, $parms );
	}
      $tmprow = $dbresult->FetchRow();
	  
      $q = "SELECT * 
                  FROM ".cms_db_prefix().$this->table_prefix."messages
                 WHERE messageid = ?";
      $dbresult = $db->Execute($q,array($tmprow['messageid']));
      if( !$dbresult )
	{
	  // process error - could not find message
	  $parms = array();
	  $parms['alldone'] = 1;
	  $parms['disable_buffer'] = 1;
	  $parms['disable_theme'] = 1;
	  $parms['start_time'] = $start_time;
	  $parms['error'] = $this->Lang('error_couldnotfindmessage');
	  $parms['num_emails'] = $num_emails;
	  $parms['thejob'] = $jobrow['jobid'];
	  $this->Redirect( $id, 'process_queue', $returnid, $parms );
	}
      $tmprow = $dbresult->FetchRow();
	  
      // then check to see if the template id that the message refers to (if >= 0 )
      // is valid and exists
      if( $tmprow['templateid'] > 0 )
	{
	  global $gCms;
	  $obj =& $gCms->GetTemplateOperations();
	  $templ = $obj->LoadTemplateByID($tmprow['templateid']);
	  if( !$templ )
	    {
	      // process error - could not find template
	      $parms = array();
	      $parms['alldone'] = 1;
	      $parms['disable_buffer'] = 1;
	      $parms['disable_theme'] = 1;
	      $parms['start_time'] = $start_time;
	      $parms['error'] = $this->Lang('error_couldnotfindtemplate');
	      $parms['num_emails'] = $num_emails;
	      $parms['thejob'] = $jobrow['jobid'];
	      $this->Redirect( $id, 'process_queue', $returnid, $parms );
	    }
	}
    }


    // check to see if our temporary table exists
    // if it does, and we've starting processing
    // that is an error
    $q = "SELECT * FROM ".$tablename." LIMIT 1";
    $dbresult = $db->Execute( $q );
    if( $dbresult && $dbresult->RecordCount() )
      {
	// todo, error
	$parms = array();
	$parms['alldone'] = 1;
	$parms['disable_buffer'] = 1;
	$parms['disable_theme'] = 1;
	$parms['start_time'] = $start_time;
	$parms['error'] = $this->Lang('error_temporarytableexists');
	$parms['num_emails'] = $num_emails;
	$parms['thejob'] = $jobrow['jobid'];
	$this->Redirect( $id, 'process_queue', $returnid, $parms );
	return;
      }

    echo "<p>".$this->Lang('initializing_job').': <strong>'.$jobrow['title'].'</strong></p>';
    flush(); @ob_flush();

    // create a table (temporary in purpose) containing all
    // of the emails we're going to send to
    $taboptarray = array('mysql' => 'TYPE=MyISAM');
    $dict = NewDataDictionary($db);
    $flds = "
                jobid I,
                messageid I,
                email C(125),
                uniqueid C(225),
                username C(255),
                status I
		";
    $sqlarray = $dict->CreateTableSQL($tablename,$flds,
				      $taboptarray);
    $dict->ExecuteSQLArray($sqlarray);
	
    // insert some records into the table 
    // NOTE: We can probably do this better, with some kind of SELECT FROM
    //       statement or something, but....
    $q = "SELECT DISTINCT jobid,email,username,C.uniqueid,messageid FROM ".
      cms_db_prefix().$this->table_prefix."listuser A left join ".
      cms_db_prefix().$this->table_prefix."job_parts B on A.listid = B.listid left join ".
      cms_db_prefix().$this->table_prefix."users C on A.userid = C.userid 
	  WHERE C.disabled = 0 AND jobid = ? order by messageid";
    $dbresult = $db->Execute( $q, array( $jobrow['jobid'] ) );
    if( !$dbresult || $dbresult->RecordCount() == 0 )
      {
	// error
	$parms = array();
	$parms['alldone'] = 1;
	$parms['disable_buffer'] = 1;
	$parms['disable_theme'] = 1;
	$parms['start_time'] = $start_time;
	$parms['error'] = $this->Lang('error_buildingtemptable');
	$parms['num_emails'] = $num_emails;
	$parms['thejob'] = $jobrow['jobid'];
	$this->Redirect( $id, 'process_queue', $returnid, $parms );
	return;
      }

    $count = 0;
    $q = "INSERT INTO ".$tablename." VALUES (?,?,?,?,?,?)";
    while( $row = $dbresult->FetchRow() )
      {
	$tmp = array( $jobrow['jobid'],
		      $row['messageid'],
		      $row['email'],
		      $row['uniqueid'],
		      $row['username'],
		      0 );
	$dbresult2 = $db->Execute( $q, $tmp );
	if( !$dbresult2 )
	  {
	    $parms = array();
	    $parms['alldone'] = 1;
	    $parms['disable_buffer'] = 1;
	    $parms['disable_theme'] = 1;
	    $parms['start_time'] = $start_time;
	    $parms['error'] = $this->Lang('error_buildingtemptable');
	    $parms['num_emails'] = $num_emails;
	    $parms['thejob'] = $jobrow['jobid'];
	    $this->Redirect( $id, 'process_queue', $returnid, $parms );
	    return;
	  }
	$count++;
	if( $count % 10 == 0 )
	  {
	    // some sort of progress indicator (hopefully)
	    echo "="; flush(); @ob_flush();
	  }
      }

    // mark the job as started
    $q = "UPDATE ".cms_db_prefix().$this->table_prefix."jobs SET started = ?, status = ?
              WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( trim($db->DbTimeStamp(time()),"'"), 
					 1, $jobrow['jobid'] ) );
    // send an event
    $this->SendEvent('OnStartJob',
		     array('jobname' => $jobrow['title'],
			   'jobid' => $jobrow['jobid'] ));

    // redirect back for refresh
    // set the start_record to 0 so that we get past this stuff again
    $params['num_emails'] = $num_emails;
    $params['start_record'] = 0;
    $params['start_time'] = $start_time;
    $params['thejob'] = $jobrow['jobid'];
    $params['thejobname'] = $jobrow['title'];
    $this->Redirect( $id, 'process_queue', $returnid, $params );
    return;
  }


//
// start processing a chunk
//
$num_per_batch = $this->GetPreference('messages_per_batch',50);
if( !isset( $params['start_record'] ) )
  {
    $parms = array();
    $parms['alldone'] = 1;
    $parms['disable_buffer'] = 1;
    $parms['disable_theme'] = 1;
    $parms['start_time'] = $start_time;
    $parms['error'] = $this->Lang('error_otherprocessingerror').' 1';
    $parms['num_emails'] = $num_emails;
    $parms['thejob'] = $jobrow['jobid'];
    $this->Redirect( $id, 'process_queue', $returnid, $params );
  }
$start_record = $params['start_record'];
    	
//get list were sending this round.
$q = "SELECT * FROM ".$tablename." ORDER BY messageid LIMIT $start_record,$num_per_batch";
$dbresult = $db->Execute($q);

$mailer =& $this->GetModuleInstance('CMSMailer');
$mailer->reset();
$mailer->IsHTML(true); 

$message = array();
if ($dbresult && ($dbresult->RecordCount() > 0)){
      
  //start sending this round
  echo '<p>'.$this->Lang('send_next_batch',$num_per_batch, $start_record)."</p>"; flush(); @ob_flush();

  $end_record = $start_record + $dbresult->RecordCount();
  echo '<p>'.$this->Lang('processing_job').': <strong>'.$params['thejobname'].'</strong></p>';
  echo '<p>'.$this->Lang('processing_records',$start_record,$end_record).'</p>';
  flush(); @ob_flush();
      
  while ($row = $dbresult->FetchRow()) 
    {   		
      // and get the message stuff
      // note, we try to cache the messages
      if( count( $message ) == 0 )
	{
	  $q = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."messages WHERE messageid = ?";
	  $dbresult2 = $db->Execute( $q, array( $row['messageid'] ) );
	  if( !$dbresult2 || $dbresult->RecordCount() == 0 )
	    {
	      $parms = array();
	      $parms['alldone'] = 1;
	      $parms['disable_buffer'] = 1;
	      $parms['disable_theme'] = 1;
	      $parms['start_time'] = $start_time;
	      $parms['error'] = $this->Lang('error_couldnotfindmessage').' 2';
	      $parms['num_emails'] = $num_emails;
	      $parms['thejob'] = $jobrow['jobid'];
	      $this->Redirect( $id, 'process_queue', $returnid, $params );
	      return;
	    }
	  $message = $dbresult2->FetchRow();
	}

      //        we're NOT gonna send twice the emails out
      //	  if ($this->GetPreference("send_admin_copies") == "true"){
      // 	    $mailer->ClearAllRecipients();
      // 	    $mailer->AddAddress($this->GetPreference("admin_email"));
      // 	    if ($config['debug'] != true){
      // 	      $mailer->SetFromName($this->GetPreference('admin_name'));
      // 	      $mailer->SetFrom($this->GetPreference('admin_email'));
      // 	      $mailer->Send();
      // 	    }
      //	  }

      //send email
      $mailer->ClearAllRecipients();	
      $mailer->SetSubject($message['subject']);
      $mailer->SetCharSet($this->GetPreference('message_charset'));
      $mailer->SetFrom($message['replyto']);
      $mailer->SetFromName($message['fromwho']);
      $this->smarty->assign('subject',$message['subject']);
      $this->smarty->assign('username',$row['username']);
      $this->smarty->assign('email',$row['email']);
      $this->smarty->assign('uniqueid',$row['uniqueid']);

      $link = $this->CreateFrontendLink( $id, $returnid, 'unsubscribe_email', '', 
					 array('showtemplate'=>false,'uniqueid'=>$row['uniqueid']) , 
					 '', true, '', true);
      $link = str_replace("/".$config['admin_dir'], "", $link);
      $this->smarty->assign('unsubscribe',$link);

      {
	$prefspage = $this->GetPreference('usersettings_page');
	$contentops =& $gCms->GetContentOperations();
	if( $prefspage == '' )
	  {
	    $prefspage = $contentops->GetDefaultPageID();
	  }
        $content = $contentops->LoadContentFromAlias($prefspage);
	if( !$content )
	  {
	    $prefspage = $contentops->GetDefaultPageID();
	  }
	$link = $this->CreateFrontendLink( $id, $prefspage, 'usersettings', '',
					   array('uniqueid'=>$row['uniqueid']) ,
					   '', true, '', true);
	$link = str_replace("/".$config['admin_dir'], "", $link);
	$this->smarty->assign('preferences',$link);
      }

      $link = $this->CreateFrontendLink( $id, $returnid, 'confirm_email', '',
					 array('showtemplate'=>false,'uniqueid'=>$row['uniqueid']) ,
					 '', true, '', true);
      $link = str_replace("/".$config['admin_dir'], "", $link);
      $this->smarty->assign('confirmurl',$link);
				
      $bodytext = "";
      $bodytext .= $this->ProcessTemplateFromData( $message['message'] );

      switch( $message['templateid'] )
	{
	case -1: // html message (no template)
	  $mailer->SetBody($bodytext);
	  $mailer->IsHTML(true);
	  break;
	      
	case -2: // text message
	  $mailer->SetBody($bodytext);
	  $mailer->IsHTML(false);
	  break;

	default: // page template
	  // assign the message as {$message_text} variable
	  $this->smarty->assign('message_text',$bodytext);

	  // load the page template given the id
	  {
	    global $gCms;
	    $obj =& $gCms->GetTemplateOperations();
	    $templ = $obj->LoadTemplateByID($message['templateid']);
	    if( $templ !== false )
	      {
		// load the page info, given the page id
		$mypi = PageInfoOperations::LoadPageInfoByContentAlias($message['pageid']);
		if( isset( $mypi ) && $mypi !== FALSE )
		  {
		    $gCms->variables['pageinfo'] =& $mypi;
			
		    $gCms->variables['content_id'] = $mypi->content_id;
		    $gCms->variables['page'] = $message['pageid'];
		    $gCms->variables['page_id'] = $message['pageid'];
			
		    $gCms->variables['page_name'] = $mypi->content_alias;
		    $gCms->variables['position'] = $mypi->content_hierarchy;

		    $contentops =& $gCms->GetContentOperations();
		    $gCms->variables['friendly_position'] = $contentops->CreateFriendlyHierarchyPosition($mypi->content_hierarchy);
			
		    $smarty->assign('content_id', $mypi->content_id);
		    $smarty->assign('page', $message['pageid']);
		    $smarty->assign('page_id', $message['pageid']);	
		    $smarty->assign('page_name', $mypi->content_alias);
		    $smarty->assign('page_alias', $mypi->content_alias);
		    $smarty->assign('position', $mypi->content_hierarchy);
		    $smarty->assign('friendly_position', $gCms->variables['friendly_position']);
		    // and process the template
		    $bodytext = $this->ProcessTemplateFromData($templ->content);
		  }

	      }
	    else
	      {
		$bodytext = '<H1>ERROR: Could not find the appropriate template</H1>';
	      }
	  }
	  $mailer->SetBody($bodytext);
	  $mailer->IsHTML(true);
	  break;
	}

      flush();
      @ob_flush();

      $mailer->AddAddress($row['email']);
      $mailer->Send();    	

      //give the server a little break...
      usleep($this->GetPreference('ms_between_message_sleep',100)); 

      // something resembling progress
      $num_emails++;
      echo "="; flush(); @ob_flush();
    } // while (processing a chunk)

      // have a little sleep before we keep going
  sleep($this->GetPreference('between_batch_sleep',5));

  // redirect back, with the start number
  // so that we can keep going if we need to
  $params['num_emails'] = $num_emails;
  $params['start_record'] = $end_record;
  $params['start_time'] = $start_time;
  $this->Redirect( $id, 'process_queue', $returnid, $params );
  return;
 }

//
// if we got here, there are no further records to process
// in this job.
//

// delete the temporary table
$dict = NewDataDictionary( $db );
$sqlarray = $dict->DropTableSQL( $tablename );
$dict->ExecuteSQLArray($sqlarray);				

// mark the job as complete
$q = "UPDATE ".cms_db_prefix().$this->table_prefix."jobs SET finished = ".
  $db->DbTimeStamp(time()).", status = ? WHERE jobid = ?";
$dbresult = $db->Execute( $q, array( 3, $params['thejob'] ) );

// send an event
$this->SendEvent('OnFinishJob',array('jobid'=>$params['thejob']));

// send a notification message
// todo, some other preference I don't want a copy of every
// email, just wanna be notified at the end when its done maybe
if ($this->GetPreference("send_admin_copies") == "true"){
  $totaltime = time() - $start_time;
  $mailer =& $this->GetModuleInstance('CMSMailer');
  $mailer->reset();
  $mailer->IsHTML(true);
  $mailer->SetSubject($message['subject']);
  $mailer->SetFrom($message['replyto']);
  $mailer->SetBody("Emailing has finished. It took $totaltime seconds to send.");
  $mailer->AddAddress($this->GetPreference('admin_email'));
  $mailer->SetFromName($this->GetPreference('admin_name'));
  $mailer->SetCharSet($this->GetPreference('message_charset'));
  $mailer->SetFrom($this->GetPreference('admin_email'));
  $mailer->Send();
  ++$num_emails;
 }

// and redirect back, with no start number
// parameter so we can start the next job
$params['num_emails'] = $num_emails;
$params['start_time'] = $start_time;
unset( $params['start_record'] );
unset( $params['thejob'] );
$this->Redirect( $id, 'process_queue', $returnid, $params );
return;


?>]]></data>
	</file>
	<file>
	  <filename>/action.save_confirm_prefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLy8gU2F2ZSB0aGUgY29uZmlybSBwcmVmZXJlbmNlcwppZiAoISR0aGlzLT5DaGVja1Blcm1pc3Npb24oJ01vZGlmeSBTaXRlIFByZWZlcmVuY2VzJykpCiAgewogICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCRpZCwgJHBhcmFtcywgJHJldHVybmlkLCAKCQkJICAgICAkdGhpcy0+TGFuZygnYWNjZXNzZGVuaWVkJykpOwogICAgcmV0dXJuOwogIH0KCiAgaWYoIGlzc2V0KCAkcGFyYW1zWydpbnB1dF9yZXNldCddICkgKQogICAgewogICAgICAkdGhpcy0+U2V0VGVtcGxhdGUoJ2NvbmZpcm1fZW1haWxfYm9keScsICR0aGlzLT5kZWZhdWx0X2NvbmZpcm1fZW1haWxfYm9keSApOwogICAgICAkdGhpcy0+U2V0UHJlZmVyZW5jZSgnY29uZmlybV9zdWJqZWN0JywgJHRoaXMtPmRlZmF1bHRfY29uZmlybV9zdWJqZWN0ICk7CiAgICAgICR0aGlzLT5TZXRUZW1wbGF0ZSgncG9zdF9lbWFpbF9jb25maXJtX21lc3NhZ2UnLCAkdGhpcy0+ZGVmYXVsdF9wb3N0X2VtYWlsX2NvbmZpcm1fbWVzc2FnZSk7CiAgICB9CiAgZWxzZQogICAgewogICAgICAkdGhpcy0+U2V0VGVtcGxhdGUoJ2NvbmZpcm1fZW1haWxfYm9keScsIAoJCQkgaXNzZXQoJHBhcmFtc1snY29uZmlybV9lbWFpbF9ib2R5J10pPyRwYXJhbXNbJ2NvbmZpcm1fZW1haWxfYm9keSddOicnKTsKICAgICAgJHRoaXMtPlNldFByZWZlcmVuY2UoJ2NvbmZpcm1fc3ViamVjdCcsIAoJCQkgICBpc3NldCgkcGFyYW1zWydjb25maXJtX3N1YmplY3QnXSk/JHBhcmFtc1snY29uZmlybV9zdWJqZWN0J106JycpOwogICAgICAkdGhpcy0+U2V0VGVtcGxhdGUoJ3Bvc3RfZW1haWxfY29uZmlybV9tZXNzYWdlJywgCgkJCSBpc3NldCgkcGFyYW1zWydwb3N0X2VtYWlsX2NvbmZpcm1fbWVzc2FnZSddKT8kcGFyYW1zWydwb3N0X2VtYWlsX2NvbmZpcm1fbWVzc2FnZSddOicnKTsKICAgIH0KCiR0aGlzLT5teVJlZGlyZWN0VG9UYWIoICRpZCwgJ2NvbmZpcm1fc3Vic2NyaWJlX2Zvcm0nLCAkcmV0dXJuaWQgKTsKCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.save_usersettings_prefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.unsubscribe.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.unsubscribe_email.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYoICFpc3NldCggJHBhcmFtc1sndW5pcXVlaWQnXSApICkKICB7CiAgICAkdGhpcy0+X0Rpc3BsYXlFcnJvclBhZ2UoICRpZCwgJHBhcmFtcywgJHJldHVybmlkLAoJCQkgICAgICAkdGhpcy0+TGFuZygnZXJyb3JfaW5zdWZmaWNpZW50cGFyYW1zJykpOwogICAgcmV0dXJuOwogIH0KCiAgJGRiID0gJHRoaXMtPkdldERiKCk7CgogICRxdWVyeSA9ICJTRUxFQ1QgKiBmcm9tICIuY21zX2RiX3ByZWZpeCgpLiR0aGlzLT50YWJsZV9wcmVmaXguInVzZXJzIHdoZXJlIHVuaXF1ZWlkID0gPyI7CiAgJHJlY29yZFsidW5pcXVlaWQiXSA9ICRwYXJhbXNbJ3VuaXF1ZWlkJ107CiAgJGRicmVzdWx0ID0gJGRiLT5FeGVjdXRlKCRxdWVyeSwgJHJlY29yZCk7CiAgaWYoICEkZGJyZXN1bHQgfHwgKCAkZGJyZXN1bHQtPlJlY29yZENvdW50KCkgPT0gMCApICkKICAgIHsKICAgICAgJHRoaXMtPl9EaXNwbGF5RXJyb3JQYWdlKCAkaWQsICRwYXJhbXMsICRyZXR1cm5pZCwKCQkJCSR0aGlzLT5MYW5nKCdlcnJvcl9pbnZhbGlkdW5pcXVlaWQnKSk7CiAgICAgIHJldHVybjsKICAgIH0KCiAgJHVzZXJpbmZvID0gJGRicmVzdWx0LT5GZXRjaFJvdygpOwogICR0aGlzLT5zbWFydHktPmFzc2lnbiggJHVzZXJpbmZvICk7CiAgJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCAnY29uZmlybV91bnN1YnNjcmliZV91cmwnLAoJCQkgJHRoaXMtPl9jbGVhbmxpbmsoCgkJCQkJICAgJHRoaXMtPkNyZWF0ZUZyb250ZW5kTGluayggJGlkLCAkcmV0dXJuaWQsICd1bnN1YnNjcmliZScsCgkJCQkJCQkJICAgICAgJycsIGFycmF5KCd1bmlxdWVpZCcgPT4gJHVzZXJpbmZvWyd1bmlxdWVpZCddKSwgCgkJCQkJCQkJICAgICAgJycsIHRydWUsICcnLCB0cnVlKSkpOwoKICAkbWFpbGVyID0mICR0aGlzLT5HZXRNb2R1bGVJbnN0YW5jZSgnQ01TTWFpbGVyJyk7CiAgJG1haWxlci0+cmVzZXQoKTsKICAkbWFpbGVyLT5TZXRTdWJqZWN0KCR0aGlzLT5HZXRQcmVmZXJlbmNlKCd1bnN1YnNjcmliZV9zdWJqZWN0JykpOwkJCgogICRib2R5VGV4dCA9ICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJ3Vuc3Vic2NyaWJlX2VtYWlsX2JvZHknKTsKCiAgJG1haWxlci0+U2V0Qm9keSgkYm9keVRleHQpOwogICRtYWlsZXItPkFkZEFkZHJlc3MoJHVzZXJpbmZvWydlbWFpbCddKTsKICAkbWFpbGVyLT5TZXRDaGFyU2V0KCR0aGlzLT5HZXRQcmVmZXJlbmNlKCdtZXNzYWdlX2NoYXJzZXQnKSk7CiAgJG1haWxlci0+U2V0RnJvbU5hbWUoJHRoaXMtPkdldFByZWZlcmVuY2UoJ2FkbWluX25hbWUnKSk7CiAgJG1haWxlci0+U2V0RnJvbSgkdGhpcy0+R2V0UHJlZmVyZW5jZSgnYWRtaW5fZW1haWwnKSk7CiAgJG1haWxlci0+U2VuZCgpOwoKICAvLyBkaXNwbGF5IHNvbWUgbWVhbmluZ2Z1bCB0ZXh0IG9uIHRoZSBmcm9udCBlbmQKICBlY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJ3Vuc3Vic2NyaWJlX3RleHQnKTsKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.usersettings.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.usersettings_email.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/checkdns_windows.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/format</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[Mwo=]]></data>
	</file>
	<file>
	  <filename>/functions.admintabs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: NMS - Newsletter Made Simple
# Version: 1.0-Beta1, Robert Campbell <rob@techcom.dyndns.org>
# - Based on the original module of the same name by Paul Lemke
# * This version is not ready for prime time.
#
# 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
#
#------------------------------------------------------------------------- 


/*---------------------------------------------------------
 _DisplayAdminConfirmTab($id, $params, $returnid, $message)
 ---------------------------------------------------------*/
function _DisplayAdminConfirmFormTab(& $module, $id, & $params, $returnid)
{
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'save_confirm_prefs', $returnid));
	$module->smarty->assign('prompt_post_email_confirm_text', $module->Lang('prompt_post_confirm_text'));
	$module->smarty->assign('post_email_confirm_text', $module->CreateTextArea(false, $id, $module->GetTemplate('post_email_confirm_message'), 'post_email_confirm_message'));
	$module->smarty->assign('prompt_confirm_email_body', $module->Lang('prompt_confirm_email_body'));
	$module->smarty->assign('confirm_email_body', $module->CreateTextArea(false, $id, $module->GetTemplate('confirm_email_body'), 'confirm_email_body'));
	$module->smarty->assign('prompt_confirm_subject', $module->Lang('prompt_confirm_subject'));
	$module->smarty->assign('confirm_subject', $module->CreateInputText($id, 'confirm_subject', $module->GetPreference('confirm_subject', '1'), 30));
	$module->smarty->assign('submit', $module->CreateInputSubmit($id, 'submit', $module->Lang('submit'), '', '', $module->Lang('confirm_adjustsettings')));
	$module->smarty->assign('reset', $module->CreateInputSubmit($id, 'input_reset', $module->Lang('resetdefaults'), '', '', $module->Lang('confirm_resetdefaults')));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	echo $module->ProcessTemplate('confirmform.tpl');
}


/*---------------------------------------------------------
 _DisplayAdminPrefsTab($id, $params, $returnid, $message)
 ---------------------------------------------------------*/
function _DisplayAdminPrefsTab(& $module, $id, & $params, $returnid, $message= '')
{


















	// simple way to have common nav available to all admin pages
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'save_admin_prefs', $returnid));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	$module->smarty->assign('submit', $module->CreateInputSubmit($id, 'submit', $module->Lang('submit')));
	if ($message != '')
	{
		$module->smarty->assign('message', $message);
	}
	$module->smarty->assign('prompt_users_per_page', $module->Lang('prompt_users_per_page'));
	$module->smarty->assign('users_per_page', $module->CreateInputText($id, 'users_per_page', $module->GetPreference('users_per_page', 25), 3, 3));
	$module->smarty->assign('prompt_messages_per_batch', $module->Lang('prompt_messages_per_batch'));
	$module->smarty->assign('messages_per_batch', $module->CreateInputText($id, 'messages_per_batch', $module->GetPreference('messages_per_batch', 50), 3, 3));
	$module->smarty->assign('prompt_ms_between_message_sleep', $module->Lang('prompt_ms_between_message_sleep'));
	$module->smarty->assign('ms_between_message_sleep', $module->CreateInputText($id, 'ms_between_message_sleep', $module->GetPreference('ms_between_message_sleep', 100), 3, 3));
	$module->smarty->assign('prompt_between_batch_sleep', $module->Lang('prompt_between_batch_sleep'));
	$module->smarty->assign('between_batch_sleep', $module->CreateInputText($id, 'between_batch_sleep', $module->GetPreference('between_batch_sleep', 5), 3, 3));
	$module->smarty->assign('prompt_email_user_on_admin_subscribe', $module->Lang('prompt_email_user_on_admin_subscribe'));
	$module->smarty->assign('email_user_on_admin_subscribe', $module->CreateInputCheckbox($id, 'email_user_on_admin_subscribe', 1, $module->GetPreference('email_user_on_admin_subscribe', 0)));
	$module->smarty->assign('send_admin_copies', $module->CreateInputCheckbox($id, 'send_admin_copies', 'true', $module->GetPreference('send_admin_copies', 'true')));
	$module->smarty->assign('admin_email', $module->CreateInputText($id, 'admin_email', $module->GetPreference('admin_email', '1'), 50));
	$module->smarty->assign('admin_name', $module->CreateInputText($id, 'admin_name', $module->GetPreference('admin_name', '1'), 50));
	$module->smarty->assign('message_charset', $module->CreateInputText($id, 'message_charset', $module->GetPreference('message_charset', '1'), 50));
	// Display the populated template
	echo $module->ProcessTemplate('adminprefs.tpl');
}
/*---------------------------------------------------------
 _DisplayAdminSubscribeFormTab($id, $params, $returnid, $message)
 ---------------------------------------------------------*/
function _DisplayAdminSubscribeFormTab(& $module, $id, & $params, $returnid, $message= '')
{
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'save_subscribe_prefs', $returnid));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	$module->smarty->assign('submit', $module->CreateInputSubmit($id, 'submit', $module->Lang('submit'), '', '', $module->Lang('confirm_adjustsettings')));
	$module->smarty->assign('reset', $module->CreateInputSubmit($id, 'input_reset', $module->Lang('resetdefaults'), '', '', $module->Lang('confirm_resetdefaults')));
	$module->smarty->assign('prompt_postsubscribetext', $module->Lang('prompt_postsubscribetext'));
	$module->smarty->assign('prompt_subscribesubject', $module->Lang('prompt_subscribesubject'));
	$module->smarty->assign('prompt_subscribe_email_body', $module->Lang('prompt_subscribe_email_body'));
	$module->smarty->assign('prompt_subscribe_form', $module->Lang('prompt_subscribe_form'));
	$module->smarty->assign('postsubscribetext', $module->CreateTextArea(false, $id, $module->GetPreference('subscribe_posttext', ''), 'postsubscribetext', "", "", 10, 10));
	$module->smarty->assign('subscribe_subject', $module->CreateInputText($id, 'subscribe_subject', $module->GetPreference('subscribe_subject', '1'), 30));
	$module->smarty->assign('subscribe_email_body', $module->CreateTextArea(false, $id, $module->GetTemplate('subscribe_email_body'), 'subscribe_email_body', "", "", "", "", 10, 10));
	$module->smarty->assign('subscribe_form', $module->CreateTextArea(false, $id, $module->GetTemplate('nms_subscribeform'), 'subscribe_form'));
	echo $module->ProcessTemplate('subscribeform.tpl');
}
/*---------------------------------------------------------
 _DisplayAdminUnsubscribeFormTab($id, $params, $returnid, $message)
 ---------------------------------------------------------*/
function _DisplayAdminUnsubscribeFormTab(& $module, $id, & $params, $returnid, $message= '')
{
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'save_unsubscribe_prefs', $returnid));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	$module->smarty->assign('submit', $module->CreateInputSubmit($id, 'submit', $module->Lang('submit'), '', '', $module->Lang('confirm_adjustsettings')));
	$module->smarty->assign('reset', $module->CreateInputSubmit($id, 'input_reset', $module->Lang('resetdefaults'), '', '', $module->Lang('confirm_resetdefaults')));
	$module->smarty->assign('prompt_unsubscribe_prompt', $module->Lang('prompt_unsubscribe_prompt'));
	$module->smarty->assign('prompt_unsubscribe_text', $module->Lang('prompt_unsubscribe_text'));
	$module->smarty->assign('prompt_unsubscribe_subject', $module->Lang('prompt_unsubscribe_subject'));
	$module->smarty->assign('prompt_unsubscribe_email_body', $module->Lang('prompt_unsubscribe_email_body'));
	$module->smarty->assign('prompt_unsubscribe_form', $module->Lang('prompt_unsubscribe_form'));
	$module->smarty->assign('prompt_unsubscribe_text', $module->Lang('prompt_unsubscribe_text'));
	$module->smarty->assign('prompt_post_unsubscribe_text', $module->Lang('prompt_post_unsubscribe_text'));
	$module->smarty->assign('unsubscribe_prompt', $module->CreateInputText($id, 'unsubscribe_prompt', $module->GetPreference('nms_unsubscribe_prompt'), 30));
	$module->smarty->assign('unsubscribe_subject', $module->CreateInputText($id, 'unsubscribe_subject', $module->GetPreference('unsubscribe_subject'), 30));
	$module->smarty->assign('unsubscribe_email_body', $module->CreateTextArea(false, $id, $module->GetTemplate('unsubscribe_email_body'), 'unsubscribe_email_body'));
	$module->smarty->assign('unsubscribe_form', $module->CreateTextArea(false, $id, $module->GetTemplate('nms_unsubscribeform'), 'unsubscribe_form'));
	$module->smarty->assign('unsubscribe_text', $module->CreateTextArea(false, $id, $module->GetTemplate('unsubscribe_text'), 'unsubscribe_text'));
	$module->smarty->assign('post_unsubscribe_text', $module->CreateTextArea(false, $id, $module->GetTemplate('post_unsubscribe_text'), 'post_unsubscribe_text'));
	echo $module->ProcessTemplate('unsubscribeform.tpl');
}
/*---------------------------------------------------------
 _DisplayAdminUserSettingsTab($id, $params, $returnid, $message)
 ---------------------------------------------------------*/
function _DisplayAdminUserSettingsTab(& $module, $id, & $params, $returnid)
{
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'save_usersettings_prefs', $returnid));
	$module->smarty->assign('prompt_usersettings_form', $module->Lang('prompt_usersettings_form'));
	$module->smarty->assign('usersettings_form', $module->CreateTextArea(false, $id, $module->GetTemplate('usersettings_form'), 'usersettings_form'));
	global $gCms;
	$contentops= & $gCms->GetContentOperations();
	$module->smarty->assign('prompt_usersettings_page', $module->Lang('prompt_usersettings_page'));
	$module->smarty->assign('info_usersettings_page', $module->Lang('info_usersettings_page'));
	$module->smarty->assign('usersettings_page', create_page_dropdown($module, $id, 'usersettings_page', $module->GetPreference('usersettings_page')));
	$module->smarty->assign('prompt_usersettings_form2', $module->Lang('prompt_usersettings_form2'));
	$module->smarty->assign('usersettings_form2', $module->CreateTextArea(false, $id, $module->GetTemplate('usersettings_form2'), 'usersettings_form2'));
	$module->smarty->assign('prompt_usersettings_text', $module->Lang('prompt_usersettings_text'));
	$module->smarty->assign('usersettings_text', $module->CreateTextArea(false, $id, $module->GetTemplate('usersettings_text'), 'usersettings_text'));
	$module->smarty->assign('prompt_usersettings_text2', $module->Lang('prompt_usersettings_text2'));
	$module->smarty->assign('usersettings_text2', $module->CreateTextArea(false, $id, $module->GetTemplate('usersettings_text2'), 'usersettings_text2'));
	$module->smarty->assign('prompt_usersettings_subject', $module->Lang('prompt_usersettings_subject'));
	$module->smarty->assign('usersettings_subject', $module->CreateInputText($id, 'usersettings_subject', $module->GetPreference('usersettings_subject', ''), 30));
	$module->smarty->assign('prompt_usersettings_email_body', $module->Lang('prompt_usersettings_email_body'));
	$module->smarty->assign('usersettings_email_body', $module->CreateTextArea(false, $id, $module->GetTemplate('usersettings_email_body'), 'usersettings_email_body'));
	$module->smarty->assign('submit', $module->CreateInputSubmit($id, 'submit', $module->Lang('submit'), '', '', $module->Lang('confirm_adjustsettings')));
	$module->smarty->assign('reset', $module->CreateInputSubmit($id, 'input_reset', $module->Lang('resetdefaults'), '', '', $module->Lang('confirm_resetdefaults')));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	echo $module->ProcessTemplate('usersettingsform.tpl');
}


function _DisplayAdminJobsTab(& $module, $id, & $params, $returnid, $message= '')
{
	$db= & $module->GetDb();
	global $config;
	global $themeObject;
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "list";
	$dbresult= $db->Execute($query);
	if (!$dbresult || $dbresult->RecordCount() == 0)
	{
		$module->smarty->assign('message', $module->Lang('error_nolists'));
		$module->smarty->assign('error', 1);
		$module->smarty->assign('noform', 1);
		echo $module->ProcessTemplate('users.tpl');
		return;
	}
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "messages";
	$dbresult= $db->Execute($query);
	if (!$dbresult || $dbresult->RecordCount() == 0)
	{
		$module->smarty->assign('message', $module->Lang('error_nomessages'));
		$module->smarty->assign('error', 1);
		$module->smarty->assign('noform', 1);
		echo $module->ProcessTemplate('users.tpl');
		return;
	}
	if (isset ($params['error']))
	{
		$module->smarty->assign('error', $params['error']);
	}
	if (isset ($params['message']))
	{
		$module->smarty->assign('message', $params['message']);
	}
	$temptablename= cms_db_prefix() . $module->table_prefix . "temp_jobstatus";
	$q= "SELECT * FROM " . $temptablename . " LIMIT 1";
	$badjobid= '';
	$dbresult= $db->Execute($q);
	if ($dbresult && $dbresult->RecordCount())
	{
		// temporary table exists, we have an error condition
		$badrow= $dbresult->FetchRow();
		$badjobid= $badrow['jobid'];
	}
	if ($badjobid != '')
	{
		$q= "UPDATE " . cms_db_prefix() . $module->table_prefix . "jobs SET status = ? 
		              WHERE jobid = ?";
		$db->Execute($q, array (
			-1,
			$badjobid
		));
	}

	//
	// 1. Display the current job queue
	// (all entries in message_list grouped by job id I guess
	// and allow him to edit jobs
	//
	$q= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "jobs ORDER BY created,started,status";
	$dbresult= $db->Execute($q);
	$rowarray= array ();
	$rowclass= 'row1';
	while ($row= $dbresult->FetchRow())
	{
		$emails= "N/A";
		if ($row['status'] != 3)
		{
			$q2= "select DISTINCT jobid,email,username,messageid from " .			cms_db_prefix() . $module->table_prefix . "listuser A left join " .			cms_db_prefix() . $module->table_prefix . "job_parts B on A.listid = B.listid left join " .			cms_db_prefix() . $module->table_prefix . "users C on A.userid = C.userid 
				      WHERE C.disabled = 0 AND jobid = ? order by messageid";
			$dbresult2= $db->Execute($q2, array (
				$row['jobid']
			));
			if ($dbresult2 && $dbresult2->RecordCount())
			{
				$emails= $dbresult2->RecordCount();
			}
		}
		$onerow= new StdClass();
		$onerow->rowclass= $rowclass;
		$onerow->id= $row['jobid'];
		$onerow->name= $row['title'];
		$onerow->emails= $emails;
		$onerow->created= $row['created'];
		$onerow->started= $row['started'];
		$onerow->finished= $row['finished'];
		$onerow->status= $module->_statusToText($row['status']);
		// we can only edit the job if the status is 0
		if ($row['status'] == 0)
		{
			$onerow->editlink= $module->CreateLink($id, 'create_edit_job', $returnid, $themeObject->DisplayImage('icons/system/edit.gif', $module->Lang('edit'), '', '', 'systemicon'), $row);
		}

		# we can only delete a job if the status is not in progress
		if ($row['status'] != 1)
		{
			$onerow->deletelink= $module->CreateLink($id, 'delete_job', $returnid, $themeObject->DisplayImage('icons/system/delete.gif', $module->Lang('delete'), '', '', 'systemicon'), $row, $module->Lang('confirmdeletejob'));
		}
		switch ($row['status'])
		{
			case -1 :
				$onerow->actionlink= $module->CreateLink($id, 'reset_job', $returnid, $module->Lang('reset'), array (
					'jobid' => $row['jobid']
				));
				break;
			case 0 :
				$onerow->actionlink= $module->CreateLink($id, 'pause_job', $returnid, $module->Lang('suspend'), array (
					'jobid' => $row['jobid']
				));
				break;
			case 2 :
				$onerow->actionlink= $module->CreateLink($id, 'resume_job', $returnid, $module->Lang('resume'), array (
					'jobid' => $row['jobid']
				));
				break;
		}
		($rowclass == "row1" ? $rowclass= "row2" : $rowclass= "row1");
		$rowarray[]= $onerow;
	}
	$module->smarty->assign('idtext', $module->Lang('id'));
	$module->smarty->assign('emailstext', $module->Lang('nummessages'));
	$module->smarty->assign('nametext', $module->Lang('name'));
	$module->smarty->assign('createdtext', $module->Lang('created'));
	$module->smarty->assign('startedtext', $module->Lang('started'));
	$module->smarty->assign('finishedtext', $module->Lang('finished'));
	$module->smarty->assign('actiontext', $module->Lang('action'));
	$module->smarty->assign('statustext', $module->Lang('status'));
	$module->smarty->assign('itemsfound', $module->Lang('jobsfoundtext'));
	$module->smarty->assign('itemcount', count($rowarray));
	$module->smarty->assign('items', $rowarray);
	$module->smarty->assign('createlink', $module->CreateLink($id, 'create_edit_job', $returnid, $module->Lang('title_mod_compose_job'), array ()));

	// check if the temporary table exists
	// if it does, allow it to be deleted
	{
		// mysql only?
		$q = "SHOW TABLES LIKE ?";
		$dbresult = $db->Execute( $q, array(cms_db_prefix().$module->table_prefix."temp_jobstatus") );
		if( $dbresult && $dbresult->RecordCount() > 0 ) {
			$module->smarty->assign('cleantemplink', $module->CreateLink($id,'cleantemptable', $returnid, $module->Lang('cleantemptable')));
		}
	}

	if (count($rowarray))
	{
		// popup the processing in a new window
		$module->smarty->assign('processlink', $module->CreateLink($id, 'process_queue', $returnid, $module->Lang('processjobs'), array (
			'disable_buffer' => 1,
			'disable_theme' => 1
		), $module->Lang('confirmsend'), false, false, " target=\"_blank\""));
		$module->smarty->assign('deletecompletedlink', $module->CreateLink($id, 'delete_completed', $returnid, $module->Lang('deletecompleted')));
	}
	echo $module->ProcessTemplate('jobs.tpl');
}


function _DisplayAdminMessagesTab(& $module, $id, & $params, $returnid, $message= '')
{
	$db= & $module->cms->db;
	global $themeObject;
	$result= array ();
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "list";
	$dbresult= $db->Execute($query);
	if (!$dbresult || $dbresult->RecordCount() == 0)
	{
		$module->smarty->assign('message', $module->Lang('error_nolists'));
		$module->smarty->assign('error', 1);
		$module->smarty->assign('noform', 1);
		echo $module->ProcessTemplate('messages.tpl');
		return;
	}
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "messages ORDER BY entered desc";
	$dbresult= $db->Execute($query);
	$rowclass= 'row1';
	$rowarray= array ();
	$currow= "row1";
	if (strlen($message) > 0)
	{
		$module->smarty->assign('message', $message);
	}
	if ($dbresult && $dbresult->RecordCount() > 0)
	{
		while ($row= $dbresult->FetchRow())
		{
			$onerow= new StdClass();
			$onerow->id= $row['messageid'];
			$onerow->from= $row['fromwho'] . "<" . $row['replyto'] . ">";
			$onerow->subject= $row['subject'];
			$onerow->entered= $row['entered'];
			// 	if ($row['status'] == 5){
			// 	  $onerow->status = $module->Lang('sent');
			// 	}else{
			// 	  $onerow->status = $module->Lang('inqueue');
			// 	}
			$record= array ();
			$record['messageid']= $row['messageid'];
			$onerow->editlink= $module->CreateLink($id, 'edit_message', $returnid, $themeObject->DisplayImage('icons/system/edit.gif', $module->Lang('edit'), '', '', 'systemicon'), $record);
			$onerow->deletelink= $module->CreateLink($id, 'delete_message', $returnid, $themeObject->DisplayImage('icons/system/delete.gif', $module->Lang('delete'), '', '', 'systemicon'), $record, $module->Lang('confirmdelete'));
			$onerow->rowclass= $rowclass;
			($rowclass == "row1" ? $rowclass= "row2" : $rowclass= "row1");
			$rowarray[]= $onerow;
		}
	}
	$module->smarty->assign('idtext', $module->Lang('id'));
	$module->smarty->assign('fromtext', $module->Lang('from'));
	$module->smarty->assign('subjecttext', $module->Lang('subject'));
	$module->smarty->assign('enteredtext', $module->Lang('entered'));
	//     $module->smarty->assign('statustext',$module->Lang('status'));
	$module->smarty->assign('itemsfound', $module->Lang('messagesfoundtext'));
	$module->smarty->assign('itemcount', count($rowarray));
	$module->smarty->assign('items', $rowarray);
	$link= $module->CreateLink($id, 'compose_message', $returnid, $themeObject->DisplayImage('icons/system/newobject.gif', $module->Lang('title_mod_compose_message'), '', '', 'systemicon'), array ()) . ' ';
	$link .= $module->CreateLink($id, 'compose_message', $returnid, $module->Lang('title_mod_compose_message'), array ());
	$module->smarty->assign('createlink', $link);
	echo $module->ProcessTemplate('messages.tpl');
}


function _DisplayAdminListsTab(& $module, $id, & $params, $returnid, $message= '')
{
	$db= & $module->cms->db;
	global $themeObject;
	$module->smarty->assign('idtext', $module->Lang('id'));
	$module->smarty->assign('desctext', $module->Lang('description'));
	$module->smarty->assign('nametext', $module->Lang('name'));
	$module->smarty->assign('publictext', $module->Lang('public'));
	$result= array ();
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "list ORDER BY listid";
	$dbresult= $db->Execute($query);
	$rowclass= 'row1';
	$rowarray= array ();
	if ($dbresult && $dbresult->RecordCount() > 0)
	{
		while ($row= $dbresult->FetchRow())
		{
			$onerow= new StdClass();
			$onerow->rowclass= $rowclass;
			$onerow->id= $row['listid'];
			$onerow->description= $row['description'];
			$onerow->public= ($row['public'] == 1) ? $module->Lang('yes') : '';
			$onerow->name= $module->CreateLink($id, 'edit_list', $returnid, $row['name'], $row);
			$onerow->editlink= $module->CreateLink($id, 'edit_list', $returnid, $themeObject->DisplayImage('icons/system/edit.gif', $module->Lang('edit'), '', '', 'systemicon'), $row);
			$onerow->deletelink= $module->CreateLink($id, 'delete_list', $returnid, $themeObject->DisplayImage('icons/system/delete.gif', $module->Lang('delete'), '', '', 'systemicon'), $row, $module->Lang('confirmdeletelist'));
			($rowclass == "row1" ? $rowclass= "row2" : $rowclass= "row1");
			$rowarray[]= $onerow;
		}
	}
	$module->smarty->assign('itemsfound', $module->Lang('listsfoundtext'));
	$module->smarty->assign('itemcount', count($rowarray));
	$module->smarty->assign('items', $rowarray);
	$module->smarty->assign('createlink', $module->CreateLink($id, 'create_new_list', $returnid, $module->Lang('title_mod_createnew'), array ()));
	echo $module->ProcessTemplate('lists.tpl');
}
function _DisplayAdminUsersTab(& $module, $id, & $params, $returnid, $message= '')
{
	$db= & $module->cms->db;
	global $themeObject;
	$result= array ();
	$page= isset ($params['page']) ? $params['page'] : 1;
	$num_per_batch= $module->GetPreference('users_per_page', 25);
	$start_record= ($page -1) * $num_per_batch;
	$query= "SELECT userid FROM " . cms_db_prefix() . $module->table_prefix . "users";
	$dbresult= $db->Execute($query);
	$total_recs= $dbresult->RecordCount();
	$query= "SELECT * FROM " . cms_db_prefix() . $module->table_prefix . "list";
	$dbresult= $db->Execute($query);
	if (($dbresult == false) || ($dbresult->RecordCount() == 0))
	{
		$module->smarty->assign('message', $module->Lang('error_nolists'));
		$module->smarty->assign('error', 1);
		$module->smarty->assign('noform', 1);
		echo $module->ProcessTemplate('users.tpl');
		return;
	}
	$lists= array ();
	while ($row= $dbresult->FetchRow())
	{
		$lists[$row['name'] . ' - ' . $row['description']]= $row['listid'];
	}
	if (isset ($params['filter'])) // the button
	{
		if (isset ($params['filter_user_regex']))
		{
			$module->SetPreference('nms_user_filter', $params['filter_user_regex']);
		} else
		{
			$module->RemovePreference('nms_user_filter');
		}
		if (isset ($params['filter_lists']))
		{
			$module->SetPreference('nms_list_filter', implode(",", $params['filter_lists']));
		} else
		{
			$module->RemovePreference('nms_list_filter');
		}
	}
	$nms_user_filter= $module->GetPreference('nms_user_filter', '');
	$nms_list_filter= $module->GetPreference('nms_list_filter', '');
	$module->smarty->assign('startform', $module->CreateFormStart($id, 'defaultadmin', '', 'post', '', false, '', array (
		'active_tab' => 'users'
	)));
	$module->smarty->assign('endform', $module->CreateFormEnd());
	$module->smarty->assign('prompt_userfilter', $module->Lang('prompt_userfilter'));
	$module->smarty->assign('userfilter', $module->CreateInputText($id, 'filter_user_regex', $nms_user_filter, 30, 30));
	$module->smarty->assign('prompt_listfilter', $module->Lang('prompt_listfilter'));
	$module->smarty->assign('info_listfilter', $module->Lang('info_listfilter'));
	$module->smarty->assign('listfilter', $module->CreateInputSelectList($id, 'filter_lists[]', $lists, explode(",", $nms_list_filter), // selected items
	min(10, count($lists))));
	$module->smarty->assign('filter', $module->CreateInputSubmit($id, 'filter', $module->Lang('applyfilter')));
	$query= "SELECT A.userid,uniqueid,email,username,disabled,confirmed,count(B.listid) as lists FROM " . cms_db_prefix() . $module->table_prefix . "users A LEFT OUTER JOIN " .	cms_db_prefix() . $module->table_prefix . "listuser B ON A.userid = B.userid";
	$where= false;
	if ($nms_user_filter != '')
	{
		if ($where == false)
		{
			$query .= ' WHERE';
			$where= true;
		} else
		{
			$query .= ' AND';
		}
		$query .= " A.email REGEXP \"$nms_user_filter\"";
	}
	if ($nms_list_filter != '')
	{
		if ($where == false)
		{
			$query .= ' WHERE';
			$where= true;
		} else
		{
			$query .= ' AND';
		}
		$query .= " B.listid IN ($nms_list_filter)";
	}
	$query .= " GROUP BY A.userid LIMIT $start_record, $num_per_batch";
	$dbresult= $db->Execute($query);
	$currow= "row1";
	if (strlen($message) > 0)
	{
		$module->smarty->assign('message', $message);
	}
	if ($total_recs > $num_per_batch)
	{
		$numpages= intval($total_recs / $num_per_batch);
		if ($numpages * $num_per_batch < $total_recs)
		{
			$numpages++;
		}
		if ($page > 1)
		{
			$module->smarty->assign('prevpage', $module->CreateLink($id, 'defaultadmin', $returnid, '<', array (
				'page' => $page -1,
				'active_tab' => 'users'
			)));
			$module->smarty->assign('firstpage', $module->CreateLink($id, 'defaultadmin', $returnid, '<<', array (
				'page' => 1,
				'active_tab' => 'users'
			)));
		} else
		{
			$module->smarty->assign('prevpage', '<');
			$module->smarty->assign('firstpage', '<<');
		}
		if ($page < $numpages)
		{
			$module->smarty->assign('nextpage', $module->CreateLink($id, 'defaultadmin', $returnid, '>', array (
				'page' => $page +1,
				'active_tab' => 'users'
			)));
			$module->smarty->assign('lastpage', $module->CreateLink($id, 'defaultadmin', $returnid, '>>', array (
				'page' => $numpages,
				'active_tab' => 'users'
			)));
		} else
		{
			$module->smarty->assign('nextpage', '>');
			$module->smarty->assign('lastpage', '>>');
		}
		$module->smarty->assign('pagetext', $module->Lang('page'));
		$module->smarty->assign('pagecount', $numpages);
		$module->smarty->assign('curpage', $page);
	}
	$module->smarty->assign('usertext', $module->Lang('userid'));
	$module->smarty->assign('nametext', $module->Lang('name'));
	$module->smarty->assign('emailtext', $module->Lang('emailaddress'));
	$module->smarty->assign('confirmedtext', $module->Lang('confirmed'));
	$module->smarty->assign('disabledtext', $module->Lang('disabled'));
	$module->smarty->assign('liststext', $module->Lang('lists'));
	$rowclass= 'row1';
	$rowarray= array ();
	if ($dbresult && $dbresult->RecordCount() > 0)
	{
		while ($row= $dbresult->FetchRow())
		{
			$onerow= new StdClass();
			$onerow->user= $row['userid'];
			$onerow->disabled= ($row['disabled'] == 1) ? $module->Lang('yes') : $module->Lang('no');
			$onerow->confirmed= ($row['confirmed'] == 1) ? $module->Lang('yes') : $module->Lang('no');
			$onerow->email= $module->CreateLink($id, 'edit_user', $returnid, $row['email'], $row);
			$onerow->name= $row['username'];
			$onerow->lists= $row['lists'];
			$onerow->editlink= $module->CreateLink($id, 'edit_user', $returnid, $themeObject->DisplayImage('icons/system/edit.gif', $module->Lang('edit'), '', '', 'systemicon'), $row);
			$onerow->deletelink= $module->CreateLink($id, 'delete_email', $returnid, $themeObject->DisplayImage('icons/system/delete.gif', $module->Lang('delete'), '', '', 'systemicon'), $row, $module->Lang('delete_user_confirm'));
			$onerow->rowclass= $rowclass;
			($rowclass == "row1" ? $rowclass= "row2" : $rowclass= "row1");
			$rowarray[]= $onerow;
		}
	}
	$module->smarty->assign('oftext', $module->Lang('of'));
	$module->smarty->assign('totalitems', $total_recs);
	$module->smarty->assign('itemsfound', $module->Lang('usersfoundtext'));
	$module->smarty->assign('itemcount', count($rowarray));
	$module->smarty->assign('items', $rowarray);
	$link= $module->CreateLink($id, 'create_new_user', $returnid, $themeObject->DisplayImage('icons/system/newobject.gif', $module->Lang('title_user_createnew'), '', '', 'systemicon'), array ()) . ' ';
	$link .= $module->CreateLink($id, 'create_new_user', $returnid, $module->Lang('title_user_createnew'), array ());
	$module->smarty->assign('createlink', $link);
	$module->smarty->assign('importlink', $module->CreateLink($id, 'import_users', $returnid, $module->Lang('title_users_import'), array ()));
	$module->smarty->assign('exportlink', $module->CreateLink($id, 'export_users', $returnid, $module->Lang('title_users_export'), array ()));
	
	$feu =& $module->GetModuleInstance('FrontEndUsers');
	if( $feu )
		{
			// todo, add an icon here
			$module->smarty->assign('feuimportlink', 
									$module->CreateLink($id, 
														'feu_import_users', 
														$returnid, 
														$module->Lang('import_feu_title')));
		}
	echo $module->ProcessTemplate('users.tpl');
}
?>]]></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['cleantemptable'] = 'Clean Temporary Table';
$lang['error_problemwithmessage'] = 'A problem occurred trying to store this message';
$lang['prompt_usersettings_page'] = 'Return page for Usersettings form';
$lang['info_usersettings_page'] = 'Page to return to when an email link is clicked on to edit user preferences.<br/>The (*) Indicates the default page.';
$lang['jobname'] = 'Job created at';
$lang['msg_jobprocessing'] = 'Batch Processing Window';
$lang['prompt_page'] = 'Return Page';
$lang['error_insufficientparams'] = 'Insufficient Parameters';
$lang['prompt_from'] = 'From';
$lang['prompt_replyto'] = 'Reply To';
$lang['prompt_subject'] = 'Subject';
$lang['prompt_template'] = 'Template';
$lang['prompt_selectstatus'] = 'Select Status';
$lang['prompt_message'] = 'Message';
$lang['prompt_userfilter'] = 'Email filter (regexp)';
$lang['prompt_listfilter'] = 'Filter on list Membership';
$lang['info_listfilter'] = '
<strong>Note:</strong> Hold the CTRL key down and click on items to select and deselect them.
';
$lang['message_help'] = 'When typing a message, the following <em>smarty</em> variables are available:<br/>
<em>{$username}</em> - The users name<br/>
<em>{$email}</em> - The users email address<br/>
<em>{$unsubscribe}</em> - A URL that can be used to display a page for unsubscribing<br/>
<em>{$preferences}</em> - A URL that can be used to display a user preferences page<br/>
<em>{$confirmurl}</em> - A URL that can be used to confirm subscriptions<br/>
<strong>Note:</strong>&nbsp; When composing an HTML message and <em>not</em> using a page template, you will need to supply the appropriate HTML tags (html,head,body,etc).<br/>
<strong>Note:</strong>&nbsp; When using a page template as a message template, you need to use {$message_text} in place of {content} in your template.
';
$lang['applyfilter'] = 'Filter';
$lang['info_event_OnNewUser'] = 'Generated when a new user subscribes to one or more mailing lists';
$lang['info_event_OnEditUser'] = 'Generated when a user is modified either in the admin or via the front end';
$lang['info_event_OnDeleteUser'] = 'Generated when a user is deleted';
$lang['info_event_OnNewList'] = 'Generated when a new mailing list is created';
$lang['info_event_OnNewList'] = 'Generated when a mailing list is modified';
$lang['info_event_OnDeleteList'] = 'Generated when a mailing list is deleted';
$lang['info_event_OnCreateMessage'] = 'Generated when a message is created';
$lang['info_event_OnEditMessage'] = 'Generated when a message is modified';
$lang['info_event_OnDeleteMessage'] = 'Generated when a message is deleted';
$lang['info_event_OnCreateJob'] = 'Generated when a job is created';
$lang['info_event_OnDeleteJob'] = 'Generated when a job is deleted';
$lang['info_event_OnStartJob'] = 'Generated when the processing of a job begins';
$lang['info_event_OnFinishJob'] = 'Generated when the processing of a job finishes';
$lang['help_OnNewUser'] = '
<p>An event generated when a new user subscribes to one or more mailing lists</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
</ul>
';
$lang['help_OnEditUser'] = '
<p>An event generated when a user is modified either in the admin or via the front end</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnDeleteUser'] = '
<p>An event generated when a user is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnNewList'] = '
<p>An event generated when a new mailing list is created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '
<p>An event generated when a mailing list is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '
<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '
<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '
<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '
<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '
<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '
<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '
<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '
<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'You must enter a valid reply to email address';
$lang['error_needfrom'] = 'You must enter a valid name for the originator of the message';
$lang['error_needsubject'] = 'You must enter a valid email subject';
$lang['error_needmessagetext'] = 'You must enter something for a message body';
$lang['error_formerror'] = 'Form error';
$lang['error_dberror'] = 'Database error';
$lang['invalidparam'] = 'Invalid param in the NMS module tag';
$lang['prompt_users_per_page'] = 'Number of users to display on each page of the user list';
$lang['disabled'] = 'Disabled';
$lang['confirmed'] = 'Confirmed';
$lang['prompt_usersettings_text2'] = 'Text displayed after the user settings form is submitted';
$lang['prompt_usersettings_form2'] = 'Form displayed to users wishing to change settings';
$lang['prompt_usersettings_text'] = 'Text displayed after the user settings message is sent';
$lang['prompt_usersettings_email_body'] = 'Body of the user settings email';
$lang['prompt_usersettings_subject'] = 'Subject of user settings email';
$lang['prompt_usersettings_form'] = 'Form asking users who whish to change settings, their email address';
$lang['prompt_post_unsubscribe_text'] = 'Text displayed after the unsubscribe process is complete';
$lang['user_settings'] = 'User Settings';
$lang['prompt_unsubscribe_prompt'] = 'Prompt asking the user for his email address to unsubscribe';
$lang['prompt_unsubscribe_text'] = 'Text displayed after unsubscribe form is completed';
$lang['prompt_unsubscribe_subject'] = 'Subject of the email sent to unsubscribe';
$lang['prompt_unsubscribe_email_body'] = 'Body of the email sent to unsubscribe';
$lang['prompt_unsubscribe_form'] = 'Template for the unsubscribe form';
$lang['error_accountdisabled'] = 'We are sorry, but your account has been disabled and this action is not possible at this time';
$lang['error_insufficientparams'] = 'One or more required parameters are missing from the request.  This action cannot proceed';
$lang['prompt_post_confirm_text'] = 'Message displayed after email confirmation';
$lang['prompt_confirm_email_body'] = 'Confirmation email body';
$lang['prompt_confirm_subject'] = 'Confirmation email subject';
$lang['confirm_subscribe'] = 'Confirm Subscribe';
$lang['confirm_unsubscribe'] = 'Confirm Unsubscribe';
$lang['nolists'] = 'No lists found to subscribe to';
$lang['public'] = 'Public';
$lang['yes'] = 'Yes';
$lang['no'] = 'No';
$lang['prompt_postsubscribetext'] = 'Message displayed after subscription';
$lang['subscription_confirmed'] = 'Subscription confirmed';
$lang['reset'] = 'Reset';
$lang['suspend'] = 'Suspend';
$lang['resume'] = 'Resume';
$lang['action'] = 'Action';
$lang['processing_records'] = 'Processing records %s to %s';
$lang['initializing_job'] = 'Initializing Job';
$lang['processing_job'] = 'Processing Job';
$lang['deletecompleted'] = 'Delete Completed Jobs';
$lang['error_importerrorcount'] = 'Error count';
$lang['lines'] = 'Lines';
$lang['users_added'] = 'Users Added';
$lang['memberships'] = 'Memberships';
$lang['subscribe'] = 'Subscribe';
$lang['resetdefaults'] = 'Reset to Defaults';
$lang['confirm_adjustsettings'] = 'Are you sure you want to adjust these settings?';
$lang['confirm_resetdefaults'] = 'Are you sure you want to reset this form to its system default value?';
$lang['prompt_subscribetext'] = 'Subscribe Text';
$lang['prompt_subscribesubject'] = 'Subscribe Subject';
$lang['prompt_subscribe_email_body'] = 'Subscribe Email Body';
$lang['prompt_subscribe_form'] = 'Template for the Subscribe Form';
$lang['subscribe_form'] = 'Subscribe';
$lang['unsubscribe_form'] = 'Unsubscribe';
$lang['error_insertinglist'] = 'Problem creating the new list';
$lang['error_emailexists'] = 'That email address already exists in the user list';
$lang['error_invalidusername'] = 'Invalid username';
$lang['error_invalidid'] = 'Invalid unique id';
$lang['username'] = 'Username';
$lang['name'] = 'Name';
$lang['prompt_public'] = 'This is a public mailing list';
$lang['error_usernotfound'] = 'Could not find user with specified uniqueid';
$lang['prompt_ms_between_message_sleep'] = 'Delay (in milliseconds) between sending each message';
$lang['prompt_between_batch_sleep'] = 'Delay (in seconds) between each batch';
$lang['prompt_messages_per_batch'] = 'The maximum number of messages to send in a batch';
$lang['okclosewindow'] = 'You can now close this window';
$lang['queuefinished'] = 'Processing of output queue finished';
$lang['totaltime'] = 'Total processing time:';
$lang['seconds'] = 'Seconds';
$lang['totalmails'] = 'Total Emails Sent (including to admin):';
$lang['page'] = 'Page';
$lang['of'] = 'of';
$lang['info_csvformat'] = 'The import file must be in CSV (comma separated value) format, one entry per line.<br />
The columns are:<br/><br/>
uniqueid, email address, username, list name, active<br /> <br />
Email addresses may be repeated on subsequent lines (particularly for different lists).';
$lang['prompt_lines'] = 'Lines Imported';
$lang['prompt_usersadded'] = 'Users Added';
$lang['prompt_membershipsadded'] = 'Memberships added';
$lang['prompt_errorcount'] = 'Number of Errors';
$lang['importerror_cantgetuserid'] = 'Error at line %s, could not get userid %s';
$lang['importerror_cantcreateuser'] = 'Error at line %s, could not create user %s';
$lang['importerror_nosuchlist'] = 'Error at line %s, no such list %s';
$lang['importerror_nofields'] = 'Error at line %s, not enough fields';
$lang['import_users'] = 'Import Users from CSV';
$lang['error_emptyfile'] = 'ERROR- An empty file was uploaded';
$lang['error_nofilesuploaded'] = "ERROR- no files were uploaded";
$lang['filename'] = 'Import Filename';
$lang['title_users_import'] = 'Import Users from CSV';
$lang['title_users_export'] = 'Export Users from Database';
$lang['nummessages'] = '# of Messages';
$lang['created'] = 'Created';
$lang['started'] = 'Started';
$lang['finished'] = 'Finished';
$lang['processjobs'] = 'Process Jobs';
$lang['status_error'] = 'ERROR';
$lang['status_unstarted'] = 'Not started';
$lang['status_inprogress'] = 'In Progress';
$lang['status_paused'] = 'Paused';
$lang['status_complete'] = 'Complete';
$lang['status_unknown'] = 'Unknown';
$lang['error_jobnameexists'] = 'ERROR- A job with that name already exists';
$lang['createjob'] = 'Create Job';
$lang['prompt_email_user_on_admin_subscribe'] = 'Send users an email when the administrator manually adds membership to a list';
$lang['error_nomessagesselected'] = 'No messages selected';
$lang['error_nolistsselected'] = 'No lists selected';
$lang['createjobmsg'] = 'Select one message, and one or more lists to send the message to';
$lang['error_nojobname'] = 'ERROR- No job name specified';
$lang['error_nolists'] = 'ERROR- No lists!';
$lang['error_nomessages'] = 'ERROR- No messages!';
$lang['jobs'] = 'Jobs';
$lang['status'] = 'Status';
$lang['jobsfoundtext'] = 'Jobs found';
$lang['messagesfoundtext'] = 'Messages found';
$lang['entered'] = 'Entered';
$lang['subject'] = 'Subject';
$lang['from'] = 'From';
$lang['delete_user_confirm'] = 'Are you sure you want to delete this user';
$lang['info_singlelist'] = 'This user will be added to the sole mailing list';
$lang['error_selectonelist'] = 'ERROR- You must select atleast one list';
$lang['error_invaliduniqueid'] = 'ERROR- invalid unique id';
$lang['error_invalidemail'] = 'ERROR- Invalid email address';
$lang['error_couldnotfindjobpart'] = 'ERROR- Could not find a requested job part in the database.  This may indicate that another user (you?) is editing/deleting jobs whilst a job is processing.';
$lang['error_couldnotfindmessage'] = 'ERROR- Could not find a requested message.  This may indicate that another user (you?) is editing/deleting messages whilst a job is processing.';
$lang['error_couldnotfindtemplate'] = 'ERROR- Could not find a requested page template.  This may indicate that the template was deleted since the mail message was created.';
$lang['error_temporarytableexists'] = 'ERROR- The temporary database table, used for job processing already exists.  This probably indicates that an error occurred when trying to process a job previously.';
$lang['error_buildingtemptable'] = 'ERROR- A problem occurred when filling the temporary table';
$lang['error_otherprocessingerror'] = 'ERROR: An error occurred during processing';
$lang['userid'] = 'User ID';
$lang['emailaddress'] = 'Email Address';
$lang['usersfoundtext'] = 'Users found';
$lang['title_user_createnew'] = 'Add User';
$lang['error_invalidlistname'] = 'ERROR- Invalid list name';
$lang['editlist_text'] = 'Edit List';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Lists found';
$lang['users'] = 'Users';
$lang['preferences'] = 'Preferences';
$lang['messages'] = 'Messages';
$lang['queue'] = 'Queue';
$lang['submit'] = 'Submit';
$lang['cancel'] = 'Cancel';
$lang['name'] = 'Name';
$lang['description'] = 'Description';
$lang['createnewlist_text'] = 'Create List';
$lang['lists'] = 'Lists';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Thank you for installing NMS. Be sure to set "Use NMS" permissions to use this module!';
$lang['postuninstall'] = 'Newsletter Made Simple Uninstalled.';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['prefsupdated'] = 'Newsletter Made Simple Module preferences updated.';
$lang['newslettercreated'] = 'A new newsletter has been created.';
$lang['no_email_error'] = 'You must fill in an email address.';
$lang['subscribe_thankyou'] = 'Thank you for subscribing. A confirmation e-mail has been sent to your inbox.';
$lang['enter_valid_email'] = 'You must enter a valid e-mail address and select at least one list.';
$lang['newslettercreatederror'] = 'You must enter a name and description.';
$lang['accessdenied'] = 'Access Denied. Please check your permissions.';
$lang['error'] = 'Error!';
$lang['sent'] = 'Sent';
$lang['inqueue'] = 'In Queue';
$lang['send_next_batch'] = 'Sending the next batch of %s emails; starting at: %s';
$lang['messages_sent'] = '%s have been sent';
$lang['closewindow'] = 'Close Window';
$lang['testmode'] = 'You are in test mode. No e-mails will be sent.';
$lang['confirmdeletejob'] = 'Are you sure you want to delete this job';
$lang['confirmsend'] = 'Are you sure you want to send all messages?';
$lang['confirmdelete'] = 'Are you sure you want to delete this message?';
$lang['confirmdeletelist'] = 'Are you sure you want to delete this list?';
$lang['keepwindowopen'] = 'Keep this window open till all messages have been sent.<br>';
$lang['profileupdated'] = 'Your profile has been updated.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['title_mod_prefs'] = 'Configuration';
$lang['title_mod_messages'] = 'Message Queue';
$lang['title_mod_createnew'] = 'Create a List';
$lang['title_mod_manage_user'] = 'Users';
$lang['title_mod_compose_job'] = 'Create Job';
$lang['title_mod_compose_message'] = 'Compose Message';
$lang['title_mod_process_queue'] = 'Process Queue';
$lang['title_mod_admin'] = 'Manage Lists';
$lang['user_delete_confirm'] = 'Are you sure you want to delete this user?';
$lang['userdeleted'] = 'User Deleted';
$lang['newsletterdeleted'] = 'Newsletter Deleted';
$lang['delete'] = 'Delete';
$lang['edit'] = 'Edit';
$lang['previous'] = 'Previous';
$lang['next'] = 'Next';
$lang['unsubscribemessage'] = 'You have been unsubscribed. Thank you.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'This module is a module that allows you to create a newsletter system.';
$lang['welcome_text'] = '<p>Welcome to Newsletter Made Simple (MNS) Module admin section. </p>';
$lang['changelog'] = '
<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0.3 - January, 2008</li>
<p>Fixes export functionality</p>
</li>
<li>Version 1.0.2 - August, 2007</li>
<p>Allow importing users from FEU <em>(originally done by skypanther, re-implemented by calguy100).</em></p>
<p>Numerous bug fixes</p>
<li>Version 1.0.1 - December, 2006</li>
<p>Fixes to import users, and to a ternery expression when creating a message. I also fixed some stupid problems with process_queue resulting from me doing this too quickly.</p>
<li>Version 1.0 - December, 2006</li>
<p>This <b>is</b> essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and attemtpts have been made to bring it up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a \'private list\'</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version <em>(Including previous betas)</em>is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Specify a comma separated list of mailing lists to display.  <em>(Valid only in subscribe mode)</em>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = "
<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>

<h3>How do I use it?</h3>
<ol>
<li>Install the module (which you have probably done by this point).</li>
<li>Grant appropriate permissions to the groups that will manage your lists. these include:
	<ul>
	<li>Manage NMS Lists &mdash; Add, remove mailing lists</li>	
	<li>Manage NMS Users &mdash; Add, remove users in the database</li>
	<li>Manage NMS Messages &mdash; Add, edit, remove messages but not send them</li> 	
	<li>Manage NMS Jobs &mdash; Send messages and perform other 'job' functions</li>	
	</ul>
</li>
<li>Create a list</li>
<li>(Optional) Add the {cms_module module='NMS'} to a page to enable web site visitors to sign up for your list.</li>
<li>(Optional) Add users to your list manually with the Users tab in the admin system</li>
<li>Create a message to be sent as part of a job</li>
<li>Create a job. You will select a message to send and a list to send it to.</li>
<li>Process the job and your message will be sent</li>
</ol>

<h3>Basic Syntax</h3>
<p>	{cms_module module='NMS'}  </p>

<h3>Further options</h3>

<h4>Display unsubscribe form:</h4>
<p>{cms_module module='NMS' mode='unsubscribe'}</p>

<h4>Display the user settings page:</h4>
<p>{cms_module module='NMS' mode='usersettings'}</p>

<h4>Display an archive of past newsletters</h4>
<p>{cms_module module='NMS' mode='archive'}</p>
<ul>
<lh>Optional parameters for the archive:</lh>
<li>show='#' where <code>#</code> is the number of past newsletters to show. If omitted, all are shown</li>
<li>sortby='date' &mdash; <code>date</code> (default), <code>id</code> (message ID), or <code>subject</code></li>
<li>sortorder='DESC' &mdash; either <code>DESC</code> (descending order, default) or <code>ASC</code> (ascending order)</li>
<li>dateformat='%Y-%m-%d' &mdash; sets the date output format following the PHP strftime() syntax</li>
</ul>		

<h4>Import users from the Front End Users database</h4>
<p>Note: You must have a property defined in FEU that stores the users' email address. It can be named whatever you want.</p>
<ol>
<li>Choose Extensions &gt; Newsletter Made Simple</li>
<li>Activate the Users tab</li>
<li>At the bottom, click Import Users from FrontEndUsers</li>
<li>Select the FEU field that contains the users' email addresses</li>
<li>Specify whether to copy the FEU user name to the NMS user name field. This is what would be output in your message if you included the {<span>$</span>username} placeholder.</li>
<li>Select the list to import to.</li>
<li>Click Submit.</li>
</ol>
<p>You will receive a report of the users processed, those already in your NMS database, those already on the list, and those that were added and subscribed. Users are not duplicated so there should be no harm in running an import periodically.</p>

<h3>Message variables</h3>
<p>These are covered elsewhere, but added here for completeness. If you add these to your message, they will be replaced at sending time with the appropriate true values.</p>

<ul>
<li>{<span>$</span>username}  &mdash;  The user's name</li>
<li>{<span>$</span>email}  &mdash;  The user's email address</li>
<li>{<span>$</span>unsubscribe}  &mdash;  A URL that can be used to display a page for unsubscribing</li>
<li>{<span>$</span>preferences}  &mdash;  A URL that can be used to display a user preferences page</li>
<li>{<span>$</span>confirmurl}  &mdash;  A URL that can be used to confirm subscriptions</li>
</ul>

<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href='http://dev.cmsmadesimple.org/projects/newsletter/' target='_blank'>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href='http://forum.cmsmadesimple.org' target='_blank'>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href='irc://irc.freenode.net/#cms'>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href='mailto:lemkepf@gmx.net'>&lt;lemkepf@gmx.net&gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href='http://www.gnu.org/licenses/licenses.html#GPL'>GNU Public License</a>. You must agree to this license before using the module.</p>
";

// this was missing causing an output problem, but I don't know what the actual message should be -- skypanther
$lang['error_problemwithmessage'] = 'Unspecified message problem.'; 

// IMPORT FROM FRONT END USERS LANG VARIABLES
$lang['import_feu_title'] = 'Import Users from FrontEndUsers';
$lang['import_feu_info'] = 'Select the FEU group to import into NMS. <em>(only groups with an email address field are displayed)</em>';

$lang['import_feu_noproperties'] = 'You have not defined any properties in the Front End Users module. You must define at least one property to store the users\'s email addresses.';
$lang['import_feu_prompt_groupname'] = 'FrontEndUsers Group';
$lang['import_feu_prompt_copyusername'] = 'Copy FEU user name to NMS?';
$lang['import_feu_info_copyusername'] = '<em>If No is selected, the username will be left blank.</em>';
$lang['import_feu_selectlists'] = 'Import users to (list name)';

$lang['import_feu_feunotinstalled'] = 'The Front End Users module is not installed or the properties definition table does not exist. Cannot import users from FEU.';
$lang['processedAddressesTitle'] = 'Processed addresses';
$lang['inDatabaseTitle'] = 'Already in NMS';
$lang['onListAlreadyTitle'] = 'Already subscribed';
$lang['addressSubscribedTitle'] = 'Subscribed';
$lang['listidInfo'] = 'Importing to list ID: ';
$lang['processedAddressesCountInfo'] = 'Addresses processed: ';

// ARCHIVE OF MESSAGES LANG VARIABLES
$lang['archive_heading'] = '<h1>Archive of messages</h1>';
$lang['archivedmessage'] = '<h1>Archived message</h1>';
$lang['archive_tbl_msgID'] = 'Msg ID';
$lang['archive_tbl_subject'] = 'Subject'; // hidden by default in archive.tpl
$lang['archive_tbl_fullurl'] = 'Message link';
$lang['archive_tbl_href'] = 'Link target'; // use this to create your own links, edit archive.tpl, hidden by default
$lang['archive_tbl_date'] = 'Date';

?>
]]></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['error_problemwithmessage'] = 'Unspecified message problem.';
$lang['prompt_usersettings_page'] = 'Return page for Usersettings form';
$lang['info_usersettings_page'] = 'Page to return to when an email link is clicked on to edit user preferences.<br/>The (*) Indicates the default page.';
$lang['jobname'] = '&Uacute;loha vytvořena v';
$lang['msg_jobprocessing'] = 'Batch Processing Window';
$lang['prompt_page'] = 'Return Page';
$lang['error_insufficientparams'] = 'One or more required parameters are missing from the request.  This action cannot proceed';
$lang['prompt_from'] = 'Od';
$lang['prompt_replyto'] = 'Adresa odpovědi';
$lang['prompt_subject'] = 'Předmět';
$lang['prompt_template'] = '&Scaron;ablona';
$lang['prompt_selectstatus'] = 'Vybrat stav';
$lang['prompt_message'] = 'Zpr&aacute;va';
$lang['prompt_userfilter'] = 'E-mailov&yacute; filtr (regul&aacute;rn&iacute; v&yacute;razy)';
$lang['prompt_listfilter'] = 'Filter on list Membership';
$lang['info_listfilter'] = '<strong>Note:</strong> Hold the CTRL key down and click on items to select and deselect them.
';
$lang['message_help'] = 'When typing a message, the following <em>smarty</em> variables are available:<br/>
<em>{$username}</em> - The users name<br/>
<em>{$email}</em> - The users email address<br/>
<em>{$unsubscribe}</em> - A URL that can be used to display a page for unsubscribing<br/>
<em>{$preferences}</em> - A URL that can be used to display a user preferences page<br/>
<em>{$confirmurl}</em> - A URL that can be used to confirm subscriptions<br/>
<strong>Note:</strong>&nbsp; When composing an HTML message and <em>not</em> using a page template, you will need to supply the appropriate HTML tags (html,head,body,etc).<br/>
<strong>Note:</strong>&nbsp; When using a page template as a message template, you need to use {$message_text} in place of {content} in your template.
';
$lang['applyfilter'] = 'Filtr';
$lang['info_event_OnNewUser'] = 'Generated when a new user subscribes to one or more mailing lists';
$lang['info_event_OnEditUser'] = 'Generated when a user is modified either in the admin or via the front end';
$lang['info_event_OnDeleteUser'] = 'Generated when a user is deleted';
$lang['info_event_OnNewList'] = 'Generated when a mailing list is modified';
$lang['info_event_OnDeleteList'] = 'Generated when a mailing list is deleted';
$lang['info_event_OnCreateMessage'] = 'Generated when a message is created';
$lang['info_event_OnEditMessage'] = 'Generated when a message is modified';
$lang['info_event_OnDeleteMessage'] = 'Generated when a message is deleted';
$lang['info_event_OnCreateJob'] = 'Generated when a job is created';
$lang['info_event_OnDeleteJob'] = 'Generated when a job is deleted';
$lang['info_event_OnStartJob'] = 'Generated when the processing of a job begins';
$lang['info_event_OnFinishJob'] = 'Generated when the processing of a job finishes';
$lang['help_OnNewUser'] = '<p>An event generated when a new user subscribes to one or more mailing lists</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>An event generated when a user is modified either in the admin or via the front end</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>An event generated when a user is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnNewList'] = '<p>An event generated when a new mailing list is created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '<p>An event generated when a mailing list is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'You must enter a valid reply to email address';
$lang['error_needfrom'] = 'You must enter a valid name for the originator of the message';
$lang['error_needsubject'] = 'You must enter a valid email subject';
$lang['error_needmessagetext'] = 'You must enter something for a message body';
$lang['error_formerror'] = 'Form error';
$lang['error_dberror'] = 'Database error';
$lang['invalidparam'] = 'Invalid param in the NMS module tag';
$lang['prompt_users_per_page'] = 'Number of users to display on each page of the user list';
$lang['disabled'] = 'Disabled';
$lang['confirmed'] = 'Confirmed';
$lang['prompt_usersettings_text2'] = 'Text displayed after the user settings form is submitted';
$lang['prompt_usersettings_form2'] = 'Form displayed to users wishing to change settings';
$lang['prompt_usersettings_text'] = 'Text displayed after the user settings message is sent';
$lang['prompt_usersettings_email_body'] = 'Body of the user settings email';
$lang['prompt_usersettings_subject'] = 'Subject of user settings email';
$lang['prompt_usersettings_form'] = 'Form asking users who whish to change settings, their email address';
$lang['prompt_post_unsubscribe_text'] = 'Text displayed after the unsubscribe process is complete';
$lang['user_settings'] = 'User Settings';
$lang['prompt_unsubscribe_prompt'] = 'Prompt asking the user for his email address to unsubscribe';
$lang['prompt_unsubscribe_text'] = 'Text displayed after unsubscribe form is completed';
$lang['prompt_unsubscribe_subject'] = 'Subject of the email sent to unsubscribe';
$lang['prompt_unsubscribe_email_body'] = 'Body of the email sent to unsubscribe';
$lang['prompt_unsubscribe_form'] = 'Template for the unsubscribe form';
$lang['error_accountdisabled'] = 'We are sorry, but your account has been disabled and this action is not possible at this time';
$lang['prompt_post_confirm_text'] = 'Message displayed after email confirmation';
$lang['prompt_confirm_email_body'] = 'Confirmation email body';
$lang['prompt_confirm_subject'] = 'Confirmation email subject';
$lang['confirm_subscribe'] = 'Confirm Subscribe';
$lang['confirm_unsubscribe'] = 'Confirm Unsubscribe';
$lang['nolists'] = 'No lists found to subscribe to';
$lang['public'] = 'Public';
$lang['yes'] = 'Yes';
$lang['no'] = 'No';
$lang['prompt_postsubscribetext'] = 'Message displayed after subscription';
$lang['subscription_confirmed'] = 'Subscription confirmed';
$lang['reset'] = 'Reset';
$lang['suspend'] = 'Suspend';
$lang['resume'] = 'Resume';
$lang['action'] = 'Action';
$lang['processing_records'] = 'Processing records %s to %s';
$lang['initializing_job'] = 'Initializing Job';
$lang['processing_job'] = 'Processing Job';
$lang['deletecompleted'] = 'Delete Completed Jobs';
$lang['error_importerrorcount'] = 'Error count';
$lang['lines'] = 'Lines';
$lang['users_added'] = 'Users Added';
$lang['memberships'] = 'Memberships';
$lang['subscribe'] = 'Subscribe';
$lang['resetdefaults'] = 'Reset to Defaults';
$lang['confirm_adjustsettings'] = 'Are you sure you want to adjust these settings?';
$lang['confirm_resetdefaults'] = 'Are you sure you want to reset this form to its system default value?';
$lang['prompt_subscribetext'] = 'Subscribe Text';
$lang['prompt_subscribesubject'] = 'Subscribe Subject';
$lang['prompt_subscribe_email_body'] = 'Subscribe Email Body';
$lang['prompt_subscribe_form'] = 'Template for the Subscribe Form';
$lang['subscribe_form'] = 'Subscribe';
$lang['unsubscribe_form'] = 'Unsubscribe';
$lang['error_insertinglist'] = 'Problem creating the new list';
$lang['error_emailexists'] = 'That email address already exists in the user list';
$lang['error_invalidusername'] = 'Invalid username';
$lang['error_invalidid'] = 'Invalid unique id';
$lang['username'] = 'Username';
$lang['name'] = 'Name';
$lang['prompt_public'] = 'This is a public mailing list';
$lang['error_usernotfound'] = 'Could not find user with specified uniqueid';
$lang['prompt_ms_between_message_sleep'] = 'Delay (in milliseconds) between sending each message';
$lang['prompt_between_batch_sleep'] = 'Delay (in seconds) between each batch';
$lang['prompt_messages_per_batch'] = 'The maximum number of messages to send in a batch';
$lang['okclosewindow'] = 'You can now close this window';
$lang['queuefinished'] = 'Processing of output queue finished';
$lang['totaltime'] = 'Total processing time:';
$lang['seconds'] = 'Seconds';
$lang['totalmails'] = 'Total Emails Sent (including to admin):';
$lang['page'] = 'Page';
$lang['of'] = 'of';
$lang['info_csvformat'] = 'The import file must be in CSV (comma separated value) format, one entry per line.<br />
The columns are:<br/><br/>
uniqueid, username, email address, list name, active<br /> <br />
Email addresses may be repeated on subsequent lines (particularly for different lists).';
$lang['prompt_lines'] = 'Lines Imported';
$lang['prompt_usersadded'] = 'Users Added';
$lang['prompt_membershipsadded'] = 'Memberships added';
$lang['prompt_errorcount'] = 'Number of Errors';
$lang['importerror_cantgetuserid'] = 'Error at line %s, could not get userid %s';
$lang['importerror_cantcreateuser'] = 'Error at line %s, could not create user %s';
$lang['importerror_nosuchlist'] = 'Error at line %s, no such list %s';
$lang['importerror_nofields'] = 'Error at line %s, not enough fields';
$lang['import_users'] = 'Import Users from CSV';
$lang['error_emptyfile'] = 'ERROR- An empty file was uploaded';
$lang['error_nofilesuploaded'] = 'ERROR- no files were uploaded';
$lang['filename'] = 'Import Filename';
$lang['title_users_import'] = 'Import Users from CSV';
$lang['nummessages'] = '# of Messages';
$lang['created'] = 'Created';
$lang['started'] = 'Started';
$lang['finished'] = 'Finished';
$lang['processjobs'] = 'Process Jobs';
$lang['status_error'] = 'ERROR';
$lang['status_unstarted'] = 'Not started';
$lang['status_inprogress'] = 'In Progress';
$lang['status_paused'] = 'Paused';
$lang['status_complete'] = 'Complete';
$lang['status_unknown'] = 'Unknown';
$lang['error_jobnameexists'] = 'ERROR- A job with that name already exists';
$lang['createjob'] = 'Create Job';
$lang['prompt_email_user_on_admin_subscribe'] = 'Send users an email when the administrator manually adds membership to a list';
$lang['error_nomessagesselected'] = 'No messages selected';
$lang['error_nolistsselected'] = 'No lists selected';
$lang['createjobmsg'] = 'Select one message, and one ore more lists to send the message to';
$lang['error_nojobname'] = 'ERROR- No job name specified';
$lang['error_nolists'] = 'ERROR- No lists!';
$lang['error_nomessages'] = 'ERROR- No messages!';
$lang['jobs'] = 'Jobs';
$lang['status'] = 'Status';
$lang['jobsfoundtext'] = 'Jobs found';
$lang['messagesfoundtext'] = 'Messages found';
$lang['entered'] = 'Entered';
$lang['subject'] = 'Subject';
$lang['from'] = 'From';
$lang['delete_user_confirm'] = 'Are you sure you want to delete this user';
$lang['info_singlelist'] = 'This user will be added to the sole mailing list';
$lang['error_selectonelist'] = 'ERROR- You must select atleast one list';
$lang['error_invaliduniqueid'] = 'ERROR- invalid unique id';
$lang['error_invalidemail'] = 'ERROR- Invalid email address';
$lang['error_couldnotfindjobpart'] = 'ERROR- Could not find a requested job part in the database.  This may indicate that another user (you?) is editing/deleting jobs whilst a job is processing.';
$lang['error_couldnotfindmessage'] = 'ERROR- Could not find a requested message.  This may indicate that another user (you?) is editing/deleting messages whilst a job is processing.';
$lang['error_couldnotfindtemplate'] = 'ERROR- Could not find a requested page template.  This may indicate that the template was deleted since the mail message was created.';
$lang['error_temporarytableexists'] = 'ERROR- The temporary database table, used for job processing already exists.  This probably indicates that an error occurred when trying to process a job previously.';
$lang['error_buildingtemptable'] = 'ERROR- A problem occurred when filling the temporary table';
$lang['error_otherprocessingerror'] = 'ERROR: An error occurred during processing';
$lang['userid'] = 'User ID';
$lang['emailaddress'] = 'Email Address';
$lang['usersfoundtext'] = 'Users found';
$lang['title_user_createnew'] = 'Add User';
$lang['error_invalidlistname'] = 'ERROR- Invalid list name';
$lang['editlist_text'] = 'Edit List';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Lists found';
$lang['users'] = 'Users';
$lang['preferences'] = 'Preferences';
$lang['messages'] = 'Messages';
$lang['queue'] = 'Queue';
$lang['submit'] = 'Submit';
$lang['description'] = 'Description';
$lang['createnewlist_text'] = 'Create List';
$lang['lists'] = 'Lists';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Thank you for installing NMS. Be sure to set &quot;Use NMS&quot; permissions to use this module!';
$lang['postuninstall'] = 'Newsletter Made Simple Uninstalled.';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['prefsupdated'] = 'Newsletter Made Simple Module preferences updated.';
$lang['newslettercreated'] = 'A new newsletter has been created.';
$lang['no_email_error'] = 'You must fill in an email address.';
$lang['subscribe_thankyou'] = 'Thank you for subscribing. A confirmation e-mail has been sent to your inbox.';
$lang['enter_valid_email'] = 'You must enter a valid e-mail address and select at least one list.';
$lang['newslettercreatederror'] = 'You must enter a name and description.';
$lang['accessdenied'] = 'Access Denied. Please check your permissions.';
$lang['error'] = 'Error!';
$lang['sent'] = 'Sent';
$lang['inqueue'] = 'In Queue';
$lang['send_next_batch'] = 'Sending the next batch of %s emails; starting at: %s';
$lang['messages_sent'] = '%s have been sent';
$lang['closewindow'] = 'Close Window';
$lang['testmode'] = 'You are in test mode. No e-mails will be sent.';
$lang['confirmdeletejob'] = 'Are you sure you want to delete this job';
$lang['confirmsend'] = 'Are you sure you want to send all messages?';
$lang['confirmdelete'] = 'Are you sure you want to delete this message?';
$lang['confirmdeletelist'] = 'Are you sure you want to delete this list?';
$lang['keepwindowopen'] = 'Keep this window open till all messages have been sent.<br>';
$lang['profileupdated'] = 'Your profile has been updated.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['title_mod_prefs'] = 'Configuration';
$lang['title_mod_messages'] = 'Message Queue';
$lang['title_mod_createnew'] = 'Create a List';
$lang['title_mod_manage_user'] = 'Users';
$lang['title_mod_compose_job'] = 'Create Job';
$lang['title_mod_compose_message'] = 'Compose Message';
$lang['title_mod_process_queue'] = 'Process Queue';
$lang['title_mod_admin'] = 'Manage Lists';
$lang['user_delete_confirm'] = 'Are you sure you want to delete this user?';
$lang['userdeleted'] = 'User Deleted';
$lang['newsletterdeleted'] = 'Newsletter Deleted';
$lang['delete'] = 'Delete';
$lang['edit'] = 'Edit';
$lang['previous'] = 'Previous';
$lang['next'] = 'Next';
$lang['unsubscribemessage'] = 'You have been unsubscribed. Thank you.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'This module is a module that allows you to create a newsletter system.';
$lang['welcome_text'] = '<p>Welcome to Newsletter Made Simple (MNS) Module admin section. </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0.1 - December, 2006</li>
<p>Fixes to import users, and to a ternery expression when creating a message. I also fixed some stupid problems with process_queue resulting from me doing this too quickly.</p>
<li>Version 1.0 - December, 2006</li>
<p>This <b>is</b> essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and attemtpts have been made to bring it up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version <em>(Including previous betas)</em>is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Specify a comma separated list of mailing lists to display.  <em>(Valid only in subscribe mode)</em>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>

<h3>How do I use it?</h3>
<ol>
<li>Install the module (which you have probably done by this point).</li>
<li>Grant appropriate permissions to the groups that will manage your lists. these include:
	<ul>
	<li>Manage NMS Lists &mdash; Add, remove mailing lists</li>	
	<li>Manage NMS Users &mdash; Add, remove users in the database</li>
	<li>Manage NMS Messages &mdash; Add, edit, remove messages but not send them</li> 	
	<li>Manage NMS Jobs &mdash; Send messages and perform other &#039;job&#039; functions</li>	
	</ul>
</li>
<li>Create a list</li>
<li>(Optional) Add the {cms_module module=&#039;NMS&#039;} to a page to enable web site visitors to sign up for your list.</li>
<li>(Optional) Add users to your list manually with the Users tab in the admin system</li>
<li>Create a message to be sent as part of a job</li>
<li>Create a job. You will select a message to send and a list to send it to.</li>
<li>Process the job and your message will be sent</li>
</ol>

<h3>Basic Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}  </p>

<h3>Further options</h3>

<h4>Display unsubscribe form:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;unsubscribe&#039;}</p>

<h4>Display the user settings page:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;usersettings&#039;}</p>

<h4>Display an archive of past newsletters</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;archive&#039;}</p>
<ul>
<lh>Optional parameters for the archive:</lh>
<li>show=&#039;#&#039; where <code>#</code> is the number of past newsletters to show. If omitted, all are shown</li>
<li>sortby=&#039;date&#039; &mdash; <code>date</code> (default), <code>id</code> (message ID), or <code>subject</code></li>
<li>sortorder=&#039;DESC&#039; &mdash; either <code>DESC</code> (descending order, default) or <code>ASC</code> (ascending order)</li>
<li>dateformat=&#039;%Y-%m-%d&#039; &mdash; sets the date output format following the PHP strftime() syntax</li>
</ul>		

<h4>Import users from the Front End Users database</h4>
<p>Note: You must have a property defined in FEU that stores the users&#039; email address. It can be named whatever you want.</p>
<ol>
<li>Choose Extensions > Newsletter Made Simple</li>
<li>Activate the Users tab</li>
<li>At the bottom, click Import Users from FrontEndUsers</li>
<li>Select the FEU field that contains the users&#039; email addresses</li>
<li>Specify whether to copy the FEU user name to the NMS user name field. This is what would be output in your message if you included the {<span>$</span>username} placeholder.</li>
<li>Select the list to import to.</li>
<li>Click Submit.</li>
</ol>
<p>You will receive a report of the users processed, those already in your NMS database, those already on the list, and those that were added and subscribed. Users are not duplicated so there should be no harm in running an import periodically.</p>

<h3>Message variables</h3>
<p>These are covered elsewhere, but added here for completeness. If you add these to your message, they will be replaced at sending time with the appropriate true values.</p>

<ul>
<li>{<span>$</span>username}  &mdash;  The user&#039;s name</li>
<li>{<span>$</span>email}  &mdash;  The user&#039;s email address</li>
<li>{<span>$</span>unsubscribe}  &mdash;  A URL that can be used to display a page for unsubscribing</li>
<li>{<span>$</span>preferences}  &mdash;  A URL that can be used to display a user preferences page</li>
<li>{<span>$</span>confirmurl}  &mdash;  A URL that can be used to confirm subscriptions</li>
</ul>

<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['import_feu_title'] = 'Import Users from FrontEndUsers';
$lang['import_feu_info'] = 'To import users from the Front End Users tables, you must specify which FEU field contains the email address and whether to copy the contents of the FEU username field to the NMS username field.';
$lang['import_feu_emailfieldname'] = 'FEU email address field';
$lang['import_feu_noproperties'] = 'You have not defined any properties in the Front End Users module. You must define at least one property to store the users&#039;s email addresses.';
$lang['import_feu_copyusername'] = 'Copy FEU user name to NMS?';
$lang['import_feu_selectlists'] = 'Import users to (list name)';
$lang['import_feu_copyusername_yes'] = 'Yes';
$lang['import_feu_copyusername_no'] = 'No (leave empty)';
$lang['import_feu_feunotinstalled'] = 'The Front End Users module is not installed or the properties definition table does not exist. Cannot import users from FEU.';
$lang['processedAddressesTitle'] = 'Processed addresses';
$lang['inDatabaseTitle'] = 'Already in NMS';
$lang['onListAlreadyTitle'] = 'Already subscribed';
$lang['addressSubscribedTitle'] = 'Subscribed';
$lang['listidInfo'] = 'Importing to list ID: ';
$lang['processedAddressesCountInfo'] = 'Addresses processed: ';
$lang['archive_heading'] = '<h1>Archiv zpr&aacute;v</h1>';
$lang['archivedmessage'] = '<h1>Archivovan&aacute; zpr&aacute;va</h1>';
$lang['archive_tbl_msgID'] = 'Msg ID';
$lang['archive_tbl_subject'] = 'Předmět';
$lang['archive_tbl_fullurl'] = 'Message link';
$lang['archive_tbl_href'] = 'C&iacute;l odkazu';
$lang['archive_tbl_date'] = 'Datum';
$lang['utmz'] = '156861353.1175892552.61.3.utmccn=(referral)|utmcsr=cs.wikibooks.org|utmcct=/wiki/CMS_made_simple|utmcmd=referral';
$lang['utma'] = '156861353.1608855210.1167908109.1177858701.1178123450.71';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['prompt_usersettings_page'] = 'Return page for Usersettings form';
$lang['info_usersettings_page'] = 'Page to return to when an email link is clicked on to edit user preferences.<br/>The (*) Indicates the default page.';
$lang['jobname'] = 'Job created at';
$lang['msg_jobprocessing'] = 'Batch Processing Window';
$lang['prompt_page'] = 'Return Page';
$lang['error_insufficientparams'] = 'In Ihrer Anfrage fehlen ein oder mehrere der erforderlichen Parameter.  Diese Aktion kann daher  nicht fortgesetzt werden.';
$lang['prompt_from'] = 'Von';
$lang['prompt_replyto'] = 'Antwort an';
$lang['prompt_subject'] = 'Betreff';
$lang['prompt_template'] = 'Template';
$lang['prompt_selectstatus'] = 'Select Status';
$lang['prompt_message'] = 'Nachricht';
$lang['prompt_userfilter'] = 'Email filter (regexp)';
$lang['prompt_listfilter'] = 'Filter on list Membership';
$lang['info_listfilter'] = '<strong>Note:</strong> Hold the CTRL key down and click on items to select and deselect them.
';
$lang['message_help'] = 'When typing a message, the following <em>smarty</em> variables are available:<br/>
<em>username</em> - The users name<br/>
<em>email</em> - The users email address<br/>
<em>unsubscribe</em> - A URL that can be used to display a page for unsubscribing<br/>
<em>preferences</em> - A URL that can be used to display a user preferences page<br/>
<em>confirmurl</em> - A URL that can be used to confirm subscriptions<br/>
<strong>Note:</strong>&nbsp; When composing an HTML message and <em>not</em> using a page template, you will need to supply the appropriate HTML tags (html,head,body,etc).<br/>
<strong>Note:</strong>&nbsp; When using a page template as a message template, you need to use {$message_text} in place of {content} in your template.
';
$lang['applyfilter'] = 'Filter';
$lang['info_event_OnNewUser'] = 'Ausf&uuml;hren, wenn sich ein  Benutzer f&uuml;r eine oder mehrere Mailinglisten eintr&auml;gt';
$lang['info_event_OnEditUser'] = 'Ausf&uuml;hren, wenn die Daten eines Benutzers entweder &uuml;ber die Administration oder das Frontend ge&auml;ndert werden';
$lang['info_event_OnDeleteUser'] = 'Ausf&uuml;hren, wenn ein Benutzer gel&ouml;scht wurde';
$lang['info_event_OnNewList'] = 'Ausf&uuml;hren, wenn an einer Mailingliste &Auml;nderungen vorgenommen wurden';
$lang['info_event_OnDeleteList'] = 'Ausf&uuml;hren, wenn eine Mailingliste gel&ouml;scht wurde';
$lang['info_event_OnCreateMessage'] = 'Ausf&uuml;hren, wenn eine Nachricht erstellt wurde';
$lang['info_event_OnEditMessage'] = 'Ausf&uuml;hren, wenn eine Nachricht ge&auml;ndert wurde';
$lang['info_event_OnDeleteMessage'] = 'Ausf&uuml;hren, wenn eine Nachricht gel&ouml;scht wurde';
$lang['info_event_OnCreateJob'] = 'Ausf&uuml;hren, wenn ein Job erstellt wurde';
$lang['info_event_OnDeleteJob'] = 'Ausf&uuml;hren, wenn ein Job gel&ouml;scht wurde';
$lang['info_event_OnStartJob'] = 'Ausf&uuml;hren, wenn mit der Verarbeitung eines Jobs begonnen wurde';
$lang['info_event_OnFinishJob'] = 'Ausf&uuml;hren, wenn die Verarbeitung eines Job abgeschlossen wurde';
$lang['help_OnNewUser'] = '<p>Ausf&uuml;hren, wenn sich ein  Benutzer f&uuml;r eine oder mehrere Mailinglisten eintr&auml;gt</p>
<h4>Parameter</h4>
<ul>
<li><em>email</em> - Emailadresse des Benutzers</li>
<li><em>username</em> - Benutzername</li>
<li><em>lists</em> - ausgew&auml;hlte Mailinglisten</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>Ausf&uuml;hren, wenn die Daten eines Benutzers entweder &uuml;ber die Administration oder das Frontend ge&auml;ndert werden</p>
<h4>Parameter</h4>
<ul>
<li><em>email</em> - Emailadresse des Benutzers</li>
<li><em>username</em> - Benutzername</li>
<li><em>lists</em> - ausgew&auml;hlte Mailinglisten</li>
<li><em>id</em> - die Benutzer-ID</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>Ausf&uuml;hren, wenn ein Benutzer gel&ouml;scht wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>id</em> - die Benutzer-ID</li>
</ul>
';
$lang['help_OnNewList'] = '<p>Ausf&uuml;hren, wenn eine neue Mailingliste erstellt wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>name</em> - Name der Mailingliste</li>
<li><em>description</em> - Beschreibung der Mailingliste</li>
<li><em>public</em> - Kennzeichnung, ob die Mailingliste &ouml;ffentlich ist</li>
</ul>
';
$lang['help_OnEditList'] = '<p>Ausf&uuml;hren, wenn an einer Mailingliste &Auml;nderungen vorgenommen wurden</p>
<h4>Parameter</h4>
<ul>
<li><em>name</em> - Name der Mailingliste</li>
<li><em>description</em> - Beschreibung der Mailingliste</li>
<li><em>public</em> - Kennzeichnung, ob die Mailingliste &ouml;ffentlich ist</li>
<li><em>listid</em> - die ID der Mailingliste</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>Ausf&uuml;hren, wenn eine Mailingliste gel&ouml;scht wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>listid</em> - die ID der Mailingliste</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>Ausf&uuml;hren, wenn eine Nachricht erstellt wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>fromwho</em> - Name der Person, der die Nachricht erstellt hat</li>
<li><em>reply_to</em> - die Emailadresse f&uuml;r das Antworten-Feld</li>
<li><em>subject</em> - der Betreff der Nachricht</li>
<li><em>message</em> - der Text der Nachricht <em>(kann Smarty-Tags enthalten)</em></li>
<li><em>entered</em> - das Erstellungsdatum der Nachricht</li>
<li><em>uniqueid</em> - die eindeutige ID dieser Nachricht</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>Ausf&uuml;hren, wenn eine Nachricht ge&auml;ndert wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>fromwho</em> - Name der Person, der die Nachricht erstellt hat</li>
<li><em>reply_to</em> - die Emailadresse f&uuml;r das Antworten-Feld</li>
<li><em>subject</em> - der Betreff der Nachricht</li>
<li><em>message</em> - der Text der Nachricht <em>(kann Smarty-Tags enthalten)</em></li>
<li><em>messageid</em> - die ID dieser Nachricht</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>Ausf&uuml;hren, wenn eine Nachricht gel&ouml;scht wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>messageid</em> - die ID dieser Nachricht</id>
</ul>
';
$lang['help_OnCreateJob'] = '<p>Ausf&uuml;hren, wenn ein Job erstellt wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>jobid</em> - die ID dieses Jobs</li>
<li><em>jobname</em> - der Name dieses Jobs</li>
<li><em>lists</em> - eine Liste der betroffenen Mailinglisten</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>Ausf&uuml;hren, wenn ein Job gel&ouml;scht wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>jobid</em> - die ID dieses Jobs</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>Ausf&uuml;hren, wenn mit der Verarbeitung eines Jobs begonnen wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>jobid</em> - die ID dieses Jobs</li>
<li><em>jobname</em> - der Name dieses Jobs</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>Ausf&uuml;hren, wenn die Verarbeitung eines Job abgeschlossen wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>jobid</em> - die ID dieses Jobs</li>
<li><em>jobname</em> - der Name dieses Jobs</li>
</ul>
';
$lang['error_needreplyto'] = 'Sie m&uuml;ssen hier eine g&uuml;ltige Antwort-Emailadresse eingeben.';
$lang['error_needfrom'] = 'You must enter a valid name for the originator of the message';
$lang['error_needsubject'] = 'Sie m&uuml;ssen hier einen g&uuml;ltigen Email-Betreff eingeben.';
$lang['error_needmessagetext'] = 'Sie m&uuml;ssen hier einen Nachrichtentext eingeben.';
$lang['error_formerror'] = 'Formular-Fehler';
$lang['error_dberror'] = 'Datenbank-Fehler';
$lang['invalidparam'] = 'Ung&uuml;ltige Parameter im NMS-Modul-Tag';
$lang['prompt_users_per_page'] = 'Anzahl der Benutzer, die auf jeder Seite der Benutzerliste angezeigt werden sollen';
$lang['disabled'] = 'Deaktiviert';
$lang['confirmed'] = 'Best&auml;tigt';
$lang['prompt_usersettings_text2'] = 'Text, der angezeigt wird, wenn das Formular mit den Benutzereinstellungen abgesandt wurde';
$lang['prompt_usersettings_form2'] = 'Formular, das Benutzern angezeigt wird, die ihre Einstellungen &auml;ndern wollen';
$lang['prompt_usersettings_text'] = 'Text, der angezeigt wird, wenn die Nachricht zum &Auml;ndern den Benutzereinstellungen versandt wurde';
$lang['prompt_usersettings_email_body'] = 'Inhalt der Email zum &Auml;ndern den Benutzereinstellungen';
$lang['prompt_usersettings_subject'] = 'Betreff der Email zum &Auml;ndern den Benutzereinstellungen';
$lang['prompt_usersettings_form'] = 'Formular, welches die Benutzer, die ihre Einstellungen &auml;ndern wollen, nach ihrer Emailadresse fragt';
$lang['prompt_post_unsubscribe_text'] = 'Text, der angezeigt wird, wenn die Abmeldung vollst&auml;ndig ist';
$lang['user_settings'] = 'Benutzereinstellungen';
$lang['prompt_unsubscribe_prompt'] = 'Aufforderung an den Benutzer, seine Emailadresse zur Abmeldung einzutragen';
$lang['prompt_unsubscribe_text'] = 'Text, der angezeigt wird, wenn das Abmeldeformular vollst&auml;ndig ist';
$lang['prompt_unsubscribe_subject'] = 'Betreff der versandten Abmeldungs-Email';
$lang['prompt_unsubscribe_email_body'] = 'Inhalt der versandten Abmeldungs-Email';
$lang['prompt_unsubscribe_form'] = 'Template f&uuml;r das Abmeldeformular';
$lang['error_accountdisabled'] = 'Entschuldigung, aber Ihr Konto wurde vor&uuml;bergehend deaktiviert - Sie k&ouml;nnen diese Aktion derzeit nicht ausf&uuml;hren.';
$lang['prompt_post_confirm_text'] = 'Nachricht, die nach der Email-Best&auml;tigung angezeigt wird.';
$lang['prompt_confirm_email_body'] = 'Inhalt der Best&auml;tigungs-Email';
$lang['prompt_confirm_subject'] = 'Betreff der Best&auml;tigungs-Email';
$lang['confirm_subscribe'] = 'Anmeldung best&auml;tigen';
$lang['confirm_unsubscribe'] = 'Abmeldung best&auml;tigen';
$lang['nolists'] = 'Keine Liste zum Anmelden gefunden';
$lang['public'] = '&Ouml;ffentlich';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nein';
$lang['prompt_postsubscribetext'] = 'Nachricht, die nach dem Abonnement angezeigt wird';
$lang['subscription_confirmed'] = 'Abonnement best&auml;tigt';
$lang['reset'] = 'Zur&uuml;cksetzen';
$lang['suspend'] = 'Ausgesetzt';
$lang['resume'] = 'Fortsetzen';
$lang['action'] = 'Aktion';
$lang['processing_records'] = 'Abgearbeitete Datens&auml;tze %s von %s';
$lang['initializing_job'] = 'Job wird initialisiert ...';
$lang['processing_job'] = 'Job wird abgearbeitet ...';
$lang['deletecompleted'] = 'Erledigte Jobs l&ouml;schen';
$lang['error_importerrorcount'] = 'Fehlerz&auml;hler';
$lang['lines'] = 'Zeilen';
$lang['users_added'] = 'Benutzer hinzugef&uuml;gt';
$lang['memberships'] = 'Mitgliedschaft';
$lang['subscribe'] = 'Anmelden';
$lang['resetdefaults'] = 'Auf die Voreinstellung zur&uuml;cksetzen';
$lang['confirm_adjustsettings'] = 'Soll das Modul wirklich diese Einstellungen verwenden?';
$lang['confirm_resetdefaults'] = 'Wollen Sie dieses Formular wirklich auf den Systemstandard zur&uuml;cksetzen?';
$lang['prompt_subscribetext'] = 'Text der Anmeldung';
$lang['prompt_subscribesubject'] = 'Betreff der Anmeldung';
$lang['prompt_subscribe_email_body'] = 'Email-Inhalt der Anmeldung';
$lang['prompt_subscribe_form'] = 'Template f&uuml;r das Anmeldeformular';
$lang['subscribe_form'] = 'Anmelden';
$lang['unsubscribe_form'] = 'Abmelden';
$lang['error_insertinglist'] = 'Problem beim Erstellen der neuen Liste';
$lang['error_emailexists'] = 'Diese Emailadresse existiert bereits in der Benutzerliste.';
$lang['error_invalidusername'] = 'Ung&uuml;ltiger Benutzername';
$lang['error_invalidid'] = 'Ung&uuml;ltige ID';
$lang['username'] = 'Benutzername';
$lang['name'] = 'Name';
$lang['prompt_public'] = 'Das ist eine &ouml;ffentliche Mailingliste.';
$lang['error_usernotfound'] = 'Konnte den Benutzer mit der vorgegebenen ID nicht finden';
$lang['prompt_ms_between_message_sleep'] = 'Verz&ouml;gerung (in Millisekunden) zwischen dem Versand jeder Nachricht';
$lang['prompt_between_batch_sleep'] = 'Verz&ouml;gerung (in Sekunden) zwischen jedem Stapel';
$lang['prompt_messages_per_batch'] = 'Maximale Anzahl der Nachrichten, die in einem Stapel versandt werden';
$lang['okclosewindow'] = 'Sie k&ouml;nnen dieses Fenster jetzt schlie&szlig;en.';
$lang['queuefinished'] = 'Die Warteschlange wurde vollst&auml;ndig abgearbeitet.';
$lang['totaltime'] = 'Bearbeitungszeit gesamt:';
$lang['seconds'] = 'Sekunden';
$lang['totalmails'] = 'Versandte Emails gesamt (einschlie&szlig;lich der an den Administrator):';
$lang['page'] = 'Seite';
$lang['of'] = 'von';
$lang['info_csvformat'] = 'Die zu importierende Datei muss im CSV-Format vorliegen (durch Komma getrennte Werte, jeweils einem Eintrag pro Zeile).  Das erste Feld sollte eine Email-Adresse, das zweite Feld einen Benutzernamen und das dritte Feld einen Listennamen enthalten. Die Email-Adressen k&ouml;nnen sich auf nachfolgenden Zeilen wiederholen (insbesondere bei unterschiedlichen Listen).';
$lang['prompt_lines'] = 'Zeilen importiert';
$lang['prompt_usersadded'] = 'Benutzer hinzugef&uuml;gt';
$lang['prompt_membershipsadded'] = 'Mitgliedschaft hinzugef&uuml;gt';
$lang['prompt_errorcount'] = 'Anzahl der Fehler';
$lang['importerror_cantgetuserid'] = 'Fehler in Zeile %s, konnte die Benutzer-ID %s nicht ermitteln';
$lang['importerror_cantcreateuser'] = 'Fehler in Zeile %s, konnte das Benutzerkonto %s nicht erstellen';
$lang['importerror_nosuchlist'] = 'Fehler in Zeile %s, keine Liste %s vorhanden';
$lang['importerror_nofields'] = 'Fehler in Zeile %s, nicht gen&uuml;gend Felder';
$lang['import_users'] = 'Benutzer aus einer CSV-Datei importieren';
$lang['error_emptyfile'] = 'FEHLER - es wurde eine leere Datei hochgeladen';
$lang['error_nofilesuploaded'] = 'FEHLER - es wurde keine Datei hochgeladen.';
$lang['filename'] = 'Name der zu importierenden Datei';
$lang['title_users_import'] = 'Benutzer importieren';
$lang['nummessages'] = '# der Nachrichten';
$lang['created'] = 'Erstellt';
$lang['started'] = 'Gestartet';
$lang['finished'] = 'Beendet';
$lang['processjobs'] = 'Jobs abarbeiten';
$lang['status_error'] = 'FEHLER';
$lang['status_unstarted'] = 'Nicht gestartet';
$lang['status_inprogress'] = 'In Arbeit';
$lang['status_paused'] = 'Vor&uuml;bergehend unterbrochen';
$lang['status_complete'] = 'Komplett';
$lang['status_unknown'] = 'Unbekannt';
$lang['error_jobnameexists'] = 'FEHLER - Ein Job mit diesem Namen existiert bereits.';
$lang['createjob'] = 'Einen Job erstellen';
$lang['prompt_email_user_on_admin_subscribe'] = 'Den Benutzern eine Nachrichten senden, wenn sie vom Administrator manuell zu einer Liste hinzugef&uuml;gt wurden.';
$lang['error_nomessagesselected'] = 'Keine Nachrichten ausgew&auml;hlt';
$lang['error_nolistsselected'] = 'Keine Listen ausgew&auml;hlt';
$lang['createjobmsg'] = 'W&auml;hlen Sie eine Nachricht sowie eine oder mehrere Listen aus, an die die Nachricht versandt werden soll.';
$lang['error_nojobname'] = 'FEHLER - Der Jobname wurde nicht festgelegt!';
$lang['error_nolists'] = 'FEHLER - Keine Listen!';
$lang['error_nomessages'] = 'FEHLER - Keine Nachrichten!';
$lang['jobs'] = 'Jobs';
$lang['status'] = 'Status';
$lang['jobsfoundtext'] = 'Jobs gefunden';
$lang['messagesfoundtext'] = 'Nachrichten gefunden';
$lang['entered'] = 'Eingegeben';
$lang['subject'] = 'Betreff';
$lang['from'] = 'Von';
$lang['delete_user_confirm'] = 'Wollen Sie diesen Benutzer wirklich l&ouml;schen?';
$lang['info_singlelist'] = 'Dieser Benutzer wird der Mailingliste hinzugef&uuml;gt';
$lang['error_selectonelist'] = 'FEHLER - Sie m&uuml;ssen mindestens eine Liste ausw&auml;hlen.';
$lang['error_invaliduniqueid'] = 'FEHLER - ung&uuml;ltige ID';
$lang['error_invalidemail'] = 'FEHLER - ung&uuml;ltige Emailadresse';
$lang['error_couldnotfindjobpart'] = 'ERROR- Could not find a requested job part in the database.  This may indicate that another user (you?) is editing/deleting jobs whilst a job is processing.';
$lang['error_couldnotfindmessage'] = 'ERROR- Could not find a requested message.  This may indicate that another user (you?) is editing/deleting messages whilst a job is processing.';
$lang['error_couldnotfindtemplate'] = 'ERROR- Could not find a requested page template.  This may indicate that the template was deleted since the mail message was created.';
$lang['error_temporarytableexists'] = 'ERROR- The temporary database table, used for job processing already exists.  This probably indicates that an error occurred when trying to process a job previously.';
$lang['error_buildingtemptable'] = 'ERROR- A problem occurred when filling the temporary table';
$lang['error_otherprocessingerror'] = 'FEHLER: W&auml;hrend der Verarbeitung ist ein Fehler aufgetreten.';
$lang['userid'] = 'Benutzer-ID';
$lang['emailaddress'] = 'Emailadresse';
$lang['usersfoundtext'] = 'Benutzer gefunden';
$lang['title_user_createnew'] = 'Einen Benutzer hinzuf&uuml;gen';
$lang['error_invalidlistname'] = 'FEHLER - ung&uuml;ltiger Listenname';
$lang['editlist_text'] = 'Liste bearbeiten';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Listen gefunden';
$lang['users'] = 'Benutzer ';
$lang['preferences'] = 'Einstellungen';
$lang['messages'] = 'Nachrichten';
$lang['queue'] = 'Warteschlange';
$lang['submit'] = 'Absenden';
$lang['description'] = 'Beschreibung';
$lang['createnewlist_text'] = 'Listen erstellen';
$lang['lists'] = 'Listen';
$lang['friendlyname'] = 'NewsletterMadeSimple';
$lang['postinstall'] = 'Vielen Dank f&uuml;r die Installation von NMS. Stellen Sie sicher, dass Sie die Berechtigung &quot;Use NMS&quot; f&uuml;r die Verwendung des Moduls gesetzt haben!';
$lang['postuninstall'] = 'Newsletter Made Simple deinstalliert.';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['prefsupdated'] = 'Newsletter Made Simple Moduleinstellungen aktualisiert.';
$lang['newslettercreated'] = 'Ein neuer Newsletter wurde erstellt.';
$lang['no_email_error'] = 'Sie m&uuml;ssen hier eine Emailadresse eingeben.';
$lang['subscribe_thankyou'] = 'Vielen Dank f&uuml;r Ihre Anmeldung. Ihnen wurde zur Best&auml;tigung eine Email gesandt.';
$lang['enter_valid_email'] = 'Sie m&uuml;ssen eine g&uuml;ltige Email-Adresse eingeben und mindestens eine Liste ausw&auml;hlen.';
$lang['newslettercreatederror'] = 'Sie m&uuml;ssen hier einen Name und eine Beschreibung eintragen.';
$lang['accessdenied'] = 'Zugriff verweigert. Bitte &uuml;berpr&uuml;fen Sie Ihre Berechtigungen.';
$lang['error'] = 'Fehler!';
$lang['sent'] = 'Versandt';
$lang['inqueue'] = 'In Warteposition';
$lang['send_next_batch'] = 'Versand des n&auml;chsten Stapels von %s Emails; beginnend mit: %s';
$lang['messages_sent'] = '%s wurden versandt.';
$lang['closewindow'] = 'Fenster schliessen';
$lang['testmode'] = 'Sie sind im Testmodus. Es werden keine Emails versandt.';
$lang['confirmdeletejob'] = 'Wollen Sie diesen Job wirklich l&ouml;schen?';
$lang['confirmsend'] = 'Wollen Sie wirklich alle Nachrichten versenden?';
$lang['confirmdelete'] = 'Wollen Sie diese Nachricht wirklich l&ouml;schen?';
$lang['confirmdeletelist'] = 'Wollen Sie diese Liste wirklich l&ouml;schen?';
$lang['keepwindowopen'] = 'Lassen Sie das Fenster ge&ouml;ffnet, bis alle Nachrichten versandt wurden.<br>';
$lang['profileupdated'] = 'Ihr Profil wurde aktualisiert.';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['title_mod_prefs'] = 'Konfiguration';
$lang['title_mod_messages'] = 'Nachrichten-Warteschlange';
$lang['title_mod_createnew'] = 'Eine Liste erstellen';
$lang['title_mod_manage_user'] = 'Benutzer ';
$lang['title_mod_compose_job'] = 'Einen Job erstellen';
$lang['title_mod_compose_message'] = 'Eine Nachricht verfassen';
$lang['title_mod_process_queue'] = 'Prozess-Warteschlange';
$lang['title_mod_admin'] = 'Listen verwalten';
$lang['user_delete_confirm'] = 'Wollen Sie diesen Benutzer wirklich l&ouml;schen?';
$lang['userdeleted'] = 'Benutzer gel&ouml;scht';
$lang['newsletterdeleted'] = 'Newsletter gel&ouml;scht';
$lang['delete'] = 'L&ouml;schen';
$lang['edit'] = 'Bearbeiten';
$lang['previous'] = 'Vorheriger';
$lang['next'] = 'N&auml;chster';
$lang['unsubscribemessage'] = 'Sie wurden ausgetragen. Vielen Dank!';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Mit diesem Modul k&ouml;nnen Newsletter erstellt werden.';
$lang['welcome_text'] = '<p>Willkommen in der Newsletter Made Simple (MNS) Administration.</p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users Tab - Filtering on list membership (maybe regexp later)</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as diabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0. - Beta 6 (September, 2006)  
<p>This is essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and brought up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<p>This version requires CMS 1.0 and fixes alot of the bugs, including the &amp;amp; issue that alot of overseas users were having problems with.  I won&#039;t release a 1.0 final, until such time as I get the user preferences done, or remove that stuff all together.</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Specify a comma separated list of mailing lists to display.  <em>(Valid only in subscribe mode)</em>';
$lang['helpmode'] = 'Legen Sie den Anzeigemodus fest. Die Optionen sind folgende:
<ul>
<li>subscribe (default) - zeigt das Anmeldeformular an</li>
<li>unsubscribe - zeigt das Abmeldeformular an</li>
<li>usersettings - zeigt das Formular mit den Usereinstellungen an</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>Was macht dieses Modul?</strong></h3>
<p>Dieses Modul aktiviert einen Email-Newsletter f&uuml;r CMS made simple. </p>
<h3>Wie wird es eingesetzt ?</h3>
<p>1. Installieren Sie das Modul. <br>
2. Setzen Sie die richtigen Berechtigungen f&uuml;r den Zugriff auf NMS.<br>
3. Konfigurieren Sie das NMS-Modul in dessen Administration. <br>
<ul>
<li>Sie haben hier die M&ouml;glichkeit, verschiedene Templates an Ihre Installation anzupassen.</li>
</ul>
4. Erstellen Sie eine beliebige Anzahl von  Mailinglisten.<br>
<ul>
<li>Sie k&ouml;nnen private und &ouml;ffentliche Mailinglisten erstellen.  Die &ouml;ffentlichen Mailinglisten werden auf den auf der Webseite angezeigt. Hier k&ouml;nnen sich die Benutzer jederzeit ein- und austragen.</li>
<li>Die Mitgliedschaften in privaten Mailinglisten werden vom Administrator kontrolliert, hier k&ouml;nnen sich die Benutzer nicht selbst austragen.</li>
</ul>
5. F&uuml;gen Sie das Modul mit dem unten stehenden Syntax in ein Template oder in eine Inhaltsseite einf&uuml;gen.<br>
6. Sobald sich Abonnenten eingetragen haben, k&ouml;nnen Sie Nachrichten schreiben, die in der Nachrichten-Warteschlange gespeichert werden.<br>
7. Erstellen Sie einen Job, indem Sie eine Nachricht und eine oder mehrere Mailinglisten ausw&auml;hlen.<br/>
&nbsp;&nbsp;<strong>Hinweis:</strong> Wenn ein Benutzer sich f&uuml;r mehrere Mailinglisten eingetragen hat, wird ihm die Nachricht nur ein Mal gesandt.<br/>
7. F&uuml;hren Sie die Warteschlange aus, um die Nachrichten zu versenden.</p>
<h3>Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}</p>
<h3>Support</h3>
<p>Dieses Modul beinhaltet keinen kommerziellen Support. Sie k&ouml;nnen jedoch &uuml;ber folgende M&ouml;glichkeiten Hilfe zu dem Modul erhalten:</p>
<ul>
<li>F&uuml;r die letzte Version dieses Moduls, FAQs oder dem Versand eines Fehlerreports  besuchen Sie bitte <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Eine weitere Diskussion zu diesem Modul ist auch in den Foren von <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple</a> zu finden.</li>
<li>Der Autor, Paul Lemke, ist h&auml;ufig im <a href=&quot;irc://irc.freenode.net/#cms&quot;>CMS IRC Channel</a> zu finden. (Username: pyrox).</li>
<li>Letztlich erreichen Sie den Autor auch &uuml;ber eine direkte Email.</li>
</ul>
<p>Nach der GPL wird diese Software so ver&ouml;ffentlicht, wie sie ist. Bitte lesen Sie den 
Lizenztext f&uuml;r den vollen Haftungsausschluss.</p>
<h3>Copyright und Lizenz</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. Alle Rechte vorbehalten.</p>
<p>Dieses Modul wurde unter der <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a> ver&ouml;ffentlicht. Sie m&uuml;ssen dieser Lizenz zustimmen, bevor Sie das Modul verwenden.</p>
';
$lang['utmz'] = '156861353.1165420301.96.55.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php|utmcmd=referral';
$lang['utma'] = '156861353.717462736.1147511856.1165420301.1165853995.97';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['info_event_OnNewUser'] = 'G&eacute;n&eacute;r&eacute; quand un nouvel utilisateur s&#039;inscrit &agrave; une ou plusieurs listes';
$lang['info_event_OnEditUser'] = 'G&eacute;n&eacute;r&eacute; quand un utilisateur est modifi&eacute; aussi bien dans l&#039;admin que sur le front';
$lang['info_event_OnDeleteUser'] = 'G&eacute;n&eacute;r&eacute; quand un utilisateur est d&eacute;truit';
$lang['info_event_OnNewList'] = 'G&eacute;n&eacute;r&eacute; quand une mailing liste est modifi&eacute;e';
$lang['info_event_OnDeleteList'] = 'G&eacute;n&eacute;r&eacute; quand une mailing liste est d&eacute;truite';
$lang['info_event_OnCreateMessage'] = 'G&eacute;n&eacute;r&eacute; quand une mailing liste est cr&eacute;e';
$lang['info_event_OnEditMessage'] = 'G&eacute;n&eacute;r&eacute; quand un message est modifi&eacute;';
$lang['info_event_OnDeleteMessage'] = 'G&eacute;n&eacute;r&eacute; quand un message est d&eacute;truit';
$lang['info_event_OnCreateJob'] = 'G&eacute;n&eacute;r&eacute; quand une t&acirc;che est cr&eacute;e';
$lang['info_event_OnDeleteJob'] = 'G&eacute;n&eacute;r&eacute; quand une t&acirc;che est d&eacute;truit';
$lang['info_event_OnStartJob'] = 'G&eacute;n&eacute;r&eacute; quand une t&acirc;che d&eacute;marre';
$lang['info_event_OnFinishJob'] = 'G&eacute;n&eacute;r&eacute; quand une t&acirc;che est termin&eacute;e';
$lang['help_OnNewUser'] = '<p>Un &eacute;v&eacute;nement g&eacute;n&eacute;r&eacute; quand un nouvel utilisateur s&#039;incrit &agrave; une ou plusieurs listes</p>
<h4>Param&egrave;tres</h4>
<ul>
<li><em>email</em> - adresse email de l&#039;utilisateur</li>
<li><em>Nom de l&#039;utilisateur</em> - Nom de l&#039;utilisateur</li>
<li><em>listes</em> - Tableau des listes de menbres (array)</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>Un &eacute;v&eacute;nement g&eacute;n&eacute;r&eacute; quand un utilisateur est modifi&eacute; aussi bien dans la partie administration que dans la partie publique</p>
<h4>Parametres</h4>
<ul>
<li><em>email</em> - Adresse email de l&#039;utilisateur</li>
<li><em>username</em> - Nom de l&#039;utilisateur</li>
<li><em>lists</em> - Tableau (array) des listes de menbres</li>
<li><em>id</em> - L&#039;identifiant de l&#039;utilsateur</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>Un &eacute;v&eacute;nement g&eacute;n&eacute;r&eacute; quand un utilisateur est supprim&eacute;</p>
<h4>Parametres</h4>
<ul>
<li><em>id</em> - L&#039;identifiant de l&#039;utilisateur</li>
</ul>
';
$lang['help_OnNewList'] = '<p>Un &eacute;v&eacute;nement g&eacute;n&eacute;r&eacute; quand une nouvelle liste de diffusion est cr&eacute;&eacute;e</p>
<h4>Parametres</h4>
<ul>
<li><em>name</em> - Le nom de la liste</li>
<li><em>description</em> - Description de la liste</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '<p>Un &eacute;v&eacute;nement g&eacute;n&eacute;r&eacute; quand une liste de diffusion est modifi&eacute;e</p>
<h4>Parametres</h4>
<ul>
<li><em>name</em> - Le nom de la liste</li>
<li><em>description</em> - Description de la liste</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - L&#039;identifiant de la liste</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'Vous devez entrer une r&eacute;ponse pour l&#039;adresse email, le nom de l&#039;exp&eacute;diteur, le message et le sujet.';
$lang['error_dberror'] = 'Erreur de base de donn&eacute;e';
$lang['invalidparam'] = 'Param&egrave;tre invalides dans le tag du module NMS';
$lang['prompt_users_per_page'] = 'Nombres d&#039;utilisateurs &agrave; afficher sur chaque page des listes d&#039;utilisateurs';
$lang['disabled'] = 'D&eacute;sactiv&eacute;';
$lang['confirmed'] = 'Confirm&eacute;';
$lang['prompt_usersettings_text2'] = 'Texte affich&eacute; apr&eacute;s la soumission du formulaire des r&eacute;glages utilisateurs';
$lang['prompt_usersettings_form2'] = 'Formulaire affich&eacute; aux utilisateurs d&eacute;sirant changer leurs r&eacute;glages';
$lang['prompt_usersettings_text'] = 'Texte affich&eacute; apr&eacute;s l&#039;envoi du message de r&eacute;glage utilisateur';
$lang['prompt_usersettings_email_body'] = 'Corps (body) du mail de r&eacute;glage utilisateur';
$lang['prompt_usersettings_subject'] = 'Sujet du mail de r&eacute;glage utilisateur';
$lang['prompt_usersettings_form'] = 'Formulaire demandant aux utilisateurs qui veulent changer leurs r&eacute;glages leur adresse email';
$lang['prompt_post_unsubscribe_text'] = 'Texte affich&eacute; une fois la d&eacute;sinscription r&eacute;alis&eacute;';
$lang['user_settings'] = 'R&eacute;glages utilisateurs';
$lang['prompt_unsubscribe_prompt'] = 'Invitation demandant &agrave; l&#039;utilisateur son email pour le d&eacute;sinscrire';
$lang['prompt_unsubscribe_text'] = 'Texte affich&eacute; une fois le formulaire de d&eacute;sinscription rempli';
$lang['prompt_unsubscribe_subject'] = 'Sujet de l&#039;email envoy&eacute; pour la d&eacute;sinscription';
$lang['prompt_unsubscribe_email_body'] = 'Corps (body) de l&#039;email envoy&eacute; pour la d&eacute;sinscription';
$lang['prompt_unsubscribe_form'] = 'Gabarit pour le formulaire de d&eacute;sinscription';
$lang['error_accountdisabled'] = 'Nous sommes d&eacute;sol&eacute;, mais votre compte a &eacute;t&eacute; d&eacute;sactiv&eacute; et cette action n&#039;est pas possible en ce moment.';
$lang['error_insufficientparams'] = 'Un ou plusieurs param&egrave;tres requis sont manquants dans la r&eacute;qu&ecirc;te. Cette action ne peut &ecirc;tre accompli.';
$lang['prompt_post_confirm_text'] = 'Message affich&eacute; apr&eacute;s l&#039;email de confirmation';
$lang['prompt_confirm_email_body'] = 'Corps (body) de l&#039;email de confirmation';
$lang['prompt_confirm_subject'] = 'Sujet de l&#039;email de confirmation';
$lang['confirm_subscribe'] = 'Confirmer l&#039;inscription';
$lang['confirm_unsubscribe'] = 'Confirmer la d&eacute;sinscription';
$lang['nolists'] = 'Aucun listes trouv&eacute;es pour s&#039;inscrire';
$lang['public'] = 'Publi';
$lang['yes'] = 'Oui';
$lang['no'] = 'Non';
$lang['prompt_postsubscribetext'] = 'Message affich&eacute; apr&eacute;s l&#039;inscription';
$lang['subscription_confirmed'] = 'Inscription confirm&eacute;';
$lang['reset'] = 'R&eacute;initialisation';
$lang['suspend'] = 'Pause';
$lang['resume'] = 'Continue';
$lang['action'] = 'Action';
$lang['processing_records'] = 'Proc&eacute;de &agrave; l&#039;enregistrement %s &agrave; %s';
$lang['initializing_job'] = 'Initialisation de la t&acirc;che';
$lang['processing_job'] = 'Effectue la t&acirc;che';
$lang['deletecompleted'] = 'D&eacute;truire les t&acirc;ches accomplies';
$lang['error_importerrorcount'] = 'Erreur de comptage';
$lang['lines'] = 'Lignes';
$lang['users_added'] = 'Utilisateurs ajout&eacute;s';
$lang['memberships'] = 'Adh&eacute;sion';
$lang['subscribe'] = 'S&#039;inscrire';
$lang['resetdefaults'] = 'R&eacute;initialisation aux r&eacute;glages par d&eacute;faut';
$lang['confirm_adjustsettings'] = 'Etes-vous sur de vouloir changer ces r&eacute;glages ?';
$lang['confirm_resetdefaults'] = 'Etes-vous sur de vouloir r&eacute;initialiser ce formulaire aux valeurs syst&egrave;mes par d&eacute;faut';
$lang['prompt_subscribetext'] = 'Texte d&#039;inscription';
$lang['prompt_subscribesubject'] = 'Sujet d&#039;inscription';
$lang['prompt_subscribe_email_body'] = 'Corps du mail d&#039;inscription';
$lang['prompt_subscribe_form'] = 'Gabarit pour le formulaire d&#039;inscription';
$lang['subscribe_form'] = 'Inscription';
$lang['unsubscribe_form'] = 'D&eacute;sinscription';
$lang['error_insertinglist'] = 'Probl&egrave;me lors de la cr&eacute;ation de la liste';
$lang['error_emailexists'] = 'Cette adresse email existe d&eacute;ja dans la liste d&#039;utilisateurs';
$lang['error_invalidusername'] = 'Nom d&#039;utilisateur invalide';
$lang['error_invalidid'] = 'Identifiant (id) unique invalide';
$lang['username'] = 'Nom d&#039;utilisateur';
$lang['name'] = 'Nom';
$lang['prompt_public'] = 'Mailing liste publique';
$lang['error_usernotfound'] = 'Ne pas trouver l&#039;utilisateur avec l&#039;identifiant sp&eacute;cifi&eacute;';
$lang['prompt_ms_between_message_sleep'] = 'D&eacute;lais (en millisecondes) entre l&#039;envoi de chaque message';
$lang['prompt_between_batch_sleep'] = 'D&eacute;lais (en seconde) entre chaque op&eacute;ration';
$lang['prompt_messages_per_batch'] = 'Le nombre maximum de messages &agrave; envoy&eacute; dans un batch';
$lang['okclosewindow'] = 'Vous pouvez maintenant fermer cette fen&ecirc;tre';
$lang['queuefinished'] = 'Fin du traitement de la file d&#039;attente';
$lang['totaltime'] = 'Temps d&#039;&eacute;x&eacute;cution total:';
$lang['seconds'] = 'Secondes';
$lang['totalmails'] = 'Nombre total d&#039;email envoy&eacute; (administrateur inclus):';
$lang['page'] = 'Page';
$lang['of'] = 'de';
$lang['info_csvformat'] = 'Le fichier import&eacute; doit &ecirc;tre au format CVS (valeur s&eacute;par&eacute; par des virgules), une entr&eacute;e par ligne. Le premier champ devrait &ecirc;tre une adresse email, le deuxi&egrave;me champ un nom d&#039;utilisateur, et le troisi&egrave;me un nom de list. Les adresses email pourrait &ecirc;tre r&eacute;p&eacute;t&eacute; sur les lignes subsequent (en particulier pour des listes diff&eacute;rentes).';
$lang['prompt_lines'] = 'Lignes import&eacute;es';
$lang['prompt_usersadded'] = 'Utilisateur ajout&eacute;';
$lang['prompt_membershipsadded'] = 'Adh&eacute;sion ajout&eacute;e';
$lang['prompt_errorcount'] = 'Nombre d&#039;erreurs';
$lang['importerror_cantgetuserid'] = 'Erreur &agrave; la ligne %s, impossible de r&eacute;cup&eacute;rer l&#039;identifiant utilisateur %s';
$lang['importerror_cantcreateuser'] = 'Erreur &agrave; la ligne %s, impossible de cr&eacute;er l&#039;utilisateur %s';
$lang['importerror_nosuchlist'] = 'Erreur &agrave; la ligne %s, aucune liste existante %s';
$lang['importerror_nofields'] = 'Erreur &agrave; la ligne %s, pas assez de champs';
$lang['import_users'] = 'Utilisateurs import&eacute;s depuis le fichier CVS';
$lang['error_emptyfile'] = 'ERREUR - Un fichier vide a &eacute;t&eacute; charg&eacute;';
$lang['error_nofilesuploaded'] = 'ERREUR - aucun fichier n&#039;a &eacute;t&eacute; charg&eacute;';
$lang['filename'] = 'Nom du fichier d&#039;import';
$lang['title_users_import'] = 'Importer des utilisateurs';
$lang['nummessages'] = '# de Messages';
$lang['created'] = 'Cr&eacute;e';
$lang['started'] = 'D&eacute;marr&eacute;';
$lang['finished'] = 'Termin&eacute;';
$lang['processjobs'] = 'Ex&eacute;cuter la t&acirc;che';
$lang['status_error'] = 'ERREUR';
$lang['status_unstarted'] = 'Non d&eacute;marr&eacute;';
$lang['status_inprogress'] = 'En cours';
$lang['status_paused'] = 'En pause';
$lang['status_complete'] = 'Termin&eacute;';
$lang['status_unknown'] = 'Inconnu';
$lang['error_jobnameexists'] = 'ERREUR - Une t&acirc;che avec ce nom existe d&eacute;ja';
$lang['createjob'] = 'Cr&eacute;er une t&acirc;che';
$lang['prompt_email_user_on_admin_subscribe'] = 'Envoyer un email aux utilisateurs quand l&#039;administrateur ajoute manuellement des adh&eacute;sions &agrave; une liste';
$lang['error_nomessagesselected'] = 'Aucun message s&eacute;lectionn&eacute;';
$lang['error_nolistsselected'] = 'Aucune liste s&eacute;lectionn&eacute;';
$lang['createjobmsg'] = 'S&eacute;lectionner un message, et une ou plusieurs listes pour envoyer le message';
$lang['error_nojobname'] = 'ERREUR - Aucun nom de t&acirc;che sp&eacute;cifier';
$lang['error_nolists'] = 'ERREUR - Aucunes listes!';
$lang['error_nomessages'] = 'ERREUR - Aucun message!';
$lang['jobs'] = 'T&acirc;che';
$lang['status'] = 'Statut';
$lang['jobsfoundtext'] = 'T&acirc;ches trouv&eacute;es';
$lang['messagesfoundtext'] = 'Messages trouv&eacute;s';
$lang['entered'] = 'Entr&eacute;';
$lang['subject'] = 'Sujet';
$lang['from'] = 'Exp&eacute;diteur';
$lang['delete_user_confirm'] = 'Etes-vous sur de vouloir supprimer cet utilisateur';
$lang['info_singlelist'] = 'Cet utilisateur sera ajout&eacute; &agrave; la liste s&eacute;lectionn&eacute;';
$lang['error_selectonelist'] = 'ERREUR - Vous devez s&eacute;lectionner au moins une liste';
$lang['error_invalidemail'] = 'ERREUR - Adresse email invalide';
$lang['userid'] = 'Identifiant utilisateur';
$lang['emailaddress'] = 'Adresse email';
$lang['usersfoundtext'] = 'Utilisateurs trouv&eacute;s';
$lang['title_user_createnew'] = 'Ajouter un utilisateur';
$lang['error_invalidlistname'] = 'ERREUR - Nom de liste invalide';
$lang['editlist_text'] = 'Modifier la liste';
$lang['id'] = 'Identifiant (ID)';
$lang['listsfoundtext'] = 'Listes trouv&eacute;es';
$lang['users'] = 'Utilisateurs &quot;';
$lang['preferences'] = 'Pr&eacute;f&eacute;rences';
$lang['messages'] = 'Messages';
$lang['queue'] = 'File d&#039;attente';
$lang['submit'] = 'Envoyer';
$lang['description'] = 'Description';
$lang['createnewlist_text'] = 'Cr&eacute;er une liste';
$lang['lists'] = 'Listes';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Merci d&#039;avoir installer NMS. V&eacute;rifier que vous avez bien la permission &quot;Use NMS&quot; pour utiliser ce module!';
$lang['postuninstall'] = 'Newsletter Made Simple d&eacute;sinstall&eacute;.';
$lang['uninstalled'] = 'Module d&eacute;sinstall&eacute;.';
$lang['installed'] = 'Version du module %s install&eacute;.';
$lang['prefsupdated'] = 'Les pr&eacute;f&eacute;rences de Newsletter Made Simple Module ont &eacute;t&eacute; mises &agrave; jour.';
$lang['newslettercreated'] = 'Une nouvelle newsletter a &eacute;t&eacute; cr&eacute;e. ';
$lang['no_email_error'] = 'Vous devez rentrer une adresse email.';
$lang['subscribe_thankyou'] = 'Mercide votre inscription. Un email de confirmation vous a &eacute;t&eacute; envoy&eacute;.';
$lang['enter_valid_email'] = 'Vous devez entrer une adresse email valide et s&eacute;lectionner au moins une liste.';
$lang['newslettercreatederror'] = 'Vous devez entrer un nom et une description.';
$lang['accessdenied'] = 'Acc&eacute;s refus&eacute;. Merci de v&eacute;rifier vos permissions.';
$lang['error'] = 'Erreur!';
$lang['sent'] = 'Envoy&eacute;';
$lang['inqueue'] = 'En file d&#039;attente';
$lang['send_next_batch'] = 'Envoi du prochain batch de %s emails; starting at: %s';
$lang['messages_sent'] = '%s ont &eacute;t&eacute; envoy&eacute;';
$lang['closewindow'] = 'Fermer la fen&ecirc;tre';
$lang['testmode'] = 'Vous &ecirc;tes en mode test. Aucun email ne sera envoy&eacute;.';
$lang['confirmdeletejob'] = 'Etes-vous sur de vouloir d&eacute;truire cette t&acirc;che ?';
$lang['confirmsend'] = 'Etes-vous sur de vouloir envoyer tous les messages ?';
$lang['confirmdelete'] = 'Etes-vous sur de vouloir d&eacute;truire ce message?';
$lang['confirmdeletelist'] = 'Etes-vous sur de vouloir d&eacute;truire cette liste?';
$lang['keepwindowopen'] = 'Merci de laisser cette fen&ecirc;tre ouverte jusqu&#039;&agrave; l&#039;envoi de tous les messages.<br>';
$lang['profileupdated'] = 'Votre profil a &eacute;t&eacute; mis &agrave; jour.';
$lang['upgraded'] = 'Module mis &agrave; jour &agrave; la version %s.';
$lang['title_mod_prefs'] = 'Configuration';
$lang['title_mod_messages'] = 'File d&#039;attente des messages';
$lang['title_mod_createnew'] = 'Cr&eacute;er une liste';
$lang['title_mod_manage_user'] = 'Utilisateurs';
$lang['title_mod_compose_job'] = 'Cr&eacute;er une t&acirc;che';
$lang['title_mod_compose_message'] = 'Composer un message';
$lang['title_mod_process_queue'] = 'Ex&eacute;cute la file d&#039;attente';
$lang['title_mod_admin'] = 'G&eacute;rer les listes';
$lang['user_delete_confirm'] = 'Etes-vous sur de vouloir supprimer cet utilisateur';
$lang['userdeleted'] = 'Utilisateur supprim&eacute;';
$lang['newsletterdeleted'] = 'Newsletter supprim&eacute;';
$lang['delete'] = 'Supprimer';
$lang['edit'] = 'Modifier';
$lang['previous'] = 'Pr&eacute;c&eacute;dent';
$lang['next'] = 'Suivant';
$lang['unsubscribemessage'] = 'Vous avez &eacute;t&eacute; d&eacute;sincrit. Merci';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Ce module vous permet de cr&eacute;er un syst&egrave;me de newsletter';
$lang['welcome_text'] = '<p>Bienvenue dans la partie administration du module Newsletter Made Simple (MNS) </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users Tab - Filtering on list membership (maybe regexp later)</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as diabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0 July, 2006.  
<p>This is essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and brought up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>
<h3>How do I use it?</h3>
<p>1. Install the module.<br>
2. Allow the correct people permissions to access NMS<br>
3. Configure NMS using the &quot;configuration&quot; panel in the NMS Module. <br>
<ul>
<li>There are numerous templates and prompts that can be customized for your installation</li>
</ul>
4. Create a list or two or three<br>
<ul>
<li>You can create private lists and public lists.  Users can subscribe and unsubscribe at any time from public lists, and they are shown in the front end</li>
<li>Membership in private lists is controlled by the administrator, and users cannot unsubscribe from them</li>
</ul>
5. Insert the module code into a template or content page using syntax below.<br>
6. Write one or more messages which will be saved into the message &quot;queue&quot;.<br>
7. Create a job by selecting a message, and one or more lists.<br/>
&nbsp;&nbsp;<strong>Note:</strong> Users will only be sent one message even if they are a member of multiple selected groups<br/>
8. Process the queue to send the messages out.</p>
<h3>Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.1017437260.1147251034.1156929761.1157013124.53';
$lang['utmz'] = '156861353.1156514528.47.26.utmccn=(referral)|utmcsr=cefim-formation.net|utmcct=/joue/admin/moduleinterface.php|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['cleantemptable'] = 'Pulisci la tabella temporanea';
$lang['error_problemwithmessage'] = 'Problemi non specificati nel messaggio.';
$lang['prompt_usersettings_page'] = 'Pagina da visualizzare per il modulo delle Impostazioni Utente';
$lang['info_usersettings_page'] = 'Pagina da visualizzare quando in una mail viene cliccato il link per modificare le preferenze utente.<br/>Il simbolo (*) indica la pagina di default.';
$lang['jobname'] = 'Processo creato il';
$lang['msg_jobprocessing'] = 'Finestra di Esecuzione Processi';
$lang['prompt_page'] = 'Pagina di ritorno';
$lang['error_insufficientparams'] = 'Uno o pi&ugrave; parametri richiesti sono mancanti. Questa azione non pu&ograve; continuare.';
$lang['prompt_from'] = 'Da';
$lang['prompt_replyto'] = 'Rispondi a';
$lang['prompt_subject'] = 'Oggetto';
$lang['prompt_template'] = 'Modello';
$lang['prompt_selectstatus'] = 'Seleziona Stato';
$lang['prompt_message'] = 'Messaggio';
$lang['prompt_userfilter'] = 'Filtro Email (regexp)';
$lang['prompt_listfilter'] = 'Filtro sulla lista dei membri';
$lang['info_listfilter'] = '<strong>Nota:</strong> Tenete premuto il tasto CTRL e cliccate sugli elementi per selezionarli e deselezionarli.
';
$lang['message_help'] = 'Quando digitate un messaggio avete a disposizione le seguenti variabili <em>smarty</em>:<br/>
<em>{$username}</em> - Il nome dell&#039;utente<br/>
<em>{$email}</em> - L&#039;indirizzo email dell&#039;utente<br/>
<em>{$unsubscribe}</em> - L&#039;URL usata per visualizzare la pagina di cancellazione della sottoscrizione<br/>
<em>{$preferences}</em> - L&#039;URL usata per visualizzare la pagina delle impostazioni utente<br/>
<em>{$confirmurl}</em> - L&#039;URL usata per confermare la sottoscrizione<br/>
<strong>Nota:</strong>&nbsp; Quando scrivete un messaggio in formato HTML e <em>non</em> usate un modello di pagina, dovete inserire i tag HTML appropriati (html,head,body,etc).<br/>
<strong>Nota:</strong>&nbsp; Quando usate un modello come modello di pagina dovete inserire {$message_text} al posto di {content} nel vostro modello.
';
$lang['applyfilter'] = 'Filtro';
$lang['info_event_OnNewUser'] = 'Generato quando un nuovo utente sottoscrive una o pi&ugrave; mailing list';
$lang['info_event_OnEditUser'] = 'Generato quando un utente &egrave; modificato o nel pannello di amministrazione o nel front end';
$lang['info_event_OnDeleteUser'] = 'Generato quando un utente &egrave; rimosso';
$lang['info_event_OnNewList'] = 'Generato quando una mailing list &egrave; modificata';
$lang['info_event_OnDeleteList'] = 'Generato quando una mailing list &egrave; rimossa';
$lang['info_event_OnCreateMessage'] = 'Generato quando una mailing list &egrave; creata';
$lang['info_event_OnEditMessage'] = 'Generato quando un messaggio &egrave; modificato';
$lang['info_event_OnDeleteMessage'] = 'Generato quando un messaggio &egrave; cancellato';
$lang['info_event_OnCreateJob'] = 'Generato quando un job &egrave; creato';
$lang['info_event_OnDeleteJob'] = 'Generato quando un job &egrave; cancellato';
$lang['info_event_OnStartJob'] = 'Generato quando il processo di un job &egrave; iniziato';
$lang['info_event_OnFinishJob'] = 'Generato quando il processo di un job &egrave; terminato';
$lang['help_OnNewUser'] = '<p>Un evento generato quando un nuovo utente si iscrive ad una o pi&ugrave; mailing list.</p>
<h4>Parametri</h4>
<ul>
<li><em>email</em> - Indirizzo email dell&#039;utente</li>
<li><em>username</em> - Nome dell&#039;utente</li>
<li><em>lists</em> - Array delle liste a cui &egrave; iscritto</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>Un evento generato quando un utente viene modificato sia tramite admin che il frontend</p>
<h4>Parametri</h4>
<ul>
<li><em>email</em> - Indirizzo email dell&#039;utente</li>
<li><em>username</em> - Nome dell&#039;utente</li>
<li><em>lists</em> - Array delle liste a cui &egrave; iscritto</li>
<li><em>id</em> - ID dell&#039;utente</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>Evento generato quando l&#039;utente viene eliminato</p>
<h4>Parametri</h4>
<ul>
<li><em>id</em> - ID dell&#039;utente</li>
</ul>
';
$lang['help_OnNewList'] = '<p>Evento generato quando una nuova mailing list viene creata</p>
<h4>Parametri</h4>
<ul>
<li><em>name</em> - Il nome</li>
<li><em>description</em> - Descrizione della lista</li>
<li><em>public</em> - Flag Pubblico</li>
</ul>
';
$lang['help_OnEditList'] = '<p>Evento generato quando una mailing list viene modificata</p>
<h4>Parametri</h4>
<ul>
<li><em>name</em> - Il nome</li>
<li><em>description</em> - Descrizione della lista</li>
<li><em>public</em> - Casella lista Pubblica</li>
<li><em>listid</em> - ID della lista</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>Evento generato quando una mailing list viene eliminata</p>
<h4>Parametri</h4>
<ul>
<li><em>listid</em> - ID della lista</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>Evento generato quando un messaggio viene creato</p>
<h4>Parametri</h4>
<ul>
<li><em>fromwho</em> - Nome della persona da cui arriva il messaggio</li>
<li><em>reply_to</em> - Indirizzo email a cui fare replay</li>
<li><em>subject</em> -Soggetto del messaggio</li>
<li><em>message</em> - Corpo del messaggio <em>(pu&ograve; contenere tag di smarty)</em></li>
<li><em>entered</em> - Data di quando il messaggio &egrave; stato inserito</li>
<li><em>uniqueid</em> - ID  univoco del messaggio</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>Evento generato quando un messaggio viene modificato</p>
<h4>Parametri</h4>
<ul>
<li><em>fromwho</em> - Nome della persona da cui arriva il messaggio</li>
<li><em>reply_to</em> - Indirizzo email a cui fare replay</li>
<li><em>subject</em> -Soggetto del messaggio</li>
<li><em>message</em> - Corpo del messaggio <em>(pu&ograve; contenere tag di smarty)</em></li>
<li><em>uniqueid</em> - ID  univoco del messaggio</em>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>Evento generato quando un messaggio viene eliminato</p>
<h4>Parametri</h4>
<ul>
<li><em>uniqueid</em> - ID  univoco del messaggio che &egrave; stato eliminato</em>
</ul>
';
$lang['help_OnCreateJob'] = '<p>Evento generato quando un nuovo job viene creato</p>
<h4>Parametri</h4>
<ul>
<li><em>jobid</em> - ID del job appena creato</li>
<li><em>jobname</em> - Nome del job</li>
<li><em>lists</em> - Array con ID delle liste</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>Evento generato quando un job viene eliminato</p>
<h4>Parametri</h4>
<ul>
<li><em>jobid</em> - ID del job eliminato</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>Evento generato quando l&#039;elaborazione di un job ha inizio</p>
<h4>Parametri</h4>
<ul>
<li><em>jobid</em> - ID del job appena creato</li>
<li><em>jobname</em> - Nome del job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>Evento generato quando l&#039;elaborazione di un job termina</p>
<h4>Parametri</h4>
<ul>
<li><em>jobid</em> - ID del job appena creato</li>
<li><em>jobname</em> - Nome del job</li>
</ul>
';
$lang['error_needreplyto'] = 'Dovete inserire un indirizzo email di replica valido.';
$lang['error_needfrom'] = 'Dovete inserire un nome valido come mittente del messaggio';
$lang['error_needsubject'] = 'Dovete inserire un Oggetto della mail valido';
$lang['error_needmessagetext'] = 'Dovete inserire qualcosa come corpo della mail';
$lang['error_formerror'] = 'Errore del modulo';
$lang['error_dberror'] = 'Errore nel database';
$lang['invalidparam'] = 'Parametro non valido nel tag del modulo NMS';
$lang['prompt_users_per_page'] = 'Numero di utenti da visualizzare su ciascuna pagina della lista utenti';
$lang['disabled'] = 'Disabilitato';
$lang['confirmed'] = 'Confermato';
$lang['prompt_usersettings_text2'] = 'Testo visualizzato dopo che il modulo delle configurazioni utente &egrave; stato inviato';
$lang['prompt_usersettings_form2'] = 'Modulo mostrato agli utenti che vogliono cambiare le loro preferenze';
$lang['prompt_usersettings_text'] = 'Testo visualizzato dopo che il messaggio delle configurazioni utente &egrave; stato spedito';
$lang['prompt_usersettings_email_body'] = 'Corpo della mail delle configurazioni utente';
$lang['prompt_usersettings_subject'] = 'Oggetto della mail delle configurazioni utente';
$lang['prompt_usersettings_form'] = 'Modulo che chiede l&#039;indirizzo email all&#039;utente che vuole cambiare le sue prefernze';
$lang['prompt_post_unsubscribe_text'] = 'Testo mostrato dopo che la procedura di iscrizione viene ultimata';
$lang['user_settings'] = 'Impostazioni Utente';
$lang['prompt_unsubscribe_prompt'] = 'Modulo che chiede all&#039;utente l&#039;indirizzo email per eseguire la cancellazione della sottoscrizione';
$lang['prompt_unsubscribe_text'] = 'Testo mostrato quando la procedura di cancellazione della sottoscrizione viene ultimata';
$lang['prompt_unsubscribe_subject'] = 'Soggetto della mail mandata per la procedura di cancellazione della sottoscrizione';
$lang['prompt_unsubscribe_email_body'] = 'Corpo della mail mandata per la procedura di cancellazione della sottoscrizione';
$lang['prompt_unsubscribe_form'] = 'Modello per il modulo di cancellazione della sottoscrizione';
$lang['error_accountdisabled'] = 'Siamo spiacenti, ma il vostro account &egrave; stato sospeso e quindi questa azione non al momento possibile';
$lang['prompt_post_confirm_text'] = 'Messaggio mostrato dopo la conferma dell&#039;e-mail';
$lang['prompt_confirm_email_body'] = 'Corpo della mail di conferma';
$lang['prompt_confirm_subject'] = 'Soggetto della mail di conferma';
$lang['confirm_subscribe'] = 'Conferma Iscrizione';
$lang['confirm_unsubscribe'] = 'Conferma Cancellazione';
$lang['nolists'] = 'Nessuna lista trovata per l&#039;iscrizione';
$lang['public'] = 'Pubblico';
$lang['yes'] = 'S&igrave;';
$lang['no'] = 'No';
$lang['prompt_postsubscribetext'] = 'Messaggio mostrato dopo l&#039;iscrizione';
$lang['subscription_confirmed'] = 'Iscrizione confermata';
$lang['reset'] = 'Annulla';
$lang['suspend'] = 'Sospendi';
$lang['resume'] = 'Riprendi';
$lang['action'] = 'Azione';
$lang['processing_records'] = 'Elaborazione record %s a %s';
$lang['initializing_job'] = 'Inizializzo il Processo';
$lang['processing_job'] = 'Elaborazione del Processo';
$lang['deletecompleted'] = 'Elimina Processi completati';
$lang['error_importerrorcount'] = 'Conteggio Errori';
$lang['lines'] = 'Linee';
$lang['users_added'] = 'Utenti aggiunti';
$lang['memberships'] = 'Membri';
$lang['subscribe'] = 'Sottoscrivi';
$lang['resetdefaults'] = 'Ripristina il predefinito';
$lang['confirm_adjustsettings'] = 'Siete sicuri di voler cambiare queste impostazioni?';
$lang['confirm_resetdefaults'] = 'Siete sicuri di volere ripristinare i valori predefiniti di sistema?';
$lang['prompt_subscribetext'] = 'Testo della sottoscrizione';
$lang['prompt_subscribesubject'] = 'Oggetto della sottoscrizione';
$lang['prompt_subscribe_email_body'] = 'Corpo della mail di sottoscrizione';
$lang['prompt_subscribe_form'] = 'Modello per il modulo di sottoscrizione';
$lang['subscribe_form'] = 'Sottoscrivi';
$lang['unsubscribe_form'] = 'Cancella Sottoscrizione';
$lang['error_insertinglist'] = 'Problema durante la creazione della nuova lista';
$lang['error_emailexists'] = 'Questo indirizzo email risulta gi&agrave; presente nella lista utenti';
$lang['error_invalidusername'] = 'Nome utente non valido';
$lang['error_invalidid'] = 'ID univoco invalido';
$lang['username'] = 'Nome utente';
$lang['name'] = 'Nome';
$lang['prompt_public'] = 'Questa &egrave; una mailing list pubblica';
$lang['error_usernotfound'] = 'Non trovo un utente con l&#039;ID univoco specificato';
$lang['prompt_ms_between_message_sleep'] = 'Ritardo (in millisecondi) fra la spedizione dei messaggi';
$lang['prompt_between_batch_sleep'] = 'Ritardo (in secondi) fra ciascuna organizzazione di invio';
$lang['prompt_messages_per_batch'] = 'Il massimo numero di messaggi da spedire in un gruppo di invio';
$lang['okclosewindow'] = 'Ora potete chiudere questa finestra';
$lang['queuefinished'] = 'Esecuzione della coda di uscita terminata';
$lang['totaltime'] = 'Tempo totale di esecuzione:';
$lang['seconds'] = 'Secondi';
$lang['totalmails'] = 'Email totali spediti (incluso all&#039;amministratore):';
$lang['page'] = 'Pagina';
$lang['of'] = 'di';
$lang['info_csvformat'] = 'Il file da importare deve essere in formato CSV (comma separated value, valori separati da virgola), un elemento per riga.<br />
Le colonne sono:<br /><br />
id univoco, indirizzo email, username, nome della lista, attivo.<br /><br />
Gli indirizzi email possono essere ripetuti su pi&ugrave; linee (particolarmente per differenti liste).';
$lang['prompt_lines'] = 'Linee importate';
$lang['prompt_usersadded'] = 'Utenti aggiunti';
$lang['prompt_membershipsadded'] = 'Membro aggiunto';
$lang['prompt_errorcount'] = 'Numero di errori';
$lang['importerror_cantgetuserid'] = 'Errore alla linea %s, non riesco a ottenere lo ID utente %s';
$lang['importerror_cantcreateuser'] = 'Errore alla linea %s, non riesco a creare l&#039;utente %s';
$lang['importerror_nosuchlist'] = 'Errora alla linea %s, nessuna lista %s';
$lang['importerror_nofields'] = 'Errore alla linea %s, campi insufficienti';
$lang['import_users'] = 'Utenti importati da CSV';
$lang['error_emptyfile'] = 'ERRORE- &egrave; stato caricato un file vuoto';
$lang['error_nofilesuploaded'] = 'ERRORE- nessun file &egrave; stato caricato';
$lang['filename'] = 'Importa nomefile';
$lang['title_users_import'] = 'Importa utenti';
$lang['title_users_export'] = 'Esporta utenti dal database';
$lang['nummessages'] = '# di Messaggi';
$lang['created'] = 'Creato';
$lang['started'] = 'Iniziato';
$lang['finished'] = 'Finito';
$lang['processjobs'] = 'Esecuzione dei job';
$lang['status_error'] = 'ERRORE';
$lang['status_unstarted'] = 'Non iniziato';
$lang['status_inprogress'] = 'In esecuzione';
$lang['status_paused'] = 'In Pausa';
$lang['status_complete'] = 'Completato';
$lang['status_unknown'] = 'Sconosciuto';
$lang['error_jobnameexists'] = 'ERRORE - Esiste gi&agrave; un Job con quel nome';
$lang['createjob'] = 'Crea Job';
$lang['prompt_email_user_on_admin_subscribe'] = 'Invia una mail all&#039;utente quando viene aggiunto manualmente dall&#039;amministratore';
$lang['error_nomessagesselected'] = 'Nessun messaggio selezionato';
$lang['error_nolistsselected'] = 'Nessuna lista selezionata';
$lang['createjobmsg'] = 'Seleziona un messaggio ed una o pi&ugrave; liste a cui inviare il messaggio';
$lang['error_nojobname'] = 'ERRORE - Nessun job specificato';
$lang['error_nolists'] = 'ERRORE - Nessuna lista!';
$lang['error_nomessages'] = 'ERRORE - Nessun messaggio!';
$lang['jobs'] = 'Job';
$lang['status'] = 'Stato';
$lang['jobsfoundtext'] = 'Job trovati';
$lang['messagesfoundtext'] = 'Messaggi Trovati';
$lang['entered'] = 'Inserito';
$lang['subject'] = 'Oggetto';
$lang['from'] = 'Da';
$lang['delete_user_confirm'] = 'Siete sicuri di voler cancellare questo utente';
$lang['info_singlelist'] = 'Questo utente verr&agrave; aggiunto alla sola malinglist';
$lang['error_selectonelist'] = 'Dovete selezionare almeno una lista';
$lang['error_invaliduniqueid'] = 'ERRORE - ID univoco non valido';
$lang['error_invalidemail'] = 'ERRORE - Indirizzo email non valido';
$lang['error_couldnotfindjobpart'] = 'ERRORE - Non riesco a trovare una parte del Job richiesto nel database.  Questo pu&ograve; significare che un altro utente (voi?) sta modificando/cancellando dei Job mentre un Job &egrave; in esecuzione.';
$lang['error_couldnotfindmessage'] = 'ERRORE - Non riesco a trovare il messaggio richiesto.  Questo pu&ograve; significare che un altro utente (voi?) sta modificando/cancellando dei messaggi mentre un Job &egrave; in esecuzione.';
$lang['error_couldnotfindtemplate'] = 'ERRORE - Non riesco a trovare il modello di pagina richiesto. Questo pu&ograve; significare che il modello sia stato cancellato dopo che il messaggio &egrave; stato creato.';
$lang['error_temporarytableexists'] = 'ERRORE - La tabella temporanea del database, usata per l&#039;esecuzione dei Job, esiste gi&agrave;. Questo pu&ograve; significare un errore avvenuto durante il tentativo di esecuzione di un Job in precedenza.';
$lang['error_buildingtemptable'] = 'ERRORE - Si &egrave; verificato un errore durante il riempimento della tabella temporanea';
$lang['error_otherprocessingerror'] = 'ERRORE: Si &egrave; verificato un errore durante l&#039;esecuzione';
$lang['userid'] = 'ID utente';
$lang['emailaddress'] = 'Indirizzo email';
$lang['usersfoundtext'] = 'Utenti trovati';
$lang['title_user_createnew'] = 'Aggiungi utente';
$lang['error_invalidlistname'] = 'ERRORE- Nome lista non valido';
$lang['editlist_text'] = 'Modifica Lista';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Liste trovate';
$lang['users'] = 'Utenti';
$lang['preferences'] = 'Preferenze';
$lang['messages'] = 'Messaggi';
$lang['queue'] = 'Coda';
$lang['submit'] = 'Invia';
$lang['cancel'] = 'Cancella';
$lang['description'] = 'Descrizione';
$lang['createnewlist_text'] = 'Crea Lista';
$lang['lists'] = 'Liste';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Grazie per avere installato NMS. Accertatevi di impostare i permessi  &quot;Use NMS&quot; per utilizzare questo modulo!';
$lang['postuninstall'] = 'Newsletter Made Simple disinstallato.';
$lang['uninstalled'] = 'Modulo disinstallato.';
$lang['installed'] = 'Versione del modulo %s installata.';
$lang['prefsupdated'] = 'Preferenze del modulo aggiornate.';
$lang['newslettercreated'] = 'Una nuova newsletter &egrave; stata creata';
$lang['no_email_error'] = 'Dovete inserire un indirizzo email';
$lang['subscribe_thankyou'] = 'Grazie per esservi iscritti. Una mail di conferma &egrave; stata inviata all&#039;indirizzo da voi inserito.';
$lang['enter_valid_email'] = 'Dovete inserire un indirizzo email valido e selezionare almeno una mailing list';
$lang['newslettercreatederror'] = 'Dovete inserire un nome ed una descrizione';
$lang['accessdenied'] = 'Accesso negato. Si prega di controllare i permessi.';
$lang['error'] = 'Errore!';
$lang['sent'] = 'Spedito';
$lang['inqueue'] = 'In coda';
$lang['send_next_batch'] = 'Invio delle prossime %s email iniziando da: %s';
$lang['messages_sent'] = '%s sono stati spediti';
$lang['closewindow'] = 'Chiudi finestra';
$lang['testmode'] = 'Siete in modalit&agrave; test. Nessuna email verr&agrave; inviata';
$lang['confirmdeletejob'] = 'Siete sicuri di voler eliminare questo job';
$lang['confirmsend'] = 'Siete sicuri di voler inviare tutti i messaggi?';
$lang['confirmdelete'] = 'Siete sicuri di voler eliminare questo messaggio?';
$lang['confirmdeletelist'] = 'Siete sicuri di voler eliminare questa lista?';
$lang['keepwindowopen'] = 'Mantenete la finestra aperta sino a che tutti i messaggi non sono stati inviati<br>';
$lang['profileupdated'] = 'Il vostro profilo &egrave; stato aggiornato';
$lang['upgraded'] = 'Modulo aggiornato alla versione %s';
$lang['title_mod_prefs'] = 'Configurazione';
$lang['title_mod_messages'] = 'Coda messaggi';
$lang['title_mod_createnew'] = 'Crea una lista';
$lang['title_mod_manage_user'] = 'Utenti';
$lang['title_mod_compose_job'] = 'Crea Job';
$lang['title_mod_compose_message'] = 'Componi messaggio';
$lang['title_mod_process_queue'] = 'Coda dei processi';
$lang['title_mod_admin'] = 'Gestione Liste';
$lang['user_delete_confirm'] = 'Siete sicuri di voler cancellare questo utente?';
$lang['userdeleted'] = 'Utente cancellato';
$lang['newsletterdeleted'] = 'Newsletter cancellata';
$lang['delete'] = 'Cancella';
$lang['edit'] = 'Modifica';
$lang['previous'] = 'Precedente';
$lang['next'] = 'Prossimo';
$lang['unsubscribemessage'] = 'Siete stato cancellato. Grazie.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Questo modulo permette di creare un sistema di newsletter';
$lang['welcome_text'] = '<p>Benvenuto nella sezione amministrativa del modulo Newsletter Made Simple (MNS). </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0.1 - December, 2006</li>
<p>Fixes to import users, and to a ternery expression when creating a message. I also fixed some stupid problems with process_queue resulting from me doing this too quickly.</p>
<li>Version 1.0 - December, 2006</li>
<p>This <b>is</b> essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and attemtpts have been made to bring it up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version <em>(Including previous betas)</em>is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Specificate un elenco di mailing list separate da virgola da visualizzare.  <em>(Valido solo in modalit&agrave; subscribe)</em>';
$lang['helpmode'] = 'Specifica la modalit&agrave; di operazione. le opzioni sono:
<ul>
<li>subscribe (default) - mostra il modulo di iscrizione</li>
<li>unsubscribe - mostra il modulo di cancellazione</li>
<li>usersettings - mostra il modulo delle impostazioni utente</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>Cosa fa?  </strong></h3>
<p>Permette di avere un sistema di newsletter all&#039;interno di CMS made simple. </p>
<h3>Come si usa?</h3>
<ol>
<li>Installa il modulo.</li>
<li>Imposta correttamente i permessi ai gruppi che gestiscono le liste. Questi includono:
	<ul>
	<li>Manage NMS Lists &amp;mdash; Aggiunge, rimuove mailing lists</li>	
	<li>Manage NMS Users &amp;mdash; Aggiunge, rimuove utenti nel database</li>
	<li>Manage NMS Messages &amp;mdash; Aggiunge, modifica, rimuove messaggi ma non li spedisce</li> 	
	<li>Manage NMS Jobs &amp;mdash; Spedisce messaggi e performa altre funzioni &#039;job&#039;</li>	
	</ul>
</li>
<li>Crea una lista</li>
<li>(Opzionale) Aggiungere {cms_module module=&#039;NMS&#039;} a una pagina abilita i visitatori a registrarsi alla Vostra lista.</li>
<li>(Opzionale) Aggiungere utenti alla Vostra lista manualmente nel tab Utenti nel pannello di amministrazione</li>
<li>Create un messaggio da spedire come parte di un job</li>
<li>Create un job. Selezionate un messaggio da spedire e una lista.</li>
<li>Processa il job e il Vostro messaggio sar&agrave; spedito</li>
</ol>
<h3>Sintassi</h3>
<p>	{cms_module module=&#039;NMS&#039;}</p>

<h3>Further options</h3>

<h4>Display unsubscribe form:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;unsubscribe&#039;}</p>

<h4>Display the user settings page:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;usersettings&#039;}</p>

<h4>Display an archive of past newsletters</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;archive&#039;}</p>
<ul>
<lh>Optional parameters for the archive:</lh>
<li>show=&#039;#&#039; where <code>#</code> is the number of past newsletters to show. If omitted, all are shown</li>
<li>sortby=&#039;date&#039; &amp;mdash; <code>date</code> (default), <code>id</code> (message ID), or <code>subject</code></li>
<li>sortorder=&#039;DESC&#039; &amp;mdash; either <code>DESC</code> (descending order, default) or <code>ASC</code> (ascending order)</li>
<li>dateformat=&#039;%Y-%m-%d&#039; &amp;mdash; sets the date output format following the PHP strftime() syntax</li>
</ul>		

<h4>Import users from the Front End Users database</h4>
<p>Note: You must have a property defined in FEU that stores the users&#039; email address. It can be named whatever you want.</p>
<ol>
<li>Choose Extensions &amp;gt; Newsletter Made Simple</li>
<li>Activate the Users tab</li>
<li>At the bottom, click Import Users from FrontEndUsers</li>
<li>Select the FEU field that contains the users&#039; email addresses</li>
<li>Specify whether to copy the FEU user name to the NMS user name field. This is what would be output in your message if you included the {<span>$</span>username} placeholder.</li>
<li>Select the list to import to.</li>
<li>Click Submit.</li>
</ol>
<p>You will receive a report of the users processed, those already in your NMS database, those already on the list, and those that were added and subscribed. Users are not duplicated so there should be no harm in running an import periodically.</p>

<h3>Message variables</h3>
<p>These are covered elsewhere, but added here for completeness. If you add these to your message, they will be replaced at sending time with the appropriate true values.</p>

<ul>
<li>{<span>$</span>username}  &amp;mdash;  The user&#039;s name</li>
<li>{<span>$</span>email}  &amp;mdash;  The user&#039;s email address</li>
<li>{<span>$</span>unsubscribe}  &amp;mdash;  A URL that can be used to display a page for unsubscribing</li>
<li>{<span>$</span>preferences}  &amp;mdash;  A URL that can be used to display a user preferences page</li>
<li>{<span>$</span>confirmurl}  &amp;mdash;  A URL that can be used to confirm subscriptions</li>
</ul>


<h3>Supporto</h3>
<p>Questo modulo non prevede supporto commerciale. Tuttavia ci sono un certo numero di risorse disponibili per aiutarti:</p>
<ul>
<li>Per l&#039;ultima versione di questo modulo, FAQ, o per inviare un rapporto di Bug visita <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Ulteriori discussioni su questo modulo possono anche essere trovate su <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>L&#039;autore, Paul Lemke, pu&ograve; essere trovato spesso nel <a href=&#039;irc://irc.freenode.net/#cms&#039;>Canale IRC CMS</a> (username: pyrox).</li>
<li>Infine potresti avere qualche possibilit&agrave; di successo mandando una mail direttamente all&#039;autore.</li>  
</ul>
<p>Come per licenza GPL, questo software &egrave; fornito cos&igrave; com&#039;&egrave;. Leggete il testo della licenza per la spiegazione completa delle responsabilit&agrave;.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;>&amp;lt;lemkepf@gmx.net&amp;gt;</a>. All Rights Are Reserved.</p>
<p>Questo modulo &egrave; stato pubblicato sotto la <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. Devi accettare la licenza prima di potere usare questo modulo.</p>';
$lang['import_feu_title'] = 'Importa Utenti da FrontEndUsers';
$lang['import_feu_info'] = 'Per importare utenti dalle tabelle di FrontEndUsers dovete specificare quale campo FEU contiene l&#039;indirizzo email e se copiare i contenuti dello username FEU nel campo username di NMS';
$lang['import_feu_noproperties'] = 'Non avete definito alcuna propriet&agrave; nel modulo FrontEndUsers. Dovete definire almeno una propriet&agrave; per memorizzare gli indirizzi e-mail degli utenti';
$lang['import_feu_prompt_groupname'] = 'Gruppi del FrontEndUsers';
$lang['import_feu_prompt_copyusername'] = 'Copia nomi utenti FEU a NMS?';
$lang['import_feu_info_copyusername'] = '<em>Se nessuno &egrave; selezionato, lo username sar&agrave; lasciato vuoto.</em>';
$lang['import_feu_selectlists'] = 'Importa utenti in (nome lista)';
$lang['import_feu_feunotinstalled'] = 'Il modulo FrontEndUsers non &egrave; installato o non esiste la tabella di definizione delle propriet&agrave;. Non posso importare utenti da FEU.';
$lang['processedAddressesTitle'] = 'Indirizzi processati';
$lang['inDatabaseTitle'] = 'Sempre in NMS';
$lang['onListAlreadyTitle'] = 'Gi&agrave; iscritto';
$lang['addressSubscribedTitle'] = 'Iscritto';
$lang['listidInfo'] = 'Importa alla lista ID: ';
$lang['processedAddressesCountInfo'] = 'Indirizzi processati: ';
$lang['archive_heading'] = '<h1>Archivio di messaggi</h1>';
$lang['archivedmessage'] = '<h1>Messaggi archiviati</h1>';
$lang['archive_tbl_msgID'] = 'Msg ID';
$lang['archive_tbl_subject'] = 'Oggetto';
$lang['archive_tbl_fullurl'] = 'Link del messaggio';
$lang['archive_tbl_href'] = 'Target del link';
$lang['archive_tbl_date'] = 'Data';
$lang['utmz'] = '156861353.1179846341.7.5.utmccn=(referral)|utmcsr=blog.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utma'] = '156861353.469508265.1170435596.1179754428.1179846341.7';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['cleantemptable'] = 't&aelig;m Midlertidig katalog';
$lang['error_problemwithmessage'] = 'Uspesifisert meldingsproblem.';
$lang['prompt_usersettings_page'] = 'Tilbakevendingside for Brukerinnstilling skjemaet';
$lang['info_usersettings_page'] = 'Side &aring; vende tilbake til n&aring;r en epost lenke blir klikket p&aring; for &aring; redigere bruker innstillingene.<br/> (*) Indikerer standard siden.';
$lang['jobname'] = 'Jobb laget den';
$lang['msg_jobprocessing'] = 'Batch prosesserings vindu';
$lang['prompt_page'] = 'Tilbakevendingside';
$lang['error_insufficientparams'] = 'En eller flere n&oslash;dvendige parametere mangler fra anmodningen.  Denne handling kan ikke fortsette';
$lang['prompt_from'] = 'Fra';
$lang['prompt_replyto'] = 'Svar til';
$lang['prompt_subject'] = 'Emne';
$lang['prompt_template'] = 'Mal';
$lang['prompt_selectstatus'] = 'Velg status';
$lang['prompt_message'] = 'Beskjed';
$lang['prompt_userfilter'] = 'E-mail filter (regexp)';
$lang['prompt_listfilter'] = 'Filtrer p&aring; liste medlemskap';
$lang['info_listfilter'] = '<strong>Merk:</strong> Hold CTRL-knappen nede og klikk p&aring; linjer for &aring; velge eller velge dem bort.';
$lang['message_help'] = 'When typing a message, the following <em>smarty</em> variables are available:<br/>
<em>{$username}</em> - The users name<br/>
<em>{$email}</em> - The users email address<br/>
<em>{$unsubscribe}</em> - A URL that can be used to display a page for unsubscribing<br/>
<em>{$preferences}</em> - A URL that can be used to display a user preferences page<br/>
<em>{$confirmurl}</em> - A URL that can be used to confirm subscriptions<br/>
<strong>Note:</strong>&nbsp; When composing an HTML message and <em>not</em> using a page template, you will need to supply the appropriate HTML tags (html,head,body,etc).<br/>
<strong>Note:</strong>&nbsp; When using a page template as a message template, you need to use {$message_text} in place of {content} in your template.';
$lang['applyfilter'] = 'Filtrer';
$lang['info_event_OnNewUser'] = 'Generert n&aring;r en bruker abonnerer p&aring; en eller flere mail-lister';
$lang['info_event_OnEditUser'] = 'Generert n&aring;r en bruker er endret enten i admin eller via fornt-end';
$lang['info_event_OnDeleteUser'] = 'Generert n&aring;r en bruker er slettet';
$lang['info_event_OnNewList'] = 'Generert n&aring;r en mail-liste er endret';
$lang['info_event_OnDeleteList'] = 'Generert n&aring;r en mail-liste er slettet';
$lang['info_event_OnCreateMessage'] = 'Generert n&aring;r en melding er opprettet';
$lang['info_event_OnEditMessage'] = 'Generert n&aring;r en melding er endret';
$lang['info_event_OnDeleteMessage'] = 'Generert n&aring;r en melding er slettet';
$lang['info_event_OnCreateJob'] = 'Generert n&aring;r en jobb er opprettet';
$lang['info_event_OnDeleteJob'] = 'Generert n&aring;r en jobb er slettet';
$lang['info_event_OnStartJob'] = 'Generert n&aring;r kj&oslash;ring av en jobb starter';
$lang['info_event_OnFinishJob'] = 'Generert n&aring;r kj&oslash;ring av en jobb avslutter';
$lang['help_OnNewUser'] = '<p>En hendelse generert n&aring;r en ny bruker abonnerer p&aring; en eller flere mail-lister</p>
<h4>Parametere</h4>
<ul>
<li><em>email</em> - Brukers epostadresse</li>
<li><em>username</em> - Brukerens navn</li>
<li><em>lists</em> - Liste med medlemslistene</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>En hendelse generert n&aring;r en bruker er endret enten i admin eller via front-end</p>
<h4>Parametere</h4>
<ul>
<li><em>email</em> - Brukerens epostadresse</li>
<li><em>username</em> - Brukerens navn</li>
<li><em>lists</em> - Liste med medlemslistene</li>
<li><em>id</em> - Bruker Id&#039;en</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>En hendelse generert n&aring;r en bruker er slettet</p>
<h4>Parametere</h4>
<ul>
<li><em>id</em> - Bruker Id&#039;en</li>
</ul>
';
$lang['help_OnNewList'] = '<p>En hendelse generert n&aring;r en ny mail-liste er opprettet</p>
<h4>Parametere</h4>
<ul>
<li><em>name</em> - Listens navn</li>
<li><em>description</em> - Liste beskrivelse</li>
<li><em>public</em> - Offentlig flagg</li>
</ul>
';
$lang['help_OnEditList'] = '<p>En hendelse generert n&aring;r en mail-liste er endret</p>
<h4>Parametere</h4>
<ul>
<li><em>name</em> - Listens navn</li>
<li><em>description</em> - Listens beskrivelse</li>
<li><em>public</em> - Offentlig flagg</li>
<li><em>listid</em> - Listens ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>En hendelse generert n&aring;r en mail-liste er slettet</p>
<h4>Parametere</h4>
<ul>
<li><em>listid</em> - Listens ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>En hendelse generert n&aring;r en melding er opprettet</p>
<h4>Parametere</h4>
<ul>
<li><em>fromwho</em> - Navnet p&aring; personen denne meldingen er fra</li>
<li><em>reply_to</em> - Epostadressen for svar-til feltet</li>
<li><em>subject</em> - Meldingens emne</li>
<li><em>message</em> - Meldingskroppen p&aring; meldingen <em>(kan inneholde smarty tagger)</em></li>
<li><em>entered</em> - Dato for n&aring;r medlingen ble postet</li>
<li><em>uniqueid</em> - Den unike ID for denne meldingen</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>En hendelse generert n&aring;r en melding er endret</p>
<h4>Parametere</h4>
<ul>
<li><em>fromwho</em> - NAvnet p&aring; personen meldingen er fra</li>
<li><em>reply_to</em> - Epostadressen for svar-til feltet</li>
<li><em>subject</em> - Meldingens emne</li>
<li><em>message</em> - Meldingskroppen p&aring; meldingen <em>(kan inneholde smarty tagger)</em></li>
<li><em>messageid</em> - Den unike ID for denne meldingen</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>En hendelse generert n&aring;r en melding er slettet</p>
<h4>Parametere</h4>
<ul>
<li><em>messageid</em> - Melding ID for meldingen som er slettet</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>En hendelse generert n&aring; en jobb er opprettet</p>
<h4>Parametere</h4>
<ul>
<li><em>jobid</em> - ID for denne jobben</li>
<li><em>jobname</em> - Navnet p&aring; denne jobben</li>
<li><em>lists</em> - En liste med listid&#039;er</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>En hendelse generert n&aring;r en jobb er slettet</p>
<h4>Parametere</h4>
<ul>
<li><em>jobid</em> - ID&#039;en for denne jobben</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>En hendelse generert n&aring;r kj&oslash;ring av en jobb starter</p>
<h4>Parametere</h4>
<ul>
<li><em>jobid</em> - ID for denne jobben</li>
<li><em>jobname</em> - Navnet p&aring; jobben</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>En hendelse generert n&aring;r kj&oslash;ring av en jobb avslutter</p>
<h4>Parametere</h4>
<ul>
<li><em>jobid</em> - ID for denne jobben</li>
<li><em>jobname</em> - Navnet p&aring; jobben</li>
</ul>
';
$lang['error_needreplyto'] = 'Du m&aring; oppgi en gyldig svar-til epostadresse, fra navn, melding, og emne.';
$lang['error_needfrom'] = 'Du m&aring; oppgi ett gyldig navn p&aring; opphavsmann for beskjeden.';
$lang['error_needsubject'] = 'Du m&aring; oppgi ett gyldig emne p&aring; eposten';
$lang['error_needmessagetext'] = 'Du m&aring; skrive ett eller annet i eposten';
$lang['error_formerror'] = 'Skjema feil';
$lang['error_dberror'] = 'Database feil';
$lang['invalidparam'] = 'Ugyldig parameter in NMS modul taggen';
$lang['prompt_users_per_page'] = 'Antall brukere &aring; vise p&aring; hver side med brukerlisten';
$lang['disabled'] = 'Sl&aring;tt av';
$lang['confirmed'] = 'Bekreftet';
$lang['prompt_usersettings_text2'] = 'Tekst vist etter en brukerinnstilling-skjemaet er sendt';
$lang['prompt_usersettings_form2'] = 'Skjema vist til brukere som vil endre innstillinger';
$lang['prompt_usersettings_text'] = 'Tekst vist til brukeren etter bruekrinnstillings-meldingen er sendt';
$lang['prompt_usersettings_email_body'] = 'Body p&aring; brukerinnstillings-eposten';
$lang['prompt_usersettings_subject'] = 'Emne p&aring; brukerinnstillings-eposten';
$lang['prompt_usersettings_form'] = 'Skjema som sp&oslash;r brukere som vil endre innstillinger - om deres epostadresse';
$lang['prompt_post_unsubscribe_text'] = 'Tekst vist etter avbestillings-prosessen er ferdig';
$lang['user_settings'] = 'Bruker innstillinger';
$lang['prompt_unsubscribe_prompt'] = 'Sp&oslash;rsm&aring;l som sp&oslash;r brukeren for hans epostadresse &aring; avbestille';
$lang['prompt_unsubscribe_text'] = 'Tekst vist etter avbestillings-skjemaet er fullf&oslash;rt';
$lang['prompt_unsubscribe_subject'] = 'Emne p&aring; eposten sendt for &aring; avbestille';
$lang['prompt_unsubscribe_email_body'] = 'Body p&aring; eposten sendt for &aring; avbestille';
$lang['prompt_unsubscribe_form'] = 'Mal for avbestillings-skjemaet';
$lang['error_accountdisabled'] = 'Beklager, men din konto er utilgjengelig og denne handling er ikke mulig n&aring;';
$lang['prompt_post_confirm_text'] = 'Melding vist etter epost bekreftelse';
$lang['prompt_confirm_email_body'] = 'Bekreftelses epost body';
$lang['prompt_confirm_subject'] = 'Bekreftelses epost emne';
$lang['confirm_subscribe'] = 'Bekreft abonnering';
$lang['confirm_unsubscribe'] = 'Bekreft avbestilling';
$lang['nolists'] = 'Ingen lister funnet &aring; abonnere p&aring;';
$lang['public'] = 'Offentlig';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nei';
$lang['prompt_postsubscribetext'] = 'Melding vist etter abonnering';
$lang['subscription_confirmed'] = 'Abonnement bekreftet';
$lang['reset'] = 'Tilbakestill';
$lang['suspend'] = 'Pause';
$lang['resume'] = 'Fortsett';
$lang['action'] = 'Iverksett';
$lang['processing_records'] = 'Prosesserer %s til %s';
$lang['initializing_job'] = 'Initierer jobb';
$lang['processing_job'] = 'Kj&oslash;rer jobb';
$lang['deletecompleted'] = 'Slett fullf&oslash;rte jobber';
$lang['error_importerrorcount'] = 'Antall feil';
$lang['lines'] = 'Linjer';
$lang['users_added'] = 'Brukere lagt til';
$lang['memberships'] = 'Medlemskap';
$lang['subscribe'] = 'Abonner';
$lang['resetdefaults'] = 'Sett til standard';
$lang['confirm_adjustsettings'] = 'Er du sikker p&aring; du vil justere disse innstillingene?';
$lang['confirm_resetdefaults'] = 'Er du sikker p&aring; at du vil tilbakestille dette skjema til systemets standard verdi?';
$lang['prompt_subscribetext'] = 'Abonnering tekst';
$lang['prompt_subscribesubject'] = 'Abonnering emne';
$lang['prompt_subscribe_email_body'] = 'Abonnering epost body';
$lang['prompt_subscribe_form'] = 'Mal for Abonnerings skjemaet';
$lang['subscribe_form'] = 'Abonner';
$lang['unsubscribe_form'] = 'Avbestill';
$lang['error_insertinglist'] = 'Problem med &aring; lage en ny liste';
$lang['error_emailexists'] = 'Den epostadressen eksisterer allerede i bruker listen';
$lang['error_invalidusername'] = 'Ugyldig brukernavn';
$lang['error_invalidid'] = 'Ugyldig unik id';
$lang['username'] = 'Brukernavn';
$lang['name'] = 'Navn';
$lang['prompt_public'] = 'Dette er en offentlig mailingliste';
$lang['error_usernotfound'] = 'Kan ikke finne brukeren med denne spesifiserte unike id&#039;en';
$lang['prompt_ms_between_message_sleep'] = 'Forsinkelse (i millisekunder) mellom sending av hver melding';
$lang['prompt_between_batch_sleep'] = 'Forsinkelse (i sekunder) mellom hvert parti';
$lang['prompt_messages_per_batch'] = 'Maksimalt antall meldinger &aring; sende i et parti';
$lang['okclosewindow'] = 'Du kan n&aring; lukke dette vinduet';
$lang['queuefinished'] = 'Prosessering av utg&aring;ende k&oslash; avsluttet';
$lang['totaltime'] = 'Total prosesseringstid:';
$lang['seconds'] = 'Sekunder';
$lang['totalmails'] = 'Totalt eposter sendt (inkludert til admin):';
$lang['page'] = 'Side';
$lang['of'] = 'av ';
$lang['info_csvformat'] = 'Importfilen m&aring; v&aelig;re i CSV (komma separert verdi) format, en post pr linje.  <br />
Kolonnene er:<br /><br />
uniqueid, email address, username, list name, active<br /> <br />
Epostadresser kan v&aelig;re gjentatt p&aring; p&aring;f&oslash;lgende linjer (spesielt for ulike lister).';
$lang['prompt_lines'] = 'Linjer importert';
$lang['prompt_usersadded'] = 'Brukere lagt til';
$lang['prompt_membershipsadded'] = 'Medlemskap lagt til';
$lang['prompt_errorcount'] = 'Antall feil';
$lang['importerror_cantgetuserid'] = 'Feil p&aring; linje %s, kunne ikke f&aring; tak i brukerid %s';
$lang['importerror_cantcreateuser'] = 'Feil p&aring; linje %s, kunne ikke opprette bruker %s';
$lang['importerror_nosuchlist'] = 'Feil p&aring; linje %s, ingen slik liste %s';
$lang['importerror_nofields'] = 'Feil p&aring; linje %s, ikke nok felter';
$lang['import_users'] = 'Importer brukere fra CSV';
$lang['error_emptyfile'] = 'FEIL- En tom fil ble lastet opp';
$lang['error_nofilesuploaded'] = 'FEIL- ingen filer ble lastet opp';
$lang['filename'] = 'Import filnavn';
$lang['title_users_import'] = 'Import brukere';
$lang['title_users_export'] = 'Eksporter brukere fra databasen';
$lang['nummessages'] = 'antall meldinger';
$lang['created'] = 'Opprettet';
$lang['started'] = 'Startet';
$lang['finished'] = 'Fullf&oslash;rt';
$lang['processjobs'] = 'Prosesserer jobber';
$lang['status_error'] = 'FEIL';
$lang['status_unstarted'] = 'Ikke startet';
$lang['status_inprogress'] = 'under arbeid';
$lang['status_paused'] = 'Pauset';
$lang['status_complete'] = 'Ferdig';
$lang['status_unknown'] = 'Ukjent';
$lang['error_jobnameexists'] = 'FEIL- En jobb med det navnet eksisterer allerede';
$lang['createjob'] = 'Opprett jobb';
$lang['prompt_email_user_on_admin_subscribe'] = 'Send brukere en epost n&aring;r administrator manuelt legger medlemskap til listen';
$lang['error_nomessagesselected'] = 'Ingen meldinger valgt';
$lang['error_nolistsselected'] = 'Ingen lister valgt';
$lang['createjobmsg'] = 'Velg en melding, og en eller flere lister &aring; sende meldingen til';
$lang['error_nojobname'] = 'FEIL- Ingen jobbnavn spesifisert';
$lang['error_nolists'] = 'FEIL- Ingen lister!';
$lang['error_nomessages'] = 'FEIL- Ingen meldinger!';
$lang['jobs'] = 'Jobber';
$lang['status'] = 'Status ';
$lang['jobsfoundtext'] = 'Jobber funnet';
$lang['messagesfoundtext'] = 'Meldinger funnet';
$lang['entered'] = 'P&aring;meldt(Entered)';
$lang['subject'] = 'Emne';
$lang['from'] = 'Fra';
$lang['delete_user_confirm'] = 'Er du sikker p&aring; at du vil slette denne brukeren';
$lang['info_singlelist'] = 'Denne brukeren vil bli lagt til denne ene epostlisten';
$lang['error_selectonelist'] = 'FEIL- Du m&aring; velge i det minste en liste';
$lang['error_invaliduniqueid'] = 'FEIL - ugyldig unik id';
$lang['error_invalidemail'] = 'FEIL- Ugyldig epostadresse';
$lang['error_couldnotfindjobpart'] = 'FEIL - Kunne ikke finne en forespurt jobbdel i databasen.  Dette kan indikere at en annen bruker (du?) redigerer/sletter jobber mens en jobb prosesseres.';
$lang['error_couldnotfindmessage'] = 'FEIL - Kunne ikke finne en forespurt beskjed.  Dette kan indikere at en annen bruker (du?) redigerer/sletter beskjeder mens en jobb prosesseres.';
$lang['error_couldnotfindtemplate'] = 'FEIL - Kunne ikke finne en forespurt mal.  Dette kan indikere at malen var slettet etter at epost beskjeden var laget.';
$lang['error_temporarytableexists'] = 'FEIL - Den midlertidige databasetabellen brukt for jobb prosessering eksisterer allerede.  Dette kan indikere at en feil har oppst&aring;tt under et nylig fors&oslash;k p&aring; &aring; prosessere en jobb.';
$lang['error_buildingtemptable'] = 'FEIL - Ett problem oppstod under fylling av den midlertidige tabellen';
$lang['error_otherprocessingerror'] = 'FEIL: En feil oppstod under prosesseringen';
$lang['userid'] = 'Bruker ID';
$lang['emailaddress'] = 'Epostadresse';
$lang['usersfoundtext'] = 'Bruekere funnet';
$lang['title_user_createnew'] = 'Legg til bruker';
$lang['error_invalidlistname'] = 'FEIL- Ugylding listenavn';
$lang['editlist_text'] = 'Rediger liste';
$lang['id'] = 'ID ';
$lang['listsfoundtext'] = 'Lister funnet';
$lang['users'] = 'Brukere';
$lang['preferences'] = 'Innstillinger';
$lang['messages'] = 'Meldinger';
$lang['queue'] = 'K&oslash;';
$lang['submit'] = 'Utf&oslash;r';
$lang['cancel'] = 'Avbryt';
$lang['description'] = 'Beskrivelse';
$lang['createnewlist_text'] = 'Opprett liste';
$lang['lists'] = 'Lister';
$lang['friendlyname'] = 'Nyhetsbrev Made Simple';
$lang['postinstall'] = 'Takk for at du installerte NMS. Husk &aring; sette &quot;USE NMS&quot; rettigheter for &aring; bruke denne modulen!';
$lang['postuninstall'] = 'Nyhetsbrev Made Simple avinnstallert.';
$lang['uninstalled'] = 'Modul avinstallert.';
$lang['installed'] = 'Modul versjon %s innstallert.';
$lang['prefsupdated'] = 'Nyhetsbrev Made Simple modul-innstillinger oppdatert.';
$lang['newslettercreated'] = 'Et nytt nyhetsbrev har blitt opprettet.';
$lang['no_email_error'] = 'Du m&aring; fylle inn en epostadresse';
$lang['subscribe_thankyou'] = 'Takk for du abonnerer. En bekreftelses-epost har blitt sendt til din innboks.';
$lang['enter_valid_email'] = 'Du m&aring; oppgi en gyldig epostadresse og i det minste &eacute;n liste.';
$lang['newslettercreatederror'] = 'Du m&aring; velge et navn og beskrivelse.';
$lang['accessdenied'] = 'Tilgang nektet. Vennligst sjekk dine rettigheter.';
$lang['error'] = 'Feil!';
$lang['sent'] = 'Sendt';
$lang['inqueue'] = 'I k&oslash;';
$lang['send_next_batch'] = 'Sending av neste parti av %s eposter; starter: %s';
$lang['messages_sent'] = '%s har blitt sendt';
$lang['closewindow'] = 'Lukk vindu';
$lang['testmode'] = 'Du er i test-mode. Ingen eposter vill bli sendt.';
$lang['confirmdeletejob'] = 'Er du sikker p&aring; du vil slette denne jobben';
$lang['confirmsend'] = 'Er du sikker p&aring; du vil sende meldingene?';
$lang['confirmdelete'] = 'Er du sikker p&aring; du slette denne meldingen?';
$lang['confirmdeletelist'] = 'Er du sikker p&aring; at du vil slette denne listen?';
$lang['keepwindowopen'] = 'Ha dette vinduet &aring;pent til alle meldingene har blitt sendt.<br>';
$lang['profileupdated'] = 'Din profil har blitt oppdatert.';
$lang['upgraded'] = 'Modul oppgradert til versjon %s.';
$lang['title_mod_prefs'] = 'Innstillinger';
$lang['title_mod_messages'] = 'Meldingsk&oslash;';
$lang['title_mod_createnew'] = 'Opprett en liste';
$lang['title_mod_manage_user'] = 'Brukere';
$lang['title_mod_compose_job'] = 'Opprett jobb';
$lang['title_mod_compose_message'] = 'Forfatt melding';
$lang['title_mod_process_queue'] = 'Prosess k&oslash;';
$lang['title_mod_admin'] = 'Behandle lister';
$lang['user_delete_confirm'] = 'Er du sikker p&aring; du vil slette denne brukeren?';
$lang['userdeleted'] = 'Bruker slettet';
$lang['newsletterdeleted'] = 'Nyhetsbrev slettet';
$lang['delete'] = 'Slett';
$lang['edit'] = 'Rediger';
$lang['previous'] = 'Forrige';
$lang['next'] = 'Neste';
$lang['unsubscribemessage'] = 'Ditt ab. har blitt fjernet. Takk.';
$lang['title_admin_panel'] = 'Nyhetsbrev Made Simple';
$lang['moddescription'] = 'Dette er en modul som lar deg lage et nyhetsbrev system.';
$lang['welcome_text'] = '<p>Velkommen til Nyhetsbrev Made Simple (NMS) Moduladministrasjon seksjonen </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0.1 - December, 2006</li>
<p>Fixes to import users, and to a ternery expression when creating a message. I also fixed some stupid problems with process_queue resulting from me doing this too quickly.</p>
<li>Version 1.0 - December, 2006</li>
<p>This <b>is</b> essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and attemtpts have been made to bring it up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version <em>(Including previous betas)</em>is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Spesifiser en komma separert liste over epost-lister som skal vises.  <em>(Gyldig kun i p&aring;meldingsmodus)</em>';
$lang['helpmode'] = 'Spesifiser en operasjonsmodus. valgene er:
<ul>
<li>subscribe (default) - vis abonner skjemaet</li>
<li>unsubscribe - vis avbestilling skjemaet</li>
<li>usersettings - vis brukerinnstillings skjemaet</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>

<h3>How do I use it?</h3>
<ol>
<li>Install the module (which you have probably done by this point).</li>
<li>Grant appropriate permissions to the groups that will manage your lists. these include:
	<ul>
	<li>Manage NMS Lists &amp;mdash; Add, remove mailing lists</li>	
	<li>Manage NMS Users &amp;mdash; Add, remove users in the database</li>
	<li>Manage NMS Messages &amp;mdash; Add, edit, remove messages but not send them</li> 	
	<li>Manage NMS Jobs &amp;mdash; Send messages and perform other &#039;job&#039; functions</li>	
	</ul>
</li>
<li>Create a list</li>
<li>(Optional) Add the {cms_module module=&#039;NMS&#039;} to a page to enable web site visitors to sign up for your list.</li>
<li>(Optional) Add users to your list manually with the Users tab in the admin system</li>
<li>Create a message to be sent as part of a job</li>
<li>Create a job. You will select a message to send and a list to send it to.</li>
<li>Process the job and your message will be sent</li>
</ol>

<h3>Basic Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}  </p>

<h3>Further options</h3>

<h4>Display unsubscribe form:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;unsubscribe&#039;}</p>

<h4>Display the user settings page:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;usersettings&#039;}</p>

<h4>Display an archive of past newsletters</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;archive&#039;}</p>
<ul>
<lh>Optional parameters for the archive:</lh>
<li>show=&#039;#&#039; where <code>#</code> is the number of past newsletters to show. If omitted, all are shown</li>
<li>sortby=&#039;date&#039; &amp;mdash; <code>date</code> (default), <code>id</code> (message ID), or <code>subject</code></li>
<li>sortorder=&#039;DESC&#039; &amp;mdash; either <code>DESC</code> (descending order, default) or <code>ASC</code> (ascending order)</li>
<li>dateformat=&#039;%Y-%m-%d&#039; &amp;mdash; sets the date output format following the PHP strftime() syntax</li>
</ul>		

<h4>Import users from the Front End Users database</h4>
<p>Note: You must have a property defined in FEU that stores the users&#039; email address. It can be named whatever you want.</p>
<ol>
<li>Choose Extensions &amp;gt; Newsletter Made Simple</li>
<li>Activate the Users tab</li>
<li>At the bottom, click Import Users from FrontEndUsers</li>
<li>Select the FEU field that contains the users&#039; email addresses</li>
<li>Specify whether to copy the FEU user name to the NMS user name field. This is what would be output in your message if you included the {<span>$</span>username} placeholder.</li>
<li>Select the list to import to.</li>
<li>Click Submit.</li>
</ol>
<p>You will receive a report of the users processed, those already in your NMS database, those already on the list, and those that were added and subscribed. Users are not duplicated so there should be no harm in running an import periodically.</p>

<h3>Message variables</h3>
<p>These are covered elsewhere, but added here for completeness. If you add these to your message, they will be replaced at sending time with the appropriate true values.</p>

<ul>
<li>{<span>$</span>username}  &amp;mdash;  The user&#039;s name</li>
<li>{<span>$</span>email}  &amp;mdash;  The user&#039;s email address</li>
<li>{<span>$</span>unsubscribe}  &amp;mdash;  A URL that can be used to display a page for unsubscribing</li>
<li>{<span>$</span>preferences}  &amp;mdash;  A URL that can be used to display a user preferences page</li>
<li>{<span>$</span>confirmurl}  &amp;mdash;  A URL that can be used to confirm subscriptions</li>
</ul>

<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;>&amp;lt;lemkepf@gmx.net&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['import_feu_title'] = 'Importer brukere fra FrontEndUsers modulen';
$lang['import_feu_info'] = 'Velg den FEU gruppen du vil importere brukere fra inn i NMS.  <em>(kun grupper med et epostadresse feldt vil bli vist)</em>';
$lang['import_feu_noproperties'] = 'Du har ikke definert noen egenskaper i FrontEndUsers modulen. Du m&aring; definere minst en egenskap for &aring; lagre brukerens epostadresse.';
$lang['import_feu_prompt_groupname'] = 'FrontEndUsers Gruppe';
$lang['import_feu_prompt_copyusername'] = 'Kopier FEU brukernavn til NMS?';
$lang['import_feu_info_copyusername'] = '<em>Om Nei er valgt, vil brukernavnet bli beholdt som blankt.</em>';
$lang['import_feu_selectlists'] = 'Importer brukere til (liste navn)';
$lang['import_feu_feunotinstalled'] = 'FrontEndUser modulen er ikke installert eller s&aring; eksisterer ikke egenskap-definisjonstabellen. Kan ikke importere brukere fra FEU.';
$lang['processedAddressesTitle'] = 'Prosesserte adresser';
$lang['inDatabaseTitle'] = 'Er allerede i NMS';
$lang['onListAlreadyTitle'] = 'Er allerede abonnert p&aring;';
$lang['addressSubscribedTitle'] = 'Abonnert';
$lang['listidInfo'] = 'Importere til liste ID: ';
$lang['processedAddressesCountInfo'] = 'Prosseserte adresser: ';
$lang['archive_heading'] = '<h1>Meldingsarkiv</h1>';
$lang['archivedmessage'] = '<h1>Arkivert melding</h1>';
$lang['archive_tbl_msgID'] = 'Meld. ID';
$lang['archive_tbl_subject'] = 'Emne';
$lang['archive_tbl_fullurl'] = 'Meldings lenke';
$lang['archive_tbl_href'] = 'Lenke m&aring;l';
$lang['archive_tbl_date'] = 'Dato';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['error_problemwithmessage'] = 'Ongespecificeerde berichtenprobleem';
$lang['prompt_usersettings_page'] = 'Return pagina voor Gebruikersinstellingenformulier';
$lang['info_usersettings_page'] = 'Pagina om naar terug te keren als er op een email-link is geklikt om de gebruikersvoorkeuren te bewerken.<br/>De (*) geeft de standaardpagina aan.';
$lang['jobname'] = 'Opdracht aangemaakt op';
$lang['msg_jobprocessing'] = 'Batchverwerkings-window';
$lang['prompt_page'] = 'Return Pagina';
$lang['error_insufficientparams'] = 'Een of meerdere verplichte parameters ontbreken aan het verzoek. Deze activiteit kan niet verder worden uitgevoerd';
$lang['prompt_from'] = 'Van';
$lang['prompt_replyto'] = 'Beantwoord';
$lang['prompt_subject'] = 'Onderwerp';
$lang['prompt_template'] = 'Sjabloon';
$lang['prompt_selectstatus'] = 'Selecteerstatus';
$lang['prompt_message'] = 'Bericht';
$lang['prompt_userfilter'] = 'Email-filter (regexp)';
$lang['prompt_listfilter'] = 'Filter op contactpersonenlijst';
$lang['info_listfilter'] = '<strong>Opmerking:</strong> Houd de CTRL toets ingedrukt en klik op items om deze te selecteren en deselecteren.
';
$lang['message_help'] = 'Tijdens het samenstellen van een bericht zijn de volgende <em>smarty</em> variabelen beschikbaar:<br/>
<em>{$username}</em> - De gebruikersnaam<br/>
<em>{$email}</em> - Het email-adres van de gebruiker<br/>
<em>{$unsubscribe}</em> - Een URL van de uitschrijfpagina<br/>
<em>{$preferences}</em> - Een URL van de gebruikersvoorkeurenpagina<br/>
<em>{$confirmurl}</em> - Een URL naar de inschrijfbevestigingspagina<br/>
<strong>Opmerking:</strong>&nbsp; Als een HTML bericht wordt samengesteld waarbij <em>geen</em> pagina-sjabloon wordt gebruikt, dan moet u de juiste HTML tags gebruiken (html, head, body, etc).<br/>
<strong>Opmerking:</strong>&nbsp; Bij het gebruik van een pagina-sjabloon als berichtensjabloon moet {$message_text} in plaats van {content} in uw sjabloon worden gebruikt.
';
$lang['applyfilter'] = 'Filter';
$lang['info_event_OnNewUser'] = 'Gegenereerd als een nieuwe gebruiker zich inschrijf op een of meerdere maillijsten';
$lang['info_event_OnEditUser'] = 'Gegenereerd als een gebruiker aangepast wordt in de beheerpagina of via de frontend';
$lang['info_event_OnDeleteUser'] = 'Gegenereerd als een gebruiker verwijderd is';
$lang['info_event_OnNewList'] = 'Gegenereerd als een maillijst is bewerkt';
$lang['info_event_OnDeleteList'] = 'Gegenereerd als een maillijst is verwijderd';
$lang['info_event_OnCreateMessage'] = 'Gegenereerd als een bericht is aangemaakt';
$lang['info_event_OnEditMessage'] = 'Gegenereerd als een bericht is bewerkt';
$lang['info_event_OnDeleteMessage'] = 'Gegenereerd als een bericht is verwijderd';
$lang['info_event_OnCreateJob'] = 'Gegenereerd als een opdracht is aangemaakt';
$lang['info_event_OnDeleteJob'] = 'Gegenereerd als opdracht is verwijderd';
$lang['info_event_OnStartJob'] = 'Gegenereerd als het verwerken van een opdracht begint';
$lang['info_event_OnFinishJob'] = 'Gegenereerd als het verwerken van een opdracht eindigt';
$lang['help_OnNewUser'] = '<p>Een event gegenereerd als een nieuwe gebruiker zich op een of meerdere maillinglijsten inschrijft</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Gebruikersemailadres</li>
<li><em>username</em> - Gebruikersnaam</li>
<li><em>lists</em> - Array van ledenlijsten</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>An event generated when a user is modified either in the admin or via the front end</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>An event generated when a user is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnNewList'] = '<p>An event generated when a new mailing list is created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '<p>An event generated when a mailing list is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'U moet een geldig beantwoordingsemailadres opgeven';
$lang['error_needfrom'] = 'U moet een geldige naam voor de aanmaker van het bericht opgeven';
$lang['error_needsubject'] = 'U moet een geldig onderwerp opgeven';
$lang['error_needmessagetext'] = 'U moet iets intypen als bericht';
$lang['error_formerror'] = 'Formulierfout';
$lang['error_dberror'] = 'Databasefout';
$lang['invalidparam'] = 'Ongeldige parameter in de NMS module tag';
$lang['prompt_users_per_page'] = 'Aantal per pagina te tonen gebruikers uit de gebruikerslijst ';
$lang['disabled'] = 'Uitgeschakeld';
$lang['confirmed'] = 'Bevestigd';
$lang['prompt_usersettings_text2'] = 'Te tonen tekst als het gebruikersvoorkeurenformulier is verzonden';
$lang['prompt_usersettings_form2'] = 'Formulier dat aan gebruikers getoond wordt om instellingen te kunnen wijzigen';
$lang['prompt_usersettings_text'] = 'Tekst die wordt getoond nadat het gebruikersinstellingenbericht is verzonden';
$lang['prompt_usersettings_email_body'] = 'Inhoud van het gebruikersinstellingen-email';
$lang['prompt_usersettings_subject'] = 'Onderwerp van het gebruikersinstellingen-email';
$lang['prompt_usersettings_form'] = 'Formulier dat gebruikers die instellingen willen wijzigen om hun emailadres vraagt';
$lang['prompt_post_unsubscribe_text'] = 'Tekst die wordt getoond nadat het uitschrijvingsproces afgerond is';
$lang['user_settings'] = 'Gebruikersinstellingen';
$lang['prompt_unsubscribe_prompt'] = 'Prompt die de gebruiker naar zijn uit te schrijven emailadres vraagt';
$lang['prompt_unsubscribe_text'] = 'Tekst die wordt getoond nadat het uitschrijfformulier is ingevuld';
$lang['prompt_unsubscribe_subject'] = 'Onderwerp van de email dat is verzonden om uit te schrijven';
$lang['prompt_unsubscribe_email_body'] = 'Inhoud van de email dat is verzonden om uit te schrijven';
$lang['prompt_unsubscribe_form'] = 'Sjabloon voor het uitschrijfformulier';
$lang['error_accountdisabled'] = 'Helaas, uw account is uitgeschakeld en deze actie is daarom niet mogelijk';
$lang['prompt_post_confirm_text'] = 'Bericht dat wordt getoond na emailbevestiging';
$lang['prompt_confirm_email_body'] = 'Bevestigingsemail-inhoud';
$lang['prompt_confirm_subject'] = 'Bevestigingsemail-onderwerp';
$lang['confirm_subscribe'] = 'Bevestig inschrijving';
$lang['confirm_unsubscribe'] = 'Bevestig uitschrijving';
$lang['nolists'] = 'Geen lijst gevonden waarop ingeschreven kan worden';
$lang['public'] = 'Openbaar';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nee';
$lang['prompt_postsubscribetext'] = 'Bericht dat getoond worden na inschrijving';
$lang['subscription_confirmed'] = 'Inschrijving bevestigd';
$lang['reset'] = 'Reset';
$lang['suspend'] = 'Uitstellen';
$lang['resume'] = 'Doorgaan';
$lang['action'] = 'Actie';
$lang['processing_records'] = 'Verwerking record %s tot %s';
$lang['initializing_job'] = 'Initialiseren opdracht';
$lang['processing_job'] = 'Verwerken opdracht';
$lang['deletecompleted'] = 'Verwijder afgeronden opdrachten';
$lang['error_importerrorcount'] = 'Foutentelling';
$lang['lines'] = 'Regels';
$lang['users_added'] = 'Gebruikers toegevoegd';
$lang['memberships'] = 'Lidmaatschappen';
$lang['subscribe'] = 'Inschrijven';
$lang['resetdefaults'] = 'Reset naar standaard';
$lang['confirm_adjustsettings'] = 'Weet u zeker dat u deze instellingen wilt aanpassen?';
$lang['confirm_resetdefaults'] = 'Weet u zeker dat u dit formulier wilt resetten naar de standaard systeemwaarde?';
$lang['prompt_subscribetext'] = 'Inschrijftekst';
$lang['prompt_subscribesubject'] = 'Inschrijfonderwerp';
$lang['prompt_subscribe_email_body'] = 'Inschrijfemail-inhoud';
$lang['prompt_subscribe_form'] = 'Sjabloon voor inschrijfformulier';
$lang['subscribe_form'] = 'Inschrijven';
$lang['unsubscribe_form'] = 'Uitschrijven';
$lang['error_insertinglist'] = 'Probleem met het aanmaken van een nieuwe lijst';
$lang['error_emailexists'] = 'Dit emailadres bestaat al in de gebruikerslijst';
$lang['error_invalidusername'] = 'Ongeldige gebruikersnaam';
$lang['error_invalidid'] = 'Ongeldige unieke id';
$lang['username'] = 'Gebruikersnaam';
$lang['name'] = 'Naam';
$lang['prompt_public'] = 'Dit is een openbare maillijst';
$lang['error_usernotfound'] = 'Kan de gebruiker met het opgegeven unieke id niet vinden';
$lang['prompt_ms_between_message_sleep'] = 'Vertraging (in milliseconden) tussen het sturen van ieder bericht';
$lang['prompt_between_batch_sleep'] = 'Vertraging (in seconden) tussen iedere batch';
$lang['prompt_messages_per_batch'] = 'Het maximum aantal te verzenden berichten in een batch';
$lang['okclosewindow'] = 'U kunt nu deze window sluiten';
$lang['queuefinished'] = 'Verwerken van uitvoerwachtrij afgerond';
$lang['totaltime'] = 'Totale verwerkingstijd:';
$lang['seconds'] = 'Seconden';
$lang['totalmails'] = 'Totaal aantal verzonde emails (inclusief die naar admin):';
$lang['page'] = 'Pagina';
$lang['of'] = 'van';
$lang['info_csvformat'] = 'Het importbestand moet in CSV (comma separated value) formaat staan, een item per regel v.<br />
De kolommen zijn:<br/><br/>
uniqueid, emailadres, gebruikersnaam, lijstnaam, actief<br /> <br />
Emailadressen kunnen herhaald worden op opeenvolgende regels (met name voor verschillende lijsten).';
$lang['prompt_lines'] = 'Regels ge&iuml;mporteerd';
$lang['prompt_usersadded'] = 'Gebruikers toegevoegd';
$lang['prompt_membershipsadded'] = 'Lidmaatschappen toegevoegd';
$lang['prompt_errorcount'] = 'Aantal fouten';
$lang['importerror_cantgetuserid'] = 'Fout in regel %s, kan userid niet ophalen %s';
$lang['importerror_cantcreateuser'] = 'Fout in regel %s, kan gebruiker %s niet aanmaken';
$lang['importerror_nosuchlist'] = 'Fout in regel %s, lijst %s bestaat niet';
$lang['importerror_nofields'] = 'Fout in regel %s, onvoldoende velden';
$lang['import_users'] = 'Importeer gebruikers uit CSV';
$lang['error_emptyfile'] = 'Fout - Een leeg bestand is geupload';
$lang['error_nofilesuploaded'] = 'Fout - er zijn geen bestanden geupload';
$lang['filename'] = 'Import bestandsnaam';
$lang['title_users_import'] = 'Importeer gebruikers uit CSV';
$lang['title_users_export'] = 'Exporteer gebruikers uit database';
$lang['nummessages'] = '# berichten';
$lang['created'] = 'Aangemaakt';
$lang['started'] = 'Gestart';
$lang['finished'] = 'Ge&euml;indigd';
$lang['processjobs'] = 'Verwerk opdrachten';
$lang['status_error'] = 'Fout';
$lang['status_unstarted'] = ' Niet gestart';
$lang['status_inprogress'] = 'In verwerking';
$lang['status_paused'] = 'Gepauzeerd';
$lang['status_complete'] = 'Afgerond';
$lang['status_unknown'] = 'Onbekend';
$lang['error_jobnameexists'] = 'Fout - Een opdracht met die naam bestaat al';
$lang['createjob'] = 'Maak opdracht aan';
$lang['prompt_email_user_on_admin_subscribe'] = 'Stuur gebruikers een email als de beheerder handmatig leden aan een lijst toevoegd';
$lang['error_nomessagesselected'] = 'Geen berichten geselecteerd';
$lang['error_nolistsselected'] = 'Geen lijsten geselecteerd';
$lang['createjobmsg'] = 'Selecteer een bericht en een of meerdere lijsten om het bericht naar te versturen';
$lang['error_nojobname'] = 'Fout - Geen opdrachtnaam gespecificeerd';
$lang['error_nolists'] = 'Fout - Geen lijsten!';
$lang['error_nomessages'] = 'Fout - Geen berichten';
$lang['jobs'] = 'Opdrachten';
$lang['status'] = 'Status';
$lang['jobsfoundtext'] = 'Gevonden opdrachten';
$lang['messagesfoundtext'] = 'Gevonden berichten';
$lang['entered'] = 'Ingevoerd';
$lang['subject'] = 'Onderwerp';
$lang['from'] = 'Van';
$lang['delete_user_confirm'] = 'Weet u zeker dat deze gebruiker verwijderd moet worden?';
$lang['info_singlelist'] = 'Deze gebruiker zal worden toegevoegd aan de sole maillijst';
$lang['error_selectonelist'] = 'Fout - U moet minstens een lijst selecteren';
$lang['error_invaliduniqueid'] = 'Fout - Ongeldige unieke id';
$lang['error_invalidemail'] = 'Fout - Ongeldig emailadres';
$lang['error_couldnotfindjobpart'] = 'Fout - Kan geen aangevraagde deelopdracht in de database vinden.  Dit kan erop wijzen dat een andere gebruiker (u?) opdrachten aan het bewerken/verwijderen is, terwijl een opdracht wordt uitgevoerd.';
$lang['error_couldnotfindmessage'] = 'Fout - Kan geen aangevraagd bericht in de database vinden.  Dit kan erop wijzen dat een andere gebruiker (u?) berichten aan het bewerken/verwijderen is, terwijl een opdracht wordt uitgevoerd.';
$lang['error_couldnotfindtemplate'] = 'Fout - Kan geen aangevraagde paginasjabloon vinden.  Dit kan erop wijzen dat de sjabloon is verwijderd sinds het mailbericht is aangemaakt.';
$lang['error_temporarytableexists'] = 'Fout - De tijdelijke databasetabel die voor het verwerken van de opdracht wordt gebruikt bestaat al. Dit wijst er op dat een fout is opgetreden tijdens het verwerken van een vorige opdracht.';
$lang['error_buildingtemptable'] = 'Fout - Er is een probleem tijdens het vullen van de tijdelijke tabel opgetreden';
$lang['error_otherprocessingerror'] = 'Fout - Er is een fout opgetreden tijdens het verwerken';
$lang['userid'] = 'Gebruikers ID';
$lang['emailaddress'] = 'Emailadres';
$lang['usersfoundtext'] = 'Gebruikers gevonden';
$lang['title_user_createnew'] = 'Gebruiker toevoegen';
$lang['error_invalidlistname'] = 'Fout - Ongeldige lijstnaam';
$lang['editlist_text'] = 'Bewerk lijst';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Lijsten gevonden';
$lang['users'] = 'Gebruiker';
$lang['preferences'] = 'Voorkeuren';
$lang['messages'] = 'Berichten';
$lang['queue'] = 'Wachtrij';
$lang['submit'] = 'Verstuur';
$lang['description'] = 'Beschrijving';
$lang['createnewlist_text'] = 'Maak lijst aan';
$lang['lists'] = 'Lijsten';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Bedankt voor het installeren van NMS. Vergewis u ervan dat de &quot;Use NMS&quot; rechten zijn ingesteld.';
$lang['postuninstall'] = 'Newsletter Made Simple gedeinstalleerd.';
$lang['uninstalled'] = 'Module gede&iuml;nstalleerd';
$lang['installed'] = 'Moduleversie %s ge&iuml;nstalleerd.';
$lang['prefsupdated'] = 'Newsletter Made Simple Module voorkeuren bijgewerkt';
$lang['newslettercreated'] = 'Een nieuwe nieuwsbrief is aangemaakt.';
$lang['no_email_error'] = 'U moet een emailadres invullen.';
$lang['subscribe_thankyou'] = 'Bedankt voor het inschrijven. Een bevestigingsemail is naar uw inbox verstuurd';
$lang['enter_valid_email'] = 'U moet een geldig emailadres invullen en minstens een lijst.';
$lang['newslettercreatederror'] = 'U moet een naam en een beschrijving invullen.';
$lang['accessdenied'] = 'Toegang geweigerd. Controleer de rechten.';
$lang['error'] = 'Fout!';
$lang['sent'] = 'Verzonden';
$lang['inqueue'] = 'In wachtrij';
$lang['send_next_batch'] = 'Verzenden van de volgende batch met %s emails; start om: %s';
$lang['messages_sent'] = '%s zijn er verzonden';
$lang['closewindow'] = 'Sluit windows';
$lang['testmode'] = 'U bent in de testmode. Er worden geen e-mails verzonden.';
$lang['confirmdeletejob'] = 'Weet u zeker dat u deze opdracht wilt verwijderen?';
$lang['confirmsend'] = 'Weet u zeker dat u alle berichten wilt versturen?';
$lang['confirmdelete'] = 'Weet u zeker dat u dit bericht wilt verwijderen?';
$lang['confirmdeletelist'] = 'Weet u zeker dat u deze lijst wilt verwijderen?';
$lang['keepwindowopen'] = 'Sluit deze windows NIET totdat alle berichten verzonden zijn.<br>';
$lang['profileupdated'] = 'Uw profiel is bijgewerkt.';
$lang['upgraded'] = 'Module geupgrade naar versie %s.';
$lang['title_mod_prefs'] = 'Configuratie';
$lang['title_mod_messages'] = 'Berichtenwachtrij';
$lang['title_mod_createnew'] = 'Maak een lijst aan';
$lang['title_mod_manage_user'] = 'Gebruikers';
$lang['title_mod_compose_job'] = 'Maak een opdracht aan';
$lang['title_mod_compose_message'] = 'Stel een bericht samen';
$lang['title_mod_process_queue'] = 'Verwerk de wachtrij';
$lang['title_mod_admin'] = 'Beheer lijsten';
$lang['user_delete_confirm'] = 'Weet u zeker dat u deze gebruiker wilt verwijderen?';
$lang['userdeleted'] = 'Gebruiker verwijderd';
$lang['newsletterdeleted'] = 'Nieuwsbrief verwijderd';
$lang['delete'] = 'Verwijder';
$lang['edit'] = 'Bewerk';
$lang['previous'] = 'Vorige';
$lang['next'] = 'Volgende';
$lang['unsubscribemessage'] = 'U bent uitgeschreven. Bedankt.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Deze module maakt het u mogelijk een nieuwsbrievensysteem aan te maken.';
$lang['welcome_text'] = '<p>Welkom bij de Newsletter Made Simple (MNS) Module beheersectie. </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0.1 - December, 2006</li>
<p>Fixes to import users, and to a ternery expression when creating a message. I also fixed some stupid problems with process_queue resulting from me doing this too quickly.</p>
<li>Version 1.0 - December, 2006</li>
<p>This <b>is</b> essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and attemtpts have been made to bring it up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version <em>(Including previous betas)</em>is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Specify a comma separated list of mailing lists to display.  <em>(Valid only in subscribe mode)</em>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>

<h3>How do I use it?</h3>
<ol>
<li>Install the module (which you have probably done by this point).</li>
<li>Grant appropriate permissions to the groups that will manage your lists. these include:
	<ul>
	<li>Manage NMS Lists &mdash; Add, remove mailing lists</li>	
	<li>Manage NMS Users &mdash; Add, remove users in the database</li>
	<li>Manage NMS Messages &mdash; Add, edit, remove messages but not send them</li> 	
	<li>Manage NMS Jobs &mdash; Send messages and perform other &#039;job&#039; functions</li>	
	</ul>
</li>
<li>Create a list</li>
<li>(Optional) Add the {cms_module module=&#039;NMS&#039;} to a page to enable web site visitors to sign up for your list.</li>
<li>(Optional) Add users to your list manually with the Users tab in the admin system</li>
<li>Create a message to be sent as part of a job</li>
<li>Create a job. You will select a message to send and a list to send it to.</li>
<li>Process the job and your message will be sent</li>
</ol>

<h3>Basic Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}  </p>

<h3>Further options</h3>

<h4>Display unsubscribe form:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;unsubscribe&#039;}</p>

<h4>Display the user settings page:</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;usersettings&#039;}</p>

<h4>Display an archive of past newsletters</h4>
<p>{cms_module module=&#039;NMS&#039; mode=&#039;archive&#039;}</p>
<ul>
<lh>Optional parameters for the archive:</lh>
<li>show=&#039;#&#039; where <code>#</code> is the number of past newsletters to show. If omitted, all are shown</li>
<li>sortby=&#039;date&#039; &mdash; <code>date</code> (default), <code>id</code> (message ID), or <code>subject</code></li>
<li>sortorder=&#039;DESC&#039; &mdash; either <code>DESC</code> (descending order, default) or <code>ASC</code> (ascending order)</li>
<li>dateformat=&#039;%Y-%m-%d&#039; &mdash; sets the date output format following the PHP strftime() syntax</li>
</ul>		

<h4>Import users from the Front End Users database</h4>
<p>Note: You must have a property defined in FEU that stores the users&#039; email address. It can be named whatever you want.</p>
<ol>
<li>Choose Extensions > Newsletter Made Simple</li>
<li>Activate the Users tab</li>
<li>At the bottom, click Import Users from FrontEndUsers</li>
<li>Select the FEU field that contains the users&#039; email addresses</li>
<li>Specify whether to copy the FEU user name to the NMS user name field. This is what would be output in your message if you included the {<span>$</span>username} placeholder.</li>
<li>Select the list to import to.</li>
<li>Click Submit.</li>
</ol>
<p>You will receive a report of the users processed, those already in your NMS database, those already on the list, and those that were added and subscribed. Users are not duplicated so there should be no harm in running an import periodically.</p>

<h3>Message variables</h3>
<p>These are covered elsewhere, but added here for completeness. If you add these to your message, they will be replaced at sending time with the appropriate true values.</p>

<ul>
<li>{<span>$</span>username}  &mdash;  The user&#039;s name</li>
<li>{<span>$</span>email}  &mdash;  The user&#039;s email address</li>
<li>{<span>$</span>unsubscribe}  &mdash;  A URL that can be used to display a page for unsubscribing</li>
<li>{<span>$</span>preferences}  &mdash;  A URL that can be used to display a user preferences page</li>
<li>{<span>$</span>confirmurl}  &mdash;  A URL that can be used to confirm subscriptions</li>
</ul>

<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['import_feu_title'] = 'Importeer gebruikers uit FrontEndUsers';
$lang['import_feu_info'] = 'Om gebruikers uit de FrontEndUsers tabellen te importen moet u opgeven welk FEU-veld het emailadres bevat en of de inhoud van het FEU-username-veld gekopieerd moet worden naar het NMS-username-veld.';
$lang['import_feu_emailfieldname'] = 'FEU-emailadres-veld';
$lang['import_feu_noproperties'] = 'U heeft geen eigenschappen in de FrontEndUsers module opgegeven. U moet minstens een eigenschap defini&euml;ren om de gebruikersemailadressen in op te slaan.';
$lang['import_feu_copyusername'] = 'Kopieer de FEU-username naar NMS?';
$lang['import_feu_selectlists'] = 'Importeer gebruikers naar (lijstnaam)';
$lang['import_feu_copyusername_yes'] = 'Ja';
$lang['import_feu_copyusername_no'] = 'Nee (laat leeg)';
$lang['import_feu_feunotinstalled'] = 'De FrontEndUsers module is niet ge&iuml;nstalleerd of d eigenschappendefinitietabel bestaat niet. Kan geen gebruikers uit FEU importeren.';
$lang['processedAddressesTitle'] = 'Verwerkte adressen';
$lang['inDatabaseTitle'] = 'Reeds in NMS';
$lang['onListAlreadyTitle'] = 'Reeds ingeschreven.';
$lang['addressSubscribedTitle'] = 'Ingeschreven';
$lang['listidInfo'] = 'Ge&iuml;mporteerd naar lijst id:';
$lang['processedAddressesCountInfo'] = 'Verwerkte adressen:';
$lang['archive_heading'] = '<h1>Archief van berichten</h1>';
$lang['archivedmessage'] = '<h1>Gearchiveerde berichten</h1>';
$lang['archive_tbl_msgID'] = 'BerichtID';
$lang['archive_tbl_subject'] = 'Onderwerp';
$lang['archive_tbl_fullurl'] = 'Bericht link';
$lang['archive_tbl_href'] = 'Link target';
$lang['archive_tbl_date'] = 'Datum';
$lang['utma'] = '156861353.1204003931.1173993091.1178438153.1178439181.31';
$lang['utmz'] = '156861353.1176024242.22.3.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php|utmcmd=referral';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pl_PL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['prompt_usersettings_page'] = 'Strona powrotna dla formularza ustawień użytkownika';
$lang['info_usersettings_page'] = 'Strona powrotna kiedy link w emailu został kliknięty w celu edycji ustawień użytkownika.<br/> (*) oznacza domyślną stronę.';
$lang['jobname'] = 'Zadanie utworzone';
$lang['msg_jobprocessing'] = 'Okno przetwarzania zadań';
$lang['prompt_page'] = 'Strona powrotna';
$lang['error_insufficientparams'] = 'Brakuje jednego lub więcej wymaganych parametr&oacute;w. Operacja nie może zostać wykonana';
$lang['prompt_from'] = 'Od';
$lang['prompt_replyto'] = 'Odpowiedz do';
$lang['prompt_subject'] = 'Temat';
$lang['prompt_template'] = 'Szablon';
$lang['prompt_selectstatus'] = 'Wybierz status';
$lang['prompt_message'] = 'Wiadomość';
$lang['prompt_userfilter'] = 'Filtr email (regexp)';
$lang['prompt_listfilter'] = 'Filtr członkostwa w liście';
$lang['info_listfilter'] = '<strong>Uwaga:</strong> Trzymaj klawisz CTRL wciśnięty i kliknij na pozycje aby je zaznaczyć lub odznaczyć.
';
$lang['message_help'] = 'Pisząc wiadomość, następujące znaczniki <em>smarty</em> są dostępne:<br/>
<em>username</em> - Nazwa/imię subskrybenta<br/>
<em>email</em> - Adres email subskrybenta<br/>
<em>unsubscribe</em> - Adres URL kt&oacute;ry może być użyty do wyświetlenia strony rezygnacji z subskrypcji<br/>
<em>preferences</em> - Adres URL kt&oacute;ry może być użyty do wyświetleni strony z ustawieniami subskrybenta<br/>
<em>confirmurl</em> - Adres URL, kt&oacute;ry może być użyty do potwierdzenia subskrypcji<br/>
<strong>Uwaga:</strong>&nbsp; Tworząc wiadomość HTML <em>bez</em> używania szablonu strony, musisz dostarczyć odpowienie znaczniki HTML (html,head,body,itp).<br/>
<strong>Uwaga:</strong>&nbsp; Używając szablon strony jako szablon wiadomości, musisz użyć znacznika {$message_text} zamiast {content} w Twoim szablonie.
';
$lang['applyfilter'] = 'Filtr';
$lang['info_event_OnNewUser'] = 'Generowane kiedy nowy subskrybent zapisuje się na jedną z dostępnych list pocztowych';
$lang['info_event_OnEditUser'] = 'Generowane kiedy subskrybent jest modyfikowny zar&oacute;wno w adminie jak i przez frontend';
$lang['info_event_OnDeleteUser'] = 'Generowane kiedy subskrybent jest usuwany';
$lang['info_event_OnNewList'] = 'Generowane kiedy lista pocztowa jest modyfikowana';
$lang['info_event_OnDeleteList'] = 'Generowane kiedy lista pocztowa jest usuwana';
$lang['info_event_OnCreateMessage'] = 'Generowane kiedy wiadomość jest utworzona';
$lang['info_event_OnEditMessage'] = 'Generowane kiedy wiadomość jest modyfikowana';
$lang['info_event_OnDeleteMessage'] = 'Generowane kiedy wiadomość jest usunięta';
$lang['info_event_OnCreateJob'] = 'Generowane kiedy zadanie jest utworzone';
$lang['info_event_OnDeleteJob'] = 'Generowane kiedy zadanie jest usunięte';
$lang['info_event_OnStartJob'] = 'Generowane kiedy rozpoczyna się wykonywanie zadania';
$lang['info_event_OnFinishJob'] = 'Generowane kiedy kończy się wykonywanie zadania';
$lang['help_OnNewUser'] = '<p>An event generated when a new user subscribes to one or more mailing lists</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>An event generated when a user is modified either in the admin or via the front end</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>An event generated when a user is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnNewList'] = '<p>An event generated when a new mailing list is created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '<p>An event generated when a mailing list is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'Musisz wprowadzić poprawny adres: odpowiedz do';
$lang['error_needfrom'] = 'Musisz wprowadzić poprawną nazwę autora wiadomości';
$lang['error_needsubject'] = 'Musisz wprowadzić poprawny temat wiadomości';
$lang['error_needmessagetext'] = 'Musisz wprowadzić treść wiadomości';
$lang['error_formerror'] = 'Błąd formularza';
$lang['error_dberror'] = 'Błąd bazy danych';
$lang['invalidparam'] = 'Błędny parametr w tagu modułu NMS';
$lang['prompt_users_per_page'] = 'Liczba subskrybent&oacute;w do wyświetlenia na każdej stronie listy subskrybent&oacute;w';
$lang['disabled'] = 'Wyłączony';
$lang['confirmed'] = 'Potwierdzony';
$lang['prompt_usersettings_text2'] = 'Tekst wyświetlany po tym jak jak formularz ustawień subskrybenta jest zapisany';
$lang['prompt_usersettings_form2'] = 'Formularz wyświetlany subskrybentom kt&oacute;rzy chcą zmienić swoje ustawienia';
$lang['prompt_usersettings_text'] = 'Tekst wyświetlany po tym jak wiadomość o ustawieniach subskrybenta zostanie wysłana';
$lang['prompt_usersettings_email_body'] = 'Treść emaila z ustawieniami subskrybenta';
$lang['prompt_usersettings_subject'] = 'Temat emaila z ustawieniami subskrybenta';
$lang['prompt_usersettings_form'] = 'Formularz pytający subskrybent&oacute;w zmieniających ustawienia o ich adres email';
$lang['prompt_post_unsubscribe_text'] = 'Tekst wyświetlany po tym jak proces wypisywania jest zakończony';
$lang['user_settings'] = 'Ustawienia subskrybenta';
$lang['prompt_unsubscribe_prompt'] = 'Komunikat z zapytaniem o adres email subskrybenta wymagany do wypisania się';
$lang['prompt_unsubscribe_text'] = 'Tekst wyświetlany kiedy proces rezygnacji z subskrypcji jest zakończony';
$lang['prompt_unsubscribe_subject'] = 'Temat emaila rezygnacji z subskrypcji';
$lang['prompt_unsubscribe_email_body'] = 'Treść emaila rezygnacji z subskrypcji';
$lang['prompt_unsubscribe_form'] = 'Szablon formularza rezygnacji z subskrypcji';
$lang['error_accountdisabled'] = 'Przepraszamy ale Twoje konto zostało wyłączone, w tym momencie ta operacja nie jest możliwa';
$lang['prompt_post_confirm_text'] = 'Wiadomość wyświetlana po potwierdzeniu emaila';
$lang['prompt_confirm_email_body'] = 'Treść emaila potwierdzenia subskrypcji';
$lang['prompt_confirm_subject'] = 'Temat emaila potwierdzenia subskrypcji';
$lang['confirm_subscribe'] = 'Potwierdź subskrypcję';
$lang['confirm_unsubscribe'] = 'Potwierdź rezygnację z subskrypcji';
$lang['nolists'] = 'Nie znaleziono list kt&oacute;re można subskrybować';
$lang['public'] = 'Publiczna';
$lang['yes'] = 'Tak';
$lang['no'] = 'Nie';
$lang['prompt_postsubscribetext'] = 'Wiadomość wyświetlona po subskrypcji';
$lang['subscription_confirmed'] = 'Subskrypcja potwierdzona';
$lang['reset'] = 'Resetuj';
$lang['suspend'] = 'Zawieś';
$lang['resume'] = 'Przywr&oacute;ć';
$lang['action'] = 'Akcja';
$lang['processing_records'] = 'Przetwarzam rekordy %s - %s';
$lang['initializing_job'] = 'Inicjalizacja zadania';
$lang['processing_job'] = 'Przetwarzanie zadania';
$lang['deletecompleted'] = 'Usuń zakończone zadania';
$lang['error_importerrorcount'] = 'Liczba błęd&oacute;w';
$lang['lines'] = 'Linii';
$lang['users_added'] = 'Użytkownicy dodani';
$lang['memberships'] = 'Członkowie';
$lang['subscribe'] = 'Subskrybuj';
$lang['resetdefaults'] = 'Przywr&oacute;ć domyślne';
$lang['confirm_adjustsettings'] = 'Na pewno chcesz zmienić te ustawienia?';
$lang['confirm_resetdefaults'] = 'Na pewno chcesz przywr&oacute;cić domyślne ustawienia?';
$lang['prompt_subscribetext'] = 'Tekst subskrypcji';
$lang['prompt_subscribesubject'] = 'Temat subskrypcji';
$lang['prompt_subscribe_email_body'] = 'Treść emaila subskrypcji';
$lang['prompt_subscribe_form'] = 'Szablon formularza subskrypcji';
$lang['subscribe_form'] = 'Subskrybuj';
$lang['unsubscribe_form'] = 'Wypisz';
$lang['error_insertinglist'] = 'Problem podczas tworzenia nowej listy';
$lang['error_emailexists'] = 'Ten adres email już istnieje w bazie';
$lang['error_invalidusername'] = 'Nieprawidłowa nazwa subskrybenta';
$lang['error_invalidid'] = 'Nieprawidłowy unikalny id';
$lang['username'] = 'Nazwa subskrybenta';
$lang['name'] = 'Nazwa';
$lang['prompt_public'] = 'To jest publiczna lista mailingowa';
$lang['error_usernotfound'] = 'Nie można znaleźć subskrybenta o takim id';
$lang['prompt_ms_between_message_sleep'] = 'Op&oacute;źnienie (w millisekundach) pomiędzy wysyłaniem każdej wiadomości';
$lang['prompt_between_batch_sleep'] = 'Op&oacute;znienie (w sekundach) pomiędzy każdą kolejką';
$lang['prompt_messages_per_batch'] = 'Maksymalna liczba wiadomości wysłana w kolejce';
$lang['okclosewindow'] = 'Możesz teraz zamknąć to okno';
$lang['queuefinished'] = 'Przetwarzanie kolejki zostało zakończone';
$lang['totaltime'] = 'Całkowity czas przetwarzania:';
$lang['seconds'] = 'Sekund';
$lang['totalmails'] = 'Suma wysłanych wiadomości (włączając admina):';
$lang['page'] = 'Strona';
$lang['of'] = 'z';
$lang['info_csvformat'] = 'Importowany plik musi być w formacie CSV (comma separated value), jeden wpis w wierszu.  Pierwsze pole powinno być adresem email, drugie nazwą subskrybenta trzecie nazwą listy. Adresy email mogą być powtarzane w kolejnych wierszach (w przypadku gdy są przypisywane do r&oacute;żnych list).';
$lang['prompt_lines'] = 'Zaimportowanych wierszy';
$lang['prompt_usersadded'] = 'Dodanych subskrybent&oacute;w';
$lang['prompt_membershipsadded'] = 'Dodanych członkostw';
$lang['prompt_errorcount'] = 'Liczba błęd&oacute;w';
$lang['importerror_cantgetuserid'] = 'Błąd w linii %s, nie można odczytać id subskrybenta %s';
$lang['importerror_cantcreateuser'] = 'Błąd w linii %s, nie można utworzyć subskrybenta %s';
$lang['importerror_nosuchlist'] = 'Błąd w linii %s, nie istnieje lista %s';
$lang['importerror_nofields'] = 'Błąd w linii %s, zbyt mało p&oacute;l';
$lang['import_users'] = 'Importuj subskrybent&oacute;w z pliku CSV';
$lang['error_emptyfile'] = 'BŁĄD - został załadowany pusty plik';
$lang['error_nofilesuploaded'] = 'BŁĄD - nie załadowano żadnego pliku';
$lang['filename'] = 'Importuj plik';
$lang['title_users_import'] = 'Importuj subskrybent&oacute;w';
$lang['nummessages'] = '# wiadomości';
$lang['created'] = 'Utworzone';
$lang['started'] = 'Rozpoczęte';
$lang['finished'] = 'Zakończone';
$lang['processjobs'] = 'Przetwarzaj zadania';
$lang['status_error'] = 'BŁĄD';
$lang['status_unstarted'] = 'Nie rozpoczęte';
$lang['status_inprogress'] = 'W trakcie';
$lang['status_paused'] = 'Wstrzymane';
$lang['status_complete'] = 'Ukończone';
$lang['status_unknown'] = 'Nieznane';
$lang['error_jobnameexists'] = 'BŁĄD - zadanie o takiej nazwie już istnieje';
$lang['createjob'] = 'Utw&oacute;rz zadanie';
$lang['prompt_email_user_on_admin_subscribe'] = 'Wyślij subskrybentowi email kiedy administrator manualnie dodaje przypisanie do listy';
$lang['error_nomessagesselected'] = 'Brak wybranych wiadomości';
$lang['error_nolistsselected'] = 'Brak wybranych list';
$lang['createjobmsg'] = 'Wybierz jedną wiadomość, i jedną lub więcej list aby wysłać wiadomość';
$lang['error_nojobname'] = 'BŁĄD - Nie określono nazwy zadania';
$lang['error_nolists'] = 'BŁĄD - Brak list!';
$lang['error_nomessages'] = 'BŁĄD - Brak wiadomości!';
$lang['jobs'] = 'Zadania';
$lang['status'] = 'Status:';
$lang['jobsfoundtext'] = 'Znalezionych zadań';
$lang['messagesfoundtext'] = 'Znalezionych wiadomości';
$lang['entered'] = 'Wprowadzone';
$lang['subject'] = 'Temat';
$lang['from'] = 'Od';
$lang['delete_user_confirm'] = 'Na pewno chcesz usunąć tego subskrybenta?';
$lang['info_singlelist'] = 'Ten subskrybent zostanie dodany wyłącznie do tej listy';
$lang['error_selectonelist'] = 'BŁĄD - Musisz wybrać przynajmniej jedną listę';
$lang['error_invaliduniqueid'] = 'BŁĄD - Niepoprawny id';
$lang['error_invalidemail'] = 'BŁĄD - Niepoprawny adres email';
$lang['error_couldnotfindjobpart'] = 'BŁAD - Nie można znaleźć żądanego zadania w bazie. Może to oznaczać, że inny użytkownik (Ty?) edytuje/usuwa zadania podczas ich przetwarzania.';
$lang['error_couldnotfindmessage'] = 'BŁĄD - Nie można znaleźć żądanej wiadomości. Może to oznaczać, że inny użytkownik (Ty?) edytuje/usuwa wiadomości podczas ich przetwarzania.';
$lang['error_couldnotfindtemplate'] = 'BŁĄD - Nie można znaleźć żądanego szablonu. Może to oznaczać, że szablon został usunięty od czasu gdy wiadomość została utworzona.';
$lang['error_temporarytableexists'] = 'BŁĄD - Tymczasowa tabela w bazie danych, używana do przetwarzania zadań już istnieje.  Oznacza to prawdopodobnie, że pojawił się błąd podczas przetwarzania poprzednich zadań.';
$lang['error_buildingtemptable'] = 'BŁĄD - Wystąpił problem podczas wypełniania tymczasowej tabeli';
$lang['error_otherprocessingerror'] = 'BŁĄD: Wystąpił błąd podczas przetwarzania';
$lang['userid'] = 'ID subskrybenta';
$lang['emailaddress'] = 'Adres email';
$lang['usersfoundtext'] = 'znalezionych subskrybent&oacute;w';
$lang['title_user_createnew'] = 'Dodaj subskrybenta';
$lang['error_invalidlistname'] = 'BŁĄD - niepoprawna nazwa listy';
$lang['editlist_text'] = 'Edytuj listę';
$lang['id'] = 'Id';
$lang['listsfoundtext'] = 'znalezionych list';
$lang['users'] = 'Subskrybenci';
$lang['preferences'] = 'Ustawienia';
$lang['messages'] = 'Wiadomości';
$lang['queue'] = 'Kolejka';
$lang['submit'] = 'Zatwierdź';
$lang['description'] = 'Opis';
$lang['createnewlist_text'] = 'Utw&oacute;rz listę';
$lang['lists'] = 'Listy';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Dziękujemy za instalacje NMS. Upewnij się, że ustawione są prawa dostępu &quot;Use NMS&quot; dla tego modułu. ';
$lang['postuninstall'] = 'Newsletter Made Simple został odinstalowany.';
$lang['uninstalled'] = 'Moduł został odinstalowany.';
$lang['installed'] = 'Moduł w wersji %s został zainstalowany.';
$lang['prefsupdated'] = 'Ustawienia newslettera zostały uaktualnione.';
$lang['newslettercreated'] = 'Nowy newsletter został utworzony.';
$lang['no_email_error'] = 'Musisz wprowadzić adres email.';
$lang['subscribe_thankyou'] = 'Dziękujemy za subskrypcję. Email z potwierdzeniem został wysłany na Twoją skrzynkę.';
$lang['enter_valid_email'] = 'Musisz wprowadzić poprawny adres email i wybrać przynajmniej jedną listę.';
$lang['newslettercreatederror'] = 'Musisz wprowadzić nazwę i opis.';
$lang['accessdenied'] = 'Dostęp zabroniony. Proszę sprawdź swoje uprawnienia.';
$lang['error'] = 'Błąd!';
$lang['sent'] = 'wysłany';
$lang['inqueue'] = 'w kolejce';
$lang['send_next_batch'] = 'Wysyłam kolejną porcję %s emaili; rozpoczynając od: %s';
$lang['messages_sent'] = '%s zostało wysłanych';
$lang['closewindow'] = 'Zamknij okno';
$lang['testmode'] = 'Jesteś aktualnie w trybie testowym. Żadne emaile nie zostaną wysłane.';
$lang['confirmdeletejob'] = 'Czy na pewno chcesz usunąć to zadanie?';
$lang['confirmsend'] = 'Czy na pewno chcesz wysłać wszystkie wiadomości?';
$lang['confirmdelete'] = 'Czy na pewno chcesz usunąć tą wiadomość?';
$lang['confirmdeletelist'] = 'Czy na pewno chcesz usunąć tą listę?';
$lang['keepwindowopen'] = 'Zostaw to okno otwarte do momentu aż wszystkie wiadomości zostaną wysłane.<br>';
$lang['profileupdated'] = 'Tw&oacute;j profil został uaktualniony.';
$lang['upgraded'] = 'Moduł został uaktualniony do wersji %s.';
$lang['title_mod_prefs'] = 'Konfiguracja';
$lang['title_mod_messages'] = 'Kolejka wiadomości';
$lang['title_mod_createnew'] = 'Utw&oacute;rz listę';
$lang['title_mod_manage_user'] = 'Subskrybent&oacute;w';
$lang['title_mod_compose_job'] = 'Utw&oacute;rz zadanie';
$lang['title_mod_compose_message'] = 'Napisz wiadomość';
$lang['title_mod_process_queue'] = 'Przetwarzaj kolejkę';
$lang['title_mod_admin'] = 'Zarządzaj listami pocztowymi';
$lang['user_delete_confirm'] = 'Czy na pewno chcesz usunąć tego subskrybenta?';
$lang['userdeleted'] = 'Subskrybent usunięty';
$lang['newsletterdeleted'] = 'Newsletter usunięty';
$lang['delete'] = 'Usuń';
$lang['edit'] = 'Edytuj';
$lang['previous'] = 'Poprzednia';
$lang['next'] = 'Następna';
$lang['unsubscribemessage'] = 'Rezygnacja z subskrypcji została wykonana. Dziękujemy.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Ten moduł pozwala na zarządanie listami pocztowymi.';
$lang['welcome_text'] = '<p>Witamy w panelu administracyjnym modułu Newsletter Made Simple (MNS)</p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as disabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0. - Beta 6 (September, 2006)  
<p>This is essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and brought up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<p>This version requires CMS 1.0 and fixes alot of the bugs, including the &amp; issue that alot of overseas users were having problems with.  I won&#039;t release a 1.0 final, until such time as I get the user preferences done, or remove that stuff all together.</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpselect'] = 'Określ listę oddzielając przecinkami list pocztowych do wyświetlenia.  <em>(Poprawne tylko w trybie subskrypcji)</em>';
$lang['helpmode'] = 'Określ tryb operacji. Dostępne opcje:
<ul>
<li>subscribe (default) - wyświetla formularz subskrypcji</li>
<li>unsubscribe - wyświetla formularz rezygnacji z subskrypcji</li>
<li>usersettings - wyświetla formularz ustawień użytkownika</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>
<h3>How do I use it?</h3>
<p>1. Install the module.<br>
2. Allow the correct people permissions to access NMS<br>
3. Configure NMS using the &quot;configuration&quot; panel in the NMS Module. <br>
<ul>
<li>There are numerous templates and prompts that can be customized for your installation</li>
</ul>
4. Create a list or two or three<br>
<ul>
<li>You can create private lists and public lists.  Users can subscribe and unsubscribe at any time from public lists, and they are shown in the front end</li>
<li>Membership in private lists is controlled by the administrator, and users cannot unsubscribe from them</li>
</ul>
5. Insert the module code into a template or content page using syntax below.<br>
6. Write one or more messages which will be saved into the message &quot;queue&quot;.<br>
7. Create a job by selecting a message, and one or more lists.<br/>
&nbsp;&nbsp;<strong>Note:</strong> Users will only be sent one message even if they are a member of multiple selected groups<br/>
8. Process the queue to send the messages out.</p>
<h3>Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.26322315.1153698979.1165670262.1166657749.66';
$lang['utmz'] = '156861353.1166657749.66.29.utmccn=(referral)|utmcsr=wiki.cmsmadesimple.org|utmcct=/index.php/User_Handbook/Admin_Panel/pl|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ru_RU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['info_event_OnNewUser'] = 'Генерируется, когда новый пользователь подписывается на одну, или более расслылку(и)';
$lang['info_event_OnEditUser'] = 'Генирируется, когда пользователь становистя администратором или переходит в передний конец ';
$lang['info_event_OnDeleteUser'] = 'Генирируется, когда пользователь удален';
$lang['info_event_OnNewList'] = 'Генирируется, когда список рассылки модифицирован';
$lang['info_event_OnDeleteList'] = 'Генирируется, когда список рассылки удален';
$lang['info_event_OnCreateMessage'] = 'Генирируется, когда сообщение было создано';
$lang['info_event_OnEditMessage'] = 'Генирируется, когда сообщение было модифицировано';
$lang['info_event_OnDeleteMessage'] = 'Генирируется, когда сообщение было удалено';
$lang['info_event_OnCreateJob'] = 'Генирируется, когда работа создана';
$lang['info_event_OnDeleteJob'] = 'Генирируется, когда работа удалена';
$lang['info_event_OnStartJob'] = 'Генирируется, когда начинается обаработка работы';
$lang['info_event_OnFinishJob'] = 'Генирируется, когда обаработка работы заканчивается';
$lang['help_OnNewUser'] = '<p>An event generated when a new user subscribes to one or more mailing lists</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
</ul>
';
$lang['help_OnEditUser'] = '<p>An event generated when a user is modified either in the admin or via the front end</p>
<h4>Parameters</h4>
<ul>
<li><em>email</em> - Users email address</li>
<li><em>username</em> - Username</li>
<li><em>lists</em> - Array of member lists</li>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnDeleteUser'] = '<p>An event generated when a user is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>id</em> - The user id</li>
</ul>
';
$lang['help_OnNewList'] = '<p>An event generated when a new mailing list is created</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
</ul>
';
$lang['help_OnEditList'] = '<p>An event generated when a mailing list is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>name</em> - The list name</li>
<li><em>description</em> - List description</li>
<li><em>public</em> - Public flag</li>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnDeleteList'] = '<p>An event generated when a mailing list is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>listid</em> - The list ID</li>
</ul>
';
$lang['help_OnCreateMessage'] = '<p>An event generated when a message is created</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>entered</em> - The date the message was entered</li>
<li><em>uniqueid</em> - The unique id of this message</em>
</ul>
';
$lang['help_OnEditMessage'] = '<p>An event generated when a message is modified</p>
<h4>Parameters</h4>
<ul>
<li><em>fromwho</em> - The Name of the person this message is from</li>
<li><em>reply_to</em> - The Email address for the reply to field</li>
<li><em>subject</em> - The subject of the message</li>
<li><em>message</em> - The body of the message <em>(may contain smarty tags)</em></li>
<li><em>messageid</em> - The ID of this message</id>
</ul>
';
$lang['help_OnDeleteMessage'] = '<p>An event generated when a message is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>messageid</em> - The ID of the message that has been deleted</li>
</ul>
';
$lang['help_OnCreateJob'] = '<p>An event generated when a job is created</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
<li><em>lists</em> - An array of listids</li>
</ul>
';
$lang['help_OnDeleteJob'] = '<p>An event generated when a job is deleted</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
</ul>
';
$lang['help_OnStartJob'] = '<p>An event generated when the processing of a job begins</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['help_OnFinishJob'] = '<p>An event generated when the processing of a job finishes</p>
<h4>Parameters</h4>
<ul>
<li><em>jobid</em> - The ID of this job</li>
<li><em>jobname</em> - The name of this job</li>
</ul>
';
$lang['error_needreplyto'] = 'Вы должны правильный е-mail адрес, имя, соообщение и тему. ';
$lang['error_dberror'] = 'Ошибка базы данных ';
$lang['invalidparam'] = 'Недопустимый параметр в теге модуля NMS';
$lang['prompt_users_per_page'] = 'Число пользователей, для отображения на каждой странице пользовательского списка';
$lang['disabled'] = 'Блокировано';
$lang['confirmed'] = 'Подтверждено';
$lang['prompt_usersettings_text2'] = 'Текст, отображаемый после пользовательской формы настройки параметров представлен';
$lang['prompt_usersettings_form2'] = 'Форма, отображаемая пользователям, желающим изменить настройки';
$lang['prompt_usersettings_text'] = 'Текст, отображаемый после пользовательского сообщения настройки параметров  отослан';
$lang['prompt_usersettings_email_body'] = ' Тело письма о настройках пользователя';
$lang['prompt_usersettings_subject'] = 'Тема письма о настройках пользователя';
$lang['prompt_usersettings_form'] = 'Форма, спрашивающая пользователей, которые хотят изменить настройки, адрес электронной почты';
$lang['prompt_post_unsubscribe_text'] = 'Текст, отображаемый по завершении процесса отказа от рассылки.';
$lang['user_settings'] = 'Настройки пользователя';
$lang['prompt_unsubscribe_prompt'] = '';
$lang['prompt_unsubscribe_text'] = 'Text displayed after unsubscribe form is completed';
$lang['prompt_unsubscribe_subject'] = 'Subject of the email sent to unsubscribe';
$lang['prompt_unsubscribe_email_body'] = 'Body of the email sent to unsubscribe';
$lang['prompt_unsubscribe_form'] = 'Template for the unsubscribe form';
$lang['error_accountdisabled'] = 'We are sorry, but your account has been disabled and this action is not possible at this time';
$lang['error_insufficientparams'] = 'One or more required parameters are missing from the request.  This action cannot proceed';
$lang['prompt_post_confirm_text'] = 'Сообщение демонстрируется после подтверждения е-mail';
$lang['prompt_confirm_email_body'] = 'Подтверждение е-mail адреса';
$lang['prompt_confirm_subject'] = 'Подтверждение темы е-mail';
$lang['confirm_subscribe'] = 'Подтвердить подписку';
$lang['confirm_unsubscribe'] = 'Подтвердить отписку';
$lang['nolists'] = 'Не найдено списков для подписки';
$lang['public'] = 'Общедоступный';
$lang['yes'] = 'Да';
$lang['no'] = 'Нет';
$lang['prompt_postsubscribetext'] = 'Сообщение демонстрируется после подписки';
$lang['subscription_confirmed'] = 'Subscription confirmed';
$lang['reset'] = 'Сброс';
$lang['suspend'] = 'Приостанавить';
$lang['resume'] = 'Продолжить';
$lang['action'] = 'Действие';
$lang['processing_records'] = 'Processing records %s to %s';
$lang['initializing_job'] = 'Инициализировать работу';
$lang['processing_job'] = 'Processing Job';
$lang['deletecompleted'] = 'Удалить Completed Jobs';
$lang['error_importerrorcount'] = 'Error count';
$lang['lines'] = 'Списки';
$lang['users_added'] = 'Пользователи добавлены';
$lang['memberships'] = 'Memberships';
$lang['subscribe'] = 'Подписаться';
$lang['resetdefaults'] = 'Reset to Defaults';
$lang['confirm_adjustsettings'] = 'Are you sure you want to adjust these settings?';
$lang['confirm_resetdefaults'] = 'Are you sure you want to reset this form to its system default value?';
$lang['prompt_subscribetext'] = 'Subscribe Text';
$lang['prompt_subscribesubject'] = 'Subscribe Subject';
$lang['prompt_subscribe_email_body'] = 'Subscribe Email Body';
$lang['prompt_subscribe_form'] = 'Шаблон для формы подписки';
$lang['subscribe_form'] = 'Подписаться';
$lang['unsubscribe_form'] = 'Отписаться';
$lang['error_insertinglist'] = 'Problem creating the new list';
$lang['error_emailexists'] = 'Этот e- mail адрес уже существует в списках пользователей';
$lang['error_invalidusername'] = 'Ошибочное имя пользователя';
$lang['error_invalidid'] = 'Ошибочный  id ';
$lang['username'] = 'Имя пользователя';
$lang['name'] = 'Имя';
$lang['prompt_public'] = 'This is a public mailing list';
$lang['error_usernotfound'] = 'Could not find user with specified uniqueid';
$lang['prompt_ms_between_message_sleep'] = 'Delay (in milliseconds) between sending each message';
$lang['prompt_between_batch_sleep'] = 'Delay (in seconds) between each batch';
$lang['prompt_messages_per_batch'] = 'The maximum number of messages to send in a batch';
$lang['okclosewindow'] = 'You can now close this window';
$lang['queuefinished'] = 'Processing of output queue finished';
$lang['totaltime'] = 'Total processing time:';
$lang['seconds'] = 'Секунды';
$lang['totalmails'] = 'Общее количество отосланных E-mail (включая администраторские):';
$lang['page'] = 'Страница';
$lang['of'] = 'из';
$lang['info_csvformat'] = 'The import file must be in CSV (comma separated value) format, one entry per line.  The first field should be an email address, the second field a username, and the third a list name.  Email addresses may be repeated on subsequent lines (particularly for different lists).';
$lang['prompt_lines'] = 'Списки импортированы';
$lang['prompt_usersadded'] = 'Пользователи добавлены';
$lang['prompt_membershipsadded'] = 'Членство добавлено';
$lang['prompt_errorcount'] = 'Количество ошибок';
$lang['importerror_cantgetuserid'] = 'Ошибка на линии %s, невозможно найти идентификатор пользователя %s';
$lang['importerror_cantcreateuser'] = 'Ошибка на линии %s, невозможно создать пользователя %s';
$lang['importerror_nosuchlist'] = 'Ошибка на линии %s, такого списка не существует %s';
$lang['importerror_nofields'] = 'Ошибка на линии %s, недостаточно полей';
$lang['import_users'] = 'Import Users from CSV';
$lang['error_emptyfile'] = 'ОШИБКА- был закачан пустой файл';
$lang['error_nofilesuploaded'] = 'ОШИБКА- ни один из файлов не был закачан';
$lang['filename'] = 'Import Filename';
$lang['title_users_import'] = 'Import Users';
$lang['nummessages'] = '# сообещения';
$lang['created'] = 'Создано ';
$lang['started'] = 'Начато';
$lang['finished'] = 'Закончено';
$lang['processjobs'] = 'Process Jobs';
$lang['status_error'] = 'ОШИБКА';
$lang['status_unstarted'] = 'Не начато';
$lang['status_inprogress'] = 'Выполняется';
$lang['status_paused'] = 'На паузе';
$lang['status_complete'] = 'Завершено';
$lang['status_unknown'] = 'Unknown';
$lang['error_jobnameexists'] = 'ОШИБКА- работа с таким названием уже существует';
$lang['createjob'] = 'Создать работу';
$lang['prompt_email_user_on_admin_subscribe'] = 'Отправить пользователям письмо, когда администратор вручную добавляется членство в список';
$lang['error_nomessagesselected'] = 'Не выбраны сообщения';
$lang['error_nolistsselected'] = 'Не выбраны списки';
$lang['createjobmsg'] = 'Select one message, and one ore more lists to send the message to';
$lang['error_nojobname'] = 'ОШИБКА- No job name specified';
$lang['error_nolists'] = 'ОШИБКА- нет списков!';
$lang['error_nomessages'] = 'ОШИБКА- нет сообещний!';
$lang['jobs'] = 'Работы';
$lang['status'] = 'Статус';
$lang['jobsfoundtext'] = 'Работы найдены';
$lang['messagesfoundtext'] = 'Сообещния найдены';
$lang['entered'] = 'Внесенный';
$lang['subject'] = 'Тема';
$lang['from'] = 'От';
$lang['delete_user_confirm'] = 'Are you sure you want to delete this user';
$lang['info_singlelist'] = 'This user will be added to the sole mailing list';
$lang['error_selectonelist'] = 'ОШИБКА- You must select atleast one list';
$lang['error_invalidemail'] = 'ОШИБКА- ошибочный email адрес ';
$lang['userid'] = 'ID пользователя';
$lang['emailaddress'] = 'Адрес электронной поты';
$lang['usersfoundtext'] = 'Пользователи найдены';
$lang['title_user_createnew'] = 'Добавить пользователя';
$lang['error_invalidlistname'] = 'ОШИБКА- ошибочное имя списка';
$lang['editlist_text'] = 'Редактировать список';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Список найден';
$lang['users'] = 'Пользователи';
$lang['preferences'] = 'Глобальные параметры';
$lang['messages'] = 'Сообещния';
$lang['queue'] = 'Очередь';
$lang['submit'] = 'Утвердить';
$lang['description'] = 'Отписание';
$lang['createnewlist_text'] = 'Создать список';
$lang['lists'] = 'Списки';
$lang['friendlyname'] = 'Newsletter Made Simple';
$lang['postinstall'] = 'Thank you for installing NMS. Be sure to set "Use NMS" permissions to use this module!';
$lang['postuninstall'] = 'Newsletter Made Simple Uninstalled.';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['prefsupdated'] = 'Newsletter Made Simple Module preferences updated.';
$lang['newslettercreated'] = 'A new newsletter has been created.';
$lang['no_email_error'] = 'You must fill in an email address.';
$lang['subscribe_thankyou'] = 'Thank you for subscribing. A confirmation e-mail has been sent to your inbox.';
$lang['enter_valid_email'] = 'You must enter a valid e-mail address and select at least one list.';
$lang['newslettercreatederror'] = 'You must enter a name and description.';
$lang['accessdenied'] = 'Access Denied. Please check your permissions.';
$lang['error'] = 'Error!';
$lang['sent'] = 'Sent';
$lang['inqueue'] = 'In Queue';
$lang['send_next_batch'] = 'Sending the next batch of %s emails; starting at: %s';
$lang['messages_sent'] = '%s have been sent';
$lang['closewindow'] = 'Close Window';
$lang['testmode'] = 'You are in test mode. No e-mails will be sent.';
$lang['confirmdeletejob'] = 'Are you sure you want to delete this job';
$lang['confirmsend'] = 'Are you sure you want to send all messages?';
$lang['confirmdelete'] = 'Are you sure you want to delete this message?';
$lang['confirmdeletelist'] = 'Are you sure you want to delete this list?';
$lang['keepwindowopen'] = 'Keep this window open till all messages have been sent.<br>';
$lang['profileupdated'] = 'Your profile has been updated.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['title_mod_prefs'] = 'Configuration';
$lang['title_mod_messages'] = 'Message Queue';
$lang['title_mod_createnew'] = 'Create a List';
$lang['title_mod_manage_user'] = 'Users';
$lang['title_mod_compose_job'] = 'Create Job';
$lang['title_mod_compose_message'] = 'Compose Message';
$lang['title_mod_process_queue'] = 'Process Queue';
$lang['title_mod_admin'] = 'Manage Lists';
$lang['user_delete_confirm'] = 'Are you sure you want to delete this user?';
$lang['userdeleted'] = 'User Deleted';
$lang['newsletterdeleted'] = 'Newsletter Deleted';
$lang['delete'] = 'Delete';
$lang['edit'] = 'Edit';
$lang['previous'] = 'Previous';
$lang['next'] = 'Next';
$lang['unsubscribemessage'] = 'You have been unsubscribed. Thank you.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'This module is a module that allows you to create a newsletter system.';
$lang['welcome_text'] = '<p>Welcome to Newsletter Made Simple (MNS) Module admin section. </p>';
$lang['changelog'] = '<ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users Tab - Filtering on list membership (maybe regexp later)</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as diabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0 July, 2006.  
<p>This is essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and brought up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username (optional)</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a \'private list\'</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
<li>Events that can be trapped to add additional behaviour</li>
</ul>
<p><strong>Note</strong>, upgrade from the previous version is not possible.  A complete uninstall of the old version is required before installing this version of NMS.</p>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>
<h3>How do I use it?</h3>
<p>1. Install the module.<br>
2. Allow the correct people permissions to access NMS<br>
3. Configure NMS using the "configuration" panel in the NMS Module. <br>
<ul>
<li>There are numerous templates and prompts that can be customized for your installation</li>
</ul>
4. Create a list or two or three<br>
<ul>
<li>You can create private lists and public lists.  Users can subscribe and unsubscribe at any time from public lists, and they are shown in the front end</li>
<li>Membership in private lists is controlled by the administrator, and users cannot unsubscribe from them</li>
</ul>
5. Insert the module code into a template or content page using syntax below.<br>
6. Write one or more messages which will be saved into the message "queue".<br>
7. Create a job by selecting a message, and one or more lists.<br/>
&nbsp;&nbsp;<strong>Note:</strong> Users will only be sent one message even if they are a member of multiple selected groups<br/>
8. Process the queue to send the messages out.</p>
<h3>Syntax</h3>
<p>	{cms_module module=\'NMS\'}</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=\'http://dev.cmsmadesimple.org/projects/newsletter/\' target=\'_blank\'>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=\'http://forum.cmsmadesimple.org\' target=\'_blank\'>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=\'irc://irc.freenode.net/#cms\'>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright © 2005, Paul Lemke <a href=\'mailto:lemkepf@gmx.net\'><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=\'http://www.gnu.org/licenses/licenses.html#GPL\'>GNU Public License</a>. You must agree to this license before using the module.</p>
';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['prompt_users_per_page'] = 'Antal anv&auml;ndare att visa p&aring; varje sida av anv&auml;ndarlistan';
$lang['disabled'] = 'Avaktiverad';
$lang['confirmed'] = 'Bekr&auml;ftad';
$lang['prompt_usersettings_text2'] = 'Text som visas efter att anv&auml;ndarinst&auml;llningsformul&auml;ret skickats';
$lang['prompt_usersettings_form2'] = 'Formul&auml;r som visas f&ouml;r anv&auml;ndare som vill &auml;ndra inst&auml;llningar';
$lang['prompt_usersettings_text'] = 'Text som visas efter att e-postmeddelande med anv&auml;ndarinst&auml;llningar skickats';
$lang['prompt_usersettings_email_body'] = 'Meddelandet i e-postmeddelandet med anv&auml;ndarinst&auml;llningar';
$lang['prompt_usersettings_subject'] = '&Auml;mne f&ouml;r e-postmeddelande med anv&auml;ndarinst&auml;llningar';
$lang['prompt_usersettings_form'] = 'Formul&auml;r d&auml;r anv&auml;ndare som vill &auml;ndra sina inst&auml;llningar skriver in e-postadress';
$lang['prompt_post_unsubscribe_text'] = 'Text som visas efter att avregistreringsprocessen &auml;r genomf&ouml;rd';
$lang['user_settings'] = 'Anv&auml;ndarinst&auml;llningar';
$lang['prompt_unsubscribe_prompt'] = 'Inmatningsmark&ouml;r d&auml;r anv&auml;ndaren fr&aring;gas efter sin e-postadress f&ouml;r att avregistrera sig';
$lang['prompt_unsubscribe_text'] = 'Text som visas efter att formul&auml;ret f&ouml;r att avregistrera har skickats';
$lang['prompt_unsubscribe_subject'] = '&Auml;mne f&ouml;r e-postmeddelandet som skickas n&auml;r n&aring;gon vill avregistrera sig';
$lang['prompt_unsubscribe_email_body'] = 'Meddelandet i e-postmeddelande som skickas n&auml;r n&aring;gon vill avregistrera sig';
$lang['prompt_unsubscribe_form'] = 'Mall f&ouml;r avregistreringsformul&auml;r';
$lang['error_accountdisabled'] = 'Tyv&auml;rr, men ditt konto har avaktiverats och handlingen &auml;r just nu inte m&ouml;jlig';
$lang['error_insufficientparams'] = 'En eller fler n&ouml;dv&auml;ndiga parametrar saknas fr&aring;n f&ouml;rfr&aring;gan. Den h&auml;r h&auml;ndelsen kan inte forts&auml;tta';
$lang['prompt_post_confirm_text'] = 'Meddelande som visas efter att anv&auml;ndare bekr&auml;ftat e-postmeddelande';
$lang['prompt_confirm_email_body'] = 'Meddelande f&ouml;r bekr&auml;ftelsemail';
$lang['prompt_confirm_subject'] = '&Auml;mne f&ouml;r bekr&auml;ftelsemail';
$lang['confirm_subscribe'] = 'Bekr&auml;fta registrering';
$lang['confirm_unsubscribe'] = 'Bekr&auml;fta avregistrering';
$lang['nolists'] = 'Inga listor finns att registrera sig f&ouml;r';
$lang['public'] = 'Offentlig';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nej';
$lang['prompt_postsubscribetext'] = 'Meddelande som visas efter registrering';
$lang['subscription_confirmed'] = 'Registrering bekr&auml;ftad';
$lang['reset'] = '&Aring;terst&auml;ll';
$lang['suspend'] = 'Uteslut';
$lang['resume'] = '&Aring;teruppta';
$lang['action'] = 'H&auml;ndelse';
$lang['processing_records'] = 'Behandlar posterna %s till %s';
$lang['initializing_job'] = 'Initierar jobb';
$lang['processing_job'] = 'Behandlar jobb';
$lang['deletecompleted'] = 'Radera utf&ouml;rda jobb';
$lang['error_importerrorcount'] = 'Felr&auml;kning';
$lang['lines'] = 'Rader';
$lang['users_added'] = 'Anv&auml;ndare tillagda';
$lang['memberships'] = 'Medlemskap';
$lang['subscribe'] = 'Registrera';
$lang['resetdefaults'] = '&Aring;terst&auml;ll standardinst&auml;llningar';
$lang['confirm_adjustsettings'] = '&Auml;r du s&auml;ker p&aring; att du vill &auml;ndra de h&auml;r inst&auml;llningarna?';
$lang['confirm_resetdefaults'] = '&Auml;r du s&auml;ker p&aring; att du vill &aring;terst&auml;lla det h&auml;r formul&auml;ret till dess ursprungliga v&auml;rden?';
$lang['prompt_subscribetext'] = 'Registreringstext';
$lang['prompt_subscribesubject'] = '&Auml;mne f&ouml;r registrering';
$lang['prompt_subscribe_email_body'] = 'Meddelande f&ouml;r registreringsmail';
$lang['prompt_subscribe_form'] = 'Mall f&ouml;r registreringsformul&auml;ret';
$lang['subscribe_form'] = 'Registrera';
$lang['unsubscribe_form'] = 'Avregistrera';
$lang['error_insertinglist'] = 'Problem att skapa ny lista';
$lang['error_emailexists'] = 'Den e-postadressen finns redan i anv&auml;ndarlistan';
$lang['error_invalidusername'] = 'Otill&aring;tet anv&auml;ndarnamn';
$lang['error_invalidid'] = 'Otill&aring;tet unik-ID';
$lang['username'] = 'Anv&auml;ndarnamn';
$lang['name'] = 'Namn';
$lang['prompt_public'] = 'Detta &auml;r en offentlig e-postlista';
$lang['error_usernotfound'] = 'Kunde inte hitta anv&auml;ndare med det angivna unik-ID&#039;t';
$lang['prompt_ms_between_message_sleep'] = 'F&ouml;rdr&ouml;jning (i millisekunder) mellan varje meddelande som s&auml;nds';
$lang['prompt_between_batch_sleep'] = 'F&ouml;rdr&ouml;jning (i sekunder) mellan varje omg&aring;ng av mail som s&auml;nds';
$lang['prompt_messages_per_batch'] = 'Maximalt antal meddelanden som s&auml;nds i varje omg&aring;ng';
$lang['okclosewindow'] = 'Du kan nu st&auml;nga det h&auml;r f&ouml;nstret';
$lang['queuefinished'] = 'Meddelandena i k&ouml;n har s&auml;nts';
$lang['totaltime'] = 'Total tid f&ouml;r att s&auml;nda meddelanden:';
$lang['seconds'] = 'Sekunder';
$lang['totalmails'] = 'Totalt antal epostmeddelanden som s&auml;nts (inkl. till administrat&ouml;ren):';
$lang['page'] = 'Sida';
$lang['of'] = 'av';
$lang['info_csvformat'] = 'Den importerade filen m&aring;ste vara i formatet CSV (kommaseparerat), med en post per rad. Det f&ouml;rsta f&auml;ltet ska vara en epostadress, och det andra f&auml;ltet namn p&aring; en lista. Epostadresserna kan repeteras p&aring; flera rader';
$lang['prompt_lines'] = 'Rader importerade';
$lang['prompt_usersadded'] = 'Anv&auml;ndare tillagda';
$lang['prompt_membershipsadded'] = 'Prenumeranter tillagda';
$lang['prompt_errorcount'] = 'Antal fel';
$lang['importerror_cantgetuserid'] = 'Fel p&aring; rad %s, kunde inte l&auml;sa userid (anv&auml;ndar-ID) %s';
$lang['importerror_cantcreateuser'] = 'Fel p&aring; rad %s, kunde inte skapa anv&auml;ndare %s';
$lang['importerror_nosuchlist'] = 'Fel p&aring; rad %s, listan %s finns inte';
$lang['importerror_nofields'] = 'Fel p&aring; rad %s, inte tillr&auml;ckligt m&aring;nga f&auml;lt';
$lang['import_users'] = 'Importera anv&auml;ndare fr&aring;n CSV';
$lang['error_emptyfile'] = 'FEL - En tom fil laddades upp';
$lang['error_nofilesuploaded'] = 'FEL - inga filer laddades upp';
$lang['filename'] = 'Importera filnamn';
$lang['title_users_import'] = 'Importera anv&auml;ndare';
$lang['nummessages'] = 'antal meddelanden';
$lang['created'] = 'Skapad';
$lang['started'] = 'Startad';
$lang['finished'] = 'Avslutad';
$lang['processjobs'] = 'S&auml;nd jobb';
$lang['status_error'] = 'FEL';
$lang['status_unstarted'] = 'Ej startad';
$lang['status_inprogress'] = 'under arbete';
$lang['status_paused'] = 'Pausad';
$lang['status_complete'] = 'Komplett';
$lang['status_unknown'] = 'Ok&auml;nd';
$lang['error_jobnameexists'] = 'FEL - Ett jobb med det namnet finns redan';
$lang['createjob'] = 'Skapa jobb';
$lang['prompt_email_user_on_admin_subscribe'] = 'Skicka email till anv&auml;ndare n&auml;r administrat&ouml;ren manuellt l&auml;gger till prenumeranter till en lista';
$lang['error_nomessagesselected'] = 'Inga meddelanden valda';
$lang['error_nolistsselected'] = 'Inga listor valda';
$lang['createjobmsg'] = 'V&auml;lj ett meddelande, och en eller flera listor att skicka meddelandet till';
$lang['error_nojobname'] = 'FEL - Inga jobbnamn specificerade';
$lang['error_nolists'] = 'FEL - Inga listor!';
$lang['error_nomessages'] = 'FEL - Inga meddelanden!';
$lang['jobs'] = 'Jobb';
$lang['status'] = 'Status';
$lang['jobsfoundtext'] = 'Jobb funna';
$lang['messagesfoundtext'] = 'Meddelanden funna';
$lang['entered'] = 'Angett';
$lang['subject'] = '&Auml;mne';
$lang['from'] = 'Fr&aring;n';
$lang['delete_user_confirm'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort den h&auml;r anv&auml;ndaren';
$lang['info_singlelist'] = 'Den h&auml;r anv&auml;ndaren l&auml;ggs till till den enda mailinglistan';
$lang['error_selectonelist'] = 'Du m&aring;ste v&auml;lja minst en lista';
$lang['error_invalidemail'] = 'FEL - Ogiltig epostadress';
$lang['userid'] = 'Anv&auml;ndar-ID';
$lang['emailaddress'] = 'Epostadress';
$lang['usersfoundtext'] = 'Anv&auml;ndare funna';
$lang['title_user_createnew'] = 'L&auml;gg till anv&auml;ndare';
$lang['error_invalidlistname'] = 'FEL - Ogiltigt listnamn';
$lang['editlist_text'] = 'Redigera lista';
$lang['id'] = 'ID';
$lang['listsfoundtext'] = 'Listor funna';
$lang['users'] = 'Anv&auml;ndare';
$lang['preferences'] = 'Inst&auml;llningar';
$lang['messages'] = 'Meddelanden';
$lang['queue'] = 'K&ouml;';
$lang['submit'] = 'Skicka';
$lang['description'] = 'Beskrivning';
$lang['createnewlist_text'] = 'Skapa lista';
$lang['lists'] = 'Listor';
$lang['friendlyname'] = 'NewsletterMadeSimple';
$lang['postinstall'] = 'Tack f&ouml;r att du installerade NMS. Gl&ouml;m inte att st&auml;lla in r&auml;ttigheten &quot;Use NMS&quot; f&ouml;r att anv&auml;nda den h&auml;r modulen!';
$lang['postuninstall'] = 'Newsletter Made Simple &auml;r avinstallerat.';
$lang['uninstalled'] = 'Modulen har avinstallerats.';
$lang['installed'] = 'Modul med versionsnummer %s &auml;r installerad.';
$lang['prefsupdated'] = 'Inst&auml;llningar f&ouml;r modulen Newsletter Made Simple uppdaterade.';
$lang['newslettercreated'] = 'Ett nytt nyhetsbrev har skapats.';
$lang['no_email_error'] = 'Du m&aring;ste fylla i en epostadress.';
$lang['subscribe_thankyou'] = 'Tack f&ouml;r din prenumeration. Ett bekr&auml;ftelsemail har skickats till din epostadress.';
$lang['enter_valid_email'] = 'Du m&aring;ste ange en giltig epostadress och v&auml;lja &aring;tminstone en lista.';
$lang['newslettercreatederror'] = 'Du m&aring;ste ange ett namn och en beskrivning.';
$lang['accessdenied'] = 'Tillst&aring;nd nekat. V&auml;nligen kontrollera dina r&auml;ttigheter.';
$lang['error'] = 'Fel!';
$lang['sent'] = 'Skickat';
$lang['inqueue'] = 'I k&ouml;';
$lang['send_next_batch'] = 'Skickar n&auml;sta omg&aring;ng av %s-meddelande, med b&ouml;rjan kl. %s';
$lang['messages_sent'] = '%s har skickats';
$lang['closewindow'] = 'St&auml;ng f&ouml;nster';
$lang['testmode'] = 'Du &auml;r i testl&auml;ge. Inga epostmeddelanden skickas.';
$lang['confirmdeletejob'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort det h&auml;r jobbet';
$lang['confirmsend'] = '&Auml;r du s&auml;ker p&aring; att du vill skicka alla meddelanden?';
$lang['confirmdelete'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort det h&auml;r meddelandet?';
$lang['confirmdeletelist'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort den h&auml;r listan?';
$lang['keepwindowopen'] = 'L&aring;t det h&auml;r f&ouml;nstret vara &ouml;ppet tills alla meddelanden har skickats.<br />';
$lang['profileupdated'] = 'Din profil har uppdaterats.';
$lang['upgraded'] = 'Modulen uppgraderad till version %s.';
$lang['title_mod_prefs'] = 'Konfiguration';
$lang['title_mod_messages'] = 'Meddelandek&ouml;';
$lang['title_mod_createnew'] = 'Skapa en lista';
$lang['title_mod_manage_user'] = 'Prenumeranter';
$lang['title_mod_compose_job'] = 'Skapa jobb';
$lang['title_mod_compose_message'] = 'Skriv meddelande';
$lang['title_mod_process_queue'] = 'Skicka k&ouml;';
$lang['title_mod_admin'] = 'Hantera listor';
$lang['user_delete_confirm'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort den h&auml;r anv&auml;ndaren?';
$lang['userdeleted'] = 'Anv&auml;ndare borttagen';
$lang['newsletterdeleted'] = 'Nyhetsbrev borttaget';
$lang['delete'] = 'Ta bort';
$lang['edit'] = 'Redigera';
$lang['previous'] = 'F&ouml;reg&aring;ende';
$lang['next'] = 'N&auml;sta';
$lang['unsubscribemessage'] = 'Du &auml;r nu avregistrerad. Tack.';
$lang['title_admin_panel'] = 'Newsletter Made Simple';
$lang['moddescription'] = 'Den h&auml;r modulen l&aring;ter dig skapa ett system f&ouml;r nyhetsbrev.';
$lang['welcome_text'] = '<p>V&auml;lkommen till administrationem f&auml;r Newsletter Made Simple (NMS). </p>';
$lang['changelog'] = 'ul>
<li>Todo:
<ul>
<li>Upgrading</li>
<li>Lists Tab - show disabled vs active lists</li>
<li>Lists - ability to Mark a list as inactive</li>
<li>Users Tab - Filtering on list membership (maybe regexp later)</li>
<li>Users - Ability to filter on confirmed or unconfirmed
<p>Admin should be able to check all unconfirmed users and either confirm them all, or send them another confirmation email message</p>
<li>Users - Ability to mark a user as diabled</li>
<li>Users - Ability to prefer text or html mail (much later)</li>
<li>Preferences - Ability to mark output messages as bulk or not</li>
<li>Something to allow a user to re-get the confirmation email</li>
<li>Docs, docs, and more docs</li>
<li><b>The frontend</b></li>
<ul>
  <li>complete the two stage unsubscribe process</li>
  <li>complete the two stage change preferences process</li>
  <li>Add a preference as to wether or not users should get a confirmation email after subscribing and unsubscribing</p>
</ul>
<li>Styling the progress page</li>
<li>Check for hardcoded strings</li>
<li>HTML vs Non HTML mail</li>
<li>Export users<li>
</ul>
</li>
<li>Version 1.0 April, 2006.  
<p>This is essentially a complete rewrite of the old NMS module.  Everything has been cleaned up and brought up to proper standards, and lots of new features added. here is a list of the major improvements:</p>
<ul>
<li>Cleanup of the lang strings, etc.</li>
<li>Param-ize the queries for security</li>
<li>Added the concept of Jobs, so that messages can be re-used</li>
<li>Added the concept of username</li>
<li>Added smarty processing on templates</li>
<li>Added bulk import</li>
<li>Added the concept of a &#039;private list&#039;</p>
<li>Devided the admin panel into tabs</li>
<li>Show progress nicely when processing large jobs</li>
<li>Uses CMSMailer module</li>
</ul>
</li>
<li>Version .74 27 November 2005. Alpha 3 Release. Fixed bug with confirmation message returnid, image urls, windows php, and a few other small issues.</li>
<li>Version .73 23 November 2005. Alpha 2 Release. Fixed bug with adding messages.</li>
<li>Version .71 22 November 2005. Alpha 1 Release.</li>
<li>Version .5. 17 September 2005. Internal Release.</li>
</ul>';
$lang['helpmode'] = 'Specify the mode of operation. options are:
<ul>
<li>subscribe (default) - display the subscribe form</li>
<li>unsubscribe - display the unsubscribe form</li>
<li>usersettings - display the usersettings form</li>
</ul>
';
$lang['help'] = '<h3>Newsletter Made Simple (NMS) </h3>
<h3><strong>What does it do?  </strong></h3>
<p>Enables you to have a e-mail newsletter system inside CMS Made Simple. </p>
<h3>How do I use it?</h3>
<p>1. Install module. <br>
2. Allow the correct people permissions to access NMS<br>
  3. Configure NMS using the &quot;configuration&quot; panel in the NMS Module. <br>
4. Create a list. <br>
5. Put into a template or content page using syntax below.<br>
6. Once users sign up, go ahead and write some messages which will be saved into the message &quot;queue&quot;.<br>
7. Process the queue to send the messages out.</p>
<h3>Syntax</h3>
<p>	{cms_module module=&#039;NMS&#039;}</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report  please visit <a href=&#039;http://dev.cmsmadesimple.org/projects/newsletter/&#039; target=&#039;_blank&#039;>http://dev.cmsmadesimple.org/projects/newsletter/</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&#039;http://forum.cmsmadesimple.org&#039; target=&#039;_blank&#039;>CMS Made Simple Forums</a>.</li>
<li>The author, Paul Lemke, can often be found in the <a href=&#039;irc://irc.freenode.net/#cms&#039;>CMS IRC Channel</a> (username: pyrox).</li>
<li>Lastly, you may have some success emailing the author directly.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2005, Paul Lemke <a href=&#039;mailto:lemkepf@gmx.net&#039;><lemkepf@gmx.net></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&#039;http://www.gnu.org/licenses/licenses.html#GPL&#039;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['utma'] = '156861353.566397030.1147555099.1149700038.1149796966.20';
$lang['utmz'] = '156861353.1149619132.18.9.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/admin/approve-pending.php|utmcmd=referral';
$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>/NMS.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: NMS - Newsletter Made Simple
# Version: 1.0-Beta1, Robert Campbell <rob@techcom.dyndns.org>
# - Based on the original module of the same name by Paul Lemke
# * This version is not ready for prime time.
#
# 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
#
#------------------------------------------------------------------------- 

#require_once(dirname(__FILE__)."/checkdns_windows.php");

class NMS extends CMSModule{
	
  var $table_prefix = "module_NMS_"; 
  var $defaultcharset = 'iso-8859-1';
  var $default_postsubscribe_prompt = 'Thank you for subscribing to one or more of our email lists.  An email has been sent to you asking you for validation purposes, and with further instructions. Please check your email soon';
  var $default_subscribe_subject = 'Subscription confirmed';
  var $default_subscribe_email_body = '
Hello {$username}.
Someone, hopefully you, has subscribed your email address to the following newsletters:
{foreach from=$lists item=list}
* {$list}
{/foreach}
If this is correct, please click the following link to confirm your subscription or copy and paste the link into your web browser. Without this confirmation, you will not receive any newsletters. {$confirmurl} If you did not sign up for this newsletter you do not need to do anything, simply delete this message. Thank you!';
  var $default_message_template = '
   <html>
   <body>
   <h1>Hello {$username}</h1>
   <p>
   Have a good day, and again, welcome.
   </p>

   <hr />
   <p>If you have received this message to this email address: {$email} it means that you are a member of one or more
   lists on our website.  You have a number of options, you can ignore the message (this is probably safe to do),
   or you can:
   <ul>
   <li>Unsubscribe:  Just follow this link <a href="{$unsubscribe}" title="unsubscribe">{$unsubscribe}</a></li>
   <li>Change your preferences:  Just follow this link <a href="{$preferences}" title="Preferences">{$preferences}</a></li>
   <li>Confirm that this is a valid email address by following this link: <a href="{$confirmurl}" title="Confirm">{$confirmurl}</a></li>
   </ul>
   </p>

   </body>
   </html>
';
  var $default_confirm_subject = 'Please confirm your subscription';
  var $default_confirm_email_body = '
Thank you {$username} for subscribing to the mailing list {$listname}.  Your registration has been confirmed.  At any time you can unsubscribe from this list by following this link {$unsubscribeurl}.  You may also change your preferences by following this link: {$preferencesurl}';
  var $default_post_email_confirm_message = '
Thank you {$username}.  Your email address {$email} has been marked as confirmed as of {$dateconfirmed}.  Your uniquid (for future reference) is {$uniqueid}';
  var $default_subscribe_form = '
	{if $message ne ""}
	<br /><span class="nms_message">{$message}</span><br />
	{/if}
	{$formstart}
		{$formhidden}
        {if $prompt_email ne ""}
		{$prompt_email}:&nbsp;{$email}<br />
        {/if}
        {if $prompt_username ne ""}
                {$prompt_username}:&nbsp;{$username}<br />
        {/if}
		{foreach from=$listids item=curr_id}
		  {$curr_id}<br/>
		{/foreach}
		{$submitbtn}
	{$formend}';
  var $default_postsubscribe_text = 'Thank you';
  var $default_unsubscribe_subject = 'Unsubscribe notification';
  var $default_unsubscribe_email_body = '
Hello {$username} <{$email}>

This message is to confirm that it is indeed you that has chosen to unsubscribe from all of the
mailing lists with us.  if this is indeed the case, please confirm this action by clicking 
on the following link:
{$confirm_unsubscribe_url}

If you did not instantiate this action, you can safely ignore this message.

Thank you.
';
  var $default_unsubscribe_prompt = 'Enter your email to unsubscribe';
  var $default_unsubscribe_form = '
	{if $message ne ""}
	<br /><span class="nms_message">{$message}</span><br/>
	{/if}
	{$formstart}
	{$formhidden}
        {if $prompt_email ne ""}
		{$prompt_email}:&nbsp;{$email}<br/>
        {/if}
	{$submitbtn}
	{$formend}';
  var $default_unsubscribe_text = '
Thank you {$username}.  An email as been sent to {$email} to confirm your wish to unsubscribe from all mailing lists on this site.  You should be receiving it shortly.  Thank you';
  var $default_post_unsubscribe_text = '
Thank you {$username} <{$email}>.  You have now been unsubscribed from all public mailing lists.  We are sorry to see you go.
';
  var $default_usersettings_subject = 'User Settings Information';
  var $default_usersettings_email_body = '
Thank you {$username} <{$email}>.  You requested information as to how to change your subscription information.  Here it is:

Follow this link to adjust your settings:
{$usersettings_url}

Follow this link to completely unsubscribe from all public mailing lists:
{$unsubscribe_url}
';
  var $default_usersettings_text = '
Thank you {$username <{$email}>.  An email has been sent to {$email} with further instructions.
';
  var $default_usersettings_form = '
	{if $message ne ""}
	<br/><span class="nms_message">{$message}</span><br/>
	{/if}
	{$formstart}
	{$formhidden}
        {if $prompt_email ne ""}
		{$prompt_email}:&nbsp;{$email}<br/>
        {/if}
	{$submitbtn}
	{$formend}';
  var $default_usersettings_form2 = '
	{if $message ne ""}
	<br/><span class="nms_message">{$message}</span><br/>
	{/if}
	{$formstart}
	{$formhidden}
	{$prompt_username}:&nbsp;{$username}<br/>
	{foreach from=$listids item=curr_id}
	  {$curr_id}<br/>
	{/foreach}
	{$submitbtn}
	{$formend}';
  var $default_usersettings_text2 = '
Thank you {$username} <{$email}>, your settings have been changed.
';
        

  function GetName()
  {
    return 'NMS';
  }

  function GetDependencies()
  {
    return array( 'CMSMailer' => '1.73.8' );
  }

  /*---------------------------------------------------------
   GetEventDescription( $name )
   ---------------------------------------------------------*/
  function GetEventDescription( $name )
  {
    return $this->Lang('info_event_'.$name );
  }


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

  function GetFriendlyName()
  {
    return $this->Lang('friendlyname');
  }
	
  function GetVersion()
  {
    return '1.0.3';
  }

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

  function GetAuthor()
  {
    return 'Paul Lemke';
  }

  function GetAuthorEmail()
  {
    return 'lemkepf@gmx.net';
  }

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

  function IsPluginModule()
  {
    return true;
  }

  function HasAdmin()
  {
    return true;
  }
	
  function SetParameters()
  {
    $this->CreateParameter('mode', 'subscribe', $this->Lang('helpmode'));
    $this->CreateParameter('select', NULL, $this->Lang('helpselect'));
  }

  function GetAdminSection()
  {
    return 'extensions';
  }

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

  function MinimumCMSVersion()
  {
    return "1.0.2";
  }

  function InstallPostMessage()
  {
    return $this->Lang('postinstall');
  }
	
  function UninstallPostMessage()
  {
    return $this->Lang('postuninstall');
  }

  /*---------------------------------------------------------
   DoAction($action, $id, $params, $returnid)
   This is the main function that gets called if your module
   is a plug-in type module.
   ---------------------------------------------------------*/
  function DoAction($action, $id, $params, $returnid=-1)
  {
    switch( $action )
      {
      case 'compose_message':
	if ($this->CheckPermission('Manage NMS Messages'))
	  {
	    $this->DisplayCompose($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;
	
      case 'create_new_user':
	if ($this->CheckPermission('Manage NMS Users'))
	  {
	    $this->_DisplayAdminUserPage($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'delete_completed':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $this->_AdminDoDeleteCompletedJobs($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'delete_email':
	if ($this->CheckPermission('Manage NMS Users'))
	  {
	    $status = $this->DeleteEmail($id, $params, $returnid);
	    $parms = array();
	    if( !$status )
	      {
		$this->parms['error'] = 1;
		$this->parms['message'] = $this->Lang('errordeletinguser');
	      }
	    $this->myRedirectToTab( $id, 'users', $returnid, $parms );
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'delete_job':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $this->_AdminDoDeleteJob($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;
	
      case 'delete_list':
	if ($this->CheckPermission('Manage NMS Lists'))
	  {
	    $message = $this->DeleteList($id, $params, $returnid);
	    $this->myRedirectToTab( $id, 'lists', $returnid, $parms );
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'delete_message':
	if ($this->CheckPermission('Manage NMS Messages'))
	  {
	    $message = $this->_AdminDoDeleteMessage($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'do_create_edit_job':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $this->_AdminDoCreateEditJob($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'do_edit_user':
	// todo, check perms
	$this->_AdminDoEditUser($id, $params, $returnid, false);
	break;

      case 'edit_message':
	if ($this->CheckPermission('Manage NMS Messages'))
	  {
	    $this->DisplayCompose($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'edit_user':
	if ($this->CheckPermission('Manage NMS Users'))
	  {
	    $this->_DisplayAdminUserPage($id, $params, $returnid, true);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'pause_job':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $message = $this->_AdminDoPauseJob($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'reset_job':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $message = $this->_AdminDoResetJob($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'resume_job':
	if ($this->CheckPermission('Manage NMS Jobs'))
	  {
	    $message = $this->_AdminDoResumeJob($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'save_admin_prefs':
	if ($this->CheckPermission('Modify Site Preferences'))
	  {
	    $this->SaveAdminPrefs($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'save_new':
	if ($this->CheckPermission('Manage NMS Lists'))
	  {
	    $this->_AdminSaveList($id, $params, $returnid);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      case 'save_old':
	if ($this->CheckPermission('Manage NMS Lists'))
	  {
	    $this->_AdminSaveList($id, $params, $returnid, true);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;
	
      case 'save_subscribe_prefs':
	if ($this->CheckPermission('Modify Site Preferences'))
	  {
	    $this->_SaveSubscribePrefs($id, $params, $returnid, true);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;


      case 'save_unsubscribe_prefs':
	if ($this->CheckPermission('Modify Site Preferences'))
	  {
	    $this->_SaveUnsubscribePrefs($id, $params, $returnid, true);
	  }
	else
	  {
	    $this->_DisplayErrorPage($id, $params, $returnid, 
				     $this->Lang('accessdenied'));
	  }
	break;

      // fallback through to call the action.xxxx.php file
      default:
	parent::DoAction( $action, $id, $params, $returnid );
	break;
      }


  }
	

  /*---------------------------------------------------------
   _AdminDoCreateEditJob($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoCreateEditJob($id, &$params, $returnid)
  {
    if( !isset($params['messagelist']) )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_nomessagesselected');
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }
    if( !isset($params['listlist']) )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_nolistsselected');
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }
    if( !isset( $params['jobname'] ) || $params['jobname'] == '' )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_nojobname');
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }
    $jobid='';
    if( isset( $params['jobid'] ) && $params['jobid'] != '' )
      {
	// we're editing an existing record
	$jobid = $params['jobid'];
      } 
    $jobname = trim($params['jobname']);

    $message = $params['messagelist'];
    $lists = array();
    if( is_array( $params['listlist'] ) )
      {
	$lists = $params['listlist'];
      }
    else
      {
	$lists[] = $params['listlist'];
      }

    if( $jobid != '' )
      {
	# editing an existing job
	# we can only edit unstarted jobs
	# so we can safely delete this job in its entirety, and re-add it
	$params['noredirect'] = 0;
	$this->_AdminDoDeleteJob($id,$params,$returnid);
      }

    # adding a new job (or replace an existing one, will always result in a new id
    
    // make sure that the job name doesn't already exist
    $db =& $this->GetDb();
    $q = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."jobs WHERE title = ?";
    $dbresult = $db->Execute( $q, array( $jobname ) );
    if( $dbresult && $dbresult->RecordCount() )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_jobnameexists');
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }
	
    // now we're ready to create the job
    $q = "INSERT INTO ".cms_db_prefix().$this->table_prefix."jobs
        (title,created,status) VALUES (?,?,?)";
    $dbresult = $db->Execute( $q, array( $jobname, 
					 trim($db->DbTimeStamp(time()),"'"),0) );
    if( !$dbresult )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_dberror').' '.$db->ErrorMsg();
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }

    // get the jobid
    $q = "SELECT jobid FROM ".cms_db_prefix().$this->table_prefix."jobs
         WHERE title = ?";
    $dbresult = $db->Execute( $q, array( $jobname ) );
    $row = $dbresult->FetchRow();
    $jobid = $row['jobid'];
	
    // and add the job parts
    foreach( $lists as $listid )
      {
	$q = "INSERT INTO ".cms_db_prefix().$this->table_prefix."job_parts
                VALUES (?,?,?,?)";
	$dbresult = $db->Execute( $q, array( $jobid, $listid, $message, 0 ) );
      }

    // Send an event
    $parms = array();
    $parms['jobid'] = $jobid;
    $parms['jobname'] = $jobname;
    $parms['lists'] = $lists;
    $this->SendEvent('OnCreateJob',$parms);
    
    // all done
    $this->myRedirectToTab( $id, 'jobs', $returnid );
  }


  /*---------------------------------------------------------
   _AdminDoDeleteCompletedJobs($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoDeleteCompletedJobs($id, &$params, $returnid)
  {
    $db =& $this->GetDb();
    $q = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."jobs WHERE status = ?";
    $dbresult = $db->Execute( $q, array( 3 ) );
    while( $row = $dbresult->FetchRow() )
      {
	$q = "DELETE FROM ".cms_db_prefix().$this->table_prefix."job_parts WHERE jobid = ?";
	$dbresult2 = $db->Execute( $q, array( $row['jobid'] ) );

	$q = "DELETE FROM ".cms_db_prefix().$this->table_prefix."jobs WHERE jobid = ?";
	$dbresult2 = $db->Execute( $q, array( $row['jobid'] ) );
      }

    // redirect to the jobs tab
    $this->myRedirectToTab( $id, 'jobs', $returnid );
  }


  /*---------------------------------------------------------
   _AdminDoDeleteJob($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoDeleteJob($id, &$params, $returnid)
  {
    if( !isset( $params['jobid'] ) )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_invalidparams');
	$this->Redirect($id,'create_edit_job',$returnid,$params);
	return;
      }
   
    // delete the job parts
    $db =& $this->GetDb();
    $q = "DELETE FROM ".cms_db_prefix().$this->table_prefix."job_parts WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( $params['jobid'] ) );

    // then the job itself
    $q = "DELETE FROM ".cms_db_prefix().$this->table_prefix."jobs WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( $params['jobid'] ) );

    // send an event
    $this->SendEvent('OnDeleteJob',array('jobid'=>$params['jobid']));

    // and redirect
    if( !isset($params['noredirect']) )
      {
	$this->myRedirectToTab( $id, 'jobs', $returnid );
      }
  }

  /*---------------------------------------------------------
   _AdminDoEditUser($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoEditUser($id, &$params, $returnid)
  {
    if( !isset( $params['email'] ) || $params['email'] == '' )
      {
	$params['message'] = $this->Lang('error_invalidemail');
	$params['error'] = 1;
	$this->Redirect( $id, 'create_new_user', $returnid, $params );
	return;
      }
    if( !isset( $params['uniqueid'] ) )
      {
	$params['message'] = $this->Lang('error_insufficientparams');
	$params['error'] = 1;
	$this->Redirect( $id, 'create_new_user', $returnid, $params );
	return;
      }

    $error = '';
    if (!check_email_mx($params['email']) )
      {
	$params['message'] = $this->Lang('error_invalidemail')." 2 ";
	$params['error'] = 1;
	$this->Redirect( $id, 'create_new_user', $returnid, $params );
	return;
      }

    $db = &$this->cms->db;
    // make sure the email isn't currently used
    $query = "SELECT email FROM ".cms_db_prefix().$this->table_prefix."users WHERE 
          email = ? AND uniqueid != ?";
    $dbresult = $db->Execute($query,array( $params['email'], $params['uniqueid'] ));
    
    if ($dbresult && $dbresult->RecordCount() > 0)
      {
	$params['message'] = $this->Lang('error_emailexists');
	$params['error'] = 1;
	$this->Redirect( $id, 'edit_user', $returnid, $params );
	return;
      }

    $disabled = 0;
    if( isset( $params['disabled'] ) && $params['disabled'] != '' )
      {
	$disabled = $params['disabled'];
      }

    // and update the record
    $query = "UPDATE ".cms_db_prefix().$this->table_prefix."users SET email = ?, disabled = ?, username = ? WHERE uniqueid = ?";
    $dbresult = $db->Execute($query,array( $params['email'], $disabled, $params['username'], 
					   $params['uniqueid'] ));
    if( !$dbresult )
      {
	echo $query."<br/>";
	echo $db->ErrorMsg();
	return;
      }
    
    // get user id
    $query = "SELECT * from ".cms_db_prefix().$this->table_prefix."users where uniqueid = ?";
    $dbresult = $db->Execute($query, array( $params['uniqueid']) );
    
    if ($dbresult && $dbresult->RecordCount() > 0)
      {
	$row = $dbresult->FetchRow();
	$userid = $row['userid'];
	$listNames = "";
	
	// delete all the existing list memberships
	$query = "DELETE FROM ".cms_db_prefix().$this->table_prefix."listuser where userid = ?";
	$dbresult = $db->Execute( $query, array($row['userid']) );
	if( !$dbresult )
	  {
	    $params['message'] = 'ERROR deleting existing membershiips: '.$db->ErrorMsg();
	    $params['error'] = 1;
	    $this->Redirect( $id, 'create_new_user', $returnid, $params );
	    return;
	  }

	// and set in the new ones
	if( isset( $params['lists'] ) )
	  {
	    foreach ($params['lists'] as $listid )
	      {
		$query = "INSERT INTO ".cms_db_prefix().$this->table_prefix.
		  "listuser (userid, listid, active, entered) VALUES (?,?,?,?)";
		$dbresult = $db->Execute( $query, 
					  array( $row['userid'], $listid, 1, 
						 trim($db->DBTimeStamp(time()),"'")));
	      }
	  }

	// send an event
	$parms = array();
	$parms['username'] = $row['username'];
	$parms['email'] = $row['email'];
	$parms['id'] = $row['userid'];
	$parms['lists'] = $params['lists'];
	$this->SendEvent( 'OnEditUser', $parms );
      }
    else
      {
	$params['message'] = 'ERROR finding user: '.$db->ErrorMsg();
	$params['error'] = 1;
	$this->Redirect( $id, 'create_new_user', $returnid, $params );
	return;
      }

    $this->myRedirectToTab( $id, 'users', $returnid );
  }


  /*---------------------------------------------------------
   _AdminDoPauseJob($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoPauseJob($id, &$params, $returnid)
  {
    if( !isset( $params['jobid'] ) )
      {
	$this->_DisplayErrorPage( $id, $params, $returnid,
				  $this->Lang('error_insufficientparams'));
	return;
      }

    $db =& $this->GetDb();
    $q = "UPDATE ".cms_db_prefix().$this->table_prefix."jobs SET status = ? WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( 2, $params['jobid'] ) );
    $this->myRedirectToTab( $id, 'jobs', $returnid );
  }


  /*---------------------------------------------------------
   _AdminDoResetJob($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoResetJob($id, &$params, $returnid)
  {
    if( !isset( $params['jobid'] ) )
      {
	$this->_DisplayErrorPage( $id, $params, $returnid,
				  $this->Lang('error_insufficientparams'));
	return;
      }

    $db =& $this->GetDb();

    // drop the temporary table
    $temptablename = cms_db_prefix().$this->table_prefix."temp_jobstatus";
    $dict = NewDataDictionary( $db );
    $sqlarray = $dict->DropTableSQL( $temptablename );
    $dict->ExecuteSQLArray($sqlarray);

    $q = "UPDATE ".cms_db_prefix().$this->table_prefix."jobs SET status = ? WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( 0, $params['jobid'] ) );
    $this->myRedirectToTab( $id, 'jobs', $returnid );
  }

  /*---------------------------------------------------------
   _AdminDoResumeJob($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminDoResumeJob($id, &$params, $returnid)
  {
    if( !isset( $params['jobid'] ) )
      {
	$this->_DisplayErrorPage( $id, $params, $returnid,
				  $this->Lang('error_insufficientparams'));
	return;
      }

    $db =& $this->GetDb();
    $q = "UPDATE ".cms_db_prefix().$this->table_prefix."jobs SET status = ? WHERE jobid = ?";
    $dbresult = $db->Execute( $q, array( 0, $params['jobid'] ) );
    $this->myRedirectToTab( $id, 'jobs', $returnid );
  }


  // todo, remove all calls to this function in favor of smarty
  function _AdminReplaceEmailLinksXX($id, &$params, $returnid, $strMessage, $uniqueid = 0, $lists = "", $ishtml = false){
    $db = &$this->cms->db;
    global $config;
    $id = "cntnt01";
    //$returnid = "9";
    $returnid = $db->GetOne("SELECT content_id FROM ".cms_db_prefix()."content WHERE active=1");
		
   		
    if ($ishtml){
      $strMessage = str_replace("{unsubscribe}", "<a href='$unsublink'>$unsublink</a>", $strMessage);
      $strMessage = str_replace("{preferences}", "<a href='$changeprefslink'>$changeprefslink</a>", $strMessage);
      $strMessage = str_replace("{confirmurl}", "<a href='$confirmUrl'>$confirmUrl</a>", $strMessage);  	
    }else{
      $strMessage = str_replace("{unsubscribe}", $unsublink, $strMessage);
      $strMessage = str_replace("{preferences}", $changeprefslink, $strMessage);
      $strMessage = str_replace("{confirmurl}", $confirmUrl, $strMessage);
    }
    //$thepos = nthPos($config['root_url'], '/', 3);
    $thepos = strrpos($config['uploads_url'], '/');
    $thelink = substr($config['uploads_url'], 0, $thepos) . "/";  
    $strMessage = str_replace("src='", "src='$thelink", $strMessage); 
    $strMessage = str_replace('src="', 'src="' . $thelink, $strMessage); 
		
    $strMessage = str_replace("{lists}", "<a href='$lists'>$lists</a>", $strMessage);
    $strMessage = str_replace('&amp;', '&',$strMessage);
    	
    return $strMessage;
  }
	

  function _cleanLink($strMessage)
  {
    $strMessage = str_replace('&amp;', '&',$strMessage);
    	
    return $strMessage;
  }

  function DeleteEmail($id, &$params, $returnid )
  {
    $db = &$this->cms->db;
    // simple way to have common nav available to all admin pages
		
    $query = "DELETE FROM ".cms_db_prefix().$this->table_prefix."users where userid = ?";
    $dbresult = $db->Execute($query,array($params['userid']));	

    $query = "DELETE FROM ".cms_db_prefix().$this->table_prefix."listuser where userid = ?";
    $dbresult = $db->Execute($query,array($params['userid']));	

    // send an event
    $parms = array( 'id' => $params['userid'] );
    $this->SendEvent('OnDeleteUser',$parms);

    if ($dbresult){
      return true;
    }else{
      $params['error'] = 1;
      $params['message'] = $db->GetErrorMsg();
      return false;
    }
  }

    
/*---------------------------------------------------------
   SaveAdminPrefs($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function SaveAdminPrefs($id, &$params, $returnid)
  {
    $this->SetPreference('users_per_page',
			 isset($params['users_per_page'])?$params['users_per_page']:false);
    $this->SetPreference('messages_per_batch',
			 isset($params['messages_per_batch'])?$params['messages_per_batch']:false);
    $this->SetPreference('ms_between_message_sleep',
			 isset($params['ms_between_message_sleep'])?$params['ms_between_message_sleep']:false);
    $this->SetPreference('between_batch_sleep',
			 isset($params['between_batch_sleep'])?$params['between_batch_sleep']:false);
    $this->SetPreference('email_user_on_admin_subscribe',
			 isset($params['email_user_on_admin_subscribe'])?$params['email_user_on_admin_subscribe']:0);
    $this->SetPreference('send_admin_copies', isset($params['send_admin_copies'])?$params['send_admin_copies']:false);
    $this->SetPreference('admin_email', isset($params['admin_email'])?$params['admin_email']:'Root');
    $this->SetPreference('admin_name', isset($params['admin_name'])?$params['admin_name']:'root@localhost.com');
    $this->SetPreference('message_charset', isset($params['message_charset'])?$params['message_charset']:$this->defaultcharset);

    // if you wanted to have a comprehensive audit log, you could write something here.      
    $this->myRedirectToTab( $id, 'preferences', $returnid );
  }
	
  /*---------------------------------------------------------
   _DisplayAdminUserPage($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _DisplayAdminUserPage($id, &$params, $returnid, $editing = false)
  {
    $db =& $this->GetDb();

    if( isset( $params['message'] ) )
      {
	$this->smarty->assign('message',$params['message']);
      }
    if( isset( $params['error'] ) )
      {
	$this->smarty->assign('error',$params['error']);
      }

    $userinfo = '';
    $memberlists = array();
    if( $editing )
      {
	// make sure we have enough params
	if( !isset( $params['uniqueid'] ) )
	  {
	    $parms = array();
	    $parms['error'] = 1;
	    $parms['message'] = $this->Lang('error_invalidparams');
	    $this->myRedirectToTab( $id, 'users', $returnid, $parms );
	    return;
	  }

	// find the user
	$query = "SELECT * from ".cms_db_prefix().$this->table_prefix."users where uniqueid = ?";
	$dbresult = $db->Execute($query, array( $params['uniqueid'] ));
	if( !$dbresult || $dbresult->RecordCount() == 0 )
	  {
	    $parms = array();
	    $parms['error'] = 1;
	    $parms['message'] = $this->Lang('error_usernotfound');
	    $this->myRedirectToTab( $id, 'users', $returnid, $parms );
	    return;
	  }

	$userinfo = $dbresult->FetchRow();
	$this->smarty->assign('formstart',
			      $this->CreateFormStart( $id, 'do_edit_user', $returnid ) );
	$this->smarty->assign('formhidden',
			      $this->CreateInputHidden( $id, 'uniqueid', $params['uniqueid'] ));

	// and get his lists
	$query = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."listuser WHERE userid = ?";
	$dbresult = $db->Execute( $query, array( $userinfo['userid'] ) );
	if( $dbresult )
	  {
	    while( $row = $dbresult->FetchRow() )
	      {
		$memberlists[] = $row;
	      }
	  }
      }
    else
      {
	$this->smarty->assign('formstart',
			      $this->CreateFormStart( $id, 'do_create_new_user', $returnid ));
      }

    $this->smarty->assign('prompt_email',
			  $this->Lang('emailaddress'));
    $this->smarty->assign('email', 
			  $this->CreateInputText($id, 'email',
						 (isset($params['email'])?$params['email']:''),
						 30, 150 ,'class="input_text"'));
    $this->smarty->assign('prompt_username',
			  $this->Lang('username'));
    $this->smarty->assign('username', 
			  $this->CreateInputText($id, 'username',
						 (isset($userinfo['username'])?$userinfo['username']:''),
						 30, 150 ,'class="input_text"'));

    $this->smarty->assign('prompt_disabled',
			  $this->Lang('disabled'));
    $this->smarty->assign('disabled',
			  $this->CreateInputCheckbox( $id, 'disabled', '1',
						      (isset($userinfo['disabled'])?$userinfo['disabled']:'0')));

    $this->smarty->assign('submit',
			  $this->CreateInputSubmit($id,'submit',$this->Lang('submit'),
						   'class="button"'));
    $this->smarty->assign('formend',$this->CreateFormEnd());

    // query all of the active lists
    $result = array();
    $temparray = array();
    $query = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."list where active = ?
                ORDER BY listid";
    $dbresult = $db->Execute($query,array(1));
    
    if ($dbresult && $dbresult->RecordCount() > 0)
      {
	// check if we only have one list.
	$oneonly = ($dbresult->RecordCount() == 1 );

	while ($row = $dbresult->FetchRow())
	  {
	    // cross reference with the member lists
	    $member = false;
	    foreach( $memberlists as $ml )
	      {
		if( $row['listid'] == $ml['listid'] )
		  {
		    $member = true;
		    break;
		  }
	      }

	    if( $oneonly )
	      {
		$temparray[] = $this->CreateInputHidden($id,"lists[]",$row['listid']);
	      }
	    $extratext = '';
	    if( $oneonly )
	      {
		$extratext .= 'disabled="disabled" ';
	      }
	    if( $member || $oneonly )
	      {
		$extratext .= 'checked="checked" ';
	      }
	    $temparray[] = "<label>" . 
	      $this->CreateInputCheckbox($id, "lists[]",$row['listid'],"",$extratext).
	      $row['name'] . " - " . $row['description'] . "</label>";
	  }
	$this->smarty->assign('listids',$temparray);
      }

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

  function DeleteList($id, &$params, $returnid, $message=''){
    $db = &$this->cms->db;
    // simple way to have common nav available to all admin pages
		
    $query = "DELETE FROM ".cms_db_prefix().$this->table_prefix."list where listid = ?";
    $dbresult = $db->Execute($query,array($params['listid']));	
		
    if ($dbresult)
      {
	// send an event
	$this->SendEvent('OnDeleteList',array('listid'=>$params['listid']));

	return $this->Lang('newsletterdeleted'); 
      }
    else
      {
	return "Newsletter not Deleted";	
      }
		
  }
	
  /*---------------------------------------------------------
   _AdminSaveList($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _AdminSaveList($id, &$params, $returnid, $saveold = false)
  {
    $name = '';
    if( isset( $params['name'] ) )
      {
	$name = $params['name'];
      }
    if( $name == '' )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_invalidlistname');
	$this->Redirect($id, $params['orig_action'], $returnid, $params );
      }
    if( !isset( $params['listid'] ) && $saveold == true )
      {
	$params['error'] = 1;
	$params['message'] = $this->Lang('error_invalidparams');
	$this->Redirect($id, $params['orig_action'], $returnid, $params );
      }
    $description = '';
	if( isset( $params['description'] ) )
      {
	$description = $params['description'];
      }
    if( $description == '' )
      {
	$description = $name;
      }
    $public = 0;
    if( isset( $params['public'] ) )
      {
	$public = $params['public'];
      }

    $db = &$this->cms->db;
    $record = array(); # Initialize an array to hold the record data to insert			
     
    # Set the values for the fields in the record
    $record["name"] = $name;
    $record["description"] = $description;
    $record['public'] = $public;

    $event = 'OnNewList';
    if ($saveold)
      {
	$event = 'OnEditList';

	$record["listid"] = $params['listid'];
	$query = "UPDATE ".cms_db_prefix().$this->table_prefix."list set name = ?, description = ?, public = ? where listid = ?";
	$dbresult = $db->Execute($query, $record); //Force admin access on

      }
    else
      {
	// todo, have to check if this name is already used or not
	$record["active"] = 1;
	$record["dateadded"] = trim($db->DBTimeStamp(time()),"'");
	$query = "INSERT INTO ".cms_db_prefix().$this->table_prefix."list (name, description, public, active, dateadded) VALUES (?,?,?,?,?)";
	$dbresult = $db->Execute($query, $record); //Force admin access on

      }		
    if( !$dbresult )
      {
	$this->_DisplayErrorPage( $id, $params, $returnid,
				 $this->Lang('error_insertinglist'));
	echo $db->ErrorMsg();
	return;
      }

    // send an event
    $parms = array();
    $parms['name'] = $name;
    $parms['description'] = $description;
    $parms['public'] = $public;
    if( isset( $params['listid'] ) )
      {
	$parms['listid'] = $params['listid'];
      }
    $this->SendEvent($event,$parms);
    
    $this->myRedirectToTab( $id, 'lists', $returnid );
  }
    
  /*---------------------------------------------------------
   DisplayCompose($id, $params, $returnid)
   ---------------------------------------------------------*/
  function DisplayCompose($id, &$params, $returnid)
  {
    $db =& $this->GetDb();

    // some default values (maybe from preferences)
    $error = false;
    $reply_to = false;
    $from = false;
    $subject = false;
    $message_text = $this->GetPreference('default_message_template','');
    $templateid = -1;
    $pageid = false;

    $messageid = (isset($params['messageid']) && $params['messageid'] != '')?$params['messageid']:'';
    if( $messageid != '' )
      {
	// we're editing an existing record, get the stuff from the database
	$query = "SELECT * FROM ".cms_db_prefix().$this->table_prefix."messages WHERE messageid = ?";
	$dbresult = $db->Execute($query,array($params['messageid']));
	$row = $dbresult->FetchRow();
	$from = $row['fromwho'];
	$reply_to = $row['replyto'];
	$subject = $row['subject'];
	$message_text = $row['message'];
	$templateid = $row['templateid'];
	$pageid = $row['pageid'];
      }

    // let params override the settings from the database if editing
    if( isset( $params['reply_to'] ) )
      {
	$reply_to = trim($params['reply_to']);
      }
    if( isset( $params['from'] ) )
      {
	$from = trim($params['from']);
      }
    if( isset( $params['subject'] ) )
      {
	$subject = trim($params['subject']);
      }
    if( isset( $params['message_text'] ) )
      {
	$message_text = trim($params['message_text']);
      }
    if( isset( $params['templateid'] ) )
      {
	$templateid = $params['templateid'];
      }
    if( isset( $params['pageid'] ) )
      {
	$pageid = $params['pageid'];
      }
	
    if( isset( $params['submit'] ) )
      {
	// form validation
	// Changed by skypanther to permit reply-to to be left blank
	if( ! $from || $from == '' )
	  {
	    $this->smarty->assign('message',$this->Lang('error_needfrom'));
	    $error = true;
	  }
	else if( ! $reply_to || $reply_to == '' )
	  {
	  	$reply_to = $from;
//	    $this->smarty->assign('message',$this->Lang('error_needreplyto'));
//	    $error = true;
	  }
	else if( ! $subject || $subject == '' )
	  {
	    $this->smarty->assign('message',$this->Lang('error_needsubject'));
	    $error = true;
	  }
	else if( ! $message_text || $message_text == '' )
	  {
	    $this->smarty->assign('message',$this->Lang('error_needmessagetext'));
	    $error = true;
	  }
	else if( $templateid > 0 && (! $pageid ) )
	  {
	    $this->smarty->assign('message',$this->Lang('error_formerror'));
	    $error = true;
	  }

	if( !$error )
	  {
	    // we got here, now we can insert/update the record, no problems.

	    $record = array(); 
	    // Set the values for the fields in the record
	    $record["fromwho"] = $from;
	    $record["replyto"] = $reply_to;
	    $record["subject"] = $subject;
	    $record["messsage"] = $message_text;
	    $record["templateid"] = $templateid;
	    $record["pageid"] = ($pageid == false)?NULL:$pageid;

	    $query = "";
	    $event = 'OnCreateMessage';
	    if ( $messageid != '' )
	      {
		$event = 'OnEditMessage';
		$record["messageid"] = $params['messageid'];
		$query = "UPDATE ".cms_db_prefix().$this->table_prefix."messages 
                             SET fromwho = ?, replyto = ?, subject = ?, message = ?, 
                                 templateid = ?, pageid = ? where messageid = ?";
	      }
	    else
	      {
		$record["entered"] = trim($db->DBTimeStamp(time()),"'");
		$record["uniqueid"] = md5(uniqid(rand(),1));
		$query = "INSERT INTO ".cms_db_prefix().$this->table_prefix."messages (fromwho, replyto, subject, message, templateid, pageid, entered, uniqueid) VALUES (?,?,?,?,?,?,?,?)";
	      }
	
	    // get the message id so we can send an event
	    $dbresult = $db->Execute($query, $record); 

	    if( !$dbresult )
	      {
		$this->smarty->assign('message',$this->Lang('error_problemwithmessage')."<br/>".$db->ErrorMsg());
		$error = true;
	      }
	    else if( $messageid != '' )
	      {
		$query = "SELECT messageid from ".cms_db_prefix().$this->table_prefix."messages where uniqueid = ?";
		$dbresult = $db->Execute($query,array($record['uniqueid']));
		$row = $dbresult->FetchRow();
		$record['messageid'] = $row['messageid'];
	      }
	    else
	      {
		$record['messageid'] = $params['messageid'];
	      }
	
	    // send an event
	    $this->SendEvent($event,$record);

	    // and redirect back to the tabs
	    if( !$error )
	      {
		$this->myRedirectToTab( $id, 'messages', $returnid );
		return;
	      }
	  }
      }

    // create a template list
    global $gCms;
    $db = &$this->GetDb();
    $ops =&  $gCms->GetTemplateOperations();
    $alltemplates = $ops->LoadTemplates();
    $mytemplates = array();
    $mytemplates['None (HTML Message)'] = -1;
    $mytemplates['None (Text Message)'] = -2;
    foreach( $alltemplates as $onetemplate )
      {
	if( !$onetemplate->active || $onetemplate->default )
	  {
	    continue;
	  }
	$mytemplates[$onetemplate->name] = $onetemplate->id;
      }

    $this->smarty->assign('startform', $this->CreateFormStart($id, $params['action'], $returnid,
						      'post', '', false, 'a'));
    $this->smarty->assign('endform', $this->CreateFormEnd());
    $this->smarty->assign('submit',	$this->CreateInputSubmit($id, 'submit', 
								 $this->Lang('submit')));
    $this->smarty->assign('prompt_from', $this->Lang('prompt_from'));
    $this->smarty->assign('prompt_replyto', $this->Lang('prompt_replyto'));
    $this->smarty->assign('prompt_subject', $this->Lang('prompt_subject'));
    $this->smarty->assign('prompt_template', $this->Lang('prompt_template'));
    $this->smarty->assign('prompt_page', $this->Lang('prompt_page'));
    $this->smarty->assign('prompt_selectstatus', $this->Lang('prompt_selectstatus'));
    $this->smarty->assign('prompt_message', $this->Lang('prompt_message'));
    $this->smarty->assign('message_help',$this->Lang('message_help'));
	
    $result = array();
    $temparray = array();
    $this->smarty->assign('messageid', $this->CreateInputHidden($id, 'messageid', $messageid ));
    $this->smarty->assign('from', 
			  $this->CreateInputText($id, 'from', 
						 $from,
						 30));
    $this->smarty->assign('reply_to', 
			  $this->CreateInputText($id, 'reply_to', 
						 $reply_to,
						 30));
    $this->smarty->assign('subject', 
			  $this->CreateInputText($id, 'subject', 
						 $subject,
						 30));
    $this->smarty->assign('templatelist',
			  $this->CreateInputDropDown($id,'templateid',
			     $mytemplates,
			     -1,
			     $templateid,
			     'onchange="document.'.$id.'moduleform_a.submit()"')); 

    $this->smarty->assign('pagelist',
			  create_page_dropdown($this,$id,'pageid',$pageid,'',
					       ($templateid == -2)?'disabled':''));
    $this->smarty->assign('message_text', 
			  $this->CreateTextArea(true, $id, 
						$message_text,
						'message_text'));      
    // Display the populated template
    echo $this->ProcessTemplate('compose.tpl');
  }
    
//   /*---------------------------------------------------------
//    _AdminDoSaveComposeMessage($id, $params, $returnid, $message)
//    ---------------------------------------------------------*/
//   function _AdminDoSaveComposeMessage($id, &$params, $returnid)
//   {
//     $error = '';
//     if (check_email_mx($params['reply_to']) && isset($params['subject']) && isset($params['message_text']) && isset($params['from']))
//       {
// 	$db = &$this->cms->db;
// 	$record = array(); # Initialize an array to hold the record data to insert			
// # Set the values for the fields in the record
// 	$record["fromwho"] = $params['from'];
// 	$record["reply_to"] = $params['reply_to'];
// 	$record["subject"] = $params['subject'];
// 	$record["messsage"] = $params['message_text'];
// 	$record["templateid"] = $params['templateid'];

// 	$event = 'OnCreateMessage';
// 	if ($params['isediting'] == "true")
// 	  {
// 	    $event = 'OnEditMessage';
// 	    $record["messageid"] = $params['messageid'];
// 	    $query = "UPDATE ".cms_db_prefix().$this->table_prefix."messages set fromwho = ?, replyto = ?, subject = ?, message = ?, templateid = ? where messageid = ?";
// 	    $dbresult = $db->Execute($query, $record); 				
// 	  }
// 	else
// 	  {
// 	    $record["entered"] = trim($db->DBTimeStamp(time()),"'");
// 	    // 	$record["sent"] = 0;
// 	    // 	$record["status"] = 0;
// 	    $record["uniqueid"] = md5(uniqid(rand(),1));
// 	    $query = "INSERT INTO ".cms_db_prefix().$this->table_prefix."messages (fromwho, replyto, subject, message, templateid, entered, uniqueid) VALUES (?,?,?,?,?,?,?)";
// 	    $dbresult = $db->Execute($query, $record); 
// 	  }
	
// 	if( !$dbresult )
// 	  {
// 	    $this->_DisplayErrorPage( $id, $params, $returnid,
// 				      $this->Lang('error_problemwithmessage'));
// 	    echo $db->ErrorMsg();
// 	    return;
// 	  }
	
// 	// get unique id
// 	if ($params['isediting'] != "true")
// 	  {
// 	    $query = "SELECT messageid from ".cms_db_prefix().$this->table_prefix."messages where uniqueid = ?";
// 	    $dbresult = $db->Execute($query,array($record['uniqueid']));
// 	    $row = $dbresult->FetchRow();
// 	    $messageid = $row['messageid'];
// 	  }
// 	else
// 	  {
// 	    $messageid = $params['messageid'];
// 	  }
	
// 	// send an event
// 	$this->SendEvent($event,$record);
//       }
//     else
//       {
// 	$error .= $this->Lang('error_needreplyto').'<br/>';
//       }

//     if (strlen($error) != 0)
//       {
// 	$this->DisplayCompose($id, $params, $returnid, $error);
//       }
//     else
//       {
// 	$this->myRedirectToTab( $id, 'messages', $returnid );
//       }
//   }
    
  function _AdminDoDeleteMessage($id, &$params, $returnid, $message='')
  {
    $db = &$this->cms->db;
		
    $query = "DELETE FROM ".cms_db_prefix().$this->table_prefix."messages where messageid = ?";
    $dbresult = $db->Execute($query,array($params['messageid']));	

    // send an event
    $this->SendEvent('OnDeleteMessage',$params);

    $this->myRedirectToTab( $id, 'messages', $returnid );
  }


  /*---------------------------------------------------------
   _DisplayErrorPage($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _DisplayErrorPage($id, &$params, $returnid, $message='')
  {
    $this->smarty->assign('title_error', $this->Lang('error'));
    if ($message != '')
      {
	$this->smarty->assign_by_ref('message', $message);
      }
    
    // Display the populated template
    echo $this->ProcessTemplate('error.tpl');
  }

  /*---------------------------------------------------------
   _SaveSubscribePrefs($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _SaveSubscribePrefs($id, &$params, $returnid)
  {
    if( isset( $params['input_reset'] ) )
      {
	$this->SetPreference('subscribe_posttext', $this->default_postsubscribe_text);
	$this->SetPreference('subscribe_subject', $this->default_subscribe_subject );
	$this->SetTemplate('subscribe_email_body', $this->default_subscribe_email_body);
	$this->SetTemplate('nms_subscribeform', $this->default_subscribe_form );
      }
    else
      {
	$this->SetTemplate('nms_subscribeform', isset($params['subscribe_form'])?$params['subscribe_form']:$this->default_subscribe_form);
	$this->SetTemplate('subscribe_email_body', isset($params['subscribe_email_body'])?$params['subscribe_email_body']:'');
	$this->SetPreference('subscribe_posttext', $params['postsubscribetext']);
	$this->SetPreference('subscribe_subject', isset($params['subscribe_subject'])?$params['subscribe_subject']:'');
      }
    $this->myRedirectToTab( $id, 'subscribe_form', $returnid );
  }

  /*---------------------------------------------------------
   _SaveUnsubscribePrefs($id, $params, $returnid, $message)
   ---------------------------------------------------------*/
  function _SaveUnsubscribePrefs($id, &$params, $returnid)
  {
    if( isset( $params['input_reset'] ) )
      {
	$this->SetPreference('unsubscribe_subject', $this->default_unsubscribe_subject );
	$this->SetPreference('nms_unsubscribe_prompt', $this->default_unsubscribe_prompt );
	$this->SetTemplate('unsubscribe_email_body', $this->default_unsubscribe_email_body );
	$this->SetTemplate('nms_unsubscribeform', $this->default_unsubscribe_form );
	$this->SetTemplate('unsubscribe_text', $this->default_unsubscribe_text );
	$this->SetTemplate('post_unsubscribe_text', $this->default_post_unsubscribe_text );
      }
    else
      {
	$this->SetPreference('nms_unsubscribe_prompt', 
			     isset($params['unsubscribe_prompt'])?$params['unsubscribe_prompt']:'');
	$this->SetPreference('unsubscribe_subject', isset($params['unsubscribe_subject'])?$params['unsubscribe_subject']:'');
	$this->SetTemplate('unsubscribe_email_body', isset($params['unsubscribe_email_body'])?$params['unsubscribe_email_body']:'');
	$this->SetTemplate('nms_unsubscribeform', isset($params['unsubscribe_form'])?$params['unsubscribe_form']:'');
	$this->SetTemplate('unsubscribe_text', 
			   isset($params['unsubscribe_text'])?$params['unsubscribe_text']:'');
	$this->SetTemplate('post_unsubscribe_text', 
			   isset($params['post_unsubscribe_text'])?$params['post_unsubscribe_text']:'');
      }

    $this->myRedirectToTab( $id, 'unsubscribe_form', $returnid );
  }

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

  function _statusToText( $status )
  {
    switch( $status )
      {
      case -1:
	return $this->Lang('status_error');
      case 0:
	return $this->Lang('status_unstarted');
      case 1:
	return $this->Lang('status_inprogress');
      case 2:
	return $this->Lang('status_paused');
      case 3:
	return $this->Lang('status_complete');
      default:
	return $this->Lang('status_unknown');
      }
  }

  function myProcessTemplateFromData( $data )
  {
    $this->smarty->_compile_source('temporary template', $data, $_compiled );
    @ob_start();
    $this->smarty->_eval('?>' . $_compiled);
    $_contents = @ob_get_contents();
    @ob_end_clean();
    return $_contents;
  }
} /* class */


/* ------------------
 HELPER FUNCTIONS 
 ------------------ */
function create_page_dropdown(&$module,$id,$name,$current='',$templateid='',$addtext='',$markdefault =true)
{
  // we get here (hopefully) when the template is changed
  // in the dropdown.
  $db =& $module->GetDb();
  global $gCms;
  $defaultid = '';
  if( $markdefault )
    {
      $contentops =& $gCms->GetContentOperations();
      $defaultid = $contentops->GetDefaultPageID();
    }
  
  // get a list of the pages used by this template
  $mypages = array();
  $parms = array('content');
  $q = "SELECT content_id,content_name 
                FROM ".cms_db_prefix()."content
               WHERE type = ?
                 AND active = 1";
  
  if( $templateid != '' )
    {
      $q .= ' AND templateid = ?';
      $parms[] = $templateid;
    }
  $dbresult = $db->Execute( $q, $parms );
  while( $row = $dbresult->FetchRow() )
    {
      if( $defaultid != '' && $row['content_id'] == $defaultid )
        {
	  // use a star instead of a word here so I don't have to
	  // worry about translation stuff
	  $mypages[$row['content_name'].' (*)'] = $row['content_id'];
	}
      else
	{
	  $mypages[$row['content_name']] = $row['content_id'];
	}
    }

  return $module->CreateInputDropdown($id,$name,$mypages,-1,$current,$addtext);
}


function check_email_mx($email,$check_mx = 0) 
{ 
  if( ((preg_match('/(@.*@)|(\.\.)|(@\.)|(\.@)|(^\.)/', $email)) || 
       (preg_match('/^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,3}|[0-9]{1,3})(\]?)$/',$email))) && strlen($email) > 5 ) { 

    if( $check_mx == 0 )
      {
	return true;
      }

    $host = explode('@', $email);
    if(checkdnsrr($host[1].'.', 'MX') ) return true;
    if(checkdnsrr($host[1].'.', 'A') ) return true;
    if(checkdnsrr($host[1].'.', 'CNAME') ) return true;			
  }
  return false;
}

/**
 * Creates a string containing links to all the pages.
 * @param string The id given to the module on execution
 * @param string The action that this form should do when the form is submitted
 * @param string The id to eventually return to when the module is finished it's task
 * @param string the current page to display
 * @param string the amount of items being listed
 * @param string the amount of items to list per page
 * @param boolean A flag to determine if actions should be handled inline (no moduleinterface.php -- only works for frontend)
 */
// function CreatePaginationNMS($id, $action, $returnid, $page, $totalrows, $limit, $name, $inline=false)
// {
//   $goto = 'index.php';
//   if ($returnid == '')
//     {
//       $goto = 'moduleinterface.php';
//     }
//   $link = '<a href="'.$goto.'?module='.$name.'&amp;'.$id.'returnid='.$id.$returnid.'&amp;'.$id.'action=' . $action .'&amp;'.$id.'page=';
//   if ($inline)
//     {
//       $link .= '&amp;'.$this->cms->config['query_var'].'='.$returnid;
//     }
//   $page_string = "";
//   $from = ($page * $limit) - $limit;
//   $numofpages = floor($totalrows / $limit);
//   if ($numofpages * $limit < $totalrows)
//     {
//       $numofpages++;
//     }

//   if ($numofpages > 1)
//     {
//       if($page != 1)
// 	{
// 	  $pageprev = $page-1;
// 	  $page_string .= $link.$pageprev."\">".$this->Lang('previous')."</a>&nbsp;";
// 	}
//       else
// 	{
// 	  $page_string .= $this->Lang('previous')." ";
// 	}

//       for($i = 1; $i <= $numofpages; $i++)
// 	{
// 	  if($i == $page)
// 	    {
// 	      $page_string .= $i."&nbsp;";
// 	    }
// 	  else
// 	    {
// 	      $page_string .= $link.$i."\">$i</a>&nbsp;";
// 	    }
// 	}

//       if (($totalrows - ($limit * $page)) > 0)
// 	{
// 	  $pagenext = $page+1;
// 	  $page_string .= $link.$pagenext."\">".$this->Lang('next')."</a>";
// 	}
//       else
// 	{
// 	  $page_string .= $this->Lang('next')." ";
// 	}
//     }

//   return $page_string;
// }

// function nthPos ($str, $needles, $n=1) {
//   //    finds the nth occurrence of any of $needles' characters in $str
//   //  returns -1 if not found; $n<0 => count backwards from end
//   //  e.g. $str = "c:\\winapps\\morph\\photos\\Party\\Phoebe.jpg";
//   //      substr($str, nthPos($str, "/\\:", -2)) => \Party\Phoebe.jpg
//   //      substr($str, nthPos($str, "/\\:", 4)) => \photos\Party\Phoebe.jpg
//   $pos = -1;
//   $size = strlen($str);
//   if ($reverse=($n<0)) { $n=-$n; $str = strrev($str); }
//   while ($n--) {
//     $bestNewPos = $size;
//     for ($i=strlen($needles)-1;$i>=0;$i--) {
//       $newPos = strpos($str, $needles[$i], $pos+1);
//       if ($newPos===false) $needles = substr($needles,0,$i) . substr($needles,$i+1);
//       else $bestNewPos = min($bestNewPos,$newPos); }
//     if (($pos=$bestNewPos)==$size) return -1; }
//   return $reverse ? $size-1-$pos : $pos;
// }
?>
]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/adminpanel.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PHA+eyRhZG1pbl9uYXZ9PC9wPg==]]></data>
	</file>
	<file>
	  <filename>/templates/adminprefs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdXNlcnNfcGVyX3BhZ2V9PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR1c2Vyc19wZXJfcGFnZX08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbXNfYmV0d2Vlbl9tZXNzYWdlX3NsZWVwfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskbXNfYmV0d2Vlbl9tZXNzYWdlX3NsZWVwfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9iZXR3ZWVuX2JhdGNoX3NsZWVwfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskYmV0d2Vlbl9iYXRjaF9zbGVlcH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbWVzc2FnZXNfcGVyX2JhdGNofTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskbWVzc2FnZXNfcGVyX2JhdGNofTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9lbWFpbF91c2VyX29uX2FkbWluX3N1YnNjcmliZX08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGVtYWlsX3VzZXJfb25fYWRtaW5fc3Vic2NyaWJlfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij5BZG1pbiBFLW1haWw8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGFkbWluX2VtYWlsfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij5BZG1pbiBOYW1lPC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRhZG1pbl9uYW1lfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij5TZW5kIGFkbWluIGEgY29weT8gPC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzZW5kX2FkbWluX2NvcGllc308L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+TWVzc2FnZSBDaGFyc2V0OjwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskbWVzc2FnZV9jaGFyc2V0fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH08L3A+CiAgPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/archive.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRhcmNoaXZlX2hlYWRpbmd9DQo8dGFibGUgY2VsbHBhZGRpbmc9IjQiIHdpZHRoPSIxMDAlIj4NCjx0ciBjbGFzcz0ibm1zYXJjaGl2ZV9oZWFkZXIiPg0KCTx0aD57JGFyY2hpdmVfdGJsX21zZ0lEfTwvdGg+DQoJPHRoPnskYXJjaGl2ZV90YmxfZGF0ZX08L3RoPg0KCTx0aCBzdHlsZT0iZGlzcGxheTpub25lOyI+eyRhcmNoaXZlX3RibF9zdWJqZWN0fTwvdGg+DQoJPHRoPnskYXJjaGl2ZV90YmxfZnVsbHVybH08L3RoPg0KCTx0aCBzdHlsZT0iZGlzcGxheTpub25lOyI+eyRhcmNoaXZlX3RibF9ocmVmfTwvdGg+DQo8L3RyPg0Ke3NlY3Rpb24gbmFtZT1teXNlYyBsb29wPSRhcmNoaXZlZF9tZXNzYWdlc30NCntzdHJpcH0NCjx0ciBjbGFzcz0ie2N5Y2xlIHZhbHVlcz0ib2Rkcm93LGV2ZW5yb3cifSI+DQoJPHRkPnskYXJjaGl2ZWRfbWVzc2FnZXNbbXlzZWNdLm1zZ0lEfTwvdGQ+DQoJPHRkPnskYXJjaGl2ZWRfbWVzc2FnZXNbbXlzZWNdLmRhdGV9PC90ZD4NCgk8dGQgc3R5bGU9ImRpc3BsYXk6bm9uZTsiPnskYXJjaGl2ZWRfbWVzc2FnZXNbbXlzZWNdLnN1YmplY3R9PC90ZD4NCgk8dGQ+eyRhcmNoaXZlZF9tZXNzYWdlc1tteXNlY10uZnVsbHVybH08L3RkPg0KCTx0ZCBzdHlsZT0iZGlzcGxheTpub25lOyI+eyRhcmNoaXZlZF9tZXNzYWdlc1tteXNlY10uaHJlZn08L3RkPg0KPC90cj4NCnsvc3RyaXB9DQp7L3NlY3Rpb259DQo8L3RhYmxlPg==]]></data>
	</file>
	<file>
	  <filename>/templates/archivedmessage.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRhcmNoaXZlZG1lc3NhZ2V9DQo8cD57JHN1YmplY3R9PC9wPg0KPGRpdiBjbGFzcz0iYXJjaGl2ZU1lc3NhZ2VCb2R5Ij57JG1lc3NhZ2Vib2R5fTwvZGl2Pg==]]></data>
	</file>
	<file>
	  <filename>/templates/compose.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX08YnIvPjxwIGNsYXNzPSdwYWdlbWVzc2FnZSc+PHN0cm9uZz57JG1lc3NhZ2V9PC9zdHJvbmc+PC9wPnsvaWZ9Cnskc3RhcnRmb3JtfQp7JG1lc3NhZ2VpZH0KeyRpc2VkaXRpbmd9CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfZnJvbX06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRmcm9tfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9yZXBseXRvfTo8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHJlcGx5X3RvfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9zdWJqZWN0fTo8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1YmplY3R9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3RlbXBsYXRlfTo8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHRlbXBsYXRlbGlzdH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfcGFnZX06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRwYWdlbGlzdH08L3A+CiAgPC9kaXY+CiAgIHtpZiAkc2VsZWN0c3RhdHVzIT0nJ30KICAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAJIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfc2VsZWN0c3RhdHVzfTo8L3A+CiAgCSA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHNlbGVjdHN0YXR1c308L3A+CiAgIDwvZGl2PgogICB7L2lmfQogICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+Cgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JG1lc3NhZ2VfaGVscH08L3A+CiAgIDwvZGl2PgogICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9tZXNzYWdlfTwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskbWVzc2FnZV90ZXh0fTwvcD4KICAgPC9kaXY+CiAgIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskc3VibWl0fTwvcD4KICAgPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/confirmform.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfY29uZmlybV9zdWJqZWN0fTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskY29uZmlybV9zdWJqZWN0fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9jb25maXJtX2VtYWlsX2JvZHl9PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRjb25maXJtX2VtYWlsX2JvZHl9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3Bvc3RfZW1haWxfY29uZmlybV90ZXh0fTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskcG9zdF9lbWFpbF9jb25maXJtX3RleHR9PC9wPgogIDwvZGl2PiAKICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH17JHJlc2V0fTwvcD4KICA8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/createjob.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlICE9ICcnfQogIHtpZiAkZXJyb3IgIT0gJyd9CiAgICA8cD48Zm9udCBjb2xvcj0icmVkIj57JG1lc3NhZ2V9PC9mb250PjwvcD4KICB7ZWxzZX0KICAgIDxwPnskbWVzc2FnZX08L3A+CiAgey9pZn0Key9pZn0KeyR0aXRsZX0KeyRzdGFydGZvcm19eyRoaWRkZW59CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbWVzc2FnZXN9PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRtZXNzYWdlbGlzdH08YnIvPnskaW5mb3R4dH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbGlzdHN9PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRsaXN0bGlzdH08YnIvPnskaW5mb3R4dH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbmFtZX06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRqb2JuYW1lfTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH0mbmJzcDt7JGNhbmNlbH08L3A+CiAgPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/createnew.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PHA+eyR0aXRsZX08L3A+CntpZiAkbWVzc2FnZSE9Jyd9CiAgPHAgY2xhc3M9J3BhZ2VtZXNzYWdlJz4KICB7aWYgJGVycm9yIT0nJ30KICAgPGZvbnQgY29sb3I9InJlZCI+CiAgey9pZn0KICA8c3Ryb25nPnskbWVzc2FnZX08L3N0cm9uZz4KICB7aWYgJGVycm9yIT0nJ30KICAgPC9mb250PgogIHsvaWZ9CiAgPC9wPgp7L2lmfQp7JHN0YXJ0Zm9ybX0KeyRoaWRkZW59eyRsaXN0aWR9CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbmFtZX08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JG5hbWV9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2Rlc2NyaXB0aW9ufTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskZGVzY3JpcHRpb259PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3B1YmxpY308L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHB1YmxpY308L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+Jm5ic3A7PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9PC9wPgogIDwvZGl2Pgo8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/createuser.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGxhYmVsPnskdGV4dH08L2xhYmVsPgp7aWYgJGVycm9yfQo8Zm9udCBjb2xvcj0icmVkIj4Key9pZn0Ke2lmICRtZXNzYWdlIG5lICIifQo8c3Ryb25nPnskbWVzc2FnZX08L3N0cm9uZz4Key9pZn0Ke2lmICRlcnJvcn0KPC9mb250Pgp7L2lmfQo8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgp7JGZvcm1zdGFydH0KeyRmb3JtaGlkZGVufQogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2VtYWlsfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskZW1haWx9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3VzZXJuYW1lfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdXNlcm5hbWV9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2Rpc2FibGVkfTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskZGlzYWJsZWR9PC9wPgogIDwvZGl2PgogIHtmb3JlYWNoIGZyb209JGxpc3RpZHMgaXRlbT1jdXJyX2lkfQogICAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskY3Vycl9pZH08L3A+CiAgICA8L2Rpdj4KICB7L2ZvcmVhY2h9CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+Jm5ic3A7PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9PC9wPgogIDwvZGl2Pgp7JGZvcm1lbmR9CjwvZGl2Pgo=]]></data>
	</file>
	<file>
	  <filename>/templates/error.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskdGl0bGVfZXJyb3J9PC9oMz4KPHA+eyRhZG1pbl9uYXZ9PC9wPgp7aWYgJG1lc3NhZ2UhPScnfTxici8+PHAgY2xhc3M9J3BhZ2VtZXNzYWdlJz48c3Ryb25nPnskbWVzc2FnZX08L3N0cm9uZz48L3A+ey9pZn0=]]></data>
	</file>
	<file>
	  <filename>/templates/feu_import.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGg0PnskdGl0bGV9PC9oND4NCjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+DQoJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbXBvcnRfZmV1X2luZm99PC9wPg0KPC9kaXY+DQp7JHN0YXJ0Zm9ybX0NCjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9ncm91cG5hbWV9OjwvcD4NCgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2dyb3VwbmFtZX08L3A+DQo8L2Rpdj4NCg0KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgk8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2NvcHl1c2VybmFtZX06PC9wPg0KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfY29weXVzZXJuYW1lfSZuYnNwO3skaW5mb19jb3B5dXNlcm5hbWV9PC9wPg0KPC9kaXY+DQoNCjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9saXN0fTwvcD4NCgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X2xpc3R9PC9wPg0KPC9kaXY+DQoNCjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+DQoJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9Jm5ic3A7eyRjYW5jZWx9PC9wPg0KPC9kaXY+DQoNCnskZW5kZm9ybX0NCg==]]></data>
	</file>
	<file>
	  <filename>/templates/feu_import_progress.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyR0aXRsZX0NCjxwPnskbGlzdGlkSW5mb317JGxpc3RpZH08L3A+DQo8cD57JHByb2Nlc3NlZEFkZHJlc3Nlc0NvdW50SW5mb317JHByb2Nlc3NlZEFkZHJlc3Nlc0NvdW50fTwvcD4NCg0KPHRhYmxlIHdpZHRoPSIxMDAlIj4NCjx0cj4NCgk8dGggd2lkdGg9IjI1JSI+eyRwcm9jZXNzZWRBZGRyZXNzZXNUaXRsZX08L3RoPg0KCTx0aCB3aWR0aD0iMjUlIj57JGluRGF0YWJhc2VUaXRsZX08L3RoPg0KCTx0aCB3aWR0aD0iMjUlIj57JG9uTGlzdEFscmVhZHlUaXRsZX08L3RoPg0KCTx0aCB3aWR0aD0iMjUlIj57JGFkZHJlc3NTdWJzY3JpYmVkVGl0bGV9PC90aD4NCjwvdHI+DQo8dHI+DQoJPHRkIHZhbGlnbj0idG9wIj57Zm9yZWFjaCBmcm9tPSRwcm9jZXNzZWRBZGRyZXNzZXMgaXRlbT1wQWRkcn17JHBBZGRyfTxiciAvPnsvZm9yZWFjaH08L3RkPg0KCTx0ZCB2YWxpZ249InRvcCI+e2ZvcmVhY2ggZnJvbT0kaW5EYXRhYmFzZSBpdGVtPWluREJ9eyRpbkRCfTxiciAvPnsvZm9yZWFjaH08L3RkPg0KCTx0ZCB2YWxpZ249InRvcCI+e2ZvcmVhY2ggZnJvbT0kb25MaXN0QWxyZWFkeSBpdGVtPW9sYX17JG9sYX08YnIgLz57L2ZvcmVhY2h9PC90ZD4NCgk8dGQgdmFsaWduPSJ0b3AiPntmb3JlYWNoIGZyb209JGFkZHJlc3NTdWJzY3JpYmVkIGl0ZW09YWRkclN1Yn17JGFkZHJTdWJ9PGJyIC8+ey9mb3JlYWNofTwvdGQ+DQo8L3RyPg0KPC90YWJsZT4NCg==]]></data>
	</file>
	<file>
	  <filename>/templates/import.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlICE9ICcnfQogIHtpZiAkZXJyb3IgIT0gJyd9CiAgICA8cD48Zm9udCBjb2xvcj0icmVkIj57JG1lc3NhZ2V9PC9mb250PjwvcD4KICB7ZWxzZX0KICAgIDxwPnskbWVzc2FnZX08L3A+CiAgey9pZn0Key9pZn0KeyR0aXRsZX0KeyRzdGFydGZvcm19CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5mb19jc3Zmb3JtYXR9PC9wPgo8L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCTxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfZmlsZW5hbWV9PC9wPgoJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9maWxlbmFtZX08L3A+CjwvZGl2Pgo8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+Cgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH08L3A+CjwvZGl2CntpZiAkbGluZXMgfQo8aHIvPgo8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF9saW5lc308L3A+Cgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGxpbmVzfTwvcD4KPC9kaXYKe2lmICR1c2Vyc2FkZGVkfQo8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF91c2Vyc2FkZGVkfTwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdXNlcnNhZGRlZH08L3A+CjwvZGl2CnsvaWZ9CntpZiAkbWVtYmVyc2hpcHNhZGRlZH0KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCTxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfbWVtYmVyc2hpcHNhZGRlZH08L3A+Cgk8cCBjbGFzcz0icGFnZWlucHV0Ij57JG1lbWJlcnNoaXBzYWRkZWR9PC9wPgo8L2Rpdgp7L2lmfQp7aWYgJGVycm9yY291bnQgIT0gJyd9CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2Vycm9yY291bnR9PC9wPgoJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRlcnJvcmNvdW50fTwvcD4Ke2ZvcmVhY2ggZnJvbT0kaW1wb3J0X2Vycm9ycyBpdGVtPWVycn0KICAgICAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JGVycn08L3A+CnsvZm9yZWFjaH0KPC9kaXYKey9pZn0Key9pZn0KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/import_errors.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PHRhYmxlPgogIDx0cj4KICAgIDx0ZD57JGVycm9yY291bnRtc2d9OjwvdGQ+CiAgICA8dGQ+eyRlcnJvcmNvdW50fTwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+eyRsaW5lc21zZ306PC90ZD4KICAgIDx0ZD57JGxpbmVzfTwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+eyR1c2Vyc2FkZGVkbXNnfTo8L3RkPgogICAgPHRkPnskdXNlcnNhZGRlZH08L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnskbWVtYmVyc2hpcHNtc2d9OjwvdGQ+CiAgICA8dGQ+eyRtZW1iZXJzaGlwc308L3RkPgogIDwvdHI+Cntmb3JlYWNoIGZyb209JGVycm9ycyBpdGVtPWVycn0KICA8dHI+CiAgICA8dGQ+Jm5ic3A7PC90ZD4KICAgIDx0ZD57JGVycn08L3RkPgogIDwvdHI+CnsvZm9yZWFjaH0KPC90YWJsZT4K]]></data>
	</file>
	<file>
	  <filename>/templates/jobs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX0KICB7aWYgJGVycm9yICE9ICcnfQogICAgPHA+PGZvbnQgY29sb3I9InJlZCI+eyRtZXNzYWdlfTwvZm9udD48L3A+CiAge2Vsc2V9CiAgICA8cD57JG1lc3NhZ2V9PC9wPgogIHsvaWZ9CnsvaWZ9CjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj48cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskaXRlbWNvdW50fSZuYnNwO3skaXRlbXNmb3VuZH08L3A+PC9kaXY+CntpZiAkaXRlbWNvdW50ID4gMH0KPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4KIDx0aGVhZD4KICA8dHI+CQogIDx0aD57JGlkdGV4dH08L3RoPgogIDx0aD57JG5hbWV0ZXh0fTwvdGg+CiAgPHRoPnskY3JlYXRlZHRleHR9PC90aD4KICA8dGg+eyRzdGFydGVkdGV4dH08L3RoPgogIDx0aD57JGZpbmlzaGVkdGV4dH08L3RoPgogIDx0aD57JGVtYWlsc3RleHR9PC90aD4KICA8dGg+eyRzdGF0dXN0ZXh0fTwvdGg+CiAgPHRoPnskYWN0aW9udGV4dH08L3RoPgogIDx0aCBjbGFzcz0icGFnZWljb24iPiZuYnNwOzwvdGg+CiAgPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KICA8L3RyPgogPC90aGVhZD4KIDx0Ym9keT4Ke2ZvcmVhY2ggZnJvbT0kaXRlbXMgaXRlbT1lbnRyeX0KICA8dHIgY2xhc3M9InskZW50cnktPnJvd2NsYXNzfSI+CiAgICA8dGQ+eyRlbnRyeS0+aWR9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5uYW1lfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+Y3JlYXRlZH08L3RkPgogICAgPHRkPnskZW50cnktPnN0YXJ0ZWR9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5maW5pc2hlZH08L3RkPgogICAgPHRkPnskZW50cnktPmVtYWlsc308L3RkPgogICAgPHRkPnskZW50cnktPnN0YXR1c308L3RkPgogICAgPHRkPnskZW50cnktPmFjdGlvbmxpbmt9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5lZGl0bGlua308L3RkPgogICAgPHRkPnskZW50cnktPmRlbGV0ZWxpbmt9PC90ZD4KICA8L3RyLz4Key9mb3JlYWNofQogPC90Ym9keT4KPC90YWJsZT4Key9pZn0KeyRjcmVhdGVsaW5rfSZuYnNwO3skZGVsZXRlY29tcGxldGVkbGlua30mbmJzcDt7JGNsZWFudGVtcGxpbmt9Jm5ic3A7eyRwcm9jZXNzbGlua308YnIvPgo=]]></data>
	</file>
	<file>
	  <filename>/templates/lists.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX0KICB7aWYgJGVycm9yICE9ICcnfQogICAgPHA+PGZvbnQgY29sb3I9InJlZCI+eyRtZXNzYWdlfTwvZm9udD48L3A+CiAge2Vsc2V9CiAgICA8cD57JG1lc3NhZ2V9PC9wPgogIHsvaWZ9CnsvaWZ9CjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj48cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskaXRlbWNvdW50fSZuYnNwO3skaXRlbXNmb3VuZH08L3A+PC9kaXY+CntpZiAkaXRlbWNvdW50ID4gMH0KPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4KIDx0aGVhZD4KICA8dHI+CQogIDx0aD57JGlkdGV4dH08L3RoPgogIDx0aD57JG5hbWV0ZXh0fTwvdGg+CiAgPHRoPnskZGVzY3RleHR9PC90aD4KICA8dGg+eyRwdWJsaWN0ZXh0fTwvdGg+CiAgPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KICA8dGggY2xhc3M9InBhZ2VpY29uIj4mbmJzcDs8L3RoPgogIDwvdHI+CiA8L3RoZWFkPgogPHRib2R5Pgp7Zm9yZWFjaCBmcm9tPSRpdGVtcyBpdGVtPWVudHJ5fQogIDx0ciBjbGFzcz0ieyRlbnRyeS0+cm93Y2xhc3N9Ij4KICAgIDx0ZD57JGVudHJ5LT5pZH08L3RkPgogICAgPHRkPnskZW50cnktPm5hbWV9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5kZXNjcmlwdGlvbn08L3RkPgogICAgPHRkPnskZW50cnktPnB1YmxpY308L3RkPgogICAgPHRkPnskZW50cnktPmVkaXRsaW5rfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+ZGVsZXRlbGlua308L3RkPgogIDwvdHIvPgp7L2ZvcmVhY2h9CiA8L3Rib2R5Pgo8L3RhYmxlPgp7L2lmfQo8ZGl2IGNsYXNzPSJwYWdlb3B0aW9ucyI+PHAgY2xhc3M9InBhZ2VvcHRpb25zIj57JGNyZWF0ZWxpbmt9PC9wPjwvZGl2Pgo=]]></data>
	</file>
	<file>
	  <filename>/templates/messages.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX0KICB7aWYgJGVycm9yICE9ICcnfQogICAgPHA+PGZvbnQgY29sb3I9InJlZCI+eyRtZXNzYWdlfTwvZm9udD48L3A+CiAge2Vsc2V9CiAgICA8cD57JG1lc3NhZ2V9PC9wPgogIHsvaWZ9CnsvaWZ9CntpZiAkbm9mb3JtID09ICcnfQo8ZGl2IGNsYXNzPSJwYWdlb3B0aW9ucyI+PHAgY2xhc3M9InBhZ2VvcHRpb25zIj57JGl0ZW1jb3VudH0mbmJzcDt7JGl0ZW1zZm91bmR9PC9wPjwvZGl2Pgp7aWYgJGl0ZW1jb3VudCA+IDB9Cjx0YWJsZSBib3JkZXI9IjAiIGNlbGxzcGFjaW5nPSIwIiBjZWxscGFkZGluZz0iMCIgY2xhc3M9InBhZ2V0YWJsZSI+CiA8dGhlYWQ+CiAgPHRyPgkKICA8dGg+eyRpZHRleHR9PC90aD4KICA8dGg+eyRmcm9tdGV4dH08L3RoPgogIDx0aD57JHN1YmplY3R0ZXh0fTwvdGg+CiAgPHRoPnskZW50ZXJlZHRleHR9PC90aD4KICA8dGggY2xhc3M9InBhZ2VpY29uIj4mbmJzcDs8L3RoPgogIDx0aCBjbGFzcz0icGFnZWljb24iPiZuYnNwOzwvdGg+CiAgPC90cj4KIDwvdGhlYWQ+CiA8dGJvZHk+Cntmb3JlYWNoIGZyb209JGl0ZW1zIGl0ZW09ZW50cnl9CiAgPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iPgogICAgPHRkPnskZW50cnktPmlkfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+ZnJvbX08L3RkPgogICAgPHRkPnskZW50cnktPnN1YmplY3R9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5lbnRlcmVkfTwvdGQ+CiAgICA8dGQ+eyRlbnRyeS0+ZWRpdGxpbmt9PC90ZD4KICAgIDx0ZD57JGVudHJ5LT5kZWxldGVsaW5rfTwvdGQ+CiAgPC90ci8+CnsvZm9yZWFjaH0KIDwvdGJvZHk+CjwvdGFibGU+CnsvaWZ9CnskY3JlYXRlbGlua308YnIvPgp7L2lmfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/subscribe.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRhZG1pbl9uYXYgbmVxICIifQoJeyRhZG1pbl9uYXZ9PGJyIC8+CnsvaWZ9CjxsYWJlbD57JHRleHR9PC9sYWJlbD4KeyRmb3Jtc3RhcnR9Cgl7JGZvcm1oaWRkZW59Cgl7JGVtYWlsfTxiciAvPgoJe2lmICRtdWx0aXBsZSBlcSB0cnVlfQoJCXtmb3JlYWNoIGZyb209JGxpc3RpZHMgaXRlbT1jdXJyX2lkfQoJCSAgeyRjdXJyX2lkfTxiciAvPgoJCXsvZm9yZWFjaH0KCXtlbHNlfQoJCTxkaXYgc3R5bGU9ImRpc3BsYXk6IG5vbmU7IHZpc2libGU6IGhpZGRlbjsiPgoJCXtmb3JlYWNoIGZyb209JGxpc3RpZHMgaXRlbT1jdXJyX2lkfQoJCSAgeyRjdXJyX2lkfQoJCXsvZm9yZWFjaH0KCQk8L2Rpdj4KCXsvaWZ9Cgl7JHN1Ym1pdGJ0bn0KeyRmb3JtZW5kfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/subscribeform.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfc3Vic2NyaWJlX2Zvcm19PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJzY3JpYmVfZm9ybX08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfc3Vic2NyaWJlc3ViamVjdH06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJzY3JpYmVfc3ViamVjdH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfc3Vic2NyaWJlX2VtYWlsX2JvZHl9OjwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskc3Vic2NyaWJlX2VtYWlsX2JvZHl9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3Bvc3RzdWJzY3JpYmV0ZXh0fTo8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHBvc3RzdWJzY3JpYmV0ZXh0fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH17JHJlc2V0fTwvcD4KICA8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/unsubscribeform.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdW5zdWJzY3JpYmVfZm9ybX08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHVuc3Vic2NyaWJlX2Zvcm19PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3Vuc3Vic2NyaWJlX3Byb21wdH08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHVuc3Vic2NyaWJlX3Byb21wdH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdW5zdWJzY3JpYmVfc3ViamVjdH08L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHVuc3Vic2NyaWJlX3N1YmplY3R9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3Vuc3Vic2NyaWJlX2VtYWlsX2JvZHl9PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR1bnN1YnNjcmliZV9lbWFpbF9ib2R5fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF91bnN1YnNjcmliZV90ZXh0fTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdW5zdWJzY3JpYmVfdGV4dH08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfcG9zdF91bnN1YnNjcmliZV90ZXh0fTwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskcG9zdF91bnN1YnNjcmliZV90ZXh0fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH17JHJlc2V0fTwvcD4KICA8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/users.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/usersettingsform.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdXNlcnNldHRpbmdzX2Zvcm19OjwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdXNlcnNldHRpbmdzX2Zvcm19PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3VzZXJzZXR0aW5nc19zdWJqZWN0fTo8L3A+CiAgICA8cCBjbGFzcz0icGFnZWlucHV0Ij57JHVzZXJzZXR0aW5nc19zdWJqZWN0fTwvcD4KICA8L2Rpdj4KICA8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHByb21wdF91c2Vyc2V0dGluZ3NfZW1haWxfYm9keX06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR1c2Vyc2V0dGluZ3NfZW1haWxfYm9keX08L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdXNlcnNldHRpbmdzX3BhZ2V9OjwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdXNlcnNldHRpbmdzX3BhZ2V9PGJyLz48ZW0+KHskaW5mb191c2Vyc2V0dGluZ3NfcGFnZX0pPC9lbT48L3A+CiAgPC9kaXY+CiAgPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyRwcm9tcHRfdXNlcnNldHRpbmdzX3RleHR9OjwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskdXNlcnNldHRpbmdzX3RleHR9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3VzZXJzZXR0aW5nc19mb3JtMn06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR1c2Vyc2V0dGluZ3NfZm9ybTJ9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3VzZXJzZXR0aW5nc190ZXh0Mn06PC9wPgogICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyR1c2Vyc2V0dGluZ3NfdGV4dDJ9PC9wPgogIDwvZGl2PgogIDxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CiAgICA8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskc3VibWl0fXskcmVzZXR9PC9wPgogIDwvZGl2Pgp7JGVuZGZvcm19Cg==]]></data>
	</file>
</module>
