Example #1
0
 public static void AddLargeImage(JsonServiceClient client)
 {
     Console.WriteLine("Getting image");
     var fp = client.Post(new FloorPlanRequestDto.FloorplanAdd {BluePrintId = 1, Floor = RandomGenerator.Integer(10000), FloorDesc = "1"});
     Console.WriteLine(string.Format("Added image id is {0}", fp.Id));
     var image = Image.FromFile(LargeImageLocation);
     string base64 = Convert.ToBase64String(image.ImageToByteArray());
     Console.WriteLine("Sending image...");
     var resp = client.Post(new FloorPlanRequestDto.FloorplanAddImage {FloorplanId = fp.Id, Image = base64});
     Console.WriteLine("Message: {0}\nMessage: {1}\nResponse Status: {2}", resp.Result, resp.Message, resp.ResponseStatus);
     Console.ReadLine();
 }
        public void Test_GET_two_PASS()
        {
            var restClient = new JsonServiceClient(serviceUrl);

            var newemp1 = new Employee() { Id = 1, Name = "Joe", StartDate = new DateTime(2015, 1, 2), };
            var newemp2 = new Employee() { Id = 2, Name = "Julie", StartDate = new DateTime(2012, 12, 2), };
            restClient.Post<object>("/employees", newemp1);
            restClient.Post<object>("/employees", newemp2);

            var emps = restClient.Get<List<Employee>>("/employees");

            Assert.NotNull(emps);
            Assert.NotEmpty(emps);
            Assert.Equal(2, emps.Count);
        }
Example #3
0
        private static void Main()
        {
            AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
            //                        PerformanceTest();

            var client = new JsonServiceClient(Settings.Default.ServiceAddress);

            var createRequest = new CreateClientRequest
            {
                Email = "*****@*****.**"
            };
            var response = client.Post<ClientResponse>(createRequest);
            Console.WriteLine("POST Response: {0}\n", response);

            var updateRequest = new UpdateClientRequest
            {
                Email = "*****@*****.**",
                Id = response.Id
            };
            response = client.Put<ClientResponse>(updateRequest);
            Console.WriteLine("PUT Response: {0}\n", response);

            var getClientRequest = new GetClientRequest
            {
                Id = response.Id,
                Date = DateTime.Now.Date
            };
            response = client.Get<ClientResponse>(getClientRequest);
            Console.WriteLine("GET Response: {0}\n", response);

            var deleteRequest = new DeleteClientRequest
            {
                Id = response.Id
            };
            client.Delete(deleteRequest);

            var certificate = new MemoryStream(File.ReadAllBytes("Certificate.cer"));

            var uploadRequest = new UploadRequest
            {
                FileContents = certificate.ToArray(),
                OriginalFileName = "MyFileName.cert",
                UploaderId = Guid.NewGuid().ToString()
            };
            client.Post(uploadRequest);

            Console.ReadKey();
        }
Example #4
0
        public void TryLogin()
        {
            using(var tempDb = new TempFile())
            {
                //GlobalProxySelection.Select = new WebProxy("127.0.0.1", 8888); // proxy via Fiddler2.

                using (var server = new Server()  { Port = 8000, SqliteFile = tempDb.Path })
                {
                    server.Start();

                    // log in
                    var restClient = new JsonServiceClient(FakeServer.BaseUri);
                    var response = restClient.Post<AuthResponseEx>(
                        "/api/auth/credentials?format=json",
                        new Auth()
                        {
                            UserName = "******",
                            Password = "******",
                            RememberMe = true
                        });

                    response.SessionId.ShouldMatch(@"[a-zA-Z0-9=+/]{20,100}");
                    response.UserName.ShouldBe("tech");
                    response.UserId.ShouldMatch(@"^[a-zA-Z0-9_-]{8}$");

                    // log out
                    var logoutResponse = restClient.Delete<AuthResponse>("/api/auth/credentials?format=json&UserName=tech");
                    logoutResponse.SessionId.ShouldBe(null);

                    // can't come up with a good way to verify that we logged out.
                }
            }
        }
Example #5
0
        /// <summary>
        /// Get a new build
        /// </summary>
        /// <returns>BuildInfo object or null on error/no build</returns>
        public static BuildInfo getBuild()
        {
            Console.WriteLine("* Checking for builds...");
            var client = new JsonServiceClient (apiurl);
            try
            {
                var buildInfo = client.Post (new CheckForBuild
                {
                    token = Uri.EscapeDataString (Config.token)
                });

                if (buildInfo != null)
                {
                    return buildInfo;
                }
            }
            catch (WebServiceException ex)
            {
                if(ex.StatusCode == 404)
                {
                    Console.WriteLine ("* Nothing");
                }
                else
                {
                    Console.WriteLine ("* Failed");
                }
            }

            return null;
        }
        public void Test_PostWithBadHostnameAndGetMessage_StatusIsFailed()
        {
            // Create message
            var postRequest = new CreateMessage
            {
                ApplicationId = 1,
                Bcc = new[] { "*****@*****.**" },
                Body = "This is a test email.",
                Cc = new[] { "*****@*****.**" },
                Connection = new Connection
                {
                    EnableSsl = false,
                    Host = "nonexistant",
                    Port = 25
                },
                Credential = new Credential(),
                From = "*****@*****.**",
                ReplyTo = new[] { "*****@*****.**" },
                Sender = "*****@*****.**",
                Subject = "Test Message",
                To = new[] { "*****@*****.**" }
            };
            var client = new JsonServiceClient("http://localhost:59200/");
            var postResponse = client.Post(postRequest);

            // Get message
            var getRequest = new GetMessage
            {
                Id = postResponse.Id
            };
            var getResponse = client.Get(getRequest);

            Assert.Equal(3, getResponse.Status.TypeMessageStatusId);
            Assert.Equal(postResponse.Id, getResponse.Id);
        }
        public void RunTests()
        {
            byte[] imageData;

            using (Image srcImage = Image.FromFile(@"D:\Bill\Code\XamarinEvolve2013Project\TestSSAPI\testavatar.jpg"))
            {
                using (MemoryStream m = new MemoryStream())
                {
                    srcImage.Save(m, ImageFormat.Jpeg);
                    imageData = m.ToArray(); //buffers
                }
            }

            JsonServiceClient client = new JsonServiceClient(SystemConstants.WebServiceBaseURL);

            UserAvatar userAvatar = new UserAvatar()
            {
                UserName = "******",
                Data = imageData,
            };

            UserAvatarResponse response = client.Post<UserAvatarResponse>("UserAvatar", userAvatar);

            //response = client.Delete<UserAvatarResponse>("UserAvatar/billholmes");

            return;
        }
Example #8
0
        /// <summary>
        /// Register the runner with the coordinator
        /// </summary>
        /// <param name="sPubKey">SSH Public Key</param>
        /// <param name="sToken">Token</param>
        /// <returns>Token</returns>
        public static string registerRunner(String sPubKey, String sToken)
        {
			var client = new JsonServiceClient (apiurl);
			try
			{
				var authToken = client.Post (new RegisterRunner
				{
					token = Uri.EscapeDataString (sToken),
					public_key = Uri.EscapeDataString (sPubKey)
				});

				if (!authToken.token.IsNullOrEmpty ())
				{
						Console.WriteLine ("Runner registered with id {0}", authToken.id);
						return authToken.token;
				}
				else
				{
					return null;
				}
			}
			catch(WebException ex)
			{
				Console.WriteLine ("Error while registering runner :", ex.Message);
				return null;
			}          
        }
Example #9
0
        public void OnTestFixtureSetUp()
        {
            Client = new JsonServiceClient(BaseUri);
            var response = Client.Post<AuthenticateResponse>("/auth",
                new Authenticate { UserName = "******", Password = "******" });

        }
        public void Populate()
        {
            ////var svc = new KnockKnockMongo();
            //var db = svc.Database<PotatoKnock>();
            //db.DeleteMany(Builders<PotatoKnock>.Filter.Empty);
            
            var knock = new KnockDto {
                FeedId = Guid.NewGuid(),
                Id = Guid.NewGuid(),
                Location = new LocationDto
                {
                    Latitude = 45,
                    Longitude = 60
                },
                Message = "Turn me into a french fry?"
            };
            using (var svc = new JsonServiceClient("http://localhost:40300/"))
            {
                var knockstr = knock.SerializeToString();
                svc.Post(new KnockPost { Knock = knock });
            }
            //svc.Any(new KnockPost {Knock = knock});

            Console.WriteLine(knock.Id);
        }
 public void check_secured_post_requires_credentials()
 {
     var restClient = new JsonServiceClient(WebServerUrl);
     var request = new Secured { Data = "Bob" };
     var error = Assert.Throws<WebServiceException>(() => restClient.Post<SecuredResponse>("/Secured/", request));
     Assert.AreEqual("Unauthorized", error.Message);
     Assert.AreEqual((int)HttpStatusCode.Unauthorized, error.StatusCode);
 }
Example #12
0
        public void OnTestFixtureSetUp()
        {
            Client = new JsonServiceClient(BaseUri);
            var response= Client.Post<AuthResponse>("/auth",
                new ServiceInterface.Auth.Auth { UserName = "******", Password = "******" });

            Console.WriteLine(response.Dump());
        }
Example #13
0
        private void btnCreate_Click(object sender, EventArgs e)
        {
            AdventureType type = new AdventureType() { Name = txtName.Text };

            ServiceClientBase client = new JsonServiceClient("http://localhost:10768");

            var response = client.Post<AdventureType>("/Adventure/Types/", (AdventureType)type);
        }
Example #14
0
		public void OnTestFixtureSetUp()
		{
			//appHost = new AppHost();
			//appHost.Init();
			//appHost.Start(ListeningOn);
			Client = new JsonServiceClient(BaseUri);
			Client.Post<AuthenticationResponse>("/login", new Authentication(){UserName="******", Password="******"});
			//Client.Send<AuthResponse>(new Auth(){UserName="******", Password="******"});
		}
Example #15
0
 public void BypassOAuthForTemporaryAccessToken()
 {
     var restClient = new JsonServiceClient (testServer.ListenUrl);
     var req = new OAuthTemporaryAccessTokenRequest ();
     req.Username = RainyTestServer.TEST_USER;
     req.Password = RainyTestServer.TEST_PASS;
     var token = restClient.Post<OAuthTemporaryAccessTokenResponse> ("/oauth/temporary_access_token", req);
     Assert.That (!token.AccessToken.StartsWith ("oauth_"));
     Assert.GreaterOrEqual (400, token.AccessToken.Length);
 }
        public void Logout_Test()
        {
            IRestClient    client   = new JsonServiceClient();
            LogoutResponse response = client.Post <LogoutResponse>("http://localhost:888/security/1.0/logout",
                                                                   new LogoutRequest {
                Context = "NG", Token = "53162017072ef71b5c3d8e4f"
            } as object);

            Assert.AreEqual(response.SuccessfulLogout, true);
        }
Example #17
0
		public void ReproduceErrorTest()
		{
			var restClient = new JsonServiceClient(BaseUrl);

			var errorList = restClient.Get<ErrorCollectionResponse>("error");
			Assert.That(errorList.Result.Count, Is.EqualTo(1));

			var error = restClient.Post<ErrorResponse>("error", new Error { Id = "Test" });
			Assert.That(error, !Is.Null);
		}
Example #18
0
        /// <summary>
        /// POST方式调用服务 直接返回JSON
        /// </summary>
        /// <typeparam name="TRequestDto">请求类</typeparam>
        /// <param name="request">请求实例</param>
        /// <param name="url"></param>
        /// <returns>响应实例</returns>
        public static string PostService <TRequestDto>(TRequestDto request, string url) where TRequestDto : BaseRequest
        {
            var client = new JsonServiceClient(url)
            {
                Timeout = new TimeSpan(0, 0, 90)
            };
            string responseJson = client.Post <string>(request);

            return(responseJson);
        }
Example #19
0
 public void AddEmptyThing()
 {
     using (FakeServer fs = new FakeServer().StartWithFakeRepos())
     {
         using(JsonServiceClient client = new JsonServiceClient(FakeServer.BaseUri)){
             var newThing = new Thing();
             client.Post(newThing);
         }
     }
 }
        public void StopProduction()
        {
            var client = new JsonServiceClient("https://{0}.campfirenow.com".FormatWith(_account)) { UserName = _token, Password = "******" };

            Parallel.ForEach(_listeners, (campfireRoomListener) =>
            {
                client.Post<string>("/room/{0}/leave.json".FormatWith(campfireRoomListener.Context.RoomId), string.Empty);
                campfireRoomListener.StopListening();
            });
        }
        public void POST_JSON_Request_calls_Any()
        {
            var client = new JsonServiceClient(Config.ListeningOn);

            var response = client.Post <ContentRoute>(new ContentRoute {
                Id = 1
            });

            Assert.That(response.Id, Is.EqualTo(1));
        }
Example #22
0
 public void OnTestSetup()
 {
     string pass;
     _host = new ServiceTestAppHost();
     _host.Init();
     _host.Start(ServiceTestAppHost.BaseUrl);
     _client = new JsonServiceClient(ServiceTestAppHost.BaseUrl);
     _testUser = DbDataGenerator.AddUserToDatabase(out pass);
     _client.Post(new Auth {provider = "credentials", UserName = _testUser.Email, Password = pass});
 }
Example #23
0
        public void OnTestFixtureSetUp()
        {
            Client = new JsonServiceClient(BaseUri);
            var response = Client.Post <AuthResponse>("/auth",
                                                      new ServiceStack.ServiceInterface.Auth.Auth {
                UserName = "******", Password = "******"
            });

            Console.WriteLine(response.Dump());
        }
Example #24
0
        public void Check_For_Changes_In_Checksum()
        {
            var client = new JsonServiceClient(BaseUri);

            var url = "https://en.wikipedia.org/wiki/Static_web_page";

            var firstChecksumResponse = client.Post(new MD5Request()
            {
                Url = url
            });

            //make another call to the same url
            var secondChecksumResponse = client.Post(new MD5Request()
            {
                Url = url
            });

            Assert.AreEqual(firstChecksumResponse.Checksum, secondChecksumResponse.Checksum, "Provided MD5 checksums for the same url are not the same!");
        }
Example #25
0
        public void Does_url_transparently_decode_RequestBody()
        {
            var client  = new JsonServiceClient(Config.AbsoluteBaseUri);
            var request = new Echo {
                Param = "test://?&% encoding"
            };
            var response = client.Post(request);

            Assert.That(response.Param, Is.EqualTo(request.Param));
        }
        public void do_unsecured_post()
        {
            var restClient = new JsonServiceClient(WebServerUrl);

            var request = new Unsecured { Data = "Bob" };
            var response = restClient.Post<UnsecuredResponse>("/Unsecured/", request);

            Assert.IsNotNull(response);
            Assert.AreEqual("Bob", response.Result);
        }
Example #27
0
        public void Does_compress_raw_Bytes_responses()
        {
            var client   = new JsonServiceClient(Config.ListeningOn);
            var response = client.Post(new CompressBytes
            {
                Bytes = "foo".ToUtf8Bytes(),
            });

            Assert.That(response, Is.EquivalentTo("foo".ToUtf8Bytes()));
        }
Example #28
0
        public void Does_compress_raw_String_responses()
        {
            var client   = new JsonServiceClient(Config.ListeningOn);
            var response = client.Post(new CompressString
            {
                String = "foo",
            });

            Assert.That(response, Is.EqualTo("foo"));
        }
Example #29
0
        public void Can_send_to_GoogleAppEngine_JSON_Python_Service()
        {
            var client  = new JsonServiceClient("http://servicestackdemo.appspot.com");
            var receipt = client.Post(new EmailMessage {
                To      = "*****@*****.**",
                Subject = "Hello from JsonServiceClient",
                Body    = "ServiceStack SMessage",
            });

            receipt.PrintDump();
        }
Example #30
0
 public static void CreateSecrets(string rootToken, string secretName, string[] secrets)
 {
     using (var client = new JsonServiceClient(VaultUriInstance))
     {
         client.AddHeader("X-Vault-Token", rootToken);
         client.Post <JsonObject>($"v1/secret/{secretName}", new
         {
             value = Encoding.UTF8.GetBytes(secrets.ToJson())
         });
     }
 }
        public void SaveProduct_RequiresRole()
        {
            var client = new JsonServiceClient(TestAppHost.BaseUri);

            var login = client.Post(Constants.TestAuthenticate);

            client.SessionId = login.SessionId;

            var authException = Assert.Throws <WebServiceException>(() => client.Post(new SaveProduct()));

            Assert.AreEqual(403, authException.StatusCode);
            Assert.AreEqual("Invalid Role", authException.ErrorCode);

            login            = client.Post(Constants.TestAdminAuthenticate);
            client.SessionId = login.SessionId;

            var exception = Assert.Throws <WebServiceException>(() => client.Post(new SaveProduct()));

            Assert.AreEqual(400, exception.StatusCode);
        }
		public void SetUp()
		{
			MongoHelpers.DeleteAllTestUserEntries();
			_client = HTTPClientHelpers.GetClient(HTTPClientHelpers.RootUrl, HTTPClientHelpers.UserName, HTTPClientHelpers.Password);
			AuthResponse authResponse = HTTPClientHelpers.Login();
			User request = new User { UserName = MongoHelpers.MongoTestUsername, Password = MongoHelpers.MongoTestUserPassword };
			request.Active = _currentActivitySetting;
			request.Roles.Add(_currentRole);
			User response = _client.Post(request);
			_userId = response.Id;
		}
		public void MethodNotSupported_NotFoundException()
		{
			using (var client = new JsonServiceClient())
			{
				var ex = Assert.Throws<WebServiceException>(()=> client.Post<string>(
						UrlFor("/languages"), 
						null));

				Assert.That(ex.StatusCode, Is.EqualTo((int)HttpStatusCode.NotFound));
			}
		}
Example #34
0
        static void Main()
        {
            var client = new JsonServiceClient {
                BaseUri="http://10.1.1.106:2001",
                UserName="******",
                Password="******"
            };

            var result = client.Post(new HelloRequest {Name = "Ameer"}).Result;
            Console.WriteLine(result);
        }
Example #35
0
        public static JsonServiceClient authenticatedClient(int domain_id, string username, string password)
        {
            var jsonclient = new JsonServiceClient("https://" + url);
            jsonclient.StoreCookies = true;
            var response = jsonclient.Post<AuthenticationResponse>(new Authentication() { domain_id = domain_id, password = password, username = username });

            var headers = jsonclient.Headers.AllKeys;
            var cookie = new System.Net.Cookie("ss-id", response.session_id, "/", url);
            jsonclient.CookieContainer.Add(cookie);
            return jsonclient;
        }
Example #36
0
        private static void Main()
        {
            var client = new JsonServiceClient(Settings.Default.ServiceAddress);
            var shipInfo = client.Post<ShipInfo>(new AddShipCommand { ShipName = "Star" });
            Console.WriteLine("The ship has added: {0}", shipInfo);

            var shipLocation = client.Get<ShipLocation>(new ShipLocationQuery { ShipId = shipInfo.Id });
            Console.WriteLine("The ship {0}", shipLocation);

            Console.ReadKey();
        }
Example #37
0
     private static void Main()
     {
         var client = new JsonServiceClient(Settings.Default.ServiceAddress);
         var shipInfo = client.Post<ShipInfo>(new AddShipCommand { ShipName = "Star" });
         Console.WriteLine("The ship has added: {0}", shipInfo);
 
         var shipLocation = client.Get<ShipLocation>(new ShipLocationQuery { ShipId = shipInfo.Id });
         Console.WriteLine("The ship {0}", shipLocation);
 
         Console.ReadKey();
     }
Example #38
0
        public async Task Can_call_return_void()
        {
            client.Post(new ReturnsVoid {
                Message = "Foo"
            });
            Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));

            await client.PostAsync(new ReturnsVoid { Message = "Foo" });

            Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));
        }
        public void Test_PATCH_PASS()
        {
            var restClient = new JsonServiceClient(serviceUrl);

            // register callback to grab the Location: header when executed
            string lastResponseLocation = "";
            HttpStatusCode lastResponseStatusCode = 0;
            restClient.LocalHttpWebResponseFilter = httpRes =>
            {
                lastResponseLocation = httpRes.Headers[HttpHeaders.Location];
                lastResponseStatusCode = httpRes.StatusCode;
            };

            // dummy data
            var newemp1 = new Employee()
            {
                Id = 123,
                Name = "Kimo",
                StartDate = new DateTime(2015, 7, 2),
                CubicleNo = 4234,
                Email = "*****@*****.**",
            };
            restClient.Post<object>("/employees", newemp1);

            var emps = restClient.Get<List<Employee>>("/employees");

            var emp = emps.First();

            var empPatch = new Operations.EmployeePatch();
            empPatch.Add(new Operations.JsonPatchElement()
            {
                op = "replace",
                path = "/title",
                value = "Kahuna Laau Lapaau",
            });

            empPatch.Add(new Operations.JsonPatchElement()
            {
                op = "replace",
                path = "/cubicleno",
                value = "32",
            });

            restClient.Patch<object>(string.Format("/employees/{0}", emp.Id), empPatch);

            var empAfterPatch = restClient.Get<Employee>(string.Format("/employees/{0}", emp.Id));

            Assert.NotNull(empAfterPatch);
            // patched
            Assert.Equal("Kahuna Laau Lapaau", empAfterPatch.Title);
            Assert.Equal("32", empAfterPatch.CubicleNo.ToString());
            // unpatched
            Assert.Equal("*****@*****.**", empAfterPatch.Email);
        }
Example #40
0
 public void PublishMessageToPhantonjs <T>(T request)
 {
     using (var client = new JsonServiceClient(AppConfig.PhantonjsOneWayUrl)) {
         try {
             client.Post(request);
         } catch (Exception e) {
             LogPublishException(request, e, "phn-remoto");
             throw new HttpError(e.Message);
         }
     }
 }
Example #41
0
        /// <summary>
        /// Return true if we can connect to server
        /// </summary>
        /// <returns></returns>
        bool _LoginToServer()
        {
            var username = (string)Settings.Get(Enum_Settings_Key.SMS_SERVICE_USERNAME, "", Enum_Settings_DataType.String);
            var password = (string)Settings.Get(Enum_Settings_Key.SMS_SERVICE_PASSWORD, "", Enum_Settings_DataType.String);

            SMSServer_LoginModel loginmodel = new SMSServer_LoginModel()
            {
                Username = username, Password = password
            };
            var login = server_client.Post(loginmodel);

            if (login.Status != null && login.Status.ErrorCode == "1")
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public void Can_send_to_GoogleAppEngine_JSON_Python_Service()
        {
            var client = new JsonServiceClient("http://servicestackdemo.appspot.com");
            var receipt = client.Post(new EmailMessage { 
                    To = "*****@*****.**",
                    Subject = "Hello from JsonServiceClient",
                    Body = "ServiceStack SMessage",
                });

            receipt.PrintDump();
        }
        public void ReceiveAndReleaseQuantity_HappyPath_ReceivesAndReleases()
        {
            var productId  = Product.Light.Id;
            var locationId = Location.TestRack.Id;
            var rng        = new Random();
            var quant      = rng.Next(10) + 1;
            var client     = new JsonServiceClient(TestAppHost.BaseUri);
            var xact       = new CreateInventoryTransaction
            {
                ProductId  = productId,
                LocationId = locationId,
                Quantity   = quant
            };
            var count = new GetProductQuantityOnHand {
                Id = xact.ProductId
            };

            var login = client.Post(new Authenticate
            {
                provider = AuthenticateService.CredentialsProvider,
                UserName = "******",
                Password = "******"
            });

            client.SessionId = login.SessionId;

            client.Post(xact);
            var qoh = client.Get(count);

            Assert.GreaterOrEqual(quant, 1);
            Assert.NotNull(qoh);
            Assert.AreEqual(quant, qoh.Quantity);

            xact.Quantity = -xact.Quantity + 1;

            client.Post(xact);
            qoh = client.Get(count);

            Assert.NotNull(qoh);
            Assert.AreEqual(1, qoh.Quantity);
        }
Example #44
0
        private GetNextNumberResponse GetNextSequenceNumber(string key)
        {
            string url = (string)new AppSettingsReader().GetValue("NextSequenceNumberServiceUrl", typeof(string));

            using (var client = new JsonServiceClient(url))
            {
                var response = client.Post <GetNextNumberResponse>(new GetNextNumber {
                    ForKey = key
                });
                return(response);
            }
        }
Example #45
0
        private ProjectRole AddActorToRole(Uri projectUri, int roleId, string actorType, string actorName)
        {
            var uri    = projectUri.Append(ProjectRoleUriPostfix).Append(roleId.ToString());
            var actors = new List <string> {
                actorName
            };
            var request = new JsonObject {
                { actorType, actors.ToJson() }
            };

            return(client.Post <ProjectRole>(uri.ToString(), request));
        }
Example #46
0
        public void BypassOAuthForTemporaryAccessToken()
        {
            var restClient = new JsonServiceClient(testServer.ListenUrl);
            var req        = new OAuthTemporaryAccessTokenRequest();

            req.Username = RainyTestServer.TEST_USER;
            req.Password = RainyTestServer.TEST_PASS;
            var token = restClient.Post <OAuthTemporaryAccessTokenResponse> ("/oauth/temporary_access_token", req);

            Assert.That(!token.AccessToken.StartsWith("oauth_"));
            Assert.GreaterOrEqual(400, token.AccessToken.Length);
        }
Example #47
0
        public static List <PatientIntervention> GetInterventions(GetInterventionsRequest request)
        {
            List <PatientIntervention> interventions = null;

            try
            {
                //[Route("/{Context}/{Version}/{ContractNumber}/Goal/Interventions", "POST")]
                IRestClient client = new JsonServiceClient();
                string      url    = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Goal/Interventions",
                                                                          DDPatientGoalsServiceUrl,
                                                                          "NG",
                                                                          request.Version,
                                                                          request.ContractNumber), request.UserId);

                GetPatientInterventionsDataResponse ddResponse =
                    client.Post <GetPatientInterventionsDataResponse>(url, new GetPatientInterventionsDataRequest
                {
                    Context        = "NG",
                    ContractNumber = request.ContractNumber,
                    Version        = request.Version,
                    UserId         = request.UserId,
                    AssignedToId   = request.AssignedToId,
                    CreatedById    = request.CreatedById,
                    PatientId      = request.PatientId,
                    StatusIds      = request.StatusIds
                } as object);

                if (ddResponse != null && ddResponse.InterventionsData != null)
                {
                    var filteredInterventions = ddResponse.InterventionsData;
                    if (request.InterventionFilterType != 0)
                    {
                        filteredInterventions = GetFilteredInterventions(ddResponse.InterventionsData, request);
                    }
                    interventions = new List <PatientIntervention>();
                    var patientIds      = filteredInterventions.Select(x => x.PatientId).ToList();
                    var patientsDetails = GetPatientsDetails(request.Version, request.ContractNumber, request.UserId, client, patientIds);

                    foreach (PatientInterventionData n in filteredInterventions)
                    {
                        PatientIntervention i = GoalsUtil.ConvertToIntervention(n);
                        i.PatientDetails = patientsDetails.FirstOrDefault(x => x.Id == n.PatientId);
                        i.PatientId      = n.PatientId;
                        interventions.Add(i);
                    }
                }
            }
            catch
            {
                throw;
            }
            return(interventions);
        }
Example #48
0
        public void WhenCreatePerson_ThenReturnsPerson()
        {
            var client = new JsonServiceClient(ServiceUrl);

            var person = client.Post(new CreatePersonRequest
            {
                FirstName = "afirstname",
                LastName  = "alastname"
            }).Person;

            person.Should().NotBeNull();
        }
Example #49
0
 public bool PostHook(string repo, string url)
 {
     try
     {
         _client.Post <Hook>("repos/" + repo + "/hooks", new Hook(url));
     }
     catch (Exception)
     {
         return(false);
     }
     return(true);
 }
 public void flushToDisk(UserFile file)
 {
     try {
         logger.Debug("Flushing file to disk with filename and owner : " + file.filemetadata.filepath + " " + file.filemetadata.owner);
         JsonServiceClient client = new JsonServiceClient(PERSISTENT_STORAGE_SERVICE_ENDPOINT);
         client.Post <Object> ("/flushfile", new FlushFile {
             file = file
         });
     } catch (Exception e) {
         logger.Warn(e);
     }
 }
Example #51
0
        protected virtual EventResponse ReportEvent(EventInfo eventInfo)
        {
            var eventInfoWithExceptionAsString = new EventInfoWithExceptionAsString
            {
                AdditionalInfo = eventInfo.AdditionalInfo,
                Exception      = eventInfo.Exception?.ToString(),
                Message        = eventInfo.Message,
                Type           = (EventInfoWithExceptionAsString.EventType)eventInfo.Type
            };

            return(_orchestratorClient.Post <EventResponse>($"/report?testName={TestName}", eventInfoWithExceptionAsString));
        }
Example #52
0
        public void Authorize(ILoginSettings loginSettings)
        {
            _jsonServiceClient.LocalHttpWebRequestFilter = LocalHttpWebRequestFilter(loginSettings);
            var request = new Auth
            {
                UserName   = loginSettings.UserName,
                Password   = loginSettings.Password,
                RememberMe = true, //important tell client to retain permanent cookies
            };

            _jsonServiceClient.Post(request);
        }
        public void Does_compress_RequestDto_responses()
        {
            var client   = new JsonServiceClient(Config.ListeningOn);
            var response = client.Post(new CompressData
            {
                String = "Hello",
                Bytes  = "World".ToUtf8Bytes()
            });

            Assert.That(response.String, Is.EqualTo("Hello"));
            Assert.That(response.Bytes, Is.EqualTo("World".ToUtf8Bytes()));
        }
        public void Can_send_gzip_client_request_ASPNET()
        {
            var client = new JsonServiceClient(Config.AspNetServiceStackBaseUri)
            {
                RequestCompressionType = CompressionTypes.GZip,
            };
            var response = client.Post(new HelloZip {
                Name = "GZIP"
            });

            Assert.That(response.Result, Is.EqualTo("Hello, GZIP"));
        }
Example #55
0
 public TaskQueue.RepresentedModel GetValidationInfo(string MType, string channelName = null)
 {
     Validation.ValidationResponse result = client.Post <Validation.ValidationResponse>("/tmq/v", new Validation.ValidationRequest {
         MType = MType, ChannelName = channelName
     });
     if (result == null)
     {
         throw new Exception(string.Format("Message type '{0}' not routed to worker module {1}",
                                           MType, channelName == null ? "" : string.Format("or '{1}' channel absent", channelName)));
     }
     return(TaskQueue.RepresentedModel.FromSchema(result.ModelScheme));
 }
        public void Can_send_Deflate_client_request()
        {
            var client = new JsonServiceClient(Config.ListeningOn)
            {
                RequestCompressionType = CompressionTypes.Deflate,
            };
            var response = client.Post(new HelloZip {
                Name = "Deflate"
            });

            Assert.That(response.Result, Is.EqualTo("Hello, Deflate"));
        }
Example #57
0
        private void BtnUpload_Click(object sender, EventArgs e)
        {
            var BrowseWin = new System.Windows.Forms.OpenFileDialog();

            BrowseWin.Filter = "All Files (*.*)|*.*";
            var ret = BrowseWin.ShowDialog();

            if (ret == System.Windows.Forms.DialogResult.OK)
            {
                long   FileVer  = -1;
                string FileName = DirectoryTextBox.Text + BrowseWin.SafeFileName;
                foreach (FileMetaData file in FileList.fileMDList)
                {
                    if (file.filepath == FileName)
                    {
                        FileVer = 1 + file.versionNumber;
                        break;
                    }
                }
                if (FileVer == -1)
                {// false
                    FileVer = 1;
                }


                UpdateFile arg           = new UpdateFile();
                string     LocalFilePath = BrowseWin.FileName;
                UserFile   FileToUpload  = new UserFile(FileName, ConnectedUser.ClientId);

                //byte[] fileStream = File.ReadAllBytes(LocalFilePath);`
                string fileStream = File.ReadAllText(LocalFilePath);
                //bool done = FileToUpload.SetFileContent(fileStream, (long)0);
                FileToUpload.SetFileContent(Encoding.UTF8.GetBytes(fileStream), FileVer);
                arg.file = FileToUpload;
                string requestUrl = string.Format("/updatefile/{0}/{1}", ConnectedUser.ClientId, ConnectedUser.Password);
                ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(ValidateRemoteCertificate);
                JsonServiceClient Updateclient = new JsonServiceClient(CLOUD_SERVICE_ENDPOINT);
                //Updateclient.ContentType = "application/json";
                try
                {
                    Updateclient.Post <Object>(requestUrl, arg);
                    ClientFileSystem.addFileSynchronized(FileToUpload);             // update clientfilesystem on upload
                }
                catch (Exception ex)
                {
                    MessageBox.Show("This File has been changed by another client. Please download the latest copy and try to uplaod");
                }

                //send file for Upload

                this.UpdateFileList();
            }
        }
        public void RunTests()
        {
            string username = "******";
            string passHash = MD5Helper.CalculateMD5Hash("password");

            JsonServiceClient client = new JsonServiceClient(SystemConstants.WebServiceBaseURL);
            Login(client, username, passHash);

            client.Get<XamarinEvolveSSLibrary.UserResponse>("User");

            Logout(client);

            client.Get<XamarinEvolveSSLibrary.UserResponse>("User");

            Login(client, username, passHash);

            User user = new User()
            {
                UserName = username,
                City = "changedtown",
                Email = "*****@*****.**"
            };

            client.Post<XamarinEvolveSSLibrary.UserResponse>("User", user);

            Logout(client);

            client.Post<XamarinEvolveSSLibrary.UserResponse>("User", user);
        }
Example #59
-1
        public static void CreateApp(string endpoint, string appName)
        {
            JsonServiceClient client = new JsonServiceClient(endpoint);
            client.Post(new Server.CreateAppRequest()
            {
                AppName = appName
            });

            try
            {
                Server.CreateAppStatus status;
                do
                {
                    status = client.Get(new Server.CreateAppStatusRequest() { AppName = appName });
                    if (status == null) break;
                    Console.Write(status.Log);
                    Thread.Sleep(200);
                }
                while (!status.Completed);
            }
            catch (WebServiceException e)
            {
                Console.WriteLine(e.ResponseBody);
                Console.WriteLine(e.ErrorMessage);
                Console.WriteLine(e.ServerStackTrace);
            }
        }
        public void CanPerform_PartialUpdate()
        {
            var client = new JsonServiceClient("http://localhost:53990/api/");

            // back date for readability
            var created = DateTime.Now.AddHours(-2);

            // Create a record so we can patch it
            var league = new League() {Name = "BEFORE", Abbreviation = "BEFORE", DateUpdated = created, DateCreated = created};
            var newLeague = client.Post<League>(league);

            // Update Name and DateUpdated fields. Notice I don't want to update DateCreatedField.
            // I also added a fake field to show it does not cause any errors
            var updated = DateTime.Now;
            newLeague.Name = "AFTER";
            newLeague.Abbreviation = "AFTER"; // setting to after but it should not get updated
            newLeague.DateUpdated = updated;

            client.Patch<League>("http://localhost:53990/api/leagues/" + newLeague.Id + "?fields=Name,DateUpdated,thisFieldDoesNotExist", newLeague);

            var updatedLeague = client.Get<League>(newLeague);

            Assert.AreEqual(updatedLeague.Name, "AFTER");
            Assert.AreEqual(updatedLeague.Abbreviation, "BEFORE");
            Assert.AreEqual(updatedLeague.DateUpdated.ToString(), updated.ToString(), "update fields don't match");
            Assert.AreEqual(updatedLeague.DateCreated.ToString(), created.ToString(), "created fields don't match");

            // double check
            Assert.AreNotEqual(updatedLeague.DateCreated, updatedLeague.DateUpdated);
        }