private async Task <WindowConfigViewModel> InitializeJiraIssueViewModel <T>(JiraConfig jiraConfig, JiraQuery jiraQuery, JiraStatusCategory jiraStatusCategory) where T : JiraIssueViewModelBase, new() { string url = $"https://{jiraConfig.ApiHost}"; var jiraConfigPassword = Encoding.UTF8.GetString(Convert.FromBase64String(jiraConfig.Password)); var projectsResult = await _apiRequestService.MakeRequestWithBasicAuthAsync <List <ProjectApiModel> >(new Uri($"{url}/project"), jiraConfig.Username, jiraConfigPassword, string.Empty); var viewModel = new T { Width = jiraConfig.Width, Height = jiraConfig.Height, PageSize = jiraConfig.PageSize, StatusColors = jiraConfig.StatusColors }; if (projectsResult.StatusCode == 200) { viewModel.Projects = JiraApiService.ParseProjects(projectsResult, Convert.ToInt32(jiraConfig.Width)); } InitializeIssueAutoUpdate(url, jiraConfig, jiraQuery, viewModel, _jiraApiService, jiraStatusCategory); return(viewModel); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc(); services.AddHttpClient(); // In production, the React files will be served from this directory services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/build"; }); using (var reader = File.OpenText("jira_privatekey.pem")) { AuthenticationConfig config = new AuthenticationConfig(); Configuration.GetSection("AuthenticationConfig").Bind(config); JiraConfig jiraConfig = new JiraConfig(); Configuration.GetSection("JiraConfig").Bind(jiraConfig); config.SmallOauthConfig.SigningKey = reader.ReadToEnd(); services.AddSingleton <ISmallOauth>(sp => new SmallOauth(config.SmallOauthConfig)); services.AddSingleton <AuthenticationConfig>(config); services.AddSingleton <JiraConfig>(jiraConfig); } }
private async void InitializeIssueAutoUpdate(string url, JiraConfig jiraConfig, JiraQuery jiraQuery, JiraIssueViewModelBase viewModel, JiraApiService jiraApiService, JiraStatusCategory jiraStatusCategory) { const string apiBase = "/search"; var issueResult = await _apiRequestService.MakeRequestWithBasicAuthAsync <APIIssueRequestRoot>(new Uri($"{url}{apiBase}"), jiraConfig.Username, Encoding.UTF8.GetString(Convert.FromBase64String(jiraConfig.Password)), jiraQuery.ToString()); if (issueResult.StatusCode == 200) { viewModel.IssuesTotal = issueResult.Data.total; viewModel.AddOrUpdateNewIssues(jiraApiService.ParseIssues(issueResult)); viewModel.Refresh(); } var lastPage = IsLastPage(50, issueResult.Data.startAt, issueResult.Data.total); var startAt = 0; if (!lastPage) { startAt += issueResult.Data.issues.Length; } await SetupJiraWindow(url, apiBase, lastPage, startAt, jiraConfig, jiraQuery, viewModel, jiraApiService, issueResult.Data.total, jiraStatusCategory); }
public JiraService(IUserService userService, IOptions <JiraConfig> jiraOptions, IProjectExternalWorkspaceService projectExternalWorkspaceService, IProjectService projectService) { _userService = userService; _projectExternalWorkspaceService = projectExternalWorkspaceService; _projectService = projectService; _jiraConfig = jiraOptions.Value; }
public JiraClientTests() { var settings = TestStartup.ServiceProvider.GetService <IOptions <JiraSettings> >() !.Value; var jiraInfo = settings.JiraInfos.First(); JiraConfig = new JiraConfig(new UserLogin(jiraInfo.Auth.Login, jiraInfo.Auth.Password), jiraInfo.BaseUri); }
private static AccessTokenInfo _accessToken; // TODO: Store this persistently? public JiraController(ISmallOauth tinyOAuth, AuthenticationConfig config, JiraConfig jiraConfig, IHttpClientFactory httpClientFactory) { _smallOauth = tinyOAuth ?? throw new ArgumentNullException(nameof(tinyOAuth)); _httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory)); _config = config ?? throw new ArgumentNullException(nameof(config)); _jiraConfig = jiraConfig ?? throw new ArgumentNullException(nameof(jiraConfig)); _client = _httpClientFactory.CreateClient("client"); }
public void JiraConfigMissingApiKeyShouldNotBeValid() { var config = new JiraConfig() { BaseUrl = "https://your-org.atlassian.net/rest/api/3", ApiKey = string.Empty }; JiraConfigValidator.IsValid(config); }
public void JiraConfigShouldBeValid() { var config = new JiraConfig() { BaseUrl = "https://your-org.atlassian.net/rest/api/3", ApiKey = "some_api_key" }; Assert.IsTrue(JiraConfigValidator.IsValid(config)); }
private async Task SetupJiraWindow(string url, string apiBase, bool lastPage, int startAt, JiraConfig jiraConfig, JiraQuery jiraQuery, JiraIssueViewModelBase viewModel, JiraApiService jiraApiService, int issuesTotal, JiraStatusCategory status) { while (!lastPage) { var at = startAt; await MakeAsyncRequest(url, apiBase, jiraConfig, jiraQuery, viewModel, jiraApiService, at); lastPage = IsLastPage(50, startAt, issuesTotal); if (!lastPage) { startAt += 50; } } var lastUpdate = DateTime.Now; var refreshRate = jiraConfig.RefreshRate; var lastPageUpdate = DateTime.Now; var lastCleanup = DateTime.Now; var pageRotation = jiraConfig.PageRotation; var pageRotationRate = jiraConfig.PageRotationRate; AppHeartbeatTimer.Elapsed += delegate { Dispatcher.Invoke(async() => { if (DateTime.Now.Subtract(lastCleanup) > TimeSpan.FromHours(1)) { viewModel.Cleanup(); lastCleanup = DateTime.Now; } if (pageRotation) { if (DateTime.Now.Subtract(lastPageUpdate) > TimeSpan.FromSeconds(pageRotationRate)) { Logger.Trace($"Page update {viewModel.GetType().Name}"); viewModel.TurnPageCommand.Execute(null); lastPageUpdate = DateTime.Now; } } if (DateTime.Now.Subtract(lastUpdate) > TimeSpan.FromSeconds(refreshRate)) { Logger.Trace($"Try update {Enum.GetName(typeof(JiraStatusCategory),status)}"); MakeAsyncRequest(url, apiBase, jiraConfig, new JiraQuery().UpdatedSince(-15, JiraTimeDifference.Minutes).OrderBy("updated"), viewModel, jiraApiService, 0); lastUpdate = DateTime.Now; } }); }; }
public void JiraConfigMissingBaseUrlShouldNotBeValid() { var config = new JiraConfig() { BaseUrl = string.Empty, ApiKey = "some_api_key" }; JiraConfigValidator.IsValid(config); }
private IOptionsMonitor <JiraConfig> GetMockConfig() { var config = new JiraConfig { Host = "-", Username = "******", Pwd = "-", UserGroupName = "-" }; return(Mock.Of <IOptionsMonitor <JiraConfig> >(_ => _.CurrentValue == config)); }
public T GetClient <T>(JiraConfig config) { var httpClient = _httpClientFactory.CreateClient(); httpClient.BaseAddress = config.BaseUri; var userLogin = config.UserLogin; var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{userLogin.Login}:{userLogin.Password}")); httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString); return(RestService.For <T>(httpClient, new RefitSettings(new NewtonsoftJsonContentSerializer()))); }
private Requirement CreateOrUpdateRequirement(RequirementSet rs, JiraConfig config, JiraService.Issue.Issue issue) { Requirement req = FindRequirementForIssue(rs, issue.key); if (req == null) { req = rs.CreateRequirement(); } //Move requirement to parent string parentKey = (issue.fields.parent == null ? null : issue.fields.parent.key); if (config.parentLocatorPropertyOverride != null) { string parentKeyOverride = issue.GetValueByPath(config.parentLocatorPropertyOverride); if (parentKeyOverride != null) { parentKey = parentKeyOverride; } } if (parentKey != null) { Requirement parent = FindRequirementForIssue(rs, parentKey); if (parent != null) { parent.Move(req); } } try { req.SetAttibuteValue(Global.JiraTicket, issue.key); } catch (Exception) { throw new Exception("Please prepare project for integration (available from context menu at project level) and then try again"); } //req.SetAttibuteValue(Global.JiraDefectID, issue.id); foreach (var fieldMap in config.fieldMaps) { string jiraValue = issue.GetValueByPath(fieldMap.jiraJsonPath); try { req.SetAttibuteValue(fieldMap.toscaField, jiraValue); } catch (Exception) { //NOM NOM NOM: Tasty tasty exceptions } } return(req); }
public TSHoursRecordController(IEmployeeService employeeService, ITSHoursRecordService tsHoursRecordService, IProjectService projectService, IProjectMembershipService projectMembershipService, IUserService userService, ITSAutoHoursRecordService autoHoursRecordService, IVacationRecordService vacationRecordService, IReportingPeriodService reportingPeriodService, IDepartmentService departmentService, IProductionCalendarService productionCalendarService, IEmployeeCategoryService employeeCategoryService, IJiraService jiraService, IOptions <JiraConfig> jiraOptions, IApplicationUserService applicationUserService) : base(employeeService, tsHoursRecordService, projectService, projectMembershipService, userService, autoHoursRecordService, vacationRecordService, reportingPeriodService, departmentService, productionCalendarService, employeeCategoryService, jiraService, jiraOptions, applicationUserService) { _jiraConfig = jiraOptions.Value; }
public ImageSource GetImage(JiraConfig jiraConfig, string uri) { lock (@object) { if (imageCache.ContainsKey(uri)) { return(imageCache[uri]); } var uriParts = uri.Split('?'); var lastIndex = uriParts[0].LastIndexOf('/'); var endpoint = uriParts[0].Substring(lastIndex); var result = _apiRequestService.MakeStreamRequestWithBasicAuth(new Uri(uriParts[0]), jiraConfig.Username, jiraConfig.Password, $"?{uriParts[1]}"); return(BitmapFrame.Create(result.Data, BitmapCreateOptions.None, BitmapCacheOption.None)); } }
public static void SaveConfig(this OwnedItem item, JiraConfig config) { string fileContent = JsonConvert.SerializeObject(config, Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); if (item.AttachedFiles.Any(f => f.Name == Global.JiraConfigAttachmentName)) { var previousConfig = item.AttachedFiles.First(f => f.Name == Global.JiraConfigAttachmentName); previousConfig.Delete(MsgBoxResult_OkCancel.Ok, MsgBoxResult_YesNo.Yes); } string tempFilePath = Environment.ExpandEnvironmentVariables($"%tricentis_projects%\\{Global.JiraConfigAttachmentName}"); File.WriteAllText(tempFilePath, fileContent); item.AttachFile(tempFilePath, "Embedded"); }
private async Task MakeAsyncRequest(string url, string apiBase, JiraConfig jiraConfig, JiraQuery jiraQuery, JiraIssueViewModelBase viewModel, JiraApiService jiraApiService, int startAt) { async void Callback() { var issueResult = await _apiRequestService.MakeRequestWithBasicAuthAsync <APIIssueRequestRoot>( new Uri($"{url}{apiBase}"), jiraConfig.Username, Encoding.UTF8.GetString(Convert.FromBase64String(jiraConfig.Password)), $"{jiraQuery}&startAt={startAt}"); if (issueResult.StatusCode == 200) { viewModel.AddOrUpdateNewIssues(jiraApiService.ParseIssues(issueResult)); viewModel.Refresh(); } else { throw new NotImplementedException(); } } await Task.Run(() => Dispatcher.Invoke(Callback)); }
public JiraConnector(JiraConfig jiraConfig) { this.jiraConnection = Jira.CreateRestClient((string)jiraConfig.Url, (string)jiraConfig.UserId, (string)jiraConfig.Password); this.projectName = jiraConfig.Project; }
protected void When_config_file_is(string configFile) { string path = string.Concat(@"Jira\TestConfigurations\", configFile); Configuration appConfig = ConfigLoader.Load(path); jiraConfig = (JiraConfig)JiraConfig.GetConfiguration(appConfig); }
public FilterStore(JiraConfig config) : base(config) { }
public override TCObject Execute(TCObject requirementSet, TCAddOnTaskContext taskContext) { RequirementSet rs = (RequirementSet)requirementSet; JiraConfig config = rs.GetJiraConfig(); #region Setup if (config == null) { string url = taskContext.GetStringValue("Jira Instance URL: ", false); string jqlValue = taskContext.GetStringValue("JQL Filter for requirements: ", false); config = new JiraConfig { baseURL = url, jqlFilter = jqlValue, fieldMaps = new List <FieldMap>() { new FieldMap { direction = JiraService.Configuration.Direction.jira_to_tosca, jiraJsonPath = "$.fields.summary", toscaField = "Name" } } }; rs.SaveConfig(config); } string username, password; if (CredentialManager.Instance.Credentials.Any(x => x.BaseURL == config.baseURL)) { Credential credential = CredentialManager.Instance.Credentials.First(x => x.BaseURL == config.baseURL); username = credential.Username; password = credential.Password; } else { username = taskContext.GetStringValue("Jira Username", false); password = taskContext.GetStringValue("Jira Password", true); CredentialManager.Instance.StoreOrUpdateCredential(new Credential { BaseURL = config.baseURL, Description = "Created by Jira Config", Username = username, Password = password }); } #endregion var jira = new JiraService.Jira(config.baseURL, username, password); var issueService = jira.GetIssueService(); String startTime = DateTime.Now.ToString("yyyyMMddHHmmss"); string jql = config.jqlFilter; JiraService.Issue.Issue[] issues = null; Task <JiraService.Issue.Issue[]> issueTask = null; try { issueTask = issueService.SearchAsync(jql); while (!issueTask.IsCompleted) { taskContext.ShowStatusInfo($"Gettign issues for JQL: {jql}"); System.Threading.Thread.Sleep(100); } //order the issues so that subtasks are not created before parent tasks issues = issueTask.Result.OrderBy(x => x.fields.project.name).ThenBy(x => x.id).ToArray(); taskContext.ShowStatusInfo("Creating Requirements"); } catch (Exception e) { string err = e.Message; if (e.InnerException != null) { err += "\r\n" + e.InnerException.Message; } taskContext.ShowErrorMessage($"Error synchronising", err); taskContext.ShowStatusInfo($"Error synchronising: {err}"); return(requirementSet); } HashSet <string> updatedItems = new HashSet <string>(); if (issues != null) { foreach (var issue in issues) { var req = CreateOrUpdateRequirement(rs, config, issue); updatedItems.Add(req.UniqueId); } // Prompt status taskContext.ShowMessageBox("Jira Sync", issues.Length.ToString() + " requirements have been synchronised."); } return(null); }
public HttpClientUtils(IOptions <JiraConfig> config) { _config = config.Value; }
public IssueStore(JiraConfig config) : base(config) { }
/* JiraReportConfig file constructor */ public JiraReportConfig(string config_file=null) { /* Init the variables */ jira_config = new JiraConfig(); file_config = new FileConfig(); email_config = new EmailConfig(); client_config = new List<ClientConfig>(); template_config = new TemplateMarkup(); if (config_file != null) { if (!LoadConfig(config_file)) { Console.WriteLine("Unable to read XML config file: " + config_file); } else { Console.WriteLine("XML config file parsed successfully"); } } }
public JiraStateWriter(JiraConfig jiraConfig, TeamMap map) { _issueStore = new IssueStore(jiraConfig); _changelogStore = new ChangelogStore(jiraConfig); _teamMap = map; }
public DashService(IOptionsMonitor <JiraConfig> jiraConfig) { _jiraConfig = jiraConfig.CurrentValue; }
public override TCObject Execute(TCObject objectToExecuteOn, TCAddOnTaskContext taskContext) { TCFolder f = (TCFolder)objectToExecuteOn; IEnumerable <Issue> childIssues = f.Search("->SUBPARTS:Issue").Cast <Issue>(); var config = f.GetJiraConfig(); if (config == null) { string url = taskContext.GetStringValue("Jira Instance URL: ", false); string project = taskContext.GetStringValue("Jira Project Key: ", false); config = new JiraConfig { baseURL = url, projectKey = project, fieldMaps = new List <FieldMap>() }; f.SaveConfig(config); } string username, password; if (CredentialManager.Instance.Credentials.Any(x => x.BaseURL == config.baseURL)) { Credential credential = CredentialManager.Instance.Credentials.First(x => x.BaseURL == config.baseURL); username = credential.Username; password = credential.Password; } else { username = taskContext.GetStringValue("Jira Username", false); password = taskContext.GetStringValue("Jira Password", true); CredentialManager.Instance.StoreOrUpdateCredential(new Credential { BaseURL = config.baseURL, Description = "Created by Jira Config", Username = username, Password = password }); } var jira = new JiraService.Jira(config.baseURL, username, password); var issueService = jira.GetIssueService(); foreach (var issue in childIssues) { string storedIssueKey = string.Empty; try { storedIssueKey = issue.GetAttributeValue(Global.JiraTicket); } catch (Exception) { throw new Exception("Please prepare project for integration (available from context menu at project level) and then try again"); } if (!string.IsNullOrEmpty(storedIssueKey)) { var jiraIssue = issueService.GetAsync(storedIssueKey).Result; issue.State = jiraIssue.fields.status.name; issue.Name = jiraIssue.fields.summary; } else //No existing Jira issue exists { string description = issue.Description; if (issue.Links.Any()) { try { var executionLog = issue.Links.First().ExecutionTestCaseLog; string executionTableHeader = $"||Step||Result||Description||Duration(sec)"; string executionTable = null; foreach (ExecutionXTestStepLog logEntry in executionLog.ExecutionSubLogs) { string stepDesc = logEntry.AggregatedDescription; if (logEntry.TestStepValueLogsInRightOrder.Count() > 0) { stepDesc = null; foreach (var stepVal in logEntry.TestStepValueLogsInRightOrder) { string act = $"{(stepVal.Result == ExecutionResult.Passed ? "(/)" : "(x)")} - {stepVal.DisplayedName} - {stepVal.LogInfo}"; if (stepDesc == null) { stepDesc = act; } else { stepDesc = stepDesc + "\r\n" + act; } } } stepDesc = stepDesc.Replace('{', ' ').Replace('}', ' ').Replace('|', ' ').Trim(); string entry = $"|{logEntry.DisplayedName} |{(logEntry.Result == ExecutionResult.Passed ? "{color:#14892c}" : "{color:#d04437}") + logEntry.Result + "{color}"} |{stepDesc}|{Math.Round(logEntry.Duration / 1000,2)}s|"; if (executionTable == null) { executionTable = entry; } else { executionTable += "\r\n" + entry; } } description = $"*TEST*: {executionLog.Name}\r\n*Description*:\r\n{executionTableHeader}\r\n{executionTable}"; } catch (Exception) { description = issue.Description; } } var newIssue = new JiraService.Issue.Issue { fields = new JiraService.Issue.IssueFields { summary = issue.Name, description = description, //Create other fields here project = new JiraService.Issue.Field.ProjectField { key = config.projectKey }, issuetype = new JiraService.Issue.Field.IssueTypeField { name = "Bug" } } }; foreach (var defaultValue in config.defaultValues) { newIssue.SetValueByPath(defaultValue.jiraJsonPath, defaultValue.defaultValue); } JiraService.Issue.Issue createdIssue = issueService.CreateAsync(newIssue).Result; createdIssue = issueService.GetAsync(createdIssue.key).Result; //The created issue only contains a shell, no fields issue.SetAttibuteValue(Global.JiraTicket, createdIssue.key); issue.State = createdIssue.fields.status.name; } } return(objectToExecuteOn); }
public ConfigViewModel(JiraService.Configuration.JiraConfig config) { this.config = config; }
public ConfigViewModel() { this.config = new JiraConfig(); }
public JiraLoader(IOptionsMonitor <JiraConfig> jiraConfig) { _jiraConfig = jiraConfig.CurrentValue; _jiraClient = GetClient(); }
public JiraStore(JiraConfig config) { _config = config; _client = new HttpClient(); _client.DefaultRequestHeaders.Add("Authorization", _config.ApiKey); }
public override TCObject Execute(TCObject objectToExecuteOn, TCAddOnTaskContext taskContext) { TCFolder f = (TCFolder)objectToExecuteOn; IEnumerable <Issue> childIssues = f.Search("->SUBPARTS:Issue").Cast <Issue>(); var config = f.GetJiraConfig(); if (config == null) { string url = taskContext.GetStringValue("Jira Instance URL: ", false); string project = taskContext.GetStringValue("Jira Project Key: ", false); config = new JiraConfig { baseURL = url, projectKey = project, fieldMaps = new List <FieldMap>() }; f.SaveConfig(config); } string username, password; if (CredentialManager.Instance.Credentials.Any(x => x.BaseURL == config.baseURL)) { Credential credential = CredentialManager.Instance.Credentials.First(x => x.BaseURL == config.baseURL); username = credential.Username; password = credential.Password; } else { username = taskContext.GetStringValue("Jira Username", false); password = taskContext.GetStringValue("Jira Password", true); CredentialManager.Instance.StoreOrUpdateCredential(new Credential { BaseURL = config.baseURL, Description = "Created by Jira Config", Username = username, Password = password }); } var jira = new JiraService.Jira(config.baseURL, username, password); var issueService = jira.GetIssueService(); foreach (var issue in childIssues) { string storedIssueKey = string.Empty; try { storedIssueKey = issue.GetAttributeValue(Global.JiraTicket); } catch (Exception) { throw new Exception("Please prepare project for integration (available from context menu at project level) and then try again"); } if (!string.IsNullOrEmpty(storedIssueKey)) { var jiraIssue = issueService.GetAsync(storedIssueKey).Result; issue.State = jiraIssue.fields.status.name; issue.Name = jiraIssue.fields.summary; } else //No existing Jira issue exists { string description = issue.Description; if (issue.Links.Any()) { var executionLog = issue.Links.First().ExecutionTestCaseLog; description = $"TEST: {executionLog.Name}\r\n{executionLog.AggregatedDescription}"; } var newIssue = new JiraService.Issue.Issue { fields = new JiraService.Issue.IssueFields { summary = issue.Name, description = description, //Create other fields here project = new JiraService.Issue.Field.ProjectField { key = config.projectKey }, issuetype = new JiraService.Issue.Field.IssueTypeField { name = "Bug" } } }; foreach (var defaultValue in config.defaultValues) { newIssue.SetValueByPath(defaultValue.jiraJsonPath, defaultValue.defaultValue); } JiraService.Issue.Issue createdIssue = issueService.CreateAsync(newIssue).Result; createdIssue = issueService.GetAsync(createdIssue.key).Result; //The created issue only contains a shell, no fields issue.SetAttibuteValue(Global.JiraTicket, createdIssue.key); issue.State = createdIssue.fields.status.name; } } return(objectToExecuteOn); }