generated code; begin domain and records

app/Http/Business/DnsDomainsBusiness.php

@@ -17,15 +17,18 @@ class DnsDomainsBusiness extends LuBusiness {
         if (is_null($domain->getName()) || !is_string($domain->getName())) {
             self::badInput("Name must be an string");
         }
+        if (strtoupper($domain->getType()) != "MASTER" && strtoupper($domain->getType()) != "SLAVE") {
+            self::badInput("Type must be SLAVE or MASTER");
+        }
+        $domain->setType(strtoupper($domain->getType()));
+        $domain->setLastCheck(null);
+        $domain->setNotifiedSerial(null);
+        $domain->setAccount(null);
     }
 
     public static function add(DnsDomainsDbo $domain)
     {
-        return 0;
-    }
-
-    public static function edit(DnsDomainsDbo $domain)
-    {
-        return 0;
+        self::checkDomain($domain);
+        return DnsDomainsDataAccess::addId($domain);
     }
 }

app/Http/Business/DnsRecordsBusiness.php

@@ -2,13 +2,59 @@
 
 namespace App\Http\Business;
 
+use Carbon\Carbon;
 use Luticate\Utils\LuBusiness;
 use App\Http\DataAccess\DnsRecordsDataAccess;
 use App\Http\DBO\DnsRecordsDbo;
 
 class DnsRecordsBusiness extends LuBusiness {
+
+    const RECORD_TYPES = array("A", "AAAA", "CNAME", "HINFO", "MX", "NAPTR", "NS", "PTR",
+        "SOA", "SPF", "SRV", "SSHFP", "TXT", "RP");
+
     protected static function getDataAccess()
     {
         return new DnsRecordsDataAccess();
     }
+
+    public static function checkRecord(DnsRecordsDbo $record)
+    {
+        DnsDomainsBusiness::getById($record->getDomainId());
+        if (is_null($record->getName()) || !is_string($record->getName())) {
+            self::badInput("Name must be an string");
+        }
+        if (is_null($record->getContent()) || !is_string($record->getContent())) {
+            self::badInput("Content must be an string");
+        }
+        if (!in_array($record->getType(), self::RECORD_TYPES)) {
+            self::badInput("Type be must be one of " . join(",", self::RECORD_TYPES));
+        }
+        if (!is_bool($record->getDisabled())) {
+            self::badInput("Disabled must be a boolean");
+        }
+        if (!is_bool($record->getAuth())) {
+            self::badInput("Auth must be a boolean");
+        }
+        if (!is_null($record->getOrdername()) && !is_string($record->getOrdername())) {
+            self::badInput("Ordername must be an string or null");
+        }
+        if (!is_int($record->getPrio())) {
+            self::badInput("Prio must be an int");
+        }
+        if (!is_int($record->getTtl())) {
+            self::badInput("Ttl must be a int");
+        }
+        $record->setChangeDate(Carbon::now()->timestamp);
+    }
+
+    public static function getAll($domain_id, $page = 0, $perPage = PHP_INT_MAX, $query = "")
+    {
+        return DnsRecordsDataAccess::getAll($domain_id, $query, $page, $perPage);
+    }
+
+    public static function add(DnsRecordsDbo $record)
+    {
+        self::checkRecord($record);
+        return DnsRecordsDataAccess::addId($record);
+    }
 }

app/Http/Controller/DnsDomainsController.php

@@ -25,19 +25,23 @@ class DnsDomainsController extends LuController {
         return DnsDomainsBusiness::getAll($page, $perPage, $query);
     }
 
+    /**
+     * Add a new DNS domain
+     * @param DnsDomainsDbo $domain The new domain
+     * @return int
+     */
     public function add(DnsDomainsDbo $domain)
     {
         return DnsDomainsBusiness::add($domain);
     }
 
+    /**
+     * Delete a DNS domain
+     * @param LuIntDbo $domain_id The domain id
+     * @return bool
+     */
     public function del(LuIntDbo $domain_id)
     {
         return DnsDomainsBusiness::deleteById($domain_id->getInt());
     }
-
-    public function edit(LuIntDbo $domain_id, DnsDomainsDbo $domain)
-    {
-        $domain->setId($domain_id->getInt());
-        return DnsDomainsBusiness::edit($domain);
-    }
 }

app/Http/Controller/DnsRecordsController.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Controller;
 
+use Luticate\Utils\Dbo\LuIntDbo;
 use Luticate\Utils\LuController;
 use App\Http\Business\DnsRecordsBusiness;
 use App\Http\DBO\DnsRecordsDbo;
@@ -11,4 +12,37 @@ class DnsRecordsController extends LuController {
     {
         return new DnsRecordsBusiness();
     }
+
+    /**
+     * Get all dns domain records
+     * @param LuIntDbo $domain_id The domain id
+     * @param int $page The page number, 0 based
+     * @param int $perPage Items per page
+     * @param string $query The filter query
+     * @return \App\Http\DBO\DnsDomainsDbo[]
+     */
+    public function getAll(LuIntDbo $domain_id, $page = 0, $perPage = 20000000, $query = "")
+    {
+        return DnsRecordsBusiness::getAll($domain_id->getInt(), $page, $perPage, $query);
+    }
+
+    /**
+     * Add a new DNS domain record
+     * @param DnsRecordsDbo $record The new domain record
+     * @return int
+     */
+    public function add(DnsRecordsDbo $record)
+    {
+        return DnsRecordsBusiness::add($record);
+    }
+
+    /**
+     * Delete a DNS domain record
+     * @param LuIntDbo $domain_id The domain record id
+     * @return bool
+     */
+    public function del(LuIntDbo $domain_id)
+    {
+        return DnsRecordsBusiness::deleteById($domain_id->getInt());
+    }
 }

app/Http/DataAccess/DnsDomainsDataAccess.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\DataAccess;
 
+use App\Http\DataAccess\SP\SpGetDomains;
 use Luticate\Utils\LuDataAccess;
 use App\Http\DataAccess\Models\DnsDomains;
 use App\Http\DBO\DnsDomainsDbo;
@@ -11,4 +12,14 @@ class DnsDomainsDataAccess extends LuDataAccess {
     {
         return new DnsDomains();
     }
+
+    protected static function getOrderBy()
+    {
+        return array(array("name", "ASC"));
+    }
+
+    public static function getAll($page = 0, $perPage = PHP_INT_MAX, $query = "")
+    {
+        return SpGetDomains::getMultipleJson($query, $page, $perPage);
+    }
 }

app/Http/DataAccess/DnsRecordsDataAccess.php

@@ -2,13 +2,23 @@
 
 namespace App\Http\DataAccess;
 
+use App\Http\DataAccess\SP\SpGetDomainRecords;
 use Luticate\Utils\LuDataAccess;
 use App\Http\DataAccess\Models\DnsRecords;
-use App\Http\DBO\DnsRecordsDbo;
 
 class DnsRecordsDataAccess extends LuDataAccess {
     protected static function getModel()
     {
         return new DnsRecords();
     }
+
+    protected static function getOrderBy()
+    {
+        return array(array("name", "ASC"));
+    }
+
+    public static function getAll($domain_id, $page = 0, $perPage = PHP_INT_MAX, $query = "")
+    {
+        return SpGetDomainRecords::getMultipleJson($domain_id, $query, $page, $perPage);
+    }
 }

app/Http/DataAccess/SP/SpGetDomainRecords.php

@@ -0,0 +1,103 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class SpGetDomainRecords extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\SpGetDomainRecords|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new SpGetDomainRecords();
+
+        $dbo->setRecords(LuStringUtils::convertJsonString($dam->records));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $domain_id integer
+    * @param $query string
+    * @return \App\Http\DataAccess\SP\SpGetDomainRecords[];
+    */
+    public static function execute($domain_id, $query)
+    {
+        $values = DB::select('SELECT to_json(data.records) AS records FROM sp_get_domain_records(:domain_id, :query) data', array(":domain_id" => $domain_id, ":query" => $query));
+        $dboValues = array();
+        foreach ($values as $value)
+            $dboValues[] = self::damToDbo($value);
+        return $dboValues;
+    }
+
+    /**
+    * @param $domain_id integer
+    * @param $query string
+    * @param $page int The page number, 0 based
+    * @param $perPage int The number of items per page
+    * @return \Luticate\Utils\LuMultipleDbo;
+    */
+    public static function getMultipleJson($domain_id, $query, $page, $perPage)
+    {
+        $values = DB::select('SELECT (SELECT count(*) FROM sp_get_domain_records(:domain_id, :query)) as count, (SELECT json_agg(q) FROM (SELECT * FROM sp_get_domain_records(:domain_id, :query) OFFSET (:page::int * :perPage::int) LIMIT :perPage) q) as data',
+            array(":domain_id" => $domain_id, ":query" => $query, ":page" => $page, ":perPage" => $perPage));
+        $value = $values[0];
+        if (is_null($value->data))
+        {
+            $value->data = '[]';
+        }
+        $data = LuStringUtils::convertJsonString($value->data);
+        return new LuMultipleDbo($value->count, $data);
+    }
+
+    public function jsonSerialize()
+    {
+        return array(
+            "Records" => $this->_records
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new SpGetDomainRecords();
+        if (isset($json["Records"])) {
+            $dbo->setRecords($json["Records"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new SpGetDomainRecords();
+        $dbo->setRecords("sample string");
+        return $dbo;
+    }
+
+
+    /**
+    * @var USER-DEFINED
+    */
+    protected $_records;
+    public function getRecords()
+    {
+        return $this->_records;
+    }
+    public function setRecords($value)
+    {
+        $this->_records = $value;
+    }
+}

app/Http/DataAccess/SP/SpGetDomains.php

@@ -0,0 +1,101 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class SpGetDomains extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\SpGetDomains|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new SpGetDomains();
+
+        $dbo->setDomains(LuStringUtils::convertJsonString($dam->domains));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $query string
+    * @return \App\Http\DataAccess\SP\SpGetDomains[];
+    */
+    public static function execute($query)
+    {
+        $values = DB::select('SELECT to_json(data.domains) AS domains FROM sp_get_domains(:query) data', array(":query" => $query));
+        $dboValues = array();
+        foreach ($values as $value)
+            $dboValues[] = self::damToDbo($value);
+        return $dboValues;
+    }
+
+    /**
+    * @param $query string
+    * @param $page int The page number, 0 based
+    * @param $perPage int The number of items per page
+    * @return \Luticate\Utils\LuMultipleDbo;
+    */
+    public static function getMultipleJson($query, $page, $perPage)
+    {
+        $values = DB::select('SELECT (SELECT count(*) FROM sp_get_domains(:query)) as count, (SELECT json_agg(q) FROM (SELECT * FROM sp_get_domains(:query) OFFSET (:page::int * :perPage::int) LIMIT :perPage) q) as data',
+            array(":query" => $query, ":page" => $page, ":perPage" => $perPage));
+        $value = $values[0];
+        if (is_null($value->data))
+        {
+            $value->data = '[]';
+        }
+        $data = LuStringUtils::convertJsonString($value->data);
+        return new LuMultipleDbo($value->count, $data);
+    }
+
+    public function jsonSerialize()
+    {
+        return array(
+            "Domains" => $this->_domains
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new SpGetDomains();
+        if (isset($json["Domains"])) {
+            $dbo->setDomains($json["Domains"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new SpGetDomains();
+        $dbo->setDomains("sample string");
+        return $dbo;
+    }
+
+
+    /**
+    * @var USER-DEFINED
+    */
+    protected $_domains;
+    public function getDomains()
+    {
+        return $this->_domains;
+    }
+    public function setDomains($value)
+    {
+        $this->_domains = $value;
+    }
+}

app/Http/DataAccess/SP/SpSearch.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class SpSearch extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\SpSearch|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new SpSearch();
+
+        $dbo->setRes(LuStringUtils::convertJsonString($dam->_res));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $_text string
+    * @param $_query string
+    * @return \App\Http\DataAccess\SP\SpSearch;
+    */
+    public static function execute($_text, $_query)
+    {
+        $values = DB::select('SELECT to_json(data._res) AS _res FROM sp_search(:_text, :_query) data', array(":_text" => $_text, ":_query" => $_query));
+        return self::damToDbo($values[0]);
+    }
+
+
+    public function jsonSerialize()
+    {
+        return array(
+            "Res" => $this->_Res
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new SpSearch();
+        if (isset($json["Res"])) {
+            $dbo->setRes($json["Res"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new SpSearch();
+        $dbo->setRes(true);
+        return $dbo;
+    }
+
+
+    /**
+    * @var boolean
+    */
+    protected $_Res;
+    public function getRes()
+    {
+        return $this->_Res;
+    }
+    public function setRes($value)
+    {
+        $this->_Res = $value;
+    }
+}

app/Http/DataAccess/SP/Unaccent.php

@@ -0,0 +1,82 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class Unaccent extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\Unaccent|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new Unaccent();
+
+        $dbo->setUnaccent(LuStringUtils::convertJsonString($dam->unaccent));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $ regdictionary
+    * @param $ text
+    * @param $ text
+    * @return \App\Http\DataAccess\SP\Unaccent;
+    */
+    public static function execute($, $, $)
+    {
+        $values = DB::select('SELECT to_json(data.unaccent) AS unaccent FROM unaccent(:, :, :) data', array(":" => $, ":" => $, ":" => $));
+        return self::damToDbo($values[0]);
+    }
+
+
+    public function jsonSerialize()
+    {
+        return array(
+            "Unaccent" => $this->_unaccent
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new Unaccent();
+        if (isset($json["Unaccent"])) {
+            $dbo->setUnaccent($json["Unaccent"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new Unaccent();
+        $dbo->setUnaccent("sample string");
+        return $dbo;
+    }
+
+
+    /**
+    * @var text
+    */
+    protected $_unaccent;
+    public function getUnaccent()
+    {
+        return $this->_unaccent;
+    }
+    public function setUnaccent($value)
+    {
+        $this->_unaccent = $value;
+    }
+}

app/Http/DataAccess/SP/UnaccentInit.php

@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class UnaccentInit extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\UnaccentInit|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new UnaccentInit();
+
+        $dbo->setUnaccentInit(LuStringUtils::convertJsonString($dam->unaccent_init));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $ internal
+    * @return \App\Http\DataAccess\SP\UnaccentInit;
+    */
+    public static function execute($)
+    {
+        $values = DB::select('SELECT to_json(data.unaccent_init) AS unaccent_init FROM unaccent_init(:) data', array(":" => $));
+        return self::damToDbo($values[0]);
+    }
+
+
+    public function jsonSerialize()
+    {
+        return array(
+            "UnaccentInit" => $this->_unaccentInit
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new UnaccentInit();
+        if (isset($json["UnaccentInit"])) {
+            $dbo->setUnaccentInit($json["UnaccentInit"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new UnaccentInit();
+        $dbo->setUnaccentInit("sample string");
+        return $dbo;
+    }
+
+
+    /**
+    * @var internal
+    */
+    protected $_unaccentInit;
+    public function getUnaccentInit()
+    {
+        return $this->_unaccentInit;
+    }
+    public function setUnaccentInit($value)
+    {
+        $this->_unaccentInit = $value;
+    }
+}

app/Http/DataAccess/SP/UnaccentLexize.php

@@ -0,0 +1,83 @@
+<?php
+
+/**
+ * AUTO GENERATED BY LUTICATE GENERATOR
+ * ANY CHANGES WILL BE OVERWRITTEN
+ */
+
+namespace App\Http\DataAccess\SP;
+
+use Luticate\Utils\LuSpDbo;
+use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
+use Illuminate\Support\Facades\DB;
+
+class UnaccentLexize extends LuSpDbo {
+
+    /**
+    * @param $dam
+    * @return \App\Http\DataAccess\SP\UnaccentLexize|null
+    */
+    protected static function damToDbo($dam)
+    {
+        if (is_null($dam))
+            return null;
+        $dbo = new UnaccentLexize();
+
+        $dbo->setUnaccentLexize(LuStringUtils::convertJsonString($dam->unaccent_lexize));
+
+        return $dbo;
+    }
+
+
+    /**
+    * @param $ internal
+    * @param $ internal
+    * @param $ internal
+    * @param $ internal
+    * @return \App\Http\DataAccess\SP\UnaccentLexize;
+    */
+    public static function execute($, $, $, $)
+    {
+        $values = DB::select('SELECT to_json(data.unaccent_lexize) AS unaccent_lexize FROM unaccent_lexize(:, :, :, :) data', array(":" => $, ":" => $, ":" => $, ":" => $));
+        return self::damToDbo($values[0]);
+    }
+
+
+    public function jsonSerialize()
+    {
+        return array(
+            "UnaccentLexize" => $this->_unaccentLexize
+        );
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        $dbo = new UnaccentLexize();
+        if (isset($json["UnaccentLexize"])) {
+            $dbo->setUnaccentLexize($json["UnaccentLexize"]);
+        }
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        $dbo = new UnaccentLexize();
+        $dbo->setUnaccentLexize("sample string");
+        return $dbo;
+    }
+
+
+    /**
+    * @var internal
+    */
+    protected $_unaccentLexize;
+    public function getUnaccentLexize()
+    {
+        return $this->_unaccentLexize;
+    }
+    public function setUnaccentLexize($value)
+    {
+        $this->_unaccentLexize = $value;
+    }
+}

app/Http/DataAccess/SP/src/sp_get_domain_records.sql

@@ -0,0 +1,4 @@
+
+        SELECT r FROM dns_records r
+        WHERE sp_search(r.name, query)
+        ORDER BY r.name

app/Http/DataAccess/SP/src/sp_get_domains.sql

@@ -0,0 +1,4 @@
+
+        SELECT d FROM dns_domains d
+        WHERE sp_search(d.name, query)
+        ORDER BY d.name

app/Http/DataAccess/SP/src/sp_search.sql

@@ -0,0 +1,2 @@
+
+	SELECT unaccent(_text) ILIKE '%' || unaccent(_query) || '%'

app/Http/DataAccess/SP/src/unaccent.sql

@@ -0,0 +1 @@
+unaccent_dict

app/Http/DataAccess/SP/src/unaccent_init.sql

@@ -0,0 +1 @@
+unaccent_init

app/Http/DataAccess/SP/src/unaccent_lexize.sql

@@ -0,0 +1 @@
+unaccent_lexize

app/Http/routes.php

@@ -8,6 +8,7 @@ $route = LuRoute::getInstance();
 
 $int = LuRoute::REG_UINT;
 $domain_id = "{domain_id:$int}";
+$record_id = "{record_id:$int}";
 
 LuticateBusiness::setupAuth();
 LuticateBusiness::setupRoutes();
@@ -16,4 +17,7 @@ LuDocBusiness::setupRoutes("/lunet");
 $route->get("/dns", "DnsDomains", "getAll");
 $route->post("/dns/add", "DnsDomains", "add");
 $route->post("/dns/$domain_id/del", "DnsDomains", "del");
-$route->post("/dns/$domain_id/edit", "DnsDomains", "edit");
+
+$route->get("/dns/$domain_id/records", "DnsRecords", "getAll");
+$route->post("/dns/$domain_id/records/add", "DnsRecords", "add");
+$route->post("/dns/$domain_id/records/$record_id/del", "DnsRecords", "del");