public string HandleRequest(HttpListenerContext ct)
{
log.Info("Handle Request");
string result = "";
try
{
ActionSelector actionselector = new ActionSelector();
Handlers messageHandler = new Handlers();
HandlerData handlerData =
actionselector.GetHandlerData(ct.Request.HttpMethod + ct.Request.RawUrl);
string Name = handlerData.handler.Method.Name;
if (Name.Equals("Authenticate") || Name.Equals("IsAuthenticated") ||
Name.Equals("SignOut") || Name.Equals("Touch") ||
messageHandler.IsSessionIdOk(ct))
{
result = handlerData.handler(ct, handlerData.actionInfo);
}
else
{
throw (new Exception("Not Authenticated."));
}
}
catch (Exception e)
{
Logger.Error(e.Message);
throw (e);
}
return(result ?? "");
}
private void SetupSteps(GameHandlerMetadata metadataSelected)
{
KillCurrentStep();
if (handlerDataManager != null)
{
// dispose
handlerDataManager.Dispose();
handlerDataManager = null;
}
selectedHandler = metadataSelected;
handlerDataManager = GameManager.Instance.PackageManager.ReadHandlerDataFromInstalledPackage(selectedHandler);
handlerData = handlerDataManager.HandlerData;
BrowserBtns.SetPlayButtonState(false);
stepsList = new List <UserInputControl>();
stepsList.Add(positionsControl);
stepsList.Add(optionsControl);
if (handlerData.CustomSteps != null)
{
for (int i = 0; i < handlerData.CustomSteps.Count; i++)
{
stepsList.Add(jsControl);
}
}
currentProfile = new GameProfile();
currentProfile.InitializeDefault(handlerData);
MainForm.Instance.ChangeGameInfo(userGame);
}
public AcquireTokenSilentHandler(HandlerData handlerData, string userIdentifer, IPlatformParameters parameters, bool forceRefresh)
: this(handlerData, (User)null, parameters, forceRefresh)
{
this.User = this.MapIdentifierToUser(userIdentifer);
PlatformPlugin.BrokerHelper.PlatformParameters = parameters;
this.SupportADFS = false;
}
public MessageInfo AnalyzeMessage(byte[] data, int offset, int length)
{
var reader = new BinaryReader(new MemoryStream(data, offset, length));
byte header = reader.ReadByte();
if ((header & ResponseTypeFlag) == 0)
{
byte ifaceOrdinal = header;
byte methodOrdinal = reader.ReadByte();
HandlerData handlerData = _handlersData[ifaceOrdinal];
RpcMethodInfo rpcMethodInfo = handlerData.InterfaceMethods[methodOrdinal];
return(new MessageInfo
{
Type = MessageType.HandlerCall,
InterfaceType = RpcInterface.GetRpcInterface(ifaceOrdinal),
InterfaceMethodInfo = rpcMethodInfo.MethodInfo,
Handler = handlerData.Handler,
});
}
return(new MessageInfo
{
Type = MessageType.CallResult,
});
}
public override bool Handle(Handler handler, HandlerData handlerData)
{
var nestedHandler = handler.CreateNestedHandler(Position, Size / OriginalSize);
return(HandlerVisitors.Exists(hv => handler.Handle(hv, handlerData)) ||
Items.Exists(v => v.Handle(nestedHandler, handlerData)));
}
/// <summary>
/// Get user project statistics.
/// </summary>
/// <param name="request">User.</param>
/// <param name="cancellationToken"></param>
/// <returns>User project statistics.</returns>
public async Task <UserStatistics> Handle(HandlerData <User, UserStatistics> request, CancellationToken cancellationToken)
{
string userName = request.Data.UserName;
var allUserProjects = Context.Projects
.Where(project => project.AuthorRoles.Any(authorRole => authorRole.User.UserName == userName));
var createdByUserProjects = Context.Projects
.Where(project => project.Creator.UserName == userName);
var allUserProjectSnapshots = Context.ProjectShapshots
.Where(snapshot => snapshot.Project.Creator.UserName == userName);
var createdByUserSnapshots = Context.ProjectShapshots
.Where(snapshot => snapshot.Author.UserName == userName);
var writtenByUserComments = Context.Comments
.Where(comment => comment.Author.UserName == userName);
var allUserProjectComments = Context.Comments
.Where(comment => comment.ProjectSnapshot.Project.Creator.UserName == userName);
return(new UserStatistics
{
AllProjectCount = allUserProjects.Count(),
CreatedProjectCount = createdByUserProjects.Count(),
ClosedAllProjectCount = allUserProjects.Where(project => project.isActive == false).Count(),
ClosedCreatedProjectCount = createdByUserProjects.Where(project => project.isActive == false).Count(),
AllUserProjectSnapshotsCount = allUserProjectSnapshots.Count(),
CreatedSnapshotsCount = createdByUserSnapshots.Count(),
AllUserProjectCommentCount = allUserProjectSnapshots.Count(),
WrittenCommentCount = writtenByUserComments.Count()
});
}
public override void Initialize(HandlerData handlerData, UserGameInfo game, GameProfile profile)
{
base.Initialize(handlerData, game, profile);
gamepadTimer.Enabled = true;
UpdatePlayers();
}
public string Subscribe(string eventKey, Func <DomainEvent, Task> handler, string name)
{
var handlerId = Convert
.ToBase64String(Guid.NewGuid().ToByteArray())
.Replace("=", "")
.Replace("+", "");
var handlerData = new HandlerData
{
HandlerId = handlerId,
Handler = handler,
Name = name,
};
if (_handlers.ContainsKey(eventKey))
{
_handlers[eventKey].Add(handlerData);
}
else
{
_handlers[eventKey] = new List <HandlerData> {
handlerData
}
};
return(handlerId);
}
public void SilentRefreshFailedNoCacheItemFoundTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false,
Guid.NewGuid());
TokenCache cache = new TokenCache();
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = TestConstants.DefaultRestrictToSingleUser,
Scope = new[] { "some-scope1", "some-scope2" },
TokenCache = cache
};
HttpMessageHandlerFactory.MockHandler = new MockHttpMessageHandler()
{
Method = HttpMethod.Post,
ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage()
};
try
{
AcquireTokenSilentHandler handler = new AcquireTokenSilentHandler(data, (string)null,
new PlatformParameters(), false);
Task <AuthenticationResult> task = handler.RunAsync();
var authenticationResult = task.Result;
Assert.Fail("MsalSilentTokenAcquisitionException should be thrown here");
}
catch (AggregateException ae)
{
Assert.IsTrue(ae.InnerException is MsalSilentTokenAcquisitionException);
}
}
public void ExpiredTokenRefreshFlowTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false,
Guid.NewGuid());
TokenCache cache = TokenCacheHelper.CreateCacheWithItems();
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = TestConstants.DefaultRestrictToSingleUser,
Scope = new[] { "some-scope1", "some-scope2" },
TokenCache = cache
};
HttpMessageHandlerFactory.MockHandler = new MockHttpMessageHandler()
{
Method = HttpMethod.Post,
ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage()
};
AcquireTokenSilentHandler handler = new AcquireTokenSilentHandler(data, (string)null,
new PlatformParameters(), false);
Task <AuthenticationResult> task = handler.RunAsync();
AuthenticationResult result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual("some-access-token", result.Token);
Assert.AreEqual("some-scope1 some-scope2", result.Scope.AsSingleString());
}
public void ConstructorTests()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false,
Guid.NewGuid());
TokenCache cache = new TokenCache();
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = true,
Scope = TestConstants.DefaultScope.ToArray(),
TokenCache = cache
};
AcquireTokenSilentHandler handler = new AcquireTokenSilentHandler(data, (string)null,
new PlatformParameters(), false);
Assert.IsNotNull(handler);
handler = new AcquireTokenSilentHandler(data, (User)null, new PlatformParameters(), false);
Assert.IsNotNull(handler);
handler = new AcquireTokenSilentHandler(data, TestConstants.DefaultDisplayableId, new PlatformParameters(), false);
Assert.IsNotNull(handler);
handler = new AcquireTokenSilentHandler(data, TestConstants.DefaultUniqueId, new PlatformParameters(), false);
Assert.IsNotNull(handler);
handler = new AcquireTokenSilentHandler(data, TestConstants.DefaultUser, new PlatformParameters(), false);
Assert.IsNotNull(handler);
}
public void NullUserForActAsCurrentUserTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false, Guid.NewGuid());
try
{
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = TestConstants.DefaultRestrictToSingleUser,
Scope = TestConstants.DefaultScope.ToArray(),
TokenCache = null
};
AcquireTokenInteractiveHandler handler = new AcquireTokenInteractiveHandler(data,
TestConstants.ScopeForAnotherResource.ToArray(), new Uri("some://uri"), new PlatformParameters(),
(User)null, UiOptions.ActAsCurrentUser, "extra=qp", new MockWebUI());
Assert.Fail("ArgumentException should be thrown here");
}
catch (ArgumentException ae)
{
Assert.IsTrue(ae.Message.Contains(MsalErrorMessage.LoginHintNullForUiOption));
}
}
public void DuplicateQueryParameterErrorTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false, Guid.NewGuid());
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = TestConstants.DefaultRestrictToSingleUser,
Scope = TestConstants.DefaultScope.ToArray(),
TokenCache = null
};
AcquireTokenInteractiveHandler handler = new AcquireTokenInteractiveHandler(data,
TestConstants.ScopeForAnotherResource.ToArray(),
new Uri("some://uri"), new PlatformParameters(),
(User)null, UiOptions.ForceLogin, "extra=qp&prompt=login", new MockWebUI());
handler.PreRunAsync().Wait();
try
{
handler.PreTokenRequest().Wait();
Assert.Fail("MsalException should be thrown here");
}
catch (Exception exc)
{
Assert.IsTrue(exc.InnerException is MsalException);
Assert.AreEqual(MsalError.DuplicateQueryParameter, ((MsalException)exc.InnerException).ErrorCode);
}
}
public void CacheWithMultipleUsersAndRestrictToSingleUserTrueTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false, Guid.NewGuid());
TokenCache cache = TokenCacheHelper.CreateCacheWithItems();
try
{
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = true,
Scope = TestConstants.DefaultScope.ToArray(),
TokenCache = cache
};
AcquireTokenInteractiveHandler handler = new AcquireTokenInteractiveHandler(data,
TestConstants.ScopeForAnotherResource.ToArray(),
new Uri("some://uri"), new PlatformParameters(),
new User {
UniqueId = TestConstants.DefaultUniqueId
}, UiOptions.ForceLogin, "extra=qp",
new MockWebUI());
Assert.Fail("ArgumentException should be thrown here");
}
catch (ArgumentException ae)
{
Assert.AreEqual(
"Cache cannot have entries for more than 1 unique id when RestrictToSingleUser is set to TRUE.",
ae.Message);
}
}
public async Task <IActionResult> ShowProjects([FromRoute] UserRoute route)
{
// Getting field _user based on route.
await Init(route);
var request = new HandlerData <User, IEnumerable <ProjectTableData> > {
Data = _user
};
IEnumerable <ProjectTableData> data = await _mediator.Send(request);
string projectLocationTemplate = "/{0}/{1}";
// Getting references to user projects.
string[] projectReferences = data
.Select(rowData => String.Format(projectLocationTemplate, rowData.CreatorName, rowData.ProjectName))
.ToArray();
// Creation all user project table.
var table = new ReferencedTable(
new NumberedTable(new ObjectTable <ProjectTableData>(data)),
new Dictionary <string, string[]>
{
{ "ProjectName", projectReferences }
}
);
return(View("Projects", new ProjectsInfo {
Table = table, UserName = route.UserName
}));
}
public bool Initialize(HandlerData handlerData, UserGameInfo userGameInfo, GameProfile profile)
{
this._handlerData = handlerData;
this._userGame = userGameInfo;
this._profile = profile;
modules = new List <HandlerModule>();
foreach (ModuleInfo info in GameManager.Instance.ModuleManager.Modules)
{
if (info.IsNeeded(handlerData))
{
modules.Add((HandlerModule)Activator.CreateInstance(info.ModuleType));
}
}
// order modules
modules = modules.OrderBy(c => c.Order).ToList();
for (int i = 0; i < modules.Count; i++)
{
modules[i].Initialize(this, handlerData, userGameInfo, profile);
}
return(true);
}
protected AcquireTokenHandlerBase(HandlerData handlerData)
{
this.Authenticator = handlerData.Authenticator;
this.CallState = CreateCallState(this.Authenticator.CorrelationId);
PlatformPlugin.Logger.Information(this.CallState,
string.Format(CultureInfo.InvariantCulture, "=== Token Acquisition started:\n\tAuthority: {0}\n\tScope: {1}\n\tClientId: {2}\n\tCacheType: {3}",
Authenticator.Authority, handlerData.Scope.AsSingleString(), handlerData.ClientKey.ClientId,
(tokenCache != null) ? tokenCache.GetType().FullName + string.Format(CultureInfo.InvariantCulture, " ({0} items)", tokenCache.Count) : "null"));
this.tokenCache = handlerData.TokenCache;
this.ClientKey = handlerData.ClientKey;
this.Policy = handlerData.Policy;
this.restrictToSingleUser = handlerData.RestrictToSingleUser;
if (MsalStringHelper.IsNullOrEmpty(handlerData.Scope))
{
throw new ArgumentNullException("scope");
}
this.Scope = handlerData.Scope.CreateSetFromArray();
ValidateScopeInput(this.Scope);
this.LoadFromCache = (tokenCache != null);
this.StoreToCache = (tokenCache != null);
this.SupportADFS = false;
if (this.tokenCache != null && (restrictToSingleUser && this.tokenCache.GetUniqueIdsFromCache(this.ClientKey.ClientId).Count() > 1))
{
throw new ArgumentException(
"Cache cannot have entries for more than 1 unique id when RestrictToSingleUser is set to TRUE.");
}
}
public static bool IsNeeded(HandlerData data)
{
#if WINDOWS
return(true);
#else
return(false);
#endif
}
public override bool Initialize(GameHandler handler, HandlerData handlerData, UserGameInfo game, GameProfile profile)
{
this.userGame = game;
this.profile = profile;
this.handlerData = handlerData;
return(true);
}
public void VerifyAuthorizationResultTest()
{
Authenticator authenticator = new Authenticator(TestConstants.DefaultAuthorityHomeTenant, false, Guid.NewGuid());
MockWebUI webUi = new MockWebUI();
webUi.MockResult = new AuthorizationResult(AuthorizationStatus.ErrorHttp,
TestConstants.DefaultAuthorityHomeTenant + "?error=" + OAuthError.LoginRequired);
HandlerData data = new HandlerData()
{
Authenticator = authenticator,
ClientKey = new ClientKey(TestConstants.DefaultClientId),
Policy = TestConstants.DefaultPolicy,
RestrictToSingleUser = TestConstants.DefaultRestrictToSingleUser,
Scope = TestConstants.DefaultScope.ToArray(),
TokenCache = null
};
AcquireTokenInteractiveHandler handler = new AcquireTokenInteractiveHandler(data,
TestConstants.ScopeForAnotherResource.ToArray(), new Uri("some://uri"), new PlatformParameters(),
(string)null, UiOptions.ForceLogin, "extra=qp", webUi);
handler.PreRunAsync().Wait();
try
{
handler.PreTokenRequest().Wait();
Assert.Fail("MsalException should have been thrown here");
}
catch (Exception exc)
{
Assert.IsTrue(exc.InnerException is MsalException);
Assert.AreEqual(MsalError.UserInteractionRequired, ((MsalException)exc.InnerException).ErrorCode);
}
webUi = new MockWebUI();
webUi.MockResult = new AuthorizationResult(AuthorizationStatus.ErrorHttp,
TestConstants.DefaultAuthorityHomeTenant + "?error=invalid_request&error_description=some error description");
handler = new AcquireTokenInteractiveHandler(data,
TestConstants.ScopeForAnotherResource.ToArray(), new Uri("some://uri"), new PlatformParameters(),
(string)null, UiOptions.ForceLogin, "extra=qp", webUi);
handler.PreRunAsync().Wait();
try
{
handler.PreTokenRequest().Wait();
Assert.Fail("MsalException should have been thrown here");
}
catch (Exception exc)
{
Assert.IsTrue(exc.InnerException is MsalException);
Assert.AreEqual("invalid_request", ((MsalException)exc.InnerException).ErrorCode);
Assert.AreEqual("some error description", ((MsalException)exc.InnerException).Message);
}
}
/// <summary>
/// Initialize filed _user.
/// </summary>
/// <param name="route"> Username</param>
private async Task Init(UserRoute route)
{
var request = new HandlerData <UserRoute, User>
{
Data = route
};
_user = await _mediator.Send(request);
}
internal override HandlerData GetHandlerData(Authenticator authenticator, string[] scope, string policy,
TokenCache cache)
{
HandlerData data = base.GetHandlerData(authenticator, scope, policy, cache);
data.ClientKey = new ClientKey(this.ClientId);
return(data);
}
/// <summary>
/// Initialize field _snapshot.
/// </summary>
/// <param name="route">User name, project name and snapshot name.</param>
private async Task Init(SnapshotRoute route)
{
var request = new HandlerData <SnapshotRoute, ProjectSnapshot>
{
Data = route
};
_snapshot = await _mediator.Send(request);
}
/// <summary>
/// Initialize field _project.
/// </summary>
/// <param name="route">User name and project name</param>
private async Task Init(ProjectRoute route)
{
var request = new HandlerData <ProjectRoute, Project>
{
Data = route
};
_project = await _mediator.Send(request);
}
private async Task <AuthenticationResult> AcquireTokenForClientCommonAsync(string[] scope, string policy)
{
Authenticator authenticator = new Authenticator(this.Authority, this.ValidateAuthority, this.CorrelationId);
HandlerData data = this.GetHandlerData(authenticator, scope, policy, this.AppTokenCache);
data.RestrictToSingleUser = false;
var handler = new AcquireTokenForClientHandler(data);
return(await handler.RunAsync());
}
public ContentManager(GameHandlerMetadata info, HandlerData game)
{
this.game = game;
loadedImages = new Dictionary <string, Image>();
handlersFolder = GameManager.Instance.GetInstalledPackagePath();
pkgFolder = PackageManager.GetInstallPath(info);
DefaultImage = new Bitmap(1, 1);
}
public static bool IsNeeded(HandlerData data)
{
return(false);
#if WINDOWS
return(data.SupportsKeyboard);
#else
return(false);
#endif
}
public AcquireTokenNonInteractiveHandler(HandlerData handlerData, UserCredential userCredential)
: base(handlerData)
{
if (userCredential == null)
{
throw new ArgumentNullException("userCredential");
}
this.userCredential = userCredential;
}
/// <summary>
/// Get snapshot file.
/// </summary>
/// <param name="route">User name, project name and snapshot name.</param>
private async Task <FileData> GetFile(SnapshotRoute route)
{
await Init(route);
var request = new HandlerData <ProjectSnapshot, FileData>
{
Data = _snapshot
};
return(await _mediator.Send(request));
}
public override bool Initialize(GameHandler handler, HandlerData handlerData, UserGameInfo game, GameProfile profile)
{
this.handler = handler;
this.userGame = game;
this.profile = profile;
this.handlerData = handlerData;
attached = new List <Process>();
return(true);
}
public ExecutionResult Execute(object handler, RequestContext requestContext, HandlerData handlerData)
{
throw new NotImplementedException();
}
public IResult RunAfter(object filter, RequestContext requestContext, HandlerData handlerData)
{
throw new NotImplementedException();
}
public object Create(HandlerData handlerData)
{
throw new NotImplementedException();
}
