public override Task UserTextMessage(Murmur.User user, Murmur.TextMessage message)
{
var apiUser = new UserWrapper(SteamListener, WServer, user);
var destChans = message.channels.Select(x => new ChannelShim(WServer, x)).ToArray();
return(Task.WhenAll(Plugins.Select(x => x.OnChatMessage(apiUser, destChans, message.text))));
}
public override Task ContextAction(string action, Murmur.User usr, int session, int channelid)
{
var apiUser = new Plugins.UserWrapper(SteamListener, Server, usr);
IServerContextCallback server;
if (ServerCallbacks.TryGetValue(action, out server))
{
return(server.Run(apiUser));
}
IChannelContextCallback channel;
if (ChannelCallbacks.TryGetValue(action, out channel))
{
return(channel.Run(apiUser, new Plugins.ChannelShim(Server, channelid)));
}
IUserContextCallback user;
if (UserCallbacks.TryGetValue(action, out user))
{
return(user.Run(apiUser, new Plugins.UserShim(SteamListener, Server, session)));
}
System.Diagnostics.Trace.WriteLine(action, "Unknown context callback action");
return(Task.FromResult <object>(null));
}
public override async Task UserStateChanged(Murmur.User user)
{
using (var context = await FancyContext.Connect())
using (var transact = context.Database.BeginTransaction())
{
var current = await context.Logs.Where(x => x.Who.Id == user.userid)
.OrderByDescending(x => x.When).Select(x => x.Where.Id).FirstAsync();
if (current != user.channel)
{
context.Logs.Add(new LogEntry.ChannelSwitched
{
When = DateTimeOffset.Now,
Who = context.Users.Attach(new User {
Id = user.userid
}),
Where = await context.Channels.SingleAsync(x => x.ServerId == user.channel),
});
await context.SaveChangesAsync();
}
transact.Commit();
}
}
public override async Task UserConnected(Murmur.User user)
{
using (var context = await FancyContext.Connect())
using (var transact = context.Database.BeginTransaction(IsolationLevel.Serializable))
{
var userNotificationsQuery = from usr in context.Users.Include(x => x.PersistentGuest.Godfathers)
.Include(x => x.GuestInvite.Inviter).Include(x => x.Membership)
where usr.Id == user.userid
join evt in context.Logs.OfType <LogEntry.Connected>() on usr.Id equals evt.Who.Id into connectedEvents
let lastConnection = connectedEvents.Max(x => x.When)
join notific in context.OfflineNotifications on usr.Id equals notific.Recipient.Id into notifications
select new { usr, notifications = notifications.Where(x => x.When > lastConnection) };
var res = await userNotificationsQuery.SingleAsync();
foreach (var notify in res.notifications)
{
await Server.SendMessage(user.session, notify.Message);
}
if (res.usr.Membership == null)
{
var onlineUsers = await Server.GetUsers();
var godfathers = res.usr.PersistentGuest?.Godfathers?.Select(x => x.UserId) ?? new[] { res.usr.GuestInvite.Inviter.Id };
if (!godfathers.Intersect(onlineUsers.Select(x => x.Value.userid)).Any())
{
await Server.KickUser(user.session, "Inviter not online.");
return;
}
if (res.usr.GuestInvite != null)
{
// move guest to inviter
var inviter = onlineUsers.Single(x => x.Value.userid == res.usr.GuestInvite.InviterId);
user.channel = inviter.Value.channel;
user.suppress = false;
await Server.SetState(user);
}
}
context.Logs.Add(new LogEntry.Connected
{
When = DateTimeOffset.Now,
Who = res.usr,
Where = await context.Channels.SingleAsync(x => x.ServerId == user.channel),
});
await context.SaveChangesAsync();
transact.Commit();
}
}
public override async Task UserTextMessage(Murmur.User user, Murmur.TextMessage message)
{
using (var context = await FancyContext.Connect())
using (var transact = context.Database.BeginTransaction())
{
User senderEntity = null;
if (user.userid > 0)
{
senderEntity = await context.Users.FindAsync(user.userid);
}
var qtext = message.text.Replace(""", "\"");
var msg = CommandPattern.Matches(qtext).Cast <Match>().Select(m => m.Value).ToArray();
if (message.channels.Any())
{
if (msg[0] == "@fancy-ng")
{
await CommandMgr.HandleCommand(SteamListener, Server, user, msg.Skip(1));
}
if (senderEntity != null)
{
context.Logs.Add(new LogEntry.ChatMessage
{
When = DateTimeOffset.Now,
Who = senderEntity,
Where = await context.Channels.SingleAsync(x => x.ServerId == user.channel),
Message = message.text
});
}
}
if (senderEntity != null)
{
var messagesInTheLastSeconds = await context.Logs.OfType <LogEntry.ChatMessage>()
.Where(x => x.Who.Id == senderEntity.Id && x.When > DbFunctions.AddSeconds(DateTimeOffset.Now, -5)).CountAsync();
if (messagesInTheLastSeconds >= 3)
{
await Server.KickUser(user.session, "Who are you, my evil twin?! [stop spamming]");
}
}
await context.SaveChangesAsync();
transact.Commit();
}
}
public override async Task UserDisconnected(Murmur.User user)
{
Model.UserAttribute.CertificateCredentials cc;
Fancyauth.GuestCredentials.TryRemove(user.userid, out cc);
using (var context = await FancyContext.Connect())
using (var transact = context.Database.BeginTransaction())
{
context.Logs.Add(new LogEntry.Disconnected
{
When = DateTimeOffset.Now,
Who = context.Users.Attach(new User {
Id = user.userid
}),
Where = await context.Channels.SingleAsync(x => x.ServerId == user.channel),
});
await context.SaveChangesAsync();
transact.Commit();
}
}
public virtual Task ContextAction(string action, Murmur.User usr, int session, int channelid)
{
return(NullTask);
}
public override void contextAction(string action, Murmur.User usr, int session, int channelid, Ice.Current current__)
{
}
public override void getState_async(Murmur.AMD_Server_getState cb__, int session, Ice.Current current__)
{
Murmur.User ret__ = new Murmur.User();
cb__.ice_response(ret__);
}
public Murmur.User getState(int session, _System.Collections.Generic.Dictionary<string, string> context__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing("getState", Ice.OperationMode.Idempotent, context__);
try
{
try
{
IceInternal.BasicStream os__ = og__.ostr();
os__.writeInt(session);
}
catch(Ice.LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(Murmur.InvalidSessionException)
{
throw;
}
catch(Murmur.ServerBootedException)
{
throw;
}
catch(Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
IceInternal.BasicStream is__ = og__.istr();
is__.startReadEncaps();
Murmur.User ret__;
ret__ = null;
if(ret__ == null)
{
ret__ = new Murmur.User();
}
ret__.read__(is__);
is__.endReadEncaps();
return ret__;
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public void userStateChanged(Murmur.User state, _System.Collections.Generic.Dictionary<string, string> context__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing("userStateChanged", Ice.OperationMode.Idempotent, context__);
try
{
try
{
IceInternal.BasicStream os__ = og__.ostr();
if(state == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
state.write__(os__);
}
}
catch(Ice.LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
if(!og__.istr().isEmpty())
{
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
og__.istr().skipEmptyEncaps();
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public static _System.Collections.Generic.Dictionary<int, Murmur.User> read(IceInternal.BasicStream is__)
{
int sz__ = is__.readSize();
_System.Collections.Generic.Dictionary<int, Murmur.User> r__ = new _System.Collections.Generic.Dictionary<int, Murmur.User>();
for(int i__ = 0; i__ < sz__; ++i__)
{
int k__;
k__ = is__.readInt();
Murmur.User v__;
v__ = null;
if(v__ == null)
{
v__ = new Murmur.User();
}
v__.read__(is__);
r__[k__] = v__;
}
return r__;
}
public virtual Task UserTextMessage(Murmur.User user, Murmur.TextMessage message)
{
return(NullTask);
}
public virtual Task UserStateChanged(Murmur.User user)
{
return(NullTask);
}
public virtual Task UserDisconnected(Murmur.User user)
{
return(NullTask);
}
public static Murmur.User[] read(IceInternal.BasicStream is__)
{
Murmur.User[] v__;
{
int szx__ = is__.readAndCheckSeqSize(44);
v__ = new Murmur.User[szx__];
for(int ix__ = 0; ix__ < szx__; ++ix__)
{
v__[ix__] = new Murmur.User();
v__[ix__].read__(is__);
}
}
return v__;
}
public override Task UserDisconnected(Murmur.User user)
{
var apiUser = new UserWrapper(SteamListener, WServer, user);
return(Task.WhenAll(Plugins.Select(x => x.OnUserDisconnected(apiUser))));
}
private Ice.AsyncResult<Murmur.Callback_ServerCallback_userStateChanged> begin_userStateChanged(Murmur.User state, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerCallback_userStateChanged> result__ = new IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerCallback_userStateChanged>(this, __userStateChanged_name, userStateChanged_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__userStateChanged_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
if(state == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
state.write__(os__);
}
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
public sealed override void contextAction_async(Murmur.AMD_ServerContextCallback_contextAction cb__, string action, Murmur.User usr, int session, int channelid, Ice.Current current__)
{
cb__.ice_response();
AsyncCompleter(ContextAction(action, usr, session, channelid));
}
public override void read__(IceInternal.BasicStream is__, bool rid__)
{
if(rid__)
{
/* string myId = */ is__.readTypeId();
}
is__.startReadSlice();
if(c == null)
{
c = new Murmur.Channel();
}
c.read__(is__);
{
int szx__ = is__.readSize();
is__.startSeq(szx__, 4);
children = new Murmur.Tree[szx__];
for(int ix__ = 0; ix__ < szx__; ++ix__)
{
IceInternal.ArrayPatcher<Murmur.Tree> spx = new IceInternal.ArrayPatcher<Murmur.Tree>("::Murmur::Tree", children, ix__);
is__.readObject(spx);
is__.checkSeq();
is__.endElement();
}
is__.endSeq(szx__);
}
{
int szx__ = is__.readSize();
is__.startSeq(szx__, 42);
users = new Murmur.User[szx__];
for(int ix__ = 0; ix__ < szx__; ++ix__)
{
users[ix__] = new Murmur.User();
users[ix__].read__(is__);
is__.checkSeq();
is__.endElement();
}
is__.endSeq(szx__);
}
is__.endReadSlice();
base.read__(is__, true);
}
public static Murmur.User[] read(IceInternal.BasicStream is__)
{
Murmur.User[] v__;
{
int szx__ = is__.readSize();
is__.startSeq(szx__, 42);
v__ = new Murmur.User[szx__];
for(int ix__ = 0; ix__ < szx__; ++ix__)
{
v__[ix__] = new Murmur.User();
v__[ix__].read__(is__);
is__.checkSeq();
is__.endElement();
}
is__.endSeq(szx__);
}
return v__;
}
public sealed override void userStateChanged_async(Murmur.AMD_ServerCallback_userStateChanged cb__, Murmur.User state, Ice.Current current__)
{
cb__.ice_response();
AsyncCompleter(UserStateChanged(state));
}
public static void write(IceInternal.BasicStream os__,
_System.Collections.Generic.Dictionary<int, Murmur.User> v__)
{
if(v__ == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(v__.Count);
foreach(_System.Collections.Generic.KeyValuePair<int, Murmur.User> e__ in v__)
{
os__.writeInt(e__.Key);
if(e__.Value == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
e__.Value.write__(os__);
}
}
}
}
public sealed override void userTextMessage_async(Murmur.AMD_ServerCallback_userTextMessage cb__, Murmur.User state, Murmur.TextMessage message, Ice.Current current__)
{
cb__.ice_response();
AsyncCompleter(UserTextMessage(state, message));
}
public void contextAction(string action, Murmur.User usr, int session, int channelid, _System.Collections.Generic.Dictionary<string, string> context__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing("contextAction", Ice.OperationMode.Idempotent, context__);
try
{
try
{
IceInternal.BasicStream os__ = og__.ostr();
os__.writeString(action);
if(usr == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
usr.write__(os__);
}
os__.writeInt(session);
os__.writeInt(channelid);
}
catch(Ice.LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
if(!og__.istr().isEmpty())
{
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
og__.istr().skipEmptyEncaps();
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public Task SetState(Murmur.User state)
{
return(FixIce.FromAsyncVoid(state, S.begin_setState, S.end_setState));
}
public override void userDisconnected(Murmur.User state, Ice.Current current__)
{
}
public static Ice.DispatchStatus userStateChanged___(ServerCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
checkMode__(Ice.OperationMode.Idempotent, current__.mode);
IceInternal.BasicStream is__ = inS__.istr();
is__.startReadEncaps();
Murmur.User state;
state = null;
if(state == null)
{
state = new Murmur.User();
}
state.read__(is__);
is__.endReadEncaps();
obj__.userStateChanged(state, current__);
return Ice.DispatchStatus.DispatchOK;
}
public override void userStateChanged(Murmur.User state, Ice.Current current__)
{
}
public UserWrapper(Steam.SteamListener steamListener, Wrapped.Server server, Murmur.User user)
: base(steamListener, server, user.session)
{
User = user;
}
public override void setState_async(Murmur.AMD_Server_setState cb__, Murmur.User state, Ice.Current current__)
{
cb__.ice_response();
}
public Murmur.User end_getState(Ice.AsyncResult r__)
{
IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
IceInternal.OutgoingAsync.check__(outAsync__, this, __getState_name);
if(!outAsync__.wait__())
{
try
{
outAsync__.throwUserException__();
}
catch(Murmur.InvalidSecretException)
{
throw;
}
catch(Murmur.InvalidSessionException)
{
throw;
}
catch(Murmur.ServerBootedException)
{
throw;
}
catch(Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
Murmur.User ret__;
IceInternal.BasicStream is__ = outAsync__.istr__;
is__.startReadEncaps();
ret__ = null;
if(ret__ == null)
{
ret__ = new Murmur.User();
}
ret__.read__(is__);
is__.endReadEncaps();
return ret__;
}
public static Ice.DispatchStatus contextAction___(ServerContextCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
checkMode__(Ice.OperationMode.Idempotent, current__.mode);
IceInternal.BasicStream is__ = inS__.istr();
is__.startReadEncaps();
string action;
action = is__.readString();
Murmur.User usr;
usr = null;
if(usr == null)
{
usr = new Murmur.User();
}
usr.read__(is__);
int session;
session = is__.readInt();
int channelid;
channelid = is__.readInt();
is__.endReadEncaps();
obj__.contextAction(action, usr, session, channelid, current__);
return Ice.DispatchStatus.DispatchOK;
}
private Ice.AsyncResult<Murmur.Callback_ServerContextCallback_contextAction> begin_contextAction(string action, Murmur.User usr, int session, int channelid, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerContextCallback_contextAction> result__ = new IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerContextCallback_contextAction>(this, __contextAction_name, contextAction_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__contextAction_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(action);
if(usr == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
usr.write__(os__);
}
os__.writeInt(session);
os__.writeInt(channelid);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
public static Ice.DispatchStatus setState___(Server obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
checkMode__(Ice.OperationMode.Idempotent, current__.mode);
IceInternal.BasicStream is__ = inS__.istr();
is__.startReadEncaps();
Murmur.User state;
state = null;
if(state == null)
{
state = new Murmur.User();
}
state.read__(is__);
is__.endReadEncaps();
AMD_Server_setState cb__ = new _AMD_Server_setState(inS__);
try
{
obj__.setState_async(cb__, state, current__);
}
catch(_System.Exception ex__)
{
cb__.ice_exception(ex__);
}
return Ice.DispatchStatus.DispatchAsync;
}
public void ice_response(Murmur.User ret__)
{
if(validateResponse__(true))
{
try
{
IceInternal.BasicStream os__ = this.os__();
if(ret__ == null)
{
Murmur.User tmp__ = new Murmur.User();
tmp__.write__(os__);
}
else
{
ret__.write__(os__);
}
}
catch(Ice.LocalException ex__)
{
ice_exception(ex__);
}
response__(true);
}
}
async Task IReadModifyWriteObject.Refresh()
{
User = await Server.GetState(User.session);
}
public Task HandleCommand(Steam.SteamListener steamListener, Wrapped.Server server, Murmur.User caller, IEnumerable <string> cmd)
{
CommandFunc func;
if (_Commands.TryGetValue(cmd.FirstOrDefault(), out func))
{
return(func(new Plugins.UserWrapper(steamListener, server, caller), cmd.Skip(1)));
}
else
{
return(server.SendMessage(caller.session, "Unknown command"));
}
}