/// <summary>
/// Отдельный конструктор для тестирования
/// </summary>
/// <param name="view"></param>
/// <param name="db"></param>
/// <param name="selectedChatID"></param>
/// <param name="chatManager"></param>
public DictionaryChatPresenter(IDictionaryChatView view, ISQLiteTesting db, int selectedChatID, IChatManager chatManager, ILanguageManager languageManager, IChatHistoryManager chatHistoryManager)
{
this.view = view;
this.db = db;
this.selectedChatID = selectedChatID;
this.chatManager = chatManager;
this.languageManager = languageManager;
this.chatHistoryManager = chatHistoryManager;
}
/// <summary>
/// Основной конструктор
/// </summary>
/// <param name="view"></param>
/// <param name="db"></param>
/// <param name="selectedChatID"></param>
public DictionaryChatPresenter(IDictionaryChatView view, ISQLiteTesting db, int selectedChatID)
{
this.view = view;
this.db = db;
this.selectedChatID = selectedChatID;
LanguageManager languageManager = new LanguageManager(db);
this.chatHistoryManager = new ChatHistoryManager(db);
this.chatManager = new ChatManager(db, languageManager, chatHistoryManager);
this.languageManager = new LanguageManager(db);
}
public void Execute(IChatManager manager, IClient client, params string[] args)
{
string message = "Available commands:\n";
foreach (IChatCommand command in manager.Commands.Values)
{
message += String.Format("{0}: {1}\n", command.Command, command.Description);
}
message = message.Trim(' ', '\n');
manager.SendPrivateMessage(client, Shared.ChatChannel.Default, message, "Server", null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="manager">The chat repository manager</param>
public ChatHub(IChatManager<string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> manager, ILoggerFactory loggerFactory) : base()
{
if (manager == null)
throw new ArgumentNullException("manager");
if (loggerFactory == null)
throw new ArgumentNullException("loggerFactory");
Logger = loggerFactory.CreateLogger<ChatHub>();
Logger.LogInformation("constructor");
Manager = manager;
}
/// <inheritdoc />
public virtual IWatchdog CreateWatchdog(
IChatManager chat,
IDmbFactory dmbFactory,
ISessionPersistor sessionPersistor,
ISessionControllerFactory sessionControllerFactory,
IIOManager gameIOManager,
IIOManager diagnosticsIOManager,
IEventConsumer eventConsumer,
Api.Models.Instance instance,
DreamDaemonSettings settings)
=> new BasicWatchdog(
public ChatManagerServer()
{
try
{
cm = (IChatManager)RemoteNew.New(typeof(IChatManager));
}
catch (Exception)
{
cm = null;
}
}
public MTSession(ILogger <MTSession> logger, ServerOptions options, IMTServiceProvider serviceProvider)
{
this.logger = logger;
this.options = options;
this.serverKey = options.ServerKey;
this.Services = serviceProvider;
this.messageQueue = new SessionMessageQueue(this);
this.userManager = serviceProvider.GetService <IUserManager>();
this.ChatManager = serviceProvider.GetService <IChatManager>();
this.UpdateManager = serviceProvider.GetService <IUpdateManager>();
}
public void Dispose()
{
_configManager.OnProfileChange -= ConfigManager_SynchronizeJSConfig;
_configManager.RemovePropertyChangeListener(ConfigManager_SynchronizeJSConfig);
_browserAPIManager.ConfigHandler = null;
_browserAPIManager = null;
_chatManager = null;
_configManager = null;
_container = null;
}
public RequestController(
ITokenRepository tokenRepository, IUserRepository userRepository, IGroupRepository groupRepository,
IMessageRepository messageRepository, IRequestRepository requestRepository, IChatManager chatManager)
{
this.tokenRepository = tokenRepository;
this.userRepository = userRepository;
this.groupRepository = groupRepository;
this.messageRepository = messageRepository;
this.requestRepository = requestRepository;
this.chatManager = chatManager;
}
public SuicideKind Suicide(IEntity victim, IChatManager chat)
{
var othersMessage = Loc.GetString("{0:theName} has thrown themselves on a meat spike!", victim);
victim.PopupMessageOtherClients(othersMessage);
var selfMessage = Loc.GetString("You throw yourself on a meat spike!");
victim.PopupMessage(selfMessage);
return(SuicideKind.Piercing);
}
/// <inheritdoc />
public override IWatchdog CreateWatchdog(
IChatManager chat,
IDmbFactory dmbFactory,
ISessionPersistor sessionPersistor,
ISessionControllerFactory sessionControllerFactory,
IIOManager gameIOManager,
IIOManager diagnosticsIOManager,
IEventConsumer eventConsumer,
IRemoteDeploymentManagerFactory remoteDeploymentManagerFactory,
Api.Models.Instance instance,
DreamDaemonSettings settings)
=> new WindowsWatchdog(
public void Execute(IChatManager manager, IClient client, params string[] args)
{
StringBuilder builder = new StringBuilder("Available commands:\n");
foreach (IChatCommand command in manager.Commands.Values)
{
builder.AppendFormat("{0}: {1}\n", command.Command, command.Description);
}
string message = builder.ToString().Trim(' ', '\n');
manager.SendPrivateMessage(client, Shared.ChatChannel.Default, message, "Server", null);
}
// ECS this out!, Handleable SuicideEvent?
SuicideKind ISuicideAct.Suicide(EntityUid victim, IChatManager chat)
{
var othersMessage = Loc.GetString("comp-kitchen-spike-suicide-other", ("victim", victim));
victim.PopupMessageOtherClients(othersMessage);
var selfMessage = Loc.GetString("comp-kitchen-spike-suicide-self");
victim.PopupMessage(selfMessage);
return(SuicideKind.Piercing);
}
public void Initialize(ApplicationStartupHandler handler, IDIContext container)
{
_container = container ?? throw new ArgumentNullException(nameof(container));
_browserAPIManager = _container.Resolve <IBrowserAPIManager>();
_configManager = _container.Resolve <IConfigManager>();
_chatManager = _container.Resolve <IChatManager>();
_browserAPIManager.ConfigHandler = new BrowserConfigHandler(this);
_configManager.OnProfileChange += ConfigManager_SynchronizeJSConfig;
_configManager.AddPropertyChangeListener("*", ConfigManager_SynchronizeJSConfig);
}
/// <summary>
/// Construct a <see cref="SessionController"/>
/// </summary>
/// <param name="reattachInformation">The value of <see cref="reattachInformation"/></param>
/// <param name="process">The value of <see cref="process"/></param>
/// <param name="byondLock">The value of <see cref="byondLock"/></param>
/// <param name="byondTopicSender">The value of <see cref="byondTopicSender"/></param>
/// <param name="bridgeRegistrar">The <see cref="IBridgeRegistrar"/> used to populate <see cref="bridgeRegistration"/>.</param>
/// <param name="chat">The value of <see cref="chat"/></param>
/// <param name="chatTrackingContext">The value of <see cref="chatTrackingContext"/></param>
/// <param name="assemblyInformationProvider">The <see cref="IAssemblyInformationProvider"/> for the <see cref="SessionController"/>.</param>
/// <param name="logger">The value of <see cref="logger"/></param>
/// <param name="startupTimeout">The optional time to wait before failing the <see cref="LaunchResult"/></param>
/// <param name="reattached">If this is a reattached session.</param>
public SessionController(
ReattachInformation reattachInformation,
IProcess process,
IByondExecutableLock byondLock,
ITopicClient byondTopicSender,
IChatTrackingContext chatTrackingContext,
IBridgeRegistrar bridgeRegistrar,
IChatManager chat,
IAssemblyInformationProvider assemblyInformationProvider,
ILogger <SessionController> logger,
uint?startupTimeout,
bool reattached)
{
this.reattachInformation = reattachInformation ?? throw new ArgumentNullException(nameof(reattachInformation));
this.process = process ?? throw new ArgumentNullException(nameof(process));
this.byondLock = byondLock ?? throw new ArgumentNullException(nameof(byondLock));
this.byondTopicSender = byondTopicSender ?? throw new ArgumentNullException(nameof(byondTopicSender));
this.chatTrackingContext = chatTrackingContext ?? throw new ArgumentNullException(nameof(chatTrackingContext));
bridgeRegistration = bridgeRegistrar?.RegisterHandler(this) ?? throw new ArgumentNullException(nameof(bridgeRegistrar));
this.chat = chat ?? throw new ArgumentNullException(nameof(chat));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.chatTrackingContext.SetChannelSink(this);
portClosedForReboot = false;
disposed = false;
apiValidationStatus = ApiValidationStatus.NeverValidated;
released = false;
rebootTcs = new TaskCompletionSource <object>();
primeTcs = new TaskCompletionSource <object>();
reattachTopicCts = new CancellationTokenSource();
synchronizationLock = new object();
_ = process.Lifetime.ContinueWith(
x =>
{
if (!disposed)
{
reattachTopicCts.Cancel();
}
chatTrackingContext.Active = false;
},
TaskScheduler.Current);
LaunchResult = GetLaunchResult(
assemblyInformationProvider,
startupTimeout,
reattached);
logger.LogDebug("Created session controller. Primary: {0}, CommsKey: {1}, Port: {2}", IsPrimary, reattachInformation.AccessIdentifier, Port);
}
public ChatController(
IChatManager chatManager,
IHubContext <ChatHub> chat,
ApplicationDbContext context,
INotificationManager notificationManager,
UserManager <ApplicationUser> userManager)
{
_chatManager = chatManager;
_chat = chat;
_context = context;
_notificationManager = notificationManager;
_userManager = userManager;
}
public ChatsListViewModel(IPageService pageService, IChatManager chatManager)
{
_pageService = pageService;
_chatManager = chatManager;
OpenFriendsListCommand = new Command(async
() => await OpenFriendsListPage(),
() => _canOpenFriend);
OpenChatCommand = new Command(async
(o) => await OpenChatPage(o),
(o) => _canOpenChat);
}
public ZoneListener(IChatManager chatManager, IClanManager clanManager, IFriendManager friendManager,
IGroupManager groupManager, IGuildManager guildManager, IMemorialDungeonManager memorialDungeonManager,
IPlayerManager playerManager, ISiegeManager siegeManager)
{
_chatManager = chatManager;
_clanManager = clanManager;
_friendManager = friendManager;
_groupManager = groupManager;
_guildManager = guildManager;
_memorialDungeonManager = memorialDungeonManager;
_siegeManager = siegeManager;
_playerManager = playerManager;
}
public ConfigHotkeyUpdater(string hotkeyid, string hotkeyName, IConfigManager configManager, string configKey, IHotkeyManager hotkeyManager, IChatManager chatManager)
{
_hotkeyId = hotkeyid ?? throw new ArgumentNullException(nameof(hotkeyid));
_configKey = configKey ?? throw new ArgumentNullException(nameof(configKey));
_hotkeyName = hotkeyName ?? throw new ArgumentNullException(nameof(hotkeyName));
_configManager = configManager ?? throw new ArgumentNullException(nameof(configManager));
_hotkeyManager = hotkeyManager ?? throw new ArgumentNullException(nameof(hotkeyManager));
_chatManager = chatManager ?? throw new ArgumentNullException(nameof(chatManager));
_hotkeyManager.RegisterHotkey(_hotkeyId, Hotkey_Action);
_configManager.AddPropertyChangeListener(_configKey, true, true, ConfigManager_Update);
}
public EventManager(IChatManager chatManager, IMessageManager messageManager, ICharacterManager characterManager, IChannelManager channelManager)
{
this.characterManager = characterManager;
this.channelManager = channelManager;
chatManager.Connected += () => {
characterManager.OnlineCharacters.CollectionChanged += (sender, args) => {
switch (args.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var character in args.NewItems.Cast <Character>())
{
AddEvent(new LoginEvent(character));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var character in args.OldItems.Cast <Character>())
{
AddEvent(new LogoutEvent(character));
}
break;
}
};
chatManager.CommandReceived += OnCommandReceived;
};
messageManager.ChannelMessageReceived += (channel, message) => {
if (message.Sender == characterManager.OwnCharacter)
{
return;
}
OnChannelMessage(channel, message);
};
channelManager.JoinedChannels.CollectionChanged += (sender, args) => {
switch (args.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var channel in args.NewItems.Cast <Channel>())
{
channel.Members.CollectionChanged += (_, memberArgs) => ChannelMembersChanged(channel, memberArgs);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var channel in args.OldItems.Cast <Channel>())
{
AddEvent(new ChannelLeaveEvent(channel, channel.Members[characterManager.OwnCharacter]));
}
break;
}
};
}
public ChatHub(ILifetimeScope lifetimeScope)
{
_hubLifetimeScope = lifetimeScope.BeginLifetimeScope();
if (userManager == null)
{
//this.userManager = (IUserManager)DependencyResolver.Current.GetService(typeof(IUserManager));
this.userManager = _hubLifetimeScope.Resolve <IUserManager>();
}
if (chatManager == null)
{
//this.chatManager = (IChatManager)DependencyResolver.Current.GetService(typeof(IChatManager));
this.chatManager = _hubLifetimeScope.Resolve <IChatManager>();
}
}
SuicideKind ISuicideAct.Suicide(EntityUid victim, IChatManager chat)
{
var headCount = 0;
if (_entities.TryGetComponent <SharedBodyComponent?>(victim, out var body))
{
var headSlots = body.GetSlotsOfType(BodyPartType.Head);
foreach (var slot in headSlots)
{
var part = slot.Part;
if (part == null ||
!body.TryDropPart(slot, out var dropped))
{
continue;
}
foreach (var droppedPart in dropped.Values)
{
if (droppedPart.PartType != BodyPartType.Head)
{
continue;
}
_storage.Insert(droppedPart.Owner);
headCount++;
}
}
}
var othersMessage = headCount > 1
? Loc.GetString("microwave-component-suicide-multi-head-others-message", ("victim", victim))
: Loc.GetString("microwave-component-suicide-others-message", ("victim", victim));
victim.PopupMessageOtherClients(othersMessage);
var selfMessage = headCount > 1
? Loc.GetString("microwave-component-suicide-multi-head-message")
: Loc.GetString("microwave-component-suicide-message");
victim.PopupMessage(selfMessage);
_currentCookTimerTime = 10;
ClickSound();
UIDirty = true;
Wzhzhzh();
return(SuicideKind.Heat);
}
public void GreetSuspicion(List <SuspicionTraitorRole> traitors, IChatManager chatMgr)
{
chatMgr.DispatchServerMessage(Mind.Session, Loc.GetString("suspicion-role-greeting", ("roleName", Name)));
chatMgr.DispatchServerMessage(Mind.Session, Loc.GetString("suspicion-objective", ("objectiveText", Objective)));
var allPartners = string.Join(", ", traitors.Where(p => p != this).Select(p => p.Mind.CharacterName));
var partnerText = Loc.GetString(
"suspicion-partners-in-crime",
("partnerCount", traitors.Count - 1),
("partnerNames", allPartners)
);
chatMgr.DispatchServerMessage(Mind.Session, partnerText);
}
public ConnectingViewModel(IRegionManager regionManager, IServerManager serverManager, IChatManager chatManager)
: base(regionManager, serverManager)
{
SetState();
this.chatManager = chatManager;
if (serverManager.IsConnect)
{
this.chatManager.FindChat();
}
this.serverManager.Connected += OnConnected;
this.chatManager.JoinedChat += OnJoinedChat;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="manager">The chat repository manager</param>
public ChatHub(IChatManager <string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> manager, ILoggerFactory loggerFactory) : base()
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (loggerFactory == null)
{
throw new ArgumentNullException("loggerFactory");
}
Logger = loggerFactory.CreateLogger <ChatHub>();
Logger.LogInformation("constructor");
Manager = manager;
}
private void DealDamage(ISuicideAct suicide, IChatManager chat, DamageableComponent damageableComponent, IEntity source, IEntity target)
{
SuicideKind kind = suicide.Suicide(target, chat);
if (kind != SuicideKind.Special)
{
damageableComponent.TakeDamage(kind switch
{
SuicideKind.Brute => DamageType.Brute,
SuicideKind.Heat => DamageType.Heat,
SuicideKind.Cold => DamageType.Cold,
SuicideKind.Acid => DamageType.Acid,
SuicideKind.Toxic => DamageType.Toxic,
SuicideKind.Electric => DamageType.Electric,
_ => DamageType.Brute
},
public UsersListViewModel(INetworkConnectionController networkConnectionController, IEventAggregator eventAggregator, IChatManager chatManager, ICurrentUser currentUser)
{
_networkConnectionController = networkConnectionController;
_eventAggregator = eventAggregator;
_chatManager = chatManager;
_currentUser = currentUser;
_networkConnectionController.MessageReceivedEventHandler += NewMessageFromServer;
_eventAggregator.GetEvent <LogoffEvent>().Subscribe(Logoff);
SelectedSocketUser = new SocketUser();
OnlineSocketUsers = new ObservableCollection <SocketUser>();
OfflineSocketUsers = new ObservableCollection <SocketUser>();
ViewLoadedCommand = new DelegateCommand(LoadView);
}
public void Initialize(ApplicationStartupHandler handler, IDIContext container)
{
_container = container ?? throw new ArgumentNullException(nameof(container));
_chatLogger = new CustomChatLogger();
//_chatLogger.LogChannels = Enum.GetValues(typeof(ChatChannel)).Cast<ChatChannel>(); //will log everything that comes from the chat manager
_configManager = _container.Resolve <IConfigManager>();
_configManager.AddPropertyChangeListener("behaviour.chatlog.active", true, true, ConfigManager_UpdateWriteLog);
_configManager.AddPropertyChangeListener("behaviour.chatlog.path", true, true, ConfigManager_UpdateLogPath);
_configManager.AddPropertyChangeListener("behaviour.chatlog.format", true, true, ConfigManager_UpdateLogFormat);
_configManager.AddPropertyChangeListener("behaviour.channel.log", true, true, ConfigManager_UpdateLogChannels);
_chatManager = _container.Resolve <IChatManager>();
_chatManager.OnChatMessage += ChatManager_ChatMessageEvent;
}
public void Dispose()
{
_configManager.RemovePropertyChangeListener(ConfigManager_UpdateWriteLog);
_configManager.RemovePropertyChangeListener(ConfigManager_UpdateLogPath);
_configManager.RemovePropertyChangeListener(ConfigManager_UpdateLogChannels);
_configManager.RemovePropertyChangeListener(ConfigManager_UpdateLogFormat);
_configManager = null;
_chatManager.OnChatMessage -= ChatManager_ChatMessageEvent;
_chatManager = null;
_chatLogger?.Dispose();
_chatLogger = null;
_container = null;
}
public ServerConnection(IChatManager chatManager, IBufferManager buffer, CharacterManager characterManager, ChannelManager channelManager)
{
this.chatManager = chatManager;
this.buffer = buffer;
this.characterManager = characterManager;
this.channelManager = channelManager;
statusTimer.Elapsed += delegate {
lock (statusTimer) {
Send(ClientCommandType.STA, newStatus);
newStatus = null;
lastStatusTime = DateTime.Now;
}
};
chatManager.CommandReceived += OnServerCommandReceived;
chatManager.Connected += OnConnectComplete;
}
private void DealDamage(ISuicideAct suicide, IChatManager chat, IDamageableComponent damageableComponent, IEntity source, IEntity target)
{
SuicideKind kind = suicide.Suicide(target, chat);
if (kind != SuicideKind.Special)
{
damageableComponent.ChangeDamage(kind switch
{
SuicideKind.Blunt => DamageType.Blunt,
SuicideKind.Piercing => DamageType.Piercing,
SuicideKind.Heat => DamageType.Heat,
SuicideKind.Disintegration => DamageType.Disintegration,
SuicideKind.Cellular => DamageType.Cellular,
SuicideKind.DNA => DamageType.DNA,
SuicideKind.Asphyxiation => DamageType.Asphyxiation,
_ => DamageType.Blunt
},
public ChatViewModel(IRegionManager regionManager, IServerManager serverManager, IChatManager chatManager)
: base(regionManager, serverManager)
{
this.chatManager = chatManager;
if (!this.chatManager.IsInChat)
{
this.GoToConnectingScreen();
return;
}
this.chatManager.LeftChat += GoToConnectingScreen;
this.chatManager.NewMessage += OnNewMessage;
this.SendCommand = new DelegateCommand <string>(Send);
this.LeaveCommand = new DelegateCommand(Leave);
}
public SpeechBubble(string text, IEntity senderEntity, IEyeManager eyeManager, IChatManager chatManager)
{
_chatManager = chatManager;
_senderEntity = senderEntity;
_eyeManager = eyeManager;
// Use text clipping so new messages don't overlap old ones being pushed up.
RectClipContent = true;
var bubble = BuildBubble(text);
AddChild(bubble);
ForceRunStyleUpdate();
ContentHeight = bubble.CombinedMinimumSize.Y;
_verticalOffsetAchieved = -ContentHeight;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="manager">the chat repository manager</param>
public UserController(IChatManager<string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> manager)
{
_manager = manager;
}
public DirectionsPresenter(IDirectionsView view, IChatManager chatManager, ILanguageManager languageManager)
{
this.view = view;
this.chatManager = chatManager;
this.languageManager = languageManager;
}
public AccountController(UserManager<ChatLeUser> userManager, SignInManager<ChatLeUser> signInManager, IChatManager<string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> chatManager)
{
UserManager = userManager;
SignInManager = signInManager;
ChatManager = chatManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="chatManager">the chat repository manager</param>
/// <param name="signalRConnectionManager">the SignalR connection manager</param>
/// <param name="userManager">the Identity user manager</param>
public ChatController(IChatManager<string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> chatManager, IConnectionManager signalRConnectionManager, UserManager<ChatLeUser> userManager)
{
_chatManager = chatManager;
_hub = signalRConnectionManager.GetHubContext<ChatHub>();
_userManager = userManager;
}
