public ProfileController(IProfileService profileService, IIssueService issueService)
{
_profileService = profileService;
_profileService.AvatarFolder = WebConfigurationManager.AppSettings["AvatarFolder"];
_profileService.DefaultAvatar = WebConfigurationManager.AppSettings["DefaultAvatar"];
_issueService = issueService;
}
public void InitializeServicesWithAuthenticationType(AuthenticationType type)
{
if (type == AuthenticationType.Basic)
{
this._userService = new UserService(AuthenticationType.Basic);
this._issueService = new IssueService(AuthenticationType.Basic);
this._transitionService = new TransitionService(AuthenticationType.Basic);
this._priorityService = new PriorityService(AuthenticationType.Basic);
this._attachmentService = new AttachmentService(AuthenticationType.Basic);
this._boardService = new BoardService(AuthenticationType.Basic);
this._sprintService = new SprintService(AuthenticationType.Basic);
this._projectService = new ProjectService(AuthenticationType.Basic);
}
else if (type == AuthenticationType.OAuth)
{
this._userService = new UserService(AuthenticationType.OAuth);
this._issueService = new IssueService(AuthenticationType.OAuth);
this._transitionService = new TransitionService(AuthenticationType.OAuth);
this._priorityService = new PriorityService(AuthenticationType.OAuth);
this._attachmentService = new AttachmentService(AuthenticationType.OAuth);
this._boardService = new BoardService(AuthenticationType.OAuth);
this._sprintService = new SprintService(AuthenticationType.OAuth);
this._projectService = new ProjectService(AuthenticationType.OAuth);
}
}
public DoiRegLogEntity GetDoiRegLog(DoiRegLogQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
DoiRegLogEntity model = service.GetDoiRegLog(query);
return(model);
}
public IssueSubscribeEntity GetIssueSubscribeModel(IssueSubscribeQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IssueSubscribeEntity model = service.GetIssueSubscribe(query.subscribeID);
return(model);
}
public IList <IssueSubscribeEntity> GetIssueSubscribeList(IssueSubscribeQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IList <IssueSubscribeEntity> list = service.GetIssueSubscribeList(query);
return(list);
}
public WorklogView(RefreshableWorklogViewModel parent, Issue issue, IIssueService issueService, IssueDetailViewModel refreshViewModel)
{
InitializeComponent();
this._viewModel = new WorklogViewModel(parent, issue, issueService, refreshViewModel);
this.DataContext = this._viewModel;
}
public IssueController(IIssueService IssueService, IProjectService projectService, UserManager <User> userManager, RoleManager <Role> roleManager)
{
_IssueService = IssueService;
_projectService = projectService;
_userManager = userManager;
_roleManager = roleManager;
}
public static async Task <IReadOnlyList <Contribution> > Get(
IReadOnlyCollection <CommitterGroup> committerGroups, IIssueService issueService)
{
Guard.AgainstNullArgument(nameof(committerGroups), committerGroups);
Guard.AgainstNullArgument(nameof(issueService), issueService);
return
((await Task.WhenAll(committerGroups.SelectMany(group => @group.RepositoryList.Select(id =>
{
log.InfoFormat("Getting issues for {@Repository}...", id);
return issueService.Get(id.Owner, id.Name).ContinueWith(task =>
{
if (task.Exception != null)
{
log.ErrorException("Failed to get issues for {@Repository}.", task.Exception.InnerException, id);
return Enumerable.Empty <Issue>();
}
log.InfoFormat("Got issues for {@Repository}.", id);
return task.Result;
});
}))))
.SelectMany(_ => _)
.Select(issue => new { issue.Repository, Login = issue.Creator, issue.Created.LocalDateTime })
.Distinct()
.GroupBy(contribution => new
{
Group = committerGroups.First(group => @group.RepositoryList.Contains(contribution.Repository)).Name,
contribution.Login
})
.Select(g => new Contribution(g.Key.Group, g.Key.Login, g.Sum(contribution => Score(contribution.LocalDateTime))))
.ToList());
}
public IssueSiteEntity GetCurIssueInfo(IssueSetQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IssueSiteEntity issueEntity = service.GetCurIssueInfo(query);
return(issueEntity);
}
public static void Initialize(TestContext context)
{
_config = TestAssistant.GetConfig();
_applicationService = new ApplicationService(new GenericRepository <Application>(_config));
_issueService = new IssueService(new GenericRepository <Issue>(_config));
_logger = new Mock <ILogger <HomeController> >();
}
public IssueController(IRepository <Issue> issueRepository,
IRepository <IssueItem> issueItemRepository,
IRepository <Item> itemRepository,
IIssueService issueService,
IStoreService storeService,
IAutoNumberService autoNumberService,
IItemService itemService,
IUnitConversionService unitConversionService,
IDateTimeHelper dateTimeHelper,
ILocalizationService localizationService,
IPermissionService permissionService,
HttpContextBase httpContext,
IWorkContext workContext,
IDbContext dbContext)
{
this._issueRepository = issueRepository;
this._issueItemRepository = issueItemRepository;
this._itemRepository = itemRepository;
this._localizationService = localizationService;
this._issueService = issueService;
this._storeService = storeService;
this._autoNumberService = autoNumberService;
this._itemService = itemService;
this._unitConversionService = unitConversionService;
this._dateTimeHelper = dateTimeHelper;
this._permissionService = permissionService;
this._httpContext = httpContext;
this._workContext = workContext;
this._dbContext = dbContext;
}
public IssueListView(JiraToolWindowNavigatorViewModel parent, IIssueService issueService, Project project)
{
InitializeComponent();
this._viewModel = new IssueListViewModel(parent, issueService, project);
this.DataContext = this._viewModel;
}
public FiltersListView(IJiraToolWindowNavigatorViewModel parent, IIssueService issueService)
{
InitializeComponent();
this._viewModel = new FilterListViewModel(parent, issueService);
this.DataContext = this._viewModel;
}
public IssueListView(JiraToolWindowNavigatorViewModel parent, IIssueService issueService, ISprintService sprintService, bool quickSearch, string filter)
{
InitializeComponent();
this._viewModel = new IssueListViewModel(parent, issueService, quickSearch, filter);
this.DataContext = this._viewModel;
}
public Pager <IssueSubscribeEntity> GetIssueSubscribePageList(IssueSubscribeQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
Pager <IssueSubscribeEntity> pager = service.GetIssueSubscribePageList(query);
return(pager);
}
public async Task <IActionResult> IssueTracker()
{
IIssueService fetchingService = null;
string configJson = await IOHelper.ReadFile(this.configFilePath);
List <WidgetConfiguration> widgetConfiguration = JsonConvert.DeserializeObject <List <WidgetConfiguration> >(configJson);
if (widgetConfiguration != null && widgetConfiguration.Count > 0)
{
foreach (WidgetConfiguration item in widgetConfiguration)
{
if (item.WidgetType == "it")
{
object[] args = new object[] { item.RestApiUrls, item.RestApiHeader, };
fetchingService = (IIssueService)Activator.CreateInstance(Type.GetType(item.ServiceName), args);
}
}
}
List <Issue> result = new List <Issue>();
if (fetchingService != null)
{
result = fetchingService.GetIssues();
}
return(this.Ok(result));
}
public IList <YearVolumeEntity> GetYearVolumeList(YearVolumeQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IList <YearVolumeEntity> list = service.GetYearVolumeList(query);
return(list);
}
public IssuesController(IUserService userService, IIssueService issueService, ICarService carService, IValidator validator)
{
this.userService = userService;
this.issueService = issueService;
this.carService = carService;
this.validator = validator;
}
public Pager <YearVolumeEntity> GetYearVolumePageList(YearVolumeQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
Pager <YearVolumeEntity> pager = service.GetYearVolumePageList(query);
return(pager);
}
public IssueContentEntity GetIssueContentModel(IssueContentQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IssueContentEntity model = service.GetIssueContent(query);
return(model);
}
public IList <JournalChannelEntity> GetJournalChannelListByIssueContent(JournalChannelQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IList <JournalChannelEntity> list = service.GetJournalChannelListByIssueContent(query);
return(list);
}
public JournalChannelEntity GetJournalChannelModel(JournalChannelQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
JournalChannelEntity model = service.GetJournalChannel(query.JChannelID);
return(model);
}
public IssueSetEntity GetIssueSetModel(IssueSetQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IssueSetEntity model = null;
if (query.IssueSetID == 0)
{
model = service.GetMaxIssueSet(query.JournalID);
}
else
{
model = service.GetIssueSet(query.IssueSetID);
}
if (model != null)
{
Pager <IssueSetEntity> currentEntity = service.GetIssueSetPageList(query);
if (currentEntity != null && currentEntity.ItemList != null && currentEntity.ItemList.Count > 0)
{
IList <IssueSetEntity> list = currentEntity.ItemList;
IssueSetEntity single = list.Where(o => o.Issue == model.Issue).SingleOrDefault();
model.PrintExpenses = single.PrintExpenses;
}
}
return(model);
}
public Pager <JournalChannelEntity> GetJournalChannelPageList(JournalChannelQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
Pager <JournalChannelEntity> pager = service.GetJournalChannelPageList(query);
return(pager);
}
public IList <DoiRegLogEntity> GetDoiRegLogList(DoiRegLogQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
IList <DoiRegLogEntity> list = service.GetDoiRegLogList(query);
return(list);
}
public Pager <DoiRegLogEntity> GetDoiRegLogPageList(DoiRegLogQuery query)
{
IIssueService service = ServiceContainer.Instance.Container.Resolve <IIssueService>();
Pager <DoiRegLogEntity> pager = service.GetDoiRegLogPageList(query);
return(pager);
}
public IssuesModule(ISettingsService <PlexRequestSettings> pr, IIssueService issueService, IRequestService request, INotificationService n, ISecurityExtensions security) : base("issues", pr, security)
{
IssuesService = issueService;
RequestService = request;
NotificationService = n;
Get["/"] = x => Index();
Get["/{id}", true] = async(x, ct) => await Details(x.id);
Post["/issue", true] = async(x, ct) => await ReportRequestIssue((int)Request.Form.requestId, (IssueState)(int)Request.Form.issue, null);
Get["/pending", true] = async(x, ct) => await GetIssues(IssueStatus.PendingIssue);
Get["/resolved", true] = async(x, ct) => await GetIssues(IssueStatus.ResolvedIssue);
Post["/remove", true] = async(x, ct) => await RemoveIssue((int)Request.Form.issueId);
Post["/resolvedUpdate", true] = async(x, ct) => await ChangeStatus((int)Request.Form.issueId, IssueStatus.ResolvedIssue);
Post["/clear", true] = async(x, ct) => await ClearIssue((int)Request.Form.issueId, (IssueState)(int)Request.Form.issue);
Get["/issuecount", true] = async(x, ct) => await IssueCount();
Get["/tabCount", true] = async(x, ct) => await TabCount();
Post["/issuecomment", true] = async(x, ct) => await ReportRequestIssue((int)Request.Form.providerId, IssueState.Other, (string)Request.Form.commentArea);
Post["/nonrequestissue", true] = async(x, ct) => await ReportNonRequestIssue((int)Request.Form.providerId, (string)Request.Form.type, (IssueState)(int)Request.Form.issue, null);
Post["/nonrequestissuecomment", true] = async(x, ct) => await ReportNonRequestIssue((int)Request.Form.providerId, (string)Request.Form.type, IssueState.Other, (string)Request.Form.commentArea);
Post["/addnote", true] = async(x, ct) => await AddNote((int)Request.Form.requestId, (string)Request.Form.noteArea, (IssueState)(int)Request.Form.issue);
}
public IssuesController(
UserManager <User> userManager,
RoleManager <IdentityRole> roleManager,
IIssueService issues)
: base(userManager, roleManager)
{
this.issues = issues;
}
public IssuesPageViewModel(
IIssueService issueService,
IMessageBoxService messageBoxService)
{
_issueService = issueService;
_messageBoxService = messageBoxService;
RefreshCommand = ReactiveCommand.CreateFromTask(OnRefreshHandlerAsync);
}
public IndexModel(TimeTracking.Models.TimeTrackDataContext context,
IAuthorizationService authorizationService,
UserManager <IdentityUser> userManager,
ISprintsService sprintsService,
IIssueService issueService)
: base(context, authorizationService, userManager, sprintsService, issueService)
{
}
public IssueController()
{
var dbfactory = new DatabaseFactory();
_IssueService = new IssueService(new IssueRepository(dbfactory), new UnitOfWork(dbfactory));
_IssueDetailService = new IssueDetailService(new IssueDetailRepository(dbfactory), new UnitOfWork(dbfactory));
_SecCompanyService = new SecCompanyService(new SecCompanyRepository(dbfactory), new UnitOfWork(dbfactory));
_officeService = new OfficeService(new OfficeRepository(dbfactory), new UnitOfWork(dbfactory));
_hrmEmployeeService = new HrmEmployeeService(new HrmEmployeeRepository(dbfactory), new UnitOfWork(dbfactory));
}
public ApiPublicationController(IOrchardServices orchardServices, IVideoService videoService, IIssueService issueService, ICategoryService categoryService, IImageService imageService)
{
_videoService = videoService;
_issueService = issueService;
_categoryService = categoryService;
_imageService = imageService;
Services = orchardServices;
T = NullLocalizer.Instance;
}
public IssueListPageViewModel(ILoader loader, ILoader listLoader, IProgressService progressService,
INavigationService navigationService,
IIssueService issueService)
: base(loader, listLoader, progressService, navigationService)
{
_issueService = issueService;
Title = IssueList.Title;
}
public Github(IUserService userService, IRepositoryService repositoryService, INetworkService networkService,
IIssueService issueService, IObjectService objectService, ICommitService commitService)
{
Users = userService;
Repositories = repositoryService;
Networks = networkService;
Issues = issueService;
Objects = objectService;
Commits = commitService;
}
public MainWindowViewModel(IIssueService issueService, IProjectService projectService, IRepositoryService repositoryService,
IScriptService scriptService, IMailService mailService, IDocumentBuilder documentBuilder, ICustomFieldsService customFieldsService)
{
_issueService = issueService;
_projectService = projectService;
_repositoryService = repositoryService;
_scriptService = scriptService;
_mailService = mailService;
_documentBuilder = documentBuilder;
_customFieldsService = customFieldsService;
}
public HomeController(IProjectService projectService, IIssueService issueService, IIssueRepository issueRepository)
{
_projectService = projectService;
_issueService = issueService;
_issueRepo = issueRepository;
}
public IssuesController(IIssueService issueService)
: base()
{
_issueService = issueService;
}
public IssueTrackerFacade(IIssueService issueService, IStateService stateService, IProjectService projectService)
{
_issueService = issueService;
_projectService = projectService;
_stateService = stateService;
}
public void Setup()
{
IssueRepository = GithubServiceLocator.Get<IIssueService>();
}
public static async Task<IReadOnlyList<Contribution>> Get(
IReadOnlyCollection<CommitterGroup> committerGroups, IIssueService issueService)
{
Guard.AgainstNullArgument(nameof(committerGroups), committerGroups);
Guard.AgainstNullArgument(nameof(issueService), issueService);
return
(await Task.WhenAll(committerGroups.SelectMany(group => @group.RepositoryList.Select(id =>
{
log.InfoFormat("Getting issues for {@Repository}...", id);
return issueService.Get(id.Owner, id.Name).ContinueWith(task =>
{
if (task.Exception != null)
{
log.ErrorException("Failed to get issues for {@Repository}.", task.Exception.InnerException, id);
return Enumerable.Empty<Issue>();
}
log.InfoFormat("Got issues for {@Repository}.", id);
return task.Result;
});
}))))
.SelectMany(_ => _)
.Select(issue => new { issue.Repository, Login = issue.Creator, issue.Created.LocalDateTime })
.Distinct()
.GroupBy(contribution => new
{
Group = committerGroups.First(group => @group.RepositoryList.Contains(contribution.Repository)).Name,
contribution.Login
})
.Select(g => new Contribution(g.Key.Group, g.Key.Login, g.Sum(contribution => Score(contribution.LocalDateTime))))
.ToList();
}
