protected BaseEventsViewModel(IApplicationService applicationService)
{
ApplicationService = applicationService;
Events = new ReactiveCollection<Tuple<EventModel, EventBlock>>();
ReportRepository = true;
GoToRepositoryCommand = new ReactiveCommand();
GoToRepositoryCommand.OfType<EventModel.RepoModel>().Subscribe(x =>
{
var repoId = new RepositoryIdentifier(x.Name);
var vm = CreateViewModel<RepositoryViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
ShowViewModel(vm);
});
GoToGistCommand = new ReactiveCommand();
GoToGistCommand.OfType<EventModel.GistEvent>().Subscribe(x =>
{
var vm = CreateViewModel<GistViewModel>();
vm.Id = x.Gist.Id;
vm.Gist = x.Gist;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
this.RequestModel(CreateRequest(0, 100), t as bool?, response =>
{
this.CreateMore(response, m => Events.MoreTask = m, d => Events.AddRange(CreateDataFromLoad(d)));
Events.Reset(CreateDataFromLoad(response.Data));
}));
}
public OrganizationRepositoriesViewModel(IApplicationService applicationService)
: base(applicationService)
{
ShowRepositoryOwner = false;
LoadCommand.RegisterAsyncTask(t =>
Repositories.SimpleCollectionLoad(applicationService.Client.Organizations[Name].Repositories.GetAll(), t as bool?));
}
public SegmentService(IIdentityLogicFactory identityLogicFactory, ITraitBuilder traitBuilder, IApplicationService applicationService, ILandlordService landlordService)
{
_identityLogicFactory = identityLogicFactory;
_traitBuilder = traitBuilder;
_applicationService = applicationService;
_landlordService = landlordService;
}
public PullRequestsViewModel(IApplicationService applicationService)
{
PullRequests = new ReactiveList<PullRequestModel>();
GoToPullRequestCommand = ReactiveCommand.Create();
GoToPullRequestCommand.OfType<PullRequestModel>().Subscribe(pullRequest =>
{
var vm = CreateViewModel<PullRequestViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.PullRequestId = pullRequest.Number;
vm.PullRequest = pullRequest;
vm.WhenAnyValue(x => x.PullRequest).Skip(1).Subscribe(x =>
{
var index = PullRequests.IndexOf(pullRequest);
if (index < 0) return;
PullRequests[index] = x;
PullRequests.Reset();
});
ShowViewModel(vm);
});
this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan());
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var state = SelectedFilter == 0 ? "open" : "closed";
var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests.GetAll(state: state);
return PullRequests.SimpleCollectionLoad(request, t as bool?);
});
}
public void TestFixtureSetUp()
{
try
{
CodeSharp.Core.Configuration.ConfigWithEmbeddedXml(null
, "application_config"
, Assembly.GetExecutingAssembly()
, "Properties.Model.Test.ConfigFiles")
.RenderProperties()
.Castle(o => this.Resolve(o.Container));
Lock.InitAll(DependencyResolver.Resolve<ILockHelper>());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
this._log = DependencyResolver.Resolve<ILoggerFactory>().Create(this.GetType());
this._sessionManager = DependencyResolver.Resolve<Castle.Facilities.NHibernateIntegration.ISessionManager>();
this._accountService = DependencyResolver.Resolve<IAccountService>();
this._appService = DependencyResolver.Resolve<IApplicationService>();
this._configService = DependencyResolver.Resolve<IConfigurationService>();
DependencyResolver.Resolve<ILockHelper>().Require<Account>();
}
public IssueAssignedToViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
Users = new ReactiveCollection<BasicUserModel>();
SelectUserCommand = new ReactiveCommand();
SelectUserCommand.RegisterAsyncTask(async t =>
{
var selectedUser = t as BasicUserModel;
if (selectedUser != null)
SelectedUser = selectedUser;
if (SaveOnSelect)
{
var assignee = SelectedUser != null ? SelectedUser.Login : null;
var updateReq = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateAssignee(assignee);
await _applicationService.Client.ExecuteAsync(updateReq);
}
DismissCommand.ExecuteIfCan();
});
LoadCommand.RegisterAsyncTask(t =>
Users.SimpleCollectionLoad(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetAssignees(), t as bool?));
}
public ProjectController(
IApplicationService service,
IReadModelFacade facade)
{
_service = service;
_facade = facade;
}
public virtual void SetUp()
{
ContentAreaRepository = MockRepository.GenerateMock<IContentAreaRepository>();
CollectionService = MockRepository.GenerateMock<ICollectionService>();
ApplicationService = MockRepository.GenerateMock<IApplicationService>();
ContentAreaService = new ContentAreaService(ContentAreaRepository, CollectionService);
}
public SourceTreeViewModel(IApplicationService applicationService, IFeaturesService featuresService)
{
_applicationService = applicationService;
_featuresService = featuresService;
GoToItemCommand = ReactiveUI.ReactiveCommand.Create();
GoToItemCommand.OfType<ContentModel>().Subscribe(x => {
if (x.Type.Equals("dir", StringComparison.OrdinalIgnoreCase))
{
ShowViewModel<SourceTreeViewModel>(new NavObject { Username = Username, Branch = Branch,
Repository = Repository, Path = x.Path, TrueBranch = TrueBranch });
}
if (x.Type.Equals("file", StringComparison.OrdinalIgnoreCase))
{
if (x.DownloadUrl == null)
{
var nameAndSlug = x.GitUrl.Substring(x.GitUrl.IndexOf("/repos/", StringComparison.Ordinal) + 7);
var indexOfGit = nameAndSlug.LastIndexOf("/git", StringComparison.Ordinal);
indexOfGit = indexOfGit < 0 ? 0 : indexOfGit;
var repoId = RepositoryIdentifier.FromFullName(nameAndSlug.Substring(0, indexOfGit));
if (repoId == null)
return;
var sha = x.GitUrl.Substring(x.GitUrl.LastIndexOf("/", StringComparison.Ordinal) + 1);
ShowViewModel<SourceTreeViewModel>(new NavObject {Username = repoId?.Owner, Repository = repoId?.Name, Branch = sha});
}
else
{
ShowViewModel<SourceViewModel>(new SourceViewModel.NavObject {
Name = x.Name, Username = Username, Repository = Repository, Branch = Branch,
Path = x.Path, HtmlUrl = x.HtmlUrl, GitUrl = x.GitUrl, TrueBranch = TrueBranch });
}
}
});
}
public EditSourceViewModel(IApplicationService applicationService)
{
SaveCommand = new ReactiveCommand();
SaveCommand.Subscribe(_ =>
{
var vm = CreateViewModel<CommitMessageViewModel>();
vm.SaveCommand.RegisterAsyncTask(async t =>
{
var request = applicationService.Client.Users[Username].Repositories[Repository]
.UpdateContentFile(Path, vm.Message, Text, BlobSha, Branch);
var response = await applicationService.Client.ExecuteAsync(request);
Content = response.Data;
DismissCommand.ExecuteIfCan();
});
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(async t =>
{
var path = Path;
if (!path.StartsWith("/", StringComparison.Ordinal))
path = "/" + path;
var request = applicationService.Client.Users[Username].Repositories[Repository].GetContentFile(path, Branch ?? "master");
request.UseCache = false;
var data = await applicationService.Client.ExecuteAsync(request);
BlobSha = data.Data.Sha;
Text = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(data.Data.Content));
});
}
public ApplicationServiceTest()
{
IApiService apiService = new ApiService();
IUrlBuilder urlBuilder = new UrlBuilder();
ITwitterRepository repository = new TwitterRepository();
this._service = new ApplicationService(repository, apiService, urlBuilder);
}
public ChangesetViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
Comments = new ReactiveList<CommentModel>();
GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Commit).Select(x => x != null));
GoToHtmlUrlCommand.Select(x => Commit).Subscribe(GoToUrlCommand.ExecuteIfCan);
GoToRepositoryCommand = ReactiveCommand.Create();
GoToRepositoryCommand.Subscribe(_ =>
{
var vm = CreateViewModel<RepositoryViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToFileCommand = ReactiveCommand.Create();
GoToFileCommand.OfType<CommitModel.CommitFileModel>().Subscribe(x =>
{
if (x.Patch == null)
{
var vm = CreateViewModel<SourceViewModel>();
vm.Branch = Commit.Sha;
vm.Username = RepositoryOwner;
vm.Repository = RepositoryName;
vm.Items = new []
{
new SourceViewModel.SourceItemModel
{
ForceBinary = true,
GitUrl = x.BlobUrl,
Name = x.Filename,
Path = x.Filename,
HtmlUrl = x.BlobUrl
}
};
vm.CurrentItemIndex = 0;
ShowViewModel(vm);
}
else
{
var vm = CreateViewModel<ChangesetDiffViewModel>();
vm.Username = RepositoryOwner;
vm.Repository = RepositoryName;
vm.Branch = Commit.Sha;
vm.Filename = x.Filename;
ShowViewModel(vm);
}
});
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Commits[Node].Get(), forceCacheInvalidation, response => Commit = response.Data);
Comments.SimpleCollectionLoad(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Commits[Node].Comments.GetAll(), forceCacheInvalidation).FireAndForget();
return t1;
});
}
public ApplicationModule(IApplicationService applicationService, IErrorService error)
: base("/application")
{
Post["/register"] = _ =>
{
if (Params.AreMissing("SingleUseToken", "Name")) return error.MissingParameters(Response);
if (!Params.SingleUseToken.IsGuid()) return error.InvalidParameters(Response);
if (!applicationService.AuthoriseSingleUseToken(Params.SingleUseToken)) return error.PermissionDenied(Response);
var application = applicationService.Register(Params.Name);
return (application == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ApplicationId = application.Id });
};
Post["/transfer"] = _ =>
{
if (Params.AreMissing("SingleUseToken", "Name", "Id")) return error.MissingParameters(Response);
if (!Params.Id.IsGuid() || !Params.SingleUseToken.IsGuid()) return error.InvalidParameters(Response);
if (!applicationService.AuthoriseSingleUseToken(Params.SingleUseToken)) return error.PermissionDenied(Response);
var application = applicationService.Transfer(Params.Name, Params.Id);
return (application == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ApplicationId = application.Id });
};
}
public GoogleAnalyticsService()
{
_googleAnalytics = new GoogleAnalytics();
_googleAnalytics.CustomVariables.Add(new PropertyValue
{
PropertyName = "Device ID",
Value = AnalyticsProperties.DeviceId
});
_googleAnalytics.CustomVariables.Add(new PropertyValue
{
PropertyName = "Application Version",
Value = AnalyticsProperties.ApplicationVersion
});
_googleAnalytics.CustomVariables.Add(new PropertyValue
{
PropertyName = "Device OS",
Value = AnalyticsProperties.OsVersion
});
_googleAnalytics.CustomVariables.Add(new PropertyValue
{
PropertyName = "Device",
Value = AnalyticsProperties.Device
});
_googleAnalytics.CustomVariables.Add(new PropertyValue
{
PropertyName = "Anonymous User ID",
Value = ViewModel.ViewModelLocator.ApplicationSettingsStatic.AnonymousUserId
});
_innerService = new WebAnalyticsService
{
IsPageTrackingEnabled = false,
Services = {_googleAnalytics,}
};
}
public CampaignLogicFactory(
ISubscriberTrackingService<ApplicationSummary> applicationSubscriberTrackingService,
IDataGatherFactory<ApplicationSummary> applicationGatherFactory,
IDataGatherFactory<LandlordSummary> landlordGatherFactory,
ISubscriberTrackingService<LandlordSummary> landlordSubscriberTrackingService,
IApplicationService applicationService,
ILetMeServiceUrlSettings letMeServiceUrlSettings,
ISubscriberRecordService subscriberRecordService,
ILogger logger
)
{
Check.If(landlordSubscriberTrackingService).IsNotNull();
Check.If(applicationService).IsNotNull();
Check.If(applicationGatherFactory).IsNotNull();
Check.If(letMeServiceUrlSettings).IsNotNull();
Check.If(landlordSubscriberTrackingService).IsNotNull();
_campaignLogic = new List<ICampaignLogic>
{
new AddApplicationNoGuarantorEventLogic(applicationGatherFactory, applicationSubscriberTrackingService, logger),
new NewPropertyAddedEventLogic(applicationGatherFactory, applicationSubscriberTrackingService, letMeServiceUrlSettings, subscriberRecordService, logger),
new BookAViewingCampaignLogic(applicationGatherFactory, applicationSubscriberTrackingService),
new DeclinedGuarantorCampaignLogic(applicationGatherFactory, applicationSubscriberTrackingService),
new NewPropertySubmissionCampaignLogic(landlordGatherFactory,landlordSubscriberTrackingService)
};
}
protected BaseRepositoriesViewModel(IApplicationService applicationService, string filterKey = "RepositoryController")
{
ApplicationService = applicationService;
ShowRepositoryOwner = true;
var gotoRepository = new Action<RepositoryItemViewModel>(x =>
{
var vm = CreateViewModel<RepositoryViewModel>();
vm.RepositoryOwner = x.Owner;
vm.RepositoryName = x.Name;
ShowViewModel(vm);
});
Repositories = RepositoryCollection.CreateDerivedCollection(
x => new RepositoryItemViewModel(x.Name, x.Owner.Login, x.Owner.AvatarUrl,
ShowRepositoryDescription ? x.Description : string.Empty, x.StargazersCount, x.ForksCount,
ShowRepositoryOwner, gotoRepository),
x => x.Name.ContainsKeyword(SearchKeyword),
signalReset: this.WhenAnyValue(x => x.SearchKeyword));
//Filter = applicationService.Account.Filters.GetFilter<RepositoriesFilterModel>(filterKey);
this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan());
// _repositories.FilteringFunction = x => Repositories.Filter.Ascending ? x.OrderBy(y => y.Name) : x.OrderByDescending(y => y.Name);
// _repositories.GroupingFunction = CreateGroupedItems;
}
public IssueEditViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
GoToDescriptionCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Issue, x => x != null));
GoToDescriptionCommand.Subscribe(_ =>
{
var vm = CreateViewModel<ComposerViewModel>();
vm.Text = Issue.Body;
vm.SaveCommand.Subscribe(__ =>
{
Issue.Body = vm.Text;
vm.DismissCommand.ExecuteIfCan();
});
ShowViewModel(vm);
});
this.WhenAnyValue(x => x.Issue).Where(x => x != null).Subscribe(x =>
{
Title = x.Title;
AssignedTo = x.Assignee;
Milestone = x.Milestone;
Labels = x.Labels.ToArray();
Content = x.Body;
IsOpen = string.Equals(x.State, "open");
});
}
public PullRequestFilesViewModel(IApplicationService applicationService)
{
Files = new ReactiveCollection<CommitModel.CommitFileModel>
{
GroupFunc = y =>
{
var filename = "/" + y.Filename;
return filename.Substring(0, filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
}
};
GoToSourceCommand = new ReactiveCommand();
GoToSourceCommand.OfType<CommitModel.CommitFileModel>().Subscribe(x =>
{
var vm = CreateViewModel<SourceViewModel>();
// vm.Name = x.Filename.Substring(x.Filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
// vm.Path = x.Filename;
// vm.GitUrl = x.ContentsUrl;
// vm.ForceBinary = x.Patch == null;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
Files.SimpleCollectionLoad(
applicationService.Client.Users[Username].Repositories[Repository].PullRequests[PullRequestId]
.GetFiles(), t as bool?));
}
public IssueMilestonesViewModel(IApplicationService applicationService)
{
Milestones = new ReactiveCollection<MilestoneModel>();
SelectMilestoneCommand = new ReactiveCommand();
SelectMilestoneCommand.RegisterAsyncTask(async t =>
{
var milestone = t as MilestoneModel;
if (milestone != null)
SelectedMilestone = milestone;
if (SaveOnSelect)
{
try
{
int? milestoneNumber = null;
if (SelectedMilestone != null) milestoneNumber = SelectedMilestone.Number;
var updateReq = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateMilestone(milestoneNumber);
await applicationService.Client.ExecuteAsync(updateReq);
}
catch (Exception e)
{
throw new Exception("Unable to to save milestone! Please try again.", e);
}
}
DismissCommand.ExecuteIfCan();
});
LoadCommand.RegisterAsyncTask(t =>
Milestones.SimpleCollectionLoad(
applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Milestones.GetAll(),
t as bool?));
}
public EditSourceViewModel(IApplicationService applicationService)
{
SaveCommand = ReactiveCommand.Create();
SaveCommand.Subscribe(_ =>
{
var vm = CreateViewModel<CommitMessageViewModel>();
vm.Username = Username;
vm.Repository = Repository;
vm.Path = Path;
vm.Text = Text;
vm.BlobSha = BlobSha;
vm.Branch = Branch;
vm.ContentChanged.Subscribe(x => Content = x);
ShowViewModel(vm);
});
LoadCommand = ReactiveCommand.CreateAsyncTask(async t =>
{
var path = Path;
if (!path.StartsWith("/", StringComparison.Ordinal))
path = "/" + path;
var request = applicationService.Client.Users[Username].Repositories[Repository].GetContentFile(path, Branch ?? "master");
request.UseCache = false;
var data = await applicationService.Client.ExecuteAsync(request);
BlobSha = data.Data.Sha;
var content = Convert.FromBase64String(data.Data.Content);
Text = System.Text.Encoding.UTF8.GetString(content, 0, content.Length);
});
}
public CashHomeViewModel(ScreenCoordinator screenCoordinator, IApplicationService applicationService)
{
ScreenCoordinator = screenCoordinator;
ApplicationService = applicationService;
Text = new BindableCollection<string>();
}
public ShellForm(IKernel kernel)
{
Asserter.AssertIsNotNull(kernel, "kernel");
_kernel = kernel;
_applicationService = _kernel.Get<IApplicationService>();
_storageService = _kernel.Get<IStorageService>();
_settingsService = _kernel.Get<ISettingsService>();
_siteService = _kernel.Get<ISiteService>();
_controller = _kernel.Get<ShellController>();
Asserter.AssertIsNotNull(_applicationService, "_applicationService");
Asserter.AssertIsNotNull(_storageService, "_storageService");
Asserter.AssertIsNotNull(_settingsService, "_settingsService");
Asserter.AssertIsNotNull(_siteService, "_siteService");
InitializeComponent();
_siteService.Register(SiteNames.ContentSite, contentPanel);
_siteService.Register(SiteNames.NavigationSite, navigationPanel);
_siteService.Register(SiteNames.ContentActionsSite, contentActionPanel);
SetStyle(ControlStyles.OptimizedDoubleBuffer |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.ResizeRedraw, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="AboutViewModel" /> class.
/// </summary>
/// <param name="settingsService">The settings service.</param>
/// <param name="applicationService">The application service.</param>
public AboutViewModel(
ISettingsService settingsService,
IApplicationService applicationService)
{
this.settingsService = settingsService;
this.applicationService = applicationService;
}
public AddInterestViewModel(IApplicationService applicationService)
{
DoneCommand = ReactiveCommand.CreateAsyncTask(async _ =>
{
if (SelectedLanguage == null)
throw new Exception("You must select a language for your interest!");
if (string.IsNullOrEmpty(Keyword))
throw new Exception("Please specify a keyword to go with your interest!");
applicationService.Account.Interests.Insert(new Interest
{
Language = _selectedLanguage.Name,
LanguageId = _selectedLanguage.Slug,
Keyword = _keyword
});
await DismissCommand.ExecuteAsync();
});
GoToLanguagesCommand = ReactiveCommand.Create();
GoToLanguagesCommand.Subscribe(_ =>
{
var vm = CreateViewModel<LanguagesViewModel>();
vm.SelectedLanguage = SelectedLanguage;
vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x =>
{
SelectedLanguage = x;
vm.DismissCommand.ExecuteIfCan();
});
ShowViewModel(vm);
});
var str = System.IO.File.ReadAllText(PopularInterestsPath, System.Text.Encoding.UTF8);
PopularInterests = new ReactiveList<PopularInterest>(JsonConvert.DeserializeObject<List<PopularInterest>>(str));
}
public AthleteViewModel(IApplicationService service)
{
athleteInfo = new AthleteDto() { EventParticipationk__BackingField = new List<EventAreaDto>(Constants.EVENT_AREAS) };
this._service = service;
this.myAthletes = new ObservableCollection<AthleteDto>();
this.showCurrent = true;
this.showFuture = true;
this.showPast = false;
this.showAllInventoryItems = false;
this.showOnlyDefaultInventoryItems = true;
this.totalsByStatusModel = new TotalByStatusModel();
this.SaveAthleteCommand = new RelayCommand(SaveAthlete);
this.ClearFieldsCommand = new RelayCommand(ClearAthleteInfo);
this.EditSelectedAthleteCommand = new RelayCommand<AthleteDto>(athleteToEdit => LoadAthleteInfoWithSelectedAthlete(athleteToEdit));
Genders = new ObservableCollection<Char>(Data.Constants.GENDERS);
Statuses = new ObservableCollection<String>(Data.Constants.ATHLETE_STATUSES);
Messenger.Default.Register<ObservableCollection<AthleteDto>>(
this,
(a) => MyAthletes = a
);
}
public GistViewableFileViewModel(IApplicationService applicationService, IFilesystemService filesystemService)
{
GoToFileSourceCommand = ReactiveCommand.Create();
LoadCommand = ReactiveCommand.CreateAsyncTask(async t =>
{
string data;
using (var ms = new System.IO.MemoryStream())
{
await applicationService.Client.DownloadRawResource(GistFile.RawUrl, ms);
ms.Position = 0;
var sr = new System.IO.StreamReader(ms);
data = sr.ReadToEnd();
}
if (GistFile.Language.Equals("Markdown"))
data = await applicationService.Client.Markdown.GetMarkdown(data);
string path;
using (var stream = filesystemService.CreateTempFile(out path, "gist.html"))
{
using (var fs = new System.IO.StreamWriter(stream))
{
fs.Write(data);
}
}
FilePath = path;
});
}
protected BaseEventsViewModel(IApplicationService applicationService)
{
ApplicationService = applicationService;
var events = new ReactiveList<EventModel>();
Events = events.CreateDerivedCollection(CreateEventTextBlocks);
ReportRepository = true;
GoToRepositoryCommand = ReactiveCommand.Create();
GoToRepositoryCommand.OfType<EventModel.RepoModel>().Subscribe(x =>
{
var repoId = new RepositoryIdentifier(x.Name);
var vm = CreateViewModel<RepositoryViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
ShowViewModel(vm);
});
GoToGistCommand = ReactiveCommand.Create();
GoToGistCommand.OfType<EventModel.GistEvent>().Subscribe(x =>
{
var vm = CreateViewModel<GistViewModel>();
vm.Id = x.Gist.Id;
vm.Gist = x.Gist;
ShowViewModel(vm);
});
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
this.RequestModel(CreateRequest(0, 100), t as bool?, response =>
{
//this.CreateMore(response, m => { }, events.AddRange);
events.Reset(response.Data);
}));
}
public RepositoriesStarredViewModel(IApplicationService applicationService) : base(applicationService)
{
ShowRepositoryOwner = true;
LoadCommand.RegisterAsyncTask(t =>
Repositories.SimpleCollectionLoad(
applicationService.Client.AuthenticatedUser.Repositories.GetStarred(), t as bool?));
}
public ApplicationController(IApplicationService applicationService,
ICredentialProvider credentialProvider,
KuduEnvironment environment)
{
_applicationService = applicationService;
_credentialProvider = credentialProvider;
_environment = environment;
}
public ApplicationQueryController(IApplicationService applicationService, IApplicationQueryService queryService)
{
Check.If(applicationService).IsNotNull();
Check.If(queryService).IsNotNull();
_applicationService = applicationService;
_queryService = queryService;
}
public EngageApplication(IApplicationService applicationService)
{
_applicationService = applicationService;
}
public MainForm(IApplicationService appService)
{
InitializeComponent();
_appService = appService;
}
public SeatsListerVm(ISeatQueries seatQueries, IApplicationService applicationService) : base(applicationService)
{
_seatQueries = seatQueries ?? throw new ArgumentNullException(nameof(seatQueries));
}
/// <summary>
/// Invokes the middleware.
/// </summary>
/// <param name="context">The current http context</param>
/// <param name="api">The current api</param>
/// <param name="service">The application service</param>
/// <returns>An async task</returns>
public override async Task Invoke(HttpContext context, IApi api, IApplicationService service)
{
var appConfig = new Config(api);
if (!IsHandled(context) && !context.Request.Path.Value.StartsWith("/manager/assets/"))
{
var url = context.Request.Path.HasValue ? context.Request.Path.Value : "";
var segments = url.Substring(1).Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
int pos = 0;
//
// 1: Store raw url
//
service.Url = context.Request.Path.Value;
//
// 2: Get the current site
//
Site site = null;
var hostname = context.Request.Host.Host;
if (_config.UseSiteRouting)
{
// Try to get the requested site by hostname & prefix
if (segments.Length > 0)
{
var prefixedHostname = $"{hostname}/{segments[0]}";
site = await api.Sites.GetByHostnameAsync(prefixedHostname)
.ConfigureAwait(false);
if (site != null)
{
context.Request.Path = "/" + string.Join("/", segments.Skip(1));
hostname = prefixedHostname;
pos = 1;
}
}
// Try to get the requested site by hostname
if (site == null)
{
site = await api.Sites.GetByHostnameAsync(context.Request.Host.Host)
.ConfigureAwait(false);
}
}
// If we didn't find the site, get the default site
if (site == null)
{
site = await api.Sites.GetDefaultAsync()
.ConfigureAwait(false);
}
if (site != null)
{
// Update application service
service.Site.Id = site.Id;
service.Site.Culture = site.Culture;
service.Site.Sitemap = await api.Sites.GetSitemapAsync(site.Id);
// Set current culture if specified in site
if (!string.IsNullOrEmpty(site.Culture))
{
var cultureInfo = new CultureInfo(service.Site.Culture);
CultureInfo.CurrentCulture = CultureInfo.CurrentUICulture = cultureInfo;
}
}
else
{
// There's no sites available, let the application finish
await _next.Invoke(context);
return;
}
// Store hostname
service.Hostname = hostname;
//
// Check if we shouldn't handle empty requests for start page
//
if (segments.Length == 0 && !_config.UseStartpageRouting)
{
await _next.Invoke(context);
return;
}
//
// 3: Check for alias
//
if (_config.UseAliasRouting && segments.Length > pos)
{
var alias = await api.Aliases.GetByAliasUrlAsync($"/{ string.Join("/", segments.Subset(pos)) }", service.Site.Id);
if (alias != null)
{
context.Response.Redirect(alias.RedirectUrl, alias.Type == RedirectType.Permanent);
return;
}
}
//
// 4: Get the current page
//
PageBase page = null;
PageType pageType = null;
if (segments.Length > pos)
{
// Scan for the most unique slug
for (var n = segments.Length; n > pos; n--)
{
var slug = string.Join("/", segments.Subset(pos, n));
page = await api.Pages.GetBySlugAsync <PageBase>(slug, site.Id)
.ConfigureAwait(false);
if (page != null)
{
pos = pos + n;
break;
}
}
}
else
{
page = await api.Pages.GetStartpageAsync <PageBase>(site.Id)
.ConfigureAwait(false);
}
if (page != null)
{
pageType = App.PageTypes.GetById(page.TypeId);
service.PageId = page.Id;
// Only cache published pages
if (page.IsPublished)
{
service.CurrentPage = page;
}
}
//
// 5: Get the current post
//
PostBase post = null;
if (_config.UsePostRouting)
{
if (page != null && pageType.IsArchive && segments.Length > pos)
{
post = await api.Posts.GetBySlugAsync <PostBase>(page.Id, segments[pos])
.ConfigureAwait(false);
if (post != null)
{
pos++;
}
}
if (post != null)
{
App.PostTypes.GetById(post.TypeId);
// Onlyc cache published posts
if (post.IsPublished)
{
service.CurrentPost = post;
}
}
}
_logger?.LogDebug($"Found Site: [{ site.Id }]");
if (page != null)
{
_logger?.LogDebug($"Found Page: [{ page.Id }]");
}
if (post != null)
{
_logger?.LogDebug($"Found Post: [{ post.Id }]");
}
//
// 6: Route request
//
var route = new StringBuilder();
var query = new StringBuilder();
if (post != null)
{
if (string.IsNullOrWhiteSpace(post.RedirectUrl))
{
// Handle HTTP caching
if (HandleCache(context, site, post, appConfig.CacheExpiresPosts))
{
// Client has latest version
return;
}
route.Append(post.Route ?? "/post");
for (var n = pos; n < segments.Length; n++)
{
route.Append("/");
route.Append(segments[n]);
}
query.Append("id=");
query.Append(post.Id);
}
else
{
_logger?.LogDebug($"Setting redirect: [{ post.RedirectUrl }]");
context.Response.Redirect(post.RedirectUrl, post.RedirectType == RedirectType.Permanent);
return;
}
}
else if (page != null && _config.UsePageRouting)
{
if (string.IsNullOrWhiteSpace(page.RedirectUrl))
{
route.Append(page.Route ?? (pageType.IsArchive ? "/archive" : "/page"));
// Set the basic query
query.Append("id=");
query.Append(page.Id);
if (!page.ParentId.HasValue && page.SortOrder == 0)
{
query.Append("&startpage=true");
}
if (!pageType.IsArchive)
{
if (HandleCache(context, site, page, appConfig.CacheExpiresPages))
{
// Client has latest version.
return;
}
// This is a regular page, append trailing segments
for (var n = pos; n < segments.Length; n++)
{
route.Append("/");
route.Append(segments[n]);
}
}
else if (post == null)
{
// This is an archive, check for archive params
int? year = null;
bool foundCategory = false;
bool foundTag = false;
bool foundPage = false;
for (var n = pos; n < segments.Length; n++)
{
if (segments[n] == "category" && !foundPage)
{
foundCategory = true;
continue;
}
if (segments[n] == "tag" && !foundPage && !foundCategory)
{
foundTag = true;
continue;
}
if (segments[n] == "page")
{
foundPage = true;
continue;
}
if (foundCategory)
{
try
{
var categoryId = (await api.Posts.GetCategoryBySlugAsync(page.Id, segments[n]).ConfigureAwait(false))?.Id;
if (categoryId.HasValue)
{
query.Append("&category=");
query.Append(categoryId);
}
}
finally
{
foundCategory = false;
}
}
if (foundTag)
{
try
{
var tagId = (await api.Posts.GetTagBySlugAsync(page.Id, segments[n]).ConfigureAwait(false))?.Id;
if (tagId.HasValue)
{
query.Append("&tag=");
query.Append(tagId);
}
}
finally
{
foundTag = false;
}
}
if (foundPage)
{
try
{
var pageNum = Convert.ToInt32(segments[n]);
query.Append("&page=");
query.Append(pageNum);
query.Append("&pagenum=");
query.Append(pageNum);
}
catch
{
// We don't care about the exception, we just
// discard malformed input
}
// Page number should always be last, break the loop
break;
}
if (!year.HasValue)
{
try
{
year = Convert.ToInt32(segments[n]);
if (year.Value > DateTime.Now.Year)
{
year = DateTime.Now.Year;
}
query.Append("&year=");
query.Append(year);
}
catch
{
// We don't care about the exception, we just
// discard malformed input
}
}
else
{
try
{
var month = Math.Max(Math.Min(Convert.ToInt32(segments[n]), 12), 1);
query.Append("&month=");
query.Append(month);
}
catch
{
// We don't care about the exception, we just
// discard malformed input
}
}
}
}
}
else
{
_logger?.LogDebug($"Setting redirect: [{ page.RedirectUrl }]");
context.Response.Redirect(page.RedirectUrl, page.RedirectType == RedirectType.Permanent);
return;
}
}
if (route.Length > 0)
{
var strRoute = route.ToString();
var strQuery = query.ToString();
_logger?.LogDebug($"Setting Route: [{ strRoute }]");
_logger?.LogDebug($"Setting Query: [{ strQuery }]");
context.Request.Path = new PathString(strRoute);
if (context.Request.QueryString.HasValue)
{
context.Request.QueryString =
new QueryString(context.Request.QueryString.Value + "&" + strQuery);
}
else
{
context.Request.QueryString =
new QueryString("?" + strQuery);
}
}
}
await _next.Invoke(context);
}
public StumbledRepositoryViewModel(IApplicationService applicationService, INetworkActivityService networkActivity)
: base(applicationService, networkActivity)
{
}
public AppController(IApplicationService applicationService)
{
_applicationService = applicationService;
}
public PushNotificationsService(IApplicationService applicationService)
{
_applicationService = applicationService;
}
private readonly string _userId = Infrastructure.EntityFramework.DataSeeder.TestUser1Id.ToString(); //TODO: Remove after identity implementation
public ApplicationsController(IApplicationService applicationService, IMapper mapper)
{
this.applicationService = applicationService;
this.mapper = mapper;
}
public PublicGistsViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
}
public RepositoryViewModel(IApplicationService applicationService,
IAccountsService accountsService, IActionMenuFactory actionMenuService)
{
ApplicationService = applicationService;
_accountsService = accountsService;
this.WhenAnyValue(x => x.RepositoryName).Subscribe(x => Title = x);
this.WhenAnyValue(x => x.Repository).Subscribe(x =>
{
Stargazers = x != null ? (int?)x.StargazersCount : null;
Watchers = x != null ? (int?)x.SubscribersCount : null;
});
ToggleStarCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), t => ToggleStar());
ToggleWatchCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsWatched, x => x.HasValue), t => ToggleWatch());
GoToOwnerCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
GoToOwnerCommand.Select(_ => Repository.Owner).Subscribe(x =>
{
if (string.Equals(x.Type, "organization", StringComparison.OrdinalIgnoreCase))
{
var vm = this.CreateViewModel <OrganizationViewModel>();
vm.Username = RepositoryOwner;
NavigateTo(vm);
}
else
{
var vm = this.CreateViewModel <UserViewModel>();
vm.Username = RepositoryOwner;
NavigateTo(vm);
}
});
PinCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
PinCommand.Subscribe(x => PinRepository());
GoToForkParentCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && x.Fork && x.Parent != null));
GoToForkParentCommand.Subscribe(x =>
{
var vm = this.CreateViewModel <RepositoryViewModel>();
vm.RepositoryOwner = Repository.Parent.Owner.Login;
vm.RepositoryName = Repository.Parent.Name;
vm.Repository = Repository.Parent;
NavigateTo(vm);
});
GoToStargazersCommand = ReactiveCommand.Create();
GoToStargazersCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryStargazersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToWatchersCommand = ReactiveCommand.Create();
GoToWatchersCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryWatchersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToEventsCommand = ReactiveCommand.Create();
GoToEventsCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryEventsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToIssuesCommand = ReactiveCommand.Create();
GoToIssuesCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <IssuesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToReadmeCommand = ReactiveCommand.Create();
GoToReadmeCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <ReadmeViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToBranchesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = this.CreateViewModel <CommitBranchesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToCommitsCommand = ReactiveCommand.Create();
GoToCommitsCommand.Subscribe(_ =>
{
if (Branches != null && Branches.Count == 1)
{
var vm = this.CreateViewModel <CommitsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Branch = Repository == null ? null : Repository.DefaultBranch;
NavigateTo(vm);
}
else
{
GoToBranchesCommand.ExecuteIfCan();
}
});
GoToPullRequestsCommand = ReactiveCommand.Create();
GoToPullRequestsCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <PullRequestsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToSourceCommand = ReactiveCommand.Create();
GoToSourceCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToContributors = ReactiveCommand.Create();
GoToContributors.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryContributorsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToForksCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = this.CreateViewModel <RepositoryForksViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToReleasesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = this.CreateViewModel <ReleasesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
ShowMenuCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.Repository, x => x.IsStarred, x => x.IsWatched)
.Select(x => x.Item1 != null && x.Item2 != null && x.Item3 != null),
_ =>
{
var menu = actionMenuService.Create(Title);
menu.AddButton(IsPinned ? "Unpin from Slideout Menu" : "Pin to Slideout Menu", PinCommand);
menu.AddButton(IsStarred.Value ? "Unstar This Repo" : "Star This Repo", ToggleStarCommand);
menu.AddButton(IsWatched.Value ? "Unwatch This Repo" : "Watch This Repo", ToggleWatchCommand);
menu.AddButton("Show in GitHub", GoToHtmlUrlCommand);
return(menu.Show());
});
var gotoWebUrl = new Action <string>(x =>
{
var vm = this.CreateViewModel <WebBrowserViewModel>();
vm.Url = x;
NavigateTo(vm);
});
GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
GoToHtmlUrlCommand.Select(_ => Repository.HtmlUrl).Subscribe(gotoWebUrl);
GoToHomepageCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.Homepage)));
GoToHomepageCommand.Select(_ => Repository.Homepage).Subscribe(gotoWebUrl);
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Get(),
forceCacheInvalidation, response => Repository = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReadme(),
forceCacheInvalidation, response => Readme = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches(),
forceCacheInvalidation, response => Branches = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsWatching(),
forceCacheInvalidation, response => IsWatched = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsStarred(),
forceCacheInvalidation, response => IsStarred = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContributors(),
forceCacheInvalidation, response => Contributors = response.Data.Count);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetLanguages(),
forceCacheInvalidation, response => Languages = response.Data.Count);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReleases(),
forceCacheInvalidation, response => Releases = response.Data.Count);
return(t1);
});
}
public ApplicationFacade(IUnitOfWorkProvider unitOfWorkProvider, IApplicationService applicationService) : base(unitOfWorkProvider)
{
this.applicationService = applicationService;
}
public AppleViewModel(IApplicationService application,
IAppleService apple)
{
_application = application;
_apple = apple;
}
public IssueViewModel(IApplicationService applicationService, IShareService shareService)
{
_applicationService = applicationService;
Comments = new ReactiveList <IssueCommentModel>();
Events = new ReactiveList <IssueEventModel>();
var issuePresenceObservable = this.WhenAnyValue(x => x.Issue).Select(x => x != null);
ShareCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
ShareCommand.Subscribe(_ => shareService.ShareUrl(Issue.HtmlUrl));
AddCommentCommand = ReactiveCommand.Create();
AddCommentCommand.Subscribe(_ =>
{
var vm = CreateViewModel <CommentViewModel>();
ReactiveUI.Legacy.ReactiveCommandMixins.RegisterAsyncTask(vm.SaveCommand, async t =>
{
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId];
var comment = await _applicationService.Client.ExecuteAsync(issue.CreateComment(vm.Comment));
Comments.Add(comment.Data);
vm.DismissCommand.ExecuteIfCan();
});
ShowViewModel(vm);
});
ToggleStateCommand = ReactiveCommand.CreateAsyncTask(issuePresenceObservable, async t =>
{
var close = string.Equals(Issue.State, "open", StringComparison.OrdinalIgnoreCase);
try
{
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[Issue.Number];
var data = await _applicationService.Client.ExecuteAsync(issue.UpdateState(close ? "closed" : "open"));
Issue = data.Data;
}
catch (Exception e)
{
throw new Exception("Unable to " + (close ? "close" : "open") + " the item. " + e.Message, e);
}
});
GoToEditCommand = ReactiveCommand.Create(issuePresenceObservable);
GoToEditCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssueEditViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Id = IssueId;
vm.Issue = Issue;
vm.WhenAnyValue(x => x.Issue).Skip(1).Subscribe(x => Issue = x);
ShowViewModel(vm);
});
GoToAssigneeCommand = ReactiveCommand.Create(issuePresenceObservable);
GoToAssigneeCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssueAssignedToViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedUser = Issue.Assignee;
vm.WhenAnyValue(x => x.SelectedUser).Subscribe(x =>
{
Issue.Assignee = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToLabelsCommand = ReactiveCommand.Create(issuePresenceObservable);
GoToLabelsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssueLabelsViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedLabels.Reset(Issue.Labels);
vm.WhenAnyValue(x => x.SelectedLabels).Subscribe(x =>
{
Issue.Labels = x.ToList();
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToMilestoneCommand = ReactiveCommand.Create(issuePresenceObservable);
GoToMilestoneCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssueMilestonesViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedMilestone = Issue.Milestone;
vm.WhenAnyValue(x => x.SelectedMilestone).Subscribe(x =>
{
Issue.Milestone = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId];
var t1 = this.RequestModel(issue.Get(), forceCacheInvalidation, response => Issue = response.Data);
Comments.SimpleCollectionLoad(issue.GetComments(), forceCacheInvalidation).FireAndForget();
Events.SimpleCollectionLoad(issue.GetEvents(), forceCacheInvalidation).FireAndForget();
return(t1);
});
}
public ApplicationController(IApplicationService serviceAXA, IMapper mapper)
{
_serviceAXA = serviceAXA;
_mapper = mapper;
}
/// <summary>
/// Initializes a new instance of the FavoritesMovieTabViewModel class.
/// </summary>
/// <param name="applicationService">Application state</param>
/// <param name="movieService">Movie service</param>
/// <param name="userService">Movie history service</param>
public FavoritesMovieTabViewModel(IApplicationService applicationService, IMovieService movieService,
IUserService userService)
: base(applicationService, movieService, userService,
() => LocalizationProviderHelper.GetLocalizedValue <string>("FavoritesTitleTab"))
{
}
public ApiModule(ILogService server, IApplicationService application)
: base("/api")
{
Server = server ?? throw new ArgumentNullException(nameof(server));
Application = application ?? throw new ArgumentNullException(nameof(application));
Get["/"] = _ =>
{
var response = (Response)JsonConvert.SerializeObject(new { id = AssemblyInfo.Id, name = AssemblyInfo.Name, description = AssemblyInfo.Description, version = AssemblyInfo.Version, build = AssemblyInfo.Build, copyright = AssemblyInfo.Copyright, hash = AssemblyInfo.Hash });
response.ContentType = "application/json";
return(response);
};
Get["/apps"] = _ =>
{
var apps = Async.Execute(() => Application.GetApplications());
var response = (Response)JsonConvert.SerializeObject(apps);
response.ContentType = "application/json";
return(response);
};
Get["/apps/{app}/logs"] = _ =>
{
var logs = Async.Execute <List <Log> >(() => Server.GetLogEntries(_.app, DateTime.Now.Subtract(new TimeSpan(1, 0, 0)), DateTime.Now));
var response = (Response)JsonConvert.SerializeObject(logs);
response.ContentType = "application/json";
return(response);
};
Get["/apps/{app}/logs/{startDate}/{endDate}"] = _ =>
{
var start = DateTime.ParseExact(_.startDate, "yyyyMMddTHHmmss", null);
var end = DateTime.ParseExact(_.endDate, "yyyyMMddTHHmmss", null);
var logs = Async.Execute <List <Log> >(() => Server.GetLogEntries(_.app, start, end));
var response = (Response)JsonConvert.SerializeObject(logs);
response.ContentType = "application/json";
return(response);
};
Get["/apps/{app}/logs/{startDate}/{endDate}/{searchTerm}"] = _ =>
{
var start = DateTime.ParseExact(_.startDate, "yyyyMMddTHHmmss", null);
var end = DateTime.ParseExact(_.endDate, "yyyyMMddTHHmmss", null);
var logs = Async.Execute <List <Log> >(() => Server.SearchLogEntries(_.app, start, end, _.searchTerm));
var response = (Response)JsonConvert.SerializeObject(logs);
response.ContentType = "application/json";
return(response);
};
}
/// <summary>
/// Initializes a new instance of the SearchMovieTabViewModel class.
/// </summary>
/// <param name="applicationService">Application state</param>
/// <param name="showService">Show service</param>
/// <param name="userService">The user service</param>
public SearchShowTabViewModel(IApplicationService applicationService, IShowService showService,
IUserService userService)
: base(applicationService, showService, userService,
() => LocalizationProviderHelper.GetLocalizedValue <string>("SearchTitleTab"))
{
}
public UserViewModel(User user, IApplicationService applicationService = null)
: this(user.Username, applicationService)
{
User = user;
}
public SonarrService(IApplicationService applicationService, IFileService fileService, ILogger <SonarrService> logger)
{
this.applicationService = applicationService;
this.fileService = fileService;
this.logger = logger;
}
public RepositoriesWatchedViewModel(IApplicationService applicationService) : base(applicationService)
{
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
RepositoryCollection.SimpleCollectionLoad(
applicationService.Client.AuthenticatedUser.Repositories.GetWatching(), t as bool?));
}
/// <summary>
/// 初始化应用程序控制器
/// </summary>
/// <param name="service">应用程序服务</param>
public ApplicationController(IApplicationService service) : base(service)
{
}
public SectorsController(ApplicationDbContext context, ISectorService sectorService, ISecurityService securityService, IApplicationSectorService applicationSectorService, IApplicationService applicationService) : base(securityService)
{
_context = context;
_sectorService = sectorService;
_applicationSectorService = applicationSectorService;
_applicationService = applicationService;
}
public PersonalController(
IApplicationService _applicationService) : base()
{
this._applicationService = _applicationService;
}
public StudentAccountController(IApplicationService applicationService, IAuthenticationService authenticationService)
{
_applicationService = applicationService;
_authenticationService = authenticationService;
}
public ApplicationsController(IApplicationService applicationService, IMapper mapper)
{
_applicationService = applicationService;
_mapper = mapper;
}
public OrganizationViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
this.WhenAnyValue(x => x.Organization, x => x.Username,
(x, y) => x == null ? y : (string.IsNullOrEmpty(x.Name) ? x.Login : x.Name))
.Select(x => x ?? "Organization")
.Subscribe(x => Title = x);
GoToMembersCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <OrganizationMembersViewModel>();
vm.OrganizationName = Username;
ShowViewModel(vm);
});
GoToTeamsCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <TeamsViewModel>();
vm.OrganizationName = Username;
ShowViewModel(vm);
});
GoToFollowersCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <UserFollowersViewModel>();
vm.Username = Username;
ShowViewModel(vm);
});
GoToFollowingCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <UserFollowingsViewModel>();
vm.Username = Username;
ShowViewModel(vm);
});
GoToEventsCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <UserEventsViewModel>();
vm.Username = Username;
ShowViewModel(vm);
});
GoToGistsCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <UserGistsViewModel>();
vm.Username = Username;
ShowViewModel(vm);
});
GoToRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <OrganizationRepositoriesViewModel>();
vm.Name = Username;
ShowViewModel(vm);
});
LoadCommand = ReactiveCommand.CreateAsyncTask(async _ =>
Organization = await _applicationService.GitHubClient.Organization.Get(Username));
}
public ApplicationControllerTests()
{
defaultAppRegistryDataService = A.Fake <IAppRegistryDataService>();
defaultMapper = new ApplicationToPageModelMapper(defaultAppRegistryDataService);
defaultLogger = A.Fake <ILogger <ApplicationController> >();
defaultApplicationService = A.Fake <IApplicationService>();
defaultVersionedFiles = A.Fake <IVersionedFiles>();
defaultConfiguration = A.Fake <IConfiguration>();
defaultBaseUrlService = A.Fake <IBaseUrlService>();
neo4JService = A.Fake <INeo4JService>();
defaultApplicationModel = new ApplicationModel
{
AppRegistrationModel = new AppRegistrationModel
{
Path = ChildAppPath,
Regions = new List <RegionModel>
{
new RegionModel
{
IsHealthy = true,
PageRegion = PageRegion.Body,
RegionEndpoint = "http://childApp/bodyRegion",
},
},
},
};
defaultPostRequestViewModel = new ActionPostRequestModel
{
Path = ChildAppPath,
Data = ChildAppData,
FormCollection = new FormCollection(new Dictionary <string, StringValues>
{
{ "someKey", "someFormValue" },
}),
};
childAppActionGetRequestModel = defaultPostRequestViewModel;
A.CallTo(() => defaultApplicationService.GetApplicationAsync(childAppActionGetRequestModel)).Returns(defaultApplicationModel);
var fakeHttpContext = new DefaultHttpContext {
Request = { QueryString = QueryString.Create("test", "testvalue") }
};
defaultGetController = new ApplicationController(defaultMapper, defaultLogger, defaultApplicationService, defaultVersionedFiles, defaultConfiguration, defaultBaseUrlService, neo4JService)
{
ControllerContext = new ControllerContext
{
HttpContext = fakeHttpContext,
},
};
defaultPostController = new ApplicationController(defaultMapper, defaultLogger, defaultApplicationService, defaultVersionedFiles, defaultConfiguration, defaultBaseUrlService, neo4JService)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
Request = { Method = "POST" },
},
},
};
bearerTokenController = new ApplicationController(defaultMapper, defaultLogger, defaultApplicationService, defaultVersionedFiles, defaultConfiguration, defaultBaseUrlService, neo4JService)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext {
User = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim> {
new Claim("bearer", "test")
}, "mock"))
},
},
};
postBearerTokenController = new ApplicationController(defaultMapper, defaultLogger, defaultApplicationService, defaultVersionedFiles, defaultConfiguration, defaultBaseUrlService, neo4JService)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext {
User = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim> {
new Claim("bearer", "test")
}, "mock"))
},
},
};
}
public ApplicationController()
{
_svc = new ApplicationService(new eFormSqlServerContext());
}
protected CommandHttpApiBase(IApplicationService <TAggregate> service) => _service = service;
public ProductController(IProductService service, IMapper <Product, ProductInput> v, IFileManagerService fileManagerService, IUserService userService, IApplicationService applicationService, IRepo <ProductCategory> categoryService, IRepo <Product> productService)
: base(service, v)
{
this.service = service;
this.userService = userService;
this.fileManagerService = fileManagerService;
this.applicationService = applicationService;
this.categoryService = categoryService;
this.productService = productService;
}
