public Issue(string title, string description, IssuePriority priority, List <string> tags)
{
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = tags;
}
public AddEditPriorityModel()
{
mIssuePriority = new IssuePriority();
OkButtonCommand = new DelegateCommand<object>(OkButtonHander, CanExecuteOkButtonHandler);
CancelButtonCommand = new DelegateCommand<object>(CancelButtonHander, CanExecuteOkButtonHandler);
}
public void Should_Return_Correct_Value(
string filePath,
int?line,
string message,
IssuePriority priority,
string rule,
string ruleUrl,
string expectedResult)
{
// Given
Uri ruleUri = null;
if (!string.IsNullOrWhiteSpace(ruleUrl))
{
ruleUri = new Uri(ruleUrl);
}
var issue =
IssueBuilder
.NewIssue(message, "ProviderType", "ProviderName")
.InFile(filePath, line)
.OfRule(rule, ruleUri)
.WithPriority(priority)
.Create();
// When
var result = ContentProvider.GetContent(issue);
// Then
result.ShouldBe(expectedResult);
}
private void FillIssueRepositoryWithFakeData()
{
User pesho = new User("pesho", "parola");
User gosho = new User("gosho", "parola");
string title1 = "title1";
string description1 = "description1";
IssuePriority priority1 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags1 = new string[] { "new", "issue", "pink" };
string title2 = "bigtitle";
string description2 = "bigdescription";
IssuePriority priority2 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "medium");
string[] tags2 = new string[] { "new", "issue", "yellow" };
string title3 = "smalltitle";
string description3 = "smalldescription";
IssuePriority priority3 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "medium");
string[] tags3 = new string[] { "green", "issue", "new" };
Issue issue1 = new Issue(title1, description1, priority1, tags1, pesho);
Issue issue2 = new Issue(title2, description2, priority2, tags2, pesho);
Issue issue3 = new Issue(title3, description3, priority3, tags3, gosho);
base.AddIssue(issue1);
base.AddIssue(issue2);
base.AddIssue(issue3);
}
public void TestSearchForIssues_MatchingTags_ShouldReturnIssuesasStringAndNoDuplicates_Test3()
{
IBuhtigIssueTrackerData data = new FakeBuhtigTrackerData();
IIssueTracker tracker = new FakeIssueTrackerWithLoggedUser(data);
string actualResult = tracker.SearchForIssues(new string[] { "pink", "green" });
string title1 = "title1";
string description1 = "description1";
IssuePriority priority1 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags1 = new string[] { "new", "issue", "pink" };
string title3 = "smalltitle";
string description3 = "smalldescription";
IssuePriority priority3 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "medium");
string[] tags3 = new string[] { "green", "issue", "new" };
User pesho = new User("pesho", "parola");
User gosho = new User("gosho", "parola");
Issue issue1 = new Issue(title1, description1, priority1, tags1, pesho);
Issue issue3 = new Issue(title3, description3, priority3, tags3, gosho);
List <Issue> issues = new List <Issue>();
issues.Add(issue1);
issues.Add(issue3);
var sortedIssues = issues.OrderByDescending(issue => issue.Priority).ThenBy(issue => issue.Title);
string expectedResult = string.Join("", sortedIssues);
Assert.AreEqual(expectedResult, actualResult, "SearchForIssues() does not get issues properly.");
}
public void Should_Throw_If_Priority_Is_Different(IssuePriority expectedValue, IssuePriority actualValue)
{
// Given
var fixture = new IssueCheckerFixture();
var issue =
fixture.IssueBuilder
.WithPriority(actualValue)
.Create();
// When
var result = Record.Exception(() =>
IssueChecker.Check(
issue,
fixture.ProviderType,
fixture.ProviderName,
fixture.ProjectFileRelativePath,
fixture.ProjectName,
fixture.AffectedFileRelativePath,
fixture.Line,
fixture.Message,
(int)expectedValue,
fixture.PriorityName,
fixture.Rule,
fixture.RuleUrl));
// Then
result.ShouldBeOfType <Exception>();
result.Message.ShouldStartWith("Expected issue.Priority");
}
public void TestGetMyIssues_ShouldReturnCurrentUserIssues()
{
IBuhtigIssueTrackerData data = new FakeBuhtigTrackerData();
IIssueTracker tracker = new FakeIssueTrackerWithLoggedUser(data);
string actualResult = tracker.GetMyIssues();
string title1 = "title1";
string description1 = "description1";
IssuePriority priority1 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags1 = new string[] { "new", "issue", "pink" };
string title2 = "bigtitle";
string description2 = "bigdescription";
IssuePriority priority2 = (IssuePriority)Enum.Parse(typeof(IssuePriority), "medium");
string[] tags2 = new string[] { "new", "issue", "yellow" };
User pesho = new User("pesho", "parola");
User gosho = new User("gosho", "parola");
Issue issue1 = new Issue(title1, description1, priority1, tags1, pesho);
Issue issue2 = new Issue(title2, description2, priority2, tags2, pesho);
List <Issue> issues = new List <Issue>();
issues.Add(issue1);
issues.Add(issue2);
var sortedIssues = issues.OrderByDescending(issue => issue.Priority).ThenBy(issue => issue.Title);
string expectedResult = string.Join("", sortedIssues);
Assert.AreEqual(expectedResult, actualResult, "GetMyIssues() does not get issues properly.");
}
private static void updatePriority(Issue issue, string prio)
{
if (prio != null)
{
IssuePriority p = new IssuePriority(null, prio);
issue.Priority = p;
}
}
public Issue(string title, string description, IssuePriority priority, List<string> tags)
{
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = tags;
this.Comments = new List<Comment>();
}
public Issue(IssueType t, string txt)
{
Type = t;
State = IssueState.NEW;
Description = txt;
Priority = IssuePriority.NORMAL;
ID = 0;
}
public Issue(string title, string description, IssuePriority priority, IList <string> tags)
{
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = tags;
this.Comments = new List <Comment>();
}
public async Task Save(IssuePriority issuePriority)
{
if (_context.Entry(issuePriority).State == EntityState.Detached)
{
await _context.IssuePriorities.AddAsync(issuePriority);
}
await _context.SaveChangesAsync();
}
public Issue(string title, string description, IssuePriority priority, ICollection <string> tags, User author)
{
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = new HashSet <string>(tags);
this.Author = author;
this.Comments = new List <Comment>();
}
public Problem(int id, string title, string description, IssuePriority priority, List <string> tags)
{
this.Id = id;
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = tags;
this.Comments = new List <Comment>();
}
public Issue(string title, string description, IssuePriority priority, List<string> tags)
{
// If the issue title is less than 3 symbols long, or if the issue description is less than 5 symbols long, the system throws an ArgumentException with an appropriate message.
this.Title = title;
this.Description = description;
this.Priority = priority;
this.Tags = tags;
this.Comments= new List<Comment>();
}
public NewIssuePage SelectPriority(IssuePriority priority)
{
comboboxPriority = new SelectElement(SearchElementUtil.GetElement(driver, locatorComboboxPriority));
if (priority != IssuePriority.Default)
{
comboboxPriority.SelectByText(priority.ToString());
}
return(this);
}
public string DispatchAction(IEndpoint endpoint)
{
switch (endpoint.ActionName)
{
case "RegisterUser":
string username = endpoint.Parameters["username"];
string password = endpoint.Parameters["password"];
string confirmPassword = endpoint.Parameters["confirmPassword"];
return(tracker.RegisterUser(username, password, confirmPassword));
case "LoginUser":
username = endpoint.Parameters["username"];
password = endpoint.Parameters["password"];
return(tracker.LoginUser(username, password));
case "LogoutUser":
return(tracker.LogoutUser());
case "CreateIssue":
string title = endpoint.Parameters["title"];
string description = endpoint.Parameters["description"];
IssuePriority priority = (IssuePriority)System.Enum.Parse(typeof(IssuePriority),
endpoint.Parameters["priority"]);
string[] tags = endpoint.Parameters["tags"].Split('|');
return(tracker.CreateIssue(title, description, priority, tags));
case "RemoveIssue":
int issueId = int.Parse(endpoint.Parameters["id"]);
return(tracker.RemoveIssue(issueId));
case "AddComment":
issueId = int.Parse(endpoint.Parameters["id"]);
string commentText = endpoint.Parameters["text"];
return(tracker.AddComment(issueId, commentText));
case "MyIssues":
return(tracker.GetMyIssues());
case "MyComments": return(tracker.GetMyComments());
case "Search":
tags = endpoint.Parameters["tags"].Split('|');
return(tracker.SearchForIssues(tags));
default:
throw new InvalidOperationException(string.Format("Invalid action: {0}", endpoint.ActionName));
}
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (!this.HasLoggedInUser())
{
return string.Format("There is no currently logged in user");
}
var issue = new Issue(title, description, priority, tags.Distinct().ToList());
int issueId = this.Data.AddIssue(issue);
return string.Format("Issue {0} created successfully", issueId);
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] strings)
{
if (this.Data.CurrentUser == null)
{
return string.Format("There is no currently logged in user");
}
var issue = new Issue(title, description, priority, strings.Distinct().ToList());
this.Data.AddIssue(issue);
return string.Format("Issue {0} created successfully.", issue.Id);
}
/// <summary>
/// Returns an issue for values from an MsBuild log.
/// </summary>
/// <param name="priority">Priority of the issue.</param>
/// <param name="message">Raw value from the MsBuild log containing the message.</param>
/// <param name="projectFile">Raw value from the MsBuild log containing the project file.</param>
/// <param name="file">Raw value from the MsBuild log containing the file.</param>
/// <param name="lineNumber">Raw value from the MsBuild log containing the line number.</param>
/// <param name="endLineNumber">Raw value from the MsBuild log containing the end of the line range.</param>
/// <param name="columnNumber">Raw value from the MsBuild log containing the column.</param>
/// <param name="endColumnNumber">Raw value from the MsBuild log containing the end of the column range.</param>
/// <param name="code">Raw value from the MsBuild log containing the rule.</param>
/// <param name="issueProvider">Issue provider instance.</param>
/// <param name="repositorySettings">Repository settings to use.</param>
/// <returns>Issue instance or null, if the values could not be parsed.</returns>
private IIssue GetIssue(
IssuePriority priority,
string message,
string projectFile,
string file,
int lineNumber,
int endLineNumber,
int columnNumber,
int endColumnNumber,
string code,
MsBuildIssuesProvider issueProvider,
IRepositorySettings repositorySettings)
{
// Ignore warnings or errors without a message.
if (string.IsNullOrWhiteSpace(message))
{
this.Log.Verbose("Skip element since it doesn't contain a message");
return(null);
}
var projectFileRelativePath = this.GetProject(projectFile, repositorySettings);
// Read affected file from the warning or error.
var(result, fileName) = this.TryGetFile(file, projectFile, repositorySettings);
if (!result)
{
this.Log.Information("Skip element since file path could not be parsed");
return(null);
}
var line = GetLine(lineNumber);
var endLine = GetLine(endLineNumber);
var column = GetColumn(columnNumber);
var endColumn = GetColumn(endColumnNumber);
var rule = code;
// Determine rule URL.
Uri ruleUrl = null;
if (!string.IsNullOrWhiteSpace(rule))
{
ruleUrl = MsBuildRuleUrlResolver.Instance.ResolveRuleUrl(rule);
}
// Build issue.
return
(IssueBuilder
.NewIssue(message, issueProvider)
.WithPriority(priority)
.InProject(projectFileRelativePath, System.IO.Path.GetFileNameWithoutExtension(projectFileRelativePath))
.InFile(fileName, line, endLine, column, endColumn)
.OfRule(rule, ruleUrl)
.Create());
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] strings)
{
if (this.Data.CurrentUser == null)
{
return(string.Format("There is no currently logged in user"));
}
var issue = new Issue(title, description, priority, strings.Distinct().ToList());
this.Data.AddIssue(issue);
return(string.Format("Issue {0} created successfully.", issue.Id));
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (!this.HasLoggedInUser())
{
return("There is no currently logged in user");
}
var issue = new Issue(title, description, priority, tags.Distinct().ToList());
int issueId = this.Data.AddIssue(issue);
return(string.Format("Issue {0} created successfully", issueId));
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] strings)
{
if (this.Data.LoggedUser == null)
{
return Messages.NotLogged;
}
var issue = new Issue(this.Data.NextIssueId, title, description, priority, strings.Distinct().ToList());
this.Data.AddIssue(issue);
return string.Format(Messages.IssueCreated, issue.Id);
}
public void Should_Set_Priority(IssuePriority issuePriority, int expectedPriority, string expectedPriorityName)
{
// Given
var fixture = new IssueBuilderFixture();
// When
var issue = fixture.IssueBuilder.WithPriority(issuePriority).Create();
// Then
issue.Priority.ShouldBe(expectedPriority);
issue.PriorityName.ShouldBe(expectedPriorityName);
}
public void TestCreateIssue_InvalidTitleAndDescription_ShouldThrowUp()
{
IIssueTracker tracker = new FakeIssueTrackerWithLoggedUser();
string title = "ab";
string description = "abc";
IssuePriority priority = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags = new string[] { "new", "issue", "another" };
tracker.CreateIssue(title, description, priority, tags);
}
public string CreateIssue(
[PexAssumeUnderTest]IssueTracker target,
string title,
string description,
IssuePriority priority,
string[] strings
)
{
string result = target.CreateIssue(title, description, priority, strings);
return result;
// TODO: add assertions to method IssueTrackerTest.CreateIssue(IssueTracker, String, String, IssuePriority, String[])
}
/// <summary>
/// Creates a new issue.
/// </summary>
public Issue(IssueStatus status, IssuePriority priority, string summary, string description, string version, string targetVersion)
{
Status = status;
Priority = priority;
Summary = summary;
Description = description;
Version = version;
TargetVersion = targetVersion;
DateCreated = DateTime.Now;
DateModified = DateTime.Now;
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (this.Data.LoggedUser == null)
{
return Message.NoOneLogged;
}
var id = this.Data.GetNextIssueId();
var issue = new Problem(id, title, description, priority, tags.Distinct().ToList());
this.Data.IncreaseIssueIdCount();
this.Data.AddIssue(issue);
return string.Format(Message.IssueCreated, issue.Id);
}
public static IssuePriority GetPriority(string p)
{
IssuePriority e = IssuePriority.NORMAL;
try { e = (IssuePriority)Enum.Parse(typeof(IssuePriority), p, true); }
catch
{
switch (p.Replace("[", "").Replace("]", ""))
{
case "!":
e = IssuePriority.CRITICAL;
break;
case "+":
e = IssuePriority.HEIGH;
break;
case "":
e = IssuePriority.NORMAL;
break;
case "-":
e = IssuePriority.LOW;
break;
case "?":
e = IssuePriority.SUGGESTION;
break;
default:
IssuePriority[] bps = (IssuePriority[])Enum.GetValues(typeof(IssuePriority));
foreach (IssuePriority bp in bps)
{
if (p.Length < 3)
{
break;
}
if (bp.ToString().ToLower().StartsWith(p))
{
e = bp;
}
}
break;
}
}
return(e);
}
public int CreateIssue(Issue issue)
{
_context.Issues.Add(issue);
_context.SaveChanges();
IssuePriority priority = new IssuePriority();
priority.IssueOrder = issue.Order;
priority.IssueId = issue.IssueId;
_context.IssuePriority.Add(priority);
_context.SaveChanges();
return(issue.IssueId);
}
/// <summary>
/// Creates a ticket with files attached
/// </summary>
/// <param name="combinedInfos">List of all selected markers</param>
/// <param name="projectKey">Jira project key needed for jira</param>
/// <param name="type">Ticket type</param>
/// <param name="priority">Ticket priority</param>
/// <param name="format">Output file format</param>
/// <param name="summary">Summary of the created issue/ticket</param>
/// <param name="description">Issue/ticket description</param>
public void CreateTicket(List <Filter> combinedInfos, String projectKey, IssueType type,
IssuePriority priority, FileFormat format, String summary, [Optional] String description)
{
var issue = _jira.CreateIssue(projectKey);
issue.Type = type;
issue.Priority = priority;
issue.Summary = summary;
issue.Description = description;
issue.SaveChanges();
String ticketDirPath = Path.GetFullPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
@"Tickets" + Path.DirectorySeparatorChar + GetDate()));
Directory.CreateDirectory(ticketDirPath);
if (format == FileFormat.TextFile)
{
foreach (var info in combinedInfos)
{
var deviceName = info.Marker.Devicename;
deviceName = Path.GetInvalidFileNameChars().Aggregate(deviceName, (current, c) => current.Replace(c, '_'));
String fileName = Path.GetFullPath(Path.Combine(ticketDirPath, deviceName + "_" +
info.Marker.MarkerId + info.Level + (info.timeSpanMinus + info.timeSpanPlus) + ".txt"));
CreateMarkerFile(info, fileName, projectKey);
issue.AddAttachment(fileName);
}
}
else if (format == FileFormat.JsonFile)
{
foreach (var info in combinedInfos)
{
var deviceName = info.Marker.Devicename;
deviceName = Path.GetInvalidFileNameChars().Aggregate(deviceName, (current, c) => current.Replace(c, '_'));
String fileName = Path.GetFullPath(Path.Combine(ticketDirPath, deviceName + "_"
+ info.Marker.MarkerId + info.Level + (info.timeSpanMinus + info.timeSpanPlus) + ".json"));
CreateMarkerJson(info, fileName);
issue.AddAttachment(fileName);
}
}
foreach (var filename in from filter in combinedInfos where filter.CreateVideo select Config.GetVideoDirPath + "marker_" + filter.Marker.MarkerId + "_" +
filter.Marker.Devicename + ".mp4")
{
issue.AddAttachment(filename);
}
}
public void TestCreateIssue_NoLoggedInUser()
{
IIssueTracker tracker = new FakeIssueTrackerWithNoUser();
string title = "title";
string description = "description";
IssuePriority priority = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags = new string[] { "new", "issue", "another" };
string result = tracker.CreateIssue(title, description, priority, tags);
Assert.AreEqual(result, "There is no currently logged in user",
"CreateIssue() does not return proper outcome in case of no logged in user.");
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var issuePriority = new IssuePriority();
issuePriority.Id = dictionary.GetValue <int>("id");
issuePriority.Name = dictionary.GetValue <string>("name");
issuePriority.IsDefault = dictionary.GetValue <bool>("is_default");
return(issuePriority);
}
return(null);
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var issuePriority = new IssuePriority();
issuePriority.Id = dictionary.GetValue<int>(RedmineKeys.ID);
issuePriority.Name = dictionary.GetValue<string>(RedmineKeys.NAME);
issuePriority.IsDefault = dictionary.GetValue<bool>(RedmineKeys.IS_DEFAULT);
return issuePriority;
}
return null;
}
public void TestCreateIssue_ValidIssueDetails_ShouldAddIssueToDatabase()
{
IIssueTracker tracker = new FakeIssueTrackerWithLoggedUser();
string title = "title";
string description = "description";
IssuePriority priority = (IssuePriority)Enum.Parse(typeof(IssuePriority), "low");
string[] tags = new string[] { "new", "issue", "another" };
string result = tracker.CreateIssue(title, description, priority, tags);
Assert.AreEqual(result, "Issue 1 created successfully",
"CreateIssue() does not return proper outcome after successful issue creation.");
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var issuePriority = new IssuePriority();
issuePriority.Id = dictionary.GetValue <int>(RedmineKeys.ID);
issuePriority.Name = dictionary.GetValue <string>(RedmineKeys.NAME);
issuePriority.IsDefault = dictionary.GetValue <bool>(RedmineKeys.IS_DEFAULT);
return(issuePriority);
}
return(null);
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (this.Data.LoggedUser == null)
{
return(Message.NoOneLogged);
}
var id = this.Data.GetNextIssueId();
var issue = new Problem(id, title, description, priority, tags.Distinct().ToList());
this.Data.IncreaseIssueIdCount();
this.Data.AddIssue(issue);
return(string.Format(Message.IssueCreated, issue.Id));
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var issuePriority = new IssuePriority();
issuePriority.Id = dictionary.GetValue<int>("id");
issuePriority.Name = dictionary.GetValue<string>("name");
issuePriority.IsDefault = dictionary.GetValue<bool>("is_default");
return issuePriority;
}
return null;
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] stringTags)
{
if (this.Data.CurrentUser == null)
{
return(Constants.AlreadyLoggedUserWarning);
}
var tags = stringTags.Distinct().ToList();
var issue = new Issue(title, description, priority, tags);
this.Data.AddIssue(issue);
// ToDo: Should AddIssue return type?
return(string.Format(Constants.SuccessfullIssueCreationMessage, issue.Id));
}
public async Task<IActionResult> Create(
CancellationToken cancellationToken,
[FromBody] CreateIssuePriorityBinding binding,
[FromServices] IIssuePriorityRepository issuePriorityRepository)
{
var issuePriority = await issuePriorityRepository.Get(binding.Id, cancellationToken);
if (issuePriority != null)
if (!issuePriority.Name.Equals(binding.Name))
throw new ApiException(HttpStatusCode.Conflict, ErrorCode.IssuePriorityAlreadyExists, "Issue priority already exists with other parameters");
issuePriority = new IssuePriority(binding.Id, binding.Name, binding.IsActive);
await issuePriorityRepository.Save(issuePriority);
return CreatedAtRoute("GetIssuePriorityAdminRoute", new { id = issuePriority.Id }, null);
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (this.Data.LoggedInUser == null)
{
return NoLoggedInUserMessage;
}
var issue = new Issue(title, description, priority, tags.Distinct().ToList());
issue.Id = this.Data.IssueId;
this.Data.Issues.Add(issue.Id, issue);
this.Data.IssueId++;
this.Data.UserIssues[this.Data.LoggedInUser.Username].Add(issue);
foreach (var tag in issue.Tags)
{
this.Data.TagIssues[tag].Add(issue);
}
return string.Format("Issue {0} created successfully.", issue.Id);
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
if (this.Data.LoggedUser == null)
{
return "There is no currently logged in user";
}
var issue = new Issue(title, description, priority, tags.Distinct().ToList());
issue.Id = this.Data.NextIssueId;
this.Data.IssuesById.Add(issue.Id, issue);
this.Data.NextIssueId++;
this.Data.IssuesByUsername[this.Data.LoggedUser.Username].Add(
issue);
foreach (var tag in issue.Tags)
{
this.Data.IssuesByTags[tag].Add(issue);
}
return string.Format("Issue {0} created successfully", issue.Id);
}
public IssuePriority SaveIssuePriority(IssuePriority issuePriority)
{
using (var cee = new CmsEntities())
{
//Check if the pipe area exist
IssuePriority originalObject =
(from x in cee.IssuePriorities where x.Id == issuePriority.Id select x).FirstOrDefault();
if (originalObject == null)
{
//Add new Issue Priority
issuePriority.Code = issuePriority.Name.Replace(" ", "");
issuePriority.IsActive = true;
cee.IssuePriorities.Add(issuePriority);
}
else
{
//Update existing Priority
originalObject.Name = issuePriority.Name;
originalObject.Ordinal = issuePriority.Ordinal;
}
cee.SaveChanges();
}
return issuePriority;
}
public string CreateIssue(string title, string description, IssuePriority priority, string[] tags)
{
// If there is no logged in user, the action returns There is no currently logged in user
if (this.Data.CurrentUser == null)
{
return "There is no currently logged in user";
}
// In case of success, the action returns Issue <id> created successfully
var issue = new Issue(title, description, priority, tags.Distinct().ToList());
this.Data.AddIssue(issue);
return string.Format("Issue {0} created successfully.", issue.Id);
}
void cmsWebServiceClient_GetIssuePriorityCompleted(object sender, GetIssuePriorityCompletedEventArgs e)
{
mIssuePriority = e.Result;
DataLoaded(null);
}
public void ImportIssuePriority()
{
mForm.AddMessage(MessageType.Info, "-------------------- Importing Issue Priority --------------------");
List<Priority> Prioritys = (from x in mOldIssuesDataContext.Priorities select x).ToList();
foreach (var Priority in Prioritys)
{
IssuePriority newPriority = new IssuePriority()
{
Name = Priority.Name,
Ordinal = Priority.Ordinal
};
var priorityExist = (from x in mCee.IssuePriorities where x.Name == newPriority.Name select x).FirstOrDefault();
if (priorityExist == null)
{
string message = String.Format("Adding Issue Priority '{0}'", newPriority.Name);
mForm.AddMessage(MessageType.Info, message);
mCee.IssuePriorities.AddObject(newPriority);
}
else
{
string message = String.Format("Issue Priority '{0}' already exist, skipping", priorityExist.Name);
mForm.AddMessage(MessageType.Warning, message);
}
}
mCee.SaveChanges();
}
