private async Task Init(IServerInfoRepository infoRepository, Guid?serverId)
{
Servers = (await infoRepository.GetActiveServerInfoAsync()).OrderBy(x => x.Name).ToList();
if (string.IsNullOrEmpty(_playerName))
{
using (var userRepo = new PlayerRepository())
{
var player = await userRepo.GetPlayerAsync(_playerGuid);
_playerName = player?.Name;
}
}
//SelectedServers = new ObservableCollection<ServerInfoDto>();
if (serverId.HasValue)
{
SelectedServers.AddRange(Servers.Where(s => s.Id == serverId.Value));
}
Reasons = await GetReasons();
BanTimes = await GetBanTimes();
RaisePropertyChanged(nameof(Reasons));
RaisePropertyChanged(nameof(BanTimes));
}
public SmallSyncTask(IApplicationBuilder app)
{
_embyClient = app.ApplicationServices.GetService <IEmbyClient>();
_embyPluginRepository = app.ApplicationServices.GetService <IPluginRepository>();
_embyServerInfoRepository = app.ApplicationServices.GetService <IServerInfoRepository>();
_configurationRepository = app.ApplicationServices.GetService <IConfigurationRepository>();
_embyDriveRepository = app.ApplicationServices.GetService <IDriveRepository>();
}
public OptionsModel(IEventAggregator eventAggregator, ISettingsStoreSource settingsStoreSource, MessageHelper messageHelper, IServerInfoRepository infoRepository)
{
_eventAggregator = eventAggregator;
_settingsStoreSource = settingsStoreSource;
_messageHelper = messageHelper;
_infoRepository = infoRepository;
Init();
}
public BanPlayerWindow(Guid?serverId, IBanHelper banHelper, string playerGuid, bool isOnline, string playerName,
string playerNum, IServerInfoRepository infoRepository, ISettingsStoreSource settingsStoreSource) : base(settingsStoreSource)
{
InitializeComponent();
_model = new BanPlayerViewModel(serverId, playerGuid, isOnline, banHelper, playerName, playerNum, infoRepository);
tbGuid.IsEnabled = string.IsNullOrEmpty(playerGuid);
DataContext = _model;
}
public ServerMonitorModel(ServerInfoDto currentServer,
IEventAggregator eventAggregator, IServerInfoRepository infoRepository)
{
CurrentServer = currentServer;
_eventAggregator = eventAggregator;
_infoRepository = infoRepository;
_eventAggregator.GetEvent <ConnectServerEvent>().Subscribe(BeServerConnectHandler, ThreadOption.UIThread);
_eventAggregator.GetEvent <DisConnectServerEvent>().Subscribe(BeServerDisconnectHandler, ThreadOption.UIThread);
_eventAggregator.GetEvent <RunServerEvent>().Publish(CurrentServer);
}
public EmbyService(IEmbyClient embyClient,
IPluginRepository embyPluginRepository,
IConfigurationRepository configurationRepository,
IServerInfoRepository embyServerInfoRepository,
IDriveRepository embyDriveRepository)
{
_embyClient = embyClient;
_embyPluginRepository = embyPluginRepository;
_configurationRepository = configurationRepository;
_embyServerInfoRepository = embyServerInfoRepository;
_embyDriveRepository = embyDriveRepository;
}
public MainWindow(MainViewModel model, IUnityContainer container, IRegionManager regionManager,
IServerInfoRepository infoRepository)
{
InitializeComponent();
_model = model;
_container = container;
_regionManager = regionManager;
_infoRepository = infoRepository;
DataContext = _model;
}
public BanPlayerViewModel(Guid?serverId, string playerGuid, bool isOnline, IBanHelper playerHelper,
string playerName,
string playerNum, IServerInfoRepository infoRepository)
{
_playerGuid = playerGuid;
_isOnline = isOnline;
_playerHelper = playerHelper;
_playerName = playerName;
_playerNum = playerNum;
_minutes = 0;
Init(infoRepository, serverId);
}
public MainViewModel(IEventAggregator eventAggregator, IServerInfoRepository infoRepository)
{
_infoRepository = infoRepository;
ReloadAsync();
OptionsCommand = new DelegateCommand(() =>
{
eventAggregator.GetEvent <ShowOptionsEvent>().Publish(new ShowOptionsEvent());
});
eventAggregator.GetEvent <BEServersChangedEvent>().Subscribe(async(state) =>
{
await ReloadAsync();
});
}
public ChatHistoryViewModel(Guid serverId, IServerInfoRepository repository)
{
_repository = repository;
FilterCommand = new ActionCommand(async() =>
{
try
{
IsBusy = true;
await UpdateLogAsync();
RaisePropertyChanged(nameof(Log));
}
finally
{
IsBusy = false;
}
});
Init(serverId);
}
public MainViewModel(IEventAggregator eventAggregator, IServerInfoRepository infoRepository, ISettingsStoreSource settingsStoreSource)
{
_infoRepository = infoRepository;
ReloadAsync();
OptionsCommand = new DelegateCommand(() =>
{
eventAggregator.GetEvent <ShowOptionsEvent>().Publish(new ShowOptionsEvent());
});
eventAggregator.GetEvent <BEServersChangedEvent>().Subscribe(async(state) =>
{
await ReloadAsync();
});
var tm = settingsStoreSource.GetSettingsStore().TopMost;
foreach (Window wnd in Application.Current.Windows)
{
wnd.Topmost = tm;
}
}
public ServerInfoRepositoryCache(IServerInfoRepository infoRepository)
{
_infoRepository = infoRepository;
}
public ServerMonitorBansViewModel(ServerInfoDto serverInfo, IEventAggregator eventAggregator, IServerInfoRepository infoRepository,
IBanHelper banHelper, ISettingsStoreSource settingsStoreSource)
: base(
new ActionCommand(() => SendCommand(eventAggregator, serverInfo.Id, CommandType.Bans)),
new BanViewComparer())
{
_serverInfoId = serverInfo.Id;
_eventAggregator = eventAggregator;
_helper = banHelper;
AvailibleBans = new BanView[0];
SyncBans = new ActionCommand(() =>
{
var bans = SelectedAvailibleBans;
if (bans != null)
{
Task.Factory.StartNew(async() => { await _helper.BanGUIDOfflineAsync(_serverInfoId, bans.ToArray(), true); },
TaskCreationOptions.LongRunning);
}
});
CustomBan = new ActionCommand(() =>
{
var w = new BanPlayerWindow(_serverInfoId, _helper, null, false, null, null, infoRepository, settingsStoreSource);
w.ShowDialog();
});
RefreshAvailiableCommand = new ActionCommand(async() =>
{
AvailibleBans = await GetAvailibleBans();
RaisePropertyChanged(nameof(AvailibleBans));
RaisePropertyChanged(nameof(AvailibleBansCount));
});
_eventAggregator.GetEvent <BEMessageEvent <BEItemsMessage <Ban> > >()
.Subscribe(async e =>
{
if (_serverInfoId == e.ServerId)
{
await SetDataAsync(e.Items);
WaitingForEvent = false;
}
});
}
public ServerMonitorChatViewModel(ServerInfoDto serverInfo, IEventAggregator eventAggregator, ISettingsStoreSource settingsStoreSource, IServerInfoRepository infoRepository)
{
_serverId = serverInfo.Id;
_eventAggregator = eventAggregator;
_settingsStoreSource = settingsStoreSource;
AutoScroll = true;
EnableChat = true;
_chatHelper = new ChatHelper(_serverId);
_eventAggregator.GetEvent <BEMessageEvent <BEChatMessage> >()
.Subscribe(async e => await BeServerChatMessageHandlerAsync(e), ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEAdminLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEPlayerLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEBanLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEItemsMessage <Player> > >()
.Subscribe(_beServer_PlayerHandler, ThreadOption.UIThread);
var global = new Player(-1, null, 0, 0, null, "GLOBAL", Player.PlayerState.Ingame);
Players = new List <Player> {
global
};
SelectedPlayer = global;
ShowHistoryCommand = new ActionCommand(() =>
{
var model = new ChatHistoryViewModel(_serverId, infoRepository);
model.StartDate = DateTime.UtcNow.UtcToLocalFromSettings().AddHours(-5);
var wnd = new ChatHistory(model);
wnd.Show();
wnd.Activate();
});
SendCommandMessage = new DelegateCommand(() => SendCommand(), () => string.IsNullOrEmpty(CommandMessage) == false);
}
