public BaseService() { const string host = ""; const string apiKey = ""; RedmineService = new RedmineManager(host, apiKey); }
public void Should_Connect_With_Api_Key() { var a = new RedmineManager(Helper.Uri, Helper.ApiKey); var currentUser = a.GetCurrentUser(); Assert.NotNull(currentUser); Assert.True(currentUser.ApiKey.Equals(Helper.ApiKey),"api keys not equals."); }
public void Should_Connect_With_Username_And_Password() { var a = new RedmineManager(Helper.Uri, Helper.Username, Helper.Password); var currentUser = a.GetCurrentUser(); Assert.NotNull(currentUser); Assert.True(currentUser.Login.Equals(Helper.Username), "usernames not equals."); }
public ProjectManagerGateway(RedmineSettings redmineSettings) { Require.NotNull(redmineSettings, nameof(redmineSettings)); _redmineSettings = redmineSettings; _redmineManager = new RedmineManager(redmineSettings.RedmineHost, redmineSettings.ApiKey); }
public bool Create() { try { RedmineManager manager = new RedmineManager(Configuration.RedmineHost, Configuration.RedmineUser, Configuration.RedminePassword); //Create a issue. var newIssue = new Issue { Subject = Title, Description = Description, Project = new IdentifiableName() { Id = ProjectId }, Tracker = new IdentifiableName() { Id = TrackerId } }; User thisuser = (from u in manager.GetObjectList<User>(new System.Collections.Specialized.NameValueCollection()) where u.Login == Configuration.RedmineUser select u).FirstOrDefault(); if (thisuser != null) newIssue.AssignedTo = new IdentifiableName() { Id = thisuser.Id }; manager.CreateObject(newIssue); } catch { return false; } return true; }
private static bool GetCredentialsIfNeeded(Configuration configuration) { if (configuration.OpenTickets) { // Get use name and password Console.Write("Redmine Username: "******"Redmine password: "); _password = Console.ReadLine(); _redmineManager = new RedmineManager(configuration.RedmineUrl, _user, _password); try { _redmineManager.GetCurrentUser(); return true; } catch (RedmineException) { return false; } } return true; }
public RedmineSettings() { buffer = RedmineDataBuffer.Read(); if (buffer == null) { //means no settings where saved until now... buffer = new RedmineDataBuffer(); } manager = null; }
public Client(string login, string password, string host) { this.login = login; this.password = password; this.host = host; manager = new RedmineManager(host, login, password); cacheissue = this.GetTotalIssue(); totalissue = this.GetTotalIssue(); totalproject = this.GetTotalProject(); projects = this.GetProjects(); _instance = this; }
public static Dictionary<string, int> GetProjects() { RedmineManager manager = new RedmineManager(Configuration.RedmineHost, Configuration.RedmineUser, Configuration.RedminePassword); Dictionary<string, int> Projects = new Dictionary<string, int>(); foreach (Project proj in manager.GetObjectList<Project>(new NameValueCollection())) { Projects.Add(proj.Name, proj.Id); } return Projects; }
public static Dictionary<string, int> GetTrackers() { RedmineManager manager = new RedmineManager(Configuration.RedmineHost, Configuration.RedmineUser, Configuration.RedminePassword); Dictionary<string, int> Trackers = new Dictionary<string, int>(); foreach (Tracker track in manager.GetObjectList<Tracker>(new NameValueCollection())) { Trackers.Add(track.Name, track.Id); } return Trackers; }
private RedmineManager getManager() { if (manager == null) { try { manager = new RedmineManager(buffer.host, buffer.apikey); System.Net.ServicePointManager.ServerCertificateValidationCallback += new System.Net.Security.RemoteCertificateValidationCallback(bypassAllCertificateStuff); } catch (Redmine.Net.Api.RedmineException e) { MessageBox.Show(e.Message,"Connection Error."); manager = null; } } return manager; }
public static void ConnectRMServer(RMConnectCmdletBase cmdlet) { // Redmine.Net.Api.RedmineWebClient client = // new RedmineWebClient(); // client. string host = ""; string apiKey = ""; var manager = new RedmineManager(host, apiKey); // var parameters = new NameValueCollection {{"status_id", "*"}}; // foreach (var issue in manager.GetObjectList<Issue>(parameters)) // { // Console.WriteLine("#{0}: {1}", issue.Id, issue.Subject); // } // // //Create a issue. // var newIssue = new Issue { Subject = "test", Project = new IdentifiableName{Id = 1}}; // manager.CreateObject(newIssue); }
private void AddToList(RedmineManager manager) { var textData = textBox.Text; foreach (var issue in list) { var s = issue.Tracker.ToString(); s = s.Remove(0, 3); string vParsed = ""; var v = issue.FixedVersion; if (v != null) vParsed = v.ToString().Remove(0, 3); if (string.IsNullOrWhiteSpace(textData)) listBox.Items.Add("#" + issue.Id + ": " + s + " - " + issue.Subject + " " + vParsed); else if (vParsed.Contains(textData)) listBox.Items.Add("#" + issue.Id + ": " + s + " - " + issue.Subject + " " + vParsed); } }
private void button_Click(object sender, RoutedEventArgs e) { JasonInformations info = new JasonInformations(); var manager = new RedmineManager(info.host, textBoxUser.Text, passwordBox.Password); var parameters = new NameValueCollection { { "status_id", "*" }, { "limit", "100" } }; try { var test = manager.GetObjectList<Issue>(parameters).ToList(); MainWindow win2 = new MainWindow(); win2.manager = manager; win2.subject = info.subject; win2.list = test; win2.info = info.destinatari; win2.Show(); this.Close(); } catch (Exception ) { labelErrore.Visibility = Visibility.Visible; this.Show(); } }
public BaseService(string host, string apiKey) { RedmineService = new RedmineManager(host, apiKey); }
private Boolean connectRedmine(String url) { try { var parameters = new NameValueCollection { { "name", "*" } }; redmine = new RedmineManager(url, parser.apiKey); redmine.GetObjectList<Project>(parameters); return true; } catch (RedmineException error) { Console.WriteLine(error); return false; } }
/// <summary> /// Uploads the file asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="data">The data.</param> /// <param name="fileName"></param> /// <returns></returns> public static Task <Upload> UploadFileAsync(this RedmineManager redmineManager, byte[] data) { return(delegate { return redmineManager.UploadFile(data); }); }
private void SetMimeTypeJSON() { redmineManager = new RedmineManager(uri, apiKey, MimeFormat.json); }
private void LoadLoggerData() { _manager = new RedmineManager(Settings.HostUrl, Settings.UserApiKey); //, MimeFormat.xml, true, CultureInfo.GetCultureInfo("es-MX")); _manager.DownloadCompleted += ManagerDownloadCompleted; BusyOperations++; _manager.GetCurrentUserAsync(); }
/// <summary> /// Initializes a new instance of the <see cref="RedmineManagerInstance"/> class. /// </summary> /// <param name="address"> /// The host address. /// </param> /// <param name="apiKey"> /// The api key. /// </param> /// <param name="limit">the limit to use</param> public RedmineManagerInstance(string address, string apiKey, int limit = 100) { this._redmineApi = new RedmineManager(address, apiKey); this._redmineApi.PageSize = 50; this.Limit = limit; }
/// <summary> /// Adds the user to group asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="groupId">The group identifier.</param> /// <param name="userId">The user identifier.</param> /// <returns></returns> public static Task AddUserToGroupAsync(this RedmineManager redmineManager, int groupId, int userId) { return(delegate { redmineManager.AddUserToGroup(groupId, userId); }); }
/// <summary> /// Gets all wiki pages asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <param name="projectId">The project identifier.</param> /// <returns></returns> public static Task <IList <WikiPage> > GetAllWikiPagesAsync(this RedmineManager redmineManager, NameValueCollection parameters, string projectId) { return(delegate { return redmineManager.GetAllWikiPages(projectId); }); }
/// <summary> /// Gets the wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="parameters">The parameters.</param> /// <param name="pageName">Name of the page.</param> /// <param name="version">The version.</param> /// <returns></returns> public static Task <WikiPage> GetWikiPageAsync(this RedmineManager redmineManager, string projectId, NameValueCollection parameters, string pageName, uint version = 0) { return(delegate { return redmineManager.GetWikiPage(projectId, parameters, pageName, version); }); }
/// <summary> /// Deletes the wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="pageName">Name of the page.</param> /// <returns></returns> public static Task DeleteWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName) { return(delegate { redmineManager.DeleteWikiPage(projectId, pageName); }); }
/// <summary> /// Creates the or update wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="pageName">Name of the page.</param> /// <param name="wikiPage">The wiki page.</param> /// <returns></returns> public static Task <WikiPage> CreateOrUpdateWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName, WikiPage wikiPage) { return(delegate { return redmineManager.CreateOrUpdateWikiPage(projectId, pageName, wikiPage); }); }
/// <summary> /// Gets the current user asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static Task <User> GetCurrentUserAsync(this RedmineManager redmineManager, NameValueCollection parameters = null) { return(delegate { return redmineManager.GetCurrentUser(parameters); }); }
/// <summary> /// Downloads the file asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="address">The address.</param> /// <returns></returns> public static Task <byte[]> DownloadFileAsync(this RedmineManager redmineManager, string address) { return(delegate { return redmineManager.DownloadFile(address); }); }
/// <summary> /// Adds the watcher to issue asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="issueId">The issue identifier.</param> /// <param name="userId">The user identifier.</param> /// <returns></returns> public static Task AddWatcherToIssueAsync(this RedmineManager redmineManager, int issueId, int userId) { return(delegate { redmineManager.AddWatcherToIssue(issueId, userId); }); }
/// <summary> /// Removes the user from group asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="groupId">The group identifier.</param> /// <param name="userId">The user identifier.</param> /// <returns></returns> public static Task RemoveUserFromGroupAsync(this RedmineManager redmineManager, int groupId, int userId) { return(delegate { redmineManager.RemoveUserFromGroup(groupId, userId); }); }
public RedmineRepository(string host, string login, string password) { _rm = new RedmineManager(host, login, password); }
/// <summary> /// Deletes the wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="pageName">Name of the page.</param> /// <returns></returns> public static Task DeleteWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName) { return(Task.Factory.StartNew(() => redmineManager.DeleteWikiPage(projectId, pageName), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default)); }
public RedmineRepository(string host, string apiKey) { _rm = new RedmineManager(host, apiKey); }
private void SetMimeTypeJSON() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey, MimeFormat.json); }
private void SetMimeTypeXML() { RedmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey); }
public void Initialize() { var uri = ConfigurationManager.AppSettings["uri"]; var apiKey = ConfigurationManager.AppSettings["apiKey"]; redmineManager = new RedmineManager(uri, apiKey); }
private void SetMimeTypeJSON() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey, MimeFormat.json); }
public void RedmineUser_ShouldCompareUsers() { RedmineManager redmineSecondManager; #if JSON redmineSecondManager = new RedmineManager(uri, apiKey, MimeFormat.xml); #else redmineSecondManager = new RedmineManager(uri, apiKey, MimeFormat.json); #endif User user = redmineManager.GetObject<User>(userId, new NameValueCollection { { "include", "groups,memberships" } }); User secondUser = redmineSecondManager.GetObject<User>(userId, new NameValueCollection { { "include", "groups,memberships" } }); Assert.IsTrue(user.Equals(secondUser)); }
private void SetMimeTypeXML() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey, MimeFormat.xml); }
public BaseService(string host, string login, string password) { RedmineService = new RedmineManager(host, login, password); }
/// <summary> /// Gets all wiki pages asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <param name="projectId">The project identifier.</param> /// <returns></returns> public static async Task <List <WikiPage> > GetAllWikiPagesAsync(this RedmineManager redmineManager, NameValueCollection parameters, string projectId) { var uri = UrlHelper.GetWikisUrl(redmineManager, projectId); return(await WebApiAsyncHelper.ExecuteDownloadList <WikiPage>(redmineManager, uri, "GetAllWikiPagesAsync", parameters).ConfigureAwait(false)); }
/// <summary> /// Removes the watcher from issue asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="issueId">The issue identifier.</param> /// <param name="userId">The user identifier.</param> /// <returns></returns> public static Task RemoveWatcherFromIssueAsync(this RedmineManager redmineManager, int issueId, int userId) { return(delegate { redmineManager.RemoveWatcherFromIssue(issueId, userId); }); }
/// <summary> /// Removes an user from a group. This method does not block the calling thread. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="groupId">The group id.</param> /// <param name="userId">The user id.</param> /// <returns></returns> public static async Task DeleteUserFromGroupAsync(this RedmineManager redmineManager, int groupId, int userId) { var uri = UrlHelper.GetRemoveUserFromGroupUrl(redmineManager, groupId, userId); await WebApiAsyncHelper.ExecuteUpload(redmineManager, uri, HttpVerbs.DELETE, string.Empty, "DeleteUserFromGroupAsync").ConfigureAwait(false); }
/// <summary> /// /// </summary> /// <param name="redmineConfiguration"></param> public RedmineLogWriter(RedmineConfiguration redmineConfiguration) { this._redmineConfiguration = redmineConfiguration; this._redmineManager = new RedmineManager(this._redmineConfiguration.HostAddress, this._redmineConfiguration.ApiKey); }
/// <summary> /// Removes the watcher asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="issueId">The issue identifier.</param> /// <param name="userId">The user identifier.</param> /// <returns></returns> public static async Task RemoveWatcherAsync(this RedmineManager redmineManager, int issueId, int userId) { var uri = UrlHelper.GetRemoveWatcherUrl(redmineManager, issueId, userId); await WebApiAsyncHelper.ExecuteUpload(redmineManager, uri, HttpVerbs.DELETE, string.Empty, "RemoveWatcherAsync").ConfigureAwait(false); }
public void resetConnection() { manager = null; }
/// <summary> /// Gets the current user asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static Task <User> GetCurrentUserAsync(this RedmineManager redmineManager, NameValueCollection parameters = null) { return(Task.Factory.StartNew(() => redmineManager.GetCurrentUser(parameters), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default)); }
public RedmineServices(string host, string apiKey) { manager = new RedmineManager(host, apiKey); }
/// <summary> /// Creates a new Redmine object. This method does not block the calling thread. /// </summary> /// <typeparam name="T">The type of object to create.</typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="obj">The object to create.</param> /// <returns></returns> public static async Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj) where T : class, new() { return(await CreateObjectAsync(redmineManager, obj, null).ConfigureAwait(false)); }
/// <summary> /// Gets the wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="parameters">The parameters.</param> /// <param name="pageName">Name of the page.</param> /// <param name="version">The version.</param> /// <returns></returns> public static Task <WikiPage> GetWikiPageAsync(this RedmineManager redmineManager, string projectId, NameValueCollection parameters, string pageName, uint version = 0) { return(Task.Factory.StartNew(() => redmineManager.GetWikiPage(projectId, parameters, pageName, version), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default)); }
/// <summary> /// Updates the object asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="id">The identifier.</param> /// <param name="obj">The object.</param> /// <param name="projectId">The project identifier.</param> /// <returns></returns> public static Task UpdateObjectAsync <T>(this RedmineManager redmineManager, string id, T obj, string projectId = null) where T : class, new() { return(delegate { redmineManager.UpdateObject(id, obj, projectId); }); }
private void SetMimeTypeXml() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey); }
/// <summary> /// Gets the objects asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static Task <List <T> > GetObjectsAsync <T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new() { return(delegate { return redmineManager.GetObjects <T>(parameters); }); }
public void Initialize() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey); }
/// <summary> /// Creates the object asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="obj">The object.</param> /// <param name="ownerId">The owner identifier.</param> /// <returns></returns> public static Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj, string ownerId) where T : class, new() { return(delegate { return redmineManager.CreateObject(obj, ownerId); }); }
private void SetMimeTypeXML() { redmineManager = new RedmineManager(Helper.Uri, Helper.ApiKey, MimeFormat.xml); }
/// <summary> /// Creates the object asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="obj">The object.</param> /// <returns></returns> public static Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj) where T : class, new() { return(CreateObjectAsync(redmineManager, obj, null)); }
private void SetMimeTypeXML() { redmineManager = new RedmineManager(uri, apiKey, MimeFormat.xml); }
private void SetMimeTypeXML() { redmineManager = new RedmineManager(uri, apiKey); }
/// <summary> /// Gets the paginated objects asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static async Task <PaginatedObjects <T> > GetPaginatedObjectsAsync <T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new() { var uri = UrlHelper.GetListUrl <T>(redmineManager, parameters); return(await WebApiAsyncHelper.ExecuteDownloadPaginatedList <T>(redmineManager, uri, "GetPaginatedObjectsAsync", parameters).ConfigureAwait(false)); }
/// <summary> /// Deletes the object asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="id">The identifier.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static Task DeleteObjectAsync <T>(this RedmineManager redmineManager, string id, NameValueCollection parameters) where T : class, new() { return(delegate { redmineManager.DeleteObject <T>(id); }); }