public void CanCreateAndCommentAndDeleteIssues()
{
var title = Guid.NewGuid().ToString();
var body = Guid.NewGuid().ToString();
var request = new CreateIssueRequest(title, body)
{
Assignee = "rhysc", Labels = new[] { "Test1", "Test2" }
};
var issue = _issuesRepositoryApi.Create("githubsharp", "rhysc", request);
Assert.NotNull(issue);
Assert.AreEqual(title, issue.Title);
Assert.AreEqual(body, issue.Body);
Assert.AreEqual(title, issue.Title);
Assert.True(issue.Labels.Any(l => l.Name == "Test1"));
Assert.True(issue.Labels.Any(l => l.Name == "Test2"));
Assert.AreEqual("RhysC", issue.Assignee.Login);
var comment = Guid.NewGuid().ToString();
var commentedIsssue = _issuesRepositoryApi.CommentOnIssue("githubsharp", "rhysc", issue.Number, comment);
Assert.AreEqual(comment, commentedIsssue.Body);
var closedIssue = _issuesRepositoryApi.Close("githubsharp", "rhysc", issue.Number);
Assert.NotNull(closedIssue);
Assert.AreEqual(title, closedIssue.Title);
Assert.AreEqual(body, closedIssue.Body);
Assert.AreEqual(title, closedIssue.Title);
Assert.AreEqual("RhysC", closedIssue.Assignee.Login);
Assert.AreEqual("closed", closedIssue.State);
Console.WriteLine("closedat - {0}, Utc Now - {1}", closedIssue.ClosedAt, DateTime.UtcNow);
Assert.True(DateTime.UtcNow.AddMinutes(-2) < closedIssue.ClosedAt && closedIssue.ClosedAt < DateTime.UtcNow.AddMinutes(2));
}
public Issue CreateIssue([NotNull] string branchId, [NotNull] CreateIssueRequest issue)
{
if (issue == null)
{
throw new ArgumentNullException(nameof(issue));
}
var projectName = GetSetting(TfsSettings.Project);
var workItemStore = GetStore();
Project project;
if (projectName.Equals(UseVcsBranch, StringComparison.InvariantCultureIgnoreCase))
{
if (string.IsNullOrEmpty(branchId))
{
throw new ArgumentException(nameof(branchId));
}
var projects = workItemStore.Projects;
project = projects
.Cast <Project>()
.SingleOrDefault(_ => branchId.StartsWith($"$/{_.Name}", StringComparison.Ordinal));
}
else
{
project = workItemStore.Projects[projectName];
}
if (project == null)
{
throw new Exception();
}
const string taskItemTypeName = "Task";
var workItemType = project.WorkItemTypes[taskItemTypeName];
var workItem = new WorkItem(workItemType)
{
Description = issue.Description,
Title = issue.Title
};
var validationResult = workItem.Validate();
if (validationResult.Count > 0)
{
throw new Exception(); // TODO: specific exception
}
workItem.Save();
return(GetIssue(workItem));
}
public IActionResult CreateIssue([FromBody] CreateIssueRequest data)
{
if (data == null)
{
return(BadRequest());
}
return(ProcessCommand(new CreateIssueCommand(data)));
}
/// <summary>
/// Creates new issue.
/// </summary>
/// <returns>The newly created issue.</returns>
/// <param name="projectId">The ID, path or <see cref="Project"/> of the project.</param>
/// <param name="request">Create issue request.</param>
public async Task <Issue> CreateAsync(ProjectId projectId, CreateIssueRequest request)
{
string impersonate = "";
if (request.Sudo_ImpersonateUsername != null)
{
impersonate = "?sudo=" + request.Sudo_ImpersonateUsername;
}
return(await _httpFacade.Post <Issue>($"projects/{projectId}/issues" + impersonate, request));
}
public string GetIssueKey(CreateIssueRequest issueRequestBody)
{
RestRequest createIssueRequest = new RestRequest(CreateIssueEndpoint);
createIssueRequest.AddHeader("Content-Type", "application/json");
createIssueRequest.AddJsonBody(issueRequestBody);
string requestContent = _restClient.Post(createIssueRequest).Content;
return(JsonConvert.DeserializeObject <CreateIssueResponse>(requestContent).key);
}
public void CreateIssue()
{
//Arrange
CreateIssueRequest createIssueRequest = new CreateIssueRequest(token, method, issueDefaultParameters.category, issueDefaultParameters.summary, issueDefaultParameters.description, issueDefaultParameters.projectName);
//Act
Task <IRestResponse> responseCreate = createIssueRequest.ExecuteRequest();
//Assert
createIssueResponse = jsonDeserializer.Deserialize <CreateIssueResponse>(responseCreate);
string nameCategory = createIssueResponse.issue.category.name;
Assert.Equal(statusEsperado, responseCreate.Result.StatusCode.ToString());
Assert.Equal(issueDefaultParameters.category, nameCategory);
}
public void CreateIssue(CreateIssueRequest issue, string userEmail)
{
if (issue is null)
{
throw new ArgumentNullException(nameof(issue));
}
var issueDbo = new Issue()
{
Description = issue.Description,
LoggedBy = userEmail
};
repository.Issue.Add(issueDbo);
repository.SaveChanges();
}
public Issue CreateIssue([NotNull] string branchId, [NotNull] CreateIssueRequest issue)
{
var gitHubClient = GetClient();
var newIssue = new NewIssue(issue.Title)
{
Body = issue.Description
};
var result = gitHubClient.Issue.Create(
GetSetting(GitHubItSettingKeys.RepositoryOwner),
GetSetting(GitHubItSettingKeys.RepositoryName),
newIssue)
.Result;
return(result.ToModel());
}
public void ShouldCreateIssue()
{
var dateTimeString = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture);
var title = $"Test issue {dateTimeString}";
var createIssueRequest = new CreateIssueRequest
{
Description = dateTimeString,
Title = title
};
var result = _target.CreateIssue(null, createIssueRequest);
result.Should().NotBeNull();
result.Description.ShouldBeEquivalentTo(dateTimeString);
result.Title.ShouldBeEquivalentTo(title);
}
/// <summary>
/// Creates the issue
/// </summary>
/// <param name="branchId">Target branch Id</param>
/// <param name="createIssueRequest">The issue.</param>
/// <returns></returns>
public Issue CreateIssue(string branchId, CreateIssueRequest createIssueRequest)
{
var client = GetClient();
var projectUuid = GetProjectUuid(client);
var workItemTypes = client.Issues.GetTypes(projectUuid).Result;
ValidateResponse(workItemTypes, HttpStatusCode.OK);
var workItemType = workItemTypes.Data
.SingleOrDefault(_ => _.Identifier.EndsWith(WorkItemTypes.Task, StringComparison.Ordinal))
?.Resource;
var caterories = client.Issues.GetCategories().Result;
ValidateResponse(workItemTypes, HttpStatusCode.OK);
var category = caterories.Data.Entities.SingleOrDefault(_ =>
_.Archived == false &&
_.Depth == 0 &&
_.Title.Equals("Unassigned") &&
_.ProjectArea.Resource.EndsWith(projectUuid, StringComparison.Ordinal))?.Resource;
var issue = client.Issues.Create(
projectUuid,
new CreateWorkItem
{
Description = createIssueRequest.Description,
FiledAgainstResource = category,
Title = createIssueRequest.Title,
TypeResource = workItemType
})
.Result;
ValidateResponse(issue, HttpStatusCode.Created);
var states = client.Issues.GetStates(projectUuid).Result;
return(issue.Data?.ToDto(states.Data));
}
/// <summary>
/// Creates the issue
/// </summary>
/// <param name="branchId">Target branch Id</param>
/// <param name="createIssueRequest">The issue.</param>
/// <returns></returns>
public Issue CreateIssue(string branchId, CreateIssueRequest createIssueRequest)
{
if (createIssueRequest == null)
{
throw new ArgumentNullException(nameof(createIssueRequest));
}
var client = GetClient();
var project = GetProject(client);
var issue = client.Issues
.Create(project.Id,
new CreateIssue
{
Description = createIssueRequest.Description,
Title = createIssueRequest.Title
})
.Result;
return(ToDto(issue.Data));
}
private async Task CreateIssue()
{
if (!ValidateSummary())
{
return;
}
if (!ValidateIssueTypes())
{
return;
}
if (!ValidatePriorities())
{
return;
}
var request = new CreateIssueRequest();
request.Fields.CreateIssueProject.Key = Project.Key;
request.Fields.Description = Description;
request.Fields.IssueType.Name = IssueTypes[SelectedIssueTypeIndex].Name;
request.Fields.Priority.Id = PriorityList[SelectedPriorityIndex].Id;
request.Fields.Summary = Summary;
LoadingText = AppResources.CreatingIssueMessage;
MessengerInstance.Send(true, "TaskBarVisibility");
var createdIssue = await jiraService.CreateIssue(request);
MessengerInstance.Send(false, "TaskBarVisibility");
if (createdIssue == null)
{
dialogService.ShowDialog(AppResources.CreateIssueErrorMessage, AppResources.Error);
}
else
{
dialogService.ShowDialog(string.Format(AppResources.IssueCreatedMessage, createdIssue.Key), AppResources.Done);
MessengerInstance.Send(true, AppResources.CreateIssueToken);
navigationService.GoBack();
}
}
public SuccessResponse PostIssue(CreateIssueRequest issue)
{
var result = _createValidator.Validate(issue, ruleSet: "Required");
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
return(new SuccessResponse
{
Message = failure.PropertyName + " failed validation." + failure.ErrorMessage
});
}
}
var newIssue = _mapper.Map <Issue>(issue);
var issueId = _issuesLogic.CreateIssue(newIssue);
return(new SuccessResponse
{
Id = issueId,
Message = "Issue Created Successfully"
});
}
public async Task <CreateIssueResponse> CreateIssue(CreateIssueRequest request)
{
var url = string.Format("{0}{1}/", App.BaseUrl, JiraRequestType.Issue.ToString().ToLower(CultureInfo.InvariantCulture));
try
{
var result = await jsonClient.Post <CreateIssueRequest, CreateIssueResponse>(new Uri(url), request, App.UserName, App.Password, HttpStatusCode.Created, TokenSource);
return(result);
}
catch (Exception exception)
{
var extras = BugSenseHandler.Instance.CrashExtraData;
extras.Add(new CrashExtraData
{
Key = "Method",
Value = "JiraService.CreateIssue"
});
BugSenseHandler.Instance.LogException(exception, extras);
}
return(null);
}
public IssueResponse Create(string repositoryName, string owner, CreateIssueRequest request)
{
var url = string.Format("repos/{0}/{1}/issues", owner, repositoryName);
return(ConsumeJsonUrlAndPostData <CreateIssueRequest, IssueResponse>(url, request));
}
public async Task <IActionResult> CreateFeatureAsync(CreateIssueRequest createIssueRequest)
{
await _githubService.CreateFeatureIssue(createIssueRequest.UserName, createIssueRequest.Title, createIssueRequest.Description);
return(Ok());
}
public CreateIssueCommand(CreateIssueRequest request)
{
_request = request;
}
public async Task <IActionResult> CreateByOrg([FromRoute] string organizationName, [FromRoute] string projectName, [FromBody] CreateIssueRequest issueRequest)
{
if (issueRequest == null)
{
return(new BadRequestResult());
}
var newIssueId = Guid.NewGuid();
var issue = new Issue
{
Id = newIssueId,
Title = issueRequest.Title,
AuthorId = HttpContext.GetUserId(),
CreatedAt = DateTime.UtcNow,
Content = issueRequest.Content,
};
var created = await _issueService.CreateIssueByOrgAsync(issue, issueRequest.Types, organizationName, projectName).ConfigureAwait(false);
if (!created)
{
return(NotFound());
}
var locationUri = _uriService.GetUri(issue.Number.ToString());
return(Created(locationUri, new Response <IssueResponse>(_mapper.Map <IssueResponse>(issue))));
}
public StatusCodeResult CreateIssue(CreateIssueRequest issue)
{
issueManager.CreateIssue(issue, UserEmail);
return(new StatusCodeResult(204));
}
public static async Task OnHttpRequest(Microsoft.AspNetCore.Http.HttpContext e, DbUser u)
{
//Decode issue
CreateIssueRequest request = Program.DecodePostBody <CreateIssueRequest>(e);
//Get topic name
string client_tag;
if (client_name_topics.ContainsKey(request.client_name))
{
client_tag = client_name_topics[request.client_name];
}
else
{
throw new StandardError("Unknown Client", StandardErrorCode.InvalidInput);
}
//Get server
DbServer server = await Program.connection.GetServerByIdAsync(request.server_id);
if (server == null)
{
throw new StandardError("Server Not Found", StandardErrorCode.InvalidInput);
}
int? tribeIdInt = server.TryGetTribeIdAsync(Program.connection, u.steam_id).GetAwaiter().GetResult();
string tribeId = tribeIdInt.HasValue ? tribeIdInt.Value.ToString() : "*No Tribe ID*";
//Get the screenshot
var screenshot = UserContentUploader.FinishContentUpload(request.screenshot_token);
//Get attachments and make their body
string attachment_body = "";
for (int i = 0; i < request.attachment_tokens.Length; i++)
{
var attachment = UserContentUploader.FinishContentUpload(request.attachment_tokens[i]);
attachment_body += $"[{request.attachment_names[i].Replace("]", "\\]")}]({attachment.url}) ";
}
if (request.attachment_tokens.Length == 0)
{
attachment_body = "*No attachments*";
}
//Create the body
string body = $"*This issue was reported automatically inside of the app.*\n\n**[Description]**\n{request.body_description}\n\n**[Expected Result]**\n{request.body_expected}\n\n**[Screenshot]**\n\n\n**[Client Info]**\n**Client-Name**: {request.client_name},\n**Client-Name**: {request.client_info}\n\n**[Attachments]**\n{attachment_body}\n\n**[User/Server Data]**\n**User Internal ID**: {u._id},\n**Server Internal ID**: {server.id},\n**Server Map**: {server.latest_server_map},\n**Tribe ID**: {tribeId}\n**Server Name**: {server.display_name}\n\n**[Report Info]**\nThis report was created by the Delta Web Map backend server.";
//Submit
string response_string;
using (HttpClient hc = new HttpClient())
{
//Send
hc.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", Program.config.github_api_key);
hc.DefaultRequestHeaders.Add("User-Agent", "DeltaWebMap-Master-Server");
var response = await hc.PostAsync("https://api.github.com/repos/deltawebmap/Delta-Web-Map-User-Reports/issues", new StringContent(JsonConvert.SerializeObject(new GitHubIssueCreateRequest
{
body = body,
title = $"[{request.topic}] {request.title}",
labels = new string[]
{
"Auto Generated",
client_tag
}
})));
//Check
response_string = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new Exception("Unexpected Status Code");
}
}
//Decode
await Program.QuickWriteJsonToDoc(e, new CreateIssueResponse
{
url = JsonConvert.DeserializeObject <GitHubIssueCreateResponse>(response_string).html_url
});
}
/// <summary>
/// Creates new issue.
/// </summary>
/// <returns>The newly created issue.</returns>
/// <param name="projectId">The ID, path or <see cref="Project"/> of the project.</param>
/// <param name="request">Create issue request.</param>
public async Task <Issue> CreateAsync(ProjectId projectId, CreateIssueRequest request) =>
await _httpFacade.Post <Issue>($"projects/{projectId}/issues", request);
