public YouTrackService(IYouTrackExtensionConfigFacade pConfig)
{
_config = pConfig;
_ytConnection = getServiceConnection((YouTrackExtensionConfigFacade)pConfig);
_ytIssues = _ytConnection.CreateIssuesService();
_log.Debug("YouTrackService: ctor called");
}
private async Task <Response> AddNote(int requestId, string noteArea, IssueState state)
{
this.RequiresClaims(UserClaims.Admin);
var issue = await IssuesService.GetAsync(requestId);
if (issue == null)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Issue does not exist to add a note!"
}));
}
var toAddNote = issue.Issues.FirstOrDefault(x => x.Issue == state);
if (toAddNote != null)
{
issue.Issues.Remove(toAddNote);
toAddNote.AdminNote = noteArea;
issue.Issues.Add(toAddNote);
}
var result = await IssuesService.UpdateIssueAsync(issue);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false, Message = "Could not update the notes, please try again or check the logs"
}));
}
public async Task <Negotiator> Details(int id)
{
var issue = await IssuesService.GetAsync(id);
if (issue == null)
{
return(Index());
}
issue = Order(issue);
var m = new IssuesDetailsViewModel
{
Issues = issue.Issues,
RequestId = issue.RequestId,
Title = issue.Title,
IssueStatus = issue.IssueStatus,
Deleted = issue.Deleted,
Type = issue.Type,
ProviderId = issue.ProviderId,
PosterUrl = issue.PosterUrl,
Id = issue.Id
};
return(View["Details", m]);
}
// POST api/<controller>
public async Task <HttpResponseMessage> Post(JObject objData)
{
dynamic jsonData = objData;
List <Reason> postReasons = new List <Reason>();
JArray reasonsJsonArray = jsonData.reasons;
JObject issueJson = jsonData.issue;
Issue toAddIssue = issueJson.ToObject <Issue>();
toAddIssue.State = 1;
toAddIssue.MSTeamId = jsonData.teamId.Value;
foreach (var item in reasonsJsonArray)
{
var reason = item.ToObject <Reason>();
reason.State = 1;
if (!string.IsNullOrEmpty(reason.Name))
{
postReasons.Add(reason);
}
}
await IssuesService.InsertItemAsync(toAddIssue);
foreach (var reason in postReasons)
{
reason.Issue = toAddIssue;
await ReasonsService.InsertItemAsync(reason);
}
return(ToJson(new {
issueId = toAddIssue.Id
}));
}
public async Task <Negotiator> Details(int id)
{
var issue = await IssuesService.GetAsync(id);
if (issue == null)
{
return(Index());
}
issue = Order(issue);
var m = new IssuesDetailsViewModel
{
Issues = issue.Issues,
RequestId = issue.RequestId,
Title = issue.Title,
IssueStatus = issue.IssueStatus,
Deleted = issue.Deleted,
Type = issue.Type,
ProviderId = issue.ProviderId,
PosterUrl = issue.PosterUrl.Contains("https://image.tmdb.org/t/p/w150/") ? issue.PosterUrl : $"https://image.tmdb.org/t/p/w150/{issue.PosterUrl}",
Id = issue.Id
};
return(View["Details", m]);
}
public async Task <HttpResponseMessage> Get(int state, string teamId)
{
var issueList = await IssuesService.GetItemsAsync(state, teamId);
var result = issueList.Select(issue => issue.ToJson()).ToArray();
return(ToJson(result));
}
public async Task <HttpResponseMessage> Delete(int id)
{
await IssuesService.DeleteIssueAndRelatedItemsAsync(id);
return(ToJson(new
{
issueId = id
}));
}
// POST api/<controller>
public async Task <HttpResponseMessage> Post(JObject objData)
{
dynamic jsonData = objData;
JArray issueMetrics = jsonData.issueMetrics;
var toAddIssueMetrics = issueMetrics.Select(im => im.ToObject <IssueMetric>()).ToList();
JArray reasonMetricArrays = jsonData.reasonMetrics;
var toAddReasonMetrics = reasonMetricArrays.Select(rmArray => {
return(rmArray.Select(rm => rm.ToObject <ReasonMetric>()).ToList());
}).ToList();
await IssuesService.UpdateItemAsync(toAddIssueMetrics.First().Issue);
toAddIssueMetrics.ForEach(async issueMetric =>
{
if (issueMetric.MetricValues.HasValue)
{
if (issueMetric.Id == 0)
{
await IssueMetricsService.InsertItemAsync(issueMetric);
}
else
{
await IssueMetricsService.UpdateItemAsync(issueMetric);
}
}
});
toAddReasonMetrics.ForEach(async reasonMetricList =>
{
await ReasonsService.UpdateItemAsync(reasonMetricList.First().Reason);
});
toAddReasonMetrics.ForEach(reasonMetricList =>
{
reasonMetricList.ForEach(async reasonMetric =>
{
if (reasonMetric.ReasonMetricValues.HasValue)
{
if (reasonMetric.Id == 0)
{
await ReasonMetricsService.InsertItemAsync(reasonMetric);
}
else
{
await ReasonMetricsService.UpdateItemAsync(reasonMetric);
}
}
});
});
return(ToJson(new
{
success = true
}));
}
public async Task <Response> IssueCount()
{
var issues = await IssuesService.GetAllAsync();
var myIssues = await FilterIssuesAsync(issues);
var count = myIssues.Count();
return(Response.AsJson(count));
}
private async Task RefreshIssue()
{
if (_issueService == null)
{
_issueService = _connector.CreateIssuesService();
}
var issuesForCurrentUser = await _issueService.GetIssues();
_issues = issuesForCurrentUser.ToList();
}
public async Task <HttpResponseMessage> Post(JObject objData)
{
dynamic jsonData = objData;
Issue toAddIssue = jsonData.issue.ToObject <Issue>();
toAddIssue.State = 1;
toAddIssue.MSTeamId = jsonData.teamId;
var issue = await IssuesService.InsertItemAsync(toAddIssue);
return(ToJson(issue.ToJson()));
}
public async Task <HttpResponseMessage> EditIssue(JObject objData)
{
dynamic jsonData = objData;
JObject issue = jsonData.issue;
var toEditIssue = issue.ToObject <Issue>();
await IssuesService.UpdateItemAsync(toEditIssue);
return(ToJson(new
{
issueId = toEditIssue.Id
}));
}
private async Task <Negotiator> ClearIssue(int issueId, IssueState state)
{
this.RequiresClaims(UserClaims.Admin);
var issue = await IssuesService.GetAsync(issueId);
var toRemove = issue.Issues.FirstOrDefault(x => x.Issue == state);
issue.Issues.Remove(toRemove);
var result = await IssuesService.UpdateIssueAsync(issue);
return(result ? await Details(issueId) : View["Index"]);
}
public async Task <Response> TabCount()
{
var issues = await IssuesService.GetAllAsync();
var myIssues = await FilterIssuesAsync(issues);
var count = new List <object>();
var issuesModels = myIssues as IssuesModel[] ?? myIssues.ToArray();
var pending = issuesModels.Where(x => x.IssueStatus == IssueStatus.PendingIssue);
var resolved = issuesModels.Where(x => x.IssueStatus == IssueStatus.ResolvedIssue);
count.Add(new { Name = IssueStatus.PendingIssue, Count = pending.Count() });
count.Add(new { Name = IssueStatus.ResolvedIssue, Count = resolved.Count() });
return(Response.AsJson(count));
}
private async Task <Negotiator> ClearIssue(int issueId, IssueState state)
{
if (!Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests))
{
return(View["Index"]);
}
var issue = await IssuesService.GetAsync(issueId);
var toRemove = issue.Issues.FirstOrDefault(x => x.Issue == state);
issue.Issues.Remove(toRemove);
var result = await IssuesService.UpdateIssueAsync(issue);
return(result ? await Details(issueId) : View["Index"]);
}
private async Task <List <CustomWorkItem> > GetCustomWorkItemsForProject(IssuesService issueService, TimeTrackingService timeTrackingService, Project project)
{
var issues = new List <Issue>();
try
{
issues.AddRange(await issueService.GetIssuesInProject(project.ShortName, take: 5000).ConfigureAwait(false));
}
catch (Exception ex)
{
// MessageBox.Show(ex.Message);
}
var workItemsTasks = issues.Select(i => GetCustomWorkItemsForIssue(timeTrackingService, i)).ToArray();
var customItems = await Task.WhenAll(workItemsTasks).ConfigureAwait(false);
return(customItems.SelectMany(x => x).ToList());
}
public static void Main(string[] args)
{
Server server = new Server {
Services =
{
IssuesService.BindService(new IssuesServiceImpl())
},
Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("Issues server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
private async Task <Response> RemoveIssue(int issueId)
{
try
{
if (!Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests))
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Sorry, you do not have the correct permissions to remove an issue."
}));
}
var issue = await IssuesService.GetAsync(issueId);
var request = await RequestService.GetAsync(issue.RequestId);
if (request.Id > 0)
{
request.IssueId = 0; // No issue;
var result = await RequestService.UpdateRequestAsync(request);
if (result)
{
await IssuesService.DeleteIssueAsync(issueId);
}
}
else
{
await IssuesService.DeleteIssueAsync(issueId);
}
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
catch (Exception e)
{
Log.Error(e);
return(Response.AsJson(new JsonResponseModel()
{
Result = false, Message = "Could not delete issue! Check the logs."
}));
}
}
private async Task <Negotiator> ChangeStatus(int issueId, IssueStatus status)
{
try
{
this.RequiresClaims(UserClaims.Admin);
var issue = await IssuesService.GetAsync(issueId);
issue.IssueStatus = status;
var result = await IssuesService.UpdateIssueAsync(issue);
return(result ? await Details(issueId) : View["Index"]);
}
catch (Exception e)
{
Log.Error(e);
return(View["Index"]);
}
}
private async Task <Response> RemoveIssue(int issueId)
{
try
{
this.RequiresClaims(UserClaims.Admin);
var issue = await IssuesService.GetAsync(issueId);
var request = await RequestService.GetAsync(issue.RequestId);
if (request.Id > 0)
{
request.IssueId = 0; // No issue;
var result = await RequestService.UpdateRequestAsync(request);
if (result)
{
await IssuesService.DeleteIssueAsync(issueId);
}
}
else
{
await IssuesService.DeleteIssueAsync(issueId);
}
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
catch (Exception e)
{
Log.Error(e);
return(Response.AsJson(new JsonResponseModel()
{
Result = false, Message = "Could not delete issue! Check the logs."
}));
}
}
private async Task <Negotiator> ChangeStatus(int issueId, IssueStatus status)
{
try
{
if (!Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests))
{
return(View["Index"]);
}
var issue = await IssuesService.GetAsync(issueId);
issue.IssueStatus = status;
var result = await IssuesService.UpdateIssueAsync(issue);
return(result ? await Details(issueId) : View["Index"]);
}
catch (Exception e)
{
Log.Error(e);
return(View["Index"]);
}
}
private async Task <Response> GetIssues(IssueStatus status)
{
var issues = await IssuesService.GetAllAsync();
issues = await FilterIssuesAsync(issues, status == IssueStatus.ResolvedIssue);
var issuesModels = issues as IssuesModel[] ?? issues.Where(x => x.IssueStatus == status).ToArray();
var viewModel = new List <IssuesViewModel>();
foreach (var i in issuesModels)
{
var model = new IssuesViewModel {
Id = i.Id, RequestId = i.RequestId, Title = i.Title, Type = i.Type.ToString().ToCamelCaseWords(), Admin = Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests)
};
// Create a string with all of the current issue states with a "," delimiter in e.g. Wrong Content, Playback Issues
var state = i.Issues.Select(x => x.Issue).ToArray();
var issueState = string.Empty;
for (var j = 0; j < state.Length; j++)
{
var word = state[j].ToString().ToCamelCaseWords();
if (j != state.Length - 1)
{
issueState += $"{word}, ";
}
else
{
issueState += word;
}
}
model.Issues = issueState;
viewModel.Add(model);
}
return(Response.AsJson(viewModel));
}
private async Task <Response> AddNote(int requestId, string noteArea, IssueState state)
{
if (!Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests))
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Sorry, you do not have the correct permissions to add a note."
}));
}
var issue = await IssuesService.GetAsync(requestId);
if (issue == null)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Issue does not exist to add a note!"
}));
}
var toAddNote = issue.Issues.FirstOrDefault(x => x.Issue == state);
if (toAddNote != null)
{
issue.Issues.Remove(toAddNote);
toAddNote.AdminNote = noteArea;
issue.Issues.Add(toAddNote);
}
var result = await IssuesService.UpdateIssueAsync(issue);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false, Message = "Could not update the notes, please try again or check the logs"
}));
}
private async Task <Response> ReportNonRequestIssue(int providerId, string type, IssueState issue, string comment)
{
var currentIssues = await IssuesService.GetAllAsync();
var notifyModel = new NotificationModel
{
User = Username,
NotificationType = NotificationType.Issue,
DateTime = DateTime.Now,
Body = issue == IssueState.Other ? comment : issue.ToString().ToCamelCaseWords()
};
var model = new IssueModel
{
Issue = issue,
UserReported = Username,
UserNote = !string.IsNullOrEmpty(comment)
? $"{Username} - {comment}"
: string.Empty,
};
var existing = currentIssues.FirstOrDefault(x => x.ProviderId == providerId && !x.Deleted && x.IssueStatus == IssueStatus.PendingIssue);
if (existing != null)
{
existing.Issues.Add(model);
await IssuesService.UpdateIssueAsync(existing);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
if (type == "movie")
{
var movieApi = new TheMovieDbApi();
var result = await movieApi.GetMovieInformation(providerId);
if (result != null)
{
notifyModel.Title = result.Title;
// New issue
var issues = new IssuesModel
{
Title = result.Title,
PosterUrl = "https://image.tmdb.org/t/p/w150/" + result.PosterPath,
ProviderId = providerId,
Type = RequestType.Movie,
IssueStatus = IssueStatus.PendingIssue
};
issues.Issues.Add(model);
var issueId = await IssuesService.AddIssueAsync(issues);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
}
if (type == "tv")
{
var tv = new TvMazeApi();
var result = tv.ShowLookupByTheTvDbId(providerId);
if (result != null)
{
var banner = result.image?.medium;
if (!string.IsNullOrEmpty(banner))
{
banner = banner.Replace("http", "https");
}
notifyModel.Title = result.name;
// New issue
var issues = new IssuesModel
{
Title = result.name,
PosterUrl = banner,
ProviderId = providerId,
Type = RequestType.TvShow,
IssueStatus = IssueStatus.PendingIssue
};
issues.Issues.Add(model);
var issueId = await IssuesService.AddIssueAsync(issues);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
}
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Album Reports are not supported yet!"
}));
}
private async Task <Response> ReportRequestIssue(int requestId, IssueState issue, string comment)
{
var model = new IssueModel
{
Issue = issue,
UserReported = Username,
UserNote = !string.IsNullOrEmpty(comment)
? $"{Username} - {comment}"
: string.Empty,
};
var request = await RequestService.GetAsync(requestId);
var issueEntity = await IssuesService.GetAllAsync();
var existingIssue = issueEntity.FirstOrDefault(x => x.RequestId == requestId);
var notifyModel = new NotificationModel
{
User = Username,
NotificationType = NotificationType.Issue,
Title = request.Title,
DateTime = DateTime.Now,
Body = issue == IssueState.Other ? comment : issue.ToString().ToCamelCaseWords()
};
// An issue already exists
if (existingIssue != null)
{
if (existingIssue.Issues.Any(x => x.Issue == issue))
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "This issue has already been reported!"
}));
}
existingIssue.Issues.Add(model);
var result = await IssuesService.UpdateIssueAsync(existingIssue);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false
}));
}
// New issue
var issues = new IssuesModel
{
Title = request.Title,
PosterUrl = request.PosterPath,
RequestId = requestId,
Type = request.Type,
IssueStatus = IssueStatus.PendingIssue
};
issues.Issues.Add(model);
var issueId = await IssuesService.AddIssueAsync(issues);
request.IssueId = issueId;
await RequestService.UpdateRequestAsync(request);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
public IssuesController(IIssueTrackerData data)
{
this.service = new IssuesService(data);
this.signInManager = new SignInManager(data);
}
/// <summary>
/// 最新のIssue情報を取得する
/// </summary>
/// <param name="issueRepository">Issueリポジトリインスタンス</param>
/// <param name="apiRepository">API呼び出しリポジトリインスタンス</param>
/// <returns>最新Issue情報</returns>
public List <IssueModel> GetIssues(IIssueRepository issueRepository, IApiRepository apiRepository)
{
var service = new IssuesService();
return(IssueModel.CreateIssues(service.GetIssues(issueRepository, apiRepository)));
}
// GET api/<controller>/5
public async Task <HttpResponseMessage> Get(int id)
{
var queryIssue = await IssuesService.GetItemAsync(id);
return(ToJson(queryIssue.ToJson()));
}
public TypedModel(GitHubService gitHubService, IssuesService issuesService)
{
_gitHubService = gitHubService;
_issuesService = issuesService;
}
public VotesServiceTests()
{
this.picturesList = new List <Picture>();
this.picturesRepo = new Mock <IDeletableEntityRepository <Picture> >();
this.picturesRepo.Setup(x => x.All()).Returns(this.picturesList.AsQueryable());
this.picturesRepo.Setup(x => x.AddAsync(It.IsAny <Picture>())).Callback((Picture picture) => this.picturesList.Add(picture));
this.picturesService = new PicturesService(this.picturesRepo.Object);
this.attachmentsList = new List <Attachment>();
this.attachmentsRepo = new Mock <IDeletableEntityRepository <Attachment> >();
this.attachmentsRepo.Setup(x => x.All()).Returns(this.attachmentsList.AsQueryable());
this.attachmentsRepo.Setup(x => x.AddAsync(It.IsAny <Attachment>())).Callback((Attachment att) => this.attachmentsList.Add(att));
this.issueAttachmentsList = new List <IssueAttachment>();
this.issueAttachmentsRepo = new Mock <IRepository <IssueAttachment> >();
this.issueAttachmentsRepo.Setup(x => x.All()).Returns(this.issueAttachmentsList.AsQueryable());
this.issueAttachmentsRepo.Setup(x => x.AddAsync(It.IsAny <IssueAttachment>())).Callback((IssueAttachment issueAtt) => this.issueAttachmentsList.Add(issueAtt));
this.issuesList = new List <Issue>();
this.issuesRepo = new Mock <IDeletableEntityRepository <Issue> >();
this.issuesRepo.Setup(x => x.All()).Returns(this.issuesList.AsQueryable());
this.issuesRepo.Setup(x => x.AddAsync(It.IsAny <Issue>())).Callback((Issue issue) => this.issuesList.Add(issue));
this.issueTagsList = new List <IssueTag>();
this.issueTagsRepo = new Mock <IRepository <IssueTag> >();
this.issueTagsRepo.Setup(x => x.All()).Returns(this.issueTagsList.AsQueryable());
this.issueTagsRepo.Setup(x => x.AddAsync(It.IsAny <IssueTag>())).Callback((IssueTag issueTag) => this.issueTagsList.Add(issueTag));
this.tagsList = new List <Tag>();
this.tagsRepo = new Mock <IRepository <Tag> >();
this.tagsRepo.Setup(x => x.All()).Returns(this.tagsList.AsQueryable());
this.tagsRepo.Setup(x => x.AddAsync(It.IsAny <Tag>())).Callback((Tag tag) => this.tagsList.Add(tag));
this.tagsService = new TagsService(this.tagsRepo.Object);
this.issueTagsService = new IssueTagsService(this.issueTagsRepo.Object, new StringOperationsServices(), this.tagsService);
this.citizensList = new List <Citizen>();
this.citizensRepo = new Mock <IDeletableEntityRepository <Citizen> >();
this.citizensRepo.Setup(x => x.All()).Returns(this.citizensList.AsQueryable());
this.citizensRepo.Setup(x => x.AddAsync(It.IsAny <Citizen>())).Callback((Citizen citizen) => this.citizensList.Add(citizen));
this.citizensService = new CitizensService(this.citizensRepo.Object);
this.addressList = new List <Address>();
this.addressesRepo = new Mock <IDeletableEntityRepository <Address> >();
this.addressesRepo.Setup(x => x.All()).Returns(this.addressList.AsQueryable());
this.addressesRepo.Setup(x => x.AddAsync(It.IsAny <Address>())).Callback((Address address) => this.addressList.Add(address));
this.addressesService = new AddressesService(this.addressesRepo.Object, this.citiesService);
this.citiesList = new List <City>();
this.citiesRepo = new Mock <IRepository <City> >();
this.citiesRepo.Setup(x => x.All()).Returns(this.citiesList.AsQueryable());
this.citiesRepo.Setup(x => x.AddAsync(It.IsAny <City>())).Callback((City city) => this.citiesList.Add(city));
this.citiesService = new CitiesService(this.citiesRepo.Object);
this.votesList = new List <Vote>();
this.votesRepo = new Mock <IRepository <Vote> >();
this.votesRepo.Setup(x => x.All()).Returns(this.votesList.AsQueryable());
this.votesRepo.Setup(x => x.AllAsNoTracking()).Returns(this.votesList.AsQueryable());
this.votesRepo.Setup(x => x.Delete(It.IsAny <Vote>())).Callback((Vote vote) => this.votesList.Remove(vote));
this.votesRepo.Setup(x => x.AddAsync(It.IsAny <Vote>())).Callback((Vote vote) => this.votesList.Add(vote));
this.issuesService = new IssuesService(
this.issuesRepo.Object,
this.issueAttachmentsRepo.Object,
this.attachmentsRepo.Object,
this.citizensRepo.Object,
this.citizensService,
this.picturesService,
this.addressesService,
this.issueTagsService);
this.votesService = new VotesService(this.votesRepo.Object, this.citizensService, this.issuesService);
}
