<?php
/*
    Nenninger N-Tools.de
    Version 1.18

  */

class UUID {
	public static function v3($namespace, $name) {
		if(!self::is_valid($namespace)) return false;

		// Get hexadecimal components of namespace
		$nhex = str_replace(array('-','{','}'), '', $namespace);

		// Binary Value
		$nstr = '';

		// Convert Namespace UUID to bits
		for($i = 0; $i < strlen($nhex); $i+=2) {
			$nstr .= chr(hexdec($nhex[$i].$nhex[$i+1]));
		}

		// Calculate hash value
		$hash = md5($nstr . $name);

		return sprintf('%08s-%04s-%04x-%04x-%12s',

					   // 32 bits for "time_low"
					   substr($hash, 0, 8),

					   // 16 bits for "time_mid"
					   substr($hash, 8, 4),

					   // 16 bits for "time_hi_and_version",
					   // four most significant bits holds version number 3
					   (hexdec(substr($hash, 12, 4)) & 0x0fff) | 0x3000,

					   // 16 bits, 8 bits for "clk_seq_hi_res",
					   // 8 bits for "clk_seq_low",
					   // two most significant bits holds zero and one for variant DCE1.1
					   (hexdec(substr($hash, 16, 4)) & 0x3fff) | 0x8000,

					   // 48 bits for "node"
					   substr($hash, 20, 12)
					  );
	}

	public static function v4() {
		return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',

					   // 32 bits for "time_low"
					   mt_rand(0, 0xffff), mt_rand(0, 0xffff),

					   // 16 bits for "time_mid"
					   mt_rand(0, 0xffff),

					   // 16 bits for "time_hi_and_version",
					   // four most significant bits holds version number 4
					   mt_rand(0, 0x0fff) | 0x4000,

					   // 16 bits, 8 bits for "clk_seq_hi_res",
					   // 8 bits for "clk_seq_low",
					   // two most significant bits holds zero and one for variant DCE1.1
					   mt_rand(0, 0x3fff) | 0x8000,

					   // 48 bits for "node"
					   mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
					  );
	}

	public static function v5($namespace, $name) {
		if(!self::is_valid($namespace)) return false;

		// Get hexadecimal components of namespace
		$nhex = str_replace(array('-','{','}'), '', $namespace);

		// Binary Value
		$nstr = '';

		// Convert Namespace UUID to bits
		for($i = 0; $i < strlen($nhex); $i+=2) {
			$nstr .= chr(hexdec($nhex[$i].$nhex[$i+1]));
		}

		// Calculate hash value
		$hash = sha1($nstr . $name);

		return sprintf('%08s-%04s-%04x-%04x-%12s',

					   // 32 bits for "time_low"
					   substr($hash, 0, 8),

					   // 16 bits for "time_mid"
					   substr($hash, 8, 4),

					   // 16 bits for "time_hi_and_version",
					   // four most significant bits holds version number 5
					   (hexdec(substr($hash, 12, 4)) & 0x0fff) | 0x5000,

					   // 16 bits, 8 bits for "clk_seq_hi_res",
					   // 8 bits for "clk_seq_low",
					   // two most significant bits holds zero and one for variant DCE1.1
					   (hexdec(substr($hash, 16, 4)) & 0x3fff) | 0x8000,

					   // 48 bits for "node"
					   substr($hash, 20, 12)
					  );
	}

	public static function is_valid($uuid) {
		return preg_match('/^\{?[0-9a-f]{8}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?'.
						  '[0-9a-f]{4}\-?[0-9a-f]{12}\}?$/i', $uuid) === 1;
	}
}


class hermineConnect{
	private $VERSION = '1.18';
	private $MACHINENAME = 'default';
	private $hermineServer = 'https://api.thw-messenger.de';
	private $connectorID = "";
	private $user = "";
	private $password = "";
	private $passphrase = "";
	private $cURL;
	private $client_key = "";
	private $user_id = "";
	private $private_key;
	private $key_cache_channels;
	private $key_cache_conversations;
	private $lasterror;
	private $companies;
	private $channels;
	private $conversations;
	//private $debug = true;

	/* Hilfsfunktion für multipart/form-data; */
	function build_data_files($boundary, $fields, $files){
		$data = '';
		$eol = "\r\n";
		$delimiter = '-------------' . $boundary;

		foreach ($fields as $name => $content) {
			$data .= "--" . $delimiter . $eol
				. 'Content-Disposition: form-data; name="' . $name . "\"".$eol.$eol
				. $content . $eol
				;
		}
		foreach ($files as $name => $content) {
			$data .= "--" . $delimiter . $eol
				. 'Content-Disposition: form-data; name="file"; filename="[object Object]"' . $eol
				. 'Content-Type: application/octet-stream'.$eol
				;

			$data .= $eol;
			$data .= $content . $eol;
		}
		$data .= "--" . $delimiter . "--".$eol;


		return $data;
	}

	function __construct($user,$password,$passphrase) {
		function intArrayToString($ia){
			$ret = '';
			foreach($ia as $val){
				$ret .= chr($val);
			}
			return $ret;
		}
		if(!isset($_SERVER['SERVER_NAME'])){ //wenn php ohne Apache aufgerufen wird ...
			exec("hostname",$ret);
			$_SERVER['SERVER_NAME'] = implode(" ",$ret);
		}
		$cID = array_map('hexdec', str_split('deadbeef'.sha1($_SERVER['SERVER_NAME']), 2));
		$cID = intArrayToString($cID);
		$this->connectorID =str_replace(['+','/','='], ['','',''],base64_encode($cID));
		$this->user = $user;
		$this->password = $password;
		$this->passphrase = $passphrase;
		$this->cURL = curl_init();
		$this->MACHINENAME = $_SERVER['SERVER_NAME'];
	}

	function __destruct() {
		curl_close($this->cURL);
	}

	function request($_url,$_data,$_files=[],$_rowData=false){   
		$_data['device_id'] = $this->connectorID;
		if($this->client_key != '')
			$_data['client_key'] = $this->client_key;

		$boundary = uniqid();
		$delimiter = '-------------' . $boundary;
		$_data = $this->build_data_files($boundary, $_data, $_files);

		curl_setopt($this->cURL, CURLOPT_URL, $_url);
		curl_setopt($this->cURL, CURLOPT_VERBOSE, 0);
		curl_setopt($this->cURL, CURLOPT_SSL_VERIFYPEER, 1);
		curl_setopt($this->cURL, CURLOPT_RETURNTRANSFER, 1);
		curl_setopt($this->cURL, CURLOPT_POST, true);
		curl_setopt($this->cURL, CURLOPT_POSTFIELDS,$_data);
		curl_setopt($this->cURL, CURLOPT_HTTPHEADER, array("Accept: application/json, text/plain, */*",
														   "Keep-Alive: timeout=5, max=100",
														   "Connection: keep-alive",
														   "Content-Type: multipart/form-data; boundary=" . $delimiter,
														   "Content-Length: " . strlen($_data),
														   'Expect:'
														  ));
		curl_setopt( $this->cURL, CURLOPT_COOKIESESSION, true );
		curl_setopt( $this->cURL, CURLOPT_COOKIEJAR, __DIR__.'/data/hermineConnectCookie.txt' );
		curl_setopt( $this->cURL, CURLOPT_COOKIEFILE, __DIR__.'/data/hermineConnectCookie.txt' );
		curl_setopt( $this->cURL, CURLINFO_HEADER_OUT, true);

		if(isset($this->debug))
			echo "\n\nsenddata->:\n".print_r($_data,true); 

		$data = curl_exec($this->cURL);
		if(!curl_errno($this->cURL)){
			if(isset($this->debug)){
				echo "\n\nSendheader->:\n".print_r(curl_getinfo($this->cURL, CURLINFO_HEADER_OUT),true); 
				echo "\n\nretdata->:\n".print_r($data,true);        
			} 
			if(!$_rowData){
				$data = json_decode($data);
				if($data->status->value === "OK"){
					$this->lasterror = '';
					return $data->payload;
				}else{
					$this->lasterror = $data;
					return false;
				}
			}else{
				return $data;
			}
		} else {
			$this->lasterror = 'Curl error: ' . curl_error($this->cURL);
			return false;
		}


	}

	function _check(){
		//Nenninger ab 20.06.2023 neue
		$data = [
			"app_name" => 'hermine@'.$this->MACHINENAME.'-PHP:'.$this->VERSION,
			"encrypted" => true,
			"callable" => false,
			"key_transfer_support" => false
		];
		$response = $this->request($this->hermineServer."/auth/check",$data);
		if($response !== false){
			return true;
		}else{
			return false;
		}
	}

	function _open_private_key(){
		//Nenninger ab 20.06.2023 neue Parameter format=pem&type=encryption
		$data = ['format'=>'pem','type'=>'encryption'];
		$response = $this->request($this->hermineServer."/security/get_private_key",$data);
		if($response !== false){
			if(property_exists($response,'keys')){
				$private_key = json_decode($response->keys->private_key);
				$privkey_decoded = openssl_pkey_get_private($private_key->private, $this->passphrase);
				if($privkey_decoded !== false){
					$this->private_key = $privkey_decoded;
					return true;
				}else{
					return false;
				}
			}else{
				return false;
			}
		}else{
			return false;
		}
	}

	function _get_conversation_key($_target,$_key=''){
		if($_key == ''){
			if($_target[0]=='conversation'){
				if(!isset($this->key_cache_conversations[$_target[1]])){
					$data = [ "conversation_id" => $_target[1]
							];
					$response = $this->request($this->hermineServer."/message/conversation",$data);
					$this->key_cache_conversations[$_target[1]] = $response->conversation->key;
				}
				if(openssl_private_decrypt(base64_decode($this->key_cache_conversations[$_target[1]]),$ret,$this->private_key,OPENSSL_PKCS1_OAEP_PADDING))
					return $ret;
				else
					return false;
			}else if($_target[0]=='channel'){
				if(!isset($this->key_cache_channels[$_target[1]])){
					$data = [ "channel_id" => $_target[1],
							 "without_members" => true
							];
					$response = $this->request($this->hermineServer."/channels/info",$data);
					$this->key_cache_channels[$_target[1]] = $response->channels->key;

				}
				if(openssl_private_decrypt(base64_decode($this->key_cache_channels[$_target[1]]),$ret,$this->private_key,OPENSSL_PKCS1_OAEP_PADDING))
					return $ret;
				else
					return false;
			}
		}else{
			if(openssl_private_decrypt(base64_decode($_key),$ret,$this->private_key,OPENSSL_PKCS1_OAEP_PADDING))
					return $ret;
				else
					return false;
		}
	}

	function _encrypt_aes($_plain, $_key, $_iv){
		$ret = openssl_encrypt($_plain, "AES-256-CBC", $_key, 0, $_iv);
		return $ret;
	}

	function _decrypt_aes($_crypt, $_key, $_iv){
		if(strlen($_crypt) == 0)
			return '[Dieser Inhalt wurde gelöscht.]';
		$ret = openssl_decrypt($_crypt, "AES-256-CBC", $_key, 0, $_iv);
		if($ret === false)
			return '[!!ERROR DeCrypt] -> '.openssl_error_string();
		return $ret;
	}

	function get_companies(){
		$data = [
			"no_cache" => true
		];

		$response = $this->request($this->hermineServer."/company/member",$data);
		if($response !== false){
			return $response;
		}else{
			return false;
		}
	}

	function get_conversations($_limit = 99999, $_offset = 0){
		$data = [
			"limit" => $_limit,
			"offset" => true,
			"archive" => 0
		];

		$response = $this->request($this->hermineServer."/message/conversations",$data);
		if($response !== false){
			return $response;
		}else{
			return false;
		}
	}

	function get_channels($_company_id){
		$data = [
			"no_cache" => true,
			"company" => $_company_id
		];

		$response = $this->request($this->hermineServer."/channels/subscripted",$data);
		if($response !== false){
			return $response;
		}else{
			return false;
		}
	}

	function sendmsg($_target,$_message,$_files=[],$_url=[],$_location=NULL){
		$iv = openssl_random_pseudo_bytes(16); 
		$conversation_key = $this->_get_conversation_key($_target);
		$data = [
			"target" => $_target[0],
			$_target[0]."_id" => $_target[1],
			"text" => bin2hex(base64_decode($this->_encrypt_aes($_message, $conversation_key, $iv))), 
			"iv" => bin2hex($iv),
			"files" => json_encode($_files), //Nummern vom Upload!
			"url" => json_encode($_url),
			"type" => "text",
			"verification" => "",
			"encrypted" => true,
			"metainfo" => '{"v":1,"style":"md"}'
		];

		if(!is_null($_location)){
			$data["latitude"] = bin2hex(base64_decode($this->_encrypt_aes(strval($_location[0]), $conversation_key, $iv)));
			$data["longitude"] = bin2hex(base64_decode($this->_encrypt_aes(strval($_location[1]), $conversation_key, $iv)));
		}
		$response = $this->request($this->hermineServer."/message/send",$data);
		if($response !== false){
			return $response;
		}else{
			return false;
		}
	}

	function uploadfile($_target,$_fileraw,$_filename,$_filetype,$_mediawidth=0,$_mediaheight=0){
		$iv = openssl_random_pseudo_bytes(16); 
		$file_key = openssl_random_pseudo_bytes(32); 
		$file_uuid = UUID::v4();
		$chunk_size = 5 * 1024 * 1024;
		$filesize = strlen($_fileraw);
		$file_encryptet = base64_decode($this->_encrypt_aes($_fileraw, $file_key, $iv));
		$file = ['dummy' => $file_encryptet];
		$data = [
			"resumableChunkNumber" => 0,
			"resumableChunkSize" => $chunk_size,
			"resumableCurrentChunkSize" => strlen($file_encryptet),
			"resumableTotalSize" => $filesize,
			"resumableType" => $_filetype,
			"resumableIdentifier" => $file_uuid,
			"resumableFilename" =>  $_filename,
			"resumableRelativePath" => $_filename,
			"resumableTotalChunks" => 1,
			"folder" => 0,
			"media_width" => $_mediawidth,
			"media_height" => $_mediaheight,
			"iv" => bin2hex($iv),
			"type" => $_target[0],
			"type_id" => $_target[1],
			"encrypted" => true 
		];

		$response = $this->request($this->hermineServer."/file/upload",$data,$file);
		if($response !== false){
			$iv = openssl_random_pseudo_bytes(16);
			$conversation_key = $this->_get_conversation_key($_target);
			$fileid = $response->file->id;
			$data = [
				"file_id" => $fileid,
				"target" => $_target[0],
				"target_id" => $_target[1],
				"iv" => bin2hex($iv),
				"key" => bin2hex(base64_decode($this->_encrypt_aes($file_key, $conversation_key, $iv)))
			];
			$response = $this->request($this->hermineServer."/security/set_file_access_key",$data);
			return $fileid;
		}else{
			return false;
		}
	}

	function get_messages($_source, $_limit=30, $_offset=0){
		$conversation_key = $this->_get_conversation_key($_source);
		$data = [
			$_source[0]."_id" => $_source[1],
			"source" => $_source[0],
			"limit" => $_limit,
			"offset" => $_offset,
		];

		$response = $this->request($this->hermineServer."/message/content",$data);
		$ret = [];    
		if($response !== false){
			foreach($response->messages as $message){
				if($message->kind == "message"){
					if($message->encrypted){
						if($message->text != ''){
							$encryptet = $this->_decrypt_aes(base64_encode(hex2bin($message->text)), $conversation_key, hex2bin($message->iv));
							if($encryptet !== false)
								$message->text = $encryptet;
							else
								$message->text = '[!!decrypterror!!]';
						}else{
							$message->text = '[Dieser Inhalt wurde gelöscht.]';
						}
					}
					if(isset($message->location->encrypted)){
						if($message->location->encrypted){
							$encryptet = $this->_decrypt_aes(base64_encode(hex2bin($message->location->latitude)), $conversation_key, hex2bin($message->location->iv));
							if($encryptet !== false)
								$message->location->latitude = $encryptet;
							else
								$message->location->latitude = '[!!decrypterror!!]';
							$encryptet = $this->_decrypt_aes(base64_encode(hex2bin($message->location->longitude)), $conversation_key, hex2bin($message->location->iv));
							if($encryptet !== false)
								$message->location->longitude = $encryptet;
							else
								$message->location->longitude = '[!!decrypterror!!]';
						}
					}
					$ret[] = $message;
				}
			}
			return $ret;
		}else{
			return false;
		}
	}

	function _get_channel_infos($_id){
		$data = [
			"channel_id" => $_id
		];

		$response = $this->request($this->hermineServer."/channels/info",$data);
		/*30.10.2024 seit 6.8 sind die Mitglieder nicht mehr bestand der Abfrage und müssen gesondert geholt werden*/
		$data['limit'] = 1000;
		$members = $this->request($this->hermineServer."/channels/members",$data);

		if($response !== false){
			$response->channels->members = $members->members;
			return $response->channels;
		}else{
			return false;
		}
	}

	function list_uploaded_files($_type,$_search,$_offset,$_limit,$_sorting){
		/*type=chats&	search=&	offset=0&	limit=75&	sorting=created_desc*/
		$data = [
			"type" => $_type,
			"search" => $_search,
			"offset" => $_offset,
			"limit" => $_limit,
			"sorting" => $_sorting
		];

		$response = $this->request($this->hermineServer."/folder/list_uploaded_files",$data);

		if($response !== false){
			//print_r($response);
			return $response->files;
		}else{
			return false;
		}
	}
	
	function _file_info($_id){
		$data = [
			"file_id" => $_id
		];
		
		$response = $this->request($this->hermineServer."/file/info",$data);

		if($response !== false){
			return $response;
		}else{
			return false;
		}
	}
	
	function _download_file($_id){
		$fileInfo = $this->_file_info($_id);
		//print_r($fileInfo);
		$response = $this->request($this->hermineServer."/file/download?id=".$_id,[],[],true);
		
		$ret = [];

		if($response !== false){
			$ret[0]['name'] = $fileInfo->file->name;
			$ret[0]['mime'] = $fileInfo->file->mime;
			if($fileInfo->file->encrypted){
				$key = $fileInfo->file->keys[0];
				$conversation_key = $this->_get_conversation_key([$key->type,$key->chat_id],$key->chat_key);
				$decryptedkey = $this->_decrypt_aes(base64_encode(hex2bin($key->key)), $conversation_key, hex2bin($key->iv));
				$decrypted = $this->_decrypt_aes(base64_encode($response), $decryptedkey, hex2bin($fileInfo->file->e2e_iv));
				if($decrypted !== false)
					$ret[1] = $decrypted;
				else
					return '[!!decrypterror!!]';
			}else{
				$ret[1] = $response;
			}
		}else{
			$ret = false;
		}
		return $ret;
	}

	function _delete_files($_ids=[]){
		$data = [
			"file_ids" => json_encode($_ids)
		];

		$response = $this->request($this->hermineServer."/file/delete",$data);

		if($response !== false){
			return $response->success;
		}else{
			return false;
		}
	}
	
	function _open_conversation($_members){
		$conversation_key = openssl_random_pseudo_bytes(32); 
		$receivers = [];
		//selbst immer Mitglied
		$key = '';
		if(openssl_private_encrypt($conversation_key,$key,$this->private_key,OPENSSL_PKCS1_PADDING) === false)
			return false;
		$receivers[] = ['id' => (int)$this->user_id, 'key' => base64_encode($key)];
		
		foreach($_members as $member){
			if(isset($member['id']) && isset($member['public_key'])){
				if(openssl_public_encrypt($conversation_key,$key,$member['public_key'],OPENSSL_PKCS1_OAEP_PADDING ) === false)
					return false;
					//throw new Exception(openssl_error_string());
				$receivers[] = ['id' => (int)$member['id'], 'key' => base64_encode($key)];
			}
		}
		
		$data = [
			"members" => json_encode($receivers)
		];

		$response = $this->request($this->hermineServer."/message/createEncryptedConversation",$data);
		
		if($response !== false){
			//wenn neu angelgt, muss der Key angefragt werden
			if($response->conversation->unique_identifier == '' && $response->conversation->key_requested == '')
				$this->request($this->hermineServer."/security/reset_content_key",["conversation_id" => $response->conversation->id]);
			return $response->conversation;
		}else{
			return false;
		}
	}

	/*  
   Öffentliche Funktionen
*/  

	/*  
     Ausgabe Fehlermeldung von Hermine
  */
	public function get_last_error(){
		return $this->lasterror;
	}

	/*  
     Ausgabe der ID (wird aus eigenem Servername ermittelt)
  */
	public function get_connector_id(){
		return $this->connectorID;
	}

	/*  
     Login, wenn $_saveLogin=true, dann wird device_id und client_key in login.dat gespeichert und es erfolgt keine Mitteilung in Hermine
  */
	public function login($_saveLogin=false){
		$savelogin = new stdClass();
		if($_saveLogin){
			if(file_exists(__DIR__.'/data/hermineConnectLogin.dat')){
				$savelogin = json_decode(file_get_contents(__DIR__.'/data/hermineConnectLogin.dat'));
				$this->client_key = $savelogin->ClientKey;
				$this->connectorID = $savelogin->DeviceId;
				$this->user_id = $savelogin->UserID;
				$this->_check();
				if($this->_open_private_key()){
					$this->companies = $this->get_companies();
					$this->channels = $this->get_channels($this->companies->companies[0]->id);
					$this->conversations = $this->get_conversations();
					return true;
				}
			}
		} 
		$data = [
			"email" => $this->user,
			"password" => $this->password,
			"app_name" => 'hermine@thw-PHP:'.$this->VERSION,
			"encrypted" => true,
			"callable" => false,
			"key_transfer_support" => false
		];

		$response = $this->request($this->hermineServer."/auth/login",$data);
		if($response !== false){
			$this->client_key = $response->client_key;
			$this->user_id = $response->userinfo->id;
			$this->_check();
			if($this->_open_private_key()){
				$this->companies = $this->get_companies();
				$this->channels = $this->get_channels($this->companies->companies[0]->id);
				$this->conversations = $this->get_conversations();
				if($_saveLogin){
					$savelogin->ClientKey = $this->client_key;
					$savelogin->DeviceId = $this->connectorID;
					$savelogin->UserID = $this->user_id;
					file_put_contents(__DIR__.'/data/hermineConnectLogin.dat',json_encode($savelogin)); 
				}
				return true;
			}
		}
		return false;
	}

	public function get_companies_list(){
		$ret = [];
		foreach($this->companies->companies as $company){
			$ret[$company->id] = $company->name; 
		}
		return $ret;
	}

	public function get_conversations_list(){
		$ret = [];
		foreach($this->conversations->conversations as $conversation){
			$ret[$conversation->id] = $conversation->members[0]->first_name.' '.$conversation->members[0]->last_name; 
		}
		return $ret;
	}

	public function get_channels_list(){
		$ret = [];
		foreach($this->channels->channels as $channels){
			$ret[$channels->id] = $channels->name; 
		}
		return $ret;
	}

	public function send_message_to_conversation($_conversation_id,$_message,$_url=[],$_location=NULL){
		return $this->sendmsg(array('conversation',$_conversation_id),$_message,[],$_url,$_location);
	}

	public function send_message_with_file_to_conversation($_conversation_id,$_message,$_fileraw,$_filename,$_filetype,$_mediawidth=0,$_mediaheight=0){
		$ret = $this->uploadfile(array('conversation',$_conversation_id),$_fileraw,$_filename,$_filetype,$_mediawidth,$_mediaheight);
		return $this->sendmsg(array('conversation',$_conversation_id),$_message,[$ret]);
	}

	public function send_message_to_channel($_channel_id,$_message,$_url=[],$_location=NULL){
		return $this->sendmsg(array('channel',$_channel_id),$_message,[],$_url,$_location);
	}

	public function send_message_with_file_to_channel($_channel_id,$_message,$_fileraw,$_filename,$_filetype,$_mediawidth=0,$_mediaheight=0){
		$ret = $this->uploadfile(array('channel',$_channel_id),$_fileraw,$_filename,$_filetype,$_mediawidth,$_mediaheight);
		return $this->sendmsg(array('channel',$_channel_id),$_message,[$ret]);
	}

	public function get_conversation_messages($_conversation_id, $_limit=30, $_offset=0){
		return $this->get_messages(array('conversation',$_conversation_id),$_limit,$_offset);
	}

	public function get_channel_messages($_channel_id,$_limit=50, $_offset=0){
		return $this->get_messages(array('channel',$_channel_id),$_limit,$_offset);
	}

	public function get_channel_infos($_channel_id){
		return $this->_get_channel_infos($_channel_id);
	}

	public function search_user($_searchby, $_limit=50, $_offset=0){
		$data = [
			"limit" => $_limit,
			"offset" => $_offset,
			"key_hashes" => false,
			"search" => $_searchby,
			"sorting" => '["first_name_asc", "last_name_asc"]',
			"exclude_user_ids" => '[]',
			"group_ids" => '[]',
		];

		$response = $this->request($this->hermineServer."/users/listing",$data);
		if($response !== false){
			return $response->users;
		}else{
			return false;
		}
	}

	public function list_uploaded_chat_files($_search){
		return $this->list_uploaded_files('chats',$_search,0,99999,'created_desc');
	}

	public function delete_files($_ids=[]){
		return $this->_delete_files($_ids);
	}
	
	public function download_file($_id){
		return $this->_download_file($_id);
	}
	
	public function open_conversation($_members){
		return $this->_open_conversation($_members);
	}
}
?>