+
+Theese basic language constructs provide you with some insight
+into the workings of the template system, so you can start to
+create your own templates.
+
+Let me just start by saying, all language constructs are
+defined between curly brace tokens (`{` and `}`). In case
+the template engine doesn't recognise the token, it leaves
+it as-is, with curly braces in tact. This should make the
+template engine javascript/json safe, no escaping is required.
+
+#### 1.1. Variables
+
+Using variables from templates is easy. Variables are enclosed
+in curly braces like so: `{variable}`. Since variables are parsed
+on the last stage, prefixing variables with the dollar sign is
+optional. So, `{$variable}` is the same as `{variable}`.
+
+~~~~~~~~~~~~~
+{variable} is the same as {$variable}
+~~~~~~~~~~~~~
+
+#### 1.2. Arrays
+
+There is a shorthand syntax for using arrays inside a template.
+The array index separator is a dot (`.`). Consecutive dots can be
+used for traversing into array depth like `{$array.items.0}`, or
+even variables starting with `$`, like `{$sections.$news_section.title}`.
+PHP syntax for arrays is also supported.
+
+~~~~~~~~~~~~
+{$array.items} is the same as {$array['items']}
+{$array.items.0} is the same as {$array['items'][0]}
+{$array.$items.0} is the same as {$array[$items][0]}
+~~~~~~~~~~~~
+
+#### 1.3. Modifiers
+
+Modifiers are PHP functions, which take one arbitrary value
+(usually, string), and return a string, which gets shown.
+Some functions in PHP can be used as modifiers
+(strtoupper, ucfirst, str_rot13, strrev, count, ...).
+
+~~~~~~~~~~~~~~~~~~~~~~~~
+/** Custom modifier example */
+
+function add_it_up($array)
+{
+ $size = 0;
+ foreach ($array as $value) {
+ $size += $value['size'];
+ }
+ return $size;
+}
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+To use the above function in a template, just do `{$variable|add_it_up}`,
+which will loop trough all `$variable` items and add up the value of
+the size element and return the total sum of all sizes.
+
+You can't pass additional parameters to modifiers. If you need to
+do that, then take a look at advanced templating,
+which will show you a way to embed php code inside a template.
+
+The modifier `escape` is a special template modifier, which
+gets replaced by a `htmlspecialchars($left, ENT_QUOTES);` call.
+It is used for escaping data, that might contain quotes or `<`, `>`.
+Here are a few examples of the correct use of the escape modifier.
+
+~~~~~~~~~~~~~~~
+
+
+Read more ...
+
{site.title|escape}
+~~~~~~~~~~~~~~~
+
+Aditional template modifiers are `toupper` for `strtoupper` and
+`tolower` for `strtolower`. No additional functions are created
+for theese special modifiers.
+
+~~~~~~~~~~~~~~
+{variable|escape}
+{variable|toupper}
+{variable|add_id_up}
+~~~~~~~~~~~~~~
+
+The above code gets compiled to:
+
+~~~~~~~~~~~~~~
+vars;
+ echo htmlspecialchars($_v['variable'], ENT_QUOTES);
+ echo strtoupper($_v['variable']);
+ echo add_id_up($_v['variable']);
+?>
+~~~~~~~~~~~~~~
+
+A common use for modifiers is outputting data for javascript,
+using the php function `json_encode`.
+
+#### 1.4. Objects
+
+You can also call object methods as modifiers, from global or
+local objects. The compiler will determine at run-time, if
+you have a global object by the name, and modify the code
+accordingly.
+
+~~~~~~~~~~~
+{$variable|$memcache->get}
+~~~~~~~~~~~
+
+If the global object doesn't exist, it assumes a local object.
+
+~~~~~~~~~~~
+vars;
+ echo $_v['memcache']->get($_v['variable']);
+?>
+~~~~~~~~~~~
+
+However, if a global object by the name $memcache exists at
+compile time:
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->get($_v['variable']);
+?>
+~~~~~~~~~~
+
+You can also use variables from objects, in the same way.
+
+~~~~~~~~~~~~
+{$memcache->variable}
+~~~~~~~~~~~~
+
+Compiles to one of theese:
+
+~~~~~~~~~~
+vars;
+ echo $_v['memcache']->variable;
+?>
+~~~~~~~~~~
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->variable;
+?>
+~~~~~~~~~~
+
+#### 1.5. Constants
+
+Value starting with `_` is assumed to be a constant. The template
+system will output the value of the constant if defined,
+or just the name of the constant. Item `{_MY_CONSTANT}` will be
+used as a constant, because of those rules, however `{$_my_variable}`
+wouldnt be, since it starts with the variable identifier `$`.
+
+~~~~~~~~~~~
+{_MY_CONSTANT}
+{_this_is_also_a_constant}
+{$_my_variable}
+~~~~~~~~~~~
+
+The above code gets compiled to:
+
+~~~~~~~~~~~
+vars;
+ echo _MY_CONSTANT;
+ echo _this_is_also_a_constant;
+ echo $_v['_my_variable'];
+?>
+~~~~~~~~~~~
+
+#### 1.6. Includes
+
+The statement `{include filename.tpl}` gets replaced with the content
+of the specified template, before it does any processing. In case
+you change the filename.tpl template, you have to regenerate the
+cache of the main template manually (by deleting the cache it or
+updating the source template, so the timestamp is modified).
+
+There is no limit to the number of files you can include.
+
+~~~~~~~~~~~
+
+
+ {$title}
+
+
+{include site_header.tpl}
+{$contents}
+{include site_footer.tpl}
+
+
+~~~~~~~~~~~
+
+If you need to include template files dynamically, you can use `{load}` to
+do this. This will solve some caching problems and enable you to use templates
+based on what you pass to the main template as variables via `assign`.
+
+Keep in mind that with this you can't use the `inline` and `block` definitions
+outside the loaded template, but with `include` you can.
+
+~~~~~~~~~~~
+
+
+ {$title}
+
+
+{load $dynamic_header}
+{load $dynamic_contents_template}
+{load $dynamic_footer}
+
+
+~~~~~~~~~~~
+
+
+#### 1.7. Comments
+
+Comments are enclosed between `{*` and `*}`. Comments are stripped
+at compile time, and don't show up in the compiled code or in
+the template engine output. This is useful for extensive documentation
+if needed, since it doesn't give any overhead at run-time.
+
+~~~~~~~~~~~
+{* This is a comment that won't be shown anywhere,
+ except in the source template, only to developers. *}
+
+Hello world!
+~~~~~~~~~~~
+
+The above compiles to:
+
+`Hello world!`
+
+
+
+#### for, foreach, foreach / else, while
+
+Since the main goal when doing pseudo code here is to make it
+friendly for the developer, syntax is PHP inspired. While
+this isn't ideal for web designers that make templates, it
+is ideal for the majority of the PHP developers, since they
+don't need to learn a new language for templating.
+
+~~~~~~~~~~~~
+
+{for $i=0; $i
+{/for}
+{foreach $array as $value}
+ I like values like I like: {value}
+{/foreach}
+{foreach $array as $key=>$value}
+ I like my value {value} to have a key {key}.
+{/foreach}
+{foreach $array as $key=>$value}
+ I like my value {value} to have a key {key}.
+{else}
+ I'm sorry, I have nothing in the array.
+{/foreach}
+{while ($k++ < 10)}
+ Well, k is {k}
+{/while}
+
+~~~~~~~~~~~~
+
+You see, this is very friendly for a PHP developer. Lets compare
+it to the original PHP code (two ways):
+
+~~~~~~~~~~~~
+echo '';
+for ($i=0; $i';
+}
+foreach ($array as $value) {
+ echo 'I like values like I like: '.$value.' ';
+}
+foreach ($array as $key=>$value) {
+ echo 'I like my value '.$value.' to have a key '.$key.'. ';
+}
+if (!empty($array)) {
+ foreach ($array as $key=>$value) {
+ echo 'I like my value '.$value.' to have a key '.$key.'. ';
+ }
+} else {
+ echo "I'm sorry, I have nothing in the array. ";
+}
+while ($k++ < 10) {
+ echo "Well, k is ".$k." ";
+}
+echo '';
+~~~~~~~~~~~~
+
+While this example illustrates the similarity in syntax,
+it also shows how writing templates is actually less time
+consuming and more readable in the long run.
+
+If you notice, the statements all support full PHP syntax.
+
+While not very obvious with `foreach`, you can see that
+the code is practically identical for other statements,
+where you can mix the complete PHP syntax along with
+template features like the table addressing shorthand.
+
+~~~~~~~~~~~~~~~~~~~
+
+
+The syntax for the `if` and `elseif` statements are
+PHP compatible. You can call functions, methods, use
+constants and arithmetic operations. Variables are parsed
+with the templating extensions for using arrays, so both
+syntaxes can be used at the same time.
+
+#### 3.1. if statement
+
+~~~~~~~~~~~~~
+{if $is.admin && $user['name']=="black"}
+ {* Hello black! Only you can edit things,
+ but only as long as you stay an admin. *}
+ ...
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.2. if/elseif/else statement
+
+~~~~~~~~~~~~~
+{if $is.admin && $user['name']=="black"}
+ {* Hello black! Only you can edit things,
+ but only as long as you stay an admin. *}
+ ...
+{elseif $is_moderator}
+ {* Hello moderator! You can do some things. *}
+{else}
+ {* You are a nobody and you earn nothing! *}
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.3. foreach/else statement
+
+~~~~~~~~~~~~~
+{foreach $newsitems.$section.items as $item}
+
+
{item.title}
+
{item.content}
+
+{else}
+
+ No newsitems exist in the chosen section.
+
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.4. nocache
+
+Minitpl template files are translated into PHP code to give you
+the best possible execution speed. Using `include` statements
+sometimes makes it hard to invalidate this cache, so for
+development purposes we have included a `nocache` directive.
+This erases your template cache after the file has been used once.
+
+~~~~~~~~~~~~
+{*nocache*}
+~~~~~~~~~~~~
+
+This behaviour needs to be activated by setting `$tpl->_nocache` to `true`.
+
+
+
+Depending on the usage, you might want to reuse pieces of
+the template multiple times in the same or multiple templates.
+You can achieve this by using Block and Inline definitions.
+The difference between a block and inline definition is,
+that the `block` definition defines a PHP function, and
+can be used recursively in the template, for example, to
+traverse a tree structure. The `inline` definition only
+allows the same piece of template code to be reused multiple
+times.
+
+#### 4.1 block definition and usage
+
+~~~~~~~~~~~
+{block recurse}
+{if $i++ < 10}
+ call {i}
+ {block:recurse}
+{/if}
+{/block}
+
+{block:recurse}
+~~~~~~~~~~~
+
+The compiled template will look something like this:
+
+~~~~~~~~~~~
+vars;
+ function recurse_1213891842_673($_v) {
+ if ($_v['i']++ < 10) {
+ echo "call ".$_v['i'];
+ recurse_1213891842_673(&$_v);
+ }
+ }
+ recurse_1213891842_673(&$_v);
+?>
+~~~~~~~~~~~
+
+As you can see, the block definition gets compiled into
+a function definition, which lives in the same variable space.
+
+While traversing a tree this way isn't very practical,
+it is however possible. You probablly won't ever need
+this functionality. In our experience recursion itself
+is very rare, and even if used, it is handled on the PHP
+level, and not the templating level.
+
+You can use `block` definitions instead of `inline` definitions
+if you are worried about code overhead. I would consider this
+ when an `inline` definition is multiple kilobytes in size and
+is beeing used extensively in the same template.
+
+#### 4.2 inline definition and usage
+
+The inline keyword comes from `C++`, where the compiler
+would replace the calls to an inline function definition
+with the function itself. This is a speed gain for
+`C++`, since calling a function many times is more
+expensive, than copying the code around. The practical
+reason for this inside a template goes along the same
+train of thought.
+
+~~~~~~~~~~
+{inline newsitem}
+
+
{news.title}
+
{news.content}
+
+{/inline}
+
+
+ {foreach $newsitems.top.items as $news}{inline:newsitem}{/foreach}
+
+
+
+{foreach $newsitems.$section.items as $news}{inline:newsitem}{/foreach}
+
+~~~~~~~~~~
+
+Usage of `inline` definition decreases template size before
+compilation, and helps with design standardisation. Same page
+components can be literally re-used inside the template and
+changing one aspect of the design is done in one place instead
+of every place the same code snippet is used.
+
+
+
+Since the above language constructs only take care of the
+read only aspect of template programming, there is sometimes
+also a need to modify variables inside templates for various
+uses. The `eval` and `eval_literal` constructs take care
+of that. The `php` construct is ment for more advanced
+operations, and like `eval` lives in the template variable
+space.
+
+#### 5.1 eval
+
+The eval construct allows quick operations on local
+template variables. For example, if you want to build
+a table with alternating css styles on rows, you would
+do something like this:
+
+~~~~~~~~~~~~~
+{eval $style="even";}
+
+~~~~~~~~~~~~~
+
+All variables when using the `eval` construct, are
+mapped to local template variables.
+
+It is not ok to use variables named or starting with
+`$_v`, since that will result in naming errors on
+compile time, and you won't be able to use your data
+in the template, since it's in the wrong location.
+
+#### 5.2 eval_literal
+
+When you need global variables and objects, to execute more complex
+code, you can use the `eval_literal` construct. The code inside
+does not get evaluated, meaning it is kept as-is.
+
+~~~~~~~~~~~
+{eval_literal
+ global $cms_module;
+ $_v['menu_data'] =
+ $cms_module->get_menu("branch", array("item","menu")); }
+~~~~~~~~~~~
+
+#### 5.3 php
+
+~~~~~~~~~~~~~~~
+{php}
+function mygettime()
+{
+ return array("time"=>time(),"date"=>date("r"),"microtime"=>microtime());
+}
+$mygettime = mygettime();
+{/php}
+
+{mygettime|var_dump}
+~~~~~~~~~~~~~~~
+
+The above code gets compiled into:
+
+~~~~~~~~~
+vars;
+
+ function mygettime()
+ {
+ return array("time"=>time(),"date"=>date("r"),"microtime"=>microtime());
+ }
+
+ $_v['mygettime'] = mygettime();
+
+ echo var_dump($_v['mygettime']);
+?>
+~~~~~~~~~
+
+This is by far the least used construct and also least tested.
+If you want to build objects or functions or use a lot of PHP
+code inside the template, you are definetly doing something wrong,
+even if supported by the templating system.
+
+It is not ok to use variables named or starting with
+`$_v`, since that will result in naming errors on
+compile time, and you won't be able to use your data
+in the template, since it's in the wrong location.
+
+
+
+This section is about functionality of the template system in PHP.
+You already know how to make templates like the ones above, this
+teaches you how to create the PHP code, that uses the templates.
+
+#### 6.1 Basic usage
+
+For basic usage, you need to include the file `class.template.php`.
+The functions used include `class.template_compiler.php` if needed.
+The following methods are exported:
+
+`load`, `assign`, `render`, `get`, `set_paths`, `set_compile_location`, `compile`
+
+You will probablly only use the first four methods unless you
+want to change the default paths, where the system is searching for
+templates, or if you want to do your own compiling of templates
+for whatever reason.
+
+##### 6.1. load ( string $filename )
+
+With this method you specify which template file to load. It will
+search trough the configured paths (Default: `templates/`) and
+use the template. Calling this method resets the template to it's
+defaults, and you have to fill up the content using the `assign`
+method.
+
+##### 6.2. assign ( mixed $key, [ mixed $value = '' ] )
+
+This is the most complex method available, and it's behaviour is
+dependant on the parameters supplied.
+
+If the first parameter is an array, and the second parameter stays
+at the default value, an entry will be created for each key and value
+pair in the first parameter.
+
+If the first parameter is an array, and the second parameter is
+a string value, an entry will be created for each key and value
+pair in the first parameter, using the second parameter as a prefix
+for each key.
+
+If the first parameter is a string, the second parameter will be
+assigned as it's value. The second parameter can be any PHP type.
+
+~~~~~~~~
+$data = array(); // some example data
+$data['title'] = "Leno promises smooth transition to O'Brien";
+$data['content'] = "For months, Fallon has been widely considered
+ the top choice to succeed O’Brien when he steps
+ down next year. On Thursday, published reports ...";
+
+/* This will define an entry {timestamp} */
+
+$tpl->assign("timestamp", time());
+
+/* This will define entries {title} and {content} */
+
+$tpl->assign($data);
+
+/* This example will define {news_title} and {news_content} */
+
+$tpl->assign($data, "news");
+
+/* This will define the item {news}, which contains an array.
+ You can output the fields with {news.title} and {news.content} */
+
+$tpl->assign("news", $data);
+~~~~~~~~
+
+##### 6.3. render and get
+
+Theese methods dont have any arguments. Template compilation is
+done in the background, if needed. The method `render` outputs
+the data to standard output, while the method `get` simply returns
+it, in order to use it in PHP.
+
+##### 6.4. set_paths ( [ $paths = false ] )
+
+The method `set_paths`, takes an array, with possible locations
+for template files. The compiled location is set with the
+`set_compile_location` function documented later. Paths passed to
+this function, must end with a trailing slash.
+
+The template system will traverse the `$paths` array searching
+for template files, until one is found. If none are found, an
+error is printed, and the script execution is terminated.
+
+This is useful if you have multiple template locations, which
+are overridable. For example, you can have the following CMS
+structure.
+
+~~~~~~~~~~~~~~~
+$paths = array();
+
+/* This is the most important location, everything
+ can be overriden from inside the theme. */
+
+$paths[] = "theme/templates/";
+
+/* This is the second most important location,
+ it usually defines the look of the cms modules */
+
+$paths[] = "modules/".$module_name."/templates/";
+
+/* This is the least important template location,
+ it usually provides system wide templates, like
+ a paginator template, an xml / rss template, or
+ other very general templates. */
+
+$paths[] = "include/templates/";
+
+$tpl->set_paths($paths);
+~~~~~~~~~~~~~~~
+
+Templating constructs like `{include}` are affected by the path
+settings. The included templates use the same paths in the same
+order, until a needed template is found.
+
+The following syntax is also allowed since 2012/05/24:
+
+~~~~~~~~~~~~~~~
+$tpl->set_paths("theme/templates/","modules/".$module_name."/templates/","include/templates/");
+~~~~~~~~~~~~~~~
+
+##### 6.5. $this->set_compile_location( [ $compile_location = "cache/" [ , $is_absolute = false ] ] );
+
+By default the compile location of the templates is relative to the
+source template folder. So, with the template locations listed above,
+you would need a `cache/` folder under every location, to store the compiled
+template files for later use.
+
+You can modify this behavior with the `set_compile_location` function.
+You can set the cache location to a common folder, and mark it as
+an absolute location (as opposed to the default, relative path).
+
+~~~~~~~~~~~~~~~
+$tpl->set_compile_location("/tmp/minitpl", true);
+~~~~~~~~~~~~~~~
+
+The example will store all your templates under `/tmp/minitpl`. This
+location needs to be writable. The compiled files under the location
+can be safely deleted any time, if you want to regenerate them.
+
+When caching, a full path structure will be created, to avoid any
+conflicts between templates, that use same names. For example:
+
+If you have a template named `site.tpl` under two distinct locations like
+`theme/templates/` and `theme/issue2012/templates/` and use both sources,
+the conflict is resolved by creating the following structure in the
+cache location:
+
+~~~~~~~~~~~~~~~
+/tmp/minitpl/theme/templates/site.tpl
+/tmp/minitpl/theme/issue2012/templates/site.tpl
+~~~~~~~~~~~~~~~
+
+This can let you change your source folders with `set_paths~ and and the
+same time only have one cache location for all your templates. When
+you want to expunge any stale cache files or use minitpl in a more complex
+system, this is a much simpler approach for cache management.
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/documentation/documentation_sl.markdown b/crm/docs/vendor/monotek/minitpl/documentation/documentation_sl.markdown
new file mode 100644
index 000000000..2ac40fdbd
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/documentation/documentation_sl.markdown
@@ -0,0 +1,705 @@
+Monotek Mini Template
+=====================
+
+Zadnje posodobljeno - Tue 18 Dec 2012 11:24:30 AM CET
+
+Avtor: Tit Petrič ( tit.petric@monotek.net ) / Monotek d.o.o.
+
+
+Predstavitev
+------------
+
+Stabilna Produkcijska različica podpira sestavljanje šablone in je združljiva
+s PHP4 in PHP5. Za ohranjanje majhne velikosti kode uporablja zelo napredne
+funkcije, ob tem pa poskrbi za izjemno uporabnost.
+
+Celotna koda je velika 13,5 KB in vsebuje minimalno količino komentarjev in
+zamik kode z uporabo tabulatorjev za berljivost.
+
+Koda je zaščitena z [Creative Commons Priznanje Avtorstva - Deljenje pod
+enakimi pogoji](http://creativecommons.org/licenses/by-sa/3.0/) licenco.
+
+
+Namestitev in potrebna programska oprema
+----------------------------
+
+Za delovanje Monotek Mini Template potrebujete PHP različice 4.3.0 ali novejšo.
+Sistem lahko deluje tudi s starejšimi PHP različicami, če priskrbite svojo
+[file_get_contents()}(http://php.net/file_get_contents) funkcijo.
+
+Glede na mapo, kjer uporabljate template objekt, potrebujete mape:
+
+> templates/
+> templates/cache/ *
+
+Ker pa se ta template sistem sestavlja, boste potrebovali tudi cache mapo.
+
+Jezikovna vezava
+------------------
+
+Ker je način uporabe template sistema podoben Smarty template sistemu in PHP
+programskem jeziku, vam bo poznavanje PHP osnov v pomoč pri uporabi tega
+template sistema.
+
+1. Sestava jezika
+2. Zanke
+3. Pogoji
+4. Block in Inline definicije
+5. Napredno, vstavljanje PHP kode
+6. Uporaba template sistema v PHP
+
+----------------------------------------------------------
+
+
+
+Jezikovna sestava vam ponuja razlago delovanja sistema, da boste lahko pričeli
+z ustvarjanjem in uporabo svojih template datotek. Prva stvar, katero je
+potrebno povedat je, da so vse jezikovne sestave definirane med zavitima
+oklepajema (`{` in `}`). Če template sistem ne prepozna jezikovne sestave, je
+ne prevaja. To omogoča uporabo javascript in json zapisov brez težav.
+
+#### 1.1. Spremenljivke
+
+Uporaba spremenljivk je enostavna. Spremenljivke so zaprte med zavite oklepaje:
+`{spremenljivka}`. Ker so spremenljivke prevedene v zadnji stopnji, je uporaba
+znaka dolar pred njimi neobvezna. Zato ni nobene razlike med zapisom
+`{$spremenljivka}` in zapisom `{spremenljivka}`, oba sta pravilna.
+
+~~~~~~~~~~~~~
+{spremenljivka} je enako kot {$spremenljivka}
+~~~~~~~~~~~~~
+
+#### 1.2. Množice
+
+Obstaja kratek način uporabe množic znotraj template. Če želite izpisati
+spremenljivko, ki se nahaja znotraj množice, za naslavljanje uporabite operator
+`.` (pika). Množice lahko naslavljate v poljubno globino kot `$mnozica.tocka.0`
+ali pa tudi z uporabo spremenljivk, ki se začnejo z znakom dolar
+`{$mnozica.$novice.naslov}`. Prav tako je mogoča uporaba PHP jezikovne sestave
+kot je razvidno iz spodnjega primera.
+
+~~~~~~~~~~~~
+{$array.items} je enako kot {$array['items']}
+{$array.items.0} je enako kot {$array['items'][0]}
+{$array.$items.0} je enako kot {$array[$items][0]}
+~~~~~~~~~~~~
+
+#### 1.3. Prikrojevalci
+
+Prikrojevalci so PHP funkcije, ki iz poljubne vrednosti (ponavadi besede)
+vrnejo besedo, ki se prikaže. Nekatere PHP funkcije se lahko uporabljajo
+kot prikrojevalci (strtoupper, ucfirst, str_rot13, strrev, count, ...).
+
+~~~~~~~~~~~~~~~~~~~~~~~~
+/** Primer uporabe prikrojevalcev */
+
+function add_it_up($array)
+{
+ $size = 0;
+ foreach ($array as $value) {
+ $size += $value['size'];
+ }
+ return $size;
+}
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Za uporabo zgornje funkcije kot prikrojevalca v template datoteko vpišite
+`{$variable|add_it_up}`. Prikrojevalec bo šel čez vse elemente spremenljivke
+in seštel vrednosti pod ključem `size`, ter izpisal seštevek.
+
+Podajanje dodatnih parametrov prikrojevalcem ni omogočeno. Če ne morete okoli
+tega, potem si oglejte kategorijo naprednih zmožnosti
+kjer boste zvedeli za način, kako vključiti PHP kodo v template datoteko.
+
+Template sistem vključuje poseben prikrojevalec z imenom `escape`, kater se
+zamenja z klicem `htmlspecialchars($left, ENT_QUOTES);`. Ta prikrojevalec vam
+služi za izpis podatkov znotraj HTML, kateri mogoče vsebujejo narekovaje ali
+pa znake `<` (manjše) in `>` (večje). V primeru je demonstrirana pravilna
+uporaba uporaba tega prikrojevalca.
+
+~~~~~~~~~~~~~~~
+
+
+Read more ...
+
{site.title|escape}
+{content} {* pričakujemo HTML, tukaj ne rabimo escape *}
+~~~~~~~~~~~~~~~
+
+Dodatna template prikrojevalca sta še `toupper` za `strtoupper` in `tolower`
+za `strtolower`. Za naštete prikrojevalce ni narejenih posebnih funkcij.
+
+~~~~~~~~~~~~~~
+{variable|escape}
+{variable|toupper}
+{variable|add_id_up}
+~~~~~~~~~~~~~~
+
+Zgornja koda se prevede v naslednje:
+
+~~~~~~~~~~~~~~
+vars;
+ echo htmlspecialchars($_v['variable'], ENT_QUOTES);
+ echo strtoupper($_v['variable']);
+ echo add_id_up($_v['variable']);
+?>
+~~~~~~~~~~~~~~
+
+V praksi se prikrojevalci pogosto uporabljajo za izpis podatkov v json notaciji
+za uporabo znotraj javascript knjižnic (uporaba funkcije `json_encode`)
+
+#### 1.4. Objekti
+
+Objekte lahko kličete tudi kot prikrojevalce, za globalne ali lokalne objekte.
+Ob prevajanju se določi, če obstaja globalni objekt z navedenim imenom in
+se glede na to prilagodi prevedeno kodo.
+
+~~~~~~~~~~~
+{$variable|$memcache->get}
+~~~~~~~~~~~
+
+Če globalni objekt ne obstaja se predvideva, da obstaja lokalni objekt.
+
+~~~~~~~~~~~
+vars;
+ echo $_v['memcache']->get($_v['variable']);
+?>
+~~~~~~~~~~~
+
+Če globalni objekt v času prevajanja obstaja se template prevede tako:
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->get($_v['variable']);
+?>
+~~~~~~~~~~
+
+Na enak način lahko uporabljate tudi spremenljivke iz objektov.
+
+~~~~~~~~~~~~
+{$memcache->variable}
+~~~~~~~~~~~~
+
+Kar se prevede se v naslednje:
+
+~~~~~~~~~~
+vars;
+ echo $_v['memcache']->variable;
+?>
+~~~~~~~~~~
+
+ali
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->variable;
+?>
+~~~~~~~~~~
+
+#### 1.5. Konstante
+
+Vrednost, ki ima na začetku znak `_` se smatra za konstanto. Template sistem
+bo izpisal vrednost konstante, če je ta določena, ali pa ime konstante če ni.
+Zaradi teh pravil bo niz `{_MOJA_KONSTANTA}` uporabljen kot konstanta, medtem
+ko bo `{$_MOJA_NESPREMENLJIVKA}` uporabljen kot spremenljivka, ker se začne z
+znakom za dolar `$`.
+
+~~~~~~~~~~~
+{_MY_CONSTANT}
+{_this_is_also_a_constant}
+{$_my_variable}
+~~~~~~~~~~~
+
+Zgornja koda se prevede v naslednje:
+
+~~~~~~~~~~~
+vars;
+ echo _MY_CONSTANT;
+ echo _this_is_also_a_constant;
+ echo $_v['_my_variable'];
+?>
+~~~~~~~~~~~
+
+#### 1.6. Vključitev ločenih template datotek
+
+Niz `{include imedatoteke.tpl}` se zamenja z vsebino določene template
+datoteke ob začetku prevajanja. V primeru, da želite spremeniti vsebino
+vključene template datoteke, morate obnoviti prevedeno kodo glavne template
+datoteke. To naredite ročno (z izbrisom vsebine cache direktorija ali obnovo
+časa posodobitve glavne template datoteke). V template datotekah lahko
+vključite poljubno število drugih template datotek.
+
+~~~~~~~~~~~
+
+
+ {$title}
+
+
+{include site_header.tpl}
+{$contents}
+{include site_footer.tpl}
+
+
+~~~~~~~~~~~
+
+Če želite imeti dejansko nalaganje skupnih datotek, kar reši nekatere težave
+okoli dinamičnega nalaganja in hranjenja cache datotek, potem uporabite `{load}`:
+
+Imejte v mislih, da s to metodo ni možna uporaba `inline` in `blok` definicij
+izven naložene template datoteke. To lahko dosežete z uporabo `include`.
+
+~~~~~~~~~~~
+
+
+ {$title}
+
+
+{load $dynamic_header}
+{load $dynamic_contents_template}
+{load $dynamic_footer}
+
+
+~~~~~~~~~~~
+
+#### 1.7. Komentarji
+
+Komentarji so zaprti med `{*` in `*}`. Komentarji se odstranijo med prevajalnim časom in se ne prikažejo v prevedeni kodi ali izpisu. Uporabni so za izčrpno dokumentacijo, s čimer ne povzročajo povečanega časa obdelave.
+
+~~~~~~~~~~~
+{* This is a comment that won't be shown anywhere,
+ except in the source template, only to developers. *}
+
+Hello world!
+~~~~~~~~~~~
+
+Kar se prevede v:
+
+~~~~~~~~~~~
+`Hello world!`
+~~~~~~~~~~~
+
+
+
+#### for, foreach, foreach / else, while
+
+Cilj sintakse je pomagati razvijalcu, zato je podobna PHP sintaksi.
+Medtem ko to ni idealno za spletne programerje, ki izdelujejo template
+datoteke, je idealno za veliko večino PHP razvijalcev, katerim se ni
+potrebno naučiti novega programskega jezika za template sistem.
+Pravtako, osnove PHP jezika kot so predstavljene, nebi smele predstavljati
+večjih problemov za oblikovalce, ki že zdaj izdelujejo template datoteke
+npr. za Smarty. Običajno programer naredi prvo template datoteko, oblikovalci
+jo pa za tem popravljajo.
+
+~~~~~~~~~~~~
+
+{for $i=0; $i
+{/for}
+{foreach $array as $value}
+ I like values like I like: {value}
+{/foreach}
+{foreach $array as $key=>$value}
+ I like my value {value} to have a key {key}.
+{/foreach}
+{foreach $array as $key=>$value}
+ I like my value {value} to have a key {key}.
+{else}
+ I'm sorry, I have nothing in the array.
+{/foreach}
+{while ($k++ < 10)}
+ Well, k is {k}
+{/while}
+
+~~~~~~~~~~~~
+
+Kot vidite, je template sistem zelo prijazen PHP razvijalcem.
+Primerjava z originalno PHP kodo (dva načina):
+
+~~~~~~~~~~~~
+echo '';
+for ($i=0; $i';
+}
+foreach ($array as $value) {
+ echo 'I like values like I like: '.$value.' ';
+}
+foreach ($array as $key=>$value) {
+ echo 'I like my value '.$value.' to have a key '.$key.'. ';
+}
+if (!empty($array)) {
+ foreach ($array as $key=>$value) {
+ echo 'I like my value '.$value.' to have a key '.$key.'. ';
+ }
+} else {
+ echo "I'm sorry, I have nothing in the array. ";
+}
+while ($k++ < 10) {
+ echo "Well, k is ".$k." ";
+}
+echo '';
+~~~~~~~~~~~~
+
+Medtem ko ta primer prikazuje podobnost v skladnji, prikazuje tudi, kako vam
+pisanje template datotek lahko vzame manj časa in je končni izdelek bolj
+berljiv. Če ste morda opazili, izjave podpirajo celotno PHP sintakso.
+Medtem ko to ni očitno ko pride do `foreach` zanke, lahko vidite, da je
+pri ostalih primerih prevedena koda skoraj identična template kodi.
+
+~~~~~~~~~~~~~~~~~~~
+
+
+Sintaksa za `if` in `elseif` izjave je enaka kot v PHP. Z njimi lahko kličete
+funkcije, metode, uporabljate konstante in izvajate aritmetične operacije.
+Spremenljivke so prevedene v lokalne spremenljivke, katere ste določili pri
+prikazu template datoteke. Istočasno se lahko uporablja PHP sintakso za
+naslavljanje množic kot pa tudi olajšano (shorthand) sintakso z uporabo pike.
+V prvem primeru je demonstrirana različna sintaksa za množice.
+
+#### 3.1. if izjave
+
+~~~~~~~~~~~~~
+{if $is.admin && $user['name']=="black"}
+ {* Hello black! Only you can edit things,
+ but only as long as you stay an admin. *}
+ ...
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.2. if/elseif/else izjave
+
+~~~~~~~~~~~~~
+{if $is.admin && $user['name']=="black"}
+ {* Hello black! Only you can edit things,
+ but only as long as you stay an admin. *}
+ ...
+{elseif $is_moderator}
+ {* Hello moderator! You can do some things. *}
+{else}
+ {* You are a nobody and you earn nothing! *}
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.3. foreach/else izjave
+
+~~~~~~~~~~~~~
+{foreach $newsitems.$section.items as $item}
+
+
{item.title}
+
{item.content}
+
+{else}
+
+ No newsitems exist in the chosen section.
+
+{/if}
+~~~~~~~~~~~~~
+
+#### 3.4. nocache
+
+MiniTPL template datoteke se prevajajo v PHP datoteke po potrebi
+za najboljšo možno hitrost izvajanja. Z uporabo `{include}` direktiv
+se osveževanje php datotek rahlo zakomplicira. Za potrebe razvoja smo
+dodali `nocache` direktivo. Z uporabo direktive zagotovite, da se vaš
+template cache zbriše po vsaki uporabi.
+
+~~~~~~~~~~~~
+{*nocache*}
+~~~~~~~~~~~~
+
+To funkcionalnost se mora omogočiti z setiranjem `$tpl->_nocache` na `true`.
+
+
+
+Odvisno od uporabe boste morda želeli večkrat uporabiti delce iste kode v
+eni ali večih template datotekah. To lahko dosežete z uporabo `block` in
+`inline` definicij. Razlika med `block` definicijo in `inline` definicijo je
+v tem, da se `block` definicija prevede v PHP funkcijo in jo lahko uporabljamo
+rekurzivno, naprimer za ustvarjanje drevesne strukture. Uporaba `inline`
+definicije vam omogoča le večkratno uporabo enake kode.
+
+#### 4.1 block definicija in uporaba
+
+~~~~~~~~~~~
+{block recurse}
+{if $i++ < 10}
+ call {i}
+ {block:recurse}
+{/if}
+{/block}
+
+{block:recurse}
+~~~~~~~~~~~
+
+Prevedena template datoteka bo izgledala nekako takole:
+
+~~~~~~~~~~~
+vars;
+ function recurse_1213891842_673($_v) {
+ if ($_v['i']++ < 10) {
+ echo "call ".$_v['i'];
+ recurse_1213891842_673(&$_v);
+ }
+ }
+ recurse_1213891842_673(&$_v);
+?>
+~~~~~~~~~~~
+
+Kot lahko vidite, se `block` definicija prevede v funkcijo, ki uporablja
+iste spremenljivke, katere ste določili template datoteki.
+
+Ustvarjanje ali izris drevesne strukture ta način ni zelo praktičen, je pa
+možen. Vrjetno nikoli ne boste potrebovali tega. Po naših izkušnjah je
+rekurzija uporabljena le redko, če pa že, pa v PHP kodi in ne v template
+datotekah.
+
+Uporabite lahko `block` konstrukt namesto `inline`, če vas skrbi za velikost
+prevedene template datoteke. Sam bi to predlagal, ko pridete do tega, da je
+ena `inline` definicija dolga več kilobyteov in se jo uporablja večkrat v
+isti template datoteki.
+
+#### 4.2 inline definicija in uporaba
+
+Ključna beseda `inline` prihaja iz programskega jezika `C++`, kjer prevajalnik
+zamenja klice inline funkcij z vsebino funkcije. S tem v `C++` pridobimo na
+hitrosti, ker je klicanje funkcije bolj praktično za berljivost, kot pa
+kopiranje kode po najvišjem nivoju. Iz enakega razloga se uporablja tudi
+v tem template sistemu.
+
+~~~~~~~~~~
+{inline newsitem}
+
+
{news.title}
+
{news.content}
+
+{/inline}
+
+
+ {foreach $newsitems.top.items as $news}{inline:newsitem}{/foreach}
+
+
+
+{foreach $newsitems.$section.items as $news}{inline:newsitem}{/foreach}
+
+~~~~~~~~~~
+
+Uporaba `inline` definicij zmanjša velikost template datotek pred prevajanjem
+in pripomore k lepši obliki template datotek. Določeni sestavni deli so lahko
+torej večkrat uporabljeni v template datoteki.
+
+
+
+Medtem ko zgornji jezikovni sestavki poskrbijo le za izpis, včasih potrebujemo
+tudi posodobiti spremenljivke znotraj template datoteke. Za to poskrbijo
+sestavki `eval`, `eval_literal` in `php`. Sestavek `php` je namenjen
+zahtevnejšim operacijam in ima kot `eval` dostop direktno do spremenljivk
+katere ste podali template datoteki.
+
+#### 5.1 eval
+
+Eval sestavek vam omogoča hitre operacije z lokalnimi template spremenljivkami.
+Če želite naprimer narediti tabelo, ki ima v vsaki vrstici drugačen CSS stil,
+bi to naredili nekako takole:
+
+~~~~~~~~~~~~~
+{eval $style="even";}
+
+~~~~~~~~~~~~~
+
+Uporabo spremenljivke `$_v` odsvetujemo, saj lahko povzročajo napake
+pri prevajanju, ali pa z uporabo te spremenljivke prepišete podatke, kateri
+so bili namenjeni prikazu.
+
+Uporaba `{` in `}` znotraj `eval` in `eval_literal` sestavkov ni mogoča.
+
+#### 5.2 eval_literal
+
+Ko potrebujete za izvajanje kode globalne spremenljivke ali objekte,
+lahko uporabite `eval_literal` sestavek. Koda znotraj sestavka se ne prevede,
+ostane torej taka kot je.
+
+~~~~~~~~~~~
+{eval_literal
+ global $cms_module;
+ $_v['menu_data'] =
+ $cms_module->get_menu("branch", array("item","menu")); }
+~~~~~~~~~~~
+
+Uporaba `{` in `}` znotraj `eval` in `eval_literal` sestavkov ni mogoča.
+
+#### 5.3 php
+
+~~~~~~~~~~~~~~~
+{php}
+function mygettime()
+{
+ return array("time"=>time(),"date"=>date("r"),"microtime"=>microtime());
+}
+$mygettime = mygettime();
+{/php}
+
+{mygettime|var_dump}
+~~~~~~~~~~~~~~~
+
+Zgornja koda se prevede v:
+
+~~~~~~~~~
+vars;
+
+ function mygettime()
+ {
+ return array("time"=>time(),"date"=>date("r"),"microtime"=>microtime());
+ }
+
+ $_v['mygettime'] = mygettime();
+
+ echo var_dump($_v['mygettime']);
+?>
+~~~~~~~~~
+
+To je najmanj uporabljen in najmanj testiran sestavek. Če želite zgraditi
+objekte ali funkcije ali uporabiti veliko PHP kode znotraj tamplate datoteke,
+definitivno delate nekaj narobe, čeprav template sistem to podpira.
+
+Uporabo spremenljivke `$_v` odsvetujemo, saj lahko povzročajo napake
+pri prevajanju, ali pa z uporabo te spremenljivke prepišete podatke, kateri
+so bili namenjeni prikazu.
+
+
+
+V tej kategoriji bomo pregledali zmogljivosti template sistema v PHP.
+Ker že znate izdelovati template datoteke vam bomo v tem oddelku prikazali,
+kako narediti PHP kodo s katero uporabimo template datoteke.
+
+#### 6.1 Osnovna uporaba
+
+Za osnovno uporabo morate vključiti datoteko `class.template.php`. Uporabljene
+funkcije bodo po potrebi same vključile datoteko `class.template_compiler.php`.
+Za razvijalce so na voljo naslednje metode:
+
+`load`, `assign`, `render`, `get`, `set_paths`, `compile`
+
+Ponavadi boste uporabljali le prve štiri metode, če seveda ne želite
+spremeniti map, kjer sistem išče template datoteke ali pa bi želeli sami
+prevajati template datoteke.
+
+##### 6.1. load ( string $filename )
+
+S to metodo določite katera template datoteka se naj naloži. Metoda bo
+preiskala nastavljene poti (Privzeto: `templates/`) in naložila želeno
+template datoteko. Klic te metode izprazni podatke namenjene template
+datoteki, katerega naknadno določite z uporabo `assign` metode.
+
+##### 6.2. assign ( mixed $key, [ mixed $value = '' ] )
+
+Za programerja je ta metoda najbolj ključna. Rezultat metode je različen glede
+na količino in vrstni red podanih parametrov.
+
+Če je prvi parameter množica, drug parameter pa ni podan, potem se template
+datoteki določi ena vrednost z ključem vnosa v množico, za vsak vnos.
+
+Če je prvi parameter množica in drug parameter niz znakov, bo narejen vnos
+za vsako vrednost v množici. Za ključ vnosa bo uporabljen niz v drugem
+parametru, kateremu sledi `_` in potem ključ vnosa iz množice.
+
+Če je prvi parameter niz znakov, potem bo drug parameter določen kot vrednost
+dosegljiva pod ključem prvega parametra. Tip drugega parametra ni pomemben.
+
+~~~~~~~~
+$data = array(); // some example data
+$data['title'] = "Leno promises smooth transition to O'Brien";
+$data['content'] = "For months, Fallon has been widely considered
+ the top choice to succeed O’Brien when he steps
+ down next year. On Thursday, published reports ...";
+
+/* This will define an entry {timestamp} */
+
+$tpl->assign("timestamp", time());
+
+/* This will define entries {title} and {content} */
+
+$tpl->assign($data);
+
+/* This example will define {news_title} and {news_content} */
+
+$tpl->assign($data, "news");
+
+/* This will define the item {news}, which contains an array.
+ You can output the fields with {news.title} and {news.content} */
+
+$tpl->assign("news", $data);
+~~~~~~~~
+
+##### 6.3. render, get
+
+Te metode nimajo parametrov. Prevajanje template datotek je izvedeno v ozadju,
+če je potrebno. Metoda `render` izpiše podatke v navadni obliki, medtem ko
+jih medota `get` vrne v obliki katero lahko uporabimo v PHP.
+
+##### 6.4. set_paths ( [ $paths = false ] )
+
+Metoda `set_paths` vzame množico z možnimi lokacijami za template datoteke.
+Lokacija za prevajanje template datotek je mapa `cache`, katera mora obstajati
+v vsaki od podanih map. Podane mape se morajo končati z vrezom (slash).
+
+Template sistem bo pregledal `$paths` množico, dokler ne najde template
+datoteke, katero želimo naložiti preko metode `load`. Če datoteke ne najde,
+izpiše napako, izvajanje se konča.
+
+Metoda je uporabna v primeru, če želite imeti več map s template datotekami.
+Naprimer, če želite imeti CMS strukturo.
+
+~~~~~~~~~~~~~~~
+$paths = array();
+
+/* This is the most important location, everything
+ can be overriden from inside the theme. */
+
+$paths[] = "theme/templates/";
+
+/* This is the second most important location,
+ it usually defines the look of the cms modules */
+
+$paths[] = "modules/".$module_name."/templates/";
+
+/* This is the least important template location,
+ it usually provides system wide templates, like
+ a paginator template, an xml / rss template, or
+ other very general templates. */
+
+$paths[] = "include/templates/";
+
+$tpl->set_paths($paths);
+~~~~~~~~~~~~~~~
+
+Konstrukt `{include}` v template datotekah upošteva nastavitve podane preko
+metode `set_paths`. Pred prevajanjem sistem išče datoteke za vključitev na
+istih lokacijah, dokler jih ne najde.
diff --git a/crm/docs/vendor/monotek/minitpl/phpunit.xml b/crm/docs/vendor/monotek/minitpl/phpunit.xml
new file mode 100644
index 000000000..5a059e95c
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/phpunit.xml
@@ -0,0 +1,22 @@
+
+
+
+ test/TemplateTest.php
+
+
+
+
+ code
+
+ vendor
+
+
+
+ vendor
+ /usr/local/bin/phpunit
+
+
+
+
+
+
diff --git a/crm/docs/vendor/monotek/minitpl/test/.gitignore b/crm/docs/vendor/monotek/minitpl/test/.gitignore
new file mode 100644
index 000000000..4ebc8aea5
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/.gitignore
@@ -0,0 +1 @@
+coverage
diff --git a/crm/docs/vendor/monotek/minitpl/test/TemplateTest.php b/crm/docs/vendor/monotek/minitpl/test/TemplateTest.php
new file mode 100644
index 000000000..0fc503419
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/TemplateTest.php
@@ -0,0 +1,128 @@
+set_paths("test/templates/");
+ $tpl->set_compile_location("test/compile/", false);
+ $tpl->add_default("key", "val");
+
+ $source = "test/templates/".$template;
+ $return = $tpl->compile($source, $destination);
+
+ $this->assertTrue((bool)$return);
+ $this->assertFileEquals($destination, $compiled);
+ }
+
+ public function compileProvider()
+ {
+ $tests = array();
+ $templates = glob("test/templates/*.tpl");
+ sort($templates);
+ foreach ($templates as $template) {
+ $tests[] = array(basename($template));
+ }
+ return $tests;
+ }
+
+ public function testRendering()
+ {
+ $tpl = new Monotek\MiniTPL\Template;
+
+ $tpl->set_paths("test/templates/");
+ $tpl->set_compile_location("test/compile/", false);
+ $tpl->add_default("key", "val");
+
+ $retval = array();
+ exec("rm -rf test/templates/test -rf", $retval);
+
+ $this->assertTrue($tpl->load("08_utf8_bom.tpl"));
+
+ touch("test/templates/test/compile/08_utf8_bom.tpl", filemtime("test/templates/08_utf8_bom.tpl") - 86400);
+
+ $this->assertTrue($tpl->load("08_utf8_bom.tpl"));
+
+ $items = array();
+ $items[] = array("id" => $i++);
+ $items[] = array("id" => $i++);
+ $items[] = array("id" => $i++);
+ $tpl->assign("items", $items);
+ $tpl->assign(array("foo"=>"bar", "d" => array("burger")), "foo");
+ $tpl->assign(".foo_foo", "baz");
+ $tpl->assign(".foo_d", array("steak", "beef", "pork", "chicken"));
+
+ $contents1 = $tpl->get();
+
+ ob_start();
+ $tpl->render();
+ $contents2 = ob_get_contents();
+ ob_end_clean();
+
+ $this->assertEquals($contents1, $contents2);
+
+ $this->assertFalse($tpl->_find_path("404.tpl"));
+
+ $tpl->set_compile_location("test/compile/", false);
+ $this->assertEquals("test/templates/test/compile/", $tpl->_compile_path("test/templates/"));
+ $tpl->set_compile_location("/test/compile/", true);
+ $this->assertEquals("/test/compile/test/templates/", $tpl->_compile_path("test/templates/"));
+
+ $retval = array();
+ exec("rm -rf test/templates/test -rf", $retval);
+ }
+
+ public function testException()
+ {
+ $this->setExpectedException("Exception");
+ $tpl = new Monotek\MiniTPL\Template;
+ $tpl->set_compile_location("test/compile/", false);
+ $tpl->set_paths("test/templates2/");
+ $tpl->load("fail_to_compile.tpl");
+ }
+
+ /**
+ * @dataProvider varsProvider
+ */
+ public function testVars($expression, $expected, $description)
+ {
+ global $tpl;
+ $tpl = new Monotek\MiniTPL\Compiler;
+
+ $result = $tpl->_split_exp($expression);
+ $this->assertEquals($expected, $result);
+ }
+
+ public function testFailure()
+ {
+ $this->setExpectedException("Exception");
+ $tpl = new Monotek\MiniTPL\Template;
+ $this->assertFalse($tpl->load("missing.tpl"));
+ $tpl->render();
+ }
+
+ public function varsProvider()
+ {
+ $vars = array();
+ $vars[] = array('news_section_news_list.tpl', 'news_section_news_list.tpl', "normal string");
+ $vars[] = array('$var', "\$_v['var']", "variable");
+ $vars[] = array('$var.netko', "\$_v['var']['netko']", "array index");
+ $vars[] = array('$var . "netko"', "\$_v['var'] . \"netko\"", "string concat");
+ $vars[] = array('$var1 . $var2', "\$_v['var1'] . \$_v['var2']", "variable concat");
+ $vars[] = array('$var1.$var2', "\$_v['var1'][\$_v['var2']]", "array var index");
+ $vars[] = array('$items.0', "\$_v['items']['0']", "array int index");
+ $vars[] = array('$tpl->get()', "\$tpl->get()", "global function");
+ $vars[] = array('$tplx->get()', "\$_v['tplx']->get()", "object function");
+ return $vars;
+ }
+}
diff --git a/crm/docs/vendor/monotek/minitpl/test/bootstrap.php b/crm/docs/vendor/monotek/minitpl/test/bootstrap.php
new file mode 100644
index 000000000..226a2f9f1
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/bootstrap.php
@@ -0,0 +1,7 @@
+vars;?>
+#### 1.1. Variables
+
+Using variables from templates is easy. Variables are enclosed
+in curly braces like so: `
+`. Since variables are parsed
+on the last stage, prefixing variables with the dollar sign is
+optional. So, `
+` is the same as `
+`.
+
+~~~~~~~~~~~~~
+
+ is the same as
+
+~~~~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/02_arrays.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/02_arrays.tpl
new file mode 100644
index 000000000..03cf15679
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/02_arrays.tpl
@@ -0,0 +1,18 @@
+vars;?>
+#### 1.2. Arrays
+
+There is a shorthand syntax for using arrays inside a template.
+The array index separator is a dot (`.`). Consecutive dots can be
+used for traversing into array depth like `
+`, or
+even variables starting with `$`, like `
+`.
+PHP syntax for arrays is also supported.
+
+~~~~~~~~~~~~
+
+ is the same as
+ is the same as
+ is the same as
+
+~~~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/03_modifiers.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/03_modifiers.tpl
new file mode 100644
index 000000000..041c46050
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/03_modifiers.tpl
@@ -0,0 +1,44 @@
+vars;?>
+#### 1.3. Modifiers
+
+Modifiers are PHP functions, which take one arbitrary value
+(usually, string), and return a string, which gets shown.
+Some functions in PHP can be used as modifiers
+(strtoupper, ucfirst, str_rot13, strrev, count, ...).
+
+~~~~~~~~~~~~~~~~~~~~~~~~
+/** Custom modifier example */
+
+function add_it_up($array)
+{
+ $size = 0;
+ foreach ($array as $value) {
+ $size += $value['size'];
+ }
+ return $size;
+}
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+To use the above function in a template, just do `
+`,
+which will loop trough all `$variable` items and add up the value of
+the size element and return the total sum of all sizes.
+
+~~~~~~~~~~~~~~
+
+
+~~~~~~~~~~~~~~
+
+The above code gets compiled to:
+
+~~~~~~~~~~~~~~
+vars;
+ echo htmlspecialchars($_v['variable'], ENT_QUOTES);
+ echo strtoupper($_v['variable']);
+ echo add_id_up($_v['variable']);
+?>
+~~~~~~~~~~~~~~
+
+A common use for modifiers is outputting data for javascript,
+using the php function `json_encode`.
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/04_objects.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/04_objects.tpl
new file mode 100644
index 000000000..025d4bd6b
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/04_objects.tpl
@@ -0,0 +1,56 @@
+vars;?>
+#### 1.4. Objects
+
+You can also call object methods as modifiers, from global or
+local objects. The compiler will determine at run-time, if
+you have a global object by the name, and modify the code
+accordingly.
+
+~~~~~~~~~~~
+get($_v['variable']);?>
+
+~~~~~~~~~~~
+
+If the global object doesn't exist, it assumes a local object.
+
+~~~~~~~~~~~
+vars;
+ echo $_v['memcache']->get($_v['variable']);
+?>
+~~~~~~~~~~~
+
+However, if a global object by the name $memcache exists at
+compile time:
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->get($_v['variable']);
+?>
+~~~~~~~~~~
+
+You can also use variables from objects, in the same way.
+
+~~~~~~~~~~~~
+variable;?>
+
+~~~~~~~~~~~~
+
+Compiles to one of theese:
+
+~~~~~~~~~~
+vars;
+ echo $_v['memcache']->variable;
+?>
+~~~~~~~~~~
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->variable;
+?>
+~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/05_constants.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/05_constants.tpl
new file mode 100644
index 000000000..e9af41345
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/05_constants.tpl
@@ -0,0 +1,15 @@
+vars;?>
+#### 1.5. Constants
+
+Value starting with `_` is assumed to be a constant. The template
+system will output the value of the constant if defined,
+or just the name of the constant. Item `
+` will be
+used as a constant, because of those rules, however `
+`
+wouldnt be, since it starts with the variable identifier `$`.
+
+~~~~~~~~~~~
+
+
+~~~~~~~~~~~
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/06_includes.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/06_includes.tpl
new file mode 100644
index 000000000..441fad26c
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/06_includes.tpl
@@ -0,0 +1,17 @@
+vars;?>
+#### 1.6. Includes
+
+#### 1.5. Constants
+
+Value starting with `_` is assumed to be a constant. The template
+system will output the value of the constant if defined,
+or just the name of the constant. Item `
+` will be
+used as a constant, because of those rules, however `
+`
+wouldnt be, since it starts with the variable identifier `$`.
+
+~~~~~~~~~~~
+
+
+~~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/07_eval.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/07_eval.tpl
new file mode 100644
index 000000000..70d10aa5f
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/07_eval.tpl
@@ -0,0 +1,12 @@
+vars; $_v['key']="nu";?>
+
+
+
+
+ $_v['item']){?>
+
+
+ 1){ echo $_v['i'];?>
+nd
+first
+
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/08_utf8_bom.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/08_utf8_bom.tpl
new file mode 100644
index 000000000..b3bbc6291
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/08_utf8_bom.tpl
@@ -0,0 +1,8 @@
+vars;?>
+This file contains utf8 BOM.
+
+It also uses the
+load
+ construct:
+
+push();$this->load("07_eval.tpl");$this->assign($_v);$this->render();$this->pop();?>
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/09_blocks_and_includes.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/09_blocks_and_includes.tpl
new file mode 100644
index 000000000..588753a98
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/09_blocks_and_includes.tpl
@@ -0,0 +1,18 @@
+vars;?>
+
+
+Functions bro, functions?
+
+
+This is a created function. This is the
+st/nd/rd/th time calling this method.
+
+
+
+This is like a copy-paste over your
+, anywhere you use this construct.
+
+This is like a copy-paste over your
+, anywhere you use this construct.
+
+
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/10_literal_blocks.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/10_literal_blocks.tpl
new file mode 100644
index 000000000..59b92b1e8
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/10_literal_blocks.tpl
@@ -0,0 +1,23 @@
+vars;?>
+The following block is literal (no template constructs work inside the tags)
+
+
+
+Or this:
+
+
+
+
+But this works:
+
+
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/11_expressions.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/11_expressions.tpl
new file mode 100644
index 000000000..42cbdf3a7
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/11_expressions.tpl
@@ -0,0 +1,15 @@
+vars; for($_v['i']=99; $_v['i']>=1; $_v['i']--){echo $_v['i'];?>
+ bottles of beer on the wall,
+ bottles of beer. Take one down and pass it around,
+ bottles of beer on the wall.
+ 10){?>
+
+ We have some beer left.
+ 3){?>
+
+ Our beer is going to run out.
+
+
+ Critical! Only
+ beer left.
+
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/12_global_objects.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/12_global_objects.tpl
new file mode 100644
index 000000000..fc8689978
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/12_global_objects.tpl
@@ -0,0 +1,9 @@
+vars; global $tpl;?>
+There is a distinct difference between
+calling `$tpl->get` or `$tplx->get`.
+
+When `$tpl` is a global variable, the template engine detects this.
+
+_paths;?>
+ _paths;?>
+;
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/compiled/13_foreach_array.tpl b/crm/docs/vendor/monotek/minitpl/test/compiled/13_foreach_array.tpl
new file mode 100644
index 000000000..c9b8a2412
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/compiled/13_foreach_array.tpl
@@ -0,0 +1,7 @@
+vars;?>
+We check if arrays are empty to suppress warnings/notices.
+
+
+HTTP
+HTTP
+HTTP
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/01_variable.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/01_variable.tpl
new file mode 100644
index 000000000..c8936b7b9
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/01_variable.tpl
@@ -0,0 +1,10 @@
+#### 1.1. Variables
+
+Using variables from templates is easy. Variables are enclosed
+in curly braces like so: `{variable}`. Since variables are parsed
+on the last stage, prefixing variables with the dollar sign is
+optional. So, `{$variable}` is the same as `{variable}`.
+
+~~~~~~~~~~~~~
+{variable} is the same as {$variable}
+~~~~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/02_arrays.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/02_arrays.tpl
new file mode 100644
index 000000000..e40328bb3
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/02_arrays.tpl
@@ -0,0 +1,13 @@
+#### 1.2. Arrays
+
+There is a shorthand syntax for using arrays inside a template.
+The array index separator is a dot (`.`). Consecutive dots can be
+used for traversing into array depth like `{$array.items.0}`, or
+even variables starting with `$`, like `{$sections.$news_section.title}`.
+PHP syntax for arrays is also supported.
+
+~~~~~~~~~~~~
+{$array.items} is the same as {$array['items']}
+{$array.items.0} is the same as {$array['items'][0]}
+{$array.$items.0} is the same as {$array[$items][0]}
+~~~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/03_modifiers.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/03_modifiers.tpl
new file mode 100644
index 000000000..1674b2bce
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/03_modifiers.tpl
@@ -0,0 +1,43 @@
+#### 1.3. Modifiers
+
+Modifiers are PHP functions, which take one arbitrary value
+(usually, string), and return a string, which gets shown.
+Some functions in PHP can be used as modifiers
+(strtoupper, ucfirst, str_rot13, strrev, count, ...).
+
+~~~~~~~~~~~~~~~~~~~~~~~~
+/** Custom modifier example */
+
+function add_it_up($array)
+{
+ $size = 0;
+ foreach ($array as $value) {
+ $size += $value['size'];
+ }
+ return $size;
+}
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+To use the above function in a template, just do `{$variable|add_it_up}`,
+which will loop trough all `$variable` items and add up the value of
+the size element and return the total sum of all sizes.
+
+~~~~~~~~~~~~~~
+{variable|escape}
+{variable|toupper}
+{variable|add_id_up}
+~~~~~~~~~~~~~~
+
+The above code gets compiled to:
+
+~~~~~~~~~~~~~~
+vars;
+ echo htmlspecialchars($_v['variable'], ENT_QUOTES);
+ echo strtoupper($_v['variable']);
+ echo add_id_up($_v['variable']);
+?>
+~~~~~~~~~~~~~~
+
+A common use for modifiers is outputting data for javascript,
+using the php function `json_encode`.
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/04_objects.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/04_objects.tpl
new file mode 100644
index 000000000..859148fe0
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/04_objects.tpl
@@ -0,0 +1,53 @@
+#### 1.4. Objects
+
+You can also call object methods as modifiers, from global or
+local objects. The compiler will determine at run-time, if
+you have a global object by the name, and modify the code
+accordingly.
+
+~~~~~~~~~~~
+{$variable|$memcache->get}
+~~~~~~~~~~~
+
+If the global object doesn't exist, it assumes a local object.
+
+~~~~~~~~~~~
+vars;
+ echo $_v['memcache']->get($_v['variable']);
+?>
+~~~~~~~~~~~
+
+However, if a global object by the name $memcache exists at
+compile time:
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->get($_v['variable']);
+?>
+~~~~~~~~~~
+
+You can also use variables from objects, in the same way.
+
+~~~~~~~~~~~~
+{$memcache->variable}
+~~~~~~~~~~~~
+
+Compiles to one of theese:
+
+~~~~~~~~~~
+vars;
+ echo $_v['memcache']->variable;
+?>
+~~~~~~~~~~
+
+~~~~~~~~~~
+vars;
+ global $memcache;
+ echo $memcache->variable;
+?>
+~~~~~~~~~~
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/05_constants.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/05_constants.tpl
new file mode 100644
index 000000000..54fc8efcd
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/05_constants.tpl
@@ -0,0 +1,13 @@
+#### 1.5. Constants
+
+Value starting with `_` is assumed to be a constant. The template
+system will output the value of the constant if defined,
+or just the name of the constant. Item `{_MY_CONSTANT}` will be
+used as a constant, because of those rules, however `{$_my_variable}`
+wouldnt be, since it starts with the variable identifier `$`.
+
+~~~~~~~~~~~
+{_MY_CONSTANT}
+{_this_is_also_a_constant}
+{$_my_variable}
+~~~~~~~~~~~
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/06_includes.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/06_includes.tpl
new file mode 100644
index 000000000..d7d4a4455
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/06_includes.tpl
@@ -0,0 +1,3 @@
+#### 1.6. Includes
+
+{include 05_constants.tpl}
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/07_eval.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/07_eval.tpl
new file mode 100644
index 000000000..33f18dcdd
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/07_eval.tpl
@@ -0,0 +1,12 @@
+{eval $key="nu"}
+
+{inline item}
+{if $i>1}{i}nd{else}first{/if}
+{/inline}
+
+{eval $i=1}
+{foreach $items as $index => $item}
+ {eval $id = $key . $i}
+ {inline:item}
+ {eval $i++}
+{/foreach}
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/08_utf8_bom.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/08_utf8_bom.tpl
new file mode 100644
index 000000000..5e3d03c5f
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/08_utf8_bom.tpl
@@ -0,0 +1,5 @@
+This file contains utf8 BOM.
+
+It also uses the {ldelim}load{rdelim} construct:
+
+{load 07_eval.tpl}
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/09_blocks_and_includes.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/09_blocks_and_includes.tpl
new file mode 100644
index 000000000..695cd6dbb
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/09_blocks_and_includes.tpl
@@ -0,0 +1,19 @@
+{inline snippet1}
+This is like a copy-paste over your {eval echo __FILE__}, anywhere you use this construct.
+{/inline}
+
+Functions bro, functions?
+
+{eval $i=1}
+{block function_call}
+This is a created function. This is the {i++}st/nd/rd/th time calling this method.
+{if $i <= 5}
+{block:function_call}
+{/if}
+{/block}
+
+{inline:snippet1}
+
+{inline:snippet1}
+
+{block:function_call}
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/10_literal_blocks.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/10_literal_blocks.tpl
new file mode 100644
index 000000000..afea61e85
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/10_literal_blocks.tpl
@@ -0,0 +1,20 @@
+The following block is literal (no template constructs work inside the tags)
+
+
+
+Or this:
+
+
+
+
+But this works:
+
+
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/11_expressions.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/11_expressions.tpl
new file mode 100644
index 000000000..57a46c46b
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/11_expressions.tpl
@@ -0,0 +1,11 @@
+{for $i=99; $i>=1; $i--}
+{i} bottles of beer on the wall, {i} bottles of beer. Take one down and pass it around, {eval echo $i-1} bottles of beer on the wall.
+{/for}
+
+{if $i > 10}
+ We have some beer left.
+{elseif $i > 3}
+ Our beer is going to run out.
+{else}
+ Critical! Only {i} beer left.
+{/if}
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/12_global_objects.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/12_global_objects.tpl
new file mode 100644
index 000000000..5baf961b2
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/12_global_objects.tpl
@@ -0,0 +1,6 @@
+There is a distinct difference between
+calling `$tpl->get` or `$tplx->get`.
+
+When `$tpl` is a global variable, the template engine detects this.
+
+{$tpl->_paths} {$tplx->_paths};
\ No newline at end of file
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates/13_foreach_array.tpl b/crm/docs/vendor/monotek/minitpl/test/templates/13_foreach_array.tpl
new file mode 100644
index 000000000..0859bae21
--- /dev/null
+++ b/crm/docs/vendor/monotek/minitpl/test/templates/13_foreach_array.tpl
@@ -0,0 +1,13 @@
+We check if arrays are empty to suppress warnings/notices.
+
+{foreach array("GET", "POST") as $method}
+HTTP {method}
+{/foreach}
+
+{foreach (array("GET", "POST") as $method)}
+HTTP {method}
+{/foreach}
+
+{foreach $methods as $method}
+HTTP {method}
+{/foreach}
diff --git a/crm/docs/vendor/monotek/minitpl/test/templates2/fail_to_compile.tpl b/crm/docs/vendor/monotek/minitpl/test/templates2/fail_to_compile.tpl
new file mode 100644
index 000000000..e69de29bb
diff --git a/crm/routes.go b/crm/routes.go
new file mode 100644
index 000000000..22fdfdca6
--- /dev/null
+++ b/crm/routes.go
@@ -0,0 +1,13 @@
+package crm
+
+import (
+ "github.com/go-chi/chi"
+)
+
+func MountRoutes(r chi.Router) {
+ types := TypesHandlers{}.new()
+ r.Route("/types", func(r chi.Router) {
+ r.Get("/list", types.List)
+ r.Get("/type/{id}", types.Type)
+ })
+}
diff --git a/crm/templates/http_.tpl b/crm/templates/http_.tpl
new file mode 100644
index 000000000..abc4b9ec1
--- /dev/null
+++ b/crm/templates/http_.tpl
@@ -0,0 +1,11 @@
+package {package}
+
+import (
+ "github.com/pkg/errors"
+)
+
+{foreach $calls as $call}
+func ({self} *{name}) {call.name|ucfirst}(r *{name|lcfirst}{call.name|ucfirst}Request) (interface{}, error) {
+ return nil, errors.New("Not implemented: {name}.{call.name}")
+}
+{/foreach}
diff --git a/crm/templates/http_handlers.tpl b/crm/templates/http_handlers.tpl
new file mode 100644
index 000000000..3eab30652
--- /dev/null
+++ b/crm/templates/http_handlers.tpl
@@ -0,0 +1,14 @@
+package {package}
+
+import (
+ "net/http"
+
+ "github.com/titpetric/factory/resputil"
+)
+
+{foreach $calls as $call}
+func ({self}h *{name}Handlers) {call.name|ucfirst}(w http.ResponseWriter, r *http.Request) {
+ params := {name|lcfirst}{call.name|ucfirst}Request{}.new()
+ resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return {self}h.{name}.{call.name|ucfirst}(params) })
+}
+{/foreach}
diff --git a/crm/templates/http_interfaces.tpl b/crm/templates/http_interfaces.tpl
new file mode 100644
index 000000000..8f2e2f213
--- /dev/null
+++ b/crm/templates/http_interfaces.tpl
@@ -0,0 +1,34 @@
+package {package}
+
+import (
+ "net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type {name}Handlers struct {
+ *{name}
+}
+
+func ({name}Handlers) new() *{name}Handlers {
+ return &{name}Handlers{
+ {name}{}.new(),
+ }
+}
+
+// Internal API interface
+type {name}API interface {
+{foreach $calls as $call}
+ {call.name|ucfirst}(*{name|lcfirst}{call.name|ucfirst}Request) (interface{}, error)
+{/foreach}
+}
+
+// HTTP API interface
+type {name}HandlersAPI interface {
+{foreach $calls as $call}
+ {call.name|ucfirst}(http.ResponseWriter, *http.Request)
+{/foreach}
+}
+
+// Compile time check to see if we implement the interfaces
+var _ {name}HandlersAPI = &{name}Handlers{}
+var _ {name}API = &{name}{}
\ No newline at end of file
diff --git a/crm/templates/http_request.tpl b/crm/templates/http_request.tpl
new file mode 100644
index 000000000..92215dd16
--- /dev/null
+++ b/crm/templates/http_request.tpl
@@ -0,0 +1,43 @@
+package {package}
+
+import (
+ "net/http"
+)
+
+{foreach $calls as $call}
+// {name} {call.name} request parameters
+type {name|lcfirst}{call.name|ucfirst}Request struct {
+{foreach $call.parameters as $params}
+{foreach $params as $method => $param}
+ {param.name} {param.type}{newline}
+{/foreach}
+{/foreach}
+}
+
+func ({name|lcfirst}{call.name|ucfirst}Request) new() *{name|lcfirst}{call.name|ucfirst}Request {
+ return &{name|lcfirst}{call.name|ucfirst}Request{}
+}
+
+func ({self} *{name|lcfirst}{call.name|ucfirst}Request) Fill(r *http.Request) error {
+ get := map[string]string{}
+ post := map[string]string{}
+ urlQuery := r.URL.Query()
+ for name, param := range urlQuery {
+ get[name] = string(param[0])
+ }
+ postVars := r.Form
+ for name, param := range postVars {
+ post[name] = string(param[0])
+ }
+{foreach $call.parameters as $method => $params}
+{foreach $params as $param}
+{if substr($param.type, 0, 2) !== '[]'}
+ {self}.{param.name} = {if $param.type !== "string"}{$parsers[$param.type]}({method|strtolower}["{param.name}"]){else}{method|strtolower}["{param.name}"]{/if}{newline}
+{/if}
+{/foreach}
+{/foreach}
+ return nil
+}
+
+var _ RequestFiller = {name|lcfirst}{call.name|ucfirst}Request{}.new()
+{/foreach}
diff --git a/crm/templates/http_routes.tpl b/crm/templates/http_routes.tpl
new file mode 100644
index 000000000..61736bc86
--- /dev/null
+++ b/crm/templates/http_routes.tpl
@@ -0,0 +1,18 @@
+package {package}
+
+import (
+ "github.com/go-chi/chi"
+)
+
+func MountRoutes(r chi.Router) {
+{foreach $apis as $api}
+ {api.interface|strtolower} := {api.interface|ucfirst}Handlers{}.new()
+{/foreach}
+{foreach $apis as $api}
+ r.Route("{api.path}", func(r chi.Router) {
+{foreach $api.apis as $call}
+ r.{eval echo ucfirst(strtolower($call.method))}("{call.path}", {api.interface|strtolower}.{call.name|ucfirst})
+{/foreach}
+ })
+{/foreach}
+}
\ No newline at end of file
diff --git a/crm/templates/http_structs.tpl b/crm/templates/http_structs.tpl
new file mode 100644
index 000000000..a39d3b73d
--- /dev/null
+++ b/crm/templates/http_structs.tpl
@@ -0,0 +1,30 @@
+package {package}
+
+{if strpos($name, "Literal") !== false}
+ {foreach $fields as $field}
+ {field}{newline}
+ {/foreach}
+{else}
+ // {api.title}
+ type {name} struct {
+{foreach $fields as $field}
+ {field.name} {field.type}{if $field.tag} `{$field.tag}`{/if}{newline}
+{/foreach}
+ }
+
+func ({name}) new() *{name} {
+ return &{name}{}
+}
+
+{/if}
+
+{foreach $fields as $field}
+func ({self} *{name}) Get{field.name}() {field.type} {
+ return {self}.{field.name}
+}
+
+func ({self} *{name}) Set{field.name}(value {field.type}) *{name} {
+ {self}.{field.name} = value
+ return {self}
+}
+{/foreach}
diff --git a/crm/types.go b/crm/types.go
new file mode 100644
index 000000000..852aea3ae
--- /dev/null
+++ b/crm/types.go
@@ -0,0 +1,12 @@
+package crm
+
+import (
+ "github.com/pkg/errors"
+)
+
+func (t *Types) List(r *typesListRequest) (interface{}, error) {
+ return nil, errors.New("Not implemented: Types.list")
+}
+func (t *Types) Type(r *typesTypeRequest) (interface{}, error) {
+ return nil, errors.New("Not implemented: Types.type")
+}
diff --git a/crm/types.handlers.go b/crm/types.handlers.go
new file mode 100644
index 000000000..989eccc7c
--- /dev/null
+++ b/crm/types.handlers.go
@@ -0,0 +1,16 @@
+package crm
+
+import (
+ "net/http"
+
+ "github.com/titpetric/factory/resputil"
+)
+
+func (th *TypesHandlers) List(w http.ResponseWriter, r *http.Request) {
+ params := typesListRequest{}.new()
+ resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Types.List(params) })
+}
+func (th *TypesHandlers) Type(w http.ResponseWriter, r *http.Request) {
+ params := typesTypeRequest{}.new()
+ resputil.JSON(w, params.Fill(r), func() (interface{}, error) { return th.Types.Type(params) })
+}
diff --git a/crm/types.interfaces.go b/crm/types.interfaces.go
new file mode 100644
index 000000000..159a23905
--- /dev/null
+++ b/crm/types.interfaces.go
@@ -0,0 +1,32 @@
+package crm
+
+import (
+ "net/http"
+)
+
+// HTTP handlers are a superset of internal APIs
+type TypesHandlers struct {
+ *Types
+}
+
+func (TypesHandlers) new() *TypesHandlers {
+ return &TypesHandlers{
+ Types{}.new(),
+ }
+}
+
+// Internal API interface
+type TypesAPI interface {
+ List(*typesListRequest) (interface{}, error)
+ Type(*typesTypeRequest) (interface{}, error)
+}
+
+// HTTP API interface
+type TypesHandlersAPI interface {
+ List(http.ResponseWriter, *http.Request)
+ Type(http.ResponseWriter, *http.Request)
+}
+
+// Compile time check to see if we implement the interfaces
+var _ TypesHandlersAPI = &TypesHandlers{}
+var _ TypesAPI = &Types{}
diff --git a/crm/types.request.go b/crm/types.request.go
new file mode 100644
index 000000000..2bd77bf19
--- /dev/null
+++ b/crm/types.request.go
@@ -0,0 +1,56 @@
+package crm
+
+import (
+ "net/http"
+)
+
+// Types list request parameters
+type typesListRequest struct {
+}
+
+func (typesListRequest) new() *typesListRequest {
+ return &typesListRequest{}
+}
+
+func (t *typesListRequest) Fill(r *http.Request) error {
+ get := map[string]string{}
+ post := map[string]string{}
+ urlQuery := r.URL.Query()
+ for name, param := range urlQuery {
+ get[name] = string(param[0])
+ }
+ postVars := r.Form
+ for name, param := range postVars {
+ post[name] = string(param[0])
+ }
+ return nil
+}
+
+var _ RequestFiller = typesListRequest{}.new()
+
+// Types type request parameters
+type typesTypeRequest struct {
+ id string
+}
+
+func (typesTypeRequest) new() *typesTypeRequest {
+ return &typesTypeRequest{}
+}
+
+func (t *typesTypeRequest) Fill(r *http.Request) error {
+ get := map[string]string{}
+ post := map[string]string{}
+ urlQuery := r.URL.Query()
+ for name, param := range urlQuery {
+ get[name] = string(param[0])
+ }
+ postVars := r.Form
+ for name, param := range postVars {
+ post[name] = string(param[0])
+ }
+
+ t.id = path["id"]
+ return nil
+}
+
+var _ RequestFiller = typesTypeRequest{}.new()
diff --git a/crm/types.structs.go b/crm/types.structs.go
new file mode 100644
index 000000000..89601f8f9
--- /dev/null
+++ b/crm/types.structs.go
@@ -0,0 +1,19 @@
+package crm
+
+// Types
+type Types struct {
+ ID string
+}
+
+func (Types) new() *Types {
+ return &Types{}
+}
+
+func (t *Types) GetID() string {
+ return t.ID
+}
+
+func (t *Types) SetID(value string) *Types {
+ t.ID = value
+ return t
+}