mirror of
https://github.com/IT4Change/gradido.git
synced 2025-12-13 07:45:54 +00:00
487 lines
18 KiB
PHP
487 lines
18 KiB
PHP
<?php
|
|
/*!
|
|
* @author: Dario Rekowski
|
|
* @date : 2020-12-01
|
|
* @brief: Controller for all ajax-json requests caming from mobile app
|
|
*
|
|
* Everything is allowed to call them, so caution!
|
|
*/
|
|
|
|
namespace App\Controller;
|
|
|
|
use App\Controller\AppController;
|
|
use Cake\ORM\TableRegistry;
|
|
use Cake\Http\Client;
|
|
use Cake\Core\Configure;
|
|
|
|
use Cake\I18n\FrozenTime;
|
|
|
|
class AppRequestsController extends AppController
|
|
{
|
|
public function initialize()
|
|
{
|
|
parent::initialize();
|
|
$this->loadComponent('JsonRequestClient');
|
|
$this->loadComponent('GradidoNumber');
|
|
//$this->loadComponent('JsonRpcRequestClient');
|
|
//$this->Auth->allow(['add', 'edit']);
|
|
$this->Auth->allow([
|
|
'index', 'sendCoins', 'createCoins', 'getBalance',
|
|
'listTransactions','listGDTTransactions', 'getDecayStartBlock'
|
|
]);
|
|
}
|
|
|
|
|
|
public function index()
|
|
{
|
|
if($this->request->is('get')) {
|
|
$method = $this->request->getQuery('method');
|
|
switch($method) {
|
|
|
|
}
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'unknown method for get', 'details' => $method]);
|
|
}
|
|
else if($this->request->is('post')) {
|
|
$jsonData = $this->request->input('json_decode');
|
|
//var_dump($jsonData);
|
|
if($jsonData == NULL || !isset($jsonData->method)) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'parameter error']);
|
|
}
|
|
$method = $jsonData->method;
|
|
|
|
switch($method) {
|
|
|
|
}
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'unknown method for post', 'details' => $method]);
|
|
}
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'no post or get']);
|
|
}
|
|
|
|
private function checkAndCopyRequiredFields($fields, &$param, $data = null) {
|
|
if($data == null) {
|
|
$data = $this->request->input('json_decode');
|
|
}
|
|
foreach($fields as $field) {
|
|
if(is_array($field)) {
|
|
$one_exist = false;
|
|
foreach($field as $oneField) {
|
|
if(isset($data->$oneField)) {
|
|
$param[$oneField] = $data->$oneField;
|
|
$one_exist = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!$one_exist) {
|
|
return ['state' => 'error', 'msg' => 'missing field of set', 'details' => $field];
|
|
}
|
|
} else {
|
|
if(!isset($data->$field)) {
|
|
return ['state' => 'error', 'msg' => 'missing field', 'details' => $field . ' not found'];
|
|
} else {
|
|
$param[$field] = $data->$field;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private function rewriteKeys(&$data, $replaceKeys)
|
|
{
|
|
foreach(array_keys($replaceKeys) as $key) {
|
|
$newKey = $replaceKeys[$key];
|
|
if(isset($data->$key)) {
|
|
$data->$newKey = $data->$key;
|
|
unset($data->$key);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function parseParameterForCreateTransaction(&$param, $data = null)
|
|
{
|
|
if($data == null) {
|
|
$data = $this->request->input('json_decode');
|
|
}
|
|
$session_id = 0;
|
|
if(isset($data->session_id)) {
|
|
$session_id = $data->session_id;
|
|
}
|
|
$login_request_result = $this->requestLogin($session_id, false);
|
|
if($login_request_result !== true) {
|
|
return $login_request_result;
|
|
}
|
|
$session = $this->getRequest()->getSession();
|
|
$param['session_id'] = $session->read('session_id');
|
|
$param['blockchain_type'] = $this->blockchainType;
|
|
|
|
$this->rewriteKeys($data, ['email' => 'target_email', 'username' => 'target_username', 'pubkey' => 'target_pubkey']);
|
|
$required_fields = $this->checkAndCopyRequiredFields(['amount', ['target_email', 'target_username', 'target_pubkey']], $param, $data);
|
|
if($required_fields !== true) {
|
|
return $required_fields;
|
|
}
|
|
|
|
if(floatval($param['amount']) <= 0.0) {
|
|
return ['state' => 'error', 'msg' => 'amount is invalid', 'details' => $param['amount']];
|
|
}
|
|
$param['amount'] = $this->GradidoNumber->parseInputNumberToCentNumber($param['amount']);
|
|
|
|
if(isset($data->memo)) {
|
|
$param['memo'] = $data->memo;
|
|
}
|
|
|
|
if(isset($data->auto_sign)) {
|
|
$param['auto_sign'] = boolval($data->auto_sign);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function sendCoins()
|
|
{
|
|
/*
|
|
* {
|
|
"session_id" : -127182,
|
|
"amount": 2000000,
|
|
"email": "max.musterman@gmail.de",
|
|
"memo":"Thank you :)",
|
|
"group": "gdd1",
|
|
"auto_sign": true
|
|
*/
|
|
if(!$this->request->is('post')) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'no post']);
|
|
}
|
|
$data = $this->request->input('json_decode');
|
|
$params = [];
|
|
$result = $this->parseParameterForCreateTransaction($params, $data);
|
|
if($result !== true) {
|
|
return $this->returnJson($result);
|
|
}
|
|
|
|
if(!isset($params['memo']) || strlen($params['memo']) < 5 || strlen($params['memo']) > 150) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'memo is not set or not in expected range [5;150]']);
|
|
}
|
|
$params['transaction_type'] = 'transfer';
|
|
|
|
$requestAnswear = $this->JsonRequestClient->sendRequest(json_encode($params), '/createTransaction');
|
|
|
|
|
|
if('success' == $requestAnswear['state'] && 'success' == $requestAnswear['data']['state']) {
|
|
$session = $this->getRequest()->getSession();
|
|
$pendingTransactionCount = $session->read('Transactions.pending');
|
|
if($pendingTransactionCount == null) {
|
|
$pendingTransactionCount = 1;
|
|
} else {
|
|
$pendingTransactionCount++;
|
|
}
|
|
$session->write('Transactions.pending', $pendingTransactionCount);
|
|
//echo "pending: " . $pendingTransactionCount;
|
|
return $this->returnJson(['state' => 'success']);
|
|
} else {
|
|
|
|
/*
|
|
* if request contain unknown parameter format, shouldn't happen't at all
|
|
* {"state": "error", "msg": "parameter format unknown"}
|
|
* if json parsing failed
|
|
* {"state": "error", "msg": "json exception", "details":"exception text"}
|
|
* if session_id is zero or not set
|
|
* {"state": "error", "msg": "session_id invalid"}
|
|
* if session id wasn't found on login server, if server was restartet or user logged out (also per timeout, default: 15 minutes)
|
|
* {"state": "error", "msg": "session not found"}
|
|
* if session hasn't active user, shouldn't happen't at all, login-server should be checked if happen
|
|
* {"state": "code error", "msg":"user is zero"}
|
|
* if transaction type not known
|
|
* {"state": "error", "msg":"transaction_type unknown"}
|
|
* if receiver wasn't known to Login-Server
|
|
* {"state": "not found", "msg":"receiver not found"}
|
|
* if receiver account disabled, and therefor cannto receive any coins
|
|
* {"state": "disabled", "msg":"receiver is disabled"}
|
|
* if transaction was okay and will be further proccessed
|
|
* {"state":"success"}
|
|
*/
|
|
$answear_data = $requestAnswear['data'];
|
|
return $this->returnJson($answear_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public function createCoins()
|
|
{
|
|
/*
|
|
* "session_id" : -127182,
|
|
* "email": "max.musterman@gmail.de",
|
|
* "amount": 10000000,
|
|
* "target_date":"2021-02-19T13:25:36+00:00",
|
|
* "memo":"AGE",
|
|
* "auto_sign": true
|
|
*/
|
|
if(!$this->request->is('post')) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'no post']);
|
|
}
|
|
$data = $this->request->input('json_decode');
|
|
$params = [];
|
|
$result = $this->parseParameterForCreateTransaction($params, $data);
|
|
if($result !== true) {
|
|
return $this->returnJson($result);
|
|
}
|
|
$required_fields = $this->checkAndCopyRequiredFields(['target_date'], $params, $data);
|
|
if($required_fields !== true) {
|
|
return $this->returnJson($required_fields);
|
|
}
|
|
$params['transaction_type'] = 'creation';
|
|
|
|
$requestAnswear = $this->JsonRequestClient->sendRequest(json_encode($params), '/createTransaction');
|
|
|
|
if('success' == $requestAnswear['state'] && 'success' == $requestAnswear['data']['state']) {
|
|
$session = $this->getRequest()->getSession();
|
|
$pendingTransactionCount = $session->read('Transactions.pending');
|
|
if($pendingTransactionCount == null) {
|
|
$pendingTransactionCount = 1;
|
|
} else {
|
|
$pendingTransactionCount++;
|
|
}
|
|
$session->write('Transactions.pending', $pendingTransactionCount);
|
|
//echo "pending: " . $pendingTransactionCount;
|
|
return $this->returnJson(['state' => 'success']);
|
|
} else {
|
|
|
|
/*
|
|
* if request contain unknown parameter format, shouldn't happen't at all
|
|
* {"state": "error", "msg": "parameter format unknown"}
|
|
* if json parsing failed
|
|
* {"state": "error", "msg": "json exception", "details":"exception text"}
|
|
* if session_id is zero or not set
|
|
* {"state": "error", "msg": "session_id invalid"}
|
|
* if session id wasn't found on login server, if server was restartet or user logged out (also per timeout, default: 15 minutes)
|
|
* {"state": "error", "msg": "session not found"}
|
|
* if session hasn't active user, shouldn't happen't at all, login-server should be checked if happen
|
|
* {"state": "code error", "msg":"user is zero"}
|
|
* if transaction type not known
|
|
* {"state": "error", "msg":"transaction_type unknown"}
|
|
* if receiver wasn't known to Login-Server
|
|
* {"state": "not found", "msg":"receiver not found"}
|
|
* if receiver account disabled, and therefor cannto receive any coins
|
|
* {"state": "disabled", "msg":"receiver is disabled"}
|
|
* if transaction was okay and will be further proccessed
|
|
* {"state":"success"}
|
|
*/
|
|
$answear_data = $requestAnswear['data'];
|
|
return $this->returnJson($answear_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public function getBalance($session_id = 0)
|
|
{
|
|
$this->viewBuilder()->setLayout('ajax');
|
|
$login_result = $this->requestLogin($session_id, false);
|
|
if($login_result !== true) {
|
|
$this->set('body', $login_result);
|
|
return;
|
|
}
|
|
$session = $this->getRequest()->getSession();
|
|
$user = $session->read('StateUser');
|
|
$state_balances_table = TableRegistry::getTableLocator()->get('StateBalances');
|
|
$state_balances_table->updateBalances($user['id']);
|
|
|
|
$state_balance = $state_balances_table->find()->where(['state_user_id' => $user['id']])->first();
|
|
|
|
|
|
$now = new FrozenTime();
|
|
if(!$state_balance) {
|
|
$body = [
|
|
'state' => 'success',
|
|
'balance' => 0,
|
|
'decay' => 0
|
|
];
|
|
} else {
|
|
|
|
$body = [
|
|
'state' => 'success',
|
|
'balance' => $state_balance->amount,
|
|
'decay' => $state_balance->partDecay($now),
|
|
];
|
|
}
|
|
|
|
$body['decay_date'] = $now;
|
|
$this->set('body', $body);
|
|
}
|
|
|
|
public function listTransactions($page = 1, $count = 25, $orderDirection = 'ASC', $session_id = 0)
|
|
{
|
|
$this->viewBuilder()->setLayout('ajax');
|
|
$startTime = microtime(true);
|
|
|
|
$login_result = $this->requestLogin($session_id, false);
|
|
|
|
if($login_result !== true) {
|
|
return $this->returnJson($login_result);
|
|
}
|
|
$session = $this->getRequest()->getSession();
|
|
$user = $session->read('StateUser');
|
|
|
|
$stateBalancesTable = TableRegistry::getTableLocator()->get('StateBalances');
|
|
$stateUserTransactionsTable = TableRegistry::getTableLocator()->get('StateUserTransactions');
|
|
$transactionsTable = TableRegistry::getTableLocator()->get('Transactions');
|
|
|
|
$stateBalancesTable->updateBalances($user['id']);
|
|
|
|
$gdtSum = 0;
|
|
|
|
$gdtEntries = $this->JsonRequestClient->sendRequestGDT(['email' => $user['email']], 'GdtEntries' . DS . 'sumPerEmailApi');
|
|
|
|
if('success' == $gdtEntries['state'] && 'success' == $gdtEntries['data']['state']) {
|
|
$gdtSum = intval($gdtEntries['data']['sum']);
|
|
} else {
|
|
$this->addAdminError('StateBalancesController', 'overview', $gdtEntries, $user['id'] ? $user['id'] : 0);
|
|
}
|
|
|
|
//echo "count: $count, page: $page<br>";
|
|
$limit = $count;
|
|
$offset = 0;
|
|
$skip_first_transaction = false;
|
|
if($page == 1) {
|
|
$limit--;
|
|
} else {
|
|
$offset = (( $page - 1 ) * $count) - 1;
|
|
}
|
|
if($offset) {
|
|
$limit++;
|
|
$skip_first_transaction = true;
|
|
if($orderDirection == 'ASC') {
|
|
$offset--;
|
|
}
|
|
}
|
|
|
|
//echo "limit: $limit, offset: $offset, skip first transaction: $skip_first_transaction<br>";
|
|
$stateUserTransactionsQuery = $stateUserTransactionsTable
|
|
->find()
|
|
->where(['state_user_id' => $user['id']])
|
|
->order(['balance_date' => $orderDirection])
|
|
->contain([])
|
|
->limit($limit)
|
|
//->page($page)
|
|
->offset($offset)
|
|
;
|
|
$decay = true;
|
|
if($page > 1) {
|
|
$decay = false;
|
|
}
|
|
$transactions = [];
|
|
$transactions_from_db = $stateUserTransactionsQuery->toArray();
|
|
|
|
if(count($transactions_from_db)) {
|
|
if($orderDirection == 'DESC') {
|
|
$transactions_from_db = array_reverse($transactions_from_db);
|
|
}
|
|
|
|
$transactions = $transactionsTable->listTransactionsHumanReadable($transactions_from_db, $user, $decay, $skip_first_transaction);
|
|
//echo "transactions count: " . count($transactions) . "<br>";
|
|
if($orderDirection == 'DESC') {
|
|
$transactions = array_reverse($transactions);
|
|
}
|
|
}
|
|
|
|
$state_balance = $stateBalancesTable->find()->where(['state_user_id' => $user['id']])->first();
|
|
|
|
$body = [
|
|
'state' => 'success',
|
|
'transactions' => $transactions,
|
|
'transactionExecutingCount' => $session->read('Transactions.executing'),
|
|
'count' => $stateUserTransactionsQuery->count(),
|
|
'gdtSum' => $gdtSum,
|
|
'timeUsed' => microtime(true) - $startTime
|
|
];
|
|
$now = new FrozenTime();
|
|
$body['decay_date'] = $now;
|
|
|
|
if(!$state_balance) {
|
|
$body['balance'] = 0.0;
|
|
$body['decay'] = 0.0;
|
|
} else {
|
|
$body['balance'] = $state_balance->amount;
|
|
$body['decay'] = $stateBalancesTable->calculateDecay($state_balance->amount, $state_balance->record_date, $now);
|
|
}
|
|
|
|
$this->set('body', $body);
|
|
}
|
|
|
|
public function listGDTTransactions($page = 1, $count = 25, $orderDirection = 'ASC', $session_id = 0)
|
|
{
|
|
$timeBegin = microtime(true);
|
|
$gdtSum = 0;
|
|
$gdtCount = -1;
|
|
$this->viewBuilder()->setLayout('ajax');
|
|
|
|
$login_result = $this->requestLogin($session_id, false);
|
|
|
|
if($login_result !== true) {
|
|
return $this->returnJson($login_result);
|
|
}
|
|
$session = $this->getRequest()->getSession();
|
|
$user = $session->read('StateUser');
|
|
|
|
if(!$user) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'user not found', 'details' => 'exist a valid session cookie?']);
|
|
}
|
|
|
|
$gdtEntries = $this->JsonRequestClient->sendRequestGDT([
|
|
'email' => $user['email'],
|
|
'page' => $page,
|
|
'count' => $count,
|
|
'orderDirection' => $orderDirection
|
|
], 'GdtEntries' . DS . 'listPerEmailApi');
|
|
|
|
$transactions = [];
|
|
$result = ['state' => 'success'];
|
|
if('success' == $gdtEntries['state'] && 'success' == $gdtEntries['data']['state']) {
|
|
$gdtSum = 0;
|
|
if(isset($gdtEntries['data']['gdtSumPerEmail'])) {
|
|
foreach($gdtEntries['data']['gdtSumPerEmail'] as $email => $sum) {
|
|
$gdtSum += floatval($sum/100.0);
|
|
}
|
|
}
|
|
$result['sum'] = $gdtSum;
|
|
if(isset($gdtEntries['data']['count'])) {
|
|
$result['count'] = intval($gdtEntries['data']['count']);
|
|
}
|
|
if(isset($gdtEntries['data']['ownEntries'])) {
|
|
$result['ownEntries'] = $gdtEntries['data']['ownEntries'];
|
|
}
|
|
if(isset($gdtEntries['data']['publisherPath'])) {
|
|
$result['publisherPath'] = $gdtEntries['data']['publisherPath'];
|
|
}
|
|
if(isset($gdtEntries['data']['connectEntrys'])) {
|
|
$result['connectEntrys'] = $gdtEntries['data']['connectEntrys'];
|
|
}
|
|
} else {
|
|
if($user) {
|
|
$this->addAdminError('StateBalancesController', 'ajaxGdtOverview', $gdtEntries, $user['id']);
|
|
} else {
|
|
$this->addAdminError('StateBalancesController', 'ajaxGdtOverview', $gdtEntries, 0);
|
|
}
|
|
}
|
|
$timeEnd = microtime(true);
|
|
|
|
$result['timeUsed'] = ($timeEnd - $timeBegin) . ' s';
|
|
return $this->returnJson($result);
|
|
}
|
|
|
|
public function getDecayStartBlock()
|
|
{
|
|
$transactionsTable = TableRegistry::getTableLocator()->get('Transactions');
|
|
$decayStartBlock = $transactionsTable->find()->where(['transaction_type_id' => 9]);
|
|
if(!$decayStartBlock->count()) {
|
|
return $this->returnJson(['state' => 'error', 'msg' => 'not found']);
|
|
}
|
|
return $this->returnJson(['state' => 'success', 'decay_start' => $decayStartBlock->first()->received]);
|
|
}
|
|
|
|
private function acquireAccessToken($session_id)
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|