private async Task <int?> PushCoreAsync()
{
var pushRequest = Dto.pushRequest(State);
if (pushRequest.IsSome())
{
var pushResponse = await _cosmos.PushAsync(FamilyIdModule.serialize(State !.FamilyId), pushRequest.Value);
var import = Dto.changesAsImport(pushResponse);
if (import.IsSome())
{
var message = StateTypes.StateMessage.NewImport(import.Value);
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
return(import.Value.EarliestTimestamp.AsNullable());
}
else
{
return(null);
}
}
else
{
return(null);
}
}
private async Task <int?> PushCoreAsync()
{
if (_familyId == null)
{
throw new InvalidOperationException("No familyId has been specified; the service must be initialized first with a valid familyId.");
}
var pushRequest = Dto.pushRequest(State);
if (pushRequest.IsSome())
{
var pushResponse = await _cosmos.PushAsync(_familyId, pushRequest.Value);
var import = Dto.changesAsImport(pushResponse);
if (import.IsSome())
{
var message = StateTypes.StateMessage.NewImport(import.Value);
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
return(import.Value.EarliestTimestamp.AsNullable());
}
else
{
return(null);
}
}
else
{
return(null);
}
}
protected override void SetupModules()
{
EchoMod = new EchoModule();
StateMod = new StateModule();
BunnyHop = new BunnyHop();
TriggerBot = new TriggerModule();
View = new ViewModule();
RCS = new NoRecoilModule();
AimBot = new AimModule();
//Pistol = new AutoPistolModule();
Glow = new GlowModule();
ESP = new ESPModule();
ReloadSettings = new ReloadSettingsModule();
AddModule(EchoMod);
AddModule(StateMod);
AddModule(BunnyHop);
AddModule(TriggerBot);
AddModule(View);
AddModule(RCS);
AddModule(AimBot);
//AddModule(Pistol);
AddModule(Glow);
AddModule(ESP);
AddModule(ReloadSettings);
}
public async Task InitializeAsync(CoreTypes.FamilyId?familyId = null)
{
if (SynchronizationStatus == SynchronizationStatus.Synchronizing)
{
return;
}
if (State == null)
{
if (familyId == null)
{
throw new InvalidOperationException("Can't initialize the service without an existing familyId.");
}
else
{
State = StateModule.createDefault(familyId.Value, UserIdModule.anonymous);
_hasSynchronized = false;
SynchronizationStatus = HasChanges();
await SyncEverythingAsync();
}
}
else
{
if (familyId == null || State.FamilyId.Equals(familyId.Value))
{
if (!_hasSynchronized)
{
await SyncEverythingAsync();
}
}
else
{
switch (SynchronizationStatus)
{
case SynchronizationStatus.Synchronizing:
break;
case SynchronizationStatus.HasChanges:
await SyncIncrementalAsync();
_hasSynchronized = false;
await InitializeAsync(familyId);
break;
case SynchronizationStatus.NoChanges:
State = StateModule.createDefault(familyId.Value, UserIdModule.anonymous);
await SyncEverythingAsync();
break;
}
}
}
}
public async Task UpdateAsync(StateTypes.StateMessage message)
{
if (State == null)
{
throw new InvalidOperationException("Can not start synchronizing until the service is initialized.");
}
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
if (StateModule.hasChanges(State))
{
await SyncCoreAsync(isIncremental : true, ignoreIfSynchronizing : false);
}
}
private async Task PullCoreAsync(int?after, int?before)
{
var pullResponse =
(after is null && before is null)
? await _cosmos.PullEverythingAsync(FamilyIdModule.serialize(State !.FamilyId))
: await _cosmos.PullIncrementalAsync(FamilyIdModule.serialize(State !.FamilyId), after ?? int.MinValue, before);
var import = Dto.changesAsImport(pullResponse);
if (import.IsSome())
{
var message = StateTypes.StateMessage.NewImport(import.Value);
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
}
}
public void Send_State_Web(StateModule stateModules)
{
foreach (var item in APISetting.APIAddress)
{
var client = new RestClient($"{item}/api/StateWeb");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", JsonConvert.SerializeObject(stateModules), ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
if (response.StatusDescription != "OK")
{
Log.Error("狀態網頁上傳失敗" + $"{JsonConvert.SerializeObject(stateModules)}" + response.Content);
}
//Console.WriteLine(response.Content);
}
}
private async Task PullCoreAsync(int?after, int?before)
{
if (_familyId == null)
{
throw new InvalidOperationException("No familyId has been specified; the service must be initialized first with a valid familyId.");
}
var pullResponse =
(after is null && before is null)
? await _cosmos.PullEverythingAsync(_familyId)
: await _cosmos.PullIncrementalAsync(_familyId, after ?? int.MinValue, before);
var import = Dto.changesAsImport(pullResponse);
if (import.IsSome())
{
var message = StateTypes.StateMessage.NewImport(import.Value);
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
}
}
public async Task CanPushThenPullSameNumberOfItems()
{
// Would be easier to test using F# since could compare the actual State variables
// with the eTag values removed
using var c = await CreateTargetAsync();
var stateA = StateModule.createSampleData(FamilyIdModule.anonymous, UserIdModule.anonymous);
await Dto.pushRequest(stateA).DoAsync(changes => c.PushAsync(_familyId, changes));
var pulledChanges = await c.PullEverythingAsync(_familyId);
var pulledChangesAsImport = Dto.changesAsImport(pulledChanges);
var stateB = StateModule.importChanges(pulledChangesAsImport.Value, stateA);
Assert.Equal(stateA.Items.Item.Count, stateB.Items.Item.Count);
Assert.Equal(stateA.Categories.Item.Count, stateB.Categories.Item.Count);
Assert.Equal(stateA.Stores.Item.Count, stateB.Stores.Item.Count);
Assert.Equal(stateA.NotSoldItems.Item.Count, stateB.NotSoldItems.Item.Count);
Assert.Equal(stateA.Purchases.Item.Count, stateB.Purchases.Item.Count);
}
public StateService(ICosmosConnector cosmos) : this(StateModule.createDefault(FamilyIdModule.anonymous, UserIdModule.anonymous), cosmos)
{
}
public static bool CountToZero(StateModule<TestData>.State state)
{
state.Data.Val--;
return state.Data.Val >= 0;
}
public void RecordPreviousState(StateModule settings)
{
}
public void InitStateWithModule(Enum state, StateModule module)
{
InitState (state, module.OnEnter, module.OnExit, module.OnWork);
}
public void RollbackState(StateModule settings)
{
}
public async Task UpdateAsync(StateTypes.StateMessage message)
{
State = StateModule.updateUsingStandardClock(message, State);
OnChange?.Invoke();
await SyncCoreAsync(isIncremental : true, ignoreIfSynchronizing : false);
}
public static bool CountToTen(StateModule<TestData>.State state)
{
state.Data.Val++;
return state.Data.Val < 10;
}
private SynchronizationStatus HasChanges() =>
StateModule.hasChanges(State)
? SynchronizationStatus.HasChanges
: SynchronizationStatus.NoChanges;
public void ApplyState(StateModule settings)
{
}
