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);
}
