BastliBridge

telegram.d (4002B)

---

 module bastlibridge.interfaces.telegram;
 static import tg=telegram.telegram;
 import bastlibridge.base;
 import bastlibridge.command;
 import std.conv;
 import std.format;
 import core.sync.mutex;
 import std.array;
 import std.datetime : SysTime, Clock;
 import std.json;
 import std.algorithm;
 
 final class Telegram: QueuedEndpoint{
 	private tg.Telegram telegram, telegram_listener;
 	Mutex telegram_lock, listener_lock;
 	
 	this(Manager m, string args){
 		super(m,args);
 		
 		telegram=tg.Telegram(args);
 		telegram_listener=tg.Telegram(args);
 		
 		telegram_lock=new Mutex();
 		listener_lock=new Mutex();
 		
 		telegram_listener.onMessage~=(j){
 			trace("Received Message\n"~j.toPrettyString());
 			auto jv="text" in j;
 			trace("We have some text");
 			string msg="";
 			if(jv){
 				msg=j["text"].str;
 			}
 			trace("got message ", msg);
 			
 			auto chatid=j["chat"]["id"].integer;
 			trace("chatid is ", chatid);
 			auto chan=chatid in telegram_channels;
 			trace("we got the channel ", chan);
 			auto get_msg(){
 				auto m=new TelegramMessage(j);
 				m.source=this;
 				return m;
 			}
 			void forward_msg(){
 				if(!chan){
 					warning("Message to unknown chat ", chatid);
 				}
 				else{
 					manager.distribute(Port(this, *chan), get_msg());
 				}
 			}
 			
 			if(msg.length>0 && msg.front=='/'){
 				trace("Bot command received");
 				try{
 					auto split=msg.findSplit(" ");
 					auto cmdbot=split[0].findSplit("@");
 					if(cmdbot[1].length!=0 && cmdbot[2]!=telegram.botName){
 						trace("Not one of our commands");
 						forward_msg();
 					}
 					else{
 						auto s=msg.findSplit(" ");
 						globalCommands.execute(s[0][1..$], get_msg(), s[2], false);
 					}
 				}
 				catch(Exception e){
 					warning(e.to!string);
 				}
 			}
 			else{
 				trace("Normal message");
 				forward_msg();
 			}
 		};
 	}
 	
 	override void open(){
 		telegram.connect();
 		telegram_listener.connect();
 	}
 	
 	private TelegramChannel[long] telegram_channels;
 	override Channel join(string c){
 		auto id=c.to!long;
 		auto chan=new TelegramChannel(id);
 		telegram_channels[id]=chan;
 		return chan;
 	}
 	
 	override void part(Channel c){
 		
 	}
 	
 	override void sendMessageQueueless(Message m, Channel c){
 		send((cast(TelegramChannel)c).id, "<"~m.userName()~"> "~m.getMessage());
 	}
 	
 	private __gshared bool shutdown=false;
 	
 	override void run(){
 		import ssl.openssl;
 		loadOpenSSL(); //We have to do this once for every thread
 		while(!shutdown){
 			trace("triggering updates");
 			synchronized(mtx)
 				telegram_listener.triggerUpdates();
 			trace("waiting for messages");
 			telegram_listener.wait();
 			heartbeat();
 			synchronized(mtx){
 				telegram_listener.read();
 				sendQueue();
 			}
 			trace("msgloop done");
 		}
 	}
 
 	override void stop(){
 		shutdown=true;
 		telegram_listener.disconnect();
 		synchronized(telegram_lock)
 			telegram.disconnect();
 	}
 	
 	void send(long id, in char[] msg){
 		synchronized(telegram_lock){
 			telegram.send(id, msg);
 		}
 	}
 }
 
 final class TelegramChannel : Channel{
 	long id;
 	this(long id){
 		this.id=id;
 	}
 }
 
 final class TelegramMessage : Message{
 	JSONValue json;
 	
 	@property Telegram _source(){
 		return cast(Telegram)(source);
 	}
 	
 	this(JSONValue json){
 		this.json=json;
 	}
 	static string TelegramUser(JSONValue User){
 		string username="unknown";
 		foreach(key; ["username", "first_name", "last_name"]){
 			if(key in User){
 				username=User[key].str;
 				break;
 			}
 		}
 		return username;
 	}
 	override const(char)[] userName(){
 		if(auto from="from" in json){
 			return TelegramUser(*from);
 		}
 		return "";
 	}
 	
 	override const(char)[] getMessage(){
 		if(auto t="text" in json){
 			return t.str;
 		}
 		return "";
 	}
 	override const(char)[] getChannelName(){
 		auto chat=json["chat"];
 		if(auto t="title" in chat){
 			return t.str;
 		}
 		return json["id"].integer.to!string;
 	}
 	
 	override bool auth(){
 		return false;
 	}
 	
 	override SysTime getTime(){
 		return SysTime();
 	}
 	
 	override void respond(in char[] response){
 		_source.send(json["chat"]["id"].integer, response);
 	}
 }