예제 #1
0
        /// <summary>
        /// Gets a list of URLs for the separate services of an instance
        /// </summary>
        /// <param name="address">The address to query</param>
        /// <returns></returns>
        public static async Task <Result <ServerURLs> > GetServerURLs(string address)
        {
            // Instantiates temporary objects
            RequestsClient requestsClient = new RequestsClient();
            Endpoint       target         = new Endpoint("/Home/InstanceInfo", HttpMethod.Get);

            // Retrieves URL information and converts to stream
            HttpResponseMessage response = await requestsClient.SendRequest(address, target);

            return(await ResponseParser.ParseJsonResponse <ServerURLs>(response));
        }
예제 #2
0
        /// <summary>
        /// Queries the given server with the given authentication token, return user information if available
        /// </summary>
        /// <param name="address">The instance to query</param>
        /// <param name="token">The token to send</param>
        public async Task <Result <CrossConnectionUser> > AuthenticateToken(string address, string token)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "token", token }
            };

            HttpResponseMessage response = await _requestsClient
                                           .SendRequest(address, CrossConnectionEndpoints.AuthenticateToken, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <CrossConnectionUser>(response));
        }
예제 #3
0
        /// <summary>
        /// Retrieves a thread of the given ID
        /// </summary>
        /// <param name="threadID">The thread to retrieve</param>
        /// <returns>The requested thread</returns>
        public async Task <Result <ApiThread> > GetThreadAsync(int threadID)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", threadID.ToString() }
            };

            // Retrieves response and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.Thread, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <ApiThread>(response));
        }
예제 #4
0
        /// <summary>
        /// Retrieves the list of threads at the front page
        /// </summary>
        /// <returns>The list of threads</returns>
        public async Task <Result <List <ApiThread> > > GetFrontPageAsync(int page = 1)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "page", page.ToString() }
            };

            // Retrieves response and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.FrontPage, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <List <ApiThread> >(response).ConfigureAwait(false));
        }
예제 #5
0
        /// <summary>
        /// Checks if a domain has already been registered in the given server
        /// </summary>
        /// <param name="address">The server to query</param>
        /// <param name="checkAddress">The address to check</param>
        /// <returns>Returns a successful when it has not been registered, otherwise returns a failure result</returns>
        public async Task <Result> CheckAddress(string address, string checkAddress)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "address", checkAddress }
            };

            HttpResponseMessage response = await _requestsClient
                                           .SendRequest(address, CrossConnectionEndpoints.CheckAddress, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse(response).ConfigureAwait(false));
        }
예제 #6
0
        /// <summary>
        /// Retrieves a user comment of the given ID
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task <Result <ApiComment> > GetUserCommentAsync(int id)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", id.ToString() }
            };

            // Sends request and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.GetUserComment, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <ApiComment>(response).ConfigureAwait(false));
        }
예제 #7
0
        /// <summary>
        /// Download the profile picture of the given user as a stream
        /// </summary>
        /// <param name="id">The ID of the user</param>
        /// <returns></returns>
        public async Task <Result <Stream> > GetProfileImg(int id)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", id.ToString() }
            };

            // Sends request and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.ProfilePicture, parameters)
                                           .ConfigureAwait(false);

            return(await ResponseParser.ParseStreamResponse(response));
        }
예제 #8
0
        /// <summary>
        /// Deletes a thread of the given ID
        /// </summary>
        /// <param name="id">The ID of the thread to delete</param>
        /// <returns></returns>
        public async Task <Result> DeleteThreadAsync(int id)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", id.ToString() }
            };

            // Retrieves the response and returns result
            HttpResponseMessage response =
                await _requestsClient.SendRequest(Endpoints.DeleteThread, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse(response).ConfigureAwait(false));
        }
예제 #9
0
        /// <summary>
        /// Creates a new thread
        /// </summary>
        /// <param name="title">The title of the new thread</param>
        /// <param name="contents">The contents of the new thread</param>
        /// <returns>The newly created thread/error</returns>
        public async Task <Result <ApiThread> > CreateThreadAsync(string title, string contents)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "title", title },
                { "content", contents }
            };

            // Retrieves response and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.CreateThread, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <ApiThread>(response));
        }
예제 #10
0
        /// <summary>
        /// Registers an outgoing token at the given address
        /// </summary>
        /// <param name="address"></param>
        /// <param name="registerAddress"></param>
        /// <param name="token">The token to register on the remote server</param>
        /// <returns></returns>
        public async Task <Result> RegisterAddress(string address, string registerAddress, string token)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "address", registerAddress },
                { "token", token }
            };

            HttpResponseMessage response = await _requestsClient
                                           .SendRequest(address, CrossConnectionEndpoints.RegisterToken, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse(response).ConfigureAwait(false));
        }
예제 #11
0
        /// <summary>
        /// Gets comments from the user of the given ID
        /// </summary>
        /// <param name="id">The ID of the user to retrieve comments for</param>
        /// <param name="page">The page of comments to retrieve</param>
        /// <returns></returns>
        public async Task <Result <List <ApiComment> > > GetUserCommentsAsync(int id, int page = 1)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", id.ToString() },
                { "page", page.ToString() }
            };

            // Receives response and returns result
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.UserComments, parameters)
                                           .ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <List <ApiComment> >(response).ConfigureAwait(false));
        }
예제 #12
0
        /// <summary>
        /// Posts a comment to the given thread
        /// </summary>
        /// <param name="threadID">The thread to post the comment to</param>
        /// <param name="content">The comment to post</param>
        /// <returns></returns>
        public async Task <Result <ApiComment> > PostCommentAsync(int threadID, string content)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", threadID.ToString() },
                { "content", content }
            };

            // Retrieves response and returns result
            HttpResponseMessage response =
                await _requestsClient.SendRequest(Endpoints.PostComment, parameters).ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <ApiComment>(response).ConfigureAwait(false));
        }
예제 #13
0
        /// <summary>
        /// Updates a thread
        /// </summary>
        /// <remarks>
        /// The user must be the owner of the thread to update it, and only the locked status of the thread can be changed
        /// </remarks>
        /// <param name="id">The id of the thread to update</param>
        /// <param name="request">The update information of the request</param>
        /// <returns></returns>
        public async Task <Result <ApiThread> > UpdateThread(int id, UpdateThreadRequest request)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "id", id.ToString() }
            };

            if (request.Locked != null)
            {
                parameters.Add("locked", request.Locked.ToString());
            }

            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.UpdateThread, parameters)
                                           .ConfigureAwait(false);

            return(await ResponseParser.ParseJsonResponse <ApiThread>(response).ConfigureAwait(false));
        }
예제 #14
0
        /// <summary>
        /// Logs the user in, returning an access token
        /// </summary>
        /// <param name="username">The username to use</param>
        /// <param name="password">The password to use</param>
        /// <returns>The LoginResponse containing the access token</returns>
        public async Task <Result <LoginResponse> > LoginAsync(string username, string password)
        {
            Dictionary <string, string> parameters = new Dictionary <string, string>()
            {
                { "username", username },
                { "password", password }
            };

            // Sends login and returns result, saving the token if successful
            HttpResponseMessage response = await _requestsClient.SendRequest(Endpoints.Login, parameters).ConfigureAwait(false);

            Result <LoginResponse> loginResponse = await ResponseParser.ParseJsonResponse <LoginResponse>(response).ConfigureAwait(false);

            if (loginResponse.Success)
            {
                TokenStorage.SetToken(loginResponse.Value.Token);
            }
            return(loginResponse);
        }