public void ReleaseVersion(Jira jira, string project, string version)
{
Argument.IsNotNull(() => jira);
Argument.IsNotNullOrWhitespace(() => project);
Argument.IsNotNullOrWhitespace(() => version);
Log.Info("Releasing version {0}", version);
var existingVersion = GetProjectVersion(jira, project, version);
if (existingVersion == null)
{
string error = string.Format("Version {0} does not exist, make sure to create it first", version);
Log.Error(error);
throw new InvalidOperationException(error);
}
if (existingVersion.IsReleased)
{
Log.Info("Version was already released on {0}", existingVersion.ReleasedDate);
return;
}
var token = jira.GetToken();
var jiraService = jira.GetJiraSoapService();
var remoteVersion = GetVersion(jiraService, token, project, version);
remoteVersion.releaseDate = DateTime.Now;
remoteVersion.released = true;
jiraService.ReleaseVersion(token, project, remoteVersion);
Log.Info("Released version {0}", version);
}
public List<Issue> GetIssuesResolvedSinceDate(DateTime dateTime)
{
var jira = new Jira(_jiraSettings.Url, _jiraSettings.UserName, _jiraSettings.Passsword);
IssueStatus status = jira.GetIssueStatuses().FirstOrDefault(x => x.Name == "Resolved");
var jiraIssues = from i in jira.Issues
where i.Status == status && i.Project == _jiraSettings.ProjectName
orderby i.Created
select i;
var issues = new List<Issue>();
foreach (var jiraIssue in jiraIssues.ToList())
{
issues.Add(new Issue()
{
DateResolved = jiraIssue.Updated.Value,
Description = jiraIssue.Description,
IssueNumber = jiraIssue.Key.Value,
Reporter = jiraIssue.Reporter
});
}
return issues;
}
public void GetWorklogTest()
{
MockJiraClient mockClient = new MockJiraClient();
Jira jira = new Jira();
jira.Connect(mockClient);
//The first test issue contains 2 worklogs. One from Jonas, One from Marc
Issue firstIssue = mockClient.GetIssue("ITDEV-7");
firstIssue.SetJira(jira);
Assert.NotNull(firstIssue.GetWorklogs());
Assert.Equal(2, firstIssue.GetWorklogs().Count);
Assert.Equal("jverdick", firstIssue.GetWorklogs()[0].Author.Username);
Assert.Equal("mwillem", firstIssue.GetWorklogs()[1].Author.Username);
//The second test issue contains 1 worklogs from Marc
Issue secondIssue = mockClient.GetIssue("ITDEV-6");
secondIssue.SetJira(jira);
Assert.NotNull(secondIssue.GetWorklogs());
Assert.Equal(1, secondIssue.GetWorklogs().Count);
Assert.Equal("mwillem", secondIssue.GetWorklogs()[0].Author.Username);
Assert.Equal("http://jira.example.com/browse/ITDEV-6", secondIssue.Url);
}
// Access token is only available in SOAP API.
void WithAccessTokenInsteadOfUserAndPassword()
{
// get access token for user
var accessToken = _jira.GetAccessToken();
// create a new jira instance using access token only
var jiraAccessToken = Jira.CreateSoapClient(HOST, accessToken, new JiraCredentials(null));
// create and query issues
var summaryValue = "Test Summary from JIRA with access token " + _random.Next(int.MaxValue);
var issue = new Issue(jiraAccessToken, "TST")
{
Type = "1",
Summary = summaryValue,
Assignee = "admin"
};
issue.SaveChanges();
var issues = (from i in jiraAccessToken.Issues
where i.Key == issue.Key
select i).ToArray();
Assert.Equal(1, issues.Count());
}
public UserController(GTTContext context)
{
this._context = context;
if (this._context.Users.Count() == 0)
{
Console.WriteLine("No existe ningun usuario");
User newUser = new User();
newUser.username = "******";
newUser.password = Encrypt.Hash("1234");
newUser.role = Role.admin;
User newUser2 = new User();
newUser2.username = "******";
newUser2.password = Encrypt.Hash("1234");
newUser2.role = Role.user;
this._context.Users.Add(newUser);
this._context.Users.Add(newUser2);
this._context.SaveChanges();
}
if (this._context.Jiras.Count() == 0)
{
Console.WriteLine("No existe ningun usuario Jira");
Jira newJira = new Jira();
newJira.username = "******";
newJira.password = "******";
newJira.component = "Arquitectura...";
newJira.url = "https://edunavarro13.atlassian.net";
newJira.proyect = "SIT";
newJira.idUser = 1;
this._context.Jiras.Add(newJira);
this._context.SaveChanges();
}
}
public void CreateIssueTest(string Summary, string issueType, string Priority, string component, string Descriprion)
{
XMLParse _oWaXmlData = new XMLParse();
_oWaXmlData.LoadXML("../../Config/ApplicationSettings.xml");
jiraURL = _oWaXmlData.getData("settings/JiraCredentials", "URL");
jiraUsername = _oWaXmlData.getData("settings/JiraCredentials", "UserName");
jiraPassword = _oWaXmlData.getData("settings/JiraCredentials", "Password");
// jiraConn = new Jira(jiraURL[0], jiraUsername[0], jiraPassword[0]);
jiraConn = new Jira("http://crmpegasus.com/", "Akhan", "WelcometoJira!");
Console.WriteLine("Login success create issue");
Summary = "[Automated Test Script] Testing " + Summary + " Script Failure Test";
Issue issue = jiraConn.CreateIssue("PEG");
try
{
issue.Summary = Summary;
issue.Type = issueType;
issue.Priority = Priority;
// issue.Assignee = Assignee;
issue.Description = Descriprion;
issue.SaveChanges();
Console.WriteLine("Issue Created Successfully");
CheckExstingIssue(Summary);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void JiraAuthComplete(string code)
{
try
{
if (!string.IsNullOrEmpty(code) && Config.JiraOAuthInfo != null && !string.IsNullOrEmpty(Config.JiraOAuthInfo.AuthToken) && !string.IsNullOrEmpty(Config.JiraOAuthInfo.AuthSecret))
{
Jira jira = new Jira(Config.JiraHost, Config.JiraOAuthInfo);
bool result = jira.GetAccessToken(code);
if (result)
{
oAuthJira.Status = OAuthLoginStatus.LoginSuccessful;
MessageBox.Show(Resources.UploadersConfigForm_Login_successful, "ShareX", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
oAuthJira.Status = OAuthLoginStatus.LoginFailed;
MessageBox.Show(Resources.UploadersConfigForm_Login_failed, "ShareX", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
catch (Exception ex)
{
ex.ShowError();
}
}
public void GetWorklogTest()
{
MockJiraClient mockClient = new MockJiraClient();
Jira jira = new Jira();
jira.Connect(mockClient);
//The first test issue contains 2 worklogs. One from Jonas, One from Marc
Issue firstIssue = mockClient.GetIssue("ITDEV-7");
firstIssue.SetJira(jira);
Assert.NotNull(firstIssue.GetWorklogs());
Assert.Equal(2, firstIssue.GetWorklogs().Count);
Assert.Equal("jverdick", firstIssue.GetWorklogs()[0].Author.Username);
Assert.Equal("mwillem", firstIssue.GetWorklogs()[1].Author.Username);
//The second test issue contains 1 worklogs from Marc
Issue secondIssue = mockClient.GetIssue("ITDEV-6");
secondIssue.SetJira(jira);
Assert.NotNull(secondIssue.GetWorklogs());
Assert.Equal(1, secondIssue.GetWorklogs().Count);
Assert.Equal("mwillem", secondIssue.GetWorklogs()[0].Author.Username);
Assert.Equal("http://jira.example.com/browse/ITDEV-6", secondIssue.Url);
}
public static List <JiraDataModel> GetJiraLastNMonthClosedByUser(int monthsToConsider, string userName, DateTime CurrDate)
{
var list = new List <JiraDataModel>();
// create a connection to JIRA
var jira = Jira.CreateRestClient(jiraURL, jiraUserName, jiraPassword);
jira.MaxIssuesPerRequest = jiraRequestLimit;
// try catch becuase if jiraKey is invalid, it throws exception
try
{
IEnumerable <Atlassian.Jira.Issue> issues;
issues = (from i in jira.Issues
where i.Assignee == userName.ToLower() //&& i.Status == "Closed" && i.Priority != "Minor" && i.Priority != "Trivial" //&& !i.Key.Value.StartsWith("RNMDE") && !i.Key.Value.StartsWith("HR")
select i).OrderBy(r => r.Priority).ThenBy(r => r.Updated);
issues = (from i in issues
where
DateTime.Compare(i.Updated.Value, CurrDate.AddMonths(-monthsToConsider)) >= 0 &&
(i.Updated.Value.Year == DateTime.Now.Year)
select i);
foreach (var issue in issues.ToList())
{
list.Add(MapFromJiraIssueToModel(issue));
}
}
catch
{
}
return(list);
}
public static List <JiraDataModel> GetAllClosedJiras(JiraDataModel searchData)
{
var list = new List <JiraDataModel>();
// create a connection to JIRA
var jira = Jira.CreateRestClient(jiraURL, jiraUserName, jiraPassword);
jira.MaxIssuesPerRequest = jiraRequestLimit;
// try catch becuase if jiraKey is invalid, it throws exception
try
{
IEnumerable <Atlassian.Jira.Issue> issues;
issues = (from i in jira.Issues select i);
issues = (from i in issues
where i.Status.Name == "Closed"
select i);
foreach (var issue in issues.ToList())
{
list.Add(MapFromJiraIssueToModel(issue));
}
}
catch
{
}
return(list);
}
public async Task <string> CreateNewItem(WorkItem wi)
{
var user = AuthHelper.GetCurrentUser();
try
{
//Create an epic in JIRA
var jira = Jira.CreateRestClient(JIRAUrl, JIRAUserName, JIRAPassword);
var issue = jira.CreateIssue("QSPEAR");
issue.Type = "Task";
issue.Priority = "Medium";
issue.Summary = wi.Title;
issue.Description = wi.Description;
issue["Epic Link"] = user.JIRAEpicId;
await issue.SaveChangesAsync();
if (!string.IsNullOrEmpty(wi.FileName))
{
UploadAttachmentInfo ai = new UploadAttachmentInfo(wi.FileName,
Convert.FromBase64String(wi.Attachment.Replace("data:text/plain;base64,", "")));
await issue.AddAttachmentAsync(new UploadAttachmentInfo[] { ai });
}
return(issue.Key.Value);
}
catch (Exception ex)
{
throw ex;
}
}
public static List <JiraDataModel> GetByUser(string userName, string jiraStatus = "")
{
var list = new List <JiraDataModel>();
// create a connection to JIRA
var jira = Jira.CreateRestClient(jiraURL, jiraUserName, jiraPassword);
jira.MaxIssuesPerRequest = jiraRequestLimit;
// try catch becuase if jiraKey is invalid, it throws exception
try
{
IEnumerable <Atlassian.Jira.Issue> issues;
if (!string.IsNullOrEmpty(jiraStatus))
{
if (!string.IsNullOrEmpty(userName))
{
issues = (from i in jira.Issues
where i.Assignee == userName && i.Priority != "Minor" && i.Priority != "Trivial" &&
i.Status == jiraStatus
select i);
}
else
{
issues = (from i in jira.Issues
where i.Priority != "Minor" && i.Priority != "Trivial" &&
i.Status == jiraStatus
select i);
}
}
else
{
if (!string.IsNullOrEmpty(userName))
{
issues = (from i in jira.Issues
where i.Assignee == userName && i.Priority != "Minor" && i.Priority != "Trivial" &&
(i.Status == "Open" || i.Status == "Reopened" || i.Status == "QA" || i.Status == "In Progress" || i.Status == "Continuous Monitoring")
select i);
}
else
{
issues = (from i in jira.Issues
where i.Priority != "Minor" && i.Priority != "Trivial" &&
(i.Status == "Open" || i.Status == "Reopened" || i.Status == "QA" || i.Status == "In Progress" || i.Status == "Continuous Monitoring")
select i);
}
}
foreach (var issue in issues.ToList())
{
list.Add(MapFromJiraIssueToModel(issue));
}
}
catch
{
}
return(list);
}
void GetIssue()
{
try
{
if (String.Empty.Equals(txtIssueNumber.Text))
{
return;
}
ClearDisplay();
var jira = Jira.CreateRestClient("https://centeredge.atlassian.net", "rroberts", "hel-j205");
var issueNumber = txtIssueNumber.Text.Trim();
try
{
_jiraIssue = jira.GetIssue($"ADVANTAGE-{issueNumber}");
jiraIssueView1.UpdateDisplay(_jiraIssue);
txtTitle.Text = _jiraIssue.Summary;
}
catch (Exception ex)
{
// DisplayErrorMessage($"Issue {issueNumber} Not Found!");
DisplayErrorMessage(ex.Message);
Console.WriteLine(ex.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
DisplayErrorMessage(ex.ToString());
}
}
private void UpdateJiraSettings()
{
if (!_enabledSettings.ValueOrDefault(Settings))
{
return;
}
var url = _urlSettings.ValueOrDefault(Settings);
var userName = _userSettings.ValueOrDefault(Settings);
var password = _passwordSettings.ValueOrDefault(Settings);
if (string.IsNullOrWhiteSpace(url) || string.IsNullOrWhiteSpace(userName))
{
return;
}
_jira = Jira.CreateRestClient(url, userName, password);
_query = _jqlQuerySettings.ValueOrDefault(Settings);
_stringTemplate = _stringTemplateSetting.ValueOrDefault(Settings);
if (_btnPreview == null)
{
return;
}
_btnPreview.Click -= btnPreviewClick;
_btnPreview = null;
}
public async void TestNotif()
{
try
{
IEnumerable <Issue> jiraIssues = await _Jira.Issues.GetIssuesFromJqlAsync("Project=LAC");
string laissue = "";
string jira = "";
foreach (var issue in jiraIssues)
{
if (issue.Project.Equals("LAC"))
{
jira += "\n" + issue.Key.Value + " - " + GetTimeLeft(issue.Created.Value, 15).ToString() + " minutes left\n" + issue.Summary;
laissue = issue.Key.Value;
break;
}
}
int duration = 30;
var animationMethod = FormAnimator.AnimationMethod.Slide;
var animationDirection = Directions[Setting.Value.Notification_Direction];
ToastNotification("LA County Issues", "New Jira Issue" + jira, duration, animationMethod, animationDirection, laissue);
}
catch
{
}
}
private void btnPreviewClick(object sender, EventArgs eventArgs)
{
try
{
_btnPreview.Enabled = false;
var localJira = Jira.CreateRestClient(_urlSettings.CustomControl.Text, _credentialsSettings.CustomControl.UserName,
_credentialsSettings.CustomControl.Password);
var localQuery = _jqlQuerySettings.CustomControl.Text;
var localStringTemplate = _stringTemplateSetting.CustomControl.Text;
ThreadHelper.JoinableTaskFactory.RunAsync(
async() =>
{
var message = await GetMessageToCommitAsync(localJira, localQuery, localStringTemplate);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var preview = message.FirstOrDefault();
MessageBox.Show(null, preview == null ? EmptyQueryResultMessage.Text : preview.Text, EmptyQueryResultCaption.Text);
_btnPreview.Enabled = true;
});
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
_btnPreview.Enabled = true;
}
}
public void AddAttachment(string path, string issueID)
{
XMLParse _oWaXmlData = new XMLParse();
_oWaXmlData.LoadXML("../../Config/ApplicationSettings.xml");
jiraURL = _oWaXmlData.getData("settings/JiraCredentials", "URL");
jiraUsername = _oWaXmlData.getData("settings/JiraCredentials", "UserName");
jiraPassword = _oWaXmlData.getData("settings/JiraCredentials", "Password");
jiraConn = new Jira(jiraURL[0], jiraUsername[0], jiraPassword[0]);
string jqlString = "project = PegasusCRM AND issuetype = Bug";
bool result = false;
IEnumerable<Atlassian.Jira.Issue> jiraIssues = jiraConn.GetIssuesFromJql(jqlString);
foreach (var issue in jiraIssues)
{
if (issue.Key.Value == issueID)
{
Issue foundissue = jiraConn.GetIssue(issueID);
foundissue.AddAttachment(path);
Console.WriteLine("Attachment Added Successfully");
foundissue.SaveChanges();
result = true;
break;
}
}
if (!result)
{
Console.WriteLine("Failed To Add Attachment");
}
}
public void Close()
{
if (_jira != null)
{
_jira = null;
}
}
public void AddAttachment(string path, string issueID)
{
XMLParse _oWaXmlData = new XMLParse();
_oWaXmlData.LoadXML("../../Config/ApplicationSettings.xml");
jiraURL = _oWaXmlData.getData("settings/JiraCredentials", "URL");
jiraUsername = _oWaXmlData.getData("settings/JiraCredentials", "UserName");
jiraPassword = _oWaXmlData.getData("settings/JiraCredentials", "Password");
// jiraConn = new Jira(jiraURL[0], jiraUsername[0], jiraPassword[0]);
jiraConn = new Jira("http://crmpegasus.com/", "Akhan", "WelcometoJira!");
Console.WriteLine("Login success add attachment");
string jqlString = "project = PegasusCRM AND issuetype = Bug";
bool result = false;
IEnumerable <Atlassian.Jira.Issue> jiraIssues = jiraConn.GetIssuesFromJql(jqlString);
foreach (var issue in jiraIssues)
{
if (issue.Key.Value == issueID)
{
Issue foundissue = jiraConn.GetIssue(issueID);
foundissue.AddAttachment(path);
Console.WriteLine("Attachment Added Successfully");
foundissue.SaveChanges();
result = true;
break;
}
}
if (!result)
{
Console.WriteLine("Failed To Add Attachment");
}
}
static void Main(string[] args)
{
string project = "myProject";
//my setup required to look at everything under an initiative
string parentInitiative = "parentInitiative";
string vstsUrl = "https://mycompany.visualstudio.com";
string vstsPAT = "mypersonalaccesstoken";
VssConnection connection = new VssConnection(new Uri(vstsUrl), new VssBasicCredential(string.Empty, vstsPAT));
witClient = connection.GetClient <WorkItemTrackingHttpClient>();
string jUserID = "myjirausername";
string jPassword = "******";
string jUrl = "https://mycompany.atlassian.net";
Jira jiraConn = Jira.CreateRestClient(jUrl, jUserID, jPassword);
jiraConn.MaxIssuesPerRequest = 1000;
//set a breakpoint here to get a list of all VSTS fields
//var fieldlist = witClient.GetFieldsAsync("myvstsproject").Result;
//var testItem = witClient.GetWorkItemAsync(1, expand: WorkItemExpand.All).Result;
var issues = (from i in jiraConn.Issues.Queryable where i.Created > DateTime.Now.AddDays(-30) orderby i.Priority select i).ToList();
//inourjira 10000 was the id for an epic and 10001 was story this could potentially be different in yours but unlikely also you may need to add extras for custom types
IList filterEpics = (from i in issues where i.Type.Id == "10000" && i.CustomFields[2].Values[0] == parentInitiative select i).ToList();
List <Issue> filterStory = (from i in issues where i.Type.Id == "10001" select i).ToList();
List <Issue> filterTask = (from i in issues where i.ParentIssueKey != null select i).ToList();
foreach (Issue epic in filterEpics)
{
WorkItem epicInfo;
List <Issue> epicChildStory = new List <Issue>();
foreach (Issue story in filterStory)
{
foreach (CustomFieldValue item in story.CustomFields)
{
if (item.Values[0] == epic.Key.Value)
{
epicChildStory.Add(story);
}
}
}
epicInfo = addWorkItem(epic, project, "Feature");
foreach (Issue story in epicChildStory)
{
WorkItem storyInfo;
storyInfo = addWorkItem(story, project, "Product Backlog Item", epicInfo);
List <Issue> StoryChildTask = new List <Issue>();
StoryChildTask = (from i in filterTask where i.ParentIssueKey == story.Key.Value select i).ToList();
foreach (Issue task in StoryChildTask)
{
addWorkItem(task, project, "Task", storyInfo);
}
}
}
Console.ReadLine();
}
public void Issue_has_correct_url()
{
var issue = new Issue("TST-123");
var jiraUrl = "http://the-jira-site.com";
Jira.Configure(jiraUrl, "user", "pass");
issue.Url.ShouldBe(jiraUrl + "/browse/" + issue.Key);
}
public AtlassianClient(AtlassianSettings settings)
{
Settings = settings;
JiraRestClientSettings set = new JiraRestClientSettings();
set.EnableRequestTrace = true;
JiraClient = Jira.CreateOAuthRestClient(Settings.JiraURL, Settings.ConsumerKey, Settings.ConsumerSecret, Settings.OAuthAccessToken, Settings.OAuthAccessSecret, settings: set);
}
private void DoLogin()
{
if (DataContext is MainViewModel)
{
((MainViewModel)DataContext).RegisterJiraInstanceAsSingleton(Jira.CreateRestClient(_serverUrl.Text, username.Text, pwd.Password));
((MainViewModel)DataContext).Init();
}
}
public void QueryWithZeroResults(Jira jira)
{
var issues = from i in jira.Issues.Queryable
where i.Created == new DateTime(2010, 1, 1)
select i;
Assert.Equal(0, issues.Count());
}
public TfsToJiraController(ApplicationDbContext context)
{
_context = context;
Env.InitEnvs();
_jira = Jira.CreateRestClient(Env.JIRA_SERVER_URI, Env.JIRA_USER, Env.JIRA_PASSWORD);
//_jira.RestClient.RestSharpClient.Proxy = WebRequest.GetSystemWebProxy();
//_jira.RestClient.RestSharpClient.Proxy.Credentials = CredentialCache.DefaultCredentials;
}
private ProjectVersion GetProjectVersion(Jira jira, string project, string version)
{
var existingVersion = (from x in jira.GetProjectVersions(project)
where string.Equals(x.Name, version, StringComparison.OrdinalIgnoreCase)
select x).FirstOrDefault();
return(existingVersion);
}
public void GetProjects(Jira jira)
{
var projects = jira.Projects.GetProjectsAsync().Result;
Assert.True(projects.Count() > 0);
Assert.Equal("admin", projects.First().Lead);
Assert.Equal("admin", projects.First().LeadUser.DisplayName);
}
public void GetProject(Jira jira)
{
var project = jira.Projects.GetProjectAsync("TST").Result;
Assert.Equal("admin", project.Lead);
Assert.Equal("admin", project.LeadUser.DisplayName);
Assert.Equal("Test Project", project.Name);
}
public JiraService(IAppConfigService appConfigService)
{
var appConfigService1 = appConfigService;
_jira = Jira.CreateRestClient(appConfigService1.Config.JiraConfig.Endpoint,
appConfigService1.Config.JiraConfig.Username,
appConfigService1.Config.JiraConfig.Password);
}
public async Task GetIssueTypes(Jira jira)
{
var project = await jira.Projects.GetProjectAsync("TST");
var issueTypes = await project.GetIssueTypesAsync();
Assert.True(issueTypes.Any());
}
public void QueryIssueWithCustomDateField(Jira jira)
{
var issue = (from i in jira.Issues.Queryable
where i["Custom Date Field"] <= new DateTime(2012, 4, 1)
select i).First();
Assert.Equal("Sample bug in Test Project", issue.Summary);
}
public Jira GetInstanciaJira()
{
string UserName = "******";
string Senha = "jEZkla9Ecla4fQEJyNeuFBC3";
string Servico = "https://gogogoninjas.atlassian.net/";
return(Jira.CreateRestClient(Servico, UserName, Senha));
}
public async Task GetServerInfoWithoutHealthCheck(Jira jira)
{
var serverInfo = await jira.ServerInfo.GetServerInfoAsync();
Assert.Equal("Server", serverInfo.DeploymentType);
Assert.Equal("Your Company Jira", serverInfo.ServerTitle);
Assert.Null(serverInfo.HealthChecks);
}
public void Put(long id, [FromBody] Jira value)
{
Jira user = this._context.Jira.Find(id);
user.username = value.username;
user.password = value.password;
this._context.SaveChanges();
}
public void GetUnknownProjectTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
Project project = environment.GetProject("NOTEXISTING");
Assert.Null(project);
}
public void GetProjectsTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
List<Project> projects = environment.GetProjects();
Assert.NotNull(projects);
Assert.Equal(2, projects.Count);
}
public void GetAgileBoardTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
List<AgileBoard> agileboards = environment.GetAgileBoards();
Assert.NotNull(agileboards);
Assert.Equal(3, agileboards.Count);
}
public ProjectViewModel(IProjectView view, IEnumerable<IPresentationViewModel> presentationViewModels, Jira.REST.Jira jira)
{
this.Name = "Project Screen";
this.Page = Pages.Project;
this.View = view;
_presentationViewModels = presentationViewModels;
_jira = jira;
InitCommands();
}
public void GetExistingProjectTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
Project project = environment.GetProject("ITDEV");
Assert.NotNull(project);
Assert.Equal(project.Key, "ITDEV");
}
public static void AssingTicket(User user, Issue issue, Message message, string assignee, TelegramBot bot, Jira jiraConn)
{
int state = user.State - 1; //безумный костыль для того, чтобы вычислять статус, который нужно перевсети пользоваетля. Так получилось, что это 3 для 4 статуса, и 5 для 6 статуса.
string keyboard = null;
if (state == 3)
{
keyboard =
"{\"keyboard\": [[\"Проверь тикеты\"], [\"Кто сейчас дежурит?\"], [\"Помоги с дежурством\"], [\"Пока ничего\"]],\"resize_keyboard\":true,\"one_time_keyboard\":true}";
}
try
{
issue.Refresh();
if (issue.Assignee == null & issue.Key.Value.Equals(user.TicketNumber))
{
if (issue.Status.ToString() == "10050")
{
issue.WorkflowTransition("Распределить");
}
issue.Assignee = assignee;
issue.SaveChanges();
user.State = state;
user.TicketNumber = "";
bot.SendMessage(message.chat.id, "Готово.", keyboard);
}
else
{
user.State = state;
user.TicketNumber = "";
bot.SendMessage(message.chat.id, "Тикет уже распределён", keyboard);
}
}
catch (Exception ex)
{
using (var repository = new Repository<DutyBotDbContext>())
{
var logReccord = new Log
{
Date = DateTime.Now,
MessageTipe = "error",
UserId = message.chat.id,
Operation = "AssingTicket",
Exception = ex.GetType() + ": " + ex.Message,
AddInfo = issue.Key.Value
};
repository.Create(logReccord);
}
user.State = 3;
user.TicketNumber = "";
bot.SendMessage(message.chat.id, "Что-то пошло не так.", "{\"keyboard\": [[\"Проверь тикеты\"], [\"Кто сейчас дежурит?\"], [\"Помоги с дежурством\"], [\"Пока ничего\"]],\"resize_keyboard\":true,\"one_time_keyboard\":true}");
}
}
public void ProjectLeadTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
Project project = environment.GetProject("ITDEV");
Assert.NotNull(project);
Assert.NotNull(project.ProjectLead);
Assert.Equal("jverdick", project.ProjectLead.Username);
}
public LoginViewModel(ILoginView view, IEnumerable<IPresentationViewModel> presentationViewModels, Jira.REST.Jira jira, ScreenViewModel screenViewModel)
{
View = view;
Name = "Login";
Page = Pages.Login;
_jira = jira;
_presentationViewModels = presentationViewModels;
_screenViewModel = screenViewModel;
AddCommandsHandlers();
}
public void GetSprintsFromAgileBoardTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
AgileBoard agileboard = environment.GetAgileBoards().First();
Assert.Equal(1, agileboard.ID);
List<Sprint> sprints = agileboard.GetSprints();
Assert.NotNull(sprints);
Assert.Equal(3, sprints.Count);
}
public void CreateVersion(Jira jira, string project, string version)
{
Argument.IsNotNull(() => jira);
Argument.IsNotNullOrWhitespace(() => project);
Argument.IsNotNullOrWhitespace(() => version);
Log.Info("Creating version {0}", version);
Log.Debug("Checking if version already exists");
var existingVersion = GetProjectVersion(jira, project, version);
if (existingVersion != null)
{
Log.Info("Version {0} already exists", version);
if (existingVersion.IsReleased)
{
string error = string.Format("Version {0} is already released, are you re-releasing an existing version?", version);
Log.Error(error);
throw new InvalidOperationException(error);
}
return;
}
Log.Debug("Version does not yet exist, creating version");
var token = jira.GetToken();
var jiraService = jira. GetJiraSoapService();
var nextSequence = 0L;
var remoteVersions = jiraService.GetVersions(token, project).OrderBy(x => x.name);
foreach (var remoteVersion in remoteVersions)
{
Log.Debug(" {0} => {1}", remoteVersion.name, ObjectToStringHelper.ToString(remoteVersion.sequence));
if (string.Compare(remoteVersion.name, version, StringComparison.OrdinalIgnoreCase) > 0 && (nextSequence == 0L))
{
nextSequence = remoteVersion.sequence.Value;
}
}
jiraService.AddVersion(token, project, new RemoteVersion
{
name = version,
archived = false,
sequence = nextSequence
});
Log.Info("Created version {0}", version);
}
public bool ConnectToJiraServer() {
if (JiraUsername == "" || JiraPassword == "" || JiraProjectURL == "")
return false;
try {
_jira = Jira.CreateRestClient(JiraProjectURL, JiraUsername, JiraPassword);
} catch (Exception e) {
MessageBox.Show("Error connecting to Jira server: " + e.Message);
return false;
}
Globals.Ribbons.TicketManagerRibbon.SetConnectionStatus(true);
return true;
}
public void GetProjectVersions()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
Project project = environment.GetProject("ITDEV");
Assert.NotNull(project);
Assert.Equal(project.Key, "ITDEV");
List<ProjectVersion> projectVersions = project.ProjectVersions;
Assert.NotNull(projectVersions);
Assert.Equal(2, projectVersions.Count);
}
public ProjectsListModel(Jira jira)
{
// TODO: Load Data from JIRA
var projects = jira.GetProjects();
for (int i = 0; i < projects.Count(); ++i)
{
var project1 = projects.ElementAt(i);
// var projectstuff = jira.GetIssue(project1.Key);
// var stuff = projectstuff.Assignee;
string currentProject = project1.Name;
int projID = Convert.ToInt32(project1.Id);
this.projectsList.Add(new ProjectEntry(projID, project1.Name, project1.Key, 56));
}
}
public static bool CheckConnection(Jira jiraConn, string login, string password)
{
if (jiraConn == null) throw new ArgumentNullException(nameof(jiraConn));
if (login == null) throw new ArgumentNullException(nameof(login));
if (password == null) throw new ArgumentNullException(nameof(password));
jiraConn = Jira.CreateRestClient("https://jira.2gis.ru/", login, password);
try
{
jiraConn.GetFilters();
return true;
}
catch
{
return false;
}
}
public static bool ConnectToJira()
{
JiraConnectionConfiguration config;
try
{
config = (JiraConnectionConfiguration)ConfigurationManager.GetSection("jiraAttachments");
_uploadImmediately = config.V1Connection.UploadImmediately.ToLower();
_jiraserver = new Jira(config.JiraConnection.ServerUrl, config.JiraConnection.UserName, config.JiraConnection.Password);
_logger.Info("Connected to Jira Server - {0}",config.JiraConnection.ServerUrl);
return true;
}
catch (Exception ex)
{
_logger.Error("Failed to connect to Jira. Exception message: {0}", ex.Message);
return false;
}
}
public void GetIssuesFromSprintTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
//Get the first agile board
AgileBoard agileboard = environment.GetAgileBoards().First();
Assert.Equal(1, agileboard.ID);
//Get the first sprint from the first agile board
List<Sprint> sprints = agileboard.GetSprints();
Assert.Equal(3, sprints.Count);
//Get a sprint and try to select an issue.
Sprint sprint = sprints.Where(s => s.ID == 1).First();
List<Issue> issues = sprint.GetIssues();
Assert.NotNull(issues);
Assert.Equal(4, issues.Count);
}
public CreateIssueForm(string savedScreenCaptureFilename)
{
InitializeComponent();
_savedScreenCaptureFilename = savedScreenCaptureFilename;
_jira = new Jira(JiraPreferences.ServerUrl, JiraPreferences.Username, JiraPreferences.Password);
_projects = _jira.GetProjects();
foreach (var project in _projects)
{
comboBoxProject.Items.Add(project.Name);
}
_issuePriorities = _jira.GetIssuePriorities();
foreach (var issuePriority in _issuePriorities)
{
comboBoxPriority.Items.Add(issuePriority.Name);
}
}
public void GetProjectVersionIssuesTest()
{
Jira environment = new Jira();
environment.Connect(new MockJiraClient());
Project project = environment.GetProject("ITDEV");
Assert.NotNull(project);
Assert.Equal(project.Key, "ITDEV");
ProjectVersion firstProjectVersion = project.ProjectVersions.FirstOrDefault();
Assert.NotNull(firstProjectVersion);
Assert.NotNull(firstProjectVersion.Issues);
Assert.Equal(2, firstProjectVersion.Issues.Count);
ProjectVersion lastProjectVersion = project.ProjectVersions.LastOrDefault();
Assert.NotNull(lastProjectVersion);
Assert.NotNull(lastProjectVersion.Issues);
Assert.Equal(5, lastProjectVersion.Issues.Count);
}
public BugViewModel(ProjectViewModel project, Jira jira)
{
title = "Agile Scrum";
}
//The private constructor for undefined epics
private Epic(String key, IssueFields fields, Jira jira)
{
base.Key = key;
base.Fields = fields;
base.SetJira(jira);
}
public string getIssueID(string issueTitle)
{
string result = "";
XMLParse _oWaXmlData = new XMLParse();
_oWaXmlData.LoadXML("../../Config/ApplicationSettings.xml");
jiraURL = _oWaXmlData.getData("settings/JiraCredentials", "URL");
jiraUsername = _oWaXmlData.getData("settings/JiraCredentials", "UserName");
jiraPassword = _oWaXmlData.getData("settings/JiraCredentials", "Password");
jiraConn = new Jira(jiraURL[0], jiraUsername[0], jiraPassword[0]);
try
{
string jqlString = "project = PegasusCRM AND issuetype = Bug";
IEnumerable<Atlassian.Jira.Issue> jiraIssues = jiraConn.GetIssuesFromJql(jqlString);
foreach (var issue in jiraIssues)
{
if (issue.Summary == issueTitle)
{
result = issue.Key.Value;
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return result;
}
public void AddComment(string issueID, string Comment)
{
XMLParse _oWaXmlData = new XMLParse();
_oWaXmlData.LoadXML("../../Config/ApplicationSettings.xml");
jiraURL = _oWaXmlData.getData("settings/JiraCredentials", "URL");
jiraUsername = _oWaXmlData.getData("settings/JiraCredentials", "UserName");
jiraPassword = _oWaXmlData.getData("settings/JiraCredentials", "Password");
jiraConn = new Jira(jiraURL[0], jiraUsername[0], jiraPassword[0]);
try
{
Issue issue = jiraConn.GetIssue(issueID);
issue.AddComment(Comment);
issue.SaveChanges();
Console.WriteLine("Comment added to Issue - " + issueID + " Successfully");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void SetJira(Jira jira)
{
_jira = jira;
}
private static dynamic QueryApi(string query, Jira jira)
{
var wc = jira.GetAuthorizedWebClient();
var resp = wc.DownloadString(jira.Url + "/rest/api/latest/" + query);
return Json.Decode(resp);
}
private IEnumerable<Issue> GetIssues(Jira jira)
{
Status = "Processing JQL...";
var jql = "updated>-12h AND status not in (open)";
if (!string.IsNullOrEmpty(jira.Project))
jql = string.Format("project%3D{0}%20AND%20{1}" +
"", jira.Project, jql);
dynamic dyn = QueryApi(string.Format("search?jql={0}&maxResults=1000", jql), jira);
return GetIssues(dyn, jira);
}
private IEnumerable<Issue> GetIssues(dynamic response, Jira jira)
{
int total = response.total;
var cur = 0;
foreach (var i in response.issues)
{
Status = string.Format("Loading issue {0} of {1}", cur++, total);
var data = QueryApi(string.Format("issue/{0}?expand=changelog", i.Key), jira);
yield return new Issue
{
Key = i.Key,
Summary = i.fields.summary,
Status = i.fields.status.name,
Comments = Enumerable.ToArray(GetItems(data.fields.comment.comments)),
History = Enumerable.ToArray(GetItems(data.changelog.histories)),
JiraUrl = jira.Url
};
}
}
