employeehours report

application/controllers/reports/EmployeeHoursController.php

@@ -27,6 +27,15 @@ class EmployeeHoursController extends MY_Controller {
 
     }
 
+    public function recapProjects()
+    {
+        $recapprojects = new Recapprojects();
+
+        $projects = $recapprojects->getProjects();
+
+        $this->json( $projects );
+    }
+
     public function getMonthlyEmployeeHoursPerProject( $employeeID, $year )
     {
         $monthlyhours = Projecthour::getMonthlyEmployeeHoursPerProject( $employeeID, $year );

application/libraries/reports/Recapprojects.php

@@ -0,0 +1,241 @@
+<?php
+/**
+ * Created by Pensare Software.
+ * User: Theo Weijmer
+ * Date: 20/02/2018
+ * Time: 16:49
+ */
+
+class Recapprojects {
+
+    private $ci;
+    private $index;
+    private $project;
+    private $projects;
+    private $invoicedYears = [];
+    private $projectTotals;
+    private $uniqueEmployee;
+    private $uniqueEmployees;
+    private $projectEmployeeDetail;
+    private $projectEmployeeDetails;
+
+    public function __construct()
+    {
+        $this->ci =& get_instance();
+
+        $this->ci->load->Model( 'projects/Invoices_model' );
+
+        $this->handle();
+    }
+
+    public function getProjects()
+    {
+        return $this->projects;
+    }
+
+    private function handle()
+    {
+        $this->setProjects();
+
+        $this->setUniqueEmployees();
+
+        $this->loopProjects();
+
+        $this->setInvoicedYears();
+
+        $this->loopProjectsForInvoicedYears();
+    }
+
+    private function setProjects()
+    {
+        $this->projects = Project::getActiveProjects()->toArray();
+    }
+
+    private function setUniqueEmployees()
+    {
+        $this->uniqueEmployees = Projectemployee::getUniqueProjectEmployees();
+    }
+
+    private function loopProjects()
+    {
+        $this->index = 0;
+        foreach ( $this->projects as $this->project )
+        {
+            $this->projectTotals = 0;
+
+            $this->setProjectEmployeeDetails();
+
+            $this->loopUniqueEmployees();
+
+            $this->setBudget();
+
+            $this->setProjectCosts();
+
+            $this->setBudgetAvailable();
+
+            $this->setSaldo();
+
+            $this->setInvoiced();
+
+            $this->setWorkInProgress();
+
+            $this->index ++;
+        }
+    }
+
+    private function setProjectEmployeeDetails()
+    {
+        $this->projectEmployeeDetails =
+            Projectemployee::getProjectemployeeDetailsPerProject( $this->project['id'] );
+    }
+
+    private function loopUniqueEmployees()
+    {
+        foreach ( $this->uniqueEmployees as $this->uniqueEmployee )
+        {
+            $this->setProjectEmployeeDetail();
+
+            $this->setEmployeeDetails();
+
+            $this->setProjectTotals();
+        }
+    }
+
+    private function setProjectEmployeeDetail()
+    {
+        foreach ( $this->projectEmployeeDetails as $this->projectEmployeeDetail )
+        {
+            if ( $this->uniqueEmployee->id == $this->projectEmployeeDetail->id ) return;
+        }
+
+        $this->projectEmployeeDetail = FALSE;
+    }
+
+    private function setEmployeeDetails()
+    {
+        $budget = is_null( $this->projectEmployeeDetail['budget'] ) ? 0 : $this->projectEmployeeDetail['budget'];
+        $hours = $this->projectEmployeeDetail ? $this->projectEmployeeDetail->hours : 0;
+        $this->projects[ $this->index ]['employees'][] = [
+            'id'             => $this->uniqueEmployee->id,
+            'fullname'       => $this->uniqueEmployee->fullname,
+            'hours'          => $hours,
+            'revenues'       => $this->projectEmployeeDetail ? $this->projectEmployeeDetail->revenues : 0,
+            'budget'         => $budget,
+            'availableHours' => $budget - $hours
+        ];
+    }
+
+    private function setProjectTotals()
+    {
+        if ( ! isset( $this->projects[ $this->index ]['projectHours'] ) )
+            $this->projects[ $this->index ]['projectHours'] = 0;
+        if ( ! isset( $this->projects[ $this->index ]['projectEuros'] ) )
+            $this->projects[ $this->index ]['projectEuros'] = 0;
+
+        $this->projects[ $this->index ]['projectHours'] +=
+            $this->projectEmployeeDetail ? $this->projectEmployeeDetail->hours : 0;
+        $this->projects[ $this->index ]['projectEuros'] +=
+            $this->projectEmployeeDetail ? $this->projectEmployeeDetail->revenues : 0;
+    }
+
+    private function setBudget()
+    {
+        $this->projects[ $this->index ]['budget'] =
+            round( ( $this->projects[ $this->index ]['own_revenue'] + $this->projects[ $this->index ]['other_revenue'] ), 0 );
+    }
+
+    private function setProjectCosts()
+    {
+        $this->projects[ $this->index ]['projectcosts'] =
+            Projectcost::getCostsPerPerProject( $this->projects[ $this->index ]['id'] );
+    }
+
+    private function setBudgetAvailable()
+    {
+        $this->projects[ $this->index ]['budgetAvailable'] =
+            $this->projects[ $this->index ]['budget'] - $this->projects[ $this->index ]['projectcosts'];
+    }
+
+    private function setSaldo()
+    {
+        $this->projects[ $this->index ]['saldo'] =
+            $this->projects[ $this->index ]['budgetAvailable'] - $this->projects[ $this->index ]['projectEuros'];
+    }
+
+    private function setInvoiced()
+    {
+        $invoiced =
+            $this->ci->Invoices_model->getInvoicedPerYearPerProject( $this->projects[ $this->index ]['id'] );
+
+        foreach ( $invoiced ? $invoiced : [] as $invoice )
+        {
+            $this->projects[ $this->index ]['invoiced'][] = [
+                'year'     => $invoice->invoiceyear,
+                'invoiced' => $invoice->invoiced
+            ];
+
+            $this->setTotalInvoiced( $invoice->invoiced );
+        }
+
+        if ( ! isset( $this->projects[ $this->index ]['invoiced'] ) )
+        {
+            $this->projects[ $this->index ]['invoiced'] = [];
+            $this->projects[ $this->index ]['totalInvoiced'] = 0;
+        }
+    }
+
+    private function setTotalInvoiced( $invoiced )
+    {
+        if ( ! isset( $this->projects[ $this->index ]['totalInvoiced'] ) )
+            $this->projects[ $this->index ]['totalInvoiced'] = 0;
+
+        $this->projects[ $this->index ]['totalInvoiced'] += $invoiced;
+    }
+
+    private function setWorkInProgress()
+    {
+        $this->projects[ $this->index ]['workInProgress'] =
+            $this->projects[ $this->index ]['projectEuros'] +
+            $this->projects[ $this->index ]['projectcosts'] -
+            $this->projects[ $this->index ]['totalInvoiced'];
+    }
+
+    private function setInvoicedYears()
+    {
+        foreach ( $this->projects as $this->project )
+        {
+            foreach ( $this->project['invoiced'] as $year )
+            {
+                if ( in_array( $year['year'], $this->invoicedYears ) ) continue;
+
+                array_push( $this->invoicedYears, $year['year'] );
+            }
+        }
+    }
+
+    private function loopProjectsForInvoicedYears()
+    {
+        $this->index = 0;
+
+        foreach ( $this->projects as $this->project )
+        {
+            foreach ( $this->invoicedYears as $invoiceYear )
+            {
+                $hasYear = FALSE;
+                foreach ( $this->project['invoiced'] as $year )
+                {
+                    if ( $invoiceYear == $year['year'] ) $hasYear = TRUE;
+                }
+
+                if ( ! $hasYear ) $this->projects[ $this->index ]['invoiced'][] = [
+                    'year'     => $invoiceYear,
+                    'invoiced' => 0
+                ];
+            }
+            usort( $this->projects[ $this->index ]['invoiced'], function ( $a, $b ) {
+                return $a['year'] - $b['year'];
+            } );
+            $this->index ++;
+        }
+    }
+}

application/models/eloquent/Invoice.php

@@ -6,6 +6,7 @@
  * Time: 15:58
  */
 
+
 class Invoice extends BaseModel {
 
     public function project()

application/models/eloquent/Project.php

@@ -68,6 +68,20 @@ class Project extends BaseModel {
         Project::whereId( $projectID )->delete();
     }
 
+    public static function getActiveProjects()
+    {
+        $projects = Project::selectRaw( "projects.id, YEAR(projects.startdate) AS instroom, YEAR(projects.enddate) AS uitstroom, projectnumber,
+            projectname, CUS.name, OFF.own_revenue, OFF.other_revenue" )
+            ->join( 'customers AS CUS', 'CUS.id', '=', 'projects.customer_id' )
+            ->join( 'offers AS OFF', 'OFF.project_id', '=', 'projects.id' )
+            ->groupBy( 'projects.id' )
+            ->groupBy( 'OFF.own_revenue' )
+            ->groupBy( 'OFF.other_revenue' )
+            ->get();
+
+        return $projects;
+    }
+
     public static function getBaseProject()
     {
         $project = Project::with( [

application/models/eloquent/Projectcost.php

@@ -35,4 +35,13 @@ class Projectcost extends BaseModel {
         return $projectID;
     }
 
+    public static function getCostsPerPerProject( $projectID )
+    {
+        $projectCosts = Projectcost::selectraw( 'ROUND(COALESCE(SUM(costs), 0), 0) AS costs')
+            ->whereProjectId($projectID)
+            ->first();
+
+        return $projectCosts->costs;
+    }
+
 }

application/models/eloquent/Projectemployee.php

@@ -36,6 +36,29 @@ class Projectemployee extends BaseModel {
         return $availableEmployees;
     }
 
+    public static function getUniqueProjectEmployees()
+    {
+        $projectemployees = Projectemployee::selectRaw( "USR.id, CONCAT(firstname, ' ', middlename, ' ', lastname) AS fullname" )
+            ->distinct()
+            ->join( 'users AS USR', 'USR.id', '=', 'projectemployees.user_id' )
+            ->get();
+
+        return $projectemployees;
+    }
+
+    public static function getProjectemployeeDetailsPerProject( $projectID )
+    {
+        $details = Projectemployee::selectRaw( 'USR.id, budget, project_id, ROUND(SUM(hours), 0) AS hours, ROUND(SUM(hours * tarif), 0) AS revenues, projectemployees.id AS projectemployeeID' )
+            ->join( 'users AS USR', 'USR.id', '=', 'projectemployees.user_id' )
+            ->join( 'projecthours AS PRH', 'PRH.projectemployee_id', '=', 'projectemployees.id' )
+            ->where( 'projectemployees.project_id', '=', $projectID )
+            ->where( 'PRH.hourtype_id', '=', 1 )
+            ->groupBy( 'projectemployees.id' )
+            ->get();
+
+        return $details;
+    }
+
     public static function createProjectEmployee( $projectID )
     {
         $projectemployee = Projectemployee::create( [

application/models/eloquent/Projecthour.php

@@ -27,50 +27,18 @@ class Projecthour extends BaseModel {
 
     public static function getMonthlyEmployeeHoursPerProject( $employeeID, $year )
     {
-        $projectHours = Projecthour::selectRaw( "
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-1', projecthours.hours, 0)) AS januari,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-2', projecthours.hours, 0)) AS februari,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-3', projecthours.hours, 0)) AS maart,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-4', projecthours.hours, 0)) AS april,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-5', projecthours.hours, 0)) AS mei,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-6', projecthours.hours, 0)) AS juni,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-7', projecthours.hours, 0)) AS juli,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-8', projecthours.hours, 0)) AS augustus,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-9', projecthours.hours, 0)) AS september,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-10', projecthours.hours, 0)) AS oktober,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-11', projecthours.hours, 0)) AS november,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-12', projecthours.hours, 0)) AS december,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-1', projecthours.hours * tarif, 0)) AS januariRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-2', projecthours.hours * tarif, 0)) AS februariRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-3', projecthours.hours * tarif, 0)) AS maartRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-4', projecthours.hours * tarif, 0)) AS aprilRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-5', projecthours.hours * tarif, 0)) AS meiRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-6', projecthours.hours * tarif, 0)) AS juniRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-7', projecthours.hours * tarif, 0)) AS juliRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-8', projecthours.hours * tarif, 0)) AS augustusRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-9', projecthours.hours * tarif, 0)) AS septemberRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-10', projecthours.hours * tarif, 0)) AS oktoberRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-11', projecthours.hours * tarif, 0)) AS novemberRevenue,
-            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-12', projecthours.hours * tarif, 0)) AS decemberRevenue,
-            SUM(IF(YEAR(hourdate) = {$year},projecthours.hours, 0)) AS totalyear,
-            SUM(IF(YEAR(hourdate) != {$year},projecthours.hours, 0)) AS totalotheryears,
-            SUM(IF(YEAR(hourdate) = {$year},projecthours.hours * tarif, 0)) AS totalyearRevenue,
-            SUM(IF(YEAR(hourdate) != {$year},projecthours.hours * tarif, 0)) AS totalotheryearsRevenue,
-            SUM(projecthours.hours) AS totalhours,
-            SUM(projecthours.hours * tarif) AS totalhoursRevenue,
-            PEM.tarif,
-            PRJ.projectname" )
-            ->join( 'projectemployees AS PEM', 'PEM.id', '=', 'projecthours.projectemployee_id' )
-            ->join( 'projects AS PRJ', 'PRJ.id', '=', 'PEM.project_id' )
-            ->where( 'PEM.user_id', '=', $employeeID )
-            ->groupBy('PRJ.id')
-            ->groupBy('PEM.tarif')
-            ->groupBy('PRJ.projectname')
-            ->get();
+        $projectHours = ProjecthoursPerEmployeePerMonth::fire($employeeID, $year);
 
         return $projectHours;
     }
 
+    public static function recapProjects()
+    {
+        $recaps = QRecapProjects::fire();
+
+        return $recaps;
+    }
+
     public static function saveProjecthour( $projecthourID, $projecthour )
     {
         $projecthour = (array) $projecthour;

application/models/eloquent/queries/ProjecthoursPerEmployeePerMonth.php

@@ -0,0 +1,58 @@
+<?php
+/**
+ * Created by Pensare Software.
+ * User: Theo Weijmer
+ * Date: 20/02/2018
+ * Time: 09:36
+ */
+
+class ProjecthoursPerEmployeePerMonth extends BaseModel {
+
+    public static function fire($employeeID, $year)
+    {
+        $projectHours = Projecthour::selectRaw( "
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-1', projecthours.hours, 0)) AS januari,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-2', projecthours.hours, 0)) AS februari,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-3', projecthours.hours, 0)) AS maart,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-4', projecthours.hours, 0)) AS april,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-5', projecthours.hours, 0)) AS mei,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-6', projecthours.hours, 0)) AS juni,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-7', projecthours.hours, 0)) AS juli,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-8', projecthours.hours, 0)) AS augustus,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-9', projecthours.hours, 0)) AS september,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-10', projecthours.hours, 0)) AS oktober,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-11', projecthours.hours, 0)) AS november,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-12', projecthours.hours, 0)) AS december,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-1', projecthours.hours * tarif, 0)) AS januariRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-2', projecthours.hours * tarif, 0)) AS februariRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-3', projecthours.hours * tarif, 0)) AS maartRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-4', projecthours.hours * tarif, 0)) AS aprilRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-5', projecthours.hours * tarif, 0)) AS meiRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-6', projecthours.hours * tarif, 0)) AS juniRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-7', projecthours.hours * tarif, 0)) AS juliRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-8', projecthours.hours * tarif, 0)) AS augustusRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-9', projecthours.hours * tarif, 0)) AS septemberRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-10', projecthours.hours * tarif, 0)) AS oktoberRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-11', projecthours.hours * tarif, 0)) AS novemberRevenue,
+            SUM(IF(CONCAT(YEAR(hourdate), '-', MONTH(hourdate))  = '{$year}-12', projecthours.hours * tarif, 0)) AS decemberRevenue,
+            SUM(IF(YEAR(hourdate) = {$year},projecthours.hours, 0)) AS totalyear,
+            SUM(IF(YEAR(hourdate) != {$year},projecthours.hours, 0)) AS totalotheryears,
+            SUM(IF(YEAR(hourdate) = {$year},projecthours.hours * tarif, 0)) AS totalyearRevenue,
+            SUM(IF(YEAR(hourdate) != {$year},projecthours.hours * tarif, 0)) AS totalotheryearsRevenue,
+            SUM(projecthours.hours) AS totalhours,
+            SUM(projecthours.hours * tarif) AS totalhoursRevenue,
+            PEM.tarif,
+            PRJ.projectname" )
+            ->join( 'projectemployees AS PEM', 'PEM.id', '=', 'projecthours.projectemployee_id' )
+            ->join( 'projects AS PRJ', 'PRJ.id', '=', 'PEM.project_id' )
+            ->where( 'PEM.user_id', '=', $employeeID )
+            ->groupBy('PRJ.id')
+            ->groupBy('PEM.tarif')
+            ->groupBy('PRJ.projectname')
+            ->get();
+
+        return $projectHours;
+    }
+
+
+}

application/models/eloquent/queries/QRecapProjects.php

@@ -0,0 +1,12 @@
+<?php
+/**
+ * Created by Pensare Software.
+ * User: Theo Weijmer
+ * Date: 20/02/2018
+ * Time: 09:45
+ */
+
+class QRecapProjects {
+
+}
+

application/models/projects/Invoices_model.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * Created by Pensare Software.
+ * User: Theo Weijmer
+ * Date: 21/02/2018
+ * Time: 10:34
+ */
+
+class Invoices_model extends MY_Model {
+
+    protected $tablename = 'invoices';
+
+    public function getInvoicedPerYearPerProject( $projectID )
+    {
+        $this->sql = "
+        SELECT          ROUND(COALESCE(SUM(invoiceamount), 0),0) AS invoiced, YEAR(invoicedate) AS invoiceyear
+        FROM            invoices
+        WHERE           project_id = {$projectID}
+        GROUP BY        YEAR(invoicedate) 
+        ORDER BY        YEAR(invoicedate) ";
+
+        $invoiced = $this->get_query_result();
+
+        return $invoiced;
+    }
+}

application/views/pages/monthlyemployeehours_view.php

@@ -1,32 +1,30 @@
 <div class="MONTHLYEMPLOYEEHOURS">
     <div class="row">
-        <div class="col-md-1">
+        <div class="col-xl-1">
             <label>jaar</label>
         </div>
-        <div class="col-md-3">
+        <div class="col-xl-3">
             <select class="form-control form-control-sm"
                     data-bind="options:years,
                                 optionsText:'year',
                                 optionsValue: 'id',
                                 value:selectedYear,
                                 event:{change:refreshTab}"></select>
-
-
         </div>
     </div>
     <div class="row">
         <div class="col-md-12">
             <div class="nav-tabs-horizontal">
                 <ul class="nav nav-tabs nav-tabs-solid">
-                    <li class="nav-item" data-bind="click:setActivetab.bind($data, 'euro')">
+                    <li class="nav-item" data-bind="click:setActivetab.bind($data, 'euro')" style="z-index:10">
                         <a class="nav-link" data-bind="css:{'active':sluggy() == 'euro'}">totaal euro's</a>
                     </li>
-                    <li class="nav-item" data-bind="click:setActivetab.bind($data, 'hours')">
+                    <li class="nav-item" data-bind="click:setActivetab.bind($data, 'hours')" style="z-index:10">
                         <a class="nav-link" data-bind="css:{'active':sluggy() == 'hours'}">totaal uren</a>
                     </li>
 
                     <!-- ko foreach:uniqueEmployees -->
-                        <li class="nav-item" data-bind="click:$root.setActivetab.bind($data, slug)">
+                        <li class="nav-item" data-bind="click:$root.setActivetab.bind($data, slug)" style="z-index:10">
                             <a class="nav-link" data-bind="text:fullname, css:{'active':$root.sluggy() == slug}"></a>
                         </li>
                     <!-- /ko -->

application/views/partials/_js.php

@@ -11,6 +11,7 @@
 <script src="js/vendor/froala/js/froala_editor.min.js"></script>
 <script src="js/vendor/froala/js/plugins/knockout-froala.js"></script>
 <script src="js/vendor/Chart.js"></script>
+<script src="js/vendor/lodash.js"></script>
 
 
 <!--<script src="js/vendor/mousewheel/jquery.mousewheel.js"></script>-->

application/views/reports/monthlyemployeehours/euro_view.php

@@ -1 +1,141 @@
-<h1>EURO'S</h1>
+<table class="table" style="font-size:.8em;">
+    <thead>
+    <tr>
+        <th class="rotate">
+            <div><span>projectnummer</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>instroom</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>uitstroom</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>naam</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>opdrachtgever</span></div>
+        </th>
+        <!-- ko foreach: uniqueEmployees -->
+        <th class="rotate">
+            <div><span data-bind="text:fullname"></span></div>
+        </th>
+        <!-- /ko -->
+        <th class="rotate">
+            <div><span>totaal</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>budget (ex btw)</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>derden (ex btw)</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>beschikbaar</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>saldo</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>OWP</span></div>
+        </th>
+        <!-- ko foreach: uniqueYears -->
+        <th class="rotate">
+            <div><span data-bind="text:year"></span></div>
+        </th>
+        <!-- /ko -->
+        <th class="rotate">
+            <div><span>OWP</span></div>
+        </th>
+    </tr>
+    </thead>
+    <tbody data-bind="foreach:recap">
+    <tr>
+        <td><span data-bind="text:projectnumber"></span></td>
+        <td><span data-bind="text:instroom"></span></td>
+        <td><span data-bind="text:uitstroom ? uitstroom : ''"></span></td>
+        <td><span data-bind="text:projectname"></span></td>
+        <td><span data-bind="text:name"></span></td>
+        <!-- ko foreach: employees -->
+        <td class="align-right">
+            <span data-bind="text:revenues"></span>
+        </td>
+        <!-- /ko -->
+        <th class="align-right">
+            <span data-bind="text:totalEmployeeRevenues"></span>
+        </th>
+        <td class="align-right">
+            <span data-bind="text:budget"></span>
+        </td>
+        <td class="align-right">
+            <span data-bind="text:externCosts"></span>
+        </td>
+        <th class="align-right">
+            <span data-bind="text:budgetAvailable"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:saldo"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:workInProgress"></span>
+        </th>
+        <!-- ko foreach:invoiced -->
+        <th class="align-right">
+            <span data-bind="text:invoiced"></span>
+        </th>
+        <!-- /ko -->
+    </tr>
+    </tbody>
+    <tfoot>
+    <tr>
+        <th class="align-right" colspan="5">totaal</th>
+        <!-- ko foreach: totalPerEmployee -->
+        <th class="align-right">
+            <span data-bind="text:totalRevenue"></span>
+        </th>
+        <!-- /ko -->
+        <th class="align-right">
+            <span data-bind="text:totalEmployeeRevenues"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:totalBudget"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:totalCosts"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:totalAvailableBudget"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:totalSaldo"></span>
+        </th>
+        <th class="align-right">
+            <span data-bind="text:totalWorkInProgress"></span>
+        </th>
+        <!-- ko foreach:totalInvoicedYear -->
+        <th class="align-right">
+            <span data-bind="text:totalInvoiced"></span>
+        </th>
+        <!-- /ko -->
+    </tr>
+    </tfoot>
+</table>
+<div class="row">
+    <div class="col-xl-3">
+        <div  class="graph-holder" style="height:100%">
+            <canvas id="recap-revenues" width="300px"></canvas>
+            <div id="recap-revenues-legends"></div>
+        </div>
+    </div>
+    <div class="col-xl-3">
+        <div  class="graph-holder" style="height:100%">
+            <canvas id="recap-revenues-project" width="300px"></canvas>
+            <div id="recap-revenues-project-legends"></div>
+        </div>
+    </div>
+    <div class="col-xl-6">
+        <div  class="graph-holder" style="height:100%">
+            <canvas id="recap-owh" width="300px"></canvas>
+        </div>
+    </div>
+</div>

application/views/reports/monthlyemployeehours/hours_view.php

@@ -1 +1,62 @@
-<h1>hours</h1>
+<table class="table" style="font-size:.8em;">
+    <thead>
+    <tr>
+        <th class="rotate">
+            <div><span>projectnummer</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>instroom</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>uitstroom</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>naam</span></div>
+        </th>
+        <th class="rotate">
+            <div><span>opdrachtgever</span></div>
+        </th>
+        <!-- ko foreach: uniqueEmployees -->
+        <th class="rotate">
+            <div><span data-bind="text:fullname + ' geschreven'"></span></div>
+        </th>
+        <!-- /ko -->
+        <th class="rotate">
+            <div><span>totaal fact. uren gerealisserd</span></div>
+        </th>
+        <!-- ko foreach: uniqueEmployees -->
+        <th class="rotate">
+            <div><span data-bind="text:fullname + ' beschikbaar'"></span></div>
+        </th>
+        <!-- /ko -->
+        <th class="rotate">
+            <div><span>totaal beschikbare uren</span></div>
+        </th>
+    </tr>
+    </thead>
+    <tbody data-bind="foreach:recap">
+    <tr>
+        <td><span data-bind="text:projectnumber"></span></td>
+        <td><span data-bind="text:instroom"></span></td>
+        <td><span data-bind="text:uitstroom ? uitstroom : ''"></span></td>
+        <td><span data-bind="text:projectname"></span></td>
+        <td><span data-bind="text:name"></span></td>
+        <!-- ko foreach: employees -->
+        <td class="align-right">
+            <span data-bind="text:hours"></span>
+        </td>
+        <!-- /ko -->
+        <th class="align-right">
+            <span data-bind="text:totalEmployeeHours"></span>
+        </th>
+        <!-- ko foreach: employees -->
+        <td class="align-right">
+            <span data-bind="text:availableHours"></span>
+        </td>
+        <!-- /ko -->
+        <td class="align-right">
+            <span data-bind=""></span>
+        </td>
+    </tr>
+    </tbody>
+</table>

composer.json

@@ -19,7 +19,9 @@
 	"autoload": {
 		"classmap": [
 			"application/models/eloquent",
+			"application/models/eloquent/queries",
 			"application/libraries/validation",
+			"application/libraries/reports",
 			"application/libraries/"
 		]
 	},

public/css/main.css

@@ -10,8 +10,8 @@
     color: #5A9101;
 }
 
-.whiteish{
-    color:#fff;
+.whiteish {
+    color: #fff;
 }
 
 .pointer {
@@ -22,7 +22,7 @@
     text-align: right;
 }
 
-.align-center{
+.align-center {
     text-align: center;
 }
 
@@ -52,6 +52,7 @@
     background-color: #0099B8;
     color: #fff !important;
 }
+
 .table-cyanish-header-light {
     background-color: #54CDE3;
     color: #fff !important;
@@ -72,6 +73,33 @@
     color: #fff !important;
 }
 
+th.rotate {
+    height: 100px;
+    white-space: nowrap;
+    position:relative;
+    top:-53px;
+}
+
+th.rotate > div {
+    transform:
+        /* Magic Numbers */
+        translate(25px, 51px)
+        /* 45 is really 360 - 45 */
+        rotate(315deg);
+    width: 30px;
+    float:left;
+}
+th.rotate > div > span {
+    padding: 5px 3px;
+    border-right: 1px solid #ccc;
+    border-bottom: 1px solid #ccc;
+}
+.pie-test{
+    width:20px;
+    height:20px;
+    border:1px solid #777;
+}
+
 /*********SWITCH************/
 .onoffswitch {
     position: relative;
@@ -178,22 +206,24 @@
     z-index: 10;
     top: 7px;
 }
+
 /**********END: percentage input***********/
 
-.pointer{
-    cursor:pointer;
+.pointer {
+    cursor: pointer;
 }
 
-.comment-text{
-    padding:5px;
-    margin-bottom:10px;
+.comment-text {
+    padding: 5px;
+    margin-bottom: 10px;
     background-color: #fffad9;
-    float:left;
-    width:100%;
-    border:1px solid #fffda0;
-    border-radius:5px;
+    float: left;
+    width: 100%;
+    border: 1px solid #fffda0;
+    border-radius: 5px;
 }
-.comment-text:hover{
+
+.comment-text:hover {
     background-color: #e9f3e9;
 }
 
@@ -202,7 +232,7 @@
     position: relative;
     overflow: hidden;
     display: inline-block;
-    width:100%
+    width: 100%
 }
 
 .upload-btn {
@@ -213,7 +243,7 @@
     border-radius: 8px;
     font-size: 15px;
     font-weight: bold;
-    width:100%
+    width: 100%
 }
 
 .upload-btn-wrapper input[type=file] {
@@ -225,39 +255,42 @@
 }
 
 /*********project page*************/
-.project-page{
-    position:fixed;
-    top:0;
-    bottom:0;
-    left:0;
-    right:0;
-    width:100%;
-    height:100%;
+.project-page {
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    width: 100%;
+    height: 100%;
     background-color: #CCD5DB;
-    z-index:1035;
-    display:none;
+    z-index: 1035;
+    display: none;
 }
-.project-page-header{
-    height:50px;
+
+.project-page-header {
+    height: 50px;
     background-color: #3e8ef7;
-    width:110%;
-    float:left;
-    position:relative;
-    left:-30px;
+    width: 110%;
+    float: left;
+    position: relative;
+    left: -30px;
 }
-.project-page-header > h3{
-    color:#fff;
-    margin-top:10px;
-    margin-left:20px;
+
+.project-page-header > h3 {
+    color: #fff;
+    margin-top: 10px;
+    margin-left: 20px;
 }
-.project-page > .container{
+
+.project-page > .container {
     background-color: #fff;
 }
 
-.graph-holder{
-    padding:10px 10px;
+.graph-holder {
+    padding: 10px 10px;
     background-color: #4c4c4c;
-    background-image: -webkit-gradient(radial, 50% 50%,0,50% 50%,200, from(rgb(22, 20, 17)), to(rgb(76, 76, 76)));
+    background-image: -webkit-gradient(radial, 50% 50%, 0, 50% 50%, 200, from(rgb(22, 20, 17)), to(rgb(76, 76, 76)));
     background-image: -webkit-radial-gradient(50% 50%, rgb(76, 76, 76), rgb(22, 20, 17));
     background-image: -moz-radial-gradient(50% 50%, rgb(76, 76, 76), rgb(22, 20, 17));
     background-image: -o-radial-gradient(50% 50%, rgb(76, 76, 76), rgb(22, 20, 17));

public/js/lib/dataservices/reportsDataService.js

@@ -15,15 +15,18 @@ dbo.reportsDataService = {
             } );
     },
 
+    getRecapProjects: function(callback){
+        $.getJSON( 'index.php/reports/employeeHoursController/recapProjects' )
+            .done( function ( data ) {
+                callback( data );
+            } );
+    },
+
     getEmployeeHours: function ( employeeID, year, callback ) {
         $.getJSON( 'index.php/reports/EmployeeHoursController/getMonthlyEmployeeHoursPerProject/' + employeeID + '/' + year )
             .done( function ( data ) {
                 callback( data );
-            } )
+            } );
     }
 
-
-
-//     getHoursPerEmployee
-
 }

public/js/lib/helpers.js

@@ -11,6 +11,10 @@ dbo.helpers = {
         return re.test( email.toLowerCase() );
     },
 
+    thousandSeparator: function ( x ) {
+        return x.toString().replace( /\B(?=(\d{3})+(?!\d))/g, "." );
+    },
+
     validateNumber: function ( input, point = true ) {
         var validNumbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ','];
         var pointTaken = false;
@@ -83,9 +87,9 @@ dbo.helpers = {
         return newDate;
     },
 
-    numberWithPoints :function(myNumber) {
-        if( ! myNumber) return 0;
+    numberWithPoints: function ( myNumber ) {
+        if ( !myNumber ) return 0;
 
-        return myNumber.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+        return myNumber.toString().replace( /\B(?=(\d{3})+(?!\d))/g, "." );
     }
 }

public/js/lib/modules/reports/monthlyEmployeeHoursModule.js

@@ -15,11 +15,21 @@ dbo.monthlyemployeehoursInit = function () {
 
         dbo.monthlyEmployeeHoursModel = {
 
-            uniqueEmployees: ko.observableArray( [] ),
-            sluggy         : ko.observable( 'euro' ),
-            years          : ko.observableArray( [] ),
-            selectedYear   : ko.observable(),
-            currentTab     : false,
+            uniqueEmployees      : ko.observableArray( [] ),
+            uniqueYears          : ko.observableArray( [] ),
+            sluggy               : ko.observable( 'euro' ),
+            years                : ko.observableArray( [] ),
+            selectedYear         : ko.observable(),
+            currentTab           : false,
+            recap                : ko.observableArray( [] ),
+            totalPerEmployee     : ko.observableArray( [] ),
+            totalEmployeeRevenues: ko.observable(),
+            totalBudget          : ko.observable(),
+            totalCosts           : ko.observable(),
+            totalAvailableBudget : ko.observable(),
+            totalSaldo           : ko.observable(),
+            totalWorkInProgress  : ko.observable(),
+            totalInvoicedYear    : ko.observableArray( [] ),
 
             init: function () {
                 var vm = dbo.monthlyEmployeeHoursModel;
@@ -38,12 +48,63 @@ dbo.monthlyemployeehoursInit = function () {
 
             initModule: function () {
                 var vm = dbo.monthlyEmployeeHoursModel;
+                vm.totalBudget( 0 );
+                vm.totalCosts( 0 );
+                vm.totalAvailableBudget( 0 );
+                vm.totalSaldo( 0 );
+                vm.totalWorkInProgress( 0 );
+                vm.totalEmployeeRevenues( 0 );
+                vm.totalPerEmployee.removeAll();
+                vm.totalInvoicedYear.removeAll();
                 dbo.userDataService.getUniqueProjectEmployees( function ( data ) {
                     vm.uniqueEmployees.removeAll();
                     $.each( data, function ( i, p ) {
                         vm.uniqueEmployees.push( new vm.UniqueEmployee( p ) )
                     } );
                 } );
+                dbo.reportsDataService.getRecapProjects( function ( data ) {
+                    vm.recap.removeAll();
+                    vm.uniqueYears.removeAll();
+                    $.each( data, function ( i, p ) {
+                        if ( i == 0 ) {
+                            $.each( p.invoiced, function ( y, q ) {
+                                vm.uniqueYears.push( {year: q.year} );
+                            } );
+                        }
+                        vm.recap.push( new vm.Project( p ) )
+                    } );
+                    vm.totalBudget( dbo.helpers.thousandSeparator( vm.totalBudget() ) );
+                    vm.totalCosts( dbo.helpers.thousandSeparator( vm.totalCosts() ) );
+                    vm.totalAvailableBudget( dbo.helpers.thousandSeparator( vm.totalAvailableBudget() ) );
+                    vm.totalSaldo( dbo.helpers.thousandSeparator( vm.totalSaldo() ) );
+                    vm.totalWorkInProgress( dbo.helpers.thousandSeparator( vm.totalWorkInProgress() ) );
+                    vm.totalEmployeeRevenues( dbo.helpers.thousandSeparator( vm.totalEmployeeRevenues() ) );
+                    _.each( vm.totalPerEmployee(), function ( p ) {
+                        p.totalRevenue( dbo.helpers.thousandSeparator( p.totalRevenue() ) );
+                    } );
+                    _.each( vm.totalInvoicedYear(), function ( p ) {
+                        p.totalInvoiced( dbo.helpers.thousandSeparator( p.totalInvoiced() ) );
+                    } );
+                    var chartData = [];
+                    var chartLabels = [];
+                    _.each( vm.totalPerEmployee(), function ( p ) {
+                        chartData.push( Number( p.totalRevenue().replace( '.', '' ) ) );
+                        chartLabels.push( p.fullname );
+                    } );
+                    var chartDataProjects = [];
+                    var chartLabelsProjects = [];
+                    var chartDataOwh = [];
+                    var chartColorOwh = [];
+                    _.each( vm.recap(), function ( p ) {
+                        chartDataProjects.push( Number( p.totalEmployeeRevenues.replace( '.', '' ) ) );
+                        chartLabelsProjects.push( p.projectname );
+                        chartDataOwh.push( Number( p.workInProgress.replace( '.', '' ) ) );
+                        chartColorOwh.push( Number( p.workInProgress.replace( '.', '' ) ) < 0 ? '#d53d24' : '#78be4b' );
+                    } );
+                    dbo.charts.drawPie( 'recap-revenues', chartData, chartLabels, 'omzet per medewerker' );
+                    dbo.charts.drawPie( 'recap-revenues-project', chartDataProjects, chartLabelsProjects, 'omzet per project' );
+                    dbo.charts.drawHoursChart( 'recap-owh', chartDataOwh, chartLabelsProjects, 'onderhandenwerk per project', chartColorOwh );
+                } );
             },
 
             refreshTab: function () {
@@ -103,7 +164,6 @@ dbo.monthlyemployeehoursInit = function () {
                         vm.currentTab.totalTotal( vm.currentTab.totalTotal() + q.totalyear );
                         vm.currentTab.totalTotalOtheryears( vm.currentTab.totalTotalOtheryears() + q.totalotheryears );
 
-
                         vm.currentTab.totalJanuariRevenue( vm.currentTab.totalJanuariRevenue() + q.januariRevenue );
                         vm.currentTab.totalFebruariRevenue( vm.currentTab.totalFebruariRevenue() + q.februariRevenue );
                         vm.currentTab.totalMaartRevenue( vm.currentTab.totalMaartRevenue() + q.maartRevenue );
@@ -149,10 +209,10 @@ dbo.monthlyemployeehoursInit = function () {
             setActivetab: function ( tab ) {
                 var vm = dbo.monthlyEmployeeHoursModel;
 
+                console.log( 'inside' );
                 $.each( vm.uniqueEmployees(), function ( i, p ) {
                     if ( tab == p.slug ) {
                         vm.currentTab = p;
-
                         vm.refreshTab();
                     }
                 } )
@@ -210,6 +270,84 @@ dbo.monthlyemployeehoursInit = function () {
 
             Detail: function ( data ) {
                 this.test = data;
+            },
+
+            Project: function ( data ) {
+                var vm = dbo.monthlyEmployeeHoursModel;
+                var self = this;
+
+                self.projectnumber = data.projectnumber;
+                self.instroom = data.instroom;
+                self.uitstroom = data.uitstroom;
+                self.projectname = data.projectname;
+                self.name = data.name;
+                self.revenues = dbo.helpers.thousandSeparator( data.budget );
+                self.hours = data.hours;
+                self.totalEmpoloyeeRevenues = 0;
+                self.externCosts = dbo.helpers.thousandSeparator( data.projectcosts );
+                self.budget = dbo.helpers.thousandSeparator( data.budget );
+                self.budgetAvailable = dbo.helpers.thousandSeparator( data.budgetAvailable );
+                self.saldo = dbo.helpers.thousandSeparator( data.saldo );
+
+                self.employees = ko.observableArray( [] );
+                $.each( data.employees, function ( i, p ) {
+                    self.employees.push( new vm.Employee( p ) );
+                    if ( !self.totalEmployeeRevenues ) self.totalEmployeeRevenues = 0;
+                } );
+                self.totalEmployeeRevenues = data.projectEuros;
+                vm.totalEmployeeRevenues( vm.totalEmployeeRevenues() + Number( self.totalEmployeeRevenues ) );
+                self.totalEmployeeRevenues = dbo.helpers.thousandSeparator( self.totalEmployeeRevenues );
+                self.totalEmployeeHours = data.projectHours;
+                self.workInProgress = dbo.helpers.thousandSeparator( data.workInProgress );
+
+                self.invoiced = ko.observableArray( [] );
+                $.each( data.invoiced, function ( i, p ) {
+                    self.invoiced.push( {invoiced: dbo.helpers.thousandSeparator( p.invoiced )} );
+                } );
+
+                vm.setTotals( data );
+            },
+
+            setTotals: function ( data ) {
+                var vm = dbo.monthlyEmployeeHoursModel;
+
+                vm.totalBudget( vm.totalBudget() + Number( data.budget ) );
+                vm.totalCosts( vm.totalCosts() + Number( data.projectcosts ) );
+                vm.totalAvailableBudget( vm.totalAvailableBudget() + Number( data.budgetAvailable ) );
+                vm.totalSaldo( vm.totalSaldo() + Number( data.saldo ) );
+                vm.totalWorkInProgress( vm.totalWorkInProgress() + Number( data.workInProgress ) );
+
+                var hasTotalEmployees = true;
+                if ( vm.totalPerEmployee().length == 0 ) hasTotalEmployees = false;
+                _.each( data.employees, function ( p ) {
+                    if ( !hasTotalEmployees ) {
+                        vm.totalPerEmployee.push( {id: p.id, fullname: p.fullname, totalRevenue: ko.observable( 0 )} );
+                    }
+                    var a = _.find( vm.totalPerEmployee(), function ( o ) {
+                        return o.id == p.id
+                    } );
+                    a.totalRevenue( a.totalRevenue() + p.revenues );
+                } );
+
+                var hasTotalsOwpYear = true;
+                if ( vm.totalInvoicedYear().length == 0 ) hasTotalsOwpYear = false;
+                _.each( data.invoiced, function ( p ) {
+                    if ( !hasTotalsOwpYear ) {
+                        vm.totalInvoicedYear.push( {year: p.year, totalInvoiced: ko.observable( 0 )} );
+                    }
+                    var a = _.find( vm.totalInvoicedYear(), function ( o ) {
+                        return o.year == p.year
+                    } );
+                    a.totalInvoiced( a.totalInvoiced() + Number( p.invoiced ) );
+                } );
+            },
+
+            Employee: function ( data ) {
+                this.fullname = data.fullname;
+                this.revenues = dbo.helpers.thousandSeparator( data.revenues );
+                this.hours = data.hours;
+                this.budget = data.budget;
+                this.availableHours = data.availableHours;
             }
         };
 

public/js/lib/services/chartService.js

@@ -7,7 +7,10 @@
 
 dbo.charts = {
 
-    monthLabels : ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'],
+    pieColors  : ['#ffcf30', '#06b2dc', '#048a44', '#a63305', '#a0c03b', '#ffcb22', '#89c540', '#f77c01', '#1094f6', '#6733ba'],
+    barColor   : ['#f3a921', '#f2770c', '#72221a', '#04843b', '#d63f2e', '#fec220'],
+    monthLabels: ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'],
+    charts     : [],
 
     drawHoursVsBudget: function ( hours, budget, element ) {
         var ctx = document.getElementById( element ).getContext( '2d' );
@@ -54,9 +57,7 @@ dbo.charts = {
                 labels  : ["offerte", "facturen", "betaald"],
                 datasets: [{
                     data           : [offer, invoice, payed],
-                    backgroundColor: [
-                        '#f3a921', '#f2770c', '#72221a'
-                    ]
+                    backgroundColor: dbo.charts.barColor
                 }]
             },
             options: {
@@ -81,8 +82,7 @@ dbo.charts = {
         } );
     },
 
-    drawHoursChart: function (element, chartData, labels, title, colors) {
-        console.log( chartData );
+    drawHoursChart: function ( element, chartData, labels, title, colors ) {
         var ctx = document.getElementById( element ).getContext( '2d' );
 
         var myChart = new Chart( ctx, {
@@ -104,7 +104,7 @@ dbo.charts = {
                     }]
                 },
                 legend             : {
-                    display: false,
+                    display  : false,
                     fontColor: '#ffffff',
                 },
                 title              : {
@@ -114,8 +114,43 @@ dbo.charts = {
                     fontColor: '#ffffff'
                 }
             }
-
         } );
+    },
+
+    drawPie: function ( element, data, chartLabels, title ) {
+        var ctx = document.getElementById( element ).getContext( '2d' );
+        dbo.charts.charts[element] = new Chart( ctx, {
+            type   : 'doughnut',
+            data   : {
+                datasets: [{
+                    data           : data,
+                    backgroundColor: dbo.charts.pieColors,
+                    borderColor    : dbo.charts.pieColors,
+                    label          : chartLabels
+                }],
+                labels  : chartLabels
+            },
+            options: {
+                title         : {
+                    display  : true,
+                    text     : title,
+                    fontSize : 16,
+                    fontColor: '#ffffff'
+                },
+                legend        : {
+                    display: false
+                },
+                legendCallback: function ( chart ) {
+                    var text = '';
+                    _.each( chart.data.labels, function ( p, i ) {
+                        text += '<div><div style="float:left;width:15px;height:15px;border-radius:50%;background-color:' + dbo.charts.pieColors[i] + '"></div><div style="margin-left:10px;float:left;color:#ffffff;">' + p + '</div></div><br />'
+                    } );
+
+                    return text;
+                }
+            }
+        } );
+        document.getElementById( element + '-legends' ).innerHTML = dbo.charts.charts[element].generateLegend();
     }
 
 }

public/js/vendor/Plugin/ace-editor.js

@@ -1,73 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/ace-editor', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAceEditor = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'ace';
-
-  var AceEditor = function (_Plugin) {
-    babelHelpers.inherits(AceEditor, _Plugin);
-
-    function AceEditor() {
-      babelHelpers.classCallCheck(this, AceEditor);
-      return babelHelpers.possibleConstructorReturn(this, (AceEditor.__proto__ || Object.getPrototypeOf(AceEditor)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(AceEditor, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof ace === 'undefined') return;
-        // ace.config.set("themePath", "../theme");
-        ace.config.loadModule('ace/ext/language_tools');
-
-        var $el = this.$el,
-            id = $el.attr('id'),
-            editor = ace.edit(id);
-
-        editor.container.style.opacity = '';
-        if (this.options.mode) {
-          editor.session.setMode('ace/mode/' + this.options.mode);
-        }
-        if (this.options.theme) {
-          editor.setTheme('ace/theme/' + this.options.theme);
-        }
-
-        editor.setOption('maxLines', 40);
-        editor.setAutoScrollEditorIntoView(true);
-
-        ace.config.loadModule('ace/ext/language_tools', function () {
-          editor.setOptions({
-            enableSnippets: true,
-            enableBasicAutocompletion: true
-          });
-        });
-      }
-    }]);
-    return AceEditor;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, AceEditor);
-
-  exports.default = AceEditor;
-});

public/js/vendor/Plugin/action-btn.js

@@ -1,168 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/action-btn', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginActionBtn = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var pluginName = 'actionBtn';
-  var defaults = {
-    trigger: 'click', // click, hover
-    toggleSelector: '.site-action-toggle',
-    listSelector: '.site-action-buttons',
-    activeClass: 'active',
-    onShow: function onShow() {},
-    onHide: function onHide() {}
-  };
-
-  var actionBtn = function () {
-    function actionBtn(element, options) {
-      babelHelpers.classCallCheck(this, actionBtn);
-
-      this.element = element;
-      this.$element = (0, _jquery2.default)(element);
-
-      this.options = _jquery2.default.extend({}, defaults, options, this.$element.data());
-
-      this.init();
-    }
-
-    babelHelpers.createClass(actionBtn, [{
-      key: 'init',
-      value: function init() {
-        this.showed = false;
-
-        this.$toggle = this.$element.find(this.options.toggleSelector);
-        this.$list = this.$element.find(this.options.listSelector);
-
-        var self = this;
-
-        if (this.options.trigger === 'hover') {
-          this.$element.on('mouseenter', this.options.toggleSelector, function () {
-            if (!self.showed) {
-              self.show();
-            }
-          });
-          this.$element.on('mouseleave', this.options.toggleSelector, function () {
-            if (self.showed) {
-              self.hide();
-            }
-          });
-        } else {
-          this.$element.on('click', this.options.toggleSelector, function () {
-            if (self.showed) {
-              self.hide();
-            } else {
-              self.show();
-            }
-          });
-        }
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        if (!this.showed) {
-          this.$element.addClass(this.options.activeClass);
-          this.showed = true;
-
-          this.options.onShow.call(this);
-        }
-      }
-    }, {
-      key: 'hide',
-      value: function hide() {
-        if (this.showed) {
-          this.$element.removeClass(this.options.activeClass);
-          this.showed = false;
-
-          this.options.onHide.call(this);
-        }
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(options) {
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        if (typeof options === 'string') {
-          var method = options;
-
-          if (/^\_/.test(method)) {
-            return false;
-          } else if (/^(get)$/.test(method)) {
-            var api = this.first().data(pluginName);
-            if (api && typeof api[method] === 'function') {
-              return api[method].apply(api, args);
-            }
-          } else {
-            return this.each(function () {
-              var api = _jquery2.default.data(this, pluginName);
-              if (api && typeof api[method] === 'function') {
-                api[method].apply(api, args);
-              }
-            });
-          }
-        } else {
-          return this.each(function () {
-            if (!_jquery2.default.data(this, pluginName)) {
-              _jquery2.default.data(this, pluginName, new actionBtn(this, options));
-            }
-          });
-        }
-      }
-    }]);
-    return actionBtn;
-  }();
-
-  _jquery2.default.fn[pluginName] = actionBtn._jQueryInterface;
-  _jquery2.default.fn[pluginName].constructor = actionBtn;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return actionBtn._jQueryInterface;
-  };
-
-  var ActionBtn = function (_Plugin) {
-    babelHelpers.inherits(ActionBtn, _Plugin);
-
-    function ActionBtn() {
-      babelHelpers.classCallCheck(this, ActionBtn);
-      return babelHelpers.possibleConstructorReturn(this, (ActionBtn.__proto__ || Object.getPrototypeOf(ActionBtn)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(ActionBtn, [{
-      key: 'getName',
-      value: function getName() {
-        return pluginName;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return defaults;
-      }
-    }]);
-    return ActionBtn;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(pluginName, ActionBtn);
-
-  exports.default = ActionBtn;
-});

public/js/vendor/Plugin/alertify.js

@@ -1,138 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/alertify', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAlertify = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'alertify';
-
-  var Alertify = function (_Plugin) {
-    babelHelpers.inherits(Alertify, _Plugin);
-
-    function Alertify() {
-      babelHelpers.classCallCheck(this, Alertify);
-      return babelHelpers.possibleConstructorReturn(this, (Alertify.__proto__ || Object.getPrototypeOf(Alertify)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Alertify, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (this.options.labelOk) {
-          this.options.okBtn = this.options.labelOk;
-        }
-
-        if (this.options.labelCancel) {
-          this.options.cancelBtn = this.options.labelCancel;
-        }
-
-        this.$el.data('alertifyWrapApi', this);
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        if (typeof alertify === 'undefined') return;
-        var options = this.options;
-        if (typeof options.delay !== 'undefined') {
-          alertify.delay(options.delay);
-        }
-
-        if (typeof options.theme !== 'undefined') {
-          alertify.theme(options.theme);
-        }
-
-        if (typeof options.cancelBtn !== 'undefined') {
-          alertify.cancelBtn(options.cancelBtn);
-        }
-
-        if (typeof options.okBtn !== 'undefined') {
-          alertify.okBtn(options.okBtn);
-        }
-
-        if (typeof options.placeholder !== 'undefined') {
-          alertify.delay(options.placeholder);
-        }
-
-        if (typeof options.defaultValue !== 'undefined') {
-          alertify.delay(options.defaultValue);
-        }
-
-        if (typeof options.maxLogItems !== 'undefined') {
-          alertify.delay(options.maxLogItems);
-        }
-
-        if (typeof options.closeLogOnClick !== 'undefined') {
-          alertify.delay(options.closeLogOnClick);
-        }
-
-        switch (options.type) {
-          case 'confirm':
-            alertify.confirm(options.confirmTitle, function () {
-              alertify.success(options.successMessage);
-            }, function () {
-              alertify.error(options.errorMessage);
-            });
-            break;
-          case 'prompt':
-            alertify.prompt(options.promptTitle, function (str, ev) {
-              var message = options.successMessage.replace('%s', str);
-              alertify.success(message);
-            }, function (ev) {
-              alertify.error(options.errorMessage);
-            });
-            break;
-          case 'log':
-            alertify.log(options.logMessage);
-            break;
-          case 'success':
-            alertify.success(options.successMessage);
-            break;
-          case 'error':
-            alertify.error(options.errorMessage);
-            break;
-          default:
-            alertify.alert(options.alertMessage);
-            break;
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          type: 'alert',
-          delay: 5000,
-          theme: 'bootstrap'
-        };
-      }
-    }, {
-      key: 'api',
-      value: function api() {
-        return 'click|show';
-      }
-    }]);
-    return Alertify;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Alertify);
-
-  exports.default = Alertify;
-});

public/js/vendor/Plugin/animate-list.js

@@ -1,100 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/animate-list', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginAnimateList = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'animateList';
-
-  var AnimateList = function (_Plugin) {
-    babelHelpers.inherits(AnimateList, _Plugin);
-
-    function AnimateList() {
-      babelHelpers.classCallCheck(this, AnimateList);
-      return babelHelpers.possibleConstructorReturn(this, (AnimateList.__proto__ || Object.getPrototypeOf(AnimateList)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(AnimateList, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        var $el = this.$el;
-
-        var animatedBox = function () {
-          function animatedBox($el, opts) {
-            babelHelpers.classCallCheck(this, animatedBox);
-
-            this.options = opts;
-            this.$children = $el.find(opts.child);
-            this.$children.addClass('animation-' + opts.animate);
-            this.$children.css('animation-fill-mode', opts.fill);
-            this.$children.css('animation-duration', opts.duration + 'ms');
-
-            var delay = 0,
-                self = this;
-
-            this.$children.each(function () {
-              (0, _jquery2.default)(this).css('animation-delay', delay + 'ms');
-              delay += self.options.delay;
-            });
-          }
-
-          babelHelpers.createClass(animatedBox, [{
-            key: 'run',
-            value: function run(type) {
-              var _this2 = this;
-
-              this.$children.removeClass('animation-' + this.options.animate);
-              if (typeof type !== 'undefined') {
-                this.options.animate = type;
-              }
-              setTimeout(function () {
-                _this2.$children.addClass('animation-' + _this2.options.animate);
-              }, 0);
-            }
-          }]);
-          return animatedBox;
-        }();
-
-        $el.data('animateList', new animatedBox($el, this.options));
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          child: '.panel',
-          duration: 250,
-          delay: 50,
-          animate: 'scale-up',
-          fill: 'backwards'
-        };
-      }
-    }]);
-    return AnimateList;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, AnimateList);
-
-  exports.default = AnimateList;
-});

public/js/vendor/Plugin/animsition.js

@@ -1,110 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/animsition', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginAnimsition = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'animsition';
-
-  var Animsition = function (_Plugin) {
-    babelHelpers.inherits(Animsition, _Plugin);
-
-    function Animsition() {
-      babelHelpers.classCallCheck(this, Animsition);
-      return babelHelpers.possibleConstructorReturn(this, (Animsition.__proto__ || Object.getPrototypeOf(Animsition)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Animsition, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render(callback) {
-        var options = this.options;
-
-        if (options.random) {
-          var li = options.inDefaults.length,
-              lo = options.outDefaults.length;
-
-          var ni = parseInt(li * Math.random(), 0),
-              no = parseInt(lo * Math.random(), 0);
-
-          options.inClass = options.inDefaults[ni];
-          options.outClass = options.outDefaults[no];
-        }
-
-        this.$el.animsition(options);
-
-        (0, _jquery2.default)('.' + options.loadingClass).addClass('loader-' + options.loadingType);
-
-        if (this.$el.animsition('supportCheck', options)) {
-          if (_jquery2.default.isFunction(callback)) {
-            this.$el.one('animsition.end', function () {
-              callback.call();
-            });
-          }
-
-          return true;
-        }
-        if (_jquery2.default.isFunction(callback)) {
-          callback.call();
-        }
-        return false;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          inClass: 'fade-in',
-          outClass: 'fade-out',
-          inDuration: 800,
-          outDuration: 500,
-          linkElement: '.animsition-link',
-          loading: true,
-          loadingParentElement: 'body',
-          loadingClass: 'loader',
-          loadingType: 'default',
-          timeout: false,
-          timeoutCountdown: 5000,
-          onLoadEvent: true,
-          browser: ['animation-duration', '-webkit-animation-duration'],
-          overlay: false,
-          // random: true,
-          overlayClass: 'animsition-overlay-slide',
-          overlayParentElement: 'body',
-
-          inDefaults: ['fade-in', 'fade-in-up-sm', 'fade-in-up', 'fade-in-up-lg', 'fade-in-down-sm', 'fade-in-down', 'fade-in-down-lg', 'fade-in-left-sm', 'fade-in-left', 'fade-in-left-lg', 'fade-in-right-sm', 'fade-in-right', 'fade-in-right-lg',
-          // 'overlay-slide-in-top', 'overlay-slide-in-bottom', 'overlay-slide-in-left', 'overlay-slide-in-right',
-          'zoom-in-sm', 'zoom-in', 'zoom-in-lg'],
-          outDefaults: ['fade-out', 'fade-out-up-sm', 'fade-out-up', 'fade-out-up-lg', 'fade-out-down-sm', 'fade-out-down', 'fade-out-down-lg', 'fade-out-left-sm', 'fade-out-left', 'fade-out-left-lg', 'fade-out-right-sm', 'fade-out-right', 'fade-out-right-lg',
-          // 'overlay-slide-out-top', 'overlay-slide-out-bottom', 'overlay-slide-out-left', 'overlay-slide-out-right'
-          'zoom-out-sm', 'zoom-out', 'zoom-out-lg']
-        };
-      }
-    }]);
-    return Animsition;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Animsition);
-
-  exports.default = Animsition;
-});

public/js/vendor/Plugin/asbreadcrumbs.js

@@ -1,80 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asbreadcrumbs', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAsbreadcrumbs = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'breadcrumb';
-
-  var Breadcrumb = function (_Plugin) {
-    babelHelpers.inherits(Breadcrumb, _Plugin);
-
-    function Breadcrumb() {
-      babelHelpers.classCallCheck(this, Breadcrumb);
-      return babelHelpers.possibleConstructorReturn(this, (Breadcrumb.__proto__ || Object.getPrototypeOf(Breadcrumb)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Breadcrumb, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        var $el = this.$el;
-        $el.asBreadcrumbs(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          overflow: 'left',
-          namespace: 'breadcrumb',
-          dropdownMenuClass: 'dropdown-menu',
-          dropdownItemClass: 'dropdown-item',
-          toggleIconClass: 'wb-chevron-down-mini',
-          ellipsis: function ellipsis(classes, label) {
-            return '<li class="breadcrumb-item ' + classes.ellipsisClass + '">' + label + '</li>';
-          },
-          dropdown: function dropdown(classes) {
-            var dropdownClass = 'dropdown';
-            var dropdownMenuClass = 'dropdown-menu';
-
-            if (this.options.overflow === 'right') {
-              dropdownMenuClass += ' dropdown-menu-right';
-            }
-
-            return '<li class="breadcrumb-item ' + dropdownClass + ' ' + classes.dropdownClass + '">\n          <a href="javascript:void(0);" class="' + classes.toggleClass + '" data-toggle="dropdown">\n            <i class="' + classes.toggleIconClass + '"></i>\n          </a>\n          <div class="' + dropdownMenuClass + ' ' + classes.dropdownMenuClass + '" role="menu"></div>\n        </li>';
-          },
-          dropdownItem: function dropdownItem(classes, label, href) {
-            if (!href) {
-              return '<a class="' + classes.dropdownItemClass + ' ' + classes.dropdownItemDisableClass + '" href="#">' + label + '</a>';
-            }
-            return '<a class="' + classes.dropdownItemClass + '" href="' + href + '">' + label + '</a>';
-          }
-        };
-      }
-    }]);
-    return Breadcrumb;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Breadcrumb);
-
-  exports.default = Breadcrumb;
-});

public/js/vendor/Plugin/ascolorpicker.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/ascolorpicker', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAscolorpicker = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'asColorPicker';
-
-  var AsColorPicker = function (_Plugin) {
-    babelHelpers.inherits(AsColorPicker, _Plugin);
-
-    function AsColorPicker() {
-      babelHelpers.classCallCheck(this, AsColorPicker);
-      return babelHelpers.possibleConstructorReturn(this, (AsColorPicker.__proto__ || Object.getPrototypeOf(AsColorPicker)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(AsColorPicker, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          namespace: 'colorInputUi'
-        };
-      }
-    }]);
-    return AsColorPicker;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, AsColorPicker);
-
-  exports.default = AsColorPicker;
-});

public/js/vendor/Plugin/aspaginator.js

@@ -1,108 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/aspaginator', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginAspaginator = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'paginator';
-
-  var Paginator = function (_Plugin) {
-    babelHelpers.inherits(Paginator, _Plugin);
-
-    function Paginator() {
-      babelHelpers.classCallCheck(this, Paginator);
-      return babelHelpers.possibleConstructorReturn(this, (Paginator.__proto__ || Object.getPrototypeOf(Paginator)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Paginator, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.asPaginator) {
-          return;
-        }
-
-        var $el = this.$el,
-            total = $el.data('total');
-
-        $el.asPaginator(total, this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          namespace: 'pagination',
-          currentPage: 1,
-          itemsPerPage: 10,
-          disabledClass: 'disabled',
-          activeClass: 'active',
-
-          visibleNum: {
-            0: 3,
-            480: 5
-          },
-
-          tpl: function tpl() {
-            return '{{prev}}{{lists}}{{next}}';
-          },
-
-
-          components: {
-            prev: {
-              tpl: function tpl() {
-                return '<li class="' + this.namespace + '-prev page-item"><a class="page-link" href="javascript:void(0)" aria-label="Prev"><span class="icon wb-chevron-left-mini"></span></a></li>';
-              }
-            },
-            next: {
-              tpl: function tpl() {
-                return '<li class="' + this.namespace + '-next page-item"><a class="page-link" href="javascript:void(0)" aria-label="Next"><span class="icon wb-chevron-right-mini"></span></a></li>';
-              }
-            },
-            lists: {
-              tpl: function tpl() {
-                var lists = '',
-                    remainder = this.currentPage >= this.visible ? this.currentPage % this.visible : this.currentPage;
-                remainder = remainder === 0 ? this.visible : remainder;
-                for (var k = 1; k < remainder; k++) {
-                  lists += '<li class="' + this.namespace + '-items page-item" data-value="' + (this.currentPage - remainder + k) + '"><a class="page-link" href="javascript:void(0)">' + (this.currentPage - remainder + k) + '</a></li>';
-                }
-                lists += '<li class="' + this.namespace + '-items page-item ' + this.classes.active + '" data-value="' + this.currentPage + '"><a class="page-link" href="javascript:void(0)">' + this.currentPage + '</a></li>';
-                for (var i = this.currentPage + 1, limit = i + this.visible - remainder - 1 > this.totalPages ? this.totalPages : i + this.visible - remainder - 1; i <= limit; i++) {
-                  lists += '<li class="' + this.namespace + '-items page-item" data-value="' + i + '"><a class="page-link" href="javascript:void(0)">' + i + '</a></li>';
-                }
-
-                return lists;
-              }
-            }
-          }
-        };
-      }
-    }]);
-    return Paginator;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Paginator);
-
-  exports.default = Paginator;
-});

public/js/vendor/Plugin/aspieprogress.js

@@ -1,71 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/aspieprogress', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginAspieprogress = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'pieProgress';
-
-  var PieProgress = function (_Plugin) {
-    babelHelpers.inherits(PieProgress, _Plugin);
-
-    function PieProgress() {
-      babelHelpers.classCallCheck(this, PieProgress);
-      return babelHelpers.possibleConstructorReturn(this, (PieProgress.__proto__ || Object.getPrototypeOf(PieProgress)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(PieProgress, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.asPieProgress) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.asPieProgress(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          namespace: 'pie-progress',
-          speed: 30,
-          classes: {
-            svg: 'pie-progress-svg',
-            element: 'pie-progress',
-            number: 'pie-progress-number',
-            content: 'pie-progress-content'
-          }
-        };
-      }
-    }]);
-    return PieProgress;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, PieProgress);
-
-  exports.default = PieProgress;
-});

public/js/vendor/Plugin/asprogress.js

@@ -1,99 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asprogress', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginAsprogress = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'progress';
-
-  var Progress = function (_Plugin) {
-    babelHelpers.inherits(Progress, _Plugin);
-
-    function Progress() {
-      babelHelpers.classCallCheck(this, Progress);
-      return babelHelpers.possibleConstructorReturn(this, (Progress.__proto__ || Object.getPrototypeOf(Progress)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Progress, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.asProgress) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.asProgress(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          bootstrap: true,
-
-          onUpdate: function onUpdate(n) {
-            var per = (n - this.min) / (this.max - this.min);
-            if (per < 0.5) {
-              this.$target.addClass('progress-bar-success').removeClass('progress-bar-warning progress-bar-danger');
-            } else if (per >= 0.5 && per < 0.8) {
-              this.$target.addClass('progress-bar-warning').removeClass('progress-bar-success progress-bar-danger');
-            } else {
-              this.$target.addClass('progress-bar-danger').removeClass('progress-bar-success progress-bar-warning');
-            }
-          },
-          labelCallback: function labelCallback(n) {
-            var label = void 0;
-            var labelType = this.$element.data('labeltype');
-
-            if (labelType === 'percentage') {
-              var percentage = this.getPercentage(n);
-              label = percentage + '%';
-            } else if (labelType === 'steps') {
-              var total = this.$element.data('totalsteps');
-              if (!total) {
-                total = 10;
-              }
-              var step = Math.round(total * (n - this.min) / (this.max - this.min));
-              label = step + ' / ' + total;
-            } else {
-              label = n;
-            }
-
-            if (this.$element.parent().hasClass('contextual-progress')) {
-              this.$element.parent().find('.progress-label').html(label);
-            }
-
-            return label;
-          }
-        };
-      }
-    }]);
-    return Progress;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Progress);
-
-  exports.default = Progress;
-});

public/js/vendor/Plugin/asrange.js

@@ -1,52 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asrange', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAsrange = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'asRange';
-
-  var AsRange = function (_Plugin) {
-    babelHelpers.inherits(AsRange, _Plugin);
-
-    function AsRange() {
-      babelHelpers.classCallCheck(this, AsRange);
-      return babelHelpers.possibleConstructorReturn(this, (AsRange.__proto__ || Object.getPrototypeOf(AsRange)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(AsRange, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          tip: false,
-          scale: false
-        };
-      }
-    }]);
-    return AsRange;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, AsRange);
-
-  exports.default = AsRange;
-});

public/js/vendor/Plugin/asscrollable.js

@@ -1,60 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asscrollable', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAsscrollable = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'scrollable';
-
-  var Scrollable = function (_Plugin) {
-    babelHelpers.inherits(Scrollable, _Plugin);
-
-    function Scrollable() {
-      babelHelpers.classCallCheck(this, Scrollable);
-      return babelHelpers.possibleConstructorReturn(this, (Scrollable.__proto__ || Object.getPrototypeOf(Scrollable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Scrollable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        var $el = this.$el;
-
-        $el.asScrollable(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          namespace: 'scrollable',
-          contentSelector: "> [data-role='content']",
-          containerSelector: "> [data-role='container']"
-        };
-      }
-    }]);
-    return Scrollable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Scrollable);
-
-  exports.default = Scrollable;
-});

public/js/vendor/Plugin/asselectable.js

@@ -1,180 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asselectable', ['exports', 'jquery'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery);
-    global.PluginAsselectable = mod.exports;
-  }
-})(this, function (exports, _jquery) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var pluginName = 'asSelectable';
-  var defaults = {
-    allSelector: '.selectable-all',
-    itemSelector: '.selectable-item',
-    rowSelector: 'tr',
-    rowSelectable: false,
-    rowActiveClass: 'active',
-    onChange: null
-  };
-
-  var asSelectable = function () {
-    function asSelectable(element, options) {
-      babelHelpers.classCallCheck(this, asSelectable);
-
-      this.element = element;
-      this.$element = (0, _jquery2.default)(element);
-      this.options = _jquery2.default.extend({}, defaults, options, this.$element.data());
-
-      this.init();
-    }
-
-    babelHelpers.createClass(asSelectable, [{
-      key: 'init',
-      value: function init() {
-        var self = this;
-        var options = this.options;
-
-        self.$element.on('change', options.allSelector, function () {
-          var value = (0, _jquery2.default)(this).prop('checked');
-          self.getItems().each(function () {
-            var $one = (0, _jquery2.default)(this);
-            $one.prop('checked', value).trigger('change', [true]);
-            self.selectRow($one, value);
-          });
-        });
-
-        self.$element.on('click', options.itemSelector, function (e) {
-          var $one = (0, _jquery2.default)(this);
-          var value = $one.prop('checked');
-          self.selectRow($one, value);
-          e.stopPropagation();
-        });
-
-        self.$element.on('change', options.itemSelector, function () {
-          var $all = self.$element.find(options.allSelector);
-          var $row = self.getItems();
-          var total = $row.length;
-          var checked = self.getSelected().length;
-
-          if (total === checked) {
-            $all.prop('checked', true);
-          } else {
-            $all.prop('checked', false);
-          }
-
-          self._trigger('change', checked);
-
-          if (typeof options.callback === 'function') {
-            options.callback.call(this);
-          }
-        });
-
-        if (options.rowSelectable) {
-          self.$element.on('click', options.rowSelector, function (e) {
-            if ('checkbox' !== e.target.type && 'button' !== e.target.type && 'a' !== e.target.tagName.toLowerCase() && !(0, _jquery2.default)(e.target).parent('div.checkbox-custom').length) {
-              var $checkbox = (0, _jquery2.default)(options.itemSelector, this);
-              var value = $checkbox.prop('checked');
-              $checkbox.prop('checked', !value);
-              self.selectRow($checkbox, !value);
-            }
-          });
-        }
-      }
-    }, {
-      key: 'selectRow',
-      value: function selectRow(item, value) {
-        if (value) {
-          item.parents(this.options.rowSelector).addClass(this.options.rowActiveClass);
-        } else {
-          item.parents(this.options.rowSelector).removeClass(this.options.rowActiveClass);
-        }
-      }
-    }, {
-      key: 'getItems',
-      value: function getItems() {
-        return this.$element.find(this.options.itemSelector);
-      }
-    }, {
-      key: 'getSelected',
-      value: function getSelected() {
-        return this.getItems().filter(':checked');
-      }
-    }, {
-      key: '_trigger',
-      value: function _trigger(eventType) {
-        var method_arguments = Array.prototype.slice.call(arguments, 1);
-        var data = [this].concat(method_arguments);
-
-        // event
-        this.$element.trigger(pluginName + '::' + eventType, data);
-
-        // callback
-        eventType = eventType.replace(/\b\w+\b/g, function (word) {
-          return word.substring(0, 1).toUpperCase() + word.substring(1);
-        });
-        var onFunction = 'on' + eventType;
-        if (typeof this.options[onFunction] === 'function') {
-          this.options[onFunction].apply(this, method_arguments);
-        }
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(options) {
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        if (typeof options === 'string') {
-          var method = options;
-
-          if (/^\_/.test(method)) {
-            return false;
-          } else if (/^(get)/.test(method)) {
-            var api = this.first().data(pluginName);
-
-            if (api && typeof api[method] === 'function') {
-              return api[method].apply(api, args);
-            }
-          } else {
-            return this.each(function () {
-              var api = _jquery2.default.data(this, pluginName);
-              if (api && typeof api[method] === 'function') {
-                api[method].apply(api, args);
-              }
-            });
-          }
-        } else {
-          return this.each(function () {
-            if (!_jquery2.default.data(this, pluginName)) {
-              _jquery2.default.data(this, pluginName, new asSelectable(this, options));
-            }
-          });
-        }
-      }
-    }]);
-    return asSelectable;
-  }();
-
-  _jquery2.default.fn[pluginName] = asSelectable._jQueryInterface;
-  _jquery2.default.fn[pluginName].constructor = asSelectable;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return asSelectable._jQueryInterface;
-  };
-
-  exports.default = asSelectable;
-});

public/js/vendor/Plugin/asspinner.js

@@ -1,55 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/asspinner', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginAsspinner = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'asSpinner';
-
-  var AsSpinner = function (_Plugin) {
-    babelHelpers.inherits(AsSpinner, _Plugin);
-
-    function AsSpinner() {
-      babelHelpers.classCallCheck(this, AsSpinner);
-      return babelHelpers.possibleConstructorReturn(this, (AsSpinner.__proto__ || Object.getPrototypeOf(AsSpinner)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(AsSpinner, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          namespace: 'spinnerUi',
-          skin: null,
-          min: '-10',
-          max: 100,
-          mousewheel: true
-        };
-      }
-    }]);
-    return AsSpinner;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, AsSpinner);
-
-  exports.default = AsSpinner;
-});

public/js/vendor/Plugin/bootbox.js

@@ -1,103 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootbox', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginBootbox = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'bootbox';
-
-  var Bootbox = function (_Plugin) {
-    babelHelpers.inherits(Bootbox, _Plugin);
-
-    function Bootbox() {
-      babelHelpers.classCallCheck(this, Bootbox);
-      return babelHelpers.possibleConstructorReturn(this, (Bootbox.__proto__ || Object.getPrototypeOf(Bootbox)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Bootbox, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$el.data('bootboxWrapApi', this);
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        if (typeof bootbox === 'undefined') {
-          return;
-        }
-
-        var options = this.options;
-
-        if (options.classname) {
-          options.className = options.classname;
-        }
-
-        if (options.className) {
-          options.className = options.className + ' modal-simple';
-        }
-
-        if (typeof options.callback === 'string' && _jquery2.default.isFunction(window[options.callback])) {
-          options.callback = window[options.callback];
-        }
-
-        if (options.type) {
-          switch (options.type) {
-            case 'alert':
-              bootbox.alert(options);
-              break;
-            case 'confirm':
-              bootbox.confirm(options);
-              break;
-            case 'prompt':
-              bootbox.prompt(options);
-              break;
-            default:
-              bootbox.dialog(options);
-          }
-        } else {
-          bootbox.dialog(options);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          message: '',
-          className: 'modal-simple'
-        };
-      }
-    }, {
-      key: 'api',
-      value: function api() {
-        return 'click|show';
-      }
-    }]);
-    return Bootbox;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Bootbox);
-
-  exports.default = Bootbox;
-});

public/js/vendor/Plugin/bootstrap-datepicker.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-datepicker', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapDatepicker = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'datepicker';
-
-  var Datepicker = function (_Plugin) {
-    babelHelpers.inherits(Datepicker, _Plugin);
-
-    function Datepicker() {
-      babelHelpers.classCallCheck(this, Datepicker);
-      return babelHelpers.possibleConstructorReturn(this, (Datepicker.__proto__ || Object.getPrototypeOf(Datepicker)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Datepicker, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          autoclose: true
-        };
-      }
-    }]);
-    return Datepicker;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Datepicker);
-
-  exports.default = Datepicker;
-});

public/js/vendor/Plugin/bootstrap-maxlength.js

@@ -1,52 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-maxlength', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapMaxlength = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'maxlength';
-
-  var Maxlength = function (_Plugin) {
-    babelHelpers.inherits(Maxlength, _Plugin);
-
-    function Maxlength() {
-      babelHelpers.classCallCheck(this, Maxlength);
-      return babelHelpers.possibleConstructorReturn(this, (Maxlength.__proto__ || Object.getPrototypeOf(Maxlength)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Maxlength, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          warningClass: 'badge badge-warning',
-          limitReachedClass: 'badge badge-danger'
-        };
-      }
-    }]);
-    return Maxlength;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Maxlength);
-
-  exports.default = Maxlength;
-});

public/js/vendor/Plugin/bootstrap-select.js

@@ -1,53 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-select', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapSelect = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'selectpicker';
-
-  var Selectpicker = function (_Plugin) {
-    babelHelpers.inherits(Selectpicker, _Plugin);
-
-    function Selectpicker() {
-      babelHelpers.classCallCheck(this, Selectpicker);
-      return babelHelpers.possibleConstructorReturn(this, (Selectpicker.__proto__ || Object.getPrototypeOf(Selectpicker)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Selectpicker, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          style: 'btn-select',
-          iconBase: 'icon',
-          tickIcon: 'wb-check'
-        };
-      }
-    }]);
-    return Selectpicker;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Selectpicker);
-
-  exports.default = Selectpicker;
-});

public/js/vendor/Plugin/bootstrap-sweetalert.js

@@ -1,63 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-sweetalert', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapSweetalert = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'sweetalert';
-
-  var Sweetalert = function (_Plugin) {
-    babelHelpers.inherits(Sweetalert, _Plugin);
-
-    function Sweetalert() {
-      babelHelpers.classCallCheck(this, Sweetalert);
-      return babelHelpers.possibleConstructorReturn(this, (Sweetalert.__proto__ || Object.getPrototypeOf(Sweetalert)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Sweetalert, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$el.data('sweetalertWrapApi', this);
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        if (typeof swal === 'undefined') {
-          return;
-        }
-
-        swal(this.options);
-      }
-    }], [{
-      key: 'api',
-      value: function api() {
-        return 'click|show';
-      }
-    }]);
-    return Sweetalert;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Sweetalert);
-
-  exports.default = Sweetalert;
-});

public/js/vendor/Plugin/bootstrap-tagsinput.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-tagsinput', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapTagsinput = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'tagsinput';
-
-  var Tagsinput = function (_Plugin) {
-    babelHelpers.inherits(Tagsinput, _Plugin);
-
-    function Tagsinput() {
-      babelHelpers.classCallCheck(this, Tagsinput);
-      return babelHelpers.possibleConstructorReturn(this, (Tagsinput.__proto__ || Object.getPrototypeOf(Tagsinput)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Tagsinput, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          tagClass: 'badge badge-default'
-        };
-      }
-    }]);
-    return Tagsinput;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Tagsinput);
-
-  exports.default = Tagsinput;
-});

public/js/vendor/Plugin/bootstrap-tokenfield.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-tokenfield', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapTokenfield = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'tokenfield';
-
-  var Tokenfield = function (_Plugin) {
-    babelHelpers.inherits(Tokenfield, _Plugin);
-
-    function Tokenfield() {
-      babelHelpers.classCallCheck(this, Tokenfield);
-      return babelHelpers.possibleConstructorReturn(this, (Tokenfield.__proto__ || Object.getPrototypeOf(Tokenfield)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Tokenfield, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Tokenfield;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Tokenfield);
-
-  exports.default = Tokenfield;
-});

public/js/vendor/Plugin/bootstrap-touchspin.js

@@ -1,54 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-touchspin', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginBootstrapTouchspin = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'TouchSpin';
-
-  var TouchSpin = function (_Plugin) {
-    babelHelpers.inherits(TouchSpin, _Plugin);
-
-    function TouchSpin() {
-      babelHelpers.classCallCheck(this, TouchSpin);
-      return babelHelpers.possibleConstructorReturn(this, (TouchSpin.__proto__ || Object.getPrototypeOf(TouchSpin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(TouchSpin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          verticalupclass: 'wb-plus',
-          verticaldownclass: 'wb-minus',
-          buttondown_class: 'btn btn-outline btn-default',
-          buttonup_class: 'btn btn-outline btn-default'
-        };
-      }
-    }]);
-    return TouchSpin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, TouchSpin);
-
-  exports.default = TouchSpin;
-});

public/js/vendor/Plugin/bootstrap-treeview.js

@@ -1,87 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/bootstrap-treeview', ['exports', 'jquery', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin, global.Config);
-    global.PluginBootstrapTreeview = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'treeview';
-
-  var Treeview = function (_Plugin) {
-    babelHelpers.inherits(Treeview, _Plugin);
-
-    function Treeview() {
-      babelHelpers.classCallCheck(this, Treeview);
-      return babelHelpers.possibleConstructorReturn(this, (Treeview.__proto__ || Object.getPrototypeOf(Treeview)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Treeview, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.treeview) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (typeof options.source === 'string' && _jquery2.default.isFunction(window[options.source])) {
-          options.data = window[options.source]();
-          delete options.source;
-        } else if (_jquery2.default.isFunction(options.souce)) {
-          options.data = options.source();
-          delete options.source;
-        }
-
-        $el.treeview(options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          injectStyle: false,
-          expandIcon: 'icon wb-plus',
-          collapseIcon: 'icon wb-minus',
-          emptyIcon: 'icon',
-          nodeIcon: 'icon wb-folder',
-          showBorder: false,
-          // color: undefined, // "#000000",
-          // backColor: undefined, // "#FFFFFF",
-          borderColor: (0, _Config.colors)('blue-grey', 200),
-          onhoverColor: (0, _Config.colors)('blue-grey', 100),
-          selectedColor: '#ffffff',
-          selectedBackColor: (0, _Config.colors)('primary', 600),
-
-          searchResultColor: (0, _Config.colors)('primary', 600),
-          searchResultBackColor: '#ffffff'
-        };
-      }
-    }]);
-    return Treeview;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Treeview);
-
-  exports.default = Treeview;
-});

public/js/vendor/Plugin/card.js

@@ -1,66 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/card', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginCard = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'card';
-
-  var Card = function (_Plugin) {
-    babelHelpers.inherits(Card, _Plugin);
-
-    function Card() {
-      babelHelpers.classCallCheck(this, Card);
-      return babelHelpers.possibleConstructorReturn(this, (Card.__proto__ || Object.getPrototypeOf(Card)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Card, [{
-      key: 'getName',
-      value: function getName() {
-        return;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.card) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.target) {
-          options.container = (0, _jquery2.default)(options.target);
-        }
-        $el.card(options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Card;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Card);
-
-  exports.default = Card;
-});

public/js/vendor/Plugin/clockpicker.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/clockpicker', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginClockpicker = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'clockpicker';
-
-  var Clockpicker = function (_Plugin) {
-    babelHelpers.inherits(Clockpicker, _Plugin);
-
-    function Clockpicker() {
-      babelHelpers.classCallCheck(this, Clockpicker);
-      return babelHelpers.possibleConstructorReturn(this, (Clockpicker.__proto__ || Object.getPrototypeOf(Clockpicker)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Clockpicker, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          donetext: 'Done'
-        };
-      }
-    }]);
-    return Clockpicker;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Clockpicker);
-
-  exports.default = Clockpicker;
-});

public/js/vendor/Plugin/closeable-tabs.js

@@ -1,107 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/closeable-tabs', ['exports', 'jquery'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery);
-    global.PluginCloseableTabs = mod.exports;
-  }
-})(this, function (exports, _jquery) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var pluginName = 'tabClose';
-  var dismiss = '[data-close="tab"]';
-
-  var TabClose = function () {
-    function TabClose(el) {
-      babelHelpers.classCallCheck(this, TabClose);
-
-      (0, _jquery2.default)(el).on('click', dismiss, this.close);
-    }
-
-    babelHelpers.createClass(TabClose, [{
-      key: 'close',
-      value: function close(e) {
-        var $this = (0, _jquery2.default)(this);
-        var $toggle = $this.closest('[data-toggle="tab"]');
-        var selector = $toggle.data('target');
-        var $li = $toggle.parent('li');
-
-        if (!selector) {
-          selector = $toggle.attr('href');
-          selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '');
-        }
-
-        if ($toggle.hasClass('active')) {
-          var $next = $li.siblings().eq(0).children('[data-toggle="tab"]');
-          if ($next.length > 0) {
-            var api = $next.tab().data('bs.tab');
-            api.show();
-          }
-        }
-
-        var $parent = (0, _jquery2.default)(selector);
-        if (e) e.preventDefault();
-
-        $parent.trigger(e = _jquery2.default.Event('close.bs.tab'));
-
-        if (e.isDefaultPrevented()) return;
-
-        $parent.removeClass('in');
-
-        function removeElement() {
-          // detach from parent, fire event then clean up data
-          $parent.detach().trigger('closed.bs.tab').remove();
-          $li.detach().remove();
-        }
-
-        _jquery2.default.support.transition && $parent.hasClass('fade') ? $parent.one('bsTransitionEnd', removeElement).emulateTransitionEnd(TabClose.TRANSITION_DURATION) : removeElement();
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(option) {
-        console.log(option);
-        return this.each(function () {
-          var $this = (0, _jquery2.default)(this);
-          var data = $this.data('bs.tab.close');
-
-          if (!data) {
-            $this.data('bs.tab.close', data = new TabClose(this));
-          }
-          if (typeof option == 'string') {
-            data[option].call($this);
-          }
-        });
-      }
-    }]);
-    return TabClose;
-  }();
-
-  TabClose.TRANSITION_DURATION = 150;
-
-  _jquery2.default.fn[pluginName] = TabClose._jQueryInterface;
-  _jquery2.default.fn[pluginName].Constructor = TabClose;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return asSelectable._jQueryInterface;
-  };
-
-  // TAB CLOSE DATA-API
-  // ==================
-
-  (0, _jquery2.default)(document).on('click.bs.tab-close.data-api', dismiss, TabClose.prototype.close);
-
-  exports.default = TabClose;
-});

public/js/vendor/Plugin/datatables.js

@@ -1,90 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/datatables', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginDatatables = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'dataTable';
-
-  var DataTable = function (_Plugin) {
-    babelHelpers.inherits(DataTable, _Plugin);
-
-    function DataTable() {
-      babelHelpers.classCallCheck(this, DataTable);
-      return babelHelpers.possibleConstructorReturn(this, (DataTable.__proto__ || Object.getPrototypeOf(DataTable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(DataTable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.dataTable) {
-          return;
-        }
-
-        // if ($.fn.dataTable.TableTools) {
-        //   // Set the classes that TableTools uses to something suitable for Bootstrap
-        //   $.extend(true, $.fn.dataTable.TableTools.classes, {
-        //     container: 'DTTT btn-group btn-group float-left',
-        //     buttons: {
-        //       normal: 'btn btn-outline btn-default',
-        //       disabled: 'disabled'
-        //     },
-        //     print: {
-        //       body: 'site-print DTTT_Print'
-        //     }
-        //   });
-        // }
-
-        this.$el.dataTable(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          responsive: true,
-          language: {
-            lengthMenu: '_MENU_',
-            searchPlaceholder: 'Search..',
-            search: "_INPUT_"
-            // ,paginate: {
-            //   previous: '<i class="icon wb-chevron-left-mini"></i>',
-            //   next: '<i class="icon wb-chevron-right-mini"></i>'
-            // }
-
-            // ,
-            // classes: {
-            //   sFilterInput: "form-control form-control-sm",
-            //   sLengthSelect: "form-control form-control-sm"
-            // }
-          } };
-      }
-    }]);
-    return DataTable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, DataTable);
-
-  exports.default = DataTable;
-});

public/js/vendor/Plugin/datepair.js

@@ -1,54 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/datepair', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginDatepair = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'datepair';
-
-  var Datepair = function (_Plugin) {
-    babelHelpers.inherits(Datepair, _Plugin);
-
-    function Datepair() {
-      babelHelpers.classCallCheck(this, Datepair);
-      return babelHelpers.possibleConstructorReturn(this, (Datepair.__proto__ || Object.getPrototypeOf(Datepair)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Datepair, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          startClass: 'datepair-start',
-          endClass: 'datepair-end',
-          timeClass: 'datepair-time',
-          dateClass: 'datepair-date'
-        };
-      }
-    }]);
-    return Datepair;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Datepair);
-
-  exports.default = Datepair;
-});

public/js/vendor/Plugin/donut.js

@@ -1,91 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/donut', ['exports', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin, global.Config);
-    global.PluginDonut = mod.exports;
-  }
-})(this, function (exports, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'donut';
-
-  var DonutPlugin = function (_Plugin) {
-    babelHelpers.inherits(DonutPlugin, _Plugin);
-
-    function DonutPlugin() {
-      babelHelpers.classCallCheck(this, DonutPlugin);
-      return babelHelpers.possibleConstructorReturn(this, (DonutPlugin.__proto__ || Object.getPrototypeOf(DonutPlugin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(DonutPlugin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!Gauge) {
-          return;
-        }
-
-        var $el = this.$el;
-        var $canvas = $el.find('canvas'),
-            $text = $el.find('.donut-label');
-
-        if ($canvas.length === 0) {
-          return;
-        }
-
-        var donut = new Donut($canvas[0]).setOptions(this.options);
-
-        $el.data('donut', donut);
-
-        donut.animationSpeed = 50;
-        donut.maxValue = $el.data('max-value');
-
-        donut.set($el.data('value'));
-
-        if ($text.length > 0) {
-          donut.setTextField($text[0]);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          lines: 12,
-          angle: 0.3,
-          lineWidth: 0.08,
-          pointer: {
-            length: 0.9,
-            strokeWidth: 0.035,
-            color: (0, _Config.colors)('blue-grey', 400)
-          },
-          limitMax: false, // If true, the pointer will not go past the end of the gauge
-          colorStart: (0, _Config.colors)('blue-grey', 200),
-          colorStop: (0, _Config.colors)('blue-grey', 200),
-          strokeColor: (0, _Config.colors)('primary', 500),
-          generateGradient: true
-        };
-      }
-    }]);
-    return DonutPlugin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, DonutPlugin);
-
-  exports.default = DonutPlugin;
-});

public/js/vendor/Plugin/dropify.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/dropify', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginDropify = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'dropify';
-
-  var Dropify = function (_Plugin) {
-    babelHelpers.inherits(Dropify, _Plugin);
-
-    function Dropify() {
-      babelHelpers.classCallCheck(this, Dropify);
-      return babelHelpers.possibleConstructorReturn(this, (Dropify.__proto__ || Object.getPrototypeOf(Dropify)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Dropify, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Dropify;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Dropify);
-
-  exports.default = Dropify;
-});

public/js/vendor/Plugin/editable-table.js

@@ -1,62 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/editable-table', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginEditableTable = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'editableTable';
-
-  var EditableTable = function (_Plugin) {
-    babelHelpers.inherits(EditableTable, _Plugin);
-
-    function EditableTable() {
-      babelHelpers.classCallCheck(this, EditableTable);
-      return babelHelpers.possibleConstructorReturn(this, (EditableTable.__proto__ || Object.getPrototypeOf(EditableTable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(EditableTable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.editableTableWidget) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.editableTableWidget(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return EditableTable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, EditableTable);
-
-  exports.default = EditableTable;
-});

public/js/vendor/Plugin/editlist.js

@@ -1,176 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/editlist', ['exports', 'jquery', 'bootbox', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('bootbox'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.bootbox, global.Plugin);
-    global.PluginEditlist = mod.exports;
-  }
-})(this, function (exports, _jquery, _bootbox, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _bootbox2 = babelHelpers.interopRequireDefault(_bootbox);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var pluginName = 'editlist';
-  var defaults = {};
-
-  var editlist = function () {
-    function editlist(element, options) {
-      babelHelpers.classCallCheck(this, editlist);
-
-      this.element = element;
-      this.$element = (0, _jquery2.default)(element);
-      this.$content = this.$element.find('.list-content');
-      this.$text = this.$element.find('.list-text');
-      this.$editable = this.$element.find('.list-editable');
-      this.$editBtn = this.$element.find('[data-toggle=list-editable]');
-      this.$delBtn = this.$element.find('[data-toggle=list-delete]');
-      this.$closeBtn = this.$element.find('[data-toggle=list-editable-close]');
-      this.$input = this.$element.find('input');
-      this.options = _jquery2.default.extend({}, _Plugin3.default.defaults, options, this.$element.data());
-      this.init();
-    }
-
-    babelHelpers.createClass(editlist, [{
-      key: 'init',
-      value: function init() {
-        this.bind();
-      }
-    }, {
-      key: 'bind',
-      value: function bind() {
-        var self = this;
-        this.$editBtn.on('click', function () {
-          self.enable();
-        });
-
-        this.$closeBtn.on('click', function () {
-          self.disable();
-        });
-
-        this.$delBtn.on('click', function () {
-          if (typeof _bootbox2.default === 'undefined') return;
-          _bootbox2.default.dialog({
-            message: 'Do you want to delete the contact?',
-            buttons: {
-              success: {
-                label: 'Delete',
-                className: 'btn-danger',
-                callback: function callback() {
-                  self.$element.remove();
-                }
-              }
-            }
-          });
-        });
-        this.$input.on('keydown', function (e) {
-          var keycode = e.keyCode ? e.keyCode : e.which;
-
-          if (keycode == 13 || keycode == 27) {
-            if (keycode == 13) {
-              self.$text.html(self.$input.val());
-            } else {
-              self.$input.val(self.$text.text());
-            }
-
-            self.disable();
-          }
-        });
-      }
-    }, {
-      key: 'enable',
-      value: function enable() {
-        this.$content.hide();
-        this.$editable.show();
-        this.$input.focus().select();
-      }
-    }, {
-      key: 'disable',
-      value: function disable() {
-        this.$content.show();
-        this.$editable.hide();
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(options) {
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        if (typeof options === 'string') {
-          var method = options;
-
-          if (/^\_/.test(method)) {
-            return false;
-          } else if (/^(get)$/.test(method)) {
-            var api = this.first().data(pluginName);
-            if (api && typeof api[method] === 'function') {
-              return api[method].apply(api, args);
-            }
-          } else {
-            return this.each(function () {
-              var api = _jquery2.default.data(this, pluginName);
-              if (api && typeof api[method] === 'function') {
-                api[method].apply(api, args);
-              }
-            });
-          }
-        } else {
-          return this.each(function () {
-            if (!_jquery2.default.data(this, pluginName)) {
-              _jquery2.default.data(this, pluginName, new editlist(this, options));
-            }
-          });
-        }
-      }
-    }]);
-    return editlist;
-  }();
-
-  _jquery2.default.fn[pluginName] = editlist._jQueryInterface;
-  _jquery2.default.fn[pluginName].constructor = editlist;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return editlist._jQueryInterface;
-  };
-
-  var Editlist = function (_Plugin) {
-    babelHelpers.inherits(Editlist, _Plugin);
-
-    function Editlist() {
-      babelHelpers.classCallCheck(this, Editlist);
-      return babelHelpers.possibleConstructorReturn(this, (Editlist.__proto__ || Object.getPrototypeOf(Editlist)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Editlist, [{
-      key: 'getName',
-      value: function getName() {
-        return pluginName;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return defaults;
-      }
-    }]);
-    return Editlist;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(pluginName, Editlist);
-
-  exports.default = Editlist;
-});

public/js/vendor/Plugin/filterable.js

@@ -1,95 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/filterable', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginFilterable = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'filterable';
-
-  var Filterable = function (_Plugin) {
-    babelHelpers.inherits(Filterable, _Plugin);
-
-    function Filterable() {
-      babelHelpers.classCallCheck(this, Filterable);
-      return babelHelpers.possibleConstructorReturn(this, (Filterable.__proto__ || Object.getPrototypeOf(Filterable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Filterable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof _jquery2.default.fn.isotope === 'undefined') {
-          return;
-        }
-
-        var $el = this.$el,
-            options = _jquery2.default.extend(this.options, {
-          filter: '*'
-        });
-
-        this.$el.isotope(options);
-        this.$filters = (0, _jquery2.default)(options.filters);
-
-        var self = this;
-
-        (0, _jquery2.default)('[data-filter]', this.$filters).on('click', function (e) {
-          var $this = (0, _jquery2.default)(this);
-          var $li = $this.parent('li');
-
-          $li.siblings().find('.nav-link.active').each(function () {
-            (0, _jquery2.default)(this).attr('aria-expanded', false).removeClass('active');
-          });
-
-          $this.addClass('active').attr('aria-expanded', true);
-
-          var filter = $this.attr('data-filter');
-          if (filter !== '*') {
-            filter = '[data-type="' + filter + '"]';
-          }
-          self.$el.isotope({
-            filter: filter
-          });
-
-          e.preventDefault();
-        });
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          animationOptions: {
-            duration: 750,
-            easing: 'linear',
-            queue: false
-          }
-        };
-      }
-    }]);
-    return Filterable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Filterable);
-
-  exports.default = Filterable;
-});

public/js/vendor/Plugin/floatthead.js

@@ -1,61 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/floatthead', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginFloatthead = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'floatThead';
-
-  var FloatThead = function (_Plugin) {
-    babelHelpers.inherits(FloatThead, _Plugin);
-
-    function FloatThead() {
-      babelHelpers.classCallCheck(this, FloatThead);
-      return babelHelpers.possibleConstructorReturn(this, (FloatThead.__proto__ || Object.getPrototypeOf(FloatThead)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(FloatThead, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          position: 'auto',
-          top: function top() {
-            var offset = (0, _jquery2.default)('.page').offset();
-
-            return offset.top;
-          },
-          responsiveContainer: function responsiveContainer($table) {
-            return $table.closest('.table-responsive');
-          }
-        };
-      }
-    }]);
-    return FloatThead;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, FloatThead);
-
-  exports.default = FloatThead;
-});

public/js/vendor/Plugin/formatter.js

@@ -1,72 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/formatter', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginFormatter = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'formatter';
-
-  var Formatter = function (_Plugin) {
-    babelHelpers.inherits(Formatter, _Plugin);
-
-    function Formatter() {
-      babelHelpers.classCallCheck(this, Formatter);
-      return babelHelpers.possibleConstructorReturn(this, (Formatter.__proto__ || Object.getPrototypeOf(Formatter)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Formatter, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.formatter) {
-          return;
-        }
-
-        var browserName = navigator.userAgent.toLowerCase();
-
-        if (/msie/i.test(browserName) && !/opera/.test(browserName)) {} else {}
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.pattern) {
-          options.pattern = options.pattern.replace(/\[\[/g, '{{').replace(/\]\]/g, '}}');
-        }
-        $el.formatter(options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          persistent: true
-        };
-      }
-    }]);
-    return Formatter;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Formatter);
-
-  exports.default = Formatter;
-});

public/js/vendor/Plugin/gauge.js

@@ -1,91 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/gauge', ['exports', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin, global.Config);
-    global.PluginGauge = mod.exports;
-  }
-})(this, function (exports, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'gauge';
-
-  var GaugePlugin = function (_Plugin) {
-    babelHelpers.inherits(GaugePlugin, _Plugin);
-
-    function GaugePlugin() {
-      babelHelpers.classCallCheck(this, GaugePlugin);
-      return babelHelpers.possibleConstructorReturn(this, (GaugePlugin.__proto__ || Object.getPrototypeOf(GaugePlugin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(GaugePlugin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!Gauge) {
-          return;
-        }
-
-        var $el = this.$el;
-        var $canvas = $el.find('canvas'),
-            $text = $el.find('.gauge-label');
-
-        if ($canvas.length === 0) {
-          return;
-        }
-
-        var gauge = new Gauge($canvas[0]).setOptions(this.options);
-
-        $el.data('gauge', gauge);
-
-        gauge.animationSpeed = 50;
-        gauge.maxValue = $el.data('max-value');
-
-        gauge.set($el.data('value'));
-
-        if ($text.length > 0) {
-          gauge.setTextField($text[0]);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          lines: 12,
-          angle: 0.2,
-          lineWidth: 0.4,
-          pointer: {
-            length: 0.58,
-            strokeWidth: 0.03,
-            color: (0, _Config.colors)('blue-grey', 400)
-          },
-          limitMax: true,
-          colorStart: (0, _Config.colors)('blue-grey', 200),
-          colorStop: (0, _Config.colors)('blue-grey', 200),
-          strokeColor: (0, _Config.colors)('primary', 500),
-          generateGradient: true
-        };
-      }
-    }]);
-    return GaugePlugin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, GaugePlugin);
-
-  exports.default = GaugePlugin;
-});

public/js/vendor/Plugin/gmaps.js

@@ -1,250 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/gmaps', ['exports', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin, global.Config);
-    global.PluginGmaps = mod.exports;
-  }
-})(this, function (exports, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'gmaps';
-
-  var GmapsPlugin = function (_Plugin) {
-    babelHelpers.inherits(GmapsPlugin, _Plugin);
-
-    function GmapsPlugin() {
-      babelHelpers.classCallCheck(this, GmapsPlugin);
-      return babelHelpers.possibleConstructorReturn(this, (GmapsPlugin.__proto__ || Object.getPrototypeOf(GmapsPlugin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(GmapsPlugin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {}
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          styles: [{
-            featureType: 'landscape',
-            elementType: 'all',
-            stylers: [{
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'all',
-            stylers: [{
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'road',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '700')
-            }]
-          }, {
-            featureType: 'administrative',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '500')
-            }]
-          }, {
-            featureType: 'road.highway',
-            elementType: 'geometry.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '300')
-            }]
-          }, {
-            featureType: 'road.arterial',
-            elementType: 'geometry.fill',
-            stylers: [{
-              color: '#e0e0e0'
-            }]
-          }, {
-            featureType: 'water',
-            elementType: 'geometry.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '200')
-            }]
-          }, {
-            featureType: 'water',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: '#000000'
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '500')
-            }]
-          }, {
-            featureType: 'road',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              visibility: 'off'
-            }]
-          }, {
-            featureType: 'poi.attraction',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              visibility: 'off'
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              visibility: 'off'
-            }]
-          }, {
-            featureType: 'road.local',
-            elementType: 'all',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '200')
-            }, {
-              weight: 0.5
-            }]
-          }, {
-            featureType: 'road.arterial',
-            elementType: 'geometry',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '300')
-            }]
-          }, {
-            featureType: 'road.arterial',
-            elementType: 'geometry.stroke',
-            stylers: [{
-              visibility: 'off'
-            }]
-          }, {
-            featureType: 'road.highway',
-            elementType: 'geometry.stroke',
-            stylers: [{
-              visibility: 'off'
-            }, {
-              color: '#000000'
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'all',
-            stylers: [{
-              visibility: 'off'
-            }, {
-              color: '#000000'
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'labels.text',
-            stylers: [{
-              visibility: 'on'
-            }, {
-              color: (0, _Config.colors)('blue-grey', '700')
-            }]
-          }, {
-            featureType: 'road.local',
-            elementType: 'labels.text',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '700')
-            }]
-          }, {
-            featureType: 'transit',
-            elementType: 'all',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '100')
-            }]
-          }, {
-            featureType: 'transit.station',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '500')
-            }]
-          }, {
-            featureType: 'road',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              visibility: 'off'
-            }]
-          }, {
-            featureType: 'road',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '600')
-            }]
-          }, {
-            featureType: 'administrative.neighborhood',
-            elementType: 'labels.text',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '700')
-            }]
-          }, {
-            featureType: 'poi',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'road.highway',
-            elementType: 'labels.icon',
-            stylers: [{
-              visibility: 'on'
-            }, {
-              hue: '#ffffff'
-            }, {
-              saturation: -100
-            }, {
-              lightness: 50
-            }]
-          }, {
-            featureType: 'water',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              visibility: 'on'
-            }, {
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'administrative.neighborhood',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'administrative',
-            elementType: 'labels.text.stroke',
-            stylers: [{
-              color: '#ffffff'
-            }]
-          }, {
-            featureType: 'water',
-            elementType: 'labels.text.fill',
-            stylers: [{
-              color: (0, _Config.colors)('blue-grey', '600')
-            }]
-          }]
-        };
-      }
-    }]);
-    return GmapsPlugin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, GmapsPlugin);
-
-  exports.default = GmapsPlugin;
-});

public/js/vendor/Plugin/gridstack.js

@@ -1,65 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/gridstack', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginGridstack = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'gridstack';
-
-  var Gridstack = function (_Plugin) {
-    babelHelpers.inherits(Gridstack, _Plugin);
-
-    function Gridstack() {
-      babelHelpers.classCallCheck(this, Gridstack);
-      return babelHelpers.possibleConstructorReturn(this, (Gridstack.__proto__ || Object.getPrototypeOf(Gridstack)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Gridstack, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.gridstack) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.gridstack(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          cellHeight: 80,
-          verticalMargin: 20
-        };
-      }
-    }]);
-    return Gridstack;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Gridstack);
-
-  exports.default = Gridstack;
-});

public/js/vendor/Plugin/highlight.js

@@ -1,56 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/highlight', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginHighlight = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'highlight';
-
-  var Highlight = function (_Plugin) {
-    babelHelpers.inherits(Highlight, _Plugin);
-
-    function Highlight() {
-      babelHelpers.classCallCheck(this, Highlight);
-      return babelHelpers.possibleConstructorReturn(this, (Highlight.__proto__ || Object.getPrototypeOf(Highlight)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Highlight, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        hljs.initHighlightingOnLoad();
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Highlight;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Highlight);
-
-  exports.default = Highlight;
-});

public/js/vendor/Plugin/html5sortable.js

@@ -1,63 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/html5sortable', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginHtml5sortable = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'sortable';
-
-  var Sortable = function (_Plugin) {
-    babelHelpers.inherits(Sortable, _Plugin);
-
-    function Sortable() {
-      babelHelpers.classCallCheck(this, Sortable);
-      return babelHelpers.possibleConstructorReturn(this, (Sortable.__proto__ || Object.getPrototypeOf(Sortable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Sortable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        sortable(this.$el.get(0), this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          connectWith: false,
-          placeholder: null,
-          // dragImage can be null or a Element
-          dragImage: null,
-          disableIEFix: false,
-          placeholderClass: 'sortable-placeholder',
-          draggingClass: 'sortable-dragging',
-          hoverClass: false
-        };
-      }
-    }]);
-    return Sortable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Sortable);
-
-  exports.default = Sortable;
-});

public/js/vendor/Plugin/icheck.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/icheck', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginIcheck = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'iCheck';
-
-  var ICheck = function (_Plugin) {
-    babelHelpers.inherits(ICheck, _Plugin);
-
-    function ICheck() {
-      babelHelpers.classCallCheck(this, ICheck);
-      return babelHelpers.possibleConstructorReturn(this, (ICheck.__proto__ || Object.getPrototypeOf(ICheck)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(ICheck, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return ICheck;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, ICheck);
-
-  exports.default = ICheck;
-});

public/js/vendor/Plugin/input-group-file.js

@@ -1,69 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/input-group-file', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginInputGroupFile = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'inputGroupFile';
-
-  var InputGroupFile = function (_Plugin) {
-    babelHelpers.inherits(InputGroupFile, _Plugin);
-
-    function InputGroupFile() {
-      babelHelpers.classCallCheck(this, InputGroupFile);
-      return babelHelpers.possibleConstructorReturn(this, (InputGroupFile.__proto__ || Object.getPrototypeOf(InputGroupFile)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(InputGroupFile, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$file = this.$el.find('[type=file]');
-        this.$text = this.$el.find('.form-control');
-      }
-    }, {
-      key: 'change',
-      value: function change() {
-        var value = '';
-        _jquery2.default.each(this.$file[0].files, function (i, file) {
-          value += file.name + ', ';
-        });
-
-        value = value.substring(0, value.length - 2);
-
-        this.$text.val(value);
-      }
-    }], [{
-      key: 'api',
-      value: function api() {
-        return 'change|change';
-      }
-    }]);
-    return InputGroupFile;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, InputGroupFile);
-
-  exports.default = InputGroupFile;
-});

public/js/vendor/Plugin/ionrangeslider.js

@@ -1,44 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/ionrangeslider', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginIonrangeslider = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'ionRangeSlider';
-
-  var IonRangeSlider = function (_Plugin) {
-    babelHelpers.inherits(IonRangeSlider, _Plugin);
-
-    function IonRangeSlider() {
-      babelHelpers.classCallCheck(this, IonRangeSlider);
-      return babelHelpers.possibleConstructorReturn(this, (IonRangeSlider.__proto__ || Object.getPrototypeOf(IonRangeSlider)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(IonRangeSlider, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }]);
-    return IonRangeSlider;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, IonRangeSlider);
-
-  exports.default = IonRangeSlider;
-});

public/js/vendor/Plugin/isotope.js

@@ -1,73 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/isotope', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginIsotope = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'isotope';
-
-  var Isotope = function (_Plugin) {
-    babelHelpers.inherits(Isotope, _Plugin);
-
-    function Isotope() {
-      babelHelpers.classCallCheck(this, Isotope);
-      return babelHelpers.possibleConstructorReturn(this, (Isotope.__proto__ || Object.getPrototypeOf(Isotope)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Isotope, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        var _this2 = this;
-
-        if (typeof _jquery2.default.fn.isotope === 'undefined') {
-          return;
-        }
-
-        var callback = function callback() {
-          var $el = _this2.$el;
-
-          $el.isotope(_this2.options);
-        };
-        if (this !== document) {
-          callback();
-        } else {
-          (0, _jquery2.default)(window).on('load', function () {
-            callback();
-          });
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Isotope;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Isotope);
-
-  exports.default = Isotope;
-});

public/js/vendor/Plugin/jquery-appear.js

@@ -1,82 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-appear', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginJqueryAppear = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'appear';
-
-  var Appear = function (_Plugin) {
-    babelHelpers.inherits(Appear, _Plugin);
-
-    function Appear() {
-      babelHelpers.classCallCheck(this, Appear);
-      return babelHelpers.possibleConstructorReturn(this, (Appear.__proto__ || Object.getPrototypeOf(Appear)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Appear, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'bind',
-      value: function bind() {
-        var _this2 = this;
-
-        this.$el.on('appear', function () {
-          if (_this2.$el.hasClass('appear-no-repeat')) {
-            return;
-          }
-          _this2.$el.removeClass('invisible').addClass('animation-' + _this2.options.animate);
-
-          if (_this2.$el.data('repeat') === false) {
-            _this2.$el.addClass('appear-no-repeat');
-          }
-        });
-
-        (0, _jquery2.default)(document).on('disappear', function () {
-          if (_this2.$el.hasClass('appear-no-repeat')) {
-            return;
-          }
-
-          _this2.$el.addClass('invisible').removeClass('animation-' + _this2.options.animate);
-        });
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.appear) {
-          return;
-        }
-
-        this.$el.appear(this.options);
-        this.$el.not(':appeared').addClass('invisible');
-
-        this.bind();
-      }
-    }]);
-    return Appear;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Appear);
-
-  exports.default = Appear;
-});

public/js/vendor/Plugin/jquery-knob.js

@@ -1,55 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-knob', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJqueryKnob = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'knob';
-
-  var Knob = function (_Plugin) {
-    babelHelpers.inherits(Knob, _Plugin);
-
-    function Knob() {
-      babelHelpers.classCallCheck(this, Knob);
-      return babelHelpers.possibleConstructorReturn(this, (Knob.__proto__ || Object.getPrototypeOf(Knob)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Knob, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          min: -50,
-          max: 50,
-          width: 120,
-          height: 120,
-          thickness: '.1'
-        };
-      }
-    }]);
-    return Knob;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Knob);
-
-  exports.default = Knob;
-});

public/js/vendor/Plugin/jquery-labelauty.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-labelauty', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJqueryLabelauty = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'labelauty';
-
-  var Labelauty = function (_Plugin) {
-    babelHelpers.inherits(Labelauty, _Plugin);
-
-    function Labelauty() {
-      babelHelpers.classCallCheck(this, Labelauty);
-      return babelHelpers.possibleConstructorReturn(this, (Labelauty.__proto__ || Object.getPrototypeOf(Labelauty)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Labelauty, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          same_width: true
-        };
-      }
-    }]);
-    return Labelauty;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Labelauty);
-
-  exports.default = Labelauty;
-});

public/js/vendor/Plugin/jquery-placeholder.js

@@ -1,62 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-placeholder', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginJqueryPlaceholder = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'placeholder';
-
-  var Placeholder = function (_Plugin) {
-    babelHelpers.inherits(Placeholder, _Plugin);
-
-    function Placeholder() {
-      babelHelpers.classCallCheck(this, Placeholder);
-      return babelHelpers.possibleConstructorReturn(this, (Placeholder.__proto__ || Object.getPrototypeOf(Placeholder)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Placeholder, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.placeholder) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.placeholder();
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Placeholder;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Placeholder);
-
-  exports.default = Placeholder;
-});

public/js/vendor/Plugin/jquery-strength.js

@@ -1,82 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-strength', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJqueryStrength = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'strength';
-
-  var Strength = function (_Plugin) {
-    babelHelpers.inherits(Strength, _Plugin);
-
-    function Strength() {
-      babelHelpers.classCallCheck(this, Strength);
-      return babelHelpers.possibleConstructorReturn(this, (Strength.__proto__ || Object.getPrototypeOf(Strength)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Strength, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          showMeter: true,
-          showToggle: false,
-
-          templates: {
-            toggle: '<div class="checkbox-custom checkbox-primary show-password-wrap"><input type="checkbox" class="{toggleClass}" title="Show/Hide Password" id="show_password" /><label for="show_password">Show Password</label></div>',
-            meter: '<div class="{meterClass}">{score}</div>',
-            score: '<div class="{scoreClass}"></div>',
-            main: '<div class="{containerClass}">{input}{meter}{toggle}</div>'
-          },
-
-          classes: {
-            container: 'strength-container',
-            status: 'strength-{status}',
-            input: 'strength-input',
-            toggle: 'strength-toggle',
-            meter: 'strength-meter',
-            score: 'strength-score'
-          },
-
-          scoreLables: {
-            invalid: 'Invalid',
-            weak: 'Weak',
-            good: 'Good',
-            strong: 'Strong'
-          },
-
-          scoreClasses: {
-            invalid: 'strength-invalid',
-            weak: 'strength-weak',
-            good: 'strength-good',
-            strong: 'strength-strong'
-          }
-        };
-      }
-    }]);
-    return Strength;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Strength);
-
-  exports.default = Strength;
-});

public/js/vendor/Plugin/jquery-wizard.js

@@ -1,75 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jquery-wizard', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJqueryWizard = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'wizard';
-
-  var Wizard = function (_Plugin) {
-    babelHelpers.inherits(Wizard, _Plugin);
-
-    function Wizard() {
-      babelHelpers.classCallCheck(this, Wizard);
-      return babelHelpers.possibleConstructorReturn(this, (Wizard.__proto__ || Object.getPrototypeOf(Wizard)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Wizard, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          step: '.steps .step, .pearls .pearl',
-          templates: {
-            buttons: function buttons() {
-              var options = this.options;
-              return '<div class="wizard-buttons"><a class="btn btn-default btn-outline" href="#' + this.id + '" data-wizard="back" role="button">' + options.buttonLabels.back + '</a><a class="btn btn-primary btn-outline float-right" href="#' + this.id + '" data-wizard="next" role="button">' + options.buttonLabels.next + '</a><a class="btn btn-success btn-outline float-right" href="#' + this.id + '" data-wizard="finish" role="button">' + options.buttonLabels.finish + '</a></div>';
-            }
-          },
-          classes: {
-            step: {
-              done: 'done',
-              error: 'error',
-              active: 'active',
-              disabled: 'disabled',
-              activing: 'activing',
-              loading: 'loading'
-            },
-            pane: {
-              active: 'active',
-              activing: 'activing'
-            },
-            button: {
-              hide: 'hidden-xs-up',
-              disabled: 'disabled'
-            }
-          }
-        };
-      }
-    }]);
-    return Wizard;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Wizard);
-
-  exports.default = Wizard;
-});

public/js/vendor/Plugin/jstree.js

@@ -1,44 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jstree', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJstree = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'jstree';
-
-  var Jstree = function (_Plugin) {
-    babelHelpers.inherits(Jstree, _Plugin);
-
-    function Jstree() {
-      babelHelpers.classCallCheck(this, Jstree);
-      return babelHelpers.possibleConstructorReturn(this, (Jstree.__proto__ || Object.getPrototypeOf(Jstree)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Jstree, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }]);
-    return Jstree;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Jstree);
-
-  exports.default = Jstree;
-});

public/js/vendor/Plugin/jt-timepicker.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jt-timepicker', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginJtTimepicker = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'timepicker';
-
-  var Timepicker = function (_Plugin) {
-    babelHelpers.inherits(Timepicker, _Plugin);
-
-    function Timepicker() {
-      babelHelpers.classCallCheck(this, Timepicker);
-      return babelHelpers.possibleConstructorReturn(this, (Timepicker.__proto__ || Object.getPrototypeOf(Timepicker)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Timepicker, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Timepicker;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Timepicker);
-
-  exports.default = Timepicker;
-});

public/js/vendor/Plugin/jvectormap.js

@@ -1,79 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/jvectormap', ['exports', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin, global.Config);
-    global.PluginJvectormap = mod.exports;
-  }
-})(this, function (exports, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'vectorMap';
-
-  var VectorMap = function (_Plugin) {
-    babelHelpers.inherits(VectorMap, _Plugin);
-
-    function VectorMap() {
-      babelHelpers.classCallCheck(this, VectorMap);
-      return babelHelpers.possibleConstructorReturn(this, (VectorMap.__proto__ || Object.getPrototypeOf(VectorMap)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(VectorMap, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          map: 'world_mill',
-          backgroundColor: '#fff',
-          zoomAnimate: true,
-          regionStyle: {
-            initial: {
-              fill: (0, _Config.colors)('primary', 600)
-            },
-            hover: {
-              fill: (0, _Config.colors)('primary', 500)
-            },
-            selected: {
-              fill: (0, _Config.colors)('primary', 800)
-            },
-            selectedHover: {
-              fill: (0, _Config.colors)('primary', 500)
-            }
-          },
-          markerStyle: {
-            initial: {
-              r: 8,
-              fill: (0, _Config.colors)('red', 600),
-              'stroke-width': 0
-            },
-            hover: {
-              r: 12,
-              stroke: (0, _Config.colors)('red', 600),
-              'stroke-width': 0
-            }
-          }
-        };
-      }
-    }]);
-    return VectorMap;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, VectorMap);
-
-  exports.default = VectorMap;
-});

public/js/vendor/Plugin/ladda.js

@@ -1,75 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/ladda', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginLadda = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'ladda';
-
-  var LaddaPlugin = function (_Plugin) {
-    babelHelpers.inherits(LaddaPlugin, _Plugin);
-
-    function LaddaPlugin() {
-      babelHelpers.classCallCheck(this, LaddaPlugin);
-      return babelHelpers.possibleConstructorReturn(this, (LaddaPlugin.__proto__ || Object.getPrototypeOf(LaddaPlugin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(LaddaPlugin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof Ladda === 'undefined') {
-          return;
-        }
-
-        if (this.options.type === 'progress') {
-          this.options.callback = function (instance) {
-            var progress = 0;
-            var interval = setInterval(function () {
-              progress = Math.min(progress + Math.random() * 0.1, 1);
-              instance.setProgress(progress);
-
-              if (progress === 1) {
-                instance.stop();
-                clearInterval(interval);
-              }
-            }, 200);
-          };
-        }
-        Ladda.bind(this.$el[0], this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          type: 'normal',
-          timeout: 2000
-        };
-      }
-    }]);
-    return LaddaPlugin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, LaddaPlugin);
-
-  exports.default = LaddaPlugin;
-});

public/js/vendor/Plugin/loading-button.js

@@ -1,82 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/loading-button', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginLoadingButton = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'loadingButton';
-
-  var LoadingButton = function (_Plugin) {
-    babelHelpers.inherits(LoadingButton, _Plugin);
-
-    function LoadingButton() {
-      babelHelpers.classCallCheck(this, LoadingButton);
-      return babelHelpers.possibleConstructorReturn(this, (LoadingButton.__proto__ || Object.getPrototypeOf(LoadingButton)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(LoadingButton, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.text = this.$el.text();
-        this.$el.data('loadingButtonApi', this);
-      }
-    }, {
-      key: 'loading',
-      value: function loading() {
-        var $el = this.$el,
-            i = this.options.time,
-            loadingText = this.options.loadingText,
-            opacity = this.options.opacity;
-
-        $el.text(loadingText + '(' + i + ')').css('opacity', opacity);
-
-        var timeout = setInterval(function () {
-          $el.text(loadingText + '(' + --i + ')');
-          if (i === 0) {
-            clearInterval(timeout);
-            $el.text(text).css('opacity', '1');
-          }
-        }, 1000);
-      }
-    }], [{
-      key: 'api',
-      value: function api() {
-        return 'click|loading';
-      }
-    }, {
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          loadingText: 'Loading',
-          time: 20,
-          opacity: '0.6'
-        };
-      }
-    }]);
-    return LoadingButton;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, LoadingButton);
-
-  exports.default = LoadingButton;
-});

public/js/vendor/Plugin/magnific-popup.js

@@ -1,55 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/magnific-popup', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginMagnificPopup = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'magnificPopup';
-
-  var MagnificPopup = function (_Plugin) {
-    babelHelpers.inherits(MagnificPopup, _Plugin);
-
-    function MagnificPopup() {
-      babelHelpers.classCallCheck(this, MagnificPopup);
-      return babelHelpers.possibleConstructorReturn(this, (MagnificPopup.__proto__ || Object.getPrototypeOf(MagnificPopup)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(MagnificPopup, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          type: 'image',
-          closeOnContentClick: true,
-          image: {
-            verticalFit: true
-          }
-        };
-      }
-    }]);
-    return MagnificPopup;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, MagnificPopup);
-
-  exports.default = MagnificPopup;
-});

public/js/vendor/Plugin/masonry.js

@@ -1,69 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/masonry', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginMasonry = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'masonry';
-
-  var Masonry = function (_Plugin) {
-    babelHelpers.inherits(Masonry, _Plugin);
-
-    function Masonry() {
-      babelHelpers.classCallCheck(this, Masonry);
-      return babelHelpers.possibleConstructorReturn(this, (Masonry.__proto__ || Object.getPrototypeOf(Masonry)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Masonry, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof _jquery2.default.fn.masonry === 'undefined') {
-          return;
-        }
-
-        var $el = this.$el;
-        if (_jquery2.default.fn.imagesLoaded) {
-          $el.imagesLoaded(function () {
-            $el.masonry(this.options);
-          });
-        } else {
-          $el.masonry(this.options);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          itemSelector: '.masonry-item'
-        };
-      }
-    }]);
-    return Masonry;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Masonry);
-
-  exports.default = Masonry;
-});

public/js/vendor/Plugin/matchheight.js

@@ -1,67 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/matchheight', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginMatchheight = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'matchHeight';
-
-  var MatchHeight = function (_Plugin) {
-    babelHelpers.inherits(MatchHeight, _Plugin);
-
-    function MatchHeight() {
-      babelHelpers.classCallCheck(this, MatchHeight);
-      return babelHelpers.possibleConstructorReturn(this, (MatchHeight.__proto__ || Object.getPrototypeOf(MatchHeight)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(MatchHeight, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof _jquery2.default.fn.matchHeight === 'undefined') {
-          return;
-        }
-
-        var $el = this.$el,
-            matchSelector = $el.data('matchSelector');
-
-        if (matchSelector) {
-          $el.find(matchSelector).matchHeight(this.options);
-        } else {
-          $el.children().matchHeight(this.options);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return MatchHeight;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, MatchHeight);
-
-  exports.default = MatchHeight;
-});

public/js/vendor/Plugin/material.js

@@ -1,132 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/material', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginMaterial = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'formMaterial';
-
-  function isChar(e) {
-    if (typeof e.which === 'undefined') {
-      return true;
-    } else if (typeof e.which === 'number' && e.which > 0) {
-      return !e.ctrlKey && !e.metaKey && !e.altKey && e.which !== 8 && e.which !== 9;
-    }
-    return false;
-  }
-
-  var FormMaterial = function (_Plugin) {
-    babelHelpers.inherits(FormMaterial, _Plugin);
-
-    function FormMaterial() {
-      babelHelpers.classCallCheck(this, FormMaterial);
-      return babelHelpers.possibleConstructorReturn(this, (FormMaterial.__proto__ || Object.getPrototypeOf(FormMaterial)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(FormMaterial, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        var $el = this.$el;
-
-        var $control = this.$control = $el.find('.form-control');
-
-        // Add hint label if required
-        if ($control.attr('data-hint')) {
-          $control.after('<div class=hint>' + $control.attr('data-hint') + '</div>');
-        }
-
-        if ($el.hasClass('floating')) {
-          // Add floating label if required
-          if ($control.hasClass('floating-label')) {
-            var placeholder = $control.attr('placeholder');
-            $control.attr('placeholder', null).removeClass('floating-label');
-            $control.after('<div class=floating-label>' + placeholder + '</div>');
-          }
-
-          // Set as empty if is empty
-          if ($control.val() === null || $control.val() === 'undefined' || $control.val() === '') {
-            $control.addClass('empty');
-          }
-        }
-
-        // Support for file input
-        if ($control.next().is('[type=file]')) {
-          $el.addClass('form-material-file');
-        }
-
-        this.$file = $el.find('[type=file]');
-        this.bind();
-        $el.data('formMaterialAPI', this);
-      }
-    }, {
-      key: 'bind',
-      value: function bind() {
-        var _this2 = this;
-
-        var $el = this.$el;
-        var $control = this.$control = $el.find('.form-control');
-
-        $el.on('keydown.site.material paste.site.material', '.form-control', function (e) {
-          if (isChar(e)) {
-            $control.removeClass('empty');
-          }
-        }).on('keyup.site.material change.site.material', '.form-control', function () {
-          if ($control.val() === '' && typeof $control[0].checkValidity !== 'undefined' && $control[0].checkValidity()) {
-            $control.addClass('empty');
-          } else {
-            $control.removeClass('empty');
-          }
-        });
-
-        if (this.$file.length > 0) {
-          this.$file.on('focus', function () {
-            _this2.$el.find('input').addClass('focus');
-          }).on('blur', function () {
-            _this2.$el.find('input').removeClass('focus');
-          }).on('change', function () {
-            var $this = (0, _jquery2.default)(this);
-            var value = '';
-
-            _jquery2.default.each($this[0].files, function (i, file) {
-              value += file.name + ', ';
-            });
-            value = value.substring(0, value.length - 2);
-            if (value) {
-              $this.prev().removeClass('empty');
-            } else {
-              $this.prev().addClass('empty');
-            }
-            $this.prev().val(value);
-          });
-        }
-      }
-    }]);
-    return FormMaterial;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, FormMaterial);
-
-  exports.default = FormMaterial;
-});

public/js/vendor/Plugin/menu.js

@@ -1,225 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/menu', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginMenu = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'menu';
-
-  var Menu = function (_Plugin) {
-    babelHelpers.inherits(Menu, _Plugin);
-
-    function Menu() {
-      var _ref;
-
-      babelHelpers.classCallCheck(this, Menu);
-
-      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-
-      var _this = babelHelpers.possibleConstructorReturn(this, (_ref = Menu.__proto__ || Object.getPrototypeOf(Menu)).call.apply(_ref, [this].concat(args)));
-
-      _this.folded = true;
-      _this.foldAlt = true;
-      _this.outerHeight = 0;
-      return _this;
-    }
-
-    babelHelpers.createClass(Menu, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.bindEvents();
-        this.$el.data('menuApi', this);
-      }
-    }, {
-      key: 'bindEvents',
-      value: function bindEvents() {
-        var self = this;
-
-        this.$el.on('mouseenter.site.menu', '.site-menu-item', function () {
-          var $item = $(this);
-          if (self.folded === true && $item.is('.has-sub') && $item.parent('.site-menu').length > 0) {
-            var $sub = $item.children('.site-menu-sub');
-            self.position($item, $sub);
-          }
-          $item.addClass('hover');
-        }).on('mouseleave.site.menu', '.site-menu-item', function () {
-          var $item = $(this);
-          if (self.folded === true && $item.is('.has-sub') && $item.parent('.site-menu').length > 0) {
-            $item.children('.site-menu-sub').css('max-height', '');
-            $item.removeClass('open');
-          }
-          $item.removeClass('hover');
-        }).on('deactive.site.menu', '.site-menu-item.active', function (e) {
-          $(this).removeClass('active');
-
-          e.stopPropagation();
-        }).on('active.site.menu', '.site-menu-item', function (e) {
-          $(this).addClass('active');
-
-          e.stopPropagation();
-        }).on('open.site.menu', '.site-menu-item', function (e) {
-          var $item = $(this);
-
-          self.expand($item, function () {
-            $item.addClass('open');
-          });
-
-          if (self.options.accordion) {
-            $item.siblings('.open').trigger('close.site.menu');
-          }
-
-          e.stopPropagation();
-        }).on('close.site.menu', '.site-menu-item.open', function (e) {
-          var $item = $(this);
-
-          self.collapse($item, function () {
-            $item.removeClass('open');
-          });
-
-          e.stopPropagation();
-        }).on('click.site.menu ', '.site-menu-item', function (e) {
-          var $item = $(this);
-
-          if ($item.is('.has-sub') && $(e.target).closest('.site-menu-item').is(this)) {
-            if ($item.is('.open')) {
-              $item.trigger('close.site.menu');
-            } else {
-              $item.trigger('open.site.menu');
-            }
-          } else if (!$item.is('.active')) {
-            $item.siblings('.active').trigger('deactive.site.menu');
-            $item.trigger('active.site.menu');
-          }
-
-          e.stopPropagation();
-        }).on('tap.site.menu', '> .site-menu-item > a', function () {
-          var link = $(this).attr('href');
-
-          if (link) {
-            window.location = link;
-          }
-        }).on('touchend.site.menu', '> .site-menu-item > a', function () {
-          var $item = $(this).parent('.site-menu-item');
-
-          if (self.folded === true) {
-            if ($item.is('.has-sub') && $item.parent('.site-menu').length > 0) {
-              $item.siblings('.hover').removeClass('hover');
-
-              if ($item.is('.hover')) {
-                $item.removeClass('hover');
-              } else {
-                $item.addClass('hover');
-              }
-            }
-          }
-        }).on('scroll.site.menu', '.site-menu-sub', function (e) {
-          e.stopPropagation();
-        });
-      }
-    }, {
-      key: 'collapse',
-      value: function collapse($item, callback) {
-        var self = this;
-        var $sub = $item.children('.site-menu-sub');
-
-        $sub.show().slideUp(this.options.speed, function () {
-          $(this).css('display', '');
-
-          $(this).find('> .site-menu-item').removeClass('is-shown');
-
-          if (callback) {
-            callback();
-          }
-
-          self.$el.trigger('collapsed.site.menu');
-        });
-      }
-    }, {
-      key: 'expand',
-      value: function expand($item, callback) {
-        var self = this;
-        var $sub = $item.children('.site-menu-sub');
-        var $children = $sub.children('.site-menu-item').addClass('is-hidden');
-
-        $sub.hide().slideDown(this.options.speed, function () {
-          $(this).css('display', '');
-
-          if (callback) {
-            callback();
-          }
-
-          self.$el.trigger('expanded.site.menu');
-        });
-
-        setTimeout(function () {
-          $children.addClass('is-shown');
-          $children.removeClass('is-hidden');
-        }, 0);
-      }
-    }, {
-      key: 'refresh',
-      value: function refresh() {
-        this.$el.find('.open').filter(':not(.active)').removeClass('open');
-      }
-    }, {
-      key: 'position',
-      value: function position($item, $dropdown) {
-        var itemHeight = $item.find('> a').outerHeight(),
-            menubarHeight = this.outerHeight,
-            offsetTop = $item.position().top;
-
-        $dropdown.removeClass('site-menu-sub-up').css('max-height', '');
-
-        if (offsetTop > menubarHeight / 2) {
-          $dropdown.addClass('site-menu-sub-up');
-
-          if (this.foldAlt) {
-            offsetTop -= itemHeight;
-          }
-          $dropdown.css('max-height', offsetTop + itemHeight);
-        } else {
-          if (this.foldAlt) {
-            offsetTop += itemHeight;
-          }
-          $dropdown.removeClass('site-menu-sub-up');
-          $dropdown.css('max-height', menubarHeight - offsetTop);
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          speed: 250,
-          accordion: true
-        };
-      }
-    }]);
-    return Menu;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Menu);
-
-  exports.default = Menu;
-});

public/js/vendor/Plugin/more-button.js

@@ -1,69 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/more-button', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginMoreButton = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'moreButton';
-
-  var MoreButton = function (_Plugin) {
-    babelHelpers.inherits(MoreButton, _Plugin);
-
-    function MoreButton() {
-      babelHelpers.classCallCheck(this, MoreButton);
-      return babelHelpers.possibleConstructorReturn(this, (MoreButton.__proto__ || Object.getPrototypeOf(MoreButton)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(MoreButton, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$target = (0, _jquery2.default)(this.options.more);
-        this.$el.data('moreButtonApi', this);
-      }
-    }, {
-      key: 'toggle',
-      value: function toggle() {
-        this.$target.toggle();
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          more: ''
-        };
-      }
-    }, {
-      key: 'api',
-      value: function api() {
-        return 'click|toggle';
-      }
-    }]);
-    return MoreButton;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, MoreButton);
-
-  exports.default = MoreButton;
-});

public/js/vendor/Plugin/multi-select.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/multi-select', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginMultiSelect = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'multiSelect';
-
-  var MultiSelect = function (_Plugin) {
-    babelHelpers.inherits(MultiSelect, _Plugin);
-
-    function MultiSelect() {
-      babelHelpers.classCallCheck(this, MultiSelect);
-      return babelHelpers.possibleConstructorReturn(this, (MultiSelect.__proto__ || Object.getPrototypeOf(MultiSelect)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(MultiSelect, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return MultiSelect;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, MultiSelect);
-
-  exports.default = MultiSelect;
-});

public/js/vendor/Plugin/nestable.js

@@ -1,49 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/nestable', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginNestable = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'nestable';
-
-  var Nestable = function (_Plugin) {
-    babelHelpers.inherits(Nestable, _Plugin);
-
-    function Nestable() {
-      babelHelpers.classCallCheck(this, Nestable);
-      return babelHelpers.possibleConstructorReturn(this, (Nestable.__proto__ || Object.getPrototypeOf(Nestable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Nestable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Nestable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Nestable);
-
-  exports.default = Nestable;
-});

public/js/vendor/Plugin/notie-js.js

@@ -1,109 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/notie-js', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginNotieJs = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'notie';
-
-  var Notie = function (_Plugin) {
-    babelHelpers.inherits(Notie, _Plugin);
-
-    function Notie() {
-      babelHelpers.classCallCheck(this, Notie);
-      return babelHelpers.possibleConstructorReturn(this, (Notie.__proto__ || Object.getPrototypeOf(Notie)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Notie, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$el.data('notieApi', this);
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        var options = this.options;
-
-        if (options.type !== undefined) {
-          if (options.type === 'confirm') {
-            notie.confirm(options.text, options.yesText, options.noText, function () {
-              notie.alert(1, options.yesMsg, 1.5);
-            }, function () {
-              notie.alert(3, options.noMsg, 1.5);
-            });
-          }
-
-          if (options.type === 'input') {
-            notie.input({
-              type: options.inputType,
-              placeholder: options.placeholder,
-              prefilledValue: options.prefilledvalue
-            }, options.text, options.yesText, options.noText, function (valueInput) {
-              notie.alert(1, 'you entered: ' + valueInput, 1.5);
-            }, function (valueInput) {
-              notie.alert(3, 'You cancelled with this value: ' + valueInput, 2);
-            });
-          }
-
-          if (options.type === 'success') {
-            notie.alert(1, options.text, options.delay);
-          }
-
-          if (options.type === 'warning') {
-            notie.alert(2, options.text, options.delay);
-          }
-
-          if (options.type === 'error') {
-            notie.alert(3, options.text, options.delay);
-          }
-
-          if (options.type === 'info') {
-            notie.alert(4, options.text, options.delay);
-          }
-
-          if (options.animationdelay !== undefined && typeof options.animationdelay === 'number') {
-            notie.setOptions({
-              animationDelay: options.animationDelay
-            });
-          }
-
-          if (options.bgclickdismiss !== undefined && typeof options.bgclickdismiss === 'boolean') {
-            notie.setOptions({
-              backgroundClickDismiss: options.bgclickdismiss
-            });
-          }
-        }
-      }
-    }], [{
-      key: 'api',
-      value: function api() {
-        return 'click|show';
-      }
-    }]);
-    return Notie;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Notie);
-
-  exports.default = Notie;
-});

public/js/vendor/Plugin/nprogress.js

@@ -1,64 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/nprogress', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginNprogress = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'nprogress';
-
-  var Nprogress = function (_Plugin) {
-    babelHelpers.inherits(Nprogress, _Plugin);
-
-    function Nprogress() {
-      babelHelpers.classCallCheck(this, Nprogress);
-      return babelHelpers.possibleConstructorReturn(this, (Nprogress.__proto__ || Object.getPrototypeOf(Nprogress)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Nprogress, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof NProgress === 'undefined') {
-          return;
-        }
-
-        NProgress.configure(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          minimum: 0.15,
-          trickleRate: 0.07,
-          trickleSpeed: 360,
-          showSpinner: false,
-          template: '<div class="bar" role="bar"></div><div class="spinner" role="spinner"><div class="spinner-icon"></div></div>'
-        };
-      }
-    }]);
-    return Nprogress;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Nprogress);
-
-  exports.default = Nprogress;
-});

public/js/vendor/Plugin/owl-carousel.js

@@ -1,63 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/owl-carousel', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginOwlCarousel = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'owlCarousel';
-
-  var OwlCarousel = function (_Plugin) {
-    babelHelpers.inherits(OwlCarousel, _Plugin);
-
-    function OwlCarousel() {
-      babelHelpers.classCallCheck(this, OwlCarousel);
-      return babelHelpers.possibleConstructorReturn(this, (OwlCarousel.__proto__ || Object.getPrototypeOf(OwlCarousel)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(OwlCarousel, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          // autoWidth: true,
-          loop: true,
-          nav: true,
-          dots: false,
-          dotsClass: 'owl-dots owl-dots-fall',
-          responsive: {
-            0: {
-              items: 1
-            },
-            600: {
-              items: 3
-            }
-          }
-        };
-      }
-    }]);
-    return OwlCarousel;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, OwlCarousel);
-
-  exports.default = OwlCarousel;
-});

public/js/vendor/Plugin/panel.js

@@ -1,248 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/panel', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginPanel = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'panel';
-
-  function getPanelAPI($el) {
-    if ($el.length <= 0) return;
-    var api = $el.data('panelAPI');
-
-    if (api) return api;
-
-    api = new Panel($el, _jquery2.default.extend(true, {}, Panel.getDefaults(), $el.data()));
-    api.render();
-    return api;
-  }
-
-  var Panel = function (_Plugin) {
-    babelHelpers.inherits(Panel, _Plugin);
-
-    function Panel() {
-      babelHelpers.classCallCheck(this, Panel);
-      return babelHelpers.possibleConstructorReturn(this, (Panel.__proto__ || Object.getPrototypeOf(Panel)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Panel, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render(context) {
-        var $el = this.$el;
-
-        this.isFullscreen = false;
-        this.isClose = false;
-        this.isCollapse = false;
-        this.isLoading = false;
-
-        this.$panelBody = $el.find('.panel-body');
-        this.$fullscreen = $el.find('[data-toggle="panel-fullscreen"]');
-        this.$collapse = $el.find('[data-toggle="panel-collapse"]');
-        this.$loading = null;
-        if ($el.hasClass('is-collapse')) {
-          this.isCollapse = true;
-        }
-
-        if (typeof this.options.loadCallback === 'string') {
-          this.options.loadCallback = window[this.options.loadCallback];
-        }
-
-        $el.data('panelAPI', this);
-      }
-    }, {
-      key: 'load',
-      value: function load(callback) {
-        var $el = this.$el,
-            type = $el.data('loader-type');
-        if (!type) {
-          type = 'default';
-        }
-
-        callback = callback || this.options.loadCallback;
-
-        this.$loading = (0, _jquery2.default)('<div class="panel-loading">\n                          <div class="loader loader-' + type + '"></div>\n                        </div>').appendTo($el);
-        $el.addClass('is-loading');
-        $el.trigger('loading.uikit.panel');
-        this.isLoading = true;
-
-        if (typeof callback === 'function') {
-          callback.call(this);
-        }
-      }
-    }, {
-      key: 'done',
-      value: function done() {
-        if (this.isLoading === true) {
-          this.$loading.remove();
-          this.$el.removeClass('is-loading');
-          this.$el.trigger('loading.done.uikit.panel');
-        }
-      }
-    }, {
-      key: 'toggleContent',
-      value: function toggleContent() {
-        if (this.isCollapse) {
-          this.showContent();
-        } else {
-          this.hideContent();
-        }
-      }
-    }, {
-      key: 'showContent',
-      value: function showContent() {
-        if (this.isCollapse !== false) {
-          this.$el.removeClass('is-collapse');
-
-          if (this.$collapse.hasClass('wb-plus')) {
-            this.$collapse.removeClass('wb-plus').addClass('wb-minus');
-          }
-
-          this.$el.trigger('shown.uikit.panel');
-
-          this.isCollapse = false;
-        }
-      }
-    }, {
-      key: 'hideContent',
-      value: function hideContent() {
-        if (this.isCollapse !== true) {
-          this.$el.addClass('is-collapse');
-
-          if (this.$collapse.hasClass('wb-minus')) {
-            this.$collapse.removeClass('wb-minus').addClass('wb-plus');
-          }
-
-          this.$el.trigger('hidden.uikit.panel');
-          this.isCollapse = true;
-        }
-      }
-    }, {
-      key: 'toggleFullscreen',
-      value: function toggleFullscreen() {
-        if (this.isFullscreen) {
-          this.leaveFullscreen();
-        } else {
-          this.enterFullscreen();
-        }
-      }
-    }, {
-      key: 'enterFullscreen',
-      value: function enterFullscreen() {
-        if (this.isFullscreen !== true) {
-          this.$el.addClass('is-fullscreen');
-
-          if (this.$fullscreen.hasClass('wb-expand')) {
-            this.$fullscreen.removeClass('wb-expand').addClass('wb-contract');
-          }
-
-          this.$el.trigger('enter.fullscreen.uikit.panel');
-          this.isFullscreen = true;
-        }
-      }
-    }, {
-      key: 'leaveFullscreen',
-      value: function leaveFullscreen() {
-        if (this.isFullscreen !== false) {
-          this.$el.removeClass('is-fullscreen');
-
-          if (this.$fullscreen.hasClass('wb-contract')) {
-            this.$fullscreen.removeClass('wb-contract').addClass('wb-expand');
-          }
-
-          this.$el.trigger('leave.fullscreen.uikit.panel');
-          this.isFullscreen = false;
-        }
-      }
-    }, {
-      key: 'toggle',
-      value: function toggle() {
-        if (this.isClose) {
-          this.open();
-        } else {
-          this.close();
-        }
-      }
-    }, {
-      key: 'open',
-      value: function open() {
-        if (this.isClose !== false) {
-          this.$el.removeClass('is-close');
-          this.$el.trigger('open.uikit.panel');
-
-          this.isClose = false;
-        }
-      }
-    }, {
-      key: 'close',
-      value: function close() {
-        if (this.isClose !== true) {
-          this.$el.addClass('is-close');
-          this.$el.trigger('close.uikit.panel');
-
-          this.isClose = true;
-        }
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }, {
-      key: 'api',
-      value: function api() {
-        return function () {
-          (0, _jquery2.default)(document).on('click.site.panel', '[data-toggle="panel-fullscreen"]', function (e) {
-            e.preventDefault();
-            var api = getPanelAPI((0, _jquery2.default)(this).closest('.panel'));
-            api.toggleFullscreen();
-          });
-
-          (0, _jquery2.default)(document).on('click.site.panel', '[data-toggle="panel-collapse"]', function (e) {
-            e.preventDefault();
-            var api = getPanelAPI((0, _jquery2.default)(this).closest('.panel'));
-            api.toggleContent();
-          });
-
-          (0, _jquery2.default)(document).on('click.site.panel', '[data-toggle="panel-close"]', function (e) {
-            e.preventDefault();
-            var api = getPanelAPI((0, _jquery2.default)(this).closest('.panel'));
-            api.close();
-          });
-
-          (0, _jquery2.default)(document).on('click.site.panel', '[data-toggle="panel-refresh"]', function (e) {
-            e.preventDefault();
-            var api = getPanelAPI((0, _jquery2.default)(this).closest('.panel'));
-            api.load();
-          });
-        };
-      }
-    }]);
-    return Panel;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Panel);
-
-  exports.default = Panel;
-});

public/js/vendor/Plugin/peity.js

@@ -1,232 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/peity', ['exports', 'jquery', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin, global.Config);
-    global.PluginPeity = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin5, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-  exports.PeityPie = exports.PeityDonut = exports.PeityLine = exports.PeityBar = undefined;
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin6 = babelHelpers.interopRequireDefault(_Plugin5);
-
-  var PeityBar = function (_Plugin) {
-    babelHelpers.inherits(PeityBar, _Plugin);
-
-    function PeityBar() {
-      babelHelpers.classCallCheck(this, PeityBar);
-      return babelHelpers.possibleConstructorReturn(this, (PeityBar.__proto__ || Object.getPrototypeOf(PeityBar)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(PeityBar, [{
-      key: 'getName',
-      value: function getName() {
-        return 'peityBar';
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.peity) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.skin) {
-          var skinColors = (0, _Config.colors)(options.skin);
-          if (skinColors) {
-            options.fill = [skinColors[400]];
-          }
-        }
-
-        $el.peity('bar', options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          delimiter: ',',
-          fill: [(0, _Config.colors)('primary', 400)],
-          height: 22,
-          max: null,
-          min: 0,
-          padding: 0.1,
-          width: 44
-        };
-      }
-    }]);
-    return PeityBar;
-  }(_Plugin6.default);
-
-  _Plugin6.default.register('peityBar', PeityBar);
-
-  var PeityDonut = function (_Plugin2) {
-    babelHelpers.inherits(PeityDonut, _Plugin2);
-
-    function PeityDonut() {
-      babelHelpers.classCallCheck(this, PeityDonut);
-      return babelHelpers.possibleConstructorReturn(this, (PeityDonut.__proto__ || Object.getPrototypeOf(PeityDonut)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(PeityDonut, [{
-      key: 'getName',
-      value: function getName() {
-        return 'peityDonut';
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.peity) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.skin) {
-          var skinColors = (0, _Config.colors)(options.skin);
-          if (skinColors) {
-            options.fill = [skinColors[700], skinColors[400], skinColors[200]];
-          }
-        }
-
-        $el.peity('donut', options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          delimiter: null,
-          fill: [(0, _Config.colors)('primary', 700), (0, _Config.colors)('primary', 400), (0, _Config.colors)('primary', 200)],
-          height: null,
-          innerRadius: null,
-          radius: 11,
-          width: null
-        };
-      }
-    }]);
-    return PeityDonut;
-  }(_Plugin6.default);
-
-  _Plugin6.default.register('peityDonut', PeityDonut);
-
-  var PeityLine = function (_Plugin3) {
-    babelHelpers.inherits(PeityLine, _Plugin3);
-
-    function PeityLine() {
-      babelHelpers.classCallCheck(this, PeityLine);
-      return babelHelpers.possibleConstructorReturn(this, (PeityLine.__proto__ || Object.getPrototypeOf(PeityLine)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(PeityLine, [{
-      key: 'getName',
-      value: function getName() {
-        return 'peityLine';
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.peity) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.skin) {
-          var skinColors = (0, _Config.colors)(options.skin);
-          if (skinColors) {
-            options.fill = [skinColors[200]];
-            options.stroke = skinColors[600];
-          }
-        }
-
-        $el.peity('line', options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          delimiter: ',',
-          fill: [(0, _Config.colors)('primary', 200)],
-          height: 22,
-          max: null,
-          min: 0,
-          stroke: (0, _Config.colors)('primary', 600),
-          strokeWidth: 1,
-          width: 44
-        };
-      }
-    }]);
-    return PeityLine;
-  }(_Plugin6.default);
-
-  _Plugin6.default.register('peityLine', PeityLine);
-
-  var PeityPie = function (_Plugin4) {
-    babelHelpers.inherits(PeityPie, _Plugin4);
-
-    function PeityPie() {
-      babelHelpers.classCallCheck(this, PeityPie);
-      return babelHelpers.possibleConstructorReturn(this, (PeityPie.__proto__ || Object.getPrototypeOf(PeityPie)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(PeityPie, [{
-      key: 'getName',
-      value: function getName() {
-        return 'peityPie';
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.peity) {
-          return;
-        }
-
-        var $el = this.$el,
-            options = this.options;
-
-        if (options.skin) {
-          var skinColors = (0, _Config.colors)(options.skin);
-          if (skinColors) {
-            options.fill = [skinColors[700], skinColors[400], skinColors[200]];
-          }
-        }
-
-        $el.peity('pie', options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          delimiter: null,
-          fill: [(0, _Config.colors)('primary', 700), (0, _Config.colors)('primary', 400), (0, _Config.colors)('primary', 200)],
-          height: null,
-          radius: 11,
-          width: null
-        };
-      }
-    }]);
-    return PeityPie;
-  }(_Plugin6.default);
-
-  _Plugin6.default.register('peityPie', PeityPie);
-
-  exports.PeityBar = PeityBar;
-  exports.PeityLine = PeityLine;
-  exports.PeityDonut = PeityDonut;
-  exports.PeityPie = PeityPie;
-});

public/js/vendor/Plugin/plyr.js

@@ -1,78 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/plyr', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginPlyr = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'plyr';
-
-  (0, _jquery2.default)(document).ready(function () {
-    var a = new XMLHttpRequest(),
-        d = document,
-        u = 'https://cdn.plyr.io/1.1.5/sprite.svg';
-    var b = d.body;
-
-    // Check for CORS support
-    if ('withCredentials' in a) {
-      a.open('GET', u, true);
-      a.send();
-      a.onload = function () {
-        var c = d.createElement('div');
-        c.style.display = 'none';
-        c.innerHTML = a.responseText;
-        b.insertBefore(c, b.childNodes[0]);
-      };
-    }
-  });
-
-  var Plyr = function (_Plugin) {
-    babelHelpers.inherits(Plyr, _Plugin);
-
-    function Plyr() {
-      babelHelpers.classCallCheck(this, Plyr);
-      return babelHelpers.possibleConstructorReturn(this, (Plyr.__proto__ || Object.getPrototypeOf(Plyr)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Plyr, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof plyr === 'undefined') {
-          return;
-        }
-        plyr.setup(this.$el[0], this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {};
-      }
-    }]);
-    return Plyr;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Plyr);
-
-  exports.default = Plyr;
-});

public/js/vendor/Plugin/raty.js

@@ -1,75 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/raty', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginRaty = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'rating';
-
-  var Rating = function (_Plugin) {
-    babelHelpers.inherits(Rating, _Plugin);
-
-    function Rating() {
-      babelHelpers.classCallCheck(this, Rating);
-      return babelHelpers.possibleConstructorReturn(this, (Rating.__proto__ || Object.getPrototypeOf(Rating)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Rating, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.raty) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        if (this.options.hints) {
-          this.options.hints = this.options.hints.split(',');
-        }
-
-        $el.raty(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          targetKeep: true,
-          icon: 'font',
-          starType: 'i',
-          starOff: 'icon wb-star',
-          starOn: 'icon wb-star orange-600',
-          cancelOff: 'icon wb-minus-circle',
-          cancelOn: 'icon wb-minus-circle orange-600',
-          starHalf: 'icon wb-star-half orange-500'
-        };
-      }
-    }]);
-    return Rating;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Rating);
-
-  exports.default = Rating;
-});

public/js/vendor/Plugin/responsive-tabs.js

@@ -1,191 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/responsive-tabs', ['exports', 'jquery'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery);
-    global.PluginResponsiveTabs = mod.exports;
-  }
-})(this, function (exports, _jquery) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var pluginName = 'responsiveHorizontalTabs';
-
-  var defaults = {
-    navSelector: '.nav-tabs',
-    itemSelector: '.nav-item',
-    dropdownSelector: '>.dropdown',
-    dropdownItemSelector: '.dropdown-item',
-    tabSelector: '.tab-pane',
-    activeClassName: 'active'
-  };
-
-  var responsiveHorizontalTabs = function () {
-    function responsiveHorizontalTabs(el, options) {
-      babelHelpers.classCallCheck(this, responsiveHorizontalTabs);
-
-      var $tabs = this.$tabs = (0, _jquery2.default)(el);
-      this.options = options = _jquery2.default.extend(true, {}, defaults, options);
-
-      var $nav = this.$nav = $tabs.find(this.options.navSelector);
-      var $dropdown = this.$dropdown = $nav.find(this.options.dropdownSelector);
-      var $items = this.$items = $nav.find(this.options.itemSelector).filter(function () {
-        return !(0, _jquery2.default)(this).is($dropdown);
-      });
-
-      this.$dropdownItems = $dropdown.find(this.options.dropdownItemSelector);
-      this.$tabPanel = this.$tabs.find(this.options.tabSelector);
-
-      this.breakpoints = [];
-
-      $items.each(function () {
-        (0, _jquery2.default)(this).data('width', (0, _jquery2.default)(this).width());
-      });
-
-      this.init();
-      this.bind();
-    }
-
-    babelHelpers.createClass(responsiveHorizontalTabs, [{
-      key: 'init',
-      value: function init() {
-        if (this.$dropdown.length === 0) return;
-
-        this.$dropdown.show();
-        this.breakpoints = [];
-
-        var length = this.length = this.$items.length;
-        var dropWidth = this.dropWidth = this.$dropdown.width();
-        var total = 0;
-
-        this.flag = length;
-
-        if (length <= 1) {
-          this.$dropdown.hide();
-          return;
-        }
-
-        for (var i = 0; i < length - 2; i++) {
-          if (i === 0) {
-            this.breakpoints.push(this.$items.eq(i).outerWidth() + dropWidth);
-          } else {
-            this.breakpoints.push(this.breakpoints[i - 1] + this.$items.eq(i).width());
-          }
-        }
-
-        for (i = 0; i < length; i++) {
-          total += this.$items.eq(i).outerWidth();
-        }
-        this.breakpoints.push(total);
-
-        this.layout();
-      }
-    }, {
-      key: 'layout',
-      value: function layout() {
-        if (this.breakpoints.length <= 0) return;
-
-        var width = this.$nav.width();
-        var i = 0;
-        var activeClassName = this.options.activeClassName;
-        var active = this.$tabPanel.filter('.' + activeClassName).index();
-
-        for (; i < this.breakpoints.length; i++) {
-          if (this.breakpoints[i] > width) break;
-        }
-
-        if (i === this.flag) return;
-
-        this.$items.children().removeClass(activeClassName);
-        this.$dropdownItems.removeClass(activeClassName);
-        this.$dropdown.children().removeClass(activeClassName);
-
-        if (i === this.breakpoints.length) {
-          this.$dropdown.hide();
-          this.$items.show();
-          this.$items.eq(active).children().addClass(activeClassName);
-        } else {
-          this.$dropdown.show();
-          for (var j = 0; j < this.length; j++) {
-            if (j < i) {
-              this.$items.eq(j).show();
-              this.$dropdownItems.eq(j).hide();
-            } else {
-              this.$items.eq(j).hide();
-              this.$dropdownItems.eq(j).show();
-            }
-          }
-
-          if (active < i) {
-            this.$items.eq(active).children().addClass(activeClassName);
-          } else {
-            this.$dropdown.children().addClass(activeClassName);
-            this.$dropdownItems.eq(active).addClass(activeClassName);
-          }
-        }
-
-        this.flag = i;
-      }
-    }, {
-      key: 'bind',
-      value: function bind() {
-        var self = this;
-
-        (0, _jquery2.default)(window).resize(function () {
-          self.layout();
-        });
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(options) {
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        if (typeof options === 'string') {
-          var method = options;
-          if (/^\_/.test(method)) {
-            return false;
-          } else {
-            return this.each(function () {
-              var api = _jquery2.default.data(this, pluginName);
-              if (api && typeof api[method] === 'function') {
-                api[method].apply(api, args);
-              }
-            });
-          }
-        } else {
-          return this.each(function () {
-            if (!_jquery2.default.data(this, pluginName)) {
-              _jquery2.default.data(this, pluginName, new responsiveHorizontalTabs(this, options));
-            } else {
-              _jquery2.default.data(this, pluginName).init();
-            }
-          });
-        }
-      }
-    }]);
-    return responsiveHorizontalTabs;
-  }();
-
-  _jquery2.default.fn[pluginName] = responsiveHorizontalTabs._jQueryInterface;
-  _jquery2.default.fn[pluginName].constructor = responsiveHorizontalTabs;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return responsiveHorizontalTabs._jQueryInterface;
-  };
-
-  exports.default = responsiveHorizontalTabs;
-});

public/js/vendor/Plugin/select2.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/select2', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginSelect2 = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'select2';
-
-  var Select2 = function (_Plugin) {
-    babelHelpers.inherits(Select2, _Plugin);
-
-    function Select2() {
-      babelHelpers.classCallCheck(this, Select2);
-      return babelHelpers.possibleConstructorReturn(this, (Select2.__proto__ || Object.getPrototypeOf(Select2)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Select2, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          width: 'style'
-        };
-      }
-    }]);
-    return Select2;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Select2);
-
-  exports.default = Select2;
-});

public/js/vendor/Plugin/selectable.js

@@ -1,69 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/selectable', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginSelectable = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'selectable';
-
-  var Selectable = function (_Plugin) {
-    babelHelpers.inherits(Selectable, _Plugin);
-
-    function Selectable() {
-      babelHelpers.classCallCheck(this, Selectable);
-      return babelHelpers.possibleConstructorReturn(this, (Selectable.__proto__ || Object.getPrototypeOf(Selectable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Selectable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (!_jquery2.default.fn.asSelectable) {
-          return;
-        }
-
-        var $el = this.$el;
-
-        $el.asSelectable(this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          allSelector: '.selectable-all',
-          itemSelector: '.selectable-item',
-          rowSelector: 'tr',
-          rowSelectable: false,
-          rowActiveClass: 'active',
-          onChange: null
-        };
-      }
-    }]);
-    return Selectable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Selectable);
-
-  exports.default = Selectable;
-});

public/js/vendor/Plugin/skintools.js

@@ -1,302 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/skintools', [], factory);
-  } else if (typeof exports !== "undefined") {
-    factory();
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory();
-    global.PluginSkintools = mod.exports;
-  }
-})(this, function () {
-  'use strict';
-
-  if (window.localStorage) {
-    var getLevel = function getLevel(url, tag) {
-      var arr = url.split('/').reverse();
-      var level = void 0;
-      var path = '';
-
-      for (var i = 0; i < arr.length; i++) {
-        if (arr[i] === tag) {
-          level = i;
-        }
-      }
-
-      for (var m = 1; m < level; m++) {
-        path += '../';
-      }
-
-      return path;
-    };
-
-    var layout = 'base';
-    var settingsName = 'remark.' + layout + '.skinTools';
-    var settings = localStorage.getItem(settingsName);
-
-    if (settings) {
-      if (settings[0] === '{') {
-        settings = JSON.parse(settings);
-      }
-
-      if (settings['primary'] && settings['primary'] !== 'primary') {
-        var head = document.head;
-        var link = document.createElement('link');
-
-        link.type = 'text/css';
-        link.rel = 'stylesheet';
-        link.href = getLevel(window.location.pathname, layout) + 'assets/skins/' + settings['primary'] + '.css';
-        link.id = 'skinStyle';
-
-        head.appendChild(link);
-      }
-
-      if (settings['sidebar'] && settings['sidebar'] === 'light') {
-        var menubarFn = setInterval(function () {
-          var menubar = document.getElementsByClassName('site-menubar');
-          if (menubar.length > 0) {
-            clearInterval(menubarFn);
-            menubar[0].className += ' site-menubar-light';
-          }
-        }, 5);
-      }
-
-      var navbarFn = setInterval(function () {
-        var navbar = document.getElementsByClassName('site-navbar');
-
-        if (navbar.length > 0) {
-          clearInterval(navbarFn);
-          if (settings['navbar'] && settings['navbar'] !== 'primary') {
-            navbar[0].className += ' bg-' + settings['navbar'] + '-600';
-          }
-          if (settings['navbarInverse'] && settings['navbarInverse'] !== 'false') {
-            navbar[0].className += ' navbar-inverse';
-          }
-        }
-      }, 5);
-    }
-
-    if (document.addEventListener) {
-      document.addEventListener('DOMContentLoaded', function () {
-        var $body = $(document.body);
-        var $doc = $(document);
-        var $win = $(window);
-
-        var Storage = {
-          set: function set(key, value) {
-            if (!window.localStorage) {
-              return null;
-            }
-            if (!key || !value) {
-              return null;
-            }
-
-            if (Object(value) === value) {
-              value = JSON.stringify(value);
-            }
-            localStorage.setItem(key, value);
-          },
-          get: function get(key) {
-            if (!window.localStorage) {
-              return null;
-            }
-
-            var value = localStorage.getItem(key);
-
-            if (!value) {
-              return null;
-            }
-
-            if (value[0] === '{') {
-              value = JSON.parse(value);
-            }
-
-            return value;
-          }
-        };
-
-        var Skintools = {
-          tpl: '<div class="site-skintools">' + '<div class="site-skintools-inner">' + '<div class="site-skintools-toggle">' + '<i class="icon wb-settings primary-600"></i>' + '</div>' + '<div class="site-skintools-content">' + '<div class="nav-tabs-horizontal">' + '<ul role="tablist" class="nav nav-tabs nav-tabs-line">' + '<li role="presentation" class="nav-item"><a class="nav-link active" role="tab" aria-controls="skintoolsSidebar" href="#skintoolsSidebar" data-toggle="tab" aria-expanded="true">Sidebar</a></li>' + '<li class="nav-item" role="presentation"><a class="nav-link" role="tab" aria-controls="skintoolsNavbar" href="#skintoolsNavbar" data-toggle="tab" aria-expanded="false">Navbar</a></li>' + '<li class="nav-item" role="presentation"><a class="nav-link" role="tab" aria-controls="skintoolsPrimary" href="#skintoolsPrimary" data-toggle="tab" aria-expanded="false">Primary</a></li>' + '</ul>' + '<div class="tab-content">' + '<div role="tabpanel" id="skintoolsSidebar" class="tab-pane active"></div>' + '<div role="tabpanel" id="skintoolsNavbar" class="tab-pane"></div>' + '<div role="tabpanel" id="skintoolsPrimary" class="tab-pane"></div>' + '<button class="btn btn-outline btn-block btn-primary mt-20" id="skintoolsReset" type="button">Reset</button>' + '</div>' + '</div>' + '</div>' + '</div>' + '</div>',
-          skintoolsSidebar: ['dark', 'light'],
-          skintoolsNavbar: ['primary', 'brown', 'cyan', 'green', 'grey', 'indigo', 'orange', 'pink', 'purple', 'red', 'teal', 'yellow'],
-          navbarSkins: 'bg-primary-600 bg-brown-600 bg-cyan-600 bg-green-600 bg-grey-600 bg-indigo-600 bg-orange-600 bg-pink-600 bg-purple-600 bg-red-600 bg-teal-600 bg-yellow-700',
-          skintoolsPrimary: ['primary', 'brown', 'cyan', 'green', 'grey', 'indigo', 'orange', 'pink', 'purple', 'red', 'teal', 'yellow'],
-          storageKey: settingsName,
-          defaultSettings: {
-            'sidebar': 'dark',
-            'navbar': 'primary',
-            'navbarInverse': 'false',
-            'primary': 'primary'
-          },
-          init: function init() {
-            var self = this;
-
-            this.path = getLevel(window.location.pathname, layout);
-            this.overflow = false;
-
-            this.$siteSidebar = $('.site-menubar');
-            this.$siteNavbar = $('.site-navbar');
-
-            this.$container = $(this.tpl);
-            this.$toggle = $('.site-skintools-toggle', this.$container);
-            this.$content = $('.site-skintools-content', this.$container);
-            this.$tabContent = $('.tab-content', this.$container);
-
-            this.$sidebar = $('#skintoolsSidebar', this.$content);
-            this.$navbar = $('#skintoolsNavbar', this.$content);
-            this.$primary = $('#skintoolsPrimary', this.$content);
-
-            this.build(this.$sidebar, this.skintoolsSidebar, 'skintoolsSidebar', 'radio', 'Sidebar Skins');
-            this.build(this.$navbar, ['inverse'], 'skintoolsNavbar', 'checkbox', 'Navbar Type');
-            this.build(this.$navbar, this.skintoolsNavbar, 'skintoolsNavbar', 'radio', 'Navbar Skins');
-            this.build(this.$primary, this.skintoolsPrimary, 'skintoolsPrimary', 'radio', 'Primary Skins');
-
-            this.$container.appendTo($body);
-
-            this.$toggle.on('click', function () {
-              self.$container.toggleClass('is-open');
-            });
-
-            $('#skintoolsSidebar input').on('click', function () {
-              self.sidebarEvents(this);
-            });
-            $('#skintoolsNavbar input').on('click', function () {
-              self.navbarEvents(this);
-            });
-            $('#skintoolsPrimary input').on('click', function () {
-              self.primaryEvents(this);
-            });
-
-            $('#skintoolsReset').on('click', function () {
-              self.reset();
-            });
-
-            this.initLocalStorage();
-          },
-          initLocalStorage: function initLocalStorage() {
-            var self = this;
-
-            this.settings = Storage.get(this.storageKey);
-
-            if (this.settings === null) {
-              this.settings = $.extend(true, {}, this.defaultSettings);
-
-              Storage.set(this.storageKey, this.settings);
-            }
-
-            if (this.settings && $.isPlainObject(this.settings)) {
-              $.each(this.settings, function (n, v) {
-                switch (n) {
-                  case 'sidebar':
-                    $('input[value="' + v + '"]', self.$sidebar).prop('checked', true);
-                    self.sidebarImprove(v);
-                    break;
-                  case 'navbar':
-                    $('input[value="' + v + '"]', self.$navbar).prop('checked', true);
-                    self.navbarImprove(v);
-                    break;
-                  case 'navbarInverse':
-                    var flag = v === 'false' ? false : true;
-                    $('input[value="inverse"]', self.$navbar).prop('checked', flag);
-                    self.navbarImprove('inverse', flag);
-                    break;
-                  case 'primary':
-                    $('input[value="' + v + '"]', self.$primary).prop('checked', true);
-                    self.primaryImprove(v);
-                    break;
-                }
-              });
-            }
-          },
-          updateSetting: function updateSetting(item, value) {
-            this.settings[item] = value;
-            Storage.set(this.storageKey, this.settings);
-          },
-          title: function title(content) {
-            return $('<h4 class="site-skintools-title">' + content + '</h4>');
-          },
-          item: function item(type, name, id, content) {
-            var item = '<div class="' + type + '-custom ' + type + '-' + content + '"><input id="' + id + '" type="' + type + '" name="' + name + '" value="' + content + '"><label for="' + id + '">' + content + '</label></div>';
-            return $(item);
-          },
-          build: function build($wrap, data, name, type, title) {
-            if (title) {
-              this.title(title).appendTo($wrap);
-            }
-            for (var i = 0; i < data.length; i++) {
-              this.item(type, name, name + '-' + data[i], data[i]).appendTo($wrap);
-            }
-          },
-          sidebarEvents: function sidebarEvents(self) {
-            var val = $(self).val();
-
-            this.sidebarImprove(val);
-            this.updateSetting('sidebar', val);
-          },
-          navbarEvents: function navbarEvents(self) {
-            var val = $(self).val();
-            var checked = $(self).prop('checked');
-
-            this.navbarImprove(val, checked);
-
-            if (val === 'inverse') {
-              this.updateSetting('navbarInverse', checked.toString());
-            } else {
-              this.updateSetting('navbar', val);
-            }
-          },
-          primaryEvents: function primaryEvents(self) {
-            var val = $(self).val();
-
-            this.primaryImprove(val);
-
-            this.updateSetting('primary', val);
-          },
-          sidebarImprove: function sidebarImprove(val) {
-            if (val === 'dark') {
-              this.$siteSidebar.removeClass('site-menubar-light');
-            } else if (val === 'light') {
-              this.$siteSidebar.addClass('site-menubar-' + val);
-            }
-          },
-          navbarImprove: function navbarImprove(val, checked) {
-            if (val === 'inverse') {
-              checked ? this.$siteNavbar.addClass('navbar-inverse') : this.$siteNavbar.removeClass('navbar-inverse');
-            } else {
-              var bg = 'bg-' + val + '-600';
-              if (val === 'yellow') {
-                bg = 'bg-yellow-700';
-              }
-              if (val === 'primary') {
-                bg = '';
-              }
-
-              this.$siteNavbar.removeClass(this.navbarSkins).addClass(bg);
-            }
-          },
-          primaryImprove: function primaryImprove(val) {
-            var $link = $('#skinStyle', $('head'));
-            var href = this.path + 'assets/skins/' + val + '.css';
-            if (val === 'primary') {
-              $link.remove();
-              return;
-            }
-            if ($link.length === 0) {
-              $('head').append('<link id="skinStyle" href="' + href + '" rel="stylesheet" type="text/css"/>');
-            } else {
-              $link.attr('href', href);
-            }
-          },
-          reset: function reset() {
-            localStorage.clear();
-            this.initLocalStorage();
-          }
-        };
-
-        Skintools.init();
-      });
-    }
-  }
-});

public/js/vendor/Plugin/slidepanel.js

@@ -1,92 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/slidepanel', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginSlidepanel = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'slidePanel';
-
-  var SlidePanel = function (_Plugin) {
-    babelHelpers.inherits(SlidePanel, _Plugin);
-
-    function SlidePanel() {
-      babelHelpers.classCallCheck(this, SlidePanel);
-      return babelHelpers.possibleConstructorReturn(this, (SlidePanel.__proto__ || Object.getPrototypeOf(SlidePanel)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(SlidePanel, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof _jquery2.default.slidePanel === 'undefined') {
-          return;
-        }
-        if (!this.options.url) {
-          this.options.url = this.$el.attr('href');
-          this.options.url = this.options.url && this.options.url.replace(/.*(?=#[^\s]*$)/, '');
-        }
-
-        this.$el.data('slidePanelWrapAPI', this);
-      }
-    }, {
-      key: 'show',
-      value: function show() {
-        var options = this.options;
-
-        _jquery2.default.slidePanel.show({
-          url: options.url
-        }, options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          closeSelector: '.slidePanel-close',
-          mouseDragHandler: '.slidePanel-handler',
-          loading: {
-            template: function template(options) {
-              return '<div class="' + options.classes.loading + '">\n                    <div class="loader loader-default"></div>\n                  </div>';
-            },
-            showCallback: function showCallback(options) {
-              this.$el.addClass(options.classes.loading + '-show');
-            },
-            hideCallback: function hideCallback(options) {
-              this.$el.removeClass(options.classes.loading + '-show');
-            }
-          }
-        };
-      }
-    }, {
-      key: 'api',
-      value: function api() {
-        return 'click|show';
-      }
-    }]);
-    return SlidePanel;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, SlidePanel);
-
-  exports.default = SlidePanel;
-});

public/js/vendor/Plugin/sortable.js

@@ -1,57 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/sortable', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginSortable = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'sortable';
-
-  var Sortable = function (_Plugin) {
-    babelHelpers.inherits(Sortable, _Plugin);
-
-    function Sortable() {
-      babelHelpers.classCallCheck(this, Sortable);
-      return babelHelpers.possibleConstructorReturn(this, (Sortable.__proto__ || Object.getPrototypeOf(Sortable)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Sortable, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        window.Sortable.create(this.$el.get(0), this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          ghostClass: 'sortable-placeholder',
-          dragClass: 'sortable-dragging'
-        };
-      }
-    }]);
-    return Sortable;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Sortable);
-
-  exports.default = Sortable;
-});

public/js/vendor/Plugin/sticky-header.js

@@ -1,140 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/sticky-header', ['exports', 'jquery'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery);
-    global.PluginStickyHeader = mod.exports;
-  }
-})(this, function (exports, _jquery) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var pluginName = 'stickyHeader';
-
-  var defaults = {
-    headerSelector: '.header',
-    changeHeaderOn: 100,
-    activeClassName: 'active-sticky-header',
-    min: 50,
-    method: 'toggle'
-  };
-
-  var stickyHeader = function () {
-    function stickyHeader(el, options) {
-      babelHelpers.classCallCheck(this, stickyHeader);
-
-      this.isActive = false;
-      this.init(options);
-      this.bind();
-    }
-
-    babelHelpers.createClass(stickyHeader, [{
-      key: 'init',
-      value: function init(options) {
-        var $el = this.$el.css('transition', 'none');
-
-        var $header = this.$header = $el.find(options.headerSelector).css({
-          position: 'absolute',
-          top: 0,
-          left: 0
-        });
-
-        this.options = _jquery2.default.extend(true, {}, defaults, options, $header.data());
-        this.headerHeight = $header.outerHeight();
-        // this.offsetTop()
-        // $el.css('transition','all .5s linear');
-        // $header.css('transition','all .5s linear');
-        this.$el.css('paddingTop', this.headerHeight);
-      }
-    }, {
-      key: '_toggleActive',
-      value: function _toggleActive() {
-        if (this.isActive) {
-          this.$header.css('height', this.options.min);
-        } else {
-          this.$header.css('height', this.headerHeight);
-        }
-      }
-    }, {
-      key: 'bind',
-      value: function bind() {
-        var self = this;
-        this.$el.on('scroll', function () {
-          if (self.options.method === 'toggle') {
-            if ((0, _jquery2.default)(this).scrollTop() > self.options.changeHeaderOn && !self.isActive) {
-              self.$el.addClass(self.options.activeClassName);
-              self.isActive = true;
-              self.$header.css('height', self.options.min);
-              self.$el.trigger('toggle:sticky', [self, self.isActive]);
-            } else if ((0, _jquery2.default)(this).scrollTop() <= self.options.changeHeaderOn && self.isActive) {
-              self.$el.removeClass(self.options.activeClassName);
-              self.isActive = false;
-              self.$header.css('height', self.headerHeight);
-              self.$el.trigger('toggle:sticky', [self, self.isActive]);
-            }
-          } else if (self.options.method === 'scroll') {
-            var offset = Math.max(self.headerHeight - (0, _jquery2.default)(this).scrollTop(), self.options.min);
-            if (offset === self.headerHeight) {
-              self.$el.removeClass(self.options.activeClassName);
-            } else {
-              self.$el.addClass(self.options.activeClassName);
-            }
-            self.$header.css('height', offset);
-            self.$el.trigger('toggle:sticky', [self]);
-          }
-        });
-      }
-    }], [{
-      key: '_jQueryInterface',
-      value: function _jQueryInterface(options) {
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        if (typeof options === 'string') {
-          var method = options;
-          if (/^\_/.test(method)) {
-            return false;
-          } else {
-            return this.each(function () {
-              var api = _jquery2.default.data(this, pluginName);
-              if (api && typeof api[method] === 'function') {
-                api[method].apply(api, args);
-              }
-            });
-          }
-        } else {
-          return this.each(function () {
-            if (!_jquery2.default.data(this, pluginName)) {
-              _jquery2.default.data(this, pluginName, new stickyHeader(this, options));
-            } else {
-              _jquery2.default.data(this, pluginName).init(options);
-            }
-          });
-        }
-      }
-    }]);
-    return stickyHeader;
-  }();
-
-  _jquery2.default.fn[pluginName] = stickyHeader._jQueryInterface;
-  _jquery2.default.fn[pluginName].constructor = stickyHeader;
-  _jquery2.default.fn[pluginName].noConflict = function () {
-    'use strict';
-
-    _jquery2.default.fn[pluginName] = window.JQUERY_NO_CONFLICT;
-    return stickyHeader._jQueryInterface;
-  };
-
-  exports.default = stickyHeader;
-});

public/js/vendor/Plugin/summernote.js

@@ -1,51 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/summernote', ['exports', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin);
-    global.PluginSummernote = mod.exports;
-  }
-})(this, function (exports, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'summernote';
-
-  var Summernote = function (_Plugin) {
-    babelHelpers.inherits(Summernote, _Plugin);
-
-    function Summernote() {
-      babelHelpers.classCallCheck(this, Summernote);
-      return babelHelpers.possibleConstructorReturn(this, (Summernote.__proto__ || Object.getPrototypeOf(Summernote)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(Summernote, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          height: 300
-        };
-      }
-    }]);
-    return Summernote;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, Summernote);
-
-  exports.default = Summernote;
-});

public/js/vendor/Plugin/switchery.js

@@ -1,59 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/switchery', ['exports', 'Plugin', 'Config'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('Plugin'), require('Config'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.Plugin, global.Config);
-    global.PluginSwitchery = mod.exports;
-  }
-})(this, function (exports, _Plugin2, _Config) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'switchery';
-
-  var SwitcheryPlugin = function (_Plugin) {
-    babelHelpers.inherits(SwitcheryPlugin, _Plugin);
-
-    function SwitcheryPlugin() {
-      babelHelpers.classCallCheck(this, SwitcheryPlugin);
-      return babelHelpers.possibleConstructorReturn(this, (SwitcheryPlugin.__proto__ || Object.getPrototypeOf(SwitcheryPlugin)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(SwitcheryPlugin, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        if (typeof Switchery === 'undefined') {
-          return;
-        }
-        new Switchery(this.$el[0], this.options);
-      }
-    }], [{
-      key: 'getDefaults',
-      value: function getDefaults() {
-        return {
-          color: (0, _Config.colors)('primary', 600)
-        };
-      }
-    }]);
-    return SwitcheryPlugin;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, SwitcheryPlugin);
-
-  exports.default = SwitcheryPlugin;
-});

public/js/vendor/Plugin/table.js

@@ -1,75 +0,0 @@
-(function (global, factory) {
-  if (typeof define === "function" && define.amd) {
-    define('/Plugin/table', ['exports', 'jquery', 'Plugin'], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require('jquery'), require('Plugin'));
-  } else {
-    var mod = {
-      exports: {}
-    };
-    factory(mod.exports, global.jQuery, global.Plugin);
-    global.PluginTable = mod.exports;
-  }
-})(this, function (exports, _jquery, _Plugin2) {
-  'use strict';
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-
-  var _jquery2 = babelHelpers.interopRequireDefault(_jquery);
-
-  var _Plugin3 = babelHelpers.interopRequireDefault(_Plugin2);
-
-  var NAME = 'tableSection';
-
-  var TableSection = function (_Plugin) {
-    babelHelpers.inherits(TableSection, _Plugin);
-
-    function TableSection() {
-      babelHelpers.classCallCheck(this, TableSection);
-      return babelHelpers.possibleConstructorReturn(this, (TableSection.__proto__ || Object.getPrototypeOf(TableSection)).apply(this, arguments));
-    }
-
-    babelHelpers.createClass(TableSection, [{
-      key: 'getName',
-      value: function getName() {
-        return NAME;
-      }
-    }, {
-      key: 'render',
-      value: function render() {
-        this.$el.data('tableApi', this);
-      }
-    }, {
-      key: 'toggle',
-      value: function toggle(e) {
-        var $el = this.$el;
-        if (e.target.type !== 'checkbox' && e.target.type !== 'button' && e.target.tagName.toLowerCase() !== 'a' && !(0, _jquery2.default)(e.target).parent('div.checkbox-custom').length) {
-          if ($el.hasClass('active')) {
-            $el.removeClass('active');
-          } else {
-            $el.siblings('.table-section').removeClass('active');
-            $el.addClass('active');
-          }
-        }
-      }
-    }], [{
-      key: 'api',
-      value: function api() {
-        var api = 'click|toggle',
-            touch = typeof document.ontouchstart !== 'undefined';
-
-        if (touch) {
-          api = 'touchstart|toggle';
-        }
-        return api;
-      }
-    }]);
-    return TableSection;
-  }(_Plugin3.default);
-
-  _Plugin3.default.register(NAME, TableSection);
-
-  exports.default = TableSection;
-});