public async Task<bool> CompletePasswordResetAsync(string email, string newPassword, string code, string answer)
        {
            if (email == null)
            {
                throw new ArgumentNullException("email");
            }

            if (newPassword == null)
            {
                throw new ArgumentNullException("newPassword");
            }

            if (code != null && answer != null)
            {
                throw new ArgumentException("You must specify either code or answer parameters but not both.", "answer");
            }

            var address = baseAddress.WithResource("password").WithParameter("login", true);
            PasswordRequest data = new PasswordRequest { email = email, new_password = newPassword, code = code, security_answer = answer };
            string content = contentSerializer.Serialize(data);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders, content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            bool success = contentSerializer.Deserialize<PasswordResponse>(response.Body).success ?? false;
            if (success)
            {
                Session session = await GetSessionAsync();
                baseHeaders.AddOrUpdate(HttpHeaders.DreamFactorySessionTokenHeader, session.session_id);
            }

            return success;
        }
Exemple #2
0
        public async Task<bool> RegisterAsync(Register register, bool login = false)
        {
            if (register == null)
            {
                throw new ArgumentNullException("register");
            }

            var address = baseAddress.WithResource("register");
            if (login)
            {
                address = address.WithParameter("login", true);
            }

            string content = contentSerializer.Serialize(register);
            IHttpRequest request = new HttpRequest(HttpMethod.Post,
                                                   address.Build(),
                                                   baseHeaders,
                                                   content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var success = new { success = false };
            success = contentSerializer.Deserialize(response.Body, success);

            if (success.success && login)
            {
                Session session = await GetSessionAsync();
                baseHeaders.AddOrUpdate(HttpHeaders.DreamFactorySessionTokenHeader, session.session_id);
            }

            return success.success;
        }
Exemple #3
0
        public async Task<FileResponse> CreateFileAsync(string container, string filepath, string content, bool checkExists = true)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            if (filepath == null)
            {
                throw new ArgumentNullException("filepath");
            }

            if (content == null)
            {
                throw new ArgumentNullException("content");
            }

            IHttpAddress address = baseAddress.WithResource( container, filepath).WithParameter("check_exist", checkExists);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders.Exclude(HttpHeaders.ContentTypeHeader), content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var data = new { file = new List<FileResponse>() };
            return contentSerializer.Deserialize(response.Body, data).file.First();
        }
Exemple #4
0
        public async Task<Session> GetSessionAsync()
        {
            var address = baseAddress.WithResource("session");
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return contentSerializer.Deserialize<Session>(response.Body);
        }
Exemple #5
0
        /// <inheritdoc />
        public async Task<IEnumerable<Service>> GetServicesAsync()
        {
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), BaseHeaders);

            IHttpResponse response = await HttpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, ContentSerializer);

            var services = new { service = new List<Service>() };
            return ContentSerializer.Deserialize(response.Body, services).service;
        }
Exemple #6
0
        public async Task<IEnumerable<TableInfo>> GetAccessComponentsAsync()
        {
            IHttpRequest request = new HttpRequest(HttpMethod.Get, baseAddress.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var resource = new { resource = new List<TableInfo>() };
            return contentSerializer.Deserialize(response.Body, resource).resource;
        }
Exemple #7
0
        public async Task<ConfigResponse> SetConfigAsync(ConfigRequest config)
        {
            IHttpAddress address = baseAddress.WithResource("config");
            string body = contentSerializer.Serialize(config);
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders, body);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return contentSerializer.Deserialize<ConfigResponse>(response.Body);
        }
        public async Task<IEnumerable<ContainerInfo>> GetAccessComponentsAsync()
        {
            IHttpAddress address = baseAddress.WithParameter("include_properties", true);
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);
            
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var data = new { container = new List<ContainerInfo>() };
            return contentSerializer.Deserialize(response.Body, data).container;
        }
Exemple #9
0
        public async Task<bool> LogoutAsync()
        {
            var address = baseAddress.WithResource("session");
            IHttpRequest request = new HttpRequest(HttpMethod.Delete, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            baseHeaders.Delete(HttpHeaders.DreamFactorySessionTokenHeader);

            var logout = new { success = false };
            return contentSerializer.Deserialize(response.Body, logout).success;
        }
Exemple #10
0
        public async Task<byte[]> DownloadApplicationSdkAsync(int applicationId)
        {
            IHttpAddress address = baseAddress
                .WithResource("app", applicationId.ToString(CultureInfo.InvariantCulture))
                .WithParameter("sdk", true);

            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return response.RawBody;
        }
Exemple #11
0
        public async Task<IEnumerable<ScriptResponse>> GetScriptsAsync(bool includeUserScripts)
        {
            IHttpAddress address = baseAddress.WithResource("script")
                                              .WithParameter("include_script_body", true)
                                              .WithParameter("include_user_scripts", includeUserScripts);

            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var scripts = new { resource = new List<ScriptResponse>() };
            return contentSerializer.Deserialize(response.Body, scripts).resource;
        }
Exemple #12
0
        public async Task<IEnumerable<EventCacheResponse>> GetEventsAsync(bool allEvents)
        {
            IHttpAddress address = baseAddress.WithResource("event").WithParameter("as_cached", false);
            if (allEvents)
            {
                address = address.WithParameter("all_events", true);
            }

            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var records = new { record = new List<EventCacheResponse>() };
            return contentSerializer.Deserialize(response.Body, records).record;
        }
Exemple #13
0
        public async Task UnregisterEventsAsync(params EventRequest[] requests)
        {
            if (requests == null || requests.Length < 1)
            {
                throw new ArgumentException("At least one parameter must be specificed", "requests");
            }

            IHttpAddress address = baseAddress.WithResource("event");
            var records = new { record = new List<EventRequest>(requests) };
            string body = contentSerializer.Serialize(records);
            IHttpRequest request = new HttpRequest(HttpMethod.Delete, address.Build(), baseHeaders, body);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);
        }
        public async Task<byte[]> GetBinaryFileAsync(string filepath)
        {
            if (filepath == null)
            {
                throw new ArgumentNullException("filepath");
            }

            IHttpAddress address = base.BaseAddress.WithResource(filepath);
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), base.BaseHeaders.Include(HttpHeaders.AcceptHeader, OctetStream));
            IHttpResponse response = await base.HttpFacade.RequestAsync(request);

            HttpUtils.ThrowOnBadStatus(response, base.ContentSerializer);

            return response.RawBody;
        }
        public async Task RunAsync(IRestContext context)
        {
            /*
             * Get random bytes as hex string from random.org
             */

            const string url = "https://www.random.org/cgi-bin/randbyte?nbytes=16&format=h";
            IHttpRequest request = new HttpRequest(HttpMethod.Get, url, new HttpHeaders());
            IHttpFacade httpFacade = new UnirestHttpFacade();

            Console.WriteLine("Sending GET request: {0}", url);
            IHttpResponse response = await httpFacade.RequestAsync(request);

            Console.WriteLine("Response CODE = {0}, BODY = {1}", response.Code, response.Body.Trim());
        }
Exemple #16
0
        public async Task DeleteScriptAsync(string scriptId)
        {
            if (scriptId == null)
            {
                throw new ArgumentNullException("scriptId");
            }

            IHttpAddress address = baseAddress
                .WithResource("script", scriptId)
                .WithParameter("is_user_script", true);

            IHttpRequest request = new HttpRequest(HttpMethod.Delete, address.Build(), baseHeaders);
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);
        }
Exemple #17
0
        public async Task<byte[]> DownloadApplicationPackageAsync(int applicationId, bool includeFiles, bool includeServices, bool includeSchema)
        {
            IHttpAddress address = baseAddress
                .WithResource("app", applicationId.ToString(CultureInfo.InvariantCulture))
                .WithParameter("pkg", true)
                .WithParameter("include_files", includeFiles)
                .WithParameter("include_services", includeServices)
                .WithParameter("include_schema", includeSchema);

            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return response.RawBody;
        }
Exemple #18
0
        public async Task<int> SendEmailAsync(EmailRequest emailRequest)
        {
            if (emailRequest == null)
            {
                throw new ArgumentNullException("emailRequest");
            }

            string content = contentSerializer.Serialize(emailRequest);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, baseAddress.Build(), baseHeaders, content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var emailsSent = new { count = 0 };
            return contentSerializer.Deserialize(response.Body, emailsSent).count;
        }
Exemple #19
0
        public async Task<PasswordResponse> RequestPasswordResetAsync(string email)
        {
            if (email == null)
            {
                throw new ArgumentNullException("email");
            }

            var address = baseAddress.WithResource("password").WithParameter("reset", true);
            PasswordRequest data = new PasswordRequest { email = email };
            string content = contentSerializer.Serialize(data);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders, content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return contentSerializer.Deserialize<PasswordResponse>(response.Body);
        }
        public Task<FileResponse> ReplaceFileContentsAsync(string filepath, string contents)
        {
            if (filepath == null)
            {
                throw new ArgumentNullException("filepath");
            }

            if (contents == null)
            {
                throw new ArgumentNullException("contents");
            }

            IHttpAddress address = base.BaseAddress.WithResource(filepath);
            IHttpRequest request = new HttpRequest(HttpMethod.Put, address.Build(), base.BaseHeaders.Exclude(HttpHeaders.ContentTypeHeader), contents);

            return base.ExecuteRequest<FileResponse>(request);
        }
Exemple #21
0
        public async Task<bool> UpdateProfileAsync(ProfileRequest profileRequest)
        {
            if (profileRequest == null)
            {
                throw new ArgumentNullException("profileRequest");
            }

            var address = baseAddress.WithResource("profile");
            string content = contentSerializer.Serialize(profileRequest);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders, content);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var success = new { success = false };
            return contentSerializer.Deserialize(response.Body, success).success;
        }
Exemple #22
0
        public async Task<bool> DeleteTableAsync(string tableName)
        {
            if (tableName == null)
            {
                throw new ArgumentNullException("tableName");
            }

            IHttpAddress address = baseAddress.WithResource( "_schema", tableName);
            IHttpRequest request = new HttpRequest(HttpMethod.Delete, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var success = new { success = false };
            success = contentSerializer.Deserialize(response.Body, success);

            return success.success;
        }
Exemple #23
0
        private async Task DeleteRecordsAsync(string resource, bool setDeleteStorage, params int[] ids)
        {
            if (ids == null || ids.Length < 1)
            {
                throw new ArgumentException("At least one application ID must be specificed", "ids");
            }

            string list = string.Join(",", ids);
            IHttpAddress address = baseAddress.WithResource(resource).WithParameter("ids", list);
            if (setDeleteStorage)
            {
                address = address.WithParameter("delete_storage", true);
            }

            IHttpRequest request = new HttpRequest(HttpMethod.Delete, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);
        }
        public async Task DeleteContainersAsync(params string[] containers)
        {
            if (containers == null)
            {
                throw new ArgumentNullException("containers");
            }

            if (containers.Length < 1)
            {
                throw new ArgumentException("At least one container name must be provided", "containers");
            }

            var data = new { container = containers.Select(x => new { name = x, path = x }) };
            string body = contentSerializer.Serialize(data);
            IHttpRequest request = new HttpRequest(HttpMethod.Delete, baseAddress.Build(), baseHeaders, body);
            request.SetTunnelingWith(HttpMethod.Post);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);
        }
Exemple #25
0
        public async Task<FolderResponse> GetFolderAsync(string container, string path, ListingFlags flags)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            if (path == null)
            {
                throw new ArgumentNullException("path");
            }

            IHttpAddress address = baseAddress.WithResource( container, path, string.Empty);
            address = AddListingParameters(address, flags);
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return contentSerializer.Deserialize<FolderResponse>(response.Body);
        }
Exemple #26
0
        public async Task<byte[]> DownloadFolderAsync(string container, string path)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            if (path == null)
            {
                throw new ArgumentNullException("path");
            }

            IHttpAddress address = baseAddress.WithResource( container, path, string.Empty)
                                              .WithParameter("zip", true);
            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return response.RawBody;
        }
        public async Task CreateContainersAsync(bool checkExists, params string[] containers)
        {
            if (containers == null)
            {
                throw new ArgumentNullException("containers");
            }

            if (containers.Length < 1)
            {
                throw new ArgumentException("At least one container name must be provided", "containers");
            }

            IHttpAddress address = baseAddress.WithParameter("check_exist", checkExists);

            var data = new { container = containers.Select(x => new ContainerInfo { name = x, path = x }) };
            string body = contentSerializer.Serialize(data);
            IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders, body);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);
        }
Exemple #28
0
        public async Task<Session> LoginAsync(string applicationName, string email, string password, int duration)
        {
            if (applicationName == null)
            {
                throw new ArgumentNullException("applicationName");
            }

            if (email == null)
            {
                throw new ArgumentNullException("email");
            }

            if (password == null)
            {
                throw new ArgumentNullException("password");
            }

            if (duration < 0)
            {
                throw new ArgumentOutOfRangeException("duration");
            }

            var address = baseAddress.WithResource("session");
            baseHeaders.AddOrUpdate(HttpHeaders.DreamFactoryApplicationHeader, applicationName);

            Login login = new Login { email = email, password = password, duration = duration };
            string loginContent = contentSerializer.Serialize(login);
            IHttpRequest request = new HttpRequest(HttpMethod.Post,
                                                   address.Build(),
                                                   baseHeaders,
                                                   loginContent);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            Session session = contentSerializer.Deserialize<Session>(response.Body);
            baseHeaders.AddOrUpdate(HttpHeaders.DreamFactorySessionTokenHeader, session.session_id);

            return session;
        }
Exemple #29
0
        public async Task<ScriptResponse> WriteScriptAsync(string id, string body)
        {
            if (id == null)
            {
                throw new ArgumentNullException("id");
            }

            if (body == null)
            {
                throw new ArgumentNullException("body");
            }

            IHttpAddress address = baseAddress
                .WithResource("script", id)
                .WithParameter("is_user_script", true);

            IHttpRequest request = new HttpRequest(HttpMethod.Put, address.Build(), baseHeaders.Exclude(HttpHeaders.ContentTypeHeader), body);
            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            return contentSerializer.Deserialize<ScriptResponse>(response.Body);
        }
Exemple #30
0
        public async Task<IEnumerable<string>> GetTableNamesAsync(bool includeSchemas, bool refresh = false)
        {
            IHttpAddress address = baseAddress.WithParameter("names_only", true);
            
            if (includeSchemas)
            {
                address = address.WithParameter("include_schemas", true);
            }

            if (refresh)
            {
                address = address.WithParameter("refresh", true);
            }

            IHttpRequest request = new HttpRequest(HttpMethod.Get, address.Build(), baseHeaders);

            IHttpResponse response = await httpFacade.RequestAsync(request);
            HttpUtils.ThrowOnBadStatus(response, contentSerializer);

            var resource = new { resource = new List<string>() };
            return contentSerializer.Deserialize(response.Body, resource).resource;
        }