kienan
/
AlternC
mirror of https://github.com/kienanstewart/AlternC.git
1
0
Fork 0
Code Issues Releases Wiki Activity

[enh] formatting

This commit is contained in:
Benjamin Sonntag 2015-01-12 20:16:28 +01:00
parent afbed13686
commit a1a49955c2
10 changed files with 659 additions and 685 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
lib/Alternc/Api/Auth/Interface.php
View File

@ -6,25 +6,21 @@
*/ */
interface Alternc_Api_Auth_Interface { interface Alternc_Api_Auth_Interface {
/** /**
* contructor : * contructor :
* $service is an Alternc_Api_Service object having a getDb() method * $service is an Alternc_Api_Service object having a getDb() method
*/ */
function __construct($service); function __construct($service);
/**
* auth takes options specific to the auth itself
* returns an Alternc_Api_Token object
*/
function auth($options);
/** /**
* auth takes options specific to the auth itself * instructions on how to use this Auth class
* returns an Alternc_Api_Token object * @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
*/ */
function auth($options); function instructions();
/**
* instructions on how to use this Auth class
* @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
*/
function instructions();
} }

110
lib/Alternc/Api/Auth/Login.php
View File

@ -5,71 +5,67 @@
*/ */
class Alternc_Api_Auth_Login implements Alternc_Api_Auth_Interface { class Alternc_Api_Auth_Login implements Alternc_Api_Auth_Interface {
private $db; // PDO object
private $db; // PDO object const ERR_INVALID_ARGUMENT = 1111201;
const ERR_INVALID_ARGUMENT = 1111201; /**
* Constructor of the Login Api Auth
*
* @param $service an Alternc_Api_Service object
* @return create the object
*/
function __construct($service) {
/** if (!($service instanceof Alternc_Api_Service))
* Constructor of the Login Api Auth throw new \Exception("Invalid argument (service)", ERR_INVALID_ARGUMENT);
*
* @param $service an Alternc_Api_Service object
* @return create the object
*/
function __constructor($service) {
if (!($service instanceof Alternc_Api_Service)) $this->db = $service->getDb();
throw new \Exception("Invalid argument (service)",ERR_INVALID_ARGUMENT);
$this->db = $service->getDb();
} // __construct
/**
* Authenticate a user
*
* @param $options options, depending on the auth scheme, including uid for setuid users
* here, login is the alternc username, and password is the password for this username.
* @return an Alternc_Api_Token
*/
function auth($options) {
if (!isset($options["login"]) || !is_string($options["login"])) {
throw new \Exception("Missing required parameter login", self::ERR_INVALID_ARGUMENT);
}
if (!isset($options["password"]) || !is_string($options["password"])) {
throw new \Exception("Missing required parameter password", self::ERR_INVALID_ARGUMENT);
} }
if (!preg_match("#^[0-9a-zA-Z-]{1,32}$#",$options["login"])) { // FIXME : normalize this on AlternC !!! /**
throw new \Exception("Invalid login", self::ERR_INVALID_LOGIN); * Authenticate a user
*
* @param $options options, depending on the auth scheme, including uid for setuid users
* here, login is the alternc username, and password is the password for this username.
* @return an Alternc_Api_Token
*/
function auth($options) {
if (!isset($options["login"]) || !is_string($options["login"])) {
throw new \Exception("Missing required parameter login", self::ERR_INVALID_ARGUMENT);
}
if (!isset($options["password"]) || !is_string($options["password"])) {
throw new \Exception("Missing required parameter password", self::ERR_INVALID_ARGUMENT);
}
if (!preg_match("#^[0-9a-zA-Z-]{1,32}$#", $options["login"])) { // FIXME : normalize this on AlternC !!!
throw new \Exception("Invalid login", self::ERR_INVALID_LOGIN);
}
$stmt = $db->query("SELECT m.enabled,m.uid,m.login,m.su FROM membres m WHERE m.login=? AND m.password=?;", array($options["login"], $options["password"]), PDO::FETCH_CLASS);
$me = $stmt->fetch();
if (!$me)
return new Alternc_Api_Response(array("code" => ERR_INVALID_AUTH, "message" => "Invalid login or password"));
if (!$me->enabled)
return new Alternc_Api_Response(array("code" => ERR_DISABLED_ACCOUNT, "message" => "Account is disabled"));
return Alternc_Api_Token::tokenGenerate(
array("uid" => $me->uid, "isAdmin" => ($me->su != 0)), $this->db
);
} }
$stmt = $db->query("SELECT m.enabled,m.uid,m.login,m.su FROM membres m WHERE m.login=? AND m.password=?;",array($options["login"],$options["password"]),PDO::FETCH_CLASS); /**
$me=$stmt->fetch(); * instructions on how to use this Auth class
if (!$me) * @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
return new Alternc_Api_Response(array("code"=>ERR_INVALID_AUTH, "message" => "Invalid login or password")); */
if (!$me->enabled) function instructions() {
return new Alternc_Api_Response(array("code"=>ERR_DISABLED_ACCOUNT, "message" => "Account is disabled")); return array("fields" => array("login" => "AlternC user account", "password" => "AlternC's user password stored in membres table."),
"description" => "Authenticate against an AlternC user and password, the same as for the control panel"
);
}
return Alternc_Api_Token::tokenGenerate( }
array("uid"=>$me->uid, "isAdmin"=>($me->su!=0) ),
$this->db
);
}
// class Alternc_Api_Auth_Login
/**
* instructions on how to use this Auth class
* @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
*/
function instructions() {
return array("fields" => array("login" => "AlternC user account", "password" => "AlternC's user password stored in membres table."),
"description" => "Authenticate against an AlternC user and password, the same as for the control panel"
);
}
} // class Alternc_Api_Auth_Login

128
lib/Alternc/Api/Auth/Sharedsecret.php
View File

@ -6,79 +6,77 @@
*/ */
class Alternc_Api_Auth_Sharedsecret implements Alternc_Api_Auth_Interface { class Alternc_Api_Auth_Sharedsecret implements Alternc_Api_Auth_Interface {
private $db; // PDO object
private $db; // PDO object const ERR_INVALID_ARGUMENT = 1111801;
const ERR_INVALID_SECRET = 1111802;
const ERR_INVALID_LOGIN = 1111803;
const ERR_DISABLED_ACCOUNT = 1111804;
const ERR_INVALID_AUTH = 1111805;
const ERR_INVALID_ARGUMENT = 1111801; /**
const ERR_INVALID_SECRET = 1111802; * Constructor of the Shared Secret Api Auth
const ERR_INVALID_LOGIN = 1111803; *
const ERR_DISABLED_ACCOUNT = 1111804; * @param $service an Alternc_Api_Service object
const ERR_INVALID_AUTH = 1111805; * @return create the object
*/
function __construct($service) {
/** if (!($service instanceof Alternc_Api_Service))
* Constructor of the Shared Secret Api Auth throw new \Exception("Invalid argument (service)", ERR_INVALID_ARGUMENT);
*
* @param $service an Alternc_Api_Service object
* @return create the object
*/
function __construct($service) {
if (!($service instanceof Alternc_Api_Service)) $this->db = $service->getDb();
throw new \Exception("Invalid argument (service)",ERR_INVALID_ARGUMENT);
$this->db = $service->getDb();
} // __construct
/**
* Authenticate a user
*
* @param $options options, depending on the auth scheme, including uid for setuid users
* here, login is the alternc username, and secret is a valid shared secret for this user.
* @return an Alternc_Api_Token
*/
function auth($options) {
if (!isset($options["login"]) || !is_string($options["login"])) {
throw new \Exception("Missing required parameter login", self::ERR_INVALID_ARGUMENT);
}
if (!isset($options["secret"]) || !is_string($options["secret"])) {
throw new \Exception("Missing required parameter secret", self::ERR_INVALID_ARGUMENT);
}
if (!preg_match("#^[0-9a-zA-Z]{32}$#",$options["secret"])) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_SECRET, "message" => "Invalid shared secret syntax") );
} }
if (!preg_match("#^[0-9a-zA-Z-]{1,32}$#",$options["login"])) { // FIXME : normalize this on AlternC !!! // __construct
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_LOGIN, "message" => "Invalid login") );
/**
* Authenticate a user
*
* @param $options options, depending on the auth scheme, including uid for setuid users
* here, login is the alternc username, and secret is a valid shared secret for this user.
* @return an Alternc_Api_Token
*/
function auth($options) {
if (!isset($options["login"]) || !is_string($options["login"])) {
throw new \Exception("Missing required parameter login", self::ERR_INVALID_ARGUMENT);
}
if (!isset($options["secret"]) || !is_string($options["secret"])) {
throw new \Exception("Missing required parameter secret", self::ERR_INVALID_ARGUMENT);
}
if (!preg_match("#^[0-9a-zA-Z]{32}$#", $options["secret"])) {
return new Alternc_Api_Response(array("code" => self::ERR_INVALID_SECRET, "message" => "Invalid shared secret syntax"));
}
if (!preg_match("#^[0-9a-zA-Z-]{1,32}$#", $options["login"])) { // FIXME : normalize this on AlternC !!!
return new Alternc_Api_Response(array("code" => self::ERR_INVALID_LOGIN, "message" => "Invalid login"));
}
$stmt = $this->db->prepare("SELECT m.enabled,m.uid,m.login,m.su FROM membres m, sharedsecret s WHERE s.uid=m.uid AND m.login=? AND s.secret=?;");
$stmt->execute(array($options["login"], $options["secret"]));
$me = $stmt->fetch(PDO::FETCH_OBJ);
if (!$me)
return new Alternc_Api_Response(array("code" => self::ERR_INVALID_AUTH, "message" => "Invalid shared secret"));
if (!$me->enabled)
return new Alternc_Api_Response(array("code" => self::ERR_DISABLED_ACCOUNT, "message" => "Account is disabled"));
return Alternc_Api_Token::tokenGenerate(
array("uid" => (int) $me->uid, "isAdmin" => ($me->su != 0)), $this->db
);
} }
$stmt = $this->db->prepare("SELECT m.enabled,m.uid,m.login,m.su FROM membres m, sharedsecret s WHERE s.uid=m.uid AND m.login=? AND s.secret=?;"); /**
$stmt->execute(array($options["login"],$options["secret"]) ); * instructions on how to use this Auth class
$me=$stmt->fetch(PDO::FETCH_OBJ); * @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
if (!$me) */
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_AUTH, "message" => "Invalid shared secret") ); function instructions() {
if (!$me->enabled) return array("fields" => array("login" => "AlternC user account", "secret" => "API Key, Shared secrets, valid for this account, stored in sharedsecret table."),
return new Alternc_Api_Response( array("code" => self::ERR_DISABLED_ACCOUNT, "message" => "Account is disabled") ); "description" => "Authenticate against an Api Key, also called SharedSecret. distinct from the account's password, can be plenty and revoked independently"
);
}
return Alternc_Api_Token::tokenGenerate( }
array("uid"=>(int)$me->uid, "isAdmin"=>($me->su!=0) ),
$this->db
);
}
// class Alternc_Api_Auth_Sharedsecret
/**
* instructions on how to use this Auth class
* @return array("fields" => array("fields to send, required or not"), "description" => "description of this auth")
*/
function instructions() {
return array("fields" => array("login" => "AlternC user account", "secret" => "API Key, Shared secrets, valid for this account, stored in sharedsecret table."),
"description" => "Authenticate against an Api Key, also called SharedSecret. distinct from the account's password, can be plenty and revoked independently"
);
}
} // class Alternc_Api_Auth_Sharedsecret

56
lib/Alternc/Api/Legacyobject.php
View File

@ -8,37 +8,37 @@
*/ */
class Alternc_Api_Legacyobject { class Alternc_Api_Legacyobject {
protected $admin; // m_admin instance protected $admin; // m_admin instance
protected $cuid; // current user id protected $cuid; // current user id
protected $isAdmin; // is it an Admin account? protected $isAdmin; // is it an Admin account?
protected $db; // PDO DB access to AlternC's database. protected $db; // PDO DB access to AlternC's database.
const ERR_INVALID_ARGUMENT = 111201; const ERR_INVALID_ARGUMENT = 111201;
const ERR_ALTERNC_FUNCTION = 111202; const ERR_ALTERNC_FUNCTION = 111202;
function __construct($service) { function __construct($service) {
global $admin,$cuid; global $admin, $cuid;
if (!($service instanceof Alternc_Api_Service)) { if (!($service instanceof Alternc_Api_Service)) {
throw new \Exception("Bad argument: service is not an Alternc_Api_Service", self::ERR_INVALID_ARGUMENT); throw new \Exception("Bad argument: service is not an Alternc_Api_Service", self::ERR_INVALID_ARGUMENT);
}
// We store the global $cuid to AlternC legacy classes
$this->db = $service->db;
$this->cuid = $cuid = $service->token->uid;
$this->isAdmin = $service->token->isAdmin;
// We use the global $admin from AlternC legacy classes
$this->admin = $admin;
// Set the legacy rights:
$this->admin->enabled = $this->isAdmin;
} }
// We store the global $cuid to AlternC legacy classes
$this->db=$service->db;
$this->cuid=$cuid=$service->token->uid;
$this->isAdmin=$service->token->isAdmin;
// We use the global $admin from AlternC legacy classes
$this->admin=$admin;
// Set the legacy rights:
$this->admin->enabled=$this->isAdmin;
}
/** return a proper Alternc_Api_Response from an error class and error string
* from AlternC legacy class
*/
protected function alterncLegacyErrorManager() {
global $err;
return new Alternc_Api_Response(array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "[" . $err->clsid . "] " . $err->error));
}
/** return a proper Alternc_Api_Response from an error class and error string }
* from AlternC legacy class
*/
protected function alterncLegacyErrorManager() {
global $err;
return new Alternc_Api_Response( array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "[".$err->clsid."] ".$err->error) );
}
/* Aternc_Api_Legacyobject */
} /* Aternc_Api_Legacyobject */

271
lib/Alternc/Api/Object/Domain.php
View File

@ -5,150 +5,147 @@
*/ */
class Alternc_Api_Object_Domain extends Alternc_Api_Legacyobject { class Alternc_Api_Object_Domain extends Alternc_Api_Legacyobject {
protected $dom; // m_dom instance
protected $dom; // m_dom instance function __construct($service) {
global $dom;
function __construct($service) { parent::__construct($service);
global $dom; $this->dom = $dom;
parent::__construct($service);
$this->dom=$dom;
} }
/** API Method from legacy class method dom->get_domain_list()
/** API Method from legacy class method dom->get_domain_list() * @param $options a hash with parameters transmitted to legacy call
* @param $options a hash with parameters transmitted to legacy call * may be "uid" to only return domains for a specific user-id
* may be "uid" to only return domains for a specific user-id * (if you are not admin, this WILL only list YOUR domains anyway)
* (if you are not admin, this WILL only list YOUR domains anyway) * may be "offset" and/or "count" to do paging.
* may be "offset" and/or "count" to do paging. * @return Alternc_Api_Response whose content is the list of hosted domains on this server
* @return Alternc_Api_Response whose content is the list of hosted domains on this server * (no more details as of now)
* (no more details as of now) */
*/ function find($options) {
function find($options) { global $cuid;
global $cuid; $sql = "";
$sql=""; if ($this->isAdmin) {
if ($this->isAdmin) { if (isset($options["uid"])) {
if (isset($options["uid"])) { $uid = intval($options["uid"]);
$uid=intval($options["uid"]); } else {
$uid = -1;
}
} else { } else {
$uid=-1; $uid = $cuid;
} }
} else { if ($uid != -1) {
$uid=$cuid; $sql = " WHERE compte=$uid ";
} } else {
if ($uid!=-1) { $sql = "";
$sql=" WHERE compte=$uid "; }
} else { $stmt = $this->db->prepare("SELECT * FROM domaines $sql ORDER BY domaine");
$sql=""; $stmt->execute();
} $result = array();
$stmt = $this->db->prepare("SELECT * FROM domaines $sql ORDER BY domaine"); while ($me = $stmt->fetch(PDO::FETCH_OBJ)) {
$stmt->execute(); $result[$me->domaine] = $me;
$result = array(); }
while ($me = $stmt->fetch(PDO::FETCH_OBJ)) { $offset = -1;
$result[$me->domaine] = $me; $count = -1;
} if (isset($options["count"]))
$offset=-1; $count=-1; $count = intval($options["count"]);
if (isset($options["count"])) $count=intval($options["count"]); if (isset($options["offset"]))
if (isset($options["offset"])) $offset=intval($options["offset"]); $offset = intval($options["offset"]);
if ($offset!=-1 || $count!=-1) { if ($offset != -1 || $count != -1) {
if ($offset<0 || $offset>count($result)) $offset=0; if ($offset < 0 || $offset > count($result))
if ($count<0 || $count>1000) $count=1000; $offset = 0;
$result= array_slice($result, $offset, $count); if ($count < 0 || $count > 1000)
} $count = 1000;
return new Alternc_Api_Response( array("content" =>$result) ); $result = array_slice($result, $offset, $count);
} }
return new Alternc_Api_Response(array("content" => $result));
}
/** API Method from legacy class method dom->add_domain()
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: domain(str), dns(bool)
* non-mandatory: noerase(bool, only admins), force(bool, only admins), isslave(bool), slavedom(str)
* @return Alternc_Api_Response whose content is the newly created DOMAIN id
*/
function add($options) {
$mandatory = array("domain", "dns");
$defaults = array("noerase" => false, "force" => false, "isslave" => false, "slavedom" => "");
$missing = "";
foreach ($mandatory as $key) {
if (!isset($options[$key])) {
$missing.=$key . " ";
}
}
if ($missing) {
return new Alternc_Api_Response(array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: " . $missing));
}
foreach ($defaults as $key => $value) {
if (!isset($options[$key])) {
$options[$key] = $value;
}
}
if (!$this->isAdmin) { // only admin can change the options below:
$options["noerase"] = false;
$options["force"] = false;
}
$did = $this->dom->add_domain($options["domain"], $options["dns"], $options["noerase"], $options["force"], $options["isslave"], $options["slavedom"]);
if (!$did) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response(array("content" => $did));
}
}
/** API Method from legacy class method dom->add_domain() /** API Method from legacy class method dom->edit_domain()
* @param $options a hash with parameters transmitted to legacy call * @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: domain(str), dns(bool) * mandatory parameters: domain(str), dns(bool)
* non-mandatory: noerase(bool, only admins), force(bool, only admins), isslave(bool), slavedom(str) * non-mandatory: noerase(bool, only admins), force(bool, only admins), isslave(bool), slavedom(str)
* @return Alternc_Api_Response whose content is the newly created DOMAIN id * @return Alternc_Api_Response whose content is the newly created DOMAIN id
*/ */
function add($options) { function update($options) {
$mandatory=array("domain","dns"); $mandatory = array("domain", "dns", "gesmx");
$defaults=array("noerase"=>false, "force"=>false, "isslave"=>false, "slavedom"=>""); $defaults = array("force" => false, "ttl" => 86400);
$missing=""; $missing = "";
foreach ($mandatory as $key) { foreach ($mandatory as $key) {
if (!isset($options[$key])) { if (!isset($options[$key])) {
$missing.=$key." "; $missing.=$key . " ";
} }
} }
if ($missing) { if ($missing) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: ".$missing) ); return new Alternc_Api_Response(array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: " . $missing));
} }
foreach ($defaults as $key => $value) { foreach ($defaults as $key => $value) {
if (!isset($options[$key])) { if (!isset($options[$key])) {
$options[$key]=$value; $options[$key] = $value;
} }
} }
if (!$this->isAdmin) { // only admin can change the options below: if (!$this->isAdmin) { // only admin can change the options below:
$options["noerase"]=false; $options["force"] = false;
$options["force"]=false; }
} $did = $this->dom->edit_domain($options["domain"], $options["dns"], $options["gesmx"], $options["force"], $options["ttl"]);
$did=$this->dom->add_domain($options["domain"], $options["dns"], $options["noerase"], if (!$did) {
$options["force"], $options["isslave"], $options["slavedom"]); return $this->alterncLegacyErrorManager();
if (!$did) { } else {
return $this->alterncLegacyErrorManager(); return new Alternc_Api_Response(array("content" => $did));
} else { }
return new Alternc_Api_Response( array("content" => $did ) ); }
}
}
/** API Method from legacy class method dom->del_domain()
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: domain
* @return Alternc_Api_Response TRUE if the domain has been marked for deletion.
*/
function del($options) {
if (!isset($options["domain"])) {
return new Alternc_Api_Response(array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "Missing or invalid argument: DOMAIN"));
}
$result = $this->dom->del_domain($options["domain"]);
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response(array("content" => true));
}
}
}
/** API Method from legacy class method dom->edit_domain() // class Alternc_Api_Object_Domain
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: domain(str), dns(bool)
* non-mandatory: noerase(bool, only admins), force(bool, only admins), isslave(bool), slavedom(str)
* @return Alternc_Api_Response whose content is the newly created DOMAIN id
*/
function update($options) {
$mandatory=array("domain","dns","gesmx");
$defaults=array("force"=>false, "ttl"=>86400);
$missing="";
foreach ($mandatory as $key) {
if (!isset($options[$key])) {
$missing.=$key." ";
}
}
if ($missing) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: ".$missing) );
}
foreach ($defaults as $key => $value) {
if (!isset($options[$key])) {
$options[$key]=$value;
}
}
if (!$this->isAdmin) { // only admin can change the options below:
$options["force"]=false;
}
$did=$this->dom->edit_domain($options["domain"], $options["dns"], $options["gesmx"],
$options["force"], $options["ttl"]);
if (!$did) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response( array("content" => $did ) );
}
}
/** API Method from legacy class method dom->del_domain()
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: domain
* @return Alternc_Api_Response TRUE if the domain has been marked for deletion.
*/
function del($options) {
if (!isset($options["domain"])) {
return new Alternc_Api_Response( array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "Missing or invalid argument: DOMAIN") );
}
$result=$this->dom->del_domain($options["domain"]);
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response( array("content" => true ) );
}
}
} // class Alternc_Api_Object_Domain

205
lib/Alternc/Api/Object/Ftp.php
View File

@ -5,111 +5,114 @@
*/ */
class Alternc_Api_Object_Ftp extends Alternc_Api_Legacyobject { class Alternc_Api_Object_Ftp extends Alternc_Api_Legacyobject {
protected $ftp; // m_ftp instance protected $ftp; // m_ftp instance
function __construct($service) { function __construct($service) {
global $ftp; global $ftp;
parent::__construct($service); parent::__construct($service);
$this->ftp=$ftp; $this->ftp = $ftp;
} }
/** API Method from legacy class method ftp->add_ftp()
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: prefix, login, pass, dir
* @return Alternc_Api_Response whose content is the newly created UID
*/
function add($options) {
$mandatory = array("prefix", "login", "pass", "dir");
$missing = "";
foreach ($mandatory as $key) {
if (!isset($options[$key])) {
$missing.=$key . " ";
}
}
if ($missing) {
return new Alternc_Api_Response(array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: " . $missing));
}
$ftpid = $this->ftp->add_ftp($options["prefix"], $options["login"], $options["pass"], $options["dir"]);
if (!$ftpid) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response(array("content" => $ftpid));
}
}
/** API Method from legacy class method ftp->add_ftp() /** API Method from legacy class method ftp->put_ftp_details()
* @param $options a hash with parameters transmitted to legacy call * @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: prefix, login, pass, dir * mandatory parameters: id
* @return Alternc_Api_Response whose content is the newly created UID * non-mandatory: prefix, login, pass, dir
*/ * @return Alternc_Api_Response whose content is the updated UID
function add($options) { */
$mandatory=array("prefix","login","pass","dir"); function update($options) {
$missing=""; $defaults = array("prefix", "login", "dir");
foreach ($mandatory as $key) { if (!isset($options["id"])) {
if (!isset($options[$key])) { return new Alternc_Api_Response(array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: ID"));
$missing.=$key." "; }
} $id = intval($options["id"]);
} $old = $this->ftp->get_ftp_details($id);
if ($missing) { if (!$old) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: ".$missing) ); return new Alternc_Api_Response(array("code" => self::ERR_NOT_FOUND, "message" => "FTP Account not found"));
} }
$ftpid=$this->ftp->add_ftp($options["prefix"],$options["login"], $options["pass"], $options["dir"]); foreach ($defaults as $key) {
if (!$ftpid) { if (!isset($options[$key])) {
return $this->alterncLegacyErrorManager(); $options[$key] = $old[$key];
} else { }
return new Alternc_Api_Response( array("content" => $ftpid ) ); }
} if (!isset($options["pass"]))
} $options["pass"] = "";
$result = $this->ftp->put_ftp_details($id, $options["prefix"], $options["login"], $options["pass"], $options["dir"]);
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response(array("content" => $result));
}
}
/** API Method from legacy class method ftp->del_ftp()
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: id
* @return Alternc_Api_Response TRUE if the FTP account has been deleted.
*/
function del($options) {
if (!isset($options["id"])) {
return new Alternc_Api_Response(array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "Missing or invalid argument: ID"));
}
$result = $this->ftp->delete_ftp(intval($options["id"]));
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response(array("content" => true));
}
}
/** API Method from legacy class method ftp->put_ftp_details() /** API Method from legacy class method ftp->get_list()
* @param $options a hash with parameters transmitted to legacy call * @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: id * non-mandatory parameters:
* non-mandatory: prefix, login, pass, dir * Any of: offset(int=0), count(int=+inf)
* @return Alternc_Api_Response whose content is the updated UID * @return Alternc_Api_Response An array with all matching FTP account informations as hashes
*/ */
function update($options) { function find($options) {
$defaults=array("prefix","login","dir"); $result = $this->ftp->get_list();
if (!isset($options["id"])) { if (!$result) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_ARGUMENT, "message" => "Missing or invalid argument: ID") ); return $this->alterncLegacyErrorManager();
} } else {
$id=intval($options["id"]); $offset = -1;
$old=$this->ftp->get_ftp_details($id); $count = -1;
if (!$old) { if (isset($options["count"]))
return new Alternc_Api_Response( array("code" => self::ERR_NOT_FOUND, "message" => "FTP Account not found") ); $count = intval($options["count"]);
} if (isset($options["offset"]))
foreach ($defaults as $key) { $offset = intval($options["offset"]);
if (!isset($options[$key])) { if ($offset != -1 || $count != -1) {
$options[$key]=$old[$key]; if ($offset < 0 || $offset > count($result))
} $offset = 0;
} if ($count < 0 || $count > 1000)
if (!isset($options["pass"])) $options["pass"]=""; $count = 1000;
$result=$this->ftp->put_ftp_details($id, $options["prefix"], $options["login"], $options["pass"], $options["dir"]); $result = array_slice($result, $offset, $count);
if (!$result) { }
return $this->alterncLegacyErrorManager(); return new Alternc_Api_Response(array("content" => $result));
} else { }
return new Alternc_Api_Response( array("content" => $result ) ); }
}
}
}
/** API Method from legacy class method ftp->del_ftp() // class Alternc_Api_Object_Ftp
* @param $options a hash with parameters transmitted to legacy call
* mandatory parameters: id
* @return Alternc_Api_Response TRUE if the FTP account has been deleted.
*/
function del($options) {
if (!isset($options["id"])) {
return new Alternc_Api_Response( array("code" => self::ERR_ALTERNC_FUNCTION, "message" => "Missing or invalid argument: ID") );
}
$result=$this->ftp->delete_ftp(intval($options["id"]));
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
return new Alternc_Api_Response( array("content" => true ) );
}
}
/** API Method from legacy class method ftp->get_list()
* @param $options a hash with parameters transmitted to legacy call
* non-mandatory parameters:
* Any of: offset(int=0), count(int=+inf)
* @return Alternc_Api_Response An array with all matching FTP account informations as hashes
*/
function find($options) {
$result=$this->ftp->get_list();
if (!$result) {
return $this->alterncLegacyErrorManager();
} else {
$offset=-1; $count=-1;
if (isset($options["count"])) $count=intval($options["count"]);
if (isset($options["offset"])) $offset=intval($options["offset"]);
if ($offset!=-1 || $count!=-1) {
if ($offset<0 || $offset>count($result)) $offset=0;
if ($count<0 || $count>1000) $count=1000;
$result= array_slice($result, $offset, $count);
}
return new Alternc_Api_Response( array("content" =>$result) );
}
}
} // class Alternc_Api_Object_Ftp

52
lib/Alternc/Api/Request.php
View File

@ -25,18 +25,21 @@ class Alternc_Api_Request {
* @var string * @var string
*/ */
public $object; public $object;
/** /**
* must link to a Alternc_Api_Object_Interface method * must link to a Alternc_Api_Object_Interface method
* *
* @var string * @var string
*/ */
public $action; public $action;
/** /**
* bag of data * bag of data
* *
* @var array * @var array
*/ */
public $options; public $options;
/** /**
* *
* Bag of data * Bag of data
@ -45,8 +48,7 @@ class Alternc_Api_Request {
*/ */
public $metadata; public $metadata;
const ERR_MISSING_PARAMETER = 111801;
const ERR_MISSING_PARAMETER = 111801;
function __construct($options) { function __construct($options) {
@ -67,37 +69,35 @@ class Alternc_Api_Request {
// Attempts to retrieve options // Attempts to retrieve options
if (isset($options["options"])) { if (isset($options["options"])) {
if (is_array($options)) { if (is_array($options)) {
$this->options = $options["options"]; $this->options = $options["options"];
} else { } else {
throw new \Exception("Missing parameter options", self::ERR_MISSING_PARAMETER); throw new \Exception("Missing parameter options", self::ERR_MISSING_PARAMETER);
} }
} else { } else {
$this->options=array(); $this->options = array();
} }
// Attempts to retrieve token // Attempts to retrieve token
if (isset($options["token"])) { if (isset($options["token"])) {
if (is_a( $options["token"], Alternc_Api_Token)) { if (is_a($options["token"], Alternc_Api_Token)) {
$this->token = $options["token"]; $this->token = $options["token"];
} else { } else {
throw new \Exception("Bad parameter token", self::ERR_MISSING_PARAMETER); throw new \Exception("Bad parameter token", self::ERR_MISSING_PARAMETER);
} }
} else { } else {
// Attempts to retrieve token_hash then // Attempts to retrieve token_hash then
if (isset($options["token_hash"]) && is_string( $options["token_hash"])) { if (isset($options["token_hash"]) && is_string($options["token_hash"])) {
$this->token_hash = $options["token_hash"]; $this->token_hash = $options["token_hash"];
} else { } else {
throw new \Exception("Missing parameter token OR token_hash", self::ERR_MISSING_PARAMETER); throw new \Exception("Missing parameter token OR token_hash", self::ERR_MISSING_PARAMETER);
} }
} }
// Attempts to retrieve metadata (eg: API version) // Attempts to retrieve metadata (eg: API version)
if (isset($options["metadata"])) { if (isset($options["metadata"])) {
$this->metadata = $options["metadata"]; $this->metadata = $options["metadata"];
} }
} }
} }

31
lib/Alternc/Api/Response.php
View File

@ -6,12 +6,11 @@
*/ */
class Alternc_Api_Response { class Alternc_Api_Response {
/** /**
* Error codes * Error codes
*/ */
const ERR_DISABLED_ACCOUNT = 221801; const ERR_DISABLED_ACCOUNT = 221801;
const ERR_INVALID_AUTH = 221802; const ERR_INVALID_AUTH = 221802;
/** /**
* Result code. 0 means success * Result code. 0 means success
@ -41,30 +40,28 @@ class Alternc_Api_Response {
*/ */
public $metadata; public $metadata;
/** /**
* initialize a response object * initialize a response object
* @param options any of the public above * @param options any of the public above
*/ */
public function __construct($options=array()) { public function __construct($options = array()) {
$os=array("code","message","content","metadata"); $os = array("code", "message", "content", "metadata");
foreach ($os as $o) { foreach ($os as $o) {
if (isset($options[$o])) $this->$o=$options[$o]; if (isset($options[$o]))
} $this->$o = $options[$o];
}
} }
/** /**
* Formats response to json * Formats response to json
* *
* @return string * @return string
*/ */
public function toJson (){ public function toJson() {
return json_encode(get_object_vars($this)); return json_encode(get_object_vars($this));
} }
}
// class Alternc_Api_Response
} // class Alternc_Api_Response

285
lib/Alternc/Api/Service.php
View File

@ -8,163 +8,158 @@
*/ */
class Alternc_Api_Service { class Alternc_Api_Service {
public $db; // PDO object
private $loggerList; // List of loggers
private $allowedAuth; // list of allowed authenticators
public $token; // Token (useful for called classes)
public $db; // PDO object const ERR_INVALID_ARGUMENT = 111801;
private $loggerList; // List of loggers const ERR_METHOD_DENIED = 111802;
private $allowedAuth; // list of allowed authenticators const ERR_INVALID_ANSWER = 111803;
public $token; // Token (useful for called classes) const ERR_SETUID_FORBIDDEN = 111804;
const ERR_SETUID_USER_NOT_FOUND = 111805;
const ERR_OBJECT_NOT_FOUND = 111806;
const ERR_ACTION_NOT_FOUND = 111807;
const ERR_INVALID_TOKEN = 111808;
const ERR_INVALID_ARGUMENT = 111801; /**
const ERR_METHOD_DENIED = 111802; * Constructor of the Api Service Wrapper
const ERR_INVALID_ANSWER = 111803; *
const ERR_SETUID_FORBIDDEN = 111804; * @param $options an hash with
const ERR_SETUID_USER_NOT_FOUND = 111805; * databaseAdapter: an already initialized PDO object
const ERR_OBJECT_NOT_FOUND = 111806; * see http://php.net/PDO
const ERR_ACTION_NOT_FOUND = 111807; * loginAdapterList: (not mandatory) list of allowed authentication adapters (their codename)
const ERR_INVALID_TOKEN = 111808; * see Alternc/Api/Auth/*
* loggerAdapter: (not mandatory), a PSR3-Interface-compliant class or a list of it.
* see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md for more information
*
* @return create the object
*/
function __construct($options) {
/** // What DB shall we connect to?
* Constructor of the Api Service Wrapper // Note: it MUST be in this mode : $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
* if (isset($options["databaseAdapter"]) && $options["databaseAdapter"] instanceof PDO) {
* @param $options an hash with $this->db = $options["databaseAdapter"];
* databaseAdapter: an already initialized PDO object } else {
* see http://php.net/PDO throw new \Exception("Missing required parameter databaseAdapter", self::ERR_INVALID_ARGUMENT);
* loginAdapterList: (not mandatory) list of allowed authentication adapters (their codename) }
* see Alternc/Api/Auth/*
* loggerAdapter: (not mandatory), a PSR3-Interface-compliant class or a list of it.
* see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md for more information
*
* @return create the object
*/
function __construct($options) { // Which login is allowed?
$this->allowedAuth = array();
if (isset($options["loginAdapterList"]) && is_array($options["loginAdapterList"])) {
foreach ($options["loginAdapterList"] as $lal) {
$this->allowedAuth[] = (string) $lal;
}
}
// What DB shall we connect to? // To which logger(s) shall we log to?
// Note: it MUST be in this mode : $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); if (isset($options["loggerAdapter"])) {
if (isset($options["databaseAdapter"]) && $options["databaseAdapter"] instanceof PDO) { if (!is_array($options["loggerAdapter"]))
$this->db=$options["databaseAdapter"]; $options["loggerAdapter"] = array($options["loggerAdapter"]);
} else { foreach ($options["loggerAdapter"] as $la) {
throw new \Exception("Missing required parameter databaseAdapter", self::ERR_INVALID_ARGUMENT); if ($la instanceof Psr\Log\LoggerInterface)
$this->loggerList[] = $la;
}
}
} }
// Which login is allowed? // __construct
$this->allowedAuth=array();
if (isset($options["loginAdapterList"]) && is_array($options["loginAdapterList"]) ) { /**
foreach($options["loginAdapterList"] as $lal) { * Authenticate into an AlternC server
$this->allowedAuth[] = (string)$lal; * @param $auth hash with
} * method: string describing the authentication name (in Alternc_Api_Auth_xxx)
* options: array list of parameters for the corresponding auth.
* if 'uid' is set in the option hash, the account MUST be an administrator one
* and as a result, the returned Api_Token will be set to this UID and not the admin one.
* @return Alternc_Api_Token an API Token
*/
function auth($auth) {
if (!isset($auth["method"]) || !is_string($auth["method"])) {
throw new \Exception("Missing required parameter method", self::ERR_INVALID_ARGUMENT);
}
if (!isset($auth["options"]) || !is_array($auth["options"])) {
throw new \Exception("Missing required parameter options", self::ERR_INVALID_ARGUMENT);
}
if (count($this->allowedAuth) && !in_array($auth["method"], $this->allowedAuth)) {
throw new \Exception("Method not allowed", self::ERR_METHOD_DENIED);
}
if (isset($auth["options"]["uid"]) && !intval($auth["options"]["uid"])) {
throw new \Exception("Invalid UID", self::ERR_INVALID_ARGUMENT);
}
$adapterName = "Alternc_Api_Auth_" . ucfirst(strtolower($auth["method"]));
$authAdapter = new $adapterName($this);
$token = $authAdapter->auth($auth["options"]);
// something went wrong user-side
if ($token instanceof Alternc_Api_Response)
return $token;
// something went *really* wrong (bad type):
if (!$token instanceof Alternc_Api_Token)
throw new \Exception("Invalid answer from Api_Auth_Interface", self::ERR_INVALID_ANSWER);
if (isset($auth["options"]["uid"])) {
if (!$token->isAdmin) {
// Non-admin are not allowed to setuid
return new Alternc_Api_Response(array("code" => self::ERR_SETUID_FORBIDDEN, "message" => "This user is not allowed to set his uid"));
}
// Search for the requested user. We allow using *disabled* account here since we are admin
foreach ($this->db->query("SELECT uid FROM membres WHERE uid=" . intval($auth["options"]["uid"])) as $setuid) {
$token->uid = intval($setuid['uid']);
$stmt = $this->db->prepare("UPDATE token SET data=? WHERE token=?");
$stmt->execute(array($token->toJson(), $token->token));
return $token;
}
return new Alternc_Api_Response(array("code" => self::ERR_SETUID_USER_NOT_FOUND, "message" => "Can't find the user you want to setuid to"));
}
return $token;
} }
// To which logger(s) shall we log to? /**
if (isset($options["loggerAdapter"])) { * Manage an API Call
if (!is_array($options["loggerAdapter"])) $options["loggerAdapter"]=array($options["loggerAdapter"]); * @param Alternc_Api_Request $request The API call
foreach($options["loggerAdapter"] as $la) { * the request must have "object" and "action" elements, and a "token" to authenticate
if ($la instanceof Psr\Log\LoggerInterface) * "options" are sent as it is to the Api Call.
$this->loggerList[]=$la; * @return Alternc_Api_Response an API response
} */
function call($request) {
if (!$request instanceof Alternc_Api_Request)
throw new \Exception("request must be an Alternc_Api_Request object", self::ERR_INVALID_ARGUMENT);
// we set the token in the Service object, so that other classes can use it :)
$this->token = Alternc_Api_Token::tokenGet($request->token_hash, $this->db);
if ($this->token instanceof Alternc_Api_Response) // bad token
return $this->token;
$className = "Alternc_Api_Object_" . ucfirst(strtolower($request->object));
if (!class_exists($className))
return new Alternc_Api_Response(array("code" => self::ERR_OBJECT_NOT_FOUND, "message" => "Object not found in this AlternC's instance"));
$object = new $className($this);
$action = $request->action;
if (!method_exists($object, $action))
return new Alternc_Api_Response(array("code" => self::ERR_ACTION_NOT_FOUND, "message" => "Action not found for this object in this AlternC's instance"));
$request->token = $this->token; // we receive $request->token_hash as a STRING, but we transmit its object as an Alternc_Api_Token.
// TODO: log this Api Call
return $object->$action($request->options);
} }
} // __construct /**
* Getter for the databaseAdapter
* (used by authAdapter)
/** */
* Authenticate into an AlternC server function getDb() {
* @param $auth hash with return $this->db;
* method: string describing the authentication name (in Alternc_Api_Auth_xxx)
* options: array list of parameters for the corresponding auth.
* if 'uid' is set in the option hash, the account MUST be an administrator one
* and as a result, the returned Api_Token will be set to this UID and not the admin one.
* @return Alternc_Api_Token an API Token
*/
function auth($auth) {
if (!isset($auth["method"]) || !is_string($auth["method"])) {
throw new \Exception("Missing required parameter method", self::ERR_INVALID_ARGUMENT);
}
if (!isset($auth["options"]) || !is_array($auth["options"])) {
throw new \Exception("Missing required parameter options", self::ERR_INVALID_ARGUMENT);
} }
if (count($this->allowedAuth) && !in_array($auth["method"],$this->allowedAuth)) { }
throw new \Exception("Method not allowed", self::ERR_METHOD_DENIED);
}
if (isset($auth["options"]["uid"]) && !intval($auth["options"]["uid"])) {
throw new \Exception("Invalid UID", self::ERR_INVALID_ARGUMENT);
}
$adapterName = "Alternc_Api_Auth_".ucfirst(strtolower($auth["method"])); // class Alternc_Api_Service
$authAdapter = new $adapterName($this);
$token = $authAdapter->auth($auth["options"]);
// something went wrong user-side
if ($token instanceof Alternc_Api_Response)
return $token;
// something went *really* wrong (bad type):
if (!$token instanceof Alternc_Api_Token)
throw new \Exception("Invalid answer from Api_Auth_Interface", self::ERR_INVALID_ANSWER);
if (isset($auth["options"]["uid"])) {
if (!$token->isAdmin) {
// Non-admin are not allowed to setuid
return new Alternc_Api_Response( array("code" => self::ERR_SETUID_FORBIDDEN, "message" => "This user is not allowed to set his uid") );
}
// Search for the requested user. We allow using *disabled* account here since we are admin
foreach($this->db->query("SELECT uid FROM membres WHERE uid=".intval($auth["options"]["uid"])) as $setuid) {
$token->uid=intval($setuid['uid']);
$stmt=$this->db->prepare("UPDATE token SET data=? WHERE token=?");
$stmt->execute(array( $token->toJson(), $token->token));
return $token;
}
return new Alternc_Api_Response( array("code" => self::ERR_SETUID_USER_NOT_FOUND, "message" => "Can't find the user you want to setuid to") );
}
return $token;
}
/**
* Manage an API Call
* @param Alternc_Api_Request $request The API call
* the request must have "object" and "action" elements, and a "token" to authenticate
* "options" are sent as it is to the Api Call.
* @return Alternc_Api_Response an API response
*/
function call($request) {
if (!$request instanceof Alternc_Api_Request)
throw new \Exception("request must be an Alternc_Api_Request object", self::ERR_INVALID_ARGUMENT);
// we set the token in the Service object, so that other classes can use it :)
$this->token = Alternc_Api_Token::tokenGet($request->token_hash,$this->db);
if ($this->token instanceof Alternc_Api_Response) // bad token
return $this->token;
$className = "Alternc_Api_Object_".ucfirst(strtolower($request->object));
if (!class_exists($className))
return new Alternc_Api_Response( array("code" => self::ERR_OBJECT_NOT_FOUND, "message" => "Object not found in this AlternC's instance") );
$object = new $className($this);
$action=$request->action;
if (!method_exists($object, $action))
return new Alternc_Api_Response( array("code" => self::ERR_ACTION_NOT_FOUND, "message" => "Action not found for this object in this AlternC's instance") );
$request->token=$this->token; // we receive $request->token_hash as a STRING, but we transmit its object as an Alternc_Api_Token.
// TODO: log this Api Call
return $object->$action($request->options);
}
/**
* Getter for the databaseAdapter
* (used by authAdapter)
*/
function getDb() {
return $this->db;
}
} // class Alternc_Api_Service

110
lib/Alternc/Api/Token.php
View File

@ -6,11 +6,10 @@
*/ */
class Alternc_Api_Token { class Alternc_Api_Token {
const ERR_DATABASE_ERROR = 112001;
const ERR_DATABASE_ERROR=112001; const ERR_INVALID_ARGUMENT = 112002;
const ERR_INVALID_ARGUMENT=112002; const ERR_MISSING_ARGUMENT = 112003;
const ERR_MISSING_ARGUMENT=112003; const ERR_INVALID_TOKEN = 112004;
const ERR_INVALID_TOKEN=112004;
/** /**
* AlternC User-Id * AlternC User-Id
@ -33,7 +32,6 @@ class Alternc_Api_Token {
*/ */
public $token; public $token;
/** /**
* how long (seconds) is a token valid * how long (seconds) is a token valid
* *
@ -41,65 +39,59 @@ class Alternc_Api_Token {
*/ */
public $tokenDuration = 2678400; // default is a month public $tokenDuration = 2678400; // default is a month
/** /**
* initialize a token object * initialize a token object
* @param options any of the public above * @param options any of the public above
* may contain a dbAdapter, in that case create() will be available * may contain a dbAdapter, in that case create() will be available
*/ */
public function __construct($options=array()) {
if (isset($options["uid"]) && is_int($options["uid"])) public function __construct($options = array()) {
$this->uid=$options["uid"];
if (isset($options["isAdmin"]) && is_bool($options["isAdmin"])) if (isset($options["uid"]) && is_int($options["uid"]))
$this->isAdmin=$options["isAdmin"]; $this->uid = $options["uid"];
if (isset($options["isAdmin"]) && is_bool($options["isAdmin"]))
$this->isAdmin = $options["isAdmin"];
} }
/** /**
* Formats response to json * Formats response to json
* *
* @return string * @return string
*/ */
public function toJson (){ public function toJson() {
return json_encode( return json_encode(
array("uid"=>$this->uid, array("uid" => $this->uid,
"isAdmin" => $this->isAdmin, "isAdmin" => $this->isAdmin,
"token" => $this->token) "token" => $this->token)
); );
} }
/** /**
* Create a new token in the DB for the associated user/admin * Create a new token in the DB for the associated user/admin
* *
* @return string the token (32 chars) * @return string the token (32 chars)
*/ */
public static function tokenGenerate($options,$db) { public static function tokenGenerate($options, $db) {
if (!($db instanceof PDO)) { if (!($db instanceof PDO)) {
throw new \Exception("No DB Object, can't create",self::ERR_DATABASE_ERROR); throw new \Exception("No DB Object, can't create", self::ERR_DATABASE_ERROR);
} }
if (!isset($options["uid"]) || !isset($options["isAdmin"])) { if (!isset($options["uid"]) || !isset($options["isAdmin"])) {
throw new \Exception("Missing Arguments (uid,isAdmin)",self::ERR_MISSING_ARGUMENT); throw new \Exception("Missing Arguments (uid,isAdmin)", self::ERR_MISSING_ARGUMENT);
} }
$token=new Alternc_Api_Token($options); $token = new Alternc_Api_Token($options);
do { do {
$token->token = $token->tokenRandom(); $token->token = $token->tokenRandom();
$stmt=$db->prepare("INSERT IGNORE INTO token SET token=?, expire=DATE_ADD(NOW(), INTERVAL ? SECOND), data=?"); $stmt = $db->prepare("INSERT IGNORE INTO token SET token=?, expire=DATE_ADD(NOW(), INTERVAL ? SECOND), data=?");
$stmt->execute(array($token->token,$token->tokenDuration, $token->toJson())); $stmt->execute(array($token->token, $token->tokenDuration, $token->toJson()));
$rows = $stmt->rowCount(); $rows = $stmt->rowCount();
} while ($rows == 0); // prevent collisions
} while ($rows==0); // prevent collisions return $token;
return $token;
} }
/** /**
* Check and return a token * Check and return a token
* @param $token string a 32-chars token * @param $token string a 32-chars token
@ -107,34 +99,34 @@ class Alternc_Api_Token {
* *
* @return Alternc_Api_Token object or NULL * @return Alternc_Api_Token object or NULL
*/ */
public static function tokenGet($token,$db) { public static function tokenGet($token, $db) {
if (!($db instanceof PDO)) { if (!($db instanceof PDO)) {
throw new \Exception("No DB Object, can't create",self::ERR_DATABASE_ERROR); throw new \Exception("No DB Object, can't create", self::ERR_DATABASE_ERROR);
} }
if (!is_string($token) || !preg_match("#^[a-zA-Z0-9]{32}$#",$token)) { if (!is_string($token) || !preg_match("#^[a-zA-Z0-9]{32}$#", $token)) {
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_TOKEN, "message" => "Invalid token") ); return new Alternc_Api_Response(array("code" => self::ERR_INVALID_TOKEN, "message" => "Invalid token"));
} }
$stmt=$db->prepare("SELECT * FROM token WHERE token=?"); $stmt = $db->prepare("SELECT * FROM token WHERE token=?");
$stmt->execute(array($token)); $stmt->execute(array($token));
if ( $tok=$stmt->fetch(PDO::FETCH_OBJ) ) { if ($tok = $stmt->fetch(PDO::FETCH_OBJ)) {
return new Alternc_Api_Token( json_decode($tok->data,true) ); return new Alternc_Api_Token(json_decode($tok->data, true));
} }
return new Alternc_Api_Response( array("code" => self::ERR_INVALID_TOKEN, "message" => "Invalid token") ); return new Alternc_Api_Response(array("code" => self::ERR_INVALID_TOKEN, "message" => "Invalid token"));
} }
/** /**
* Generate a new random token * Generate a new random token
* @return string * @return string
*/ */
public function tokenRandom(){ public function tokenRandom() {
$chars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
$s=""; $s = "";
for($i=0;$i<32;$i++) for ($i = 0; $i < 32; $i++)
$s.=substr($chars,rand(0,61),1); $s.=substr($chars, rand(0, 61), 1);
return $s; return $s;
} }
}
} // class Alternc_Api_Response // class Alternc_Api_Response