C# Client.Login方法代码示例

        private async void Execute()
        {
            var client = new Client(ClientSettings);

            try
            {

                await client.Login();

                await client.SetServer();
                var inventory = await client.GetInventory();
                var pokemons =
                    inventory.InventoryDelta.InventoryItems.Select(i => i.InventoryItemData?.Pokemon)
                        .Where(p => p != null && p?.PokemonId > 0).OrderByDescending(key => key.Cp);


                foreach (var pokemon in pokemons)
                {
                    ListViewItem lvi = new ListViewItem(pokemon.PokemonId.ToString());
                    listView1.Items.Add(lvi);
                    lvi.SubItems.Add(pokemon.Cp.ToString());
                }
            }
            catch (TaskCanceledException) { ColoredConsoleWrite(Color.Red, "Task Canceled Exception - Restarting"); Execute(); }
            catch (UriFormatException) { ColoredConsoleWrite(Color.Red, "System URI Format Exception - Restarting"); Execute(); }
            catch (ArgumentOutOfRangeException) { ColoredConsoleWrite(Color.Red, "ArgumentOutOfRangeException - Restarting"); Execute(); }
            catch (ArgumentNullException) { ColoredConsoleWrite(Color.Red, "Argument Null Refference - Restarting"); Execute(); }
            catch (NullReferenceException) { ColoredConsoleWrite(Color.Red, "Null Refference - Restarting"); Execute(); }
            catch (Exception ex) { ColoredConsoleWrite(Color.Red, ex.ToString()); Execute(); }
        }

        public void TestSendEvents()
        {
            //var client = new Client("http", "event-fabric.com", 80, "/api/session", "/api/event");
            var client = new Client();
            // login with your username and password in Event Fabric
            var loginResponse = client.Login("demouser", "demouser");

            var productApple = new Product { Name = "Apple", Description = "Argentinian Apple" };
            var productBanana = new Product { Name = "Banana", Description = "Ecuadorian Banana" };

            var olineBillDetailApple = new OnlineBillDetail { Product = productApple, Quantity = 2, UnitPrice = 5.6 };
            var olineBillDetailBanana = new OnlineBillDetail { Product = productBanana, Quantity = 3, UnitPrice = 4.4 };

            var totalPrice = (olineBillDetailBanana.Quantity * olineBillDetailBanana.UnitPrice) +
                             (olineBillDetailApple.Quantity * olineBillDetailApple.UnitPrice);

            var onlineBill = new OnlineBill { AccountNumber = "987654321", TotalPrice = totalPrice };

            onlineBill.OnlineBillDetails.Add(olineBillDetailApple);
            onlineBill.OnlineBillDetails.Add(olineBillDetailBanana);

            // Create event entity with online bill as value of the event
            var _event = new Event("online bill", onlineBill);
            // send the event to Event Fabric
            var response = client.SendEvent(_event, loginResponse.Cookies);

            Assert.AreEqual(201, response.StatusCode);
        }

        public static void Main(string[] args)
        {
            if (args.Length == 0) {
                ServiceLocator locator = new ServiceLocator ();
                locator.Found += OnServiceFound;
                locator.Removed += OnServiceRemoved;
                locator.Start ();
            } else {
                string host = args[0];

                ushort port = 3689;
                if (args.Length > 1)
                    port = UInt16.Parse (args[1]);

                Client client = new Client (host, port);
                client.Login ();
                AddClient (client);
            }

            Console.WriteLine ("Press enter to quit");
            Console.ReadLine ();

            foreach (Client client in clients) {
                client.Logout ();
            }
        }

        public void ShouldPassCorrectAccessToken()
        {
            const string accessToken = "access_token";
            IUsergridRequest request = Helpers.InitializeUserGridRequestWithAccessToken(accessToken);

            var restResponseContent = new UsergridGetResponse<Friend> { Entities = new List<Friend>(), Cursor = "" };
            IRestResponse<UsergridGetResponse<Friend>> restResponse = Helpers.SetUpRestResponseWithContent<UsergridGetResponse<Friend>>(HttpStatusCode.OK, restResponseContent);

            request
                .Execute(Arg.Any<string>(), Arg.Any<Method>(), Arg.Any<object>(), Arg.Any<string>())
                .Returns(restResponse);

            const string collectionName = "collection";
            const string entityName = "entity";

            var client = new Client(null, null, request: request);
            client.Login(null, null, AuthType.ClientId);
            var friend = client.GetEntity<Friend>(collectionName, entityName);
            Assert.IsNull(friend);

            request.Received(1).Execute(
                Arg.Is(string.Format("/{0}/{1}", collectionName, entityName)),
                Arg.Is(Method.GET),
                Arg.Any<object>(),
                accessToken);
        }

        public void ShouldLoginWithApplicationCredentialsWithCorrectRequestBody()
        {
            var restResponse = Substitute.For<IRestResponse<LoginResponse>>();
            restResponse.StatusCode.Returns(HttpStatusCode.OK);
            restResponse.Data.Returns(new LoginResponse { AccessToken = "access_token" });

            var request = Substitute.For<IUsergridRequest>();
            request
                .Execute<LoginResponse>(Arg.Any<string>(), Arg.Any<Method>(), Arg.Any<object>(), Arg.Any<string>())
                .Returns(restResponse);

            const string clientLoginId = "client_login_id";
            const string clientSecret = "client_secret";

            var client = new Client(null, null, request: request);
            client.Login(clientLoginId, clientSecret, AuthType.ClientId);

            request
                .Received(1)
                .Execute<LoginResponse>(
                    Arg.Any<string>(),
                    Arg.Any<Method>(),
                    Arg.Is<ClientIdLoginPayload>(d => d.GrantType == "client_credentials" && d.ClientId == clientLoginId && d.ClientSecret == clientSecret),
                    Arg.Any<string>());
        }

        public void ShouldLoginWithClientCredentialsAndSetTheAccessToken()
        {
            var client = new Client(Organization, Application);
            client.Login(ClientId, ClientSecret, AuthType.ClientId);

            Assert.IsFalse(string.IsNullOrEmpty(client.AccessToken));
        }

        public void LoginShouldDelegateToAuthenticationManagerWithCorrectParameters(string login, string secret, AuthType authType)
        {
            var authenticationManager = Substitute.For<IAuthenticationManager>();

            var client = new Client(null, null) {AuthenticationManager = authenticationManager};

            client.Login(login, secret, authType);

            authenticationManager.Received(1).Login(login, secret, authType);
        }

        public void LoginShouldDelegateToAuthenticationManager()
        {
            var authenticationManager = Substitute.For<IAuthenticationManager>();

            var client = new Client(null, null) {AuthenticationManager = authenticationManager};

            client.Login(null, null, AuthType.None);

            authenticationManager.Received(1).Login(null, null, AuthType.None);
        }

        public void LoginShouldPassOnTheException()
        {
            var authenticationManager = Substitute.For<IAuthenticationManager>();
            authenticationManager
                .When(m => m.Login(null, null, AuthType.None))
                .Do(m => { throw new UsergridException(new UsergridError {Description = "Exception message"}); });


            var client = new Client(null, null) {AuthenticationManager = authenticationManager};
            client.Login(null, null, AuthType.None);
        }

        public void TestSendEvents()
        {
            var client = new Client("http", "event-fabric.com", 80, "/api/session", "/api/event");
            var loginResponse = client.Login("demouser", "demouser");
            Assert.AreEqual(System.Net.HttpStatusCode.Created, Enum.Parse(typeof(System.Net.HttpStatusCode), loginResponse.StatusCode.ToString()));

            for (int i = 0; i < 3; i++) {
                var value = new Value (i, string.Format ("Text is {0}", i));
                var @event = new Event ("your.channel", value);
                var response = client.SendEvent(@event, loginResponse.Cookies);
                Assert.AreEqual(System.Net.HttpStatusCode.Created, Enum.Parse(typeof(System.Net.HttpStatusCode), response.StatusCode.ToString()));
            }
        }

        public void ShouldThrowWithInvalidUserCredentials()
        {
            var client = new Client(Organization, Application);

            try
            {
                client.Login("Invalid_User_Name", "Invalid_Password", AuthType.User);
                Assert.True(true, "Was expecting login to throw UserGridException");
            }
            catch (UsergridException e)
            {
                Assert.That(e.ErrorCode, Is.EqualTo("invalid_grant"));
            }
        }

		public void ShouldDoPaging()
		{
			var client = new Client(Organization, Application);
			client.Login(ClientId, ClientSecret, AuthType.Organization);

			for (var i=0; i<20; i++) 
			{
				try{
					client.DeleteEntity ("pages", "page-" + i);
					Console.WriteLine ("Deleted " + i);
				} catch (UsergridException) {
				}
			}

			for (var i=0; i<20; i++) 
			{
				var page = new Page { PageNumber = i, Name = "page-" + i };
				client.CreateEntity ("pages", page);
				Console.WriteLine ("Created " + i);
			}
      

			var collection = client.GetEntities<Page> ("pages", 3);
			Assert.AreEqual (3, collection.Count);
			Assert.IsTrue (collection.HasNext);
			Assert.IsFalse (collection.HasPrevious);
			Assert.AreEqual ("page-1", collection [1].Name);

			collection = client.GetNextEntities<Page> ("pages");
			Assert.IsTrue (collection.HasNext);
			Assert.IsTrue (collection.HasPrevious);
			Assert.AreEqual ("page-4", collection [1].Name);

			collection = client.GetNextEntities<Page> ("pages");
			Assert.IsTrue (collection.HasNext);
			Assert.IsTrue (collection.HasPrevious);
			Assert.AreEqual ("page-7", collection [1].Name);

			collection = client.GetPreviousEntities<Page> ("pages");
			Assert.IsTrue (collection.HasNext);
			Assert.IsTrue (collection.HasPrevious);
			Assert.AreEqual ("page-4", collection [1].Name);

			for (var i=0; i<20; i++) 
			{
				client.DeleteEntity ("pages", "page-" + i);
				Console.WriteLine ("Deleted " + i);
			}
		}

        public void ShouldNotPassAccessTokenWhenLoggingIn()
        {
            var restResponse = Substitute.For<IRestResponse<LoginResponse>>();
            restResponse.StatusCode.Returns(HttpStatusCode.OK);
            restResponse.Data.Returns(new LoginResponse { AccessToken = "access_token" });

            var request = Substitute.For<IUsergridRequest>();
            request
                .Execute<LoginResponse>(Arg.Any<string>(), Arg.Any<Method>(), Arg.Any<object>(), Arg.Any<string>())
                .Returns(restResponse);

            var client = new Client(null, null, request: request);
            client.Login(null, null, AuthType.ClientId);

            request.Received(1).Execute<LoginResponse>(Arg.Any<string>(), Arg.Any<Method>(), Arg.Any<object>(), Arg.Is((string)null));
        }

 public static void FindFailedToDeployConnectors()
 {
     var client = new Client(ClientUrl, timeout: int.MaxValue);
     var loginStatus = client.Login(ClientUsername, ClientPassword, "0.0.0");
     var channelStatusList = client.GetChannelStatusList().DashboardStatuses;
     foreach (var item in channelStatusList.OrderBy(x => x.Name))
     {
         Console.Write("{0} deployed with {1} connectors. ", item.Name.MaxOrPad(30), item.ChildStatuses.DashboardStatuses.Count);
         var channelId = item.ChannelId;
         var channel = client.GetChannels(channelId).Channels.Single();
         var connectors = channel.GetAllEnabledConnectors();
         if (connectors.Count != item.ChildStatuses.DashboardStatuses.Count)
         {
             Console.Write("WARNING: Found {0} configured connectors!", connectors.Count);
             Console.Error.Write("WARNING: Found {0} configured connectors!", connectors.Count);
         }
         Console.WriteLine();
     }
     client.Logout();
 }

 public static void TestMessageSearch()
 {
     var client = new Client(ClientUrl, timeout: int.MaxValue);
     try
     {
         var sw = Stopwatch.StartNew();
         var loginStatus = client.Login(ClientUsername, ClientPassword, "0.0.0");
         var channel = client.GetChannels("d24f9ca7-d696-4ffd-b86e-484669213fa8").Channels[0];
         Console.WriteLine("Loaded Channel [{0}] in {1}ms ", channel.Name, sw.Elapsed.TotalMilliseconds.ToString("N2"));
         Console.WriteLine("Found {0} metadata columns: {1}", channel.Properties.MetaDataColumns.Items.Count, string.Join(",", channel.Properties.MetaDataColumns.Items.Select(x => x.Name).ToArray()));
         sw.Restart();
         var maxMessageId = client.GetMaxMessageId(channel.Id);
         var filter = new MessageFilter()
         {
             MaxMessageId = maxMessageId,
             //Statuses = new List<string>() { "ERROR" },
             //EndDate = DateTime.Now.Date.AddDays(-7),
             MetaDataSearch = new List<MetaDataSearchCriteria>
             {
                 new MetaDataSearchCriteria
                 {
                     ColumnName = "PATIENT_ID",
                     Value = new MetaDataSearchCriteriaValue("00556249"),
                     Operator = MetaDataSearchOperator.STARTS_WITH,
                     IgnoreCase = "true",
                 },
             },
             MinMessageId = 896930,
         };
         var messageCount = client.GetMessageCount(channel.Id, filter);
         Console.WriteLine("Counted {0} messages in {1}ms", messageCount, sw.Elapsed.TotalMilliseconds.ToString("N2"));
         sw.Restart();
         var messages_nocontent = client.GetMessages(channel.Id, filter, false, 0, 51);
         Console.WriteLine("Loaded {0} messages in {1}ms", messages_nocontent.Messages.Count, sw.Elapsed.TotalMilliseconds.ToString("N2"));
         var messages_rows = messages_nocontent.Messages.SelectMany(x => x.AsFlatMessageRows()).ToArray();
     }
     finally
     {
         client.Logout();
     }
 }