/// <summary> /// Gets details of a single <see cref="Contact"/> Graph. /// </summary> /// <returns>A view with the details of a single <see cref="Contact"/>.</returns> public ActionResult Details(string objectId) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } // Setup Graph API connection and get single Contact Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(accessToken, ClientRequestId, graphSettings); Contact contact = graphConnection.Get <Contact>(objectId); return(View(contact)); }
public GraphModel(DocumentClient client, DocumentCollection collection) { this.client = client; this.collection = collection; this.graphConnection = new GraphConnection(client, collection); this.graphCommand = new GraphCommand(this.graphConnection); }
public ActionResult Delete(User user) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // Setup Graph API connection and delete User var clientRequestId = Guid.NewGuid(); var graphSettings = new GraphSettings { ApiVersion = GraphConfiguration.GraphApiVersion }; var graphConnection = new GraphConnection(accessToken, clientRequestId, graphSettings); graphConnection.Delete(user); return(RedirectToAction("Index")); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View(user)); } }
static int Main(string[] args) { var connection = new GraphConnection(); if (args.Length < 1) { PrintUsage(); return(1); } string responseContent; try { responseContent = connection.InvokeRequestAndDeserialize(args[0]); } catch (GraphHttpException exception) { Console.Error.WriteLine("Request failed with status code {0}", exception.StatusCode); Console.Error.WriteLine(exception.Message); return(1); } Console.WriteLine(responseContent); return(0); }
public ActionResult Create([Bind(Include = "DisplayName,Description,MailNickName,SecurityEnabled")] Group group) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // Setup Graph API connection and add Group Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(accessToken, ClientRequestId, graphSettings); group.MailEnabled = false; graphConnection.Add(group); return(RedirectToAction("Index")); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } }
/// <summary> /// Gets a list of <see cref="User"/> objects that a given <see cref="User"/> has as a direct report. /// </summary> /// <param name="objectId">Unique identifier of the <see cref="User"/>.</param> /// <returns>A view with the list of <see cref="User"/> objects.</returns> public ActionResult GetDirectReports(string objectId) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } // Setup Graph API connection and get Group membership Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(accessToken, ClientRequestId, graphSettings); GraphObject graphUser = graphConnection.Get <User>(objectId); IList <GraphObject> results = graphConnection.GetAllDirectLinks(graphUser, LinkProperty.DirectReports); IList <User> reports = new List <User>(); foreach (GraphObject obj in results) { if (obj is User) { User user = (User)obj; reports.Add(user); } } return(View(reports)); }
public ActionResult Create([Bind(Include = "UserPrincipalName,AccountEnabled,PasswordProfile,MailNickname,DisplayName,GivenName,Surname,JobTitle,Department")] User user) { //Get the access token as we need it to make a call to the Graph API var accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // Setup Graph API connection and add User var clientRequestId = Guid.NewGuid(); var graphSettings = new GraphSettings { ApiVersion = GraphConfiguration.GraphApiVersion }; var graphConnection = new GraphConnection(accessToken, clientRequestId, graphSettings); graphConnection.Add(user); return(RedirectToAction("Index")); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } }
// GET: UserProfile public ActionResult Index() { string clientId = ConfigurationManager.AppSettings["ida:ClientID"]; string appKey = ConfigurationManager.AppSettings["ida:Password"]; string graphResourceID = "https://graph.windows.net"; string signedInUserID = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value; string tenantID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value; string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value; try { // get a token for the Graph without triggering any user interaction (from the cache, via multi-resource refresh token, etc) ClientCredential clientcred = new ClientCredential(clientId, appKey); // initialize AuthenticationContext with the token cache of the currently signed in user, as kept in the app's EF DB AuthenticationContext authContext = new AuthenticationContext(string.Format("https://login.windows.net/{0}", tenantID), new EFADALTokenCache(signedInUserID)); AuthenticationResult result = authContext.AcquireTokenSilent(graphResourceID, clientcred, new UserIdentifier(userObjectID, UserIdentifierType.UniqueId)); // use the token for querying the graph GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = "2013-11-08"; graphSettings.GraphDomainName = "graph.windows.net"; Guid ClientRequestId = Guid.NewGuid(); GraphConnection graphConnection = new GraphConnection(result.AccessToken, ClientRequestId, graphSettings); User user = graphConnection.Get <User>(userObjectID); return(View(user)); } // if the above failed, the user needs to explicitly re-authenticate for the app to obtain the required token catch (Exception ee) { ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } }
public void Test() { var connection = new GraphConnection <int>(); connection.AddPredecessor(1); Assert.True(connection.IsPredecessors(1)); Assert.True(connection.RemovePredecessor(1)); Assert.False(connection.IsPredecessors(1)); connection.AddSuccessor(1); Assert.True(connection.IsSuccessors(1)); Assert.True(connection.RemoveSuccessor(1)); Assert.False(connection.IsSuccessors(1)); connection.AddPredecessor(1); connection.AddSuccessor(1); Assert.True(connection.IsPredecessors(1)); Assert.True(connection.IsSuccessors(1)); Assert.True(connection.RemovePredecessor(1)); Assert.False(connection.IsPredecessors(1)); connection.AddPredecessor(1); Assert.True(connection.RemoveSuccessor(1)); Assert.False(connection.IsSuccessors(1)); Assert.True(connection.RemovePredecessor(1)); Assert.False(connection.RemovePredecessor(1)); Assert.False(connection.RemoveSuccessor(1)); }
public override void OnTapUp(float x, float y) { if (IsInConnector(x, y, parentNode.Width) && Graph.currentlyInteractingNode != null && Graph.currentlyInteractingRow != -1) { var newConnection = new GraphConnection(); if (this is OutputRow) { newConnection.source = parentNode; newConnection.sourceRow = parentNode.Rows.FindIndex(r => r == this); newConnection.sink = Graph.currentlyInteractingNode; newConnection.sinkRow = Graph.currentlyInteractingRow; } else if (this is InputRow) { newConnection.source = Graph.currentlyInteractingNode; newConnection.sourceRow = Graph.currentlyInteractingRow; newConnection.sink = parentNode; newConnection.sinkRow = parentNode.Rows.FindIndex(r => r == this); } if (!parentNode.parentGraph.connections.Exists(c => c.Equals(newConnection)) && ConnectionFilter(newConnection)) { parentNode.parentGraph.connections.Add(newConnection); } } }
public void TestClone() { BuildCyclicGraph(); Graph <String> dup = (Graph <String>)Graph.Clone(); Assert.IsTrue(ListsAreEqual(Graph.Nodes, dup.Nodes)); Assert.AreEqual(dup.Weights.Count, Graph.Weights.Count); foreach (GraphNode <String> sourceKeyNode in dup.Weights.Keys) { Assert.IsTrue(Graph.Weights.ContainsKey(sourceKeyNode)); Assert.AreEqual(dup.Weights[sourceKeyNode].Count, Graph.Weights[sourceKeyNode].Count); foreach (GraphNode <String> destinationKeyNode in dup.Weights[sourceKeyNode].Keys) { Assert.IsTrue(Graph.Weights[sourceKeyNode].ContainsKey(destinationKeyNode)); Assert.AreEqual(dup.Weights[sourceKeyNode][destinationKeyNode].Count, Graph.Weights[sourceKeyNode][destinationKeyNode].Count); for (Int32 i = 0; i < dup.Weights[sourceKeyNode][destinationKeyNode].Count; ++i) { GraphConnection <String> dupConnection = dup.Weights[sourceKeyNode][destinationKeyNode][i]; GraphConnection <String> graphConnection = Graph.Weights[sourceKeyNode][destinationKeyNode][i]; Assert.AreEqual(dupConnection.Weight, graphConnection.Weight, WEIGHT_TOLERANCE); } } } }
/// <summary> /// Splits a list of borders into clusters, where in each cluster the borders are connected /// </summary> public static List <List <GraphConnection> > FindBorderClusters(List <GraphConnection> borders) { List <List <GraphConnection> > clusters = new List <List <GraphConnection> >(); List <GraphConnection> bordersWithoutCluster = new List <GraphConnection>(); bordersWithoutCluster.AddRange(borders); while (bordersWithoutCluster.Count > 0) { List <GraphConnection> cluster = new List <GraphConnection>(); Queue <GraphConnection> bordersToAdd = new Queue <GraphConnection>(); bordersToAdd.Enqueue(bordersWithoutCluster[0]); while (bordersToAdd.Count > 0) { GraphConnection borderToAdd = bordersToAdd.Dequeue(); cluster.Add(borderToAdd); List <GraphConnection> connectedBorders = borderToAdd.Connections.Where(x => borders.Contains(x)).ToList(); foreach (GraphConnection connectedBorder in connectedBorders) { if (!cluster.Contains(connectedBorder) && !bordersToAdd.Contains(connectedBorder)) { bordersToAdd.Enqueue(connectedBorder); } } } clusters.Add(cluster); foreach (GraphConnection border in cluster) { bordersWithoutCluster.Remove(border); } } return(clusters); }
/// <summary> /// Gets a list of <see cref="Contact"/> objects from Graph. /// </summary> /// <returns>A view with the list of <see cref="Contact"/> objects.</returns> public ActionResult Index() { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } //Setup Graph API connection and get a list of users Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(accessToken, ClientRequestId, graphSettings); PagedResults <Contact> pagedResults = graphConnection.List <Contact>(null, new FilterGenerator()); return(View(pagedResults.Results)); }
/// <summary> /// Creates a view to for editing an existing <see cref="User"/> in Graph. /// </summary> /// <param name="objectId">Unique identifier of the <see cref="User"/>.</param> /// <returns>A view with details to edit <see cref="User"/>.</returns> public ActionResult Edit(string objectId) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } // Setup Graph API connection and get single User var clientRequestId = Guid.NewGuid(); var graphSettings = new GraphSettings { ApiVersion = GraphConfiguration.GraphApiVersion }; var graphConnection = new GraphConnection(accessToken, clientRequestId, graphSettings); var user = graphConnection.Get <User>(objectId); return(View(user)); }
/// <summary> /// Creates a view to delete an existing <see cref="User"/>. /// </summary> /// <param name="objectId">Unique identifier of the <see cref="User"/>.</param> /// <returns>A view of the <see cref="User"/> to be deleted.</returns> public ActionResult Delete(string objectId) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // Setup Graph API connection and get single User Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(accessToken, ClientRequestId, graphSettings); User user = graphConnection.Get <User>(objectId); return(View(user)); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } }
public AzureADGraphConnection(string tenantName, string clientId, string clientSecret) { var authenticationContext = new AuthenticationContext("https://login.windows.net/" + tenantName, false); var clientCred = new ClientCredential(clientId, clientSecret); var token = authenticationContext.AcquireToken(Resource, clientCred).AccessToken; _graphConnection = new GraphConnection(token, ClientRequestId); }
public ActionResult Create([Bind(Include = "DisplayName,Description,MailNickName,SecurityEnabled")] Group group) { //Get the access token as we need it to make a call to the Graph API AuthenticationResult result = null; try { // Get the access token from the cache string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value; AuthenticationContext authContext = new AuthenticationContext(Startup.Authority, new NaiveSessionCache(userObjectID)); ClientCredential credential = new ClientCredential(clientId, appKey); result = authContext.AcquireTokenSilent(graphResourceId, credential, new UserIdentifier(userObjectID, UserIdentifierType.UniqueId)); } catch (Exception e) { if (Request.QueryString["reauth"] == "True") { // // Send an OpenID Connect sign-in request to get a new set of tokens. // If the user still has a valid session with Azure AD, they will not be prompted for their credentials. // The OpenID Connect middleware will return to this controller after the sign-in response has been handled. // HttpContext.GetOwinContext().Authentication.Challenge(OpenIdConnectAuthenticationDefaults.AuthenticationType); } // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // Setup Graph API connection and add Group Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; if (result != null) { GraphConnection graphConnection = new GraphConnection(result.AccessToken, ClientRequestId, graphSettings); group.MailEnabled = false; graphConnection.Add(group); return(RedirectToAction("Index")); } } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); }
public IEnumerable <User> GetUsersInGroup(string accessToken, string groupId) { CallContext currentCallContext = new CallContext(accessToken, Guid.NewGuid()); GraphConnection graphConnection = new GraphConnection(currentCallContext); var fieldAgentsGroup = graphConnection.Get <Group>(groupId); var fieldAgentMembers = graphConnection.GetLinks(fieldAgentsGroup, "members", null); return(fieldAgentMembers.Results.OfType <User>()); }
public ActionResult Users() { // get the tenantName var tenantId = ClaimsPrincipal.Current.FindFirst(ClaimType).Value; var authenticationContext = new AuthenticationContext( string.Format(AuthString, tenantId), false); authenticationContext.TokenCacheStore.Clear(); // retrieve the clientId and password from the Web.config file var clientId = ConfigurationManager.AppSettings["ClientId"]; var clientSecret = ConfigurationManager.AppSettings["Password"]; // create the credentials and get a token var clientCred = new ClientCredential(clientId, clientSecret); try { var token = authenticationContext.AcquireToken(Resource, clientCred).AccessToken; if (!string.IsNullOrEmpty(token)) { var graphSettings = new GraphSettings { ApiVersion = "2013-11-08", GraphDomainName = "graph.windows.net" }; // get tenant information var graphConnection = new GraphConnection(token, graphSettings); var tenant = graphConnection.Get(typeof(TenantDetail), tenantId); if (tenant != null) { var tenantDetail = (TenantDetail)tenant; ViewBag.OtherMessage = "User List from tenant: " + tenantDetail.DisplayName; } // get the list of users var pagedReslts = graphConnection.List <User>(null, new FilterGenerator()); return(this.View(pagedReslts.Results)); } } catch (ActiveDirectoryAuthenticationException ex) { ViewBag.OtherMessage = string.Format("Acquiring a token failed with the following error: {0}", ex.Message); } catch (AuthorizationException e) { ViewBag.OtherMessage = string.Format("Failed to return the list of Users with Exception: {0}", e.ErrorMessage); } return(this.View()); }
/// <summary> /// Gets a list of <see cref="User"/> objects that are members of a give <see cref="Role"/>. /// </summary> /// <param name="objectId">Unique identifier of the <see cref="Role"/>.</param> /// <returns>A view with the list of <see cref="User"/> objects.</returns> public ActionResult GetMembers(string objectId) { //Get the access token as we need it to make a call to the Graph API AuthenticationResult result = null; IList <User> users = new List <User>(); try { // Get the access token from the cache string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value; AuthenticationContext authContext = new AuthenticationContext(Startup.Authority, new NaiveSessionCache(userObjectID)); ClientCredential credential = new ClientCredential(clientId, appKey); result = authContext.AcquireTokenSilent(graphResourceId, credential, new UserIdentifier(userObjectID, UserIdentifierType.UniqueId)); // Setup Graph API connection and get a list of roles Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(result.AccessToken, ClientRequestId, graphSettings); Role role = graphConnection.Get <Role>(objectId); IList <GraphObject> members = graphConnection.GetAllDirectLinks(role, LinkProperty.Members); // Filter for users foreach (GraphObject obj in members) { if (obj is User) { users.Add((User)obj); } } } catch (Exception e) { if (Request.QueryString["reauth"] == "True") { // // Send an OpenID Connect sign-in request to get a new set of tokens. // If the user still has a valid session with Azure AD, they will not be prompted for their credentials. // The OpenID Connect middleware will return to this controller after the sign-in response has been handled. // HttpContext.GetOwinContext().Authentication.Challenge(OpenIdConnectAuthenticationDefaults.AuthenticationType); } // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } return(View(users)); }
/// <summary> /// Creates a view to for adding a key credential to an existing <see cref="Application"/> in Graph. /// </summary> /// <param name="objectId">Unique identifier of the <see cref="Application"/>.</param> /// <returns>A view with details to add a key to the <see cref="Application"/>.</returns> public ActionResult AddKey(string objectId) { //Get the access token as we need it to make a call to the Graph API AuthenticationResult result = null; Application app = null; try { // Get the access token from the cache string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value; AuthenticationContext authContext = new AuthenticationContext(Startup.Authority, new NaiveSessionCache(userObjectID)); ClientCredential credential = new ClientCredential(clientId, appKey); result = authContext.AcquireTokenSilent(graphResourceId, credential, new UserIdentifier(userObjectID, UserIdentifierType.UniqueId)); //Setup Graph API connection and get a list of groups Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(result.AccessToken, ClientRequestId, graphSettings); app = graphConnection.Get <Application>(objectId); } catch (Exception e) { if (Request.QueryString["reauth"] == "True") { // // Send an OpenID Connect sign-in request to get a new set of tokens. // If the user still has a valid session with Azure AD, they will not be prompted for their credentials. // The OpenID Connect middleware will return to this controller after the sign-in response has been handled. // HttpContext.GetOwinContext().Authentication.Challenge(OpenIdConnectAuthenticationDefaults.AuthenticationType); } // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } KeyCredential key = new KeyCredential(); key.KeyId = System.Guid.NewGuid(); key.Type = "Symmetric"; key.Usage = "Verify"; String keyValue = "VSoJ0xLgSyQv60M+mJCtJOMM6yflDz5pLnAVNzGT6do="; byte[] keyBytes = System.Text.Encoding.ASCII.GetBytes(keyValue); key.Value = keyBytes; app.KeyCredentials.Add(key); return(View(app)); }
public ActionResult Edit([Bind(Include = "ObjectId,UserPrincipalName,DisplayName,AccountEnabled,GivenName,Surname,JobTitle,Department,Mobile,StreetAddress,City,State,Country,")] User user, FormCollection values) { //Get the access token as we need it to make a call to the Graph API string accessToken = AuthUtils.GetAuthToken(Request, HttpContext); if (accessToken == null) { // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // TODO: Add update logic here // Setup Graph API connection and update single User var clientRequestId = Guid.NewGuid(); var graphSettings = new GraphSettings { ApiVersion = GraphConfiguration.GraphApiVersion }; var graphConnection = new GraphConnection(accessToken, clientRequestId, graphSettings); graphConnection.Update(user); // update thumbnail photo if (!String.IsNullOrEmpty(values["photofile"])) { //string path = AppDomain.CurrentDomain.BaseDirectory + "uploads/"; //string filename = Path.GetFileName(values["photofile"]); //Image image = Image.FromFile(filename); var imageFile = Path.Combine(Server.MapPath("~/app_data"), values["photofile"]); var image = Image.FromFile(imageFile); var stream = new MemoryStream(); image.Save(stream, ImageFormat.Jpeg); // Write the photo file to the Graph service. graphConnection.SetStreamProperty(user, GraphProperty.ThumbnailPhoto, stream, "image/jpeg"); } return(RedirectToAction("Index")); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } }
/// <summary> /// Gets a list of <see cref="Contact"/> objects from Graph. /// </summary> /// <returns>A view with the list of <see cref="Contact"/> objects.</returns> public ActionResult Index() { //Get the access token as we need it to make a call to the Graph API AuthenticationResult result = null; List <Contact> contactList = new List <Contact>(); try { // Get the access token from the cache string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value; AuthenticationContext authContext = new AuthenticationContext(Startup.Authority, new NaiveSessionCache(userObjectID)); ClientCredential credential = new ClientCredential(clientId, appKey); result = authContext.AcquireTokenSilent(graphResourceId, credential, new UserIdentifier(userObjectID, UserIdentifierType.UniqueId)); // Setup Graph API connection and get a list of users Guid ClientRequestId = Guid.NewGuid(); GraphSettings graphSettings = new GraphSettings(); graphSettings.ApiVersion = GraphConfiguration.GraphApiVersion; GraphConnection graphConnection = new GraphConnection(result.AccessToken, ClientRequestId, graphSettings); // Get all results into a list PagedResults <Contact> pagedResults = graphConnection.List <Contact>(null, new FilterGenerator()); contactList.AddRange(pagedResults.Results); while (!pagedResults.IsLastPage) { pagedResults = graphConnection.List <Contact>(pagedResults.PageToken, new FilterGenerator()); contactList.AddRange(pagedResults.Results); } } catch (Exception e) { if (Request.QueryString["reauth"] == "True") { // // Send an OpenID Connect sign-in request to get a new set of tokens. // If the user still has a valid session with Azure AD, they will not be prompted for their credentials. // The OpenID Connect middleware will return to this controller after the sign-in response has been handled. // HttpContext.GetOwinContext().Authentication.Challenge(OpenIdConnectAuthenticationDefaults.AuthenticationType); } // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } return(View(contactList)); }
private static bool UserIsMemberOfGroup(GraphConnection graphConnection, string userUPN, string groupDisplayName) { // Get the group for which we want to check membership FilterGenerator filter = new FilterGenerator(); Expression filterExpression = ExpressionHelper.CreateEqualsExpression(typeof(Group), GraphProperty.DisplayName, groupDisplayName); filter.QueryFilter = filterExpression; PagedResults <Group> groupToCheckResults = graphConnection.List <Group>(null, filter); if (groupToCheckResults.Results.Count == 1) { // Add group to our groups to check list Group groupToCheck = groupToCheckResults.Results[0] as Group; IList <String> groupsList = new List <string>(); groupsList.Add(groupToCheck.ObjectId); // Get the user for which we want to check the group membership FilterGenerator userFilter = new FilterGenerator(); Expression userFilterExpression = ExpressionHelper.CreateEqualsExpression(typeof(User), GraphProperty.UserPrincipalName, userUPN); userFilter.QueryFilter = userFilterExpression; User retrievedUser = new User(); PagedResults <User> pagedUserResults = graphConnection.List <User>(null, userFilter); if (pagedUserResults.Results.Count == 1) { retrievedUser = pagedUserResults.Results[0] as User; // Check if the user belongs to any of the passed groups IList <String> memberships = graphConnection.CheckMemberGroups(retrievedUser, groupsList); // If the passed group is returned back then the user is a member if (memberships.Contains(groupToCheck.ObjectId)) { return(true); } else { return(false); } } else { throw new ArgumentException(String.Format("Group {0} does not exist", groupDisplayName)); } } else { throw new ArgumentException(String.Format("User {0} does not exist", userUPN)); } }
public List <String> GetUsersInGroup(string accessToken, string groupId) { CallContext currentCallContext = new CallContext(accessToken, Guid.NewGuid()); GraphConnection graphConnection = new GraphConnection(currentCallContext); var fieldAgentsGroup = graphConnection.Get <Group>(groupId); var fieldAgentMembers = graphConnection.GetLinks(fieldAgentsGroup, "members", null); var fieldAgents = fieldAgentMembers.Results.OfType <User>(); List <String> agentIds = new List <string>(); foreach (User user in fieldAgents) { agentIds.Add(user.ObjectId); } return(agentIds); }
public void Initialize(ClaimsPrincipal p) { var authContext = new AuthenticationContext(String.Format(CultureInfo.InvariantCulture, LoginUrl, GetTenantIdFromClaimsPrincipal(p))); var credential = new ClientCredential(ClientId, ClientSecret); AuthenticationResult authenticationResult = authContext.AcquireToken(GraphUrl, credential); string token = authenticationResult.AccessToken; var callContext = new CallContext(token, Guid.NewGuid(), "1.21-preview"); _graphConnection = new GraphConnection(callContext); }
public void Init(GraphConnection connection) { Connection = connection; StartPoint = Connection.StartNode.BorderPoint; EndPoint = Connection.EndNode.BorderPoint; Regions = Connection.Polygons.Select(x => x.Region).ToList(); Center = new Vector2((StartPoint.Position.x + EndPoint.Position.x) / 2, (StartPoint.Position.y + EndPoint.Position.y) / 2); Length = Vector2.Distance(StartPoint.Position, EndPoint.Position); Angle = Vector2.SignedAngle((EndPoint.Position - StartPoint.Position), new Vector2(1, 0)); this.transform.position = new Vector3(Center.x, BorderHeight * 0.5f, Center.y); this.transform.rotation = Quaternion.Euler(0, Angle, 0); this.transform.localScale = new Vector3(Length, BorderHeight, BorderWidth); }
/// <summary> /// GraphConnection is done based on application parameters. The connection is not based on any /// particular user. /// </summary> /// <returns></returns> private static GraphConnection BuildGraphConnectionForApplication() { var clientId = ConfigurationManager.AppSettings.Get("ida:ClientID"); var clientSecret = ConfigurationManager.AppSettings.Get("ida:Password"); var clientCred = new ClientCredential(clientId, clientSecret); var authorityDomain = ConfigurationManager.AppSettings.Get("ida:AuthorityDomain"); // custom appSetting in web.config - <add key="ida:AuthorityDomain" value="pragmaticazure.com" /> Debug.Assert(!String.IsNullOrWhiteSpace(authorityDomain)); var authorityUrl = String.Format(AadAuthorityUrlTemplate, authorityDomain); var authenticationContext = new AuthenticationContext(authorityUrl); var authenticationResult = authenticationContext.AcquireToken(GraphUrl, clientCred); var callContext = new CallContext(authenticationResult.AccessToken, Guid.NewGuid(), GraphApiVersion); var graphConnection = new GraphConnection(callContext); return(graphConnection); }
static void Main(string[] args) { try { // get OAuth token using Client Credentials string authString = "https://login.windows.net/" + ConfigurationManager.AppSettings["TenantName"]; AuthenticationContext authenticationContext = new AuthenticationContext(authString, false); // Config for OAuth client credentials ClientCredential clientCred = new ClientCredential(ConfigurationManager.AppSettings["AzureADClientId"], ConfigurationManager.AppSettings["AzureADClientSecret"]); string resource = "https://graph.windows.net"; string token = String.Empty; // Authenticate AuthenticationResult authenticationResult = authenticationContext.AcquireToken(resource, clientCred); token = authenticationResult.AccessToken; // setup Graph connection GraphConnection graphConnection = SetupGraphConnection(token); // Check group memberships. Pass along UPN of user and displayname of // the group to be checked. API support checking multiple groups at once Test(graphConnection, "*****@*****.**", "executives"); Test(graphConnection, "*****@*****.**", "executives"); Test(graphConnection, "*****@*****.**", "employees"); Console.WriteLine("Press enter to continue..."); Console.ReadLine(); } catch (AuthenticationException ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Acquiring a token failed with the following error: {0}", ex.Message); if (ex.InnerException != null) { //You should implement retry and back-off logic per the guidance given here:http://msdn.microsoft.com/en-us/library/dn168916.aspx //InnerException Message will contain the HTTP error status codes mentioned in the link above Console.WriteLine("Error detail: {0}", ex.InnerException.Message); } Console.ResetColor(); Console.ReadKey(); return; } }
public ActionResult Edit([Bind(Include = "ObjectId,UserPrincipalName,DisplayName,City,Department")] User user) { string accessToken = null; string tenantId = ClaimsPrincipal.Current.FindFirst(TenantIdClaimType).Value; if (tenantId != null) { accessToken = TokenCacheUtils.GetAccessTokenFromCacheOrRefreshToken(tenantId, graphResourceId); } if (accessToken == null) { // // If refresh is set to true, the user has clicked the link to be authorized again. // if (Request.QueryString["reauth"] == "True") { // Send an OpenID Connect sign-in request to get a new set of tokens. // If the user still has a valid session with Azure AD, they will not be prompted for their credentials. // The OpenID Connect middleware will return to this controller after the sign-in response has been handled. // HttpContext.GetOwinContext().Authentication.Challenge(OpenIdConnectAuthenticationDefaults.AuthenticationType); } // // The user needs to re-authorize. Show them a message to that effect. // ViewBag.ErrorMessage = "AuthorizationRequired"; return(View()); } try { // TODO: Add update logic here CallContext currentCallContext = new CallContext( accessToken, Guid.NewGuid(), graphApiVersion); GraphConnection graphConnection = new GraphConnection(currentCallContext); graphConnection.Update(user); return(RedirectToAction("Index")); } catch (Exception exception) { ModelState.AddModelError("", exception.Message); return(View()); } }
protected override void AddInitialCell(CPos location) { var cost = heuristic(location); Graph[location] = new CellInfo(0, cost, location, CellStatus.Open); var connection = new GraphConnection(location, cost); OpenQueue.Add(connection); StartPoints.Add(connection); considered.AddLast(new Pair<CPos, int>(location, 0)); }