public int SaveIssue(CreateIssue issue)
{
using (var con = new SqlConnection(ConnectionString))
{
con.Open();
if (issue.Id == 0)
{
issue.CreatedDate = DateTime.Now;
var q =
con.Query <int>(
@"INSERT INTO Issue(Title,Description,DueDate,CategoryId,StatusID,PriorityID,ProjectID,TeamId,Active,CreatedDate,CreatedByID)
VALUES(@title,@description,@IssueDueDate,@categoryId,@statusId,@priorityId,@projectId,@teamId,1,@createdDate,@createdById);SELECT CAST(SCOPE_IDENTITY() as int)",
issue);
return(q.First());
}
else
{
con.Execute(
"UPDATE Issue SET Title=@title,Description=@description,CategoryId=@CategoryId,ProjectId=@ProjectId,StatusId=@statusId,PriorityId=@priorityId WHERE Id=@id",
issue);
return(issue.Id);
}
}
}
/// <summary>
/// Returns a new CreateIssue based on this view model.
/// </summary>
/// <returns>a new CreateIssue based on this view model</returns>
public CreateIssue ToCreateIssue()
{
var newIssue = new CreateIssue(Util.GetProjectKey(), Summary, Description, issueTypeId, priorityId, labels);
newIssue.AddField(Util.GetClientReporterFieldName(), ClientReporter);
return(newIssue);
}
public async Task IssueCRUDTest()
{
//Read
var initCount = (await GetIssues()).Count;
//Create
var createCommand = new CreateIssue(
IssueType.Task,
"Check Create Task",
"Task should be created after running command"
);
var createdIssue = await CreateIssue(createCommand, initCount);
//Update
var updateCommand = new UpdateIssue(
createdIssue.Id,
IssueType.Task,
"Check Update Task",
"Task should be update after running command"
);
await UpdateIssue(updateCommand);
//Delete
await DeleteIssue(createdIssue.Id);
}
private int SaveAttachedDocument(CreateIssue model, OperationStatus result, int fileCounter, HttpPostedFileBase file)
{
if (file != null)
{
fileCounter++;
string fileName = Path.GetFileName(file.FileName).ToLower();
string fileKey = fileName;
fileKey = fileKey.Replace(" ", "-").Replace("%", "-");
fileKey = String.Format("{0}-{1}-{2:n}-{3}", result.OperationID, fileCounter, Guid.NewGuid(), fileName);
if (fileKey.Length > 99)
{
fileKey = fileKey.Substring(0, 99);
}
string path = Path.Combine(Server.MapPath("~/uploads"), fileKey);
file.SaveAs(path);
Document img = new Document {
FileName = fileName, ParentID = model.Id
};
img.FileAlias = fileKey;
img.CreatedByID = UserID;
img.ParentID = result.OperationID;
var resultForImg = repo.SaveDocument(img);
if (!resultForImg.Status)
{
log.Debug(resultForImg);
}
}
return(fileCounter);
}
public async Task LoadDropdownData(CreateIssue issue)
{
issue.Projects = this.iProjectRepository.GetProjects(this.userSessionHelper.TeamId)
.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
})
.ToList();
var statuses = await this.cache.Get(CacheKey.Statuses, () => this.issueRepository.GetStatuses(), 360);
var priorities = await this.cache.Get(CacheKey.Priorities, () => this.issueRepository.GetPriorities(), 360);
var catagories = await this.cache.Get(CacheKey.Categories, () => this.issueRepository.GetCategories(), 360);
issue.Statuses = statuses.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
}).ToList();
issue.Priorities = priorities.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
}).ToList();
issue.Categories = catagories.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
}).ToList();
}
public void LoadDropdownData(CreateIssue issue)
{
issue.Projects =
this.iProjectRepository.GetProjects(this.userSessionHelper.TeamId)
.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
})
.ToList();
issue.Statuses = this.issueRepository.GetStatuses()
.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
})
.ToList();
issue.Priorities = this.issueRepository.GetPriorities()
.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
})
.ToList();
issue.Categories = this.issueRepository.GetCategories()
.Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
})
.ToList();
}
private void LoadDefaultIssueValues(Issue issue, CreateIssue model)
{
issue.PriorityID = model.SelectedPriority;
if (issue.PriorityID == 0)
{
issue.PriorityID = 1;
}
issue.ProjectID = model.SelectedProject;
if (issue.ProjectID == 0)
{
var teamMember = repo.GetTeamMember(UserID, TeamID);
if (teamMember.DefaultProjectID == null)
{
throw new MissingSettingsException("Default Project not set", "Default Project");
}
//get from team member
issue.ProjectID = teamMember.DefaultProjectID.Value;
}
issue.StatusID = model.SelectedStatus;
if ((model.Id == 0) && (model.SelectedStatus == 0))
{
issue.StatusID = 1;
}
issue.CategoryID = model.SelectedCategory;
if (issue.CategoryID == 0)
{
issue.CategoryID = 1;
}
issue.Location = (string.IsNullOrEmpty(model.SelectedIteration) ? "SPRNT" : model.SelectedIteration);
}
public async Task <IActionResult> Add()
{
var vm = new CreateIssue();
await this._issueManager.LoadDropdownData(vm);
return(PartialView("~/Views/Issues/Partial/Edit.cshtml", vm));
}
private void LoadDropDownsForCreate(CreateIssue viewModel)
{
viewModel.Projects = ProjectService.GetProjects(repo, TeamID);
viewModel.Priorities = ProjectService.GetPriorities(repo);
viewModel.Categories = ProjectService.GetCategories(repo);
viewModel.Statuses = ProjectService.GetStatuses(repo);
viewModel.Iterations = ProjectService.GetIterations();
}
private IEnumerable <SelectListItem> PopulateIssueTypes(CreateIssue model = null)
{
Dictionary <int, string> issues = new Dictionary <int, string> {
{ 0, "Story" }, { 1, "Task" }, { 2, "Test Task" }, { 3, "Bug" }
};
return(issues.AsEnumerable().ToSelectListItems(value => value.Key.ToString(), text => text.Value, selected => model != null && model.IssueType == selected.Key));
}
public async Task <IssueCreatedResult> CreateIssue([FromBody] CreateIssue issue)
{
var commandResult = await _mediator.Send(issue);
var dto = _mapper.Map <IssueCreatedResult>(commandResult);
return(dto);
}
private string CreateNewBug()
{
//Need to implement this
CreateIssue newIssue = new CreateIssue(this.projectName, base.BugTitle, base.BugDescription, "1", "1", null);
client.CreateIssue(newIssue);
return(this.GetPreviouslyEnteredBugURL());
}
private void LoadDropDownsForCreate(CreateIssue viewModel)
{
viewModel.Projects = projectManager.GetProjects().Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Name
}).ToList();
viewModel.Priorities = ProjectService.GetPriorities(repo);
viewModel.Categories = ProjectService.GetCategories(repo);
viewModel.Statuses = ProjectService.GetStatuses(repo);
viewModel.Iterations = ProjectService.GetIterations();
}
public async Task UpdateIssueWithNotValidData_ShouldReturnBadRequest()
{
var command = new CreateIssue(
IssueType.Task,
null,
null
);
var response = await _sut.Client.PostAsync("/api/Issues", command.ToJsonStringContent());
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
/// <summary>
/// Creates a new issue. Throws a JiraApiException if the request was
/// unable to execute.
/// </summary>
/// <returns>the new issue</returns>
public BasicIssue CreateIssue(CreateIssue newIssue)
{
var request = new RestRequest()
{
Resource = ResourceUrls.Issue(),
RequestFormat = DataFormat.Json,
Method = Method.POST
};
request.AddBody(newIssue);
return(Execute <BasicIssue>(request, HttpStatusCode.Created));
}
private CreateIssue CreateIssueModel(CreateIssue model, bool isModal)
{
if (model == null)
{
model = new CreateIssue {
IsModal = isModal
};
}
model.IssueTypeOptions = PopulateIssueTypes(model);
return(model);
}
private void addIssueActionItems(int generation)
{
List <JiraNamedEntity> actions = null;
if (!issue.IsSubtask && issue.Server.BuildNumber > 0)
{
this.safeInvoke(new MethodInvoker(delegate {
if (generation != menuOpenGeneration)
{
return;
}
Items.Add(new ToolStripSeparator());
Items.Add(new ToolStripMenuItem("Add Subtask", Resources.add_jira, new EventHandler(
delegate {
CreateIssue.createDialogOrBringToFront(issue.Server, issue);
}
)));
}));
}
try {
actions = SmartJiraServerFacade.Instance.getActionsForIssue(issue);
} catch (Exception e) {
status.setError("Failed to retrieve issue actions", e);
}
if (actions == null || actions.Count == 0)
{
return;
}
this.safeInvoke(new MethodInvoker(delegate {
// PLVS-39 - only update current menu, skip results of previous getActionsForIssue()
// in case the user quickly opens context menu more than once
if (generation != menuOpenGeneration)
{
return;
}
Items.Add(new ToolStripSeparator());
foreach (var action in actions)
{
var actionCopy = action;
ToolStripMenuItem item = new ToolStripMenuItem(
action.Name, null,
new EventHandler(
delegate {
IssueActionRunner.runAction(this, actionCopy, model, issue, status, null);
}));
Items.Add(item);
}
}));
}
public ActivityDto SaveActivity(CreateIssue model, IssueDetailVM previousVersion, IssueDetailVM newVersion)
{
bool isStateChanged = false;
var activity = new ActivityDto()
{
ObjectId = newVersion.Id, ObjectType = "Issue"
};
if (previousVersion == null)
{
activity.ObjectUrl = "issue/" + newVersion.Id;
//activity.CreatedBy =
activity.Description = "Created";
activity.ObjectTitle = model.Title;
isStateChanged = true;
}
else
{
if (previousVersion.Status.Id != newVersion.Status.Id)
{
// status of issue updated
activity.Description = "Changed status";
activity.NewState = newVersion.Status.Name;
activity.OldState = previousVersion.Status.Name;
activity.ObjectTitle = newVersion.Title;
isStateChanged = true;
}
else if (previousVersion.Category.Id != newVersion.Category.Id)
{
activity.Description = "Changed category";
activity.NewState = newVersion.Category.Name;
activity.OldState = previousVersion.Category.Name;
activity.ObjectTitle = newVersion.Title;
isStateChanged = true;
}
}
activity.CreatedTime = DateTime.Now;
activity.TeamId = userSessionHelper.TeamId;
activity.Actor = new UserDto {
Id = userSessionHelper.UserId
};
if (isStateChanged)
{
var newId = activityRepository.Save(activity);
return(activityRepository.GetActivityItem(newId));
}
return(null);
}
public IssueDetailVM SaveIssue(CreateIssue issue, List <HttpPostedFileBase> files)
{
issue.TeamID = userSessionHelper.TeamId;
issue.CreatedByID = userSessionHelper.UserId;
issue.ProjectID = GetDefaultProjectId();
var issueId = issueRepository.SaveIssue(issue);
return(issueRepository.GetIssue(issueId));
//Activity entry
// return SaveActivity(issue, previousVersion, newVersion);
}
public IActionResult Edit(int id)
{
var issue = this.issueManager.GetIssue(id);
if (issue != null && issue.Active)
{
var vm = new CreateIssue(issue);
this.issueManager.LoadDropdownData(vm);
vm.IsEditableForCurrentUser = this.teamManager.DoesCurrentUserBelongsToTeam();
return(PartialView("~/Views/Issues/Partial/Edit.cshtml", vm));
}
return(PartialView("NotFound"));
}
public async Task <IActionResult> Edit(int id)
{
var issue = await this._issueManager.GetIssue(id);
if (issue != null && issue.Active)
{
var vm = new CreateIssue(issue);
await this._issueManager.LoadDropdownData(vm);
vm.IsEditableForCurrentUser = this._teamManager.DoesCurrentUserBelongsToTeam(this._userSessionHelper.UserId, this._userSessionHelper.TeamId);
return(PartialView("~/Views/Issues/Partial/Edit.cshtml", vm));
}
return(PartialView("NotFound"));
}
public async Task <IssueDetailVM> SaveIssue(CreateIssue issue, List <IFormFile> files)
{
bool isNewIssue = issue.Id == 0;
if (issue.ProjectId == 0)
{
var defaultProject = await iProjectRepository.GetDefaultProjectForTeamMember(this.userSessionHelper.TeamId,
this.userSessionHelper.UserId);
if (defaultProject == null)
{
throw new MissingSettingsException("Missing data", "Default project");
}
issue.ProjectId = defaultProject.Id;
}
if (issue.CategoryId == 0)
{
var categories = await this.issueRepository.GetCategories();
issue.CategoryId = categories.First().Id;
}
if (issue.PriorityId == 0)
{
var categories = await this.issueRepository.GetPriorities();
issue.PriorityId = categories.First().Id;
}
if (issue.StatusId == 0)
{
var statuses = await this.issueRepository.GetStatuses();
issue.StatusId = statuses.First().Id;
}
issue.CreatedById = this.userSessionHelper.UserId;
issue.TeamID = this.userSessionHelper.TeamId;
var issueId = this.issueRepository.SaveIssue(issue);
var issueDetail = this.issueRepository.GetIssue(issueId, this.userSessionHelper.UserId);
if (isNewIssue)
{
await emailManager.SendIssueCreatedEmail(issueDetail, this.userSessionHelper.TeamId);
//.QueueBackgroundWorkItem(ct => SendMailAsync(user.Email));
}
return(issueDetail);
}
public Issue CreateIssue(CreateIssue data)
{
//prepare the initial issue model to insert
IssueEntity issueEntity = _mapper.Map <IssueEntity>(data);
ReleaseEntity releaseEntity = null;
if (data.ExistingPlannedReleaseId.HasValue && data.ExistingPlannedReleaseId.Value != 0)
{
//check if the release exists
releaseEntity = _releasesUow.Releases.SingleOrDefault(x => x.Id == data.ExistingPlannedReleaseId.Value);
if (releaseEntity == null)
{
throw new Exception("Invalid release id");
}
else
{
issueEntity.PlannedReleaseId = data.ExistingPlannedReleaseId;
}
}
else if (data.NewPlannedRelease != null)
{
//we can still change to a different isolation level because we haven't done anything with Releases database yet
_releasesUow.SetIsolationLevel(IsolationLevel.ReadCommitted);
releaseEntity = _mapper.Map <ReleaseEntity>(data.NewPlannedRelease);
_releasesUow.Releases.Add(releaseEntity);
_releasesUow.SaveChanges();
issueEntity.PlannedReleaseId = releaseEntity.Id;
}
//add issue to the database
_issuesUow.Issues.Add(issueEntity);
_issuesUow.SaveChanges();
//prepare and return models
var issue = _mapper.Map <Issue>(issueEntity);
if (releaseEntity != null)
{
issue.PlannedRelease = _mapper.Map <Release>(releaseEntity);
}
return(issue);
}
public ActionResult CreateIssue(CreateIssue model)
{
if (!ModelState.IsValid && model.IsModal)
{
return(PartialView("CreateIssue", CreateIssueModel(model, true)));
}
else if (!ModelState.IsValid)
{
return(PartialView("CreateIssue", CreateIssueModel(model, false)));
}
else if (model.IsModal)
{
return(Content("OK"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public async Task create_issue_command_fails_when_project_does_not_exist()
{
var projectId = "projectKey";
var epicId = "epicKey";
var issueId = "issueKey";
var title = "Title";
var description = "description";
var type = IssueType.Story;
var status = IssueStatus.TODO;
var storypoints = 0;
var command = new CreateIssue(issueId, type, status, title, description, storypoints, projectId, epicId, null, null, DateTime.Now);
// Check if exception is thrown
_commandHandler
.Awaiting(c => c.HandleAsync(command))
.Should().Throw <ProjectNotFoundException>();
}
public async Task <IActionResult> Add([FromBody] CreateIssue model) //, List<IFormFile> files
{
try
{
if (ModelState.IsValid)
{
var previousVersion = issueManager.GetIssue(model.Id);
var newVersion = await issueManager.SaveIssue(model, null);
var issueActivity = issueManager.SaveActivity(model, previousVersion, newVersion);
//if ((files != null) && (files.Any()))
//{
// int fileCounter = 0;
// foreach (var file in files)
// {
// // fileCounter = SaveAttachedDocument(model, result, fileCounter, file);
// }
//}
if (model.IncludeIssueInResponse)
{
var newIssue = issueManager.GetIssue(newVersion.Id);
return(Json(new { Status = "Success", Data = newIssue }));
}
return(Json(new { Status = "Success" }));
}
}
catch (MissingSettingsException mex)
{
return(Json(new { Status = "Error", Message = String.Format("You need to set a value for {0} first.", mex.MissingSettingName) }));
}
catch (Exception ex)
{
// bErrorStore.LogException(ex, Request.HttpContext);
return(Json(new { Status = "Error", Message = "Error saving issue" }));
}
return(View(model));
}
private async Task <IssueView> CreateIssue(CreateIssue command, int previousCount)
{
var response = await _sut.Client.PostAsync("/api/Issues", command.ToJsonStringContent());
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var issues = await GetIssues();
issues.Count.Should().Be(previousCount + 1);
var issue = issues.Last();
issue.Id.Should().NotBeEmpty();
issue.Type.Should().Be(command.Type);
issue.Title.Should().Be(command.Title);
issue.Description.Should().Be(command.Description);
return(issue);
}
public async Task <IssueDetailVM> SaveIssue(CreateIssue issue, List <IFormFile> files)
{
if (issue.SelectedProject == 0)
{
var defaultProject = await this.iProjectRepository.GetDefaultProjectForTeamMember(this.userSessionHelper.TeamId,
this.userSessionHelper.UserId);
if (defaultProject == null)
{
throw new MissingSettingsException("Missing data", "Default project");
}
issue.SelectedProject = defaultProject.Id;
}
if (issue.SelectedCategory == 0)
{
var categories = this.issueRepository.GetCategories();
issue.SelectedCategory = categories.First().Id;
}
if (issue.SelectedPriority == 0)
{
var categories = this.issueRepository.GetPriorities();
issue.SelectedPriority = categories.First().Id;
}
if (issue.SelectedStatus == 0)
{
var statuses = this.issueRepository.GetStatuses();
issue.SelectedStatus = statuses.First().Id;
}
issue.CreatedByID = this.userSessionHelper.UserId;
issue.TeamID = this.userSessionHelper.TeamId;
var issueId = this.issueRepository.SaveIssue(issue);
var issueDetail = this.issueRepository.GetIssue(issueId, this.userSessionHelper.UserId);
return(issueDetail);
;
}
public async Task <IActionResult> CreateIssue([FromBody] CreateIssue model)
{
try
{
var issue = new Issue {
HandlerId = model.HandlerId,
Customer = model.Customer,
CreatedDate = DateTime.Now,
ChangedDate = model.ChangedDate,
IssueStatus = model.IssueStatus,
IssueDescription = model.IssueDescription
};
_context.Issues.Add(issue);
await _context.SaveChangesAsync();
return(new OkResult());
}
catch { }
return(new BadRequestResult());
}
private Activity SaveActivity(CreateIssue model, Issue existingIssue, Issue issuePreviousVersion, Status currentIssueStatus, int issueId, bool isNewIssue = false)
{
bool isStateChanged = false;
var activity = new Activity()
{
CreatedByID = UserID, ObjectID = issueId, ObjectType = "Issue"
};
if (isNewIssue)
{
activity.ActivityDesc = "Created";
activity.NewState = model.Title;
isStateChanged = true;
}
else
{
if (issuePreviousVersion.StatusID != existingIssue.StatusID)
{
// status of issue updated
activity.OldState = model.Title;
activity.ActivityDesc = "Changed status";
activity.NewState = currentIssueStatus.Name;
isStateChanged = true;
}
}
activity.TeamID = TeamID;
if (isStateChanged)
{
var result = repo.SaveActivity(activity);
if (!result.Status)
{
log.Error(result);
}
return(repo.GetActivity(activity.ID));
}
return(null);
}
