public void OnChatToAllianceStreamMessageReceived(ChatToAllianceStreamMessage message)
{
if (!this.CanSendGlobalChatMessage())
{
return;
}
if (this.m_session.Alliance != null)
{
string chatMessage = message.RemoveMessage();
if (string.IsNullOrEmpty(chatMessage))
{
return;
}
if (chatMessage.Length > 128)
{
chatMessage = chatMessage.Substring(0, 128);
}
AllianceMemberEntry memberEntry = this.m_session.Alliance.Members[this.m_session.AccountId];
ChatStreamEntry chatStreamEntry = new ChatStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(chatStreamEntry, memberEntry);
chatStreamEntry.SetMessage(WordCensorUtil.FilterMessage(chatMessage));
StreamManager.Create(this.m_session.Alliance.Id, chatStreamEntry);
this.m_session.Alliance.AddStreamEntry(chatStreamEntry);
AllianceManager.Save(this.m_session.Alliance);
}
}
private void OnCancelChallengeMessageReceived(CancelChallengeMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
ChallengeStreamEntry prevChallengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (prevChallengeStreamEntry.IsStarted())
{
return;
}
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
}
}
public Channels()
{
InitializeComponent();
Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;
channels = new ObservableCollection<ChannelInfo>();
onlineImage = new BitmapImage(new Uri("pack://application:,,,/LivestreamBuddyNew;component/Resources/check.png"));
offlineImage = new BitmapImage(new Uri("pack://application:,,,/LivestreamBuddyNew;component/Resources/grayX.png"));
addStreamToFavoritesList("teamxim");
foreach (string channel in DataFileManager.GetFavoriteChannels())
{
addStreamToFavoritesList(channel, true);
}
streamManager = new StreamManager();
grdChannels.ItemsSource = channels;
firstReportDone = false;
worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.WorkerSupportsCancellation = true;
worker.DoWork += worker_DoWork;
worker.ProgressChanged += worker_ProgressChanged;
worker.RunWorkerAsync();
}
public InfoBackgroundWorker(string url)
{
Url = url;
var type = UrlHelper.ParseUrl(Url);
switch (type.Item1)
{
case SourceType.UrPlay:
case SourceType.UrSkola:
case SourceType.Svt1Live:
case SourceType.Svt24Live:
case SourceType.Svt2Live:
case SourceType.SvtBarnLive:
case SourceType.SvtKunskapLive:
Manager = new UrStreamManager(Url, new StreamDownloader());
break;
case SourceType.YouTube:
Manager = new YouTubeStreamManager(Url, new StreamDownloader());
break;
default:
Manager = new StreamManager(Url, new StreamDownloader());
break;
}
this.DoWork += DownloadInfo;
}
private static void RegisterCreationActivity(ActivityKind activityKind, Dictionary <string, object> data,
SPWeb contextWeb,
StreamManager streamManager, ThreadManager threadManager, ActivityManager activityManager)
{
var webId = (Guid)data["Id"];
var activityDateTime = (DateTime)data["ActivityTime"];
Thread thread = threadManager.SaveThread(new Thread
{
Title = (string)data["Title"],
Url = (string)data["URL"],
Kind = ObjectKind.Workspace,
FirstActivityDateTime = activityDateTime,
WebId = webId,
Users = new[] { new User {
Id = (int)data["UserId"], Role = UserRole.Author
} }
});
activityManager.RegisterActivity(new Activity
{
Kind = activityKind,
UserId = (int)data["UserId"],
Thread = thread,
Date = activityDateTime
});
Guid streamId = streamManager.GetGlobalStreamId(webId);
threadManager.AssociateStreams(thread, new[] { streamId });
threadManager.UpdateUsers(thread);
CoreFunctions.setConfigSetting(contextWeb, CREATED_CONFIG_KEY, true.ToString());
}
private void OnStartFriendlyChallengeSpectateMessageReceived(StartFriendlyChallengeSpectateMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicLong streamId = message.GetStreamId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE)
{
ChallengeStreamEntry challengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (challengeStreamEntry.IsStarted() && challengeStreamEntry.GetLiveReplayId() != null)
{
this.m_session.SendMessage(new GameSpectateLiveReplayMessage
{
LiveReplayId = challengeStreamEntry.GetLiveReplayId(),
IsEnemy = false
}, 9);
return;
}
}
}
}
LiveReplayFailedMessage liveReplayFailedMessage = new LiveReplayFailedMessage();
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(liveReplayFailedMessage, 1);
}
public IEnumerable <TRet> StreamRecords <TRet>(TParam parameters, int?countToRetrieve, Func <int> totalExist = null)
{
if (StreamCount != null)
{
SetTotalExist(StreamCount.Value);
}
SetStreamCount(parameters, countToRetrieve);
if (totalExist == null)
{
//If TotalExist was known, we set it upon entering StreamRecords.
//Otherwise, we set it upon entering SetStreamCount
totalExist = () => GetTotalExist(parameters);
}
var manager = new StreamManager <TObject, TParam>(
PrtgSessionState.Client.ObjectEngine, //Object Engine
parameters, //Parameters
totalExist, //Get Count (Total Exist)
true, //Serial
true, //Direct Call
cmdlet.GetStreamObjects //Get Objects
);
return((IEnumerable <TRet>)PrtgSessionState.Client.ObjectEngine.SerialStreamObjectsInternal(manager));
}
public async void DoneProducing_Data_WillCauseZeroRead_And_End()
{
const int expectedReadCount = 100;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount = 0;
var streamManager = new StreamManager(e => { });
var id = Guid.NewGuid();
var assembler = streamManager.GetPayloadAssembler(id);
assembler.ContentLength = 0;
var random = new Random();
random.NextBytes(producerBuffer);
var stream = new PayloadStream(assembler);
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
stream.DoneProducing();
readCount = stream.Read(consumerBuffer, 0, expectedReadCount);
Assert.Equal(100, readCount);
readCount = stream.Read(consumerBuffer, readCount, expectedReadCount);
Assert.Equal(0, readCount);
}
private void saveImageDlgClicked()
{
// NOTE: SaveFileDialog are only supported on WinRT
var data = ReignLogo.texture.EncodeToPNG();
StreamManager.SaveFileDialog(data, FolderLocations.Pictures, new string[] { ".png" }, imageSavedCallback);
}
private void saveToPicturesClicked()
{
disableButtons();
var data = ReignLogo.texture.EncodeToPNG();
StreamManager.SaveFile("TEST.png", data, FolderLocations.Pictures, imageSavedCallback);
}
public void Setup()
{
_downloader = A.Fake <IStreamDownloader>();
A.CallTo(() => _downloader.Download(_dataUrl)).Returns(_dataAbsolutePath);
A.CallTo(() => _downloader.Download(_streamMasterDataUrl)).Returns(_masterDataAbsolutePath);
_underTest = new StreamManager(_htmlUri, _downloader);
}
private static void OnAllianceRequestAllianceUnitsMessageReceived(AllianceRequestAllianceUnitsMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.DONATE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
DonateStreamEntry donateStreamEntry = new DonateStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(donateStreamEntry, memberEntry);
string donateMessage = message.Message;
if (donateMessage.Length > 128)
{
donateMessage = donateMessage.Substring(0, 128);
}
donateStreamEntry.SetMessage(donateMessage);
donateStreamEntry.SetCasteLevel(message.CastleUpgradeLevel, message.CastleUsedCapacity, message.CastleSpellUsedCapacity, message.CastleTotalCapacity, message.CastleSpellTotalCapacity);
StreamManager.Create(alliance.Id, donateStreamEntry);
alliance.AddStreamEntry(donateStreamEntry);
AllianceManager.Save(alliance);
}
}
private static MemoryStream GetThumbnailFromProcess(Process p,
ref int width,
ref int height)
{
var lastPosition = 0L;
using (var thumb = StreamManager.GetStream())
{
using (var pump = new StreamPump(
p.StandardOutput.BaseStream, thumb, 4096))
{
pump.Pump(null);
while (!p.WaitForExit(20000))
{
if (lastPosition != thumb.Position)
{
lastPosition = thumb.Position;
continue;
}
p.Kill();
throw new ArgumentException("ffmpeg timed out");
}
if (p.ExitCode != 0)
{
throw new ArgumentException("ffmpeg does not understand the stream");
}
if (!pump.Wait(2000))
{
throw new ArgumentException("stream reading timed out");
}
if (thumb.Length == 0)
{
throw new ArgumentException("ffmpeg did not produce a result");
}
using (var img = Image.FromStream(thumb))
{
using (var scaled = ThumbnailMaker.ResizeImage(img, width, height,
ThumbnailMakerBorder.Bordered))
{
width = scaled.Width;
height = scaled.Height;
var rv = new MemoryStream();
try
{
scaled.Save(rv, ImageFormat.Jpeg);
return(rv);
}
catch (Exception)
{
rv.Dispose();
throw;
}
}
}
}
}
}
public void ShouldDownLoadStreamInfo()
{
var manager = new StreamManager(_htmlUri, new StreamDownloader());
manager.DownloadAndParseData();
Assert.AreEqual(7, manager.Streams.Count);
}
private void _infoWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
_infoResult = _infoWorker.Manager;
_infoWorker.RunWorkerCompleted -= _infoWorker_RunWorkerCompleted;
_infoWorker = null;
int i = 0;
foreach (var streamInfo in _infoResult.Streams)
{
var radio = new MaterialRadioButton();
radio.Text = streamInfo.ToString();
radio.Size = new Size(250, 18);
radio.Location = new Point(20, 122 + i * 20);
radio.CheckedChanged += Radio_CheckedChanged;
tabPage1.Controls.Add(radio);
i++;
_streamButtons.Add(radio, streamInfo);
}
if (_streamButtons.Count > 0)
{
txtFilename.Text = _infoResult.GetValidFileName(_infoResult.Streams.Last());
pictureBox.Image = _infoResult.PosterImage;
_streamButtons.Last().Key.Checked = true;
btnStartDownload.Visible = true;
}
else
{
lblStatus.Text = "Status: Could not find stream";
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
StreamManager.UnRegister(_id);
if (_form != IntPtr.Zero)
{
NativeMethods.FORM_DoDocumentAAction(_form, NativeMethods.FPDFDOC_AACTION.WC);
NativeMethods.FPDFDOC_ExitFormFillEnvironment(_form);
_form = IntPtr.Zero;
}
if (_document != IntPtr.Zero)
{
NativeMethods.FPDF_CloseDocument(_document);
_document = IntPtr.Zero;
}
if (_formCallbacksHandle.IsAllocated)
{
_formCallbacksHandle.Free();
}
if (_stream != null)
{
_stream.Dispose();
_stream = null;
}
_disposed = true;
}
}
public static void InitWorkspace(List <string> typeDirectories, string workspaceDirectory, string cacheDirectory)
{
if (typeDirectories == null)
{
throw new ArgumentNullException("typeDirectories");
}
if (typeDirectories.Count == 0)
{
throw new ArgumentException("List of type directories cannot be empty", "typeDirectories");
}
if (cacheDirectory == null)
{
throw new ArgumentNullException("cacheDirectory");
}
if (cacheDirectory.Length == 0)
{
throw new ArgumentException("m_workspace cache directory must be a valid directory", "cacheDirectory");
}
if (s_workspaceInstance != null)
{
s_workspaceInstance.Dispose();
}
StreamManager manager = StreamManager.CreateNewManager();
s_workspaceInstance = InitWorkspaceInternal(typeDirectories, workspaceDirectory, cacheDirectory, manager);
}
public LoginController(UserDBRepository repo, StreamManager manager)
{
_userRepo = repo;
streamManager = manager;
CONSUMER_KEY = manager.ConsumerKey;
CONSUMER_SECRET = manager.ConsumerSecret;
}
private static void OnSendAvatarStreamsToClientMessageReceived(SendAvatarStreamsToClientMessage message)
{
AvatarStreamMessage avatarStreamMessage = new AvatarStreamMessage();
LogicArrayList <LogicLong> ids = message.StreamIds;
LogicArrayList <AvatarStreamEntry> avatarStreamList = new LogicArrayList <AvatarStreamEntry>(ids.Size());
for (int i = 0; i < ids.Size(); i++)
{
AvatarStreamEntry avatarStreamEntry = StreamManager.GetAvatarStream(ids[i]);
if (avatarStreamEntry != null)
{
avatarStreamList.Add(avatarStreamEntry);
}
}
avatarStreamMessage.SetStreamEntries(avatarStreamList);
avatarStreamMessage.Encode();
ServerMessageManager.SendMessage(StreamMessageManager.CreateForwardLogicMessage(avatarStreamMessage, message.SessionId), ServerManager.GetProxySocket(message.SessionId));
for (int i = 0; i < avatarStreamList.Size(); i++)
{
AvatarStreamEntry avatarStreamEntry = avatarStreamList[i];
if (avatarStreamEntry.IsNew())
{
avatarStreamEntry.SetNew(false);
StreamManager.Save(avatarStreamEntry);
}
}
}
private static void OnLoadAvatarStreamOfTypeRequestMessageReceived(LoadAvatarStreamOfTypeRequestMessage message)
{
LoadAvatarStreamOfTypeResponseMessage loadAvatarStreamOfTypeResponseMessage = new LoadAvatarStreamOfTypeResponseMessage();
LogicArrayList <AvatarStreamEntry> streamEntryList = new LogicArrayList <AvatarStreamEntry>(message.StreamIds.Size());
for (int i = 0; i < message.StreamIds.Size(); i++)
{
AvatarStreamEntry entry = StreamManager.GetAvatarStream(message.StreamIds[i]);
if (entry != null && entry.GetAvatarStreamEntryType() == message.Type)
{
if (message.SenderAvatarId != null && !entry.GetSenderAvatarId().Equals(message.SenderAvatarId))
{
continue;
}
streamEntryList.Add(entry);
}
}
loadAvatarStreamOfTypeResponseMessage.Success = true;
loadAvatarStreamOfTypeResponseMessage.StreamList = streamEntryList;
ServerRequestManager.SendResponse(loadAvatarStreamOfTypeResponseMessage, message);
}
private static void OnAllianceChallengeReportMessageReceived(AllianceChallengeReportMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance))
{
ChallengeStreamEntry streamEntry = (ChallengeStreamEntry)StreamManager.GetAllianceStream(message.StreamId);
if (streamEntry != null)
{
ChallengeReplayStreamEntry challengeReplayStreamEntry = new ChallengeReplayStreamEntry();
challengeReplayStreamEntry.SetSenderAvatarId(challengeReplayStreamEntry.GetSenderAvatarId());
challengeReplayStreamEntry.SetSenderHomeId(challengeReplayStreamEntry.GetSenderHomeId());
challengeReplayStreamEntry.SetSenderName(challengeReplayStreamEntry.GetSenderName());
challengeReplayStreamEntry.SetSenderLevel(challengeReplayStreamEntry.GetSenderLevel());
challengeReplayStreamEntry.SetSenderLeagueType(challengeReplayStreamEntry.GetSenderLeagueType());
challengeReplayStreamEntry.SetSenderRole(challengeReplayStreamEntry.GetSenderRole());
challengeReplayStreamEntry.SetBattleLogJSON(message.BattleLog);
challengeReplayStreamEntry.SetReplayMajorVersion(LogicVersion.MAJOR_VERSION);
challengeReplayStreamEntry.SetReplayBuildVersion(LogicVersion.BUILD_VERSION);
challengeReplayStreamEntry.SetReplayContentVersion(ResourceManager.GetContentVersion());
challengeReplayStreamEntry.SetReplayId(message.ReplayId);
StreamManager.Create(alliance.Id, challengeReplayStreamEntry);
alliance.RemoveStreamEntry(streamEntry.GetId());
alliance.AddStreamEntry(challengeReplayStreamEntry);
}
else
{
Logging.Warning("StreamMessageManager.onAllianceChallengeReportMessageReceived: pStreamEntry has been deleted. Replay ignored.");
}
}
}
/// <summary>
/// Dispose OutboundSessionDriver references and the actual dispose of the OutboundSessionDriver in a safe fashion.
/// This is used in reset partner stream operation, when the OutBoundSessionDriver is disposed and recreated.
/// </summary>
/// <param name="targetPartition">OutBoundSessionDriver for this Partition</param>
/// <param name="streamManager">Reset corresponding OutBoundSessionDriver ref. in stream manager</param>
/// <returns></returns>
internal static async Task ClearDriverAsync(PartitionKey targetPartition, StreamManager streamManager)
{
FabricEvents.Events.ClearOutboundSessionDriver("Start@" + streamManager.TraceType, targetPartition.ToString());
// this key must already have been resolved and normalized when the driver was created
var normalizedPartitionKey = streamManager.SessionConnectionManager.GetNormalizedPartitionKey(targetPartition);
Diagnostics.Assert(null != normalizedPartitionKey, "normalizedPartitionKey is not expected to be null in ClearDriverAsync().");
// SyncPoint(lock)
using (
var syncPoint = new SyncPoint <PartitionKey>(
streamManager,
normalizedPartitionKey,
streamManager.RuntimeResources.OutboundSessionDriverSyncpoints))
{
// this is entering an await compatible critical section -- syncPoint.Dispose will leave it
await syncPoint.EnterAsync(Timeout.InfiniteTimeSpan);
// remove appropriate ref.
OutboundSessionDriver driver = null;
var removeSuccess = streamManager.RuntimeResources.OutboundSessionDrivers.TryRemove(normalizedPartitionKey, out driver);
// dispose the driver session
if (removeSuccess)
{
driver.Dispose();
}
}
FabricEvents.Events.ClearOutboundSessionDriver("Finish@" + streamManager.TraceType, targetPartition.ToString());
}
public void RegisterTest()
{
Task server = runServer();
server.Start();
UserCommandManager userCommandManager = new UserCommandManager("127.0.0.1", 5555);
Assert.IsFalse(userCommandManager.Register("Ala", "s", "Normal", "A", "A"));
Assert.IsFalse(userCommandManager.Login("Ala", "zaq1@WSX"));
Assert.IsTrue(userCommandManager.Register("Ala", "zaq1@WSX", "Normal", "A", "A"));
Assert.IsTrue(userCommandManager.Login("Ala", "zaq1@WSX"));
userCommandManager.Exit();
server.Wait();
Task textserver = runServer();
textserver.Start();
TcpClient tcpClient = new TcpClient("127.0.0.1", 5555);
StreamManager sm = new StreamManager(tcpClient.GetStream());
sm.Data = "new;Ala;s;Normal;A;A";
Assert.AreNotEqual(sm.Data, "created");
sm.Data = "login;Ala;s";
Assert.AreNotEqual(sm.Data, "loged");
sm.Data = "new;Ala;zaq1@WSX;Normal;A;A";
Assert.AreEqual(sm.Data, "created");
sm.Data = "login;Ala;zaq1@WSX";
Assert.AreEqual(sm.Data, "loged");
sm.Data = "exit";
textserver.Wait();
}
/// <inheritdoc />
protected override Stream OpenFileImpl(UPath path, FileMode mode, FileAccess access,
FileShare share)
{
if (IsWithinSpecialDirectory(path))
{
throw new UnauthorizedAccessException($"The access to `{path}` is denied");
}
// Create directory if not existing
var directory = path.GetDirectory();
if (!DirectoryExists(directory))
{
CreateDirectory(directory);
}
// Open file
Stream file;
if (mode == FileMode.Create || mode == FileMode.CreateNew)
{
file = File.Open(ConvertPathToInternal(path), mode);
}
else
{
file = File.Open(ConvertPathToInternal(path), mode, access, share);
}
StreamManager.Register(file);
GetOrCreateDispatcher().RaiseOpened(path);
return(file);
}
public void Open()
{
if (m_inputStream == null)
{
m_inputStream = StreamManager.OpenReadStream(FilePath, PointDataOffset);
}
}
/// <inheritdoc />
public virtual void Dispose()
{
ArchiveChildren?.Clear();
DialogOptions?.Clear();
PluginManager?.CloseAll();
StreamManager?.ReleaseAll();
// Dispose content of state
switch (PluginState)
{
case IArchiveState archiveState:
archiveState.Files?.ForEach(x => x.Dispose());
break;
case IImageState imageState:
imageState.Images?.ForEach(x => x.Dispose());
break;
}
FilePlugin = null;
PluginState = null;
FilePath = UPath.Empty;
FileSystem = null;
StreamManager = null;
PluginManager = null;
DialogOptions = null;
ParentStateInfo = null;
IsDisposed = true;
}
internal SyncPoint(StreamManager streamManager, TKey key, ConcurrentDictionary <TKey, SyncPoint <TKey> > syncPointCollection)
{
this.syncEvent = new TaskCompletionSource <bool>();
this.key = key;
this.syncPointCollection = syncPointCollection;
this.exitedAfterAcquiring = false;
this.traceType = streamManager.TraceType;
this.streamManager = streamManager;
this.era = streamManager.Era;
this.id = Interlocked.Increment(ref idgen);
// we reset StreamManager level syncPointCollections to null when transitioning Primary -> NotPrimary and there may be a race
if (syncPointCollection == null || this.era == Guid.Empty)
{
/*
* if (syncPointCollection == null)
* {
* Tracing.WriteNoise("SyncPoint.Ctor", "{0} syncPointCollection is null", this.traceType);
* }
*
* Tracing.WriteNoise("SyncPoint.Ctor", "{0} Era = {1}", this.traceType, this.era);
*/
// we seem to have made a transition to not primary
throw new FabricNotPrimaryException();
}
}
public CliCommander(string[] args)
{
LoadConfiguration();
var command = GetCommand(args);
_streamManager = new StreamManager();
switch (command.Type)
{
case CommandType.Start:
{
var startCommand = (StartCommand)command;
var server = _streamManager.Add(startCommand.Settings);
server.Start();
break;
}
case CommandType.Stop:
{
_streamManager.Stop(int.Parse(args[1]));
break;
}
}
}
private void SetUpShims()
{
shimsContext = ShimsContext.Create();
guid = Guid.NewGuid();
spWeb = new ShimSPWeb()
{
IDGet = () => guid,
SiteGet = () => new ShimSPSite()
{
IDGet = () => guid,
WebApplicationGet = () => new ShimSPWebApplication(),
RootWebGet = () => new ShimSPWeb()
},
PropertiesGet = () =>
{
var propertyBag = new ShimSPPropertyBag();
var sd = new ShimStringDictionary(propertyBag);
sd.ItemGetString = (key) =>
{
return("EPMLive_MyWork_Grid_GlobalViews");
};
return(propertyBag);
}
}.Instance;
ShimSqlConnection.AllInstances.Open = _ => { };
ShimSqlConnection.AllInstances.Close = _ => { };
ShimSPSecurity.RunWithElevatedPrivilegesSPSecurityCodeToRunElevated = _ => { };
ShimSPPersistedObject.AllInstances.IdGet = _ => guid;
ShimCoreFunctions.getReportingConnectionStringGuidGuid = (_, _1) => ConnectionString;
ShimCoreFunctions.getConfigSettingSPWebString = (_, _1) => string.Empty;
threadManager = new ThreadManager(new DBConnectionManager(spWeb, false));
activityManager = new ActivityManager(new DBConnectionManager(spWeb, false));
streamManager = new StreamManager(new DBConnectionManager(spWeb, false));
}
public void ShouldDetectCorrectDataUrl()
{
var manager = new StreamManager(_htmlUri, new StreamDownloader());
manager.DownloadAndParseData();
Assert.AreEqual(_dataUrl, manager.DataUrl);
}
internal MobileStreamingProcessor(IMobileConfiguration configuration,
IFlagCacheManager cacheManager,
User user,
StreamManager.EventSourceCreator eventSourceCreator)
{
this._configuration = configuration;
this._cacheManager = cacheManager;
this._user = user;
StreamProperties streamProperties;
if (_configuration.UseReport)
{
streamProperties = MakeStreamPropertiesForREPORT();
}
else
{
streamProperties = MakeStreamPropertiesForGET();
}
_streamManager = new StreamManager(this,
streamProperties,
_configuration,
MobileClientEnvironment.Instance,
eventSourceCreator);
}
public StreamManagerViewModel(Account account)
{
_selectedIndex = -1;
_accountModel = account;
_streamManagerModel = account.Stream;
_streams = ViewModelHelper.CreateReadOnlyDispatcherCollection(
_streamManagerModel.Streams, item => new StreamViewModel(item), App.Current.Dispatcher);
CompositeDisposable.Add(_thisPropChangedEventListener = new PropertyChangedEventListener(this));
_thisPropChangedEventListener.Add(() => IsActive, IsActive_PropertyChanged);
}
public StreamViewModel(Stream circle, Account account, StreamManager manager)
{
_circleModel = circle;
_name = circle.Name;
_circleManagerModel = manager;
_accountModel = account;
_isConnected = true;
_activities = new ObservableCollection<ViewModelBase>();
ReconnectCommand = new RelayCommand(ReconnectCommand_Executed);
ResumeCommand = new RelayCommand(ReconnectCommand_Executed);
_resumeButton = new ResumeButtonViewModel(ResumeCommand);
_circleModel.ChangedStatus += _circleModel_ChangedStatus;
_circleModel.ChangedChangedActivityCount += _circleModel_ChangedChangedActivityCount;
PropertyChanged += StreamViewModel_PropertyChanged;
}
