/usr/local/miolo2/classes/ui/controls/mform.class

Go to the documentation of this file.

<?
define ('FORM_SUBMIT_BTN_NAME', 'submit_button');

class MForm extends MControl
{
    var $title;

    var $action;

    var $method;

    var $buttons;

    var $fields=array();

    var $return;

    var $reset;

    var $styles;

    var $help;

    var $footer;

    var $width;

    var $showHints = true;

    var $enctype;

    var $validations;

    var $defaultButton;

    var $errors;

    var $infos;

    var $box;

    static $fieldNum = 0;
    var $layout;

    var $cssForm = false;
    var $cssButtons;
    var $zebra = false;
    var $labelWidth = NULL;

    var $bgColor = NULL;
    var $align = NULL;
    
    function __construct($title='',$action='',$close='',$icon='', $help='')
    {
        parent::__construct();
        $this->AddStyleFile('m_forms.css'); 
        $this->name          = $this->page->name;
        $this->box           = new MBox($title,$close,$icon,$help);
        $this->title         = $title;
        $this->action        = $action;
        $this->method        = 'post';
        $this->return        = false;
        $this->width         = '95%';
        $this->defaultButton = true;
        $this->fields        = array();
        $this->validations   = array();
        $this->CreateFields();
        if ($this->IsSubmitted())
        { 
            $this->GetFormFields(); // set the fields array with form post/get values
        }
        $this->onLoad();
    }

    
    function __set($name, $value)
    {
        $this->AddControl($value);
        $this->fields[$name] = $value;
    }

    
    function __get($name)
    {
        return $this->fields[$name];
    }

    
    function OnLoad()
    {
    }

    
    function CreateFields()
    {
    }

    
    function AddValidator($validator)
    {
        if ( ! $validator->label )
        {
            $field = $this->{$validator->field};
            $validator->label = ($validator->label == '') ? $field->label : $validator->label;
        }

        $name = '_validator_' . $this->name . '_' . $validator->id . '_' . $validator->field;
        $validator->name     = $name;
        $validator->form     = $this->name;
        $validator->max      = $validator->max ? $validator->max : 0;
        $this->validations[] = $validator;
        return $name;
    }

    
    function SetValidators($validators)
    {
       if (is_array($validators))
       {
          foreach($validators as $v)
          {
             $this->AddValidator($v);
          }
       }
       elseif (is_subclass_of( $validators, 'validator'))
       {
             $this->AddValidator($validators);
       }
    }

    
    function IsSubmitted()
    {   
        $isSubmitted = $this->defaultButton && MForm::getFormValue(FORM_SUBMIT_BTN_NAME);
        if (isset($this->buttons))
        {
            foreach($this->buttons as $b)
            {
                $isSubmitted = $isSubmitted || MForm::GetFormValue($b->name);
            }
        }
        return $isSubmitted;
    }
    
    
    function GetTitle()
    {
        return $this->title;
    }
    
    
    function SetTitle($title)
    {
        $this->title = $title;
        $this->caption = $title;
        $this->box->SetCaption($title);
    }

    function SetClose($action)
    {
        if ($this->box->boxTitle != NULL)
        {
           $this->box->boxTitle->SetClose($action);
        }
    }
    
        
    public function SetIcon($icon)
    {
        if ($this->box->boxTitle != NULL)
        {
            $this->box->boxTitle->SetIcon($icon);
        }
    }

    function SetAlternate($color0, $color1)
    {
        $this->zebra = array($color0, $color1);
    }

    
    function GetFooter()
    {
        return $this->footer;
    }

    function SetFooter($footer)
    {
        $this->footer = $footer;
    }

    
    function GetFormFields()
    {   
       $this->_GetFormFieldValue($this->fields);
    }

    
    function _GetFormFieldValue($field)
    {   
        if ( is_array($field) )
        {
            foreach($field as $f)
            {
                $this->_GetFormFieldValue($f);
            }
        }
        else
        {
            if ($field instanceof MFormControl)
            {
                if ( $field->name )
                {
                    $defvalue = $field->GetValue();
                    $value = $this->page->Request($field->name);
                    if ( ($field instanceof MCheckBox) || ($field instanceof MRadioButton) )
                    {
                       $field->checked = (isset($value) ? ($value == $field->value) : $field->checked);
                    }
                    else
                    {  
                       $field->SetValue(isset($value) ? $value : $defvalue);
                    }
                }
            }
        }
    }
    
    
    function GetFormValue($name,$value=NULL)
    { 
        $result = '';
        if ( ($name != '') && ((strpos($name,'[')) === false))
        {
           $result = MIOLO::_REQUEST($name, 'ALL');
        }
        if (! isset($result))
        {
            $result = $value;
        }
        return $result;
    }

        
    function SetFormValue($name,$value)
    {   
        $value = MForm::EscapeValue($value);
        if (isset($this->$name))
        {
            $this->$name->SetValue($value);
        }
        $_REQUEST[$name] = $value;
    }
    
    
    private function /* PRIVATE */ EscapeValue($value)
    {
        if ( is_array($value) )
        {
            for ( $i=0, $n = count($value); $i < $n; $i++ )
            {
                $value[$i] = $this->EscapeValue($value[$i]);
            }
        }
        else
        {
            $value = str_replace('\"','&quot;',$value);
            $value = str_replace('"','&quot;',$value);
        }
        return $value;
    }

    
    function OnSubmit($jscode)
    {
        $this->page->OnSubmit($jscode);
    }

    
    function AddJsCode($jscode)
    {
        $this->page->AddJsCode($jscode);
    }
    
    
    function SetAction($action)
    {
        $this->action = $action;
    }
    
    
    function setHelp($help, $module=null, $action=null)
    {
        if ($this->box->boxTitle != NULL)
        {
            if ( $module != null &&
                 $action != null )
            {
                $class = $help;
                $content = "MIOLO_getHelp( '$class', '$module', '$action');";
            }
            else
            {
                $content = $help;
            }

            $this->box->boxTitle->setHelp($content);
        }
        else
        {
            $this->help = $help;
        }
    }

    private function /*PRIVATE*/ GetFields()
    {
        return $this->fields;
    }
    
    
    function SetFields(&$fields)
    {
//        $this->fields = $fields; // inicializa a lista de campos
//        $this->_RegisterField($this->fields);
        $this->fields = array();
        if (!is_array($fields)) $fields = array($fields);
        $this->layout = $fields;
        $this->_RegisterField($fields);
    }
    
    
    private function /*PRIVATE*/ _RegisterField($field)
    {   
        if ( is_array($field) )
        {
            for ( $i=0, $n = count($field); $i < $n; $i++ )
            {
                $this->_RegisterField($field[$i]);
            }
        }
        elseif ($field instanceof MDiv)
        {
            $namefield = $field->id;
            $this->$namefield = $field;

            $field = $field->getInner();

            if(is_array($field) || is_object($field) )
            {
                return $this->_registerField($field);
            }
        }
        else
        {
            $field->form = $this;
            $className = $field->className;
            if ($field instanceof MFileField)
            {
                $this->enctype='multipart/form-data';
                $this->page->setEnctype($this->enctype);
            }
            if ($field->name == $field->id)
            {
                $namefield = $field->name;
            }
            else
            {
                $namefield = $field->id;
            }
            $this->manager->Assert(!isset($this->$namefield), "Err: property [$namefield] already in use in the form [$this->title]! Choose another name to [$namefield].");
            $this->$namefield = $field;


            if ($field instanceof MFormControl)
            {
                $value = $this->page->Request($field->name);
                if ( ($field instanceof MCheckBox) || ($field instanceof MRadioButton) )
                {
                    // set checked flag of checkbox or radiobutton if the value matches
                    $field->checked = $this->page->isPostBack() ? (isset($value) ? ($value == $field->value) : $field->checked) : $field->checked;
                }
                elseif ( ($field instanceof MIndexedControl) )
                {
                    $this->AddFields($field->controls);
                    $field->SetValue($value);
                }
                elseif (($field instanceof MInputGrid))
                {
                    $field->SetValue($value);
                }
                elseif ( $field->value == '' )
                {
                    $field->SetValue($value);
                    if ($field instanceof MContainer)
                    {
                        $this->_RegisterField($field->GetControls());
                    }
                    else
                    {
                        $field->SetValue($this->EscapeValue($field->value));
                    }
                }
            }
         }
    }
    
    
    function AddField($field,$hint=false)
    {
        if ( $hint )
        {
            $field->SetHint($hint);
        }
        $this->_RegisterField($field);
        $this->layout[] = $field;
//        $this->fields[] = $field;
    }

    
    function AddFields($fields)
    {
        if (is_array($fields))
        {
           foreach($fields as $f)
              $this->AddField($f);
        }
    }
    
    
    function AddButton($btn)
    {
        if (strtoupper($btn->action == 'REPORT'))
        {
           $this->page->hasReport = true;
        }
        $this->buttons[] = $this->{$btn->GetId()} = $btn;
    }

    
    function SetButtons($btn)
    {
        if ( is_array($btn) )
        {
            for ( $i=0, $n = count($btn); $i < $n; $i++ )
            {
                $this->SetButtons($btn[$i]);
            }
        }
        else
        {
           $this->AddButton($btn);
        }
    }

    public function setButtonLabel( $index, $label )
    {
        $this->buttons[$index]->label = $label;
    }

    public function showReturn( $state )
    {
        $this->setShowReturnButton( $state );
    }

    public function setShowReturnButton( $state )
    {
        $this->return = $state;
    }

    public function setShowPostButton( $state )
    {
        $this->defaultButton = $state;
    }

    public function showReset( $state )
    {
        $this->setShowResetButton( $state );
    }

    public function setShowResetButton( $state )
    {
        $this->reset = $state;
    }

    public function getShowHints()
    {
        return $this->showHints;
    }

    public function setShowHints( $state )
    {
        $this->showHints = $state;
    }

    public function showHints( $state )
    {
        $this->setShowHints ( $state );
    }


    function GetFieldList()
    {
        return $this->_GetFieldList($this->fields);
    }

    private function _GetFieldList($allfields)
    {
        $fields = array();
        foreach ($allfields as $f )
        {
            if ( is_array($f) )
            {
                foreach ( $f as $a )
                {
                    if (is_a($a,'BaseLabel')) continue;
                    $fields[] = $a;
                }
            }
            else
            {
                if ( is_a($f,'BaseLabel') || is_null($f->value) ) continue;
                $fields[] = $f;
            }
        }
        return $fields;
    }

    function ClearFields()
    {
        $this->fields = NULL;
        $this->layout = NULL;
    }

    function ClearButtons()
    {
        $this->buttons = NULL;
    }

    function validateAll( $assert=true )
    {
        foreach ( $this->getFieldList() as $f )
        {
            if ( $f->name )
            {
                $required[] = $f->name;
            }
        }
        return $this->validate($required, $assert);
    }

    function validateRequiredFields( $assert=true )
    {
        foreach ( $this->getFieldList() as $f )
        {
            if ( $f->required )
            {
                $required[] = $f->name;
            }
        }
        return $this->Validate( $required, $assert );
    }

    function validate( $required, $assert=true )
    {   global $MIOLO,$HTTP_POST_VARS;

        $this->errors = array();
        // collect fields by label
        foreach ( $this->getFieldList() as $f )
        {
            $fields[$f->name] = $f->name;
        }
        foreach ( $required as $r )
        {
            $name  = $r;
            $label = $fields[$name];
            $MIOLO->Assert( $label,
                            "ERROR: Required field [<b><font color=red>$name</font></b>] is not defined in form!" );

            $value = $this->getFormValue( $name );
            if ( $value === '' || (is_null($value)) )
            {
                $this->errors[] = "<b>$label</b> " . _M("was not informed!");
            }
        }
        if ( $assert && count($this->errors) )
        {
            $theme =& $MIOLO->getTheme();
            $theme->setContent( $this );
            $theme->generate();
        }
        return count( $this->errors ) == 0;
    }

    function Error( $err )
    {   global $MIOLO;

        $MIOLO->logMessage('[DEPRECATED] Call method Form::Error() is deprecated -- use Form::AddError() instead!');
        $this->addError( $err );
    }

    function AddError($err)
    {
        if ( $err )
        {
            if ( is_array($err) )
            {
                if ( $this->errors )
                {
                    $this->errors = array_merge($this->errors,$err);
                }
                
                else
                {
                    $this->errors = $err;
                }
            }
            else
            {
                $this->errors[] = $err;
            }
        }
    }

    
    function HasErrors()
    {
        return count($this->errors);
    }
    
    
    function AddInfo($info)
    {
        if ( $info )
        {
            if ( is_array($info) )
            {
                if ( $this->infos )
                {
                    $this->infos = array_merge($this->infos,$info);
                }
                
                else
                {
                    $this->infos = $info;
                }
            }
            else
            {
                $this->infos[] = $info;
            }
        }
    }

    
    function HasInfos()
    {
        return count($this->infos);
    }
    
    
    function CollectInput($data)
    {           
        foreach ( $this->GetFieldList() as $f )
        {
            $field = $f->name;
            if ( $field != '' )
            {
                  $value        = $this->GetFormValue($field); 
                  $data->$field = $value;
            }
        }
        return $data;
    }

    function getData()
    {
        return $this->collectInput( new FormData() );
    }

    function SetData($data)
    {
        $this->_SetData($data);
    }
    
    
    private function _SetData($data)
    {  
        foreach( $this->fields as $i=>$field) // ( $i=0, $n = count($this->fields); $i < $n; $i++ )
        {
            $name = $this->fields[$i]->name;
            if ( $name )
            {
                if ( ($this->fields[$i] instanceof MRadioButton) || 
                     ($this->fields[$i] instanceof MCheckBox) )
                {
                    $this->fields[$i]->checked = ( $data->$name == $this->fields[$i]->value );
                }
                else
                { 
                    $value = $data->$name;

                    if ( method_exists($this->fields[$i], 'setValue') )
                    {
                        $this->fields[$i]->setValue($value);
                    }

                    $_POST[$name] = $value;
                }
            }
        }
    }
    
    
    function GetFieldValue($name,$value=false)
    {   
        $field = $this->fields[$name];
        return ($field ? $field->GetValue() : NULL);
    }
    
    
    function SetFieldValue($name, $value)
    {   
        $field = $this->fields[$name];

        if( method_exists($field, 'setValue') )
        {
            $field->setValue( $value );
        }
    }
    
    
    function SetFieldValidator($name,$value)
    {   
        for ( $i=0, $n = count($field); $i < $n; $i++ )
        {
            if ( $name == $this->fields[$i]->name )
            {
                $this->fields[$i]->validator = $value;
                break;
            }
        }
    }
    
    
    function & GetField($name)
    {
        return $this->fields[$name];
    }
    
    
    function & GetButton($name)
    {
        for ( $i=0, $n = count($this->buttons); $i < $n; $i++ )
        {
            if ( $name == $this->buttons[$i]->name )
            {
                return $this->buttons[$i];
            }
        }
    }
    
    
    function & GetPage()
    {
        return $this->page;
    }
    
    
    function SetPage(&$page)
    {
        $this->page = &$page;
    }
    
    
    function SetFieldAttr($name,$attr,$value)
    {   
//      $field = $this->$name;
//      $field->$attr = $value;
        $this->fields[$name]->$attr = $value; 
    }
    
    
    function GetFieldAttr($name,$attr, $index=NULL)
    {   
        $field = $this->fields[$name];
        if ( is_array($field->$attr) )
        {
            $a = $field->$attr;
            $value = $a[$index];
        }
        else
        {
          $value = $field->$attr;
        }
        return $value;
    }
    
    
    function SetButtonAttr($name,$attr,$value)
    {   
        $button = &$this->GetButton($name);
        $button->$attr = $value;
    }
    
    
    function SetFieldCSS($name,$top,$left,$width=NULL, $position='absolute')
    {   
        $field = $this->$name;
//        $top = $this->box->top + $top;
//        $left = $this->box->left + $left;
        if ($width) 
        {
            $field->width = "{$width}px";
        }
        $field->top      = "{$top}px";
        $field->left     = "{$left}px";
        if ($position) $field->position = $position;
        $field->formMode = 2;
    }

    
    
    function SetFormCSS($height=0, $width=0, $top=0, $left=0, $buttons=0, $position='absolute')
    {
        if ($height)   $this->box->AddStyle('height',"{$height}px");
        if ($width)    $this->box->AddStyle('width',"{$width}px");
        if ($top)      $this->box->AddStyle('top',"{$top}px");
        if ($left)     $this->box->AddStyle('left',"{$left}px");
        if ($position) $this->box->AddStyle('position',$position);
        $this->cssButtons = "{$buttons}px";
        $this->cssForm    = true;
    }
    
    function SetBackgroundColor($bgcolor)
    {
        $this->bgColor = $bgcolor; 
    }

    function SetAlign($value)
    {
        $this->align = $value;
    }
    
    function SetWidth($width=NULL)
    { 
        if ($width) $this->box->AddStyle('width',"{$width}");
    }
    
    function SetHeight($height=NULL)
    { 
        if ($height) $this->box->AddStyle('height',"{$height}");
    }
   function SetLabelWidth($width)
   {
       $this->labelWidth = $width; 
   } 
   
   function GenerateErrors()
   {    
        $prompt = Prompt::Error($this->errors,'NONE','Erros');
        return $prompt;
   }
   
   
   function GenerateInfos()
   {    
        $prompt = Prompt::Information($this->infos,'NONE','Informações');
        return $prompt;
   }
   
    
   function GenerateBody()
   {  
        global $MIOLO;

        $row = 0;
        $t = array();
        // optionally generate errors
        if ( $this->HasErrors() )
        {
            $t[] = $this->GenerateErrors();
        }
        if ( $this->HasInfos() )
        {
            $t[] = $this->GenerateInfos();
        }
        $hidden = null;
        $t = array_merge($t, $this->GenerateLayoutFields($hidden));
        
        if( method_exists($this->page,'getLayout') )
        {
            $layout = $this->page->theme->GetLayout();
        }
        else
        {
            $layout = $this->manager->theme->GetLayout();
        }
        
        if ( $layout != 'print')
        {
           $buttons = $this->GenerateButtons();
           if ($buttons)
           {
              $t = array_merge($t,array($buttons));
           }
        }
        if ( $hidden )
        {
           $t = array_merge($t,$this->GenerateHiddenFields($hidden));
        }
        $t = array_merge($t,$this->GenerateScript());
//        $t[] = new MDiv('','&nbsp;','m-spacer');
        $body = new MDiv('',$t);
        return $body;
   }
   
    
   function GenerateFooter()
   {
   }
   
    
   function GenerateLayoutFields(&$hidden)
   {  
       $line = 0;  
       $zebra = is_array($this->zebra);
       $t = array();
       if (is_array($this->layout))
       {
           foreach ( $this->layout as $f )
           {
               if ( $f->validator != NULL)
               {
                    if ($f->validator instanceof mValidator)
                    {
                        $this->AddValidator($f->validator);
                    }
               }
               elseif ( $f instanceof mformcontrol )
               {
                    $f->validator = $this->getFieldValidator($f->name);
               }
               $row = $t[] = $this->GenerateLayoutField($f, $hidden);
               if ($zebra)
               {
                   $row->AddStyle('backgroundColor', $this->zebra[($line++) % 2]);
               }
           }
       }
       return $t;
   }

    public function getFieldValidator($name)
    {
        foreach($this->validations as $validator)
        {
            if( $validator && $validator->field == $name )
            {
                return $validator;
            }
        }
        return false;
    }

   
   function GenerateLayoutField($f, &$hidden)
   {  
       if ( is_array($f) )
       {
          $c = array();
          foreach($f as $fld)
          {
             if ($fld->visible) $c[] = $fld;
          }
          $f = new MHContainer('',$c);
          $f->showLabel = true;
       }
       if ( ! $f->visible ) return;
       $rowContent = NULL;
       $label = $f->label;
       if ( ( ( ($f->className == 'textfield') || ($f->className == 'mtextfield'))  && ($f->size==0) ) || ($f instanceof  MHiddenField) )
       {
          $hidden[] = $f;
          return;
       }
       if ( $f->maintainstate )
       {
          $hidden[] = $f;
       }
       if ( $f->cssp )
       {
          return $f;
       }
   
//       if ( ($f->formMode == 0) || (($f->formMode == 1) && (! $label)))
       if (($f->formMode != 1) || (($f->formMode == 1) && (! $label)))
       {
          $rowContent = $f;
       }
       else
       {
          if ( $label != '' && $label != '&nbsp;' )
          {
              $label .= ':';
          }
          $tf = array();
          if ($label != '') 
          { 
             if ($f->id != '')
             { 
                $lbl = new MFieldLabel($f->id,$label);
                $lbl->setClass('m-caption');
             }
             else
             {
                $lbl = new MSpan('',$label,'m-caption');
             }
             if($f->validator && $f->validator->type == 'required')
             {
                $lbl->setClass('m-caption-required');
             }

             $slbl = $rowContent[] = new MSpan('',$lbl,'label');
             if ($this->labelWidth != NULL)
             {
                 //$slbl->_AddStyle('width',$this->labelWidth.'%');
                 $slbl->_AddStyle('width',$this->labelWidth.'px');
             }
          }
          if ( $this->showHints && $f->hint )
          {
             $hint = new MSpan('',$f->hint,'m-hint');
             $sfld = $rowContent[] = new MSpan('',array($f,'&nbsp;',$hint),'field');
          }
          else
          {
             $sfld = new MSpan('',$f,'field');
             $rowContent[] = $sfld;
          }
          if ($this->labelWidth != NULL)
          {
             //$sfld->_AddStyle('width', (95 - $this->labelWidth).'%');
          }
       }
       return new MDiv('',$rowContent, "m-form-row");
    }

    
    function GenerateButtons()
    {
           $ul = new MUnorderedList();
           if (isset($this->buttons) )
           {
              $ul->AddOption(new MHr);
              foreach ( $this->buttons as $b )
              {
                 if ($b->visible) $ul->AddOption($b);
              }
           }
           if ( $this->reset )
           {
              $ul->AddOption(new MButton('_reset','Limpar','RESET'));
           }
           if ( $this->return )
           {
              $ul->AddOption(new MButton('_return','Voltar','RETURN'));
           }
           $d = (count($ul->options) ? new MDiv('',$ul,'m-form-button-box') : NULL);
           return ($d ? new MDiv('',$d,'m-form-row') : NULL);
    }


    function GenerateHiddenFields($hidden)
    {
        $f[] = "\n<!-- START OF HIDDEN FIELDS -->\n";
        foreach ( $hidden as $h )
        {
            $f[] = new HiddenField($h->name,$h->value);
        }
        $f[] = "\n<!-- END OF HIDDEN FIELDS -->";
        return $f;
    }

    
    function GenerateScript()
    {
        $f = array();
        if ( $this->validations )
        {
            // we generate the form onSubmit handler right in the body of the form
            $f[] = "\n<!-- START OF FORM SCRIPT CODE -->\n";
            $f[] =  "<script language=\"JavaScript\">\n";
//            echo "document.{$this->name}.elements[0].focus();\n";
            $this->OnSubmit("MIOLO_Validate_Input({$this->name}_validations)");
            $f[] =  "\n";
            $f[] =  "/*\n";
            $f[] =  " * MIOLO Form Validation Objects\n";
            $f[] =  "*/\n";
            foreach ( $this->validations as $v )
            {
                $f[] = $v;
                $f[] = "\n";
            }
            $f[] = "var {$this->name}_validations = Array( ";
            $i   = 0;
            foreach ( $this->validations as $v )
            {
                if ( $i++ )
                {
                    $f[] = ",\n                                ";
                }
                $f[] = $v->name;
            }
            $f[] = " );\n";
            $f[] = "\n";
            $f[] = "</script>\n";
            $f[] = "<!-- END OF FORM SCRIPT CODE -->\n";
        }
        return $f;
    }

    function Generate()
    {
        if (!isset($this->buttons))
        {
            if ($this->defaultButton)
            {
                $this->buttons[] = new FormButton(FORM_SUBMIT_BTN_NAME, 'Enviar', 'SUBMIT');
            }
        }
        $footer = $this->GenerateFooter();
        if ($this->cssForm)
        {
            $body = $this->GenerateBody();
            $this->box->SetControls(array($body));
            $this->box->SetBoxClass('m-form-css');
            return $this->box->Generate();
        }
        else
        {
            $body = new MDiv('',$this->GenerateBody(),'m-form-body');
            if (!is_null($this->bgColor)) $body->AddStyle('backgroundColor',$this->bgColor);
            $this->box->SetControls(array($body, $footer));
            $id   = $this->GetUniqueId();
            $this->box->SetBoxClass("m-form-outer");
            $form = new MDiv("frm$id", $this->box,"m-form-box");
            if (!is_null($this->align)) $form->AddBoxStyle('text-align',$this->align);
            return $form->Generate();
//            return $this->box->Generate();
        }
    }
}

class FormData
{
}
?>

CopyLeft (L) 2001-2006 - [MIOLO Development Team] SOLIS - Cooperativa de Soluções Livres - Lajeado/RS - Brasil