p34.10 (#514)

Sellafield · web-flow · commit d6e60f3ded7f · 2025-05-28T12:07:31.000+05:00
diff --git a/src/Perpetuum.Bootstrapper/PerpetuumBootstrapper.cs b/src/Perpetuum.Bootstrapper/PerpetuumBootstrapper.cs
@@ -301,6 +301,17 @@ private static void InitGame(IComponentContext container)
 
         private void InitContainer(string gameRoot)
         {
+            _ = _builder.Register(c => new FileSystem(gameRoot)).As<IFileSystem>();
+            _ = _builder.Register(c =>
+            {
+                IFileSystem fileManager = c.Resolve<IFileSystem>();
+                string settingsFile = fileManager.ReadAllText("perpetuum.ini");
+                GlobalConfiguration configuration = JsonConvert.DeserializeObject<GlobalConfiguration>(settingsFile);
+                configuration.GameRoot = gameRoot;
+
+                return configuration;
+            }).SingleInstance();
+
             _builder.RegisterModule(new CommandsModule());
             _builder.RegisterModule(new RequestHandlersModule());
             _builder.RegisterModule(new ZoneRequestHandlersModule());
@@ -356,16 +367,6 @@ private void InitContainer(string gameRoot)
 
             InitRelayManager();
 
-            _ = _builder.Register(c => new FileSystem(gameRoot)).As<IFileSystem>();
-            _ = _builder.Register(c =>
-            {
-                IFileSystem fileManager = c.Resolve<IFileSystem>();
-                string settingsFile = fileManager.ReadAllText("perpetuum.ini");
-                GlobalConfiguration configuration = JsonConvert.DeserializeObject<GlobalConfiguration>(settingsFile);
-                configuration.GameRoot = gameRoot;
-                return configuration;
-            }).SingleInstance();
-
             _ = _builder.RegisterType<AdminCommandRouter>().SingleInstance();
 
             _ = _builder.RegisterType<Gang>();
diff --git a/src/Perpetuum/Services/Channels/Channel.cs b/src/Perpetuum/Services/Channels/Channel.cs
@@ -15,6 +15,8 @@ public class Channel
 
         public bool IsForcedJoin { get; private set; }
 
+        public ulong? DiscordId { get; private set; }
+
         public IChannelLogger Logger { get; private set; }
         private ChannelType _type;
         private ChannelType _prevType;
@@ -33,12 +35,13 @@ private Channel()
 
         }
 
-        public Channel(int id, ChannelType type, string name, string topic, string password, bool isForcedJoin, IChannelLogger logger) : this(type, name, logger)
+        public Channel(int id, ChannelType type, string name, string topic, string password, bool isForcedJoin, ulong? discordId, IChannelLogger logger) : this(type, name, logger)
         {
             Id = id;
             Topic = topic;
             Password = password;
             IsForcedJoin = isForcedJoin;
+            DiscordId = discordId;
         }
 
         public Channel(ChannelType type, string name, IChannelLogger logger)
@@ -63,6 +66,7 @@ public Channel SetId(int id)
                     Topic = Topic,
                     Password = Password,
                     IsForcedJoin = IsForcedJoin,
+                    DiscordId = DiscordId,
                     Logger = Logger,
                     _members = new Dictionary<Character, ChannelMember>(_members)
                 };
@@ -85,6 +89,7 @@ public Channel SetTopic(string topic)
                     Topic = topic,
                     Password = Password,
                     IsForcedJoin = IsForcedJoin,
+                    DiscordId = DiscordId,
                     Logger = Logger,
                     _members = new Dictionary<Character, ChannelMember>(_members)
                 };
@@ -102,7 +107,9 @@ public Channel SetPassword(string password)
                     Topic = Topic,
                     Password = password,
                     IsForcedJoin = IsForcedJoin,
+                    DiscordId = DiscordId,
                     Logger = Logger,
+
                     _members = new Dictionary<Character, ChannelMember>(_members)
                 };
         }
@@ -124,6 +131,7 @@ public Channel SetMember(ChannelMember member)
                 Topic = Topic,
                 Password = Password,
                 IsForcedJoin = IsForcedJoin,
+                DiscordId = DiscordId,
                 Logger = Logger,
                 _members = members
             };
@@ -148,6 +156,7 @@ public Channel RemoveMember(Character member)
                     Topic = Topic,
                     Password = Password,
                     IsForcedJoin = IsForcedJoin,
+                    DiscordId = DiscordId,
                     Logger = Logger,
                     _members = members
                 };
diff --git a/src/Perpetuum/Services/Channels/ChannelManager.cs b/src/Perpetuum/Services/Channels/ChannelManager.cs
@@ -1,17 +1,15 @@
-﻿using Newtonsoft.Json;
-using Perpetuum.Accounting.Characters;
+﻿using Perpetuum.Accounting.Characters;
 using Perpetuum.Common.Loggers;
 using Perpetuum.Host.Requests;
 using Perpetuum.Services.Channels.ChatCommands;
+using Perpetuum.Services.EventServices;
+using Perpetuum.Services.EventServices.EventMessages;
 using Perpetuum.Services.Sessions;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Net.Http;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Perpetuum.Services.Channels
 {
@@ -27,6 +25,7 @@ public class ChannelManager : IChannelManager
         private readonly ConcurrentDictionary<string, Channel> _channels = new ConcurrentDictionary<string, Channel>();
         private readonly AdminCommandRouter _adminCommand;
         private readonly GlobalConfiguration _globalConfiguration;
+        private readonly EventListenerService _eventChannel;
 
         public ChannelManager(
             ISessionManager sessionManager,
@@ -35,6 +34,7 @@ public ChannelManager(
             IChannelBanRepository banRepository,
             ChannelLoggerFactory channelLoggerFactory,
             AdminCommandRouter adminCommand,
+            EventListenerService eventListener,
             GlobalConfiguration globalConfiguration)
         {
             _sessionManager = sessionManager;
@@ -51,6 +51,7 @@ public ChannelManager(
                 _channels[channel.Name] = channel;
             }
 
+            _eventChannel = eventListener;
             _globalConfiguration = globalConfiguration;
         }
 
@@ -313,6 +314,17 @@ public void Talk(string channelName, Character sender, string message, IRequest
             {
                 channel.SendMessageToAll(_sessionManager, sender, message);
 
+                if (channel.DiscordId != null)
+                {
+                    _eventChannel.PublishMessage(
+                        new DiscordIntegrationMessage(
+                            EventType.PerpetuumToDiscord,
+                            channel.DiscordId.Value,
+                            sender.Nick,
+                            message));
+                }
+
+                /*
                 if (channel.Name == HelpChat)
                 {
                     // Sending message to discord
@@ -340,6 +352,7 @@ public void Talk(string channelName, Character sender, string message, IRequest
                         HttpResponseMessage response = await httpClient.PostAsync(url, content);
                     });
                 }
+                */
             }
         }
 
@@ -461,11 +474,17 @@ public IEnumerable<Channel> GetAllChannels()
         {
             return _channels.Values;
         }
+
+        public string GetChannelNameByDiscordId(ulong discordId)
+        {
+            return _channels.FirstOrDefault(x => x.Value.DiscordId.GetValueOrDefault() == discordId).Key;
+        }
     }
 
     internal class DiscordPayload
     {
-        public DateTime Timestamp { get; set; }
         public string content { get; set; }
+
+        public object allowed_mentions { get; } = new { parse = new[] { "users" } };
     }
 }
diff --git a/src/Perpetuum/Services/Channels/ChannelRepository.cs b/src/Perpetuum/Services/Channels/ChannelRepository.cs
@@ -52,10 +52,14 @@ public IEnumerable<Channel> GetAll()
                 string topic = record.GetValue<string>("topic");
                 string password = record.GetValue<string>("password");
                 bool isForcedJoin = record.GetValueOrDefault<bool>("isForcedJoin");
+                string discordIdString = record.GetValueOrDefault<string>("DiscordId");
+                ulong? discordId = ulong.TryParse(discordIdString, out ulong parsedId)
+                    ? parsedId
+                    : (ulong?)null;
 
                 IChannelLogger logger = _channelLoggerFactory(name);
 
-                return new Channel(id, type, name, topic, password, isForcedJoin, logger);
+                return new Channel(id, type, name, topic, password, isForcedJoin, discordId, logger);
             }).ToArray();
         }
     }
diff --git a/src/Perpetuum/Services/Channels/IChannelManager.cs b/src/Perpetuum/Services/Channels/IChannelManager.cs
@@ -1,6 +1,6 @@
-﻿using System.Collections.Generic;
-using Perpetuum.Accounting.Characters;
+﻿using Perpetuum.Accounting.Characters;
 using Perpetuum.Host.Requests;
+using System.Collections.Generic;
 
 namespace Perpetuum.Services.Channels
 {
@@ -11,6 +11,8 @@ public interface IChannelManager
         [CanBeNull]
         Channel GetChannelByName(string name);
 
+        string GetChannelNameByDiscordId(ulong discordId);
+
         void CreateChannel(ChannelType type, string name);
         void DeleteChannel(string channelName);
         void JoinChannel(string channelName, Character member, ChannelMemberRole role, string password);
diff --git a/src/Perpetuum/Services/EventServices/EventListenerService.cs b/src/Perpetuum/Services/EventServices/EventListenerService.cs
@@ -41,7 +41,21 @@ public EventListenerService(GlobalConfiguration globalConfiguration)
         /// <param name="message">EventMessage of the type</param>
         public void PublishMessage(IEventMessage message)
         {
-            _queue.Enqueue(message);
+            if (message is DiscordIntegrationMessage discordMessage &&
+                discordMessage.Type == EventType.PerpetuumToDiscord)
+            {
+                if (_client.GetChannel(discordMessage.ChannelDiscordId) is IMessageChannel discordChannel)
+                {
+                    string messageToSend = $"**<{discordMessage.Nick}>**: {discordMessage.Message}";
+                    discordChannel.SendMessageAsync(
+                        messageToSend,
+                        allowedMentions: new AllowedMentions { AllowedTypes = AllowedMentionTypes.Users });
+                }
+            }
+            else
+            {
+                _queue.Enqueue(message);
+            }
         }
 
         public void NotifyListeners(IEventMessage message)
@@ -127,17 +141,20 @@ private Task OnMessageReceived(SocketMessage message)
         {
             ulong.TryParse(_globalConfiguration.OpHelpChannelId, out ulong channelId);
 
-            if (!message.Author.IsBot && message.Channel.Id == channelId && !string.IsNullOrEmpty(message.Content))
+            if (!message.Author.IsBot && /*message.Channel.Id == channelId &&*/ !string.IsNullOrEmpty(message.CleanContent))
             {
                 string nick = message.Author.GlobalName;
 
+                // No more imposting until we find a better approach
+                /*
                 if (message.Author is SocketGuildUser guildUser &&
                     !string.IsNullOrEmpty(guildUser.DisplayName))
                 {
                     nick = guildUser.DisplayName;
                 }
+                */
 
-                PublishMessage(new DiscordIntegrationMessage(nick, message.Content));
+                PublishMessage(new DiscordIntegrationMessage(EventType.DiscordToPerpetuum, message.Channel.Id, nick, message.CleanContent));
             }
 
             return Task.CompletedTask;
diff --git a/src/Perpetuum/Services/EventServices/EventMessages/DiscordIntegrationMessage.cs b/src/Perpetuum/Services/EventServices/EventMessages/DiscordIntegrationMessage.cs
@@ -5,11 +5,14 @@
     /// </summary>
     public class DiscordIntegrationMessage : IEventMessage
     {
-        public EventType Type => EventType.DiscordIntegration;
+        public EventType Type { get; private set; }
+        public ulong ChannelDiscordId { get; private set; }
         public string Nick { get; private set; }
         public string Message { get; private set; }
-        public DiscordIntegrationMessage(string nick, string message)
+        public DiscordIntegrationMessage(EventType type, ulong channelDiscordId, string nick, string message)
         {
+            Type = type;
+            ChannelDiscordId = channelDiscordId;
             Nick = nick;
             Message = message;
         }
diff --git a/src/Perpetuum/Services/EventServices/EventProcessors/DiscordIntegrationHandler.cs b/src/Perpetuum/Services/EventServices/EventProcessors/DiscordIntegrationHandler.cs
@@ -11,23 +11,27 @@ public class DiscordIntegrationHandler : EventProcessor
     {
         private readonly IChannelManager _channelManager;
         private const string SENDER_CHARACTER_NICKNAME = "Discord";
-        private const string HelpChat = "regchannel_help";
-        private readonly Character _announcer;
+        private readonly Character _discordIntegrationCharacter;
 
         public DiscordIntegrationHandler(IChannelManager channelManager)
         {
-            _announcer = Character.GetByNick(SENDER_CHARACTER_NICKNAME);
+            _discordIntegrationCharacter = Character.GetByNick(SENDER_CHARACTER_NICKNAME);
             _channelManager = channelManager;
         }
 
-        public override EventType Type => EventType.DiscordIntegration;
+        public override EventType Type => EventType.DiscordToPerpetuum;
         public override void HandleMessage(IEventMessage message)
         {
             if (message is DiscordIntegrationMessage discordMessage)
             {
-                string chatMessage = $"{discordMessage.Nick}: {discordMessage.Message}";
+                string channelName = _channelManager.GetChannelNameByDiscordId(discordMessage.ChannelDiscordId);
 
-                _channelManager.Announcement(HelpChat, _announcer, chatMessage);
+                if (!string.IsNullOrEmpty(channelName))
+                {
+                    string chatMessage = $"{discordMessage.Nick}: {discordMessage.Message}";
+
+                    _channelManager.Announcement(channelName, _discordIntegrationCharacter, chatMessage);
+                }
             }
         }
     }
diff --git a/src/Perpetuum/Services/EventServices/EventType.cs b/src/Perpetuum/Services/EventServices/EventType.cs
@@ -13,6 +13,7 @@ public enum EventType
         Environmental,
         PortalSpawn,
         NpcSapAttackers,
-        DiscordIntegration,
+        DiscordToPerpetuum,
+        PerpetuumToDiscord,
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,15 @@`
`1`		`-using Newtonsoft.Json;`
`2`		`-using Perpetuum.Accounting.Characters;`
	`1`	`+using Perpetuum.Accounting.Characters;`
`3`	`2`	`using Perpetuum.Common.Loggers;`
`4`	`3`	`using Perpetuum.Host.Requests;`
`5`	`4`	`using Perpetuum.Services.Channels.ChatCommands;`
	`5`	`+using Perpetuum.Services.EventServices;`
	`6`	`+using Perpetuum.Services.EventServices.EventMessages;`
`6`	`7`	`using Perpetuum.Services.Sessions;`
`7`	`8`	`using System;`
`8`	`9`	`using System.Collections.Concurrent;`
`9`	`10`	`using System.Collections.Generic;`
`10`	`11`	`using System.Linq;`
`11`		`-using System.Net.Http;`
`12`		`-using System.Text;`
`13`	`12`	`using System.Threading;`
`14`		`-using System.Threading.Tasks;`
`15`	`13`
`16`	`14`	`namespace Perpetuum.Services.Channels`
`17`	`15`	`{`
`@@ -27,6 +25,7 @@ public class ChannelManager : IChannelManager`
`27`	`25`	`private readonly ConcurrentDictionary<string, Channel> _channels = new ConcurrentDictionary<string, Channel>();`
`28`	`26`	`private readonly AdminCommandRouter _adminCommand;`
`29`	`27`	`private readonly GlobalConfiguration _globalConfiguration;`
	`28`	`+ private readonly EventListenerService _eventChannel;`
`30`	`29`
`31`	`30`	`public ChannelManager(`
`32`	`31`	`ISessionManager sessionManager,`
`@@ -35,6 +34,7 @@ public ChannelManager(`
`35`	`34`	`IChannelBanRepository banRepository,`
`36`	`35`	`ChannelLoggerFactory channelLoggerFactory,`
`37`	`36`	`AdminCommandRouter adminCommand,`
	`37`	`+ EventListenerService eventListener,`
`38`	`38`	`GlobalConfiguration globalConfiguration)`
`39`	`39`	`{`
`40`	`40`	`_sessionManager = sessionManager;`
`@@ -51,6 +51,7 @@ public ChannelManager(`
`51`	`51`	`_channels[channel.Name] = channel;`
`52`	`52`	`}`
`53`	`53`
	`54`	`+ _eventChannel = eventListener;`
`54`	`55`	`_globalConfiguration = globalConfiguration;`
`55`	`56`	`}`
`56`	`57`
`@@ -313,6 +314,17 @@ public void Talk(string channelName, Character sender, string message, IRequest`
`313`	`314`	`{`
`314`	`315`	`channel.SendMessageToAll(_sessionManager, sender, message);`
`315`	`316`
	`317`	`+ if (channel.DiscordId != null)`
	`318`	`+ {`
	`319`	`+ _eventChannel.PublishMessage(`
	`320`	`+ new DiscordIntegrationMessage(`
	`321`	`+ EventType.PerpetuumToDiscord,`
	`322`	`+ channel.DiscordId.Value,`
	`323`	`+ sender.Nick,`
	`324`	`+ message));`
	`325`	`+ }`
	`326`	`+`
	`327`	`+ /*`
`316`	`328`	`if (channel.Name == HelpChat)`
`317`	`329`	`{`
`318`	`330`	`// Sending message to discord`
`@@ -340,6 +352,7 @@ public void Talk(string channelName, Character sender, string message, IRequest`
`340`	`352`	`HttpResponseMessage response = await httpClient.PostAsync(url, content);`
`341`	`353`	`});`
`342`	`354`	`}`
	`355`	`+ */`
`343`	`356`	`}`
`344`	`357`	`}`
`345`	`358`
`@@ -461,11 +474,17 @@ public IEnumerable<Channel> GetAllChannels()`
`461`	`474`	`{`
`462`	`475`	`return _channels.Values;`
`463`	`476`	`}`
	`477`	`+`
	`478`	`+ public string GetChannelNameByDiscordId(ulong discordId)`
	`479`	`+ {`
	`480`	`+ return _channels.FirstOrDefault(x => x.Value.DiscordId.GetValueOrDefault() == discordId).Key;`
	`481`	`+ }`
`464`	`482`	`}`
`465`	`483`
`466`	`484`	`internal class DiscordPayload`
`467`	`485`	`{`
`468`		`- public DateTime Timestamp { get; set; }`
`469`	`486`	`public string content { get; set; }`
	`487`	`+`
	`488`	`+ public object allowed_mentions { get; } = new { parse = new[] { "users" } };`
`470`	`489`	`}`
`471`	`490`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,10 +52,14 @@ public IEnumerable<Channel> GetAll()`
`52`	`52`	`string topic = record.GetValue<string>("topic");`
`53`	`53`	`string password = record.GetValue<string>("password");`
`54`	`54`	`bool isForcedJoin = record.GetValueOrDefault<bool>("isForcedJoin");`
	`55`	`+ string discordIdString = record.GetValueOrDefault<string>("DiscordId");`
	`56`	`+ ulong? discordId = ulong.TryParse(discordIdString, out ulong parsedId)`
	`57`	`+ ? parsedId`
	`58`	`+ : (ulong?)null;`
`55`	`59`
`56`	`60`	`IChannelLogger logger = _channelLoggerFactory(name);`
`57`	`61`
`58`		`- return new Channel(id, type, name, topic, password, isForcedJoin, logger);`
	`62`	`+ return new Channel(id, type, name, topic, password, isForcedJoin, discordId, logger);`
`59`	`63`	`}).ToArray();`
`60`	`64`	`}`
`61`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,14 @@`
`5`	`5`	`/// </summary>`
`6`	`6`	`public class DiscordIntegrationMessage : IEventMessage`
`7`	`7`	`{`
`8`		`- public EventType Type => EventType.DiscordIntegration;`
	`8`	`+ public EventType Type { get; private set; }`
	`9`	`+ public ulong ChannelDiscordId { get; private set; }`
`9`	`10`	`public string Nick { get; private set; }`
`10`	`11`	`public string Message { get; private set; }`
`11`		`- public DiscordIntegrationMessage(string nick, string message)`
	`12`	`+ public DiscordIntegrationMessage(EventType type, ulong channelDiscordId, string nick, string message)`
`12`	`13`	`{`
	`14`	`+ Type = type;`
	`15`	`+ ChannelDiscordId = channelDiscordId;`
`13`	`16`	`Nick = nick;`
`14`	`17`	`Message = message;`
`15`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,23 +11,27 @@ public class DiscordIntegrationHandler : EventProcessor`
`11`	`11`	`{`
`12`	`12`	`private readonly IChannelManager _channelManager;`
`13`	`13`	`private const string SENDER_CHARACTER_NICKNAME = "Discord";`
`14`		`- private const string HelpChat = "regchannel_help";`
`15`		`- private readonly Character _announcer;`
	`14`	`+ private readonly Character _discordIntegrationCharacter;`
`16`	`15`
`17`	`16`	`public DiscordIntegrationHandler(IChannelManager channelManager)`
`18`	`17`	`{`
`19`		`- _announcer = Character.GetByNick(SENDER_CHARACTER_NICKNAME);`
	`18`	`+ _discordIntegrationCharacter = Character.GetByNick(SENDER_CHARACTER_NICKNAME);`
`20`	`19`	`_channelManager = channelManager;`
`21`	`20`	`}`
`22`	`21`
`23`		`- public override EventType Type => EventType.DiscordIntegration;`
	`22`	`+ public override EventType Type => EventType.DiscordToPerpetuum;`
`24`	`23`	`public override void HandleMessage(IEventMessage message)`
`25`	`24`	`{`
`26`	`25`	`if (message is DiscordIntegrationMessage discordMessage)`
`27`	`26`	`{`
`28`		`- string chatMessage = $"{discordMessage.Nick}: {discordMessage.Message}";`
	`27`	`+ string channelName = _channelManager.GetChannelNameByDiscordId(discordMessage.ChannelDiscordId);`
`29`	`28`
`30`		`- _channelManager.Announcement(HelpChat, _announcer, chatMessage);`
	`29`	`+ if (!string.IsNullOrEmpty(channelName))`
	`30`	`+ {`
	`31`	`+ string chatMessage = $"{discordMessage.Nick}: {discordMessage.Message}";`
	`32`	`+`
	`33`	`+ _channelManager.Announcement(channelName, _discordIntegrationCharacter, chatMessage);`
	`34`	`+ }`
`31`	`35`	`}`
`32`	`36`	`}`
`33`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public enum EventType`
`13`	`13`	`Environmental,`
`14`	`14`	`PortalSpawn,`
`15`	`15`	`NpcSapAttackers,`
`16`		`- DiscordIntegration,`
	`16`	`+ DiscordToPerpetuum,`
	`17`	`+ PerpetuumToDiscord,`
`17`	`18`	`}`
`18`	`19`	`}`