347 lines
9.2 KiB
PHP
347 lines
9.2 KiB
PHP
<?php
|
|
|
|
namespace Aiko;
|
|
|
|
use Firebase\JWT\JWT;
|
|
use Symfony\Component\HttpFoundation\JsonResponse;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
use finfo;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class Http
|
|
{
|
|
private static $request = null;
|
|
private static $response = null;
|
|
public static function GetBodyRequest()
|
|
{
|
|
self::$request = new Request();
|
|
|
|
return self::$request->getContent();
|
|
}
|
|
|
|
public static function enabledCors()
|
|
{
|
|
// // Allow from any origin
|
|
if (isset($_SERVER['HTTP_ORIGIN'])) {
|
|
// Decide if the origin in $_SERVER['HTTP_ORIGIN'] is one
|
|
// you want to allow, and if so:
|
|
header("Access-Control-Allow-Origin: {$_SERVER['HTTP_ORIGIN']}");
|
|
header('Access-Control-Allow-Credentials: true');
|
|
header('Access-Control-Max-Age: 86400'); // cache for 1 day
|
|
}
|
|
|
|
// Access-Control headers are received during OPTIONS requests
|
|
if ($_SERVER['REQUEST_METHOD'] == 'OPTIONS') {
|
|
|
|
if (isset($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_METHOD']))
|
|
// may also be using PUT, PATCH, HEAD etc
|
|
{
|
|
header("Access-Control-Allow-Methods: GET, POST, OPTIONS");
|
|
}
|
|
|
|
if (isset($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS'])) {
|
|
header("Access-Control-Allow-Headers: {$_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']}");
|
|
}
|
|
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
public static function UnauthorizedResponse($content)
|
|
{
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_UNAUTHORIZED,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->send();
|
|
exit();
|
|
}
|
|
|
|
public static function InternalServerError($content)
|
|
{
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_INTERNAL_SERVER_ERROR,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->send();
|
|
exit();
|
|
}
|
|
|
|
public static function UnauthorizedResponseJson($content)
|
|
{
|
|
self::$response = new Response(
|
|
JWT::jsonEncode($content),
|
|
Response::HTTP_UNAUTHORIZED,
|
|
array('content-type' => 'application/json')
|
|
);
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
|
|
self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
|
|
self::$response->send();
|
|
exit();
|
|
}
|
|
public static function PageNotFound($content)
|
|
{
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_NOT_FOUND,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
|
|
self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
|
|
self::$response->send();
|
|
|
|
exit();
|
|
}
|
|
|
|
public static function GetXsrfHeader()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$token = self::$request->headers->get('X-XSRF-TOKEN');
|
|
|
|
return $token;
|
|
}
|
|
|
|
public static function GetTokenHeader()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$token = self::$request->headers->get('token');
|
|
|
|
return $token;
|
|
}
|
|
|
|
public static function ErrorQueryResponse($content, $type = 'text')
|
|
{
|
|
if ($type == 'text') {
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_BAD_REQUEST,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->send();
|
|
} else {
|
|
self::$response = new JsonResponse();
|
|
self::$response->setData($content);
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->setStatusCode(Response::HTTP_BAD_REQUEST);
|
|
self::$response->send();
|
|
}
|
|
|
|
exit();
|
|
}
|
|
|
|
public static function Forbidden($content, $type = 'text')
|
|
{
|
|
if ($type == 'text') {
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_FORBIDDEN,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->send();
|
|
} else {
|
|
self::$response = new JsonResponse();
|
|
self::$response->setData($content);
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->setStatusCode(Response::HTTP_FORBIDDEN);
|
|
self::$response->send();
|
|
}
|
|
|
|
exit();
|
|
}
|
|
|
|
public static function responseJson($array, $secure = '0', $cors = '0')
|
|
{
|
|
if ($secure == '0') {
|
|
self::$response = new JsonResponse();
|
|
self::$response->setData($array);
|
|
if ($cors == '1') {
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp-version,x-firephp,x-firephp-version,x-wf-max-combined-size');
|
|
self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
|
|
}
|
|
self::$response->send();
|
|
} else {
|
|
self::$response = new Response();
|
|
$jtext = ")]}',\n" . JWT::jsonEncode($array, JSON_UNESCAPED_SLASHES);
|
|
self::$response->setContent($jtext);
|
|
self::$response->headers->set('Content-Type', 'application/json');
|
|
if ($cors == '1') {
|
|
self::$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
}
|
|
self::$response->send();
|
|
}
|
|
|
|
exit();
|
|
}
|
|
|
|
public static function GetVarData($key, $method = 'get')
|
|
{
|
|
self::$request = Request::createFromGlobals();
|
|
if ($method == 'get') {
|
|
$result = self::$request->query->get($key);
|
|
} else {
|
|
|
|
$result = self::$request->request->get($key);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public static function Error404($content)
|
|
{
|
|
self::$response = new Response(
|
|
$content,
|
|
Response::HTTP_NOT_FOUND,
|
|
array('content-type' => 'text/html')
|
|
);
|
|
self::$response->send();
|
|
exit();
|
|
}
|
|
|
|
public static function GetFile($key)
|
|
{
|
|
|
|
|
|
self::$request = Request::createFromGlobals();
|
|
// var_dump(self::$request);
|
|
$result = self::$request->files->get($key);
|
|
|
|
|
|
return $result;
|
|
}
|
|
|
|
public static function CekTokenHeader()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$token = self::$request->headers->get('token');
|
|
|
|
return $token;
|
|
}
|
|
|
|
public static function CekTokenAuthHeader()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$token = self::$request->headers->get('tokenAuth');
|
|
|
|
return $token;
|
|
}
|
|
|
|
public static function getTokenJWT()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$authHeader = self::$request->headers->get('Authorization');
|
|
list($jwt) = sscanf($authHeader, 'Bearer %s');
|
|
// var_dump($jwt);
|
|
return $jwt;
|
|
}
|
|
|
|
public static function getBasicAuth()
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
$authHeader = self::$request->headers->get('Authorization');
|
|
list($code) = sscanf($authHeader, 'Basic %s');
|
|
// var_dump($code);
|
|
return $code;
|
|
}
|
|
|
|
public static function requestServer($key)
|
|
{
|
|
if (is_null(self::$request)) {
|
|
self::$request = Request::CreateFromGlobals();
|
|
}
|
|
|
|
return self::$request->server->get($key);
|
|
}
|
|
public static function tokenExpired($content)
|
|
{
|
|
$response = new Response(
|
|
JWT::jsonEncode($content),
|
|
Response::HTTP_NOT_ACCEPTABLE,
|
|
array('content-type' => 'application/json')
|
|
);
|
|
$response->headers->set('Access-Control-Allow-Origin', '*');
|
|
$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
|
|
$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
|
|
$response->send();
|
|
exit();
|
|
}
|
|
|
|
public static function responseFile($params)
|
|
{
|
|
$path_to_zip=$params['file_path'];
|
|
|
|
|
|
// if( file_exists( $path_to_zip ) )
|
|
// {
|
|
// die();
|
|
// header( 'Cache-Control: public' );
|
|
// header( 'Content-Description: File Transfer' );
|
|
// header( "Content-Disposition: attachment; filename={$path_to_zip}" );
|
|
// header( 'Content-Type: application/zip' );
|
|
// header( 'Content-Transfer-Encoding: binary' );
|
|
// readfile( $path_to_zip );
|
|
// exit;
|
|
// }
|
|
|
|
// die( "ERROR: invalid song or you don't have permissions to download it." );
|
|
$extension = pathinfo(parse_url($path_to_zip, PHP_URL_PATH), PATHINFO_EXTENSION);
|
|
$file_info = new finfo(FILEINFO_MIME_TYPE);
|
|
$mime_type = $file_info->buffer(file_get_contents($path_to_zip));
|
|
$file=file_get_contents($path_to_zip);
|
|
|
|
$response = new Response(
|
|
$file,
|
|
Response::HTTP_OK,
|
|
array('content-type' => $mime_type)
|
|
);
|
|
$response->send();
|
|
|
|
// var_dump($file);die();
|
|
}
|
|
|
|
|
|
public static function getHeaderValue($key, $default = null)
|
|
{
|
|
self::$request = Request::CreateFromGlobals();
|
|
if (!self::$request->headers->has($key)) {
|
|
return $default;
|
|
}
|
|
$value = self::$request->headers->has($key);
|
|
return $value;
|
|
}
|
|
|
|
public static function getAllRequest($method = 'get')
|
|
{
|
|
self::$request = Request::createFromGlobals();
|
|
if ($method == 'get') {
|
|
$result = self::$request->query->all();
|
|
} else {
|
|
$result = self::$request->request->all();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
public static function isMultipartFormData()
|
|
{
|
|
$req = Request::CreateFromGlobals();
|
|
$multipart=$req->headers->has('Content-Type');
|
|
if($multipart)
|
|
{
|
|
$contentType=$req->headers->get('Content-Type');
|
|
if(strpos($contentType,'multipart/form-data')!==false)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|