public async Task Remoting_SubscribeDo_AsyncToSyncMethodCalls()
{
var testObserverName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var uri = new Uri("reactor://test/subscription");
var xs = ctx.GetObservable <int, int>(ReactorConstants.Identifiers.Observable.Range.Uri)(3);
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
var doObserver = ctx.GetObserver <int>(new Uri(Constants.Observer.Nop));
await xs
.Where(x => x > 0)
.Do(x => doObserver.OnNextAsync(x, CancellationToken.None))
.SubscribeAsync(observer, uri, null, CancellationToken.None);
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(1),
ObserverMessage.OnNext(2),
ObserverMessage.OnCompleted <int>()
}
);
}
void IObserver.RefrashObserver(ObserverMessage id, object[] message)
{
switch (id)
{
case ObserverMessage.SetPlayer:
{
GameObject playerObject = new GameObject("myPlayerController");
myPlayerController = playerObject.AddComponent <PlayerController>();
myPlayerController.transform.SetParent(actorGroup);
myPlayerController.SetPlayer(GameManager.Instance.MyPlayer);
myPlayerController.CreateMyCharacter();
playerControllers.Add(myPlayerController);
}
break;
case ObserverMessage.ChangeCostume:
{
}
break;
case ObserverMessage.ChangeEquip:
{
myPlayerController.ChangeEquip(message[0] as Equip, isWear: (bool)message[1]);
if (UIController.IsOpenVIew(UIPrefabs.EquipView))
{
BasePresenter equipPresenter = UIController.GetPresenter(UIPrefabs.EquipView);
equipPresenter.RefreshUI();
}
if (UIController.IsOpenVIew(UIPrefabs.InventoryView))
{
BasePresenter inventoryPresenter = UIController.GetPresenter(UIPrefabs.InventoryView);
inventoryPresenter.RefreshUI();
}
}
break;
//case ObserverMessage.UnWearEquip:
// {
// myPlayerController.ChangeEquip(message[0] as Equip, isWear: false);
// if (UIController.IsOpenVIew(UIPrefabs.EquipView))
// {
// BasePresenter equipPresenter = UIController.GetPresenter(UIPrefabs.EquipView);
// equipPresenter.RefashUI();
// }
// if (UIController.IsOpenVIew(UIPrefabs.InventoryView))
// {
// BasePresenter inventoryPresenter = UIController.GetPresenter(UIPrefabs.InventoryView);
// inventoryPresenter.RefashUI();
// }
// }
// break;
case ObserverMessage.UseItem:
{
}
break;
}
}
public async Task Remoting_DistinctUntilChanged_KnownType()
{
var controlObserverName = new Uri("reactor://control/observer");
var testObserverName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var controlUri = new Uri("reactor://control/subscription");
var testUri = new Uri("reactor://test/subscription");
var io = ctx.GetObservable <ClientPersonObservableParameters, ClientPerson>(ReactorConstants.Identifiers.Observable.Person.Uri);
var iv = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri);
await io(new ClientPersonObservableParameters {
Age = 50
}).Take(5).Select(p => p.Age).SubscribeAsync(iv(controlObserverName), controlUri, null, CancellationToken.None);
await io(new ClientPersonObservableParameters {
Age = 50
}).Take(5).DistinctUntilChanged().Select(p => p.Age).SubscribeAsync(iv(testObserverName), testUri, null, CancellationToken.None);
},
new ObserverState <int>(controlObserverName)
{
ObserverMessage.OnNext(50),
ObserverMessage.OnNext(50),
ObserverMessage.OnNext(50),
ObserverMessage.OnNext(50),
ObserverMessage.OnNext(50),
ObserverMessage.OnCompleted <int>()
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(50),
ObserverMessage.OnCompleted <int>()
}
);
}
public async Task Remoting_SubscribeWithEnums_ClientTypeToClientType()
{
var observerName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var uri = new Uri("reactor://test/observable");
var subUri = new Uri("reactor://test/subscription");
await ctx.DefineObservableAsync <ClientPerson>(
uri,
ctx.Empty <ClientPerson>().StartWith(new ClientPerson {
LastName = "Smith", Age = 30, Occupation = ClientOccupation.ChiefExecutiveOfficer
}),
null,
CancellationToken.None);
var observable = ctx.GetObservable <AltClientPerson>(uri);
var observerFactory = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri);
var observer = observerFactory(observerName);
await observable
.Where(p => p.Occupation == AltClientOccupation.ChiefExecutiveOfficer)
.Select(p => p.YearsSinceBirth)
.SubscribeAsync(observer, new Uri("reactor://test/subscription"), null, CancellationToken.None);
},
new ObserverState <int>(observerName)
{
ObserverMessage.OnNext(30),
ObserverMessage.OnCompleted <int>()
}
);
}
public async Task Remoting_SubscribeWithEnums_ClientTypeToKnownType()
{
var observerName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var uri = new Uri("reactor://test/observable");
var subUri = new Uri("reactor://test/subscription");
var personObservable = ctx.GetObservable <ClientPersonObservableParameters, ClientPerson>(ReactorConstants.Identifiers.Observable.Person.Uri);
var observerFactory = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri);
var observer = observerFactory(observerName);
await personObservable(new ClientPersonObservableParameters {
Age = 20, Occupation = ClientOccupation.Unemployed
})
.Take(1)
.Where(p => p.Occupation == ClientOccupation.Unemployed).Select(p => p.Age)
.SubscribeAsync(observer, new Uri("reactor://test/subscription"), null, CancellationToken.None);
},
new ObserverState <int>(observerName)
{
ObserverMessage.OnNext(20),
ObserverMessage.OnCompleted <int>()
}
);
}
public async Task Remoting_DefineObservableAndSubscribe_ClientTypeToClientTypeWithStructuralArray()
{
var observerName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var uri = new Uri("reactor://test/observable");
var suburi = new Uri("reactor://test/subscription");
await ctx.UndefineObservableAsync(uri, CancellationToken.None);
await ctx.DefineObservableAsync <ClientFamily>(
uri,
ctx.Empty <ClientFamily>().StartWith(new ClientFamily {
Members = { new ClientPerson {
LastName = "Smith", Age = 30
} }
}),
null,
CancellationToken.None);
var observable = ctx.GetObservable <ClientFamily>(uri);
var observerFactory = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri);
var observer = observerFactory(observerName);
await observable.Select(p => p.Members[0].Age).SubscribeAsync(observer, suburi, null, CancellationToken.None);
},
new ObserverState <int>(observerName)
{
ObserverMessage.OnNext(30),
ObserverMessage.OnCompleted <int>()
}
);
}
public async Task Remoting_Subscribe_HigherArityObservable_ObserverState()
{
var uri = new Uri("rx://test/observable");
var subUri = new Uri("rx://test/sub");
var testObserverName = new Uri("rx://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var range = ctx.GetObservable <int, int>(ReactorConstants.Identifiers.Observable.Range.Uri);
await ctx.DefineObservableAsync <int, int, int, int>(
uri,
(x, y, z) => range(x + y - z),
null,
CancellationToken.None
);
var o = ctx.GetObservable <int, int, int, int>(uri);
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
await o(1, 2, 1).SubscribeAsync(observer, subUri, null, CancellationToken.None);
await ctx.UndefineObservableAsync(uri, CancellationToken.None);
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(0),
ObserverMessage.OnNext(1),
ObserverMessage.OnCompleted <int>()
}
);
}
public void RemoveObserver(ObserverMessage id, IObserver removeObserver)
{
if (observers.ContainsKey(id))
{
observers[id].Remove(removeObserver);
}
}
public static void Observate(ObserverMessage observer)
{
GlobalBus.observers.Add(new GlobalBusObserver
{
observerMessage = observer,
Filter = null,
reg = null
});
}
void IObserver.RefrashObserver(ObserverMessage id, object[] message)
{
switch (id)
{
case ObserverMessage.RestartApp:
{
break;
}
}
}
public void Observe(IUnitOfWork uow, IMessageBusiness messageBusiness, ObserverMessage msg, User user)
{
messageBusiness.Insert(new Message
{
Content = msg.BotContent.Replace("NAME", user.FullName),
State = StateType.Begin,
Type = MessagingType.Email,
ExtraData = msg.Subject,
ReplyMessageId = msg.MessageId,
Receiver = "*****@*****.**"// "*****@*****.**",
});
}
public void Observe(IUnitOfWork uow, IMessageBusiness messageBusiness, ObserverMessage msg, User user)
{
messageBusiness.Insert(new Message
{
Content = msg.BotContent.Replace("NAME", user.FullName),
Receiver = GlobalVariable.AdminInstanceId,
State = StateType.Begin,
Type = MessagingType.RoboTele,
ExtraData = msg.Key,
ReplyMessageId = msg.MessageId
});
}
public void AddObserver(ObserverMessage id, IObserver addObserver)
{
if (observers.ContainsKey(id))
{
observers[id].Add(addObserver);
}
else
{
List <IObserver> addObservers = new List <IObserver>();
addObservers.Add(addObserver);
observers.Add(id, addObservers);
}
}
public void Notify(ConcreteKey concrete, ObserverMessage msg)
{
var user = new User();
var officeUser = new User();
if (msg.UserId.IsNotNullGuid())
{
user = _uow.Set <User>().Find(msg.UserId);
}
if (msg.OfficeUserId.IsNotNullGuid())
{
officeUser = _uow.Set <User>().Find(msg.OfficeUserId);
}
var observers = JsonConvert.DeserializeObject <IEnumerable <Concrete> >(File.ReadAllText(GlobalVariable.ObserverConfig));
var officeUsername = false;
foreach (var item in observers)
{
if (item.Key == concrete.ToString())
{
if (item.Key == "Order_Status_Changed" ||
item.Key == "Offline_Payment")
{
officeUsername = true;
}
foreach (var obs in item.Observers)
{
Assembly assembly = Assembly.GetExecutingAssembly();
_observers.Add(assembly.CreateInstance(obs) as IObserver);
}
msg.Subject = item.Key;
foreach (IObserver o in _observers)
{
if (officeUsername)
{
o.Observe(_uow, _messageBusiness, msg, officeUser.UserId.IsNotNullGuid() ? officeUser : user);
}
else
{
o.Observe(_uow, _messageBusiness, msg, user);
}
}
break;
}
}
_uow.SaveChanges();
}
public static void NotifyObserver2(ObserverMessage id, params object[] message)
{
if (Instance.observers.ContainsKey(id))
{
for (int i = 0; i < Instance.observers[id].Count; ++i)
{
if (Instance.observers[id][i] == null)
{
continue;
}
Instance.observers[id][i].RefrashObserver(id, message);
}
}
}
public void Observe(IUnitOfWork uow, IMessageBusiness messageBusiness, ObserverMessage msg, User user)
{
if (user.MobileNumber == 0)
{
return;
}
messageBusiness.Insert(new Message
{
Content = msg.SmsContent.Replace("NAME", user.FullName),
Receiver = user.MobileNumber.ToString(),
State = StateType.Begin,
Type = MessagingType.Sms,
});
}
public async Task Remoting_ContextSwitchOperator_StateChanged_NoneProcessed()
{
var streamId = new Uri("reactor://test/stream");
var subscriptionId = new Uri("reactor://test/subscription");
var testObserverName = new Uri("reactor://test/observer");
using var client = CreateTestClient();
var ctx = client.Context;
var scheduler = (ITestScheduler)client.Platform.QueryEvaluators.First().Scheduler;
var sf = ctx.GetStreamFactory <int, int>(PlatformConstants.Identifiers.Observable.FireHose.Uri);
var stream = await sf.CreateAsync(streamId, null, CancellationToken.None);
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
scheduler.ScheduleAbsolute(100, () => stream.SubscribeAsync(observer, subscriptionId, null, CancellationToken.None));
// Cause the ItemProcessor to execute once...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(1, CancellationToken.None));
// Cause item to be queued but not processed...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(2, CancellationToken.None));
// Full checkpoint and trigger OnStateSaved()...
scheduler.ScheduleAbsolute(110, () => client.Platform.QueryEvaluators.First().Checkpoint());
// Cause additional item to be queued but not processed...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(3, CancellationToken.None));
// Differential checkpoint and reload from state...
scheduler.ScheduleAbsolute(110, () =>
{
var qe = client.Platform.QueryEvaluators.First();
qe.Checkpoint();
qe.Unload();
qe.Recover();
});
scheduler.Start();
var observerState = new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(1),
ObserverMessage.OnNext(2),
ObserverMessage.OnNext(3),
ObserverMessage.OnNext(2),
ObserverMessage.OnNext(3),
};
AssertObserverState(client.Platform, observerState);
}
public void Remoting_VirtualTimeTest_Sample()
{
using var client = CreateTestClient();
var xs = client.CreateHotObservable(
ObserverMessage.OnNext(100, 1),
ObserverMessage.OnNext(150, 2),
ObserverMessage.OnNext(200, 3),
ObserverMessage.OnNext(250, 4));
var res = client.Start(() => xs.Select(x => x * x), 50, 125, 225);
res.Messages.AssertEqual(
ObserverMessage.OnNext(150, 4),
ObserverMessage.OnNext(200, 9));
xs.Subscriptions.AssertEqual(
ReactiveTest.Subscribe(125, 225));
}
void IObserver.RefrashObserver(ObserverMessage id, object[] message)
{
switch (id)
{
case ObserverMessage.FindProfile:
{
string pid = GameManager.Instance.MyPlayer.pid;
WebRequestProfile requestProfile = new WebRequestProfile(pid, (response) =>
{
if (NetworkManager.Web.IsError(response.result, response.msg, true))
{
}
else
{
NetworkManager.Web.RecvProfile(response);
}
});
NetworkManager.Web.SendProfile(requestProfile);
break;
}
}
}
public async Task Remoting_Subscribe_VirtualTime_ObserverState()
{
var uri = new Uri("reactor://test/subscription");
var testObserverName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
(ctx, scheduler) =>
{
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
scheduler.ScheduleAbsolute(200, () => ctx.Empty <int>().StartWith(0, 1, 2, 3, 4).SubscribeAsync(observer, uri, null, CancellationToken.None));
var sub = ctx.GetSubscription(uri);
scheduler.ScheduleAbsolute(500, () => sub.DisposeAsync(CancellationToken.None));
scheduler.ScheduleAbsolute(501, async() =>
{
try
{
await sub.DisposeAsync(CancellationToken.None);
}
catch (AggregateException ex)
{
Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentException));
}
});
return(Task.FromResult(true));
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(201, 0),
ObserverMessage.OnNext(202, 1),
ObserverMessage.OnNext(203, 2),
ObserverMessage.OnNext(204, 3),
ObserverMessage.OnNext(205, 4),
ObserverMessage.OnCompleted <int>(206)
}
);
}
public async Task Remoting_SubscribeGetDispose_ObserverState()
{
var uri = new Uri("reactor://test/subscription");
var testObserverName = new Uri("reactor://test/observer");
await AssertVirtual <ReactiveClientContext, int>(
async (ctx, _) =>
{
var xs = ctx.GetObservable <int, int>(ReactorConstants.Identifiers.Observable.Range.Uri)(5);
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
await xs.SubscribeAsync(observer, uri, null, CancellationToken.None);
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(0),
ObserverMessage.OnNext(1),
ObserverMessage.OnNext(2),
ObserverMessage.OnNext(3),
ObserverMessage.OnNext(4),
ObserverMessage.OnCompleted <int>()
}
);
}
public async Task Remoting_Range_VirtualTime_ObserverState_Schedule()
{
var observer = default(Func <Uri, IAsyncReactiveQbserver <int> >);
var observable = default(IAsyncReactiveQbservable <int>);
var testObserverName = new Uri("reactor://test/observer");
var subscriptionUri = new Uri("reactor://test/subscription");
await AssertVirtual <ReactiveClientContext, int>(
new VirtualTimeAgenda <ReactiveClientContext>
{
{ 100L, ctx => { observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri); } },
{ 150L, ctx => { observable = ctx.Empty <int>().StartWith(0, 1, 2, 3, 4); } },
{ 200L, ctx => observable.SubscribeAsync(observer(testObserverName), subscriptionUri, null, CancellationToken.None) }
},
new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(201, 0),
ObserverMessage.OnNext(202, 1),
ObserverMessage.OnNext(203, 2),
ObserverMessage.OnNext(204, 3),
ObserverMessage.OnNext(205, 4),
ObserverMessage.OnCompleted <int>(206)
});
}
