BastliBridge

irc.d (7637B)

---

 module bastlibridge.interfaces.irc;
 import bastlibridge.util;
 import bastlibridge.base;
 import bastlibridge.manager;
 import bastlibridge.command;
 import bastlibridge.interfaces.telegram;
 import std.socket;
 import std.exception;
 import std.typecons;
 import irc.client;
 import std.algorithm;
 import std.range;
 import std.json;
 import std.conv;
 import std.format;
 import std.array;
 import std.datetime : SysTime,Clock;
 import std.experimental.logger;
 
 alias waitForData=wait;
 	
 final class IRCMessage : Message{
 	import irc.client;
 	IrcUser user;
 	const(char)[] msg,channel;
 	SysTime dt;
 	
 	this(IrcUser u, in char[] msg, in char[] channel){
 		this.user=u;
 		this.msg=msg;
 		this.channel=channel;
 		dt=Clock.currTime();
 	}
 	
 	override const(char)[] getMessage(){
 		return msg;
 	}
 	
 	override const(char)[] userName(){
 		return user.nickName;
 	}
 	
 	override const(char)[] getChannelName(){
 		if(channel==(cast(IRC)source).ircClient.nickName){
 			return user.nickName;
 		}
 		else{
 			return channel;
 		}
 	}
 	
 	override SysTime getTime(){
 		return dt;
 	}
 	
 	override bool auth(){
 		bool* val=user.nickName in (cast(IRC)source).admins;
 		if(!val){
 			return false;
 		}
 		return *val;
 	}
 	
 	override void respond(in char[] r){
 		auto ep=cast(IRC)source;
 		const(char)[] chan=getChannelName();
 		trace("Sending response for ", msg, " on ", channel, " to ", chan, ": ", r);
 		ep.send(chan, r);
 	}
 }
 
 final class IRCChannel:Channel{
 	
 }
 
 final class IRC : QueuedEndpoint{
 	import ssl.socket;
 	import irc.url;
 	import irc.client;
 	static import irc.url;
 	
 	private IrcClient ircClient;
 	private Socket sock;
 	private string commandPrefix;
 	
 	Address addr;
 	
 	private __gshared bool shutdown=false;
 	
 	
 	private{
 	static immutable string unknown_username="Unknown";
 	string proxy_url;
 	string formatProxyURL(string file_id){
 		return proxy_url~file_id;
 	}
 	
 	string locationToOSMUrl(JSONValue loc){
 		return locationToOSMUrl(loc["latitude"].floating, loc["longitude"].floating);
 	}
 	string locationToOSMUrl(float lat, float lng){
 		return format!"https://www.openstreetmap.org/#map=%f/%f"(lat, lng);
 	}
 	
 	
 	static string TelegramUserToIRC(JSONValue user, TelegramMessage msg){
 		dchar mode=' ';
 		if(user["is_bot"].type==JSON_TYPE.TRUE){
 			mode='*';
 		}
 		return "<"~mode.to!string~msg.userName().idup~">";
 	}
 	
 	void TelegramToIRC(TelegramMessage msg, ref Appender!string app){
 		TelegramToIRC(msg, app, msg.json);
 	}
 	void TelegramToIRC(TelegramMessage msg, ref Appender!string app, JSONValue m){
 		string username="< "~unknown_username~">";
 		if(auto from="from" in m){
 			app~=TelegramUserToIRC(*from,msg);
 			app~=" ";
 		}
 		if(auto fwd="forward_from" in m){
 			app~=TelegramUserToIRC(*fwd,msg);
 			app~=" ";
 		}
 		foreach(t; ["text", "caption"]){
 			if(auto tv=t in m){
 				app~=(*tv).str;
 				app~=" ";
 			}
 		}
 		
 		if(auto photo="photo" in m){
 			string fid;
 			long size=long.min;
 			foreach(p; (*photo).array){
 				if(p["file_size"].integer>size){
 					size=p["file_size"].integer;
 					fid=p["file_id"].str;
 				}
 			}
 			app~=formatProxyURL(fid);
 			app~=" ";
 		}
 		
 		foreach(t; ["audio", "document", "sticker", "video", "voice"]){
 			if(auto tv=t in m){
 				app~=formatProxyURL((*tv)["file_id"].str);
 				app~=" ";
 			}
 		}
 		if(auto location="location" in m){
 			app~=locationToOSMUrl(*location);
 			app~=" ";
 		}
 		if("contact" in m){
 			auto c=m["contact"];
 			app~=c["first_name"].str;
 			app~=" ";
 			if("last_name" in c){
 				app~=c["last_name"].str;
 				app~=" ";
 			}
 			app~="(";
 			app~=c["phone_number"].str;
 			app~=") ";
 		}
 		if(auto venue="venue" in m){
 			app~=(*venue).str;
 			app~=locationToOSMUrl((*venue)["location"]);
 			app~=" ";
 		}
 		if(auto jv="reply_to_message" in m){
 			TelegramToIRC(msg, app, *jv);
 		}
 	}
 	string TelegramToIRC(TelegramMessage m){
 		Appender!string app;
 		
 		TelegramToIRC(m, app);
 		
 		return app.data[0..$-1];
 	}
 	}
 	
 	bool[string] admins;
 	
 	this(Manager m, string args){
 		super(m,args);
 		
 		string nick,username,realname;
 		bool have_addr=false;
 		ConnectionInfo info;
 		
 		foreach(arg; args.splitter(",")){
 			auto s=arg.findSplit("=");
 			switch(s[0]){
 				case "proxyurl": 
 					proxy_url=s[2];
 				break;
 				case "realname": 
 					realname=s[2];
 				break;
 				case "username": 
 					username=s[2];
 				break;
 				case "nick": 
 					nick=s[2];
 				break;
 				case "admin": 
 					admins[s[2]]=true;
 				break;
 				default:
 					info = irc.url.parse(cast(string)s[0]);
 					have_addr=true;
 				break;
 			}
 		}
 		
 		enforce(have_addr, "You have to provide an URL to connect to with irc://address");
 		enforce(nick, "You have to provide at least a nickname with nick=foo");
 		if(!username) username=nick;
 		if(!realname) realname=nick;
 		
 		this.commandPrefix=("!"~nick);
 		
 		addr = getAddress(info.address, info.port).front;
 		auto af=addr.addressFamily;
 		if(info.secure){
 			sock=new SslSocket(af);
 		}
 		else{
 			sock=new TcpSocket(af);
 		}
 		ircClient = new IrcClient(sock);
 		ircClient.nickName=nick;
 		ircClient.userName(username);
 		ircClient.realName(realname);
 		ircClient.onMessage~=&onInput;
 	}
 	
 	void onInput(IrcUser user, in char[] channel, in char[] msg){
 		trace("Got message from ",user.nickName, " in ", channel, ": ", msg);
 		heartbeat();
 		auto msg2=new IRCMessage(user, msg, channel);
 		msg2.source=this;
 		if(msg.startsWith(this.commandPrefix)){
 			trace("Is a command");
 			onCommand(msg2);
 		}
 		else{
 			trace("Is a message");
 			onMessage(msg2);
 		}
 	}
 	
 	void onMessage(IRCMessage msg){
 		auto chan=getChannel(msg.getChannelName());
 		if(!chan){
 			info("Got message on non-connected channel ", msg.channel);
 			return;
 		}
 		this.manager.distribute(Port(this,chan), msg);
 	}
 	
 	static CommandMachine ircCommands;
 	static this(){
 		ircCommands.add!((Message m, const(char)[] name){(cast(IRC)m.source).admins[name.idup]=true;})("addAdmin", CommandOptions(true));
 		ircCommands.add!((Message m, const(char)[] name){(cast(IRC)m.source).admins[name.idup]=false;})("removeAdmin", CommandOptions(true));
 	}
 	
 	void onCommand(IRCMessage msg){
 		auto s=msg.msg[commandPrefix.length+1..$].findSplit(" ");
 		if(ircCommands.available(s[0])){
 			ircCommands.execute(s[0], msg, s[2]);
 		}
 		else{
 			globalCommands.execute(s[0], msg, s[2]);
 		}
 	}
 	
 	override void open(){
 		info("Connecting to IRC on ", addr.toString);
 		ircClient.connect(addr);
 	}
 	
 	private void _join(string c){
 		if(c[0]=='#'){
 			trace("Joining irc channel ", c);
 			ircClient.join(c);
 		}
 		else{
 			trace("Not joining query ", c);
 		}
 	}
 	override Channel join(string c){
 		_join(c);
 		return new IRCChannel();
 	}
 	
 	override void part(Channel c){
 		auto ic=cast(IRCChannel)c;
 		ircClient.part(ic._name);
 	}
 	
 	override void sendMessageQueueless(scope Message m, Channel chan){
 		auto ichan=cast(IRCChannel)chan;
 		trace("Delivering message of type ",typeid(m)," to channel", ichan._name);
 		if(cast(TelegramMessage)m){
 			send(ichan, TelegramToIRC(cast(TelegramMessage)m));
 		}
 		else{
 			send(ichan, chain("< ",m.userName(), "> ", m.getMessage()));
 		}
 	}
 	
 	protected void send(T)(IRCChannel c, T text){
 		send(c._name, text);
 	}
 	
 	protected void send(T)(in char[] channel, T text){
 		ircClient.send(channel, text);
 	}
 	
 	override void run(){
 		import ssl.openssl;
 		loadOpenSSL(); //We have to do this once for every thread
 		info("Listening for IRC messages on");
 		ubyte[1] buf;
 		while(true){
 			waitForData(sock);
 			info("IRC message received");
 			if(shutdown)
 				break;
 			synchronized(mtx){
 				if(ircClient.read()){
 					break;
 				}
 				sendQueue();
 			}
 		}
 	}
 	override void stop(){
 		synchronized(mtx){
 			shutdown=true;
 			ircClient.quit("Planned shutdown");
 		}
 	}
 }