public IList <IInternalFriend> ParseFriendships(GetStateResponse response, IUserDatabase userDatabase)
{
List <IInternalFriend> list = new List <IInternalFriend>();
List <User> users = response.Users;
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
string userId = friendship.FriendUserId;
bool value = friendship.IsTrusted.Value;
string displayNameText = string.Empty;
string firstName = string.Empty;
if (users != null)
{
User user = users.FirstOrDefault((User u) => u.UserId == userId);
if (user != null)
{
displayNameText = user.DisplayName;
firstName = user.FirstName;
}
}
IInternalFriend item = RemoteUserFactory.CreateFriend(userId, value, displayNameText, firstName, userDatabase);
list.Add(item);
}
}
return(list);
}
public void GetState_ShouldReturn_CommandWouldCauseOffGridStatus_UpperBound()
{
var initialState = new State
{
FaceDirection = Direction.North,
Position = new GridPosition {
XPos = 2, YPos = 1
}
};
var commandSequence = "RMMLM";
var expected = new GetStateResponse
{
StateResult = new State {
FaceDirection = Direction.North, Position = new GridPosition {
XPos = 3, YPos = 2
}
},
StateStatus = GetStateStatus.CommandCouldCauseOffGrid
};
stateMachine.SetGridBoundary(new GridPosition {
XPos = 3, YPos = 3
});
var result = stateMachine.GetState(initialState, commandSequence);
Assert.AreEqual(GetStateStatus.CommandCouldCauseOffGrid, result.StateStatus);
Assert.AreEqual(expected.StateResult, result.StateResult);
}
public void ParseFriendshipInvitations(GetStateResponse response, IUserDatabase userDatabase, IInternalLocalUser localUser, out IList <IInternalIncomingFriendInvitation> incomingFriendInvitations, out IList <IInternalOutgoingFriendInvitation> outgoingFriendInvitations)
{
incomingFriendInvitations = new List <IInternalIncomingFriendInvitation>();
outgoingFriendInvitations = new List <IInternalOutgoingFriendInvitation>();
if (response.FriendshipInvitations != null)
{
foreach (FriendshipInvitation invitation in response.FriendshipInvitations)
{
List <User> users = response.Users;
Func <User, bool> predicate = (User user) => user.DisplayName == invitation.FriendDisplayName;
string firstName = users.FirstOrDefault(predicate)?.FirstName;
if (invitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, invitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
outgoingFriendInvitations.Add(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, invitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
incomingFriendInvitations.Add(incomingFriendInvitation);
}
}
}
}
public void ParsePollIntervals(GetStateResponse response, out int[] pollIntervals, out int[] pokeIntervals)
{
pollIntervals = (from i in response.PollIntervals
select i.Value * 1000).ToArray();
pokeIntervals = (from i in response.PokeIntervals
select i.Value * 1000).ToArray();
}
private static bool ValidateResponse(GetStateResponse response)
{
if (response.FriendshipInvitations != null && response.FriendshipInvitations.Any((FriendshipInvitation i) => !i.IsTrusted.HasValue || !i.FriendshipInvitationId.HasValue))
{
return(false);
}
if (response.Friendships != null && response.Friendships.Any((Friendship f) => !f.IsTrusted.HasValue))
{
return(false);
}
if (response.PollIntervals != null && response.PollIntervals.Any((int?p) => !p.HasValue))
{
return(false);
}
if (response.PokeIntervals != null && response.PokeIntervals.Any((int?p) => !p.HasValue))
{
return(false);
}
if (!response.Timestamp.HasValue)
{
return(false);
}
if (!response.NotificationSequenceCounter.HasValue)
{
return(false);
}
if (response.Users == null || response.Users.Any((User u) => u.HashedUserId == null))
{
return(false);
}
return(true);
}
public void NewState(Order order)
{
bool isValid = false;
OrderManager manager = OrderManagerFactory.Create();
while (!isValid)
{
string stateName = ConsoleIO.GetStateName();
Console.WriteLine($"Is this the correct new state: {stateName}, Y/N?");
string correctState = Console.ReadLine().ToUpper();
if (correctState == "Y")
{
isValid = true;
}
}
GetStateResponse response = new GetStateResponse();
if (response.Success)
{
manager.SaveCurrentOrder(order);
ConsoleIO.DisplayEditedOrderDetail(order);
}
else
{
response.Success = false;
response.Message = "An error occurred: ";
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
private void ReconcileFriendInvitations(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <FriendshipInvitation> friendshipInvitations = response.FriendshipInvitations;
List <IInternalIncomingFriendInvitation> list = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list2 = localUser.InternalOutgoingFriendInvitations.ToList();
if (friendshipInvitations != null)
{
foreach (FriendshipInvitation friendInvitation in friendshipInvitations)
{
Func <IInternalIncomingFriendInvitation, bool> predicate = (IInternalIncomingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId;
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list.FirstOrDefault(predicate);
if (internalIncomingFriendInvitation != null)
{
if (internalIncomingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalIncomingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list.Remove(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list2.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId);
if (internalOutgoingFriendInvitation != null)
{
if (internalOutgoingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalOutgoingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list2.Remove(internalOutgoingFriendInvitation);
continue;
}
string firstName = response.Users.FirstOrDefault((User user) => user.DisplayName == friendInvitation.FriendDisplayName)?.FirstName;
if (friendInvitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, friendInvitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddOutgoingFriendInvitation(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, friendInvitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddIncomingFriendInvitation(incomingFriendInvitation);
}
}
}
foreach (IInternalIncomingFriendInvitation item in list)
{
localUser.RemoveIncomingFriendInvitation(item);
item.Rejected();
}
foreach (IInternalOutgoingFriendInvitation item2 in list2)
{
localUser.RemoveOutgoingFriendInvitation(item2);
item2.Rejected();
}
}
private void ReconcileFriends(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <IInternalFriend> list = localUser.InternalFriends.ToList();
List <IInternalIncomingFriendInvitation> list2 = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list3 = localUser.InternalOutgoingFriendInvitations.ToList();
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
string friendUserId = friendship.FriendUserId;
IInternalFriend internalFriend = list.FirstOrDefault((IInternalFriend f) => f.Swid == friendUserId);
User user = response.Users.First((User u) => u.UserId == friendUserId);
if (internalFriend != null)
{
if (internalFriend.IsTrusted != friendship.IsTrusted)
{
if (friendship.IsTrusted.Value)
{
internalFriend.ChangeTrust(isTrusted: true);
}
else
{
localUser.UntrustFriend(internalFriend);
}
}
list.Remove(internalFriend);
continue;
}
IInternalFriend internalFriend2 = RemoteUserFactory.CreateFriend(friendship.FriendUserId, friendship.IsTrusted.Value, user.DisplayName, user.FirstName, userDatabase);
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list2.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.InternalInviter.DisplayName.Text == user.DisplayName);
if (internalIncomingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalIncomingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list2.Remove(internalIncomingFriendInvitation);
localUser.RemoveIncomingFriendInvitation(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list3.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InternalInvitee.DisplayName.Text == user.DisplayName);
if (internalOutgoingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalOutgoingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list3.Remove(internalOutgoingFriendInvitation);
localUser.RemoveOutgoingFriendInvitation(internalOutgoingFriendInvitation);
}
else
{
localUser.AddFriend(internalFriend2);
}
}
}
foreach (IInternalFriend item in list)
{
localUser.RemoveFriend(item);
}
}
public void GetStateTaxDataTest(string stateAbbreviation, string stateName, decimal taxRate)
{
MockTaxRepo taxRepo = new MockTaxRepo();
GetStateResponse response = new GetStateResponse();
var result = taxRepo.GetStateName(stateAbbreviation);
Assert.AreEqual(stateAbbreviation, result.StateAbbreviation);
}
public void SyncToGetStateResponse(GetStateResponse response, Action callback)
{
if (response.Alerts != null)
{
foreach (Disney.Mix.SDK.Internal.MixDomain.Alert alert in response.Alerts)
{
AddAlert(new Alert(alert));
}
}
ClearFriends();
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
PersistUser(friendship.FriendUserId, null, null, null, null);
FriendDocument friendDocument = new FriendDocument();
friendDocument.Swid = friendship.FriendUserId;
friendDocument.IsTrusted = friendship.IsTrusted.Value;
FriendDocument doc = friendDocument;
InsertFriend(doc);
}
}
ClearFriendInvitations();
if (response.FriendshipInvitations != null)
{
foreach (FriendshipInvitation friendshipInvitation in response.FriendshipInvitations)
{
List <User> source = response.Users;
Func <User, bool> predicate = (User user) => user.DisplayName == friendshipInvitation.FriendDisplayName;
User user2 = source.FirstOrDefault(predicate);
if (user2 != null)
{
string firstName = user2.FirstName;
string userId = user2.UserId;
string hashedUserId = user2.HashedUserId;
string status = user2.Status;
PersistUser(userId, hashedUserId, friendshipInvitation.FriendDisplayName, firstName, status);
}
FriendInvitationDocument friendInvitationDocument = new FriendInvitationDocument();
friendInvitationDocument.FriendInvitationId = friendshipInvitation.FriendshipInvitationId.Value;
friendInvitationDocument.IsInviter = friendshipInvitation.IsInviter.Value;
friendInvitationDocument.IsTrusted = friendshipInvitation.IsTrusted.Value;
friendInvitationDocument.DisplayName = friendshipInvitation.FriendDisplayName;
FriendInvitationDocument doc2 = friendInvitationDocument;
InsertFriendInvitation(doc2);
}
}
if (response.Users != null)
{
foreach (User user3 in response.Users)
{
PersistUser(user3.UserId, user3.HashedUserId, user3.DisplayName, user3.FirstName, user3.Status);
}
}
callback();
}
private async Task SendResponseWithState <T>(T state, TestClient <DaprClient> .TestGrpcRequest request)
{
var stateData = TypeConverters.ToJsonByteString(state, new JsonSerializerOptions(JsonSerializerDefaults.Web));
var stateResponse = new GetStateResponse()
{
Data = stateData,
Etag = "test",
};
await request.CompleteWithMessageAsync(stateResponse);
}
private async void SendResponseWithState <T>(T state, TestHttpClient.Entry entry)
{
var stateData = TypeConverters.ToJsonByteString(state);
var stateResponse = new GetStateResponse();
stateResponse.Data = stateData;
stateResponse.Etag = "test";
var streamContent = await GrpcUtils.CreateResponseContent(stateResponse);
var response = GrpcUtils.CreateResponse(HttpStatusCode.OK, streamContent);
entry.Completion.SetResult(response);
}
private async Task SendResponseWithState <T>(T state, TestHttpClient.Entry entry)
{
var stateData = TypeConverters.ToJsonByteString(state, new JsonSerializerOptions(JsonSerializerDefaults.Web));
var stateResponse = new GetStateResponse
{
Data = stateData,
Etag = "test",
};
var streamContent = await GrpcUtils.CreateResponseContent(stateResponse);
var response = GrpcUtils.CreateResponse(HttpStatusCode.OK, streamContent);
entry.Completion.SetResult(response);
}
public GetStateResponse GetStateTaxData(string stateAbbreviation)
{
GetStateResponse response = new GetStateResponse();
response.TaxData = _taxRepository.LoadTaxForState(stateAbbreviation);
if (response.TaxData == null)
{
response.Success = false;
response.Message = $"{stateAbbreviation} is not valid!";
}
else
{
response.Success = true;
}
return(response);
}
internal void Populate(GetStateResponse response, EdisType edisType)
{
IgnitionAdvance = response.CurrentIgnitionAdvance;
Rpm = response.GetCurrentRpmValue(edisType);
Load = response.CurrentLoadValue;
IgnitionCell = new IgnitionCellIndex(response.CurrentLoadBin, response.CurrentRpmBin);
UserOutput1State = response.UserOutput1;
UserOutput2State = response.UserOutput2;
UserOutput3State = response.UserOutput3;
UserOutput4State = response.UserOutput4;
ShiftLightState = response.ShiftLightState;
RevLimitState = response.RevLimitState;
IgnitionConfiguration = response.IgnitionConfiguration;
AuxiliaryInput = response.AuxiliaryInputValue;
AdvanceCorrectionBin = response.CurrentAdvanceCorrectionBin;
AdvanceCorrection = response.CurrentAdvanceCorrectionValue;
}
public void GetCurrentSate(object userState)
{
if (RefreshInProgress)
{
return;
}
RefreshInProgress = true;
GetStateResponse response = (GetStateResponse)SendCommand(new GetStateCommand());
if (response != null)
{
CurrentState.Populate(response, GlobalConfiguration.EdisType);
}
RefreshInProgress = false;
}
private async Task<StateDataViewModel> GetStateDataAsync(TISWebServiceGetStateSupportIN stateIn)
{
GetStateResponse result = new GetStateResponse();
using (TISWebService.TISWebServiceSoapClient client = GetClient())
using (var scope = new FlowingOperationContextScope(client.InnerChannel))
{
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = CreateRequestMessageProperty();
string strIn = DCSerializer.SerializeWithDCS(stateIn);
try
{
var webResponse = await client.GetStateAsync(strIn).ContinueOnScope(scope);
return GetStateData(webResponse.Body);
}
catch (Exception ex)
{
return new StateDataViewModel { Error = ex.Message };
}
}
}
private async Task <StateDataViewModel> GetStateDataAsync(TISWebServiceGetStateSupportIN stateIn)
{
GetStateResponse result = new GetStateResponse();
using (TISWebService.TISWebServiceSoapClient client = GetClient())
using (var scope = new FlowingOperationContextScope(client.InnerChannel))
{
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = CreateRequestMessageProperty();
string strIn = DCSerializer.SerializeWithDCS(stateIn);
try
{
var webResponse = await client.GetStateAsync(strIn).ContinueOnScope(scope);
return(GetStateData(webResponse.Body));
}
catch (Exception ex)
{
return(new StateDataViewModel {
Error = ex.Message
});
}
}
}
public void ReconcileWithLocalUser(IMixWebCallFactory mixWebCallFactory, GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
ReconcileFriends(response, localUser, userDatabase);
ReconcileFriendInvitations(response, localUser, userDatabase);
}
private static void HandleGetStateSuccess(AbstractLogger logger, IEpochTime epochTime, IDatabase database, IUserDatabase userDatabase, INotificationQueue notificationQueue, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, Action <GetStateResponse> successCallback, Action failureCallback)
{
try
{
if (ValidateResponse(response))
{
epochTime.ReferenceTime = response.Timestamp.Value;
database.SetServerTimeOffsetMillis((long)epochTime.Offset.TotalMilliseconds);
logger.Debug("New time offset: " + epochTime.Offset);
successCallback(response);
notificationQueue.LatestSequenceNumber = response.NotificationSequenceCounter.Value;
}
else
{
logger.Critical("Error validating get state response: " + JsonParser.ToJson(response));
failureCallback();
notificationQueue.Clear();
}
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
failureCallback();
notificationQueue.Clear();
}
}
public IList <IInternalAlert> ParseAlerts(GetStateResponse response)
{
return((from a in (IEnumerable <Disney.Mix.SDK.Internal.MixDomain.Alert>)response.Alerts
select new Disney.Mix.SDK.Internal.Alert(a)).ToList());
}
public void ParsePollIntervals(GetStateResponse response, out int[] pollIntervals, out int[] pokeIntervals)
{
pollIntervals = response.PollIntervals.Select((int?i) => i.Value * 1000).ToArray();
pokeIntervals = response.PokeIntervals.Select((int?i) => i.Value * 1000).ToArray();
}
public IList <IInternalAlert> ParseAlerts(GetStateResponse response)
{
return(((IEnumerable <Disney.Mix.SDK.Internal.MixDomain.Alert>)response.Alerts).Select((Func <Disney.Mix.SDK.Internal.MixDomain.Alert, IInternalAlert>)((Disney.Mix.SDK.Internal.MixDomain.Alert a) => new Alert(a))).ToList());
}
internal void Execute()
{
bool isValid = false;
OrderManager manager = OrderManagerFactory.Create();
SaveNewOrderRequest saveRequest = new SaveNewOrderRequest();
saveRequest.Order = new Order();
Console.Clear();
Console.WriteLine("ADD A NEW ORDER");
Console.WriteLine("****************************");
Console.WriteLine();
Console.WriteLine("NEW ORDERS MUST BE FUTURE DATED!");
while (!isValid)
{
Console.WriteLine();
DateTime orderDate = ConsoleIO.GetDate();
Console.WriteLine();
if (orderDate > DateTime.Today)
{
saveRequest.Order.OrderDate = orderDate;
isValid = true;
}
else
{
Console.WriteLine("The new order must be futured dated.");
}
}
//Cannot be blank. Allowed to contain [a-z][0-9]
string userInput = ConsoleIO.GetUserName();
Console.WriteLine();
saveRequest.Order.CustomerName = userInput;
//State must be checked against the tax file.
bool validState = false;
while (!validState)
{
string stateInput = ConsoleIO.GetStateName();
Console.WriteLine();
GetStateResponse stateResponse = manager.GetStateTaxData(stateInput);
if (stateResponse.Success)
{
saveRequest.Order.StateTaxData = stateResponse.TaxData;
validState = true;
}
else
{
stateResponse.Success = false;
Console.WriteLine("That state does not exist!");
}
}
//verify that is the correct product type
bool validProduct = false;
while (!validProduct)
{
ProductRepo repo = new ProductRepo();
string productType = ConsoleIO.GetProduct(repo.LoadProducts());
Console.WriteLine();
ProductTypeResponse productResponse = manager.FindProductByType(productType);
if (productResponse.Success)
{
saveRequest.Order.ProductDetail = productResponse.ProductType;
validProduct = true;
}
else
{
productResponse.Success = false;
Console.WriteLine("That product does not exist!");
//Console.WriteLine(productResponse.Message);
}
}
string areaInput = ConsoleIO.GetArea();
saveRequest.Order.Area = decimal.Parse(areaInput);
Console.WriteLine("Would you like to save this order?: Y/N");
string saveResponse = Console.ReadLine().ToUpper();
if (saveResponse == "Y")
{
manager.SaveNewOrder(saveRequest.Order);
}
else
{
Console.WriteLine("Press any key to return to Menu");
Console.ReadKey();
Menu.Start();
}
}
private static void HandleGetStateSuccess(AbstractLogger logger, IGetStateResponseParser getStateResponseParser, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, IInternalLocalUser localUser, IUserDatabase userDatabase, INotificationPoller notificationPoller, Action <IResumeSessionResult> callback)
{
try
{
userDatabase.SyncToGetStateResponse(response, delegate
{
HandleGetStateSynced(getStateResponseParser, response, mixWebCallFactory, localUser, userDatabase, notificationPoller, callback);
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new ResumeSessionResult(success: false));
}
}
private static void HandleGetStateSynced(IGetStateResponseParser getStateResponseParser, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, IInternalLocalUser localUser, IUserDatabase userDatabase, INotificationPoller notificationPoller, Action <IResumeSessionResult> callback)
{
getStateResponseParser.ParsePollIntervals(response, out var pollIntervals, out var pokeIntervals);
notificationPoller.PollIntervals = pollIntervals;
notificationPoller.PokeIntervals = pokeIntervals;
notificationPoller.Jitter = response.NotificationIntervalsJitter.Value;
notificationPoller.MaximumMissingNotificationTime = response.NotificationSequenceThreshold.Value;
getStateResponseParser.ReconcileWithLocalUser(mixWebCallFactory, response, localUser, userDatabase);
callback(new ResumeSessionResult(success: true));
}
