public IssuesViewModel(ISessionService sessionService)
: base(sessionService)
{
_sessionService = sessionService;
Filter = new IssuesFilterModel();
Title = "Issues";
GoToNewIssueCommand = ReactiveCommand.Create();
GoToNewIssueCommand.Subscribe(_ => {
var vm = this.CreateViewModel <IssueAddViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.SaveCommand.Subscribe(x => LoadCommand.ExecuteIfCan());
NavigateTo(vm);
});
this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(filter => {
InternalItems.Clear();
LoadCommand.ExecuteIfCan();
//CustomFilterEnabled = !(filter == _closedFilter || filter == _openFilter);
});
GoToFilterCommand = ReactiveCommand.Create();
GoToFilterCommand.Subscribe(_ => {
var vm = this.CreateViewModel <RepositoryIssuesFilterViewModel>();
vm.Init(RepositoryOwner, RepositoryName, Filter);
vm.SaveCommand.Subscribe(filter => {
Filter = filter;
FilterSelection = IssueFilterSelection.Custom;
});
NavigateTo(vm);
});
}
void SegmentValueChanged(object sender, EventArgs e)
{
var application = Mvx.Resolve <IApplicationService>();
// If there is searching going on. Finish it.
FinishSearch();
if (_viewSegment.SelectedSegment == 0)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateOpenFilter(), true);
}
else if (_viewSegment.SelectedSegment == 1)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateClosedFilter(), true);
}
else if (_viewSegment.SelectedSegment == 2)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateMineFilter(application.Account.Username), true);
}
else if (_viewSegment.SelectedSegment == 3)
{
var filter = new IssuesFilterViewController(ViewModel.Username, ViewModel.Repository, ViewModel.Issues);
var nav = new UINavigationController(filter);
PresentViewController(nav, true, null);
}
}
public override void ViewWillAppear(bool animated)
{
base.ViewWillAppear(animated);
if (ToolbarItems != null)
{
NavigationController.SetToolbarHidden(false, animated);
}
//Before we select which one, make sure we detach the event handler or silly things will happen
_viewSegment.ValueChanged -= SegmentValueChanged;
var application = Mvx.Resolve <IApplicationService>();
//Select which one is currently selected
if (ViewModel.Issues.Filter.Equals(IssuesFilterModel.CreateAllFilter()))
{
_viewSegment.SelectedSegment = 0;
}
else if (ViewModel.Issues.Filter.Equals(IssuesFilterModel.CreateOpenFilter()))
{
_viewSegment.SelectedSegment = 1;
}
else if (ViewModel.Issues.Filter.Equals(IssuesFilterModel.CreateMineFilter(application.Account.Username)))
{
_viewSegment.SelectedSegment = 2;
}
else
{
_viewSegment.SelectedSegment = 3;
}
_viewSegment.ValueChanged += SegmentValueChanged;
}
private IssuesFilterModel CreateFilterModel()
{
var model = new IssuesFilterModel();
model.AssignedTo = _assignedTo.Value;
model.ReportedBy = _reportedBy.Value;
model.Status = _statusChoice.Obj;
model.Priority = _priorityChoice.Obj;
model.Kind = _kindChoice.Obj;
model.OrderBy = _orderby.Obj;
return model;
}
public IssuesViewModel(IApplicationService applicationService)
{
_mineFilter = IssuesFilterModel.CreateMineFilter(applicationService.Account.Username);
_filterSelection = this.WhenAnyValue(x => x.Filter)
.Select(x =>
{
if (x == null || _openFilter.Equals(x))
{
return(IssueFilterSelection.Open);
}
if (_closedFilter.Equals(x))
{
return(IssueFilterSelection.Closed);
}
if (_mineFilter.Equals(x))
{
return(IssueFilterSelection.Mine);
}
return(IssueFilterSelection.Custom);
})
.ToProperty(this, Xamarin => Xamarin.FilterSelection);
GoToNewIssueCommand = ReactiveCommand.Create();
GoToNewIssueCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssueAddViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.CreatedIssue.IsNotNull().Subscribe(IssuesCollection.Add);
ShowViewModel(vm);
});
GoToCustomFilterCommand = ReactiveCommand.Create();
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var direction = Filter.Ascending ? "asc" : "desc";
var state = Filter.Open ? "open" : "closed";
var sort = Filter.SortType == BaseIssuesFilterModel.Sort.None ? null : Filter.SortType.ToString().ToLower();
var labels = string.IsNullOrEmpty(Filter.Labels) ? null : Filter.Labels;
var assignee = string.IsNullOrEmpty(Filter.Assignee) ? null : Filter.Assignee;
var creator = string.IsNullOrEmpty(Filter.Creator) ? null : Filter.Creator;
var mentioned = string.IsNullOrEmpty(Filter.Mentioned) ? null : Filter.Mentioned;
var milestone = Filter.Milestone == null ? null : Filter.Milestone.Value;
var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues.GetAll(
sort: sort, labels: labels, state: state, direction: direction,
assignee: assignee, creator: creator, mentioned: mentioned, milestone: milestone);
return(IssuesCollection.SimpleCollectionLoad(request, t as bool?));
});
}
private IssuesFilterModel CreateFilterModel()
{
var model = new IssuesFilterModel();
model.AssignedTo = _assignedTo.Value;
model.ReportedBy = _reportedBy.Value;
model.Status = _statusChoice.Obj;
model.Priority = _priorityChoice.Obj;
model.Kind = _kindChoice.Obj;
model.OrderBy = _orderby.Value;
model.FilterName = _filterName.Value;
return(model);
}
private IssuesFilterModel CreateFilterModel()
{
var model = new IssuesFilterModel();
model.Open = _open.Value;
model.Labels = _labels.Value;
model.SortType = _sort.Value;
model.Ascending = _asc.Value;
model.Mentioned = _mentioned.Value;
model.Creator = _creator.Value;
model.Assignee = _assignee.Value;
model.Milestone = _milestoneHolder;
return(model);
}
public IssuesFilterViewController(
string username, string repository,
IssuesFilterModel currentFilter, Action <IssuesFilterModel> searchAction)
{
_currentFilter = currentFilter.Clone();
_searchAction = searchAction;
OnActivation(disposable =>
{
_milestoneElement
.Clicked
.Select(_ =>
{
var vc = new IssueMilestonesViewController(username, repository);
vc.ViewModel.SelectedValue = _currentFilter.Milestone;
vc.ViewModel.WhenAnyValue(x => x.SelectedValue)
.Subscribe(x => _currentFilter.Milestone = x);
return(vc);
})
.Subscribe(x => NavigationController.PushViewController(x, true))
.AddTo(disposable);
_verisonElement
.Clicked
.Select(_ =>
{
var vc = new IssueVersionsViewController(username, repository);
vc.ViewModel.SelectedValue = _currentFilter.Version;
vc.ViewModel.WhenAnyValue(x => x.SelectedValue)
.Subscribe(x => _currentFilter.Version = x);
return(vc);
})
.Subscribe(x => NavigationController.PushViewController(x, true))
.AddTo(disposable);
_componentElement
.Clicked
.Select(_ =>
{
var vc = new IssueComponentsViewController(username, repository);
vc.ViewModel.SelectedValue = _currentFilter.Component;
vc.ViewModel.WhenAnyValue(x => x.SelectedValue)
.Subscribe(x => _currentFilter.Component = x);
return(vc);
})
.Subscribe(x => NavigationController.PushViewController(x, true))
.AddTo(disposable);
});
}
private IssuesFilterModel CreateFilterModel()
{
var model = new IssuesFilterModel();
model.AssignedTo = _assignedTo.Value;
model.ReportedBy = _reportedBy.Value;
model.Status = _statusChoice.Obj;
model.Priority = _priorityChoice.Obj;
model.Kind = _kindChoice.Obj;
model.OrderBy = _orderby.Value;
model.Milestone = _currentFilter.Milestone;
model.Version = _currentFilter.Version;
model.Component = _currentFilter.Component;
return(model);
}
public IssuesFilterViewController(IssuesFilterModel currentFilter)
{
_currentFilter = currentFilter.Clone();
Style = UITableViewStyle.Grouped;
Title = "Filter & Sort";
NavigationItem.RightBarButtonItem = new UIBarButtonItem(Theme.CurrentTheme.SaveButton, UIBarButtonItemStyle.Plain, (s, e) => {
if (string.IsNullOrEmpty(_filterName.Value))
{
MonoTouch.Utilities.ShowAlert("Filter Name", "You must name your filter!");
return;
}
CreatedFilterModel(CreateFilterModel());
NavigationController.PopViewController(true);
});
}
public IssuesViewModel(
string username, string repository,
IApplicationService applicationService = null,
IMessageService messageService = null)
{
Username = username;
Repository = repository;
applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>();
messageService = messageService ?? Locator.Current.GetService <IMessageService>();
var currentUser = applicationService.Account.Username;
GoToNewIssueCommand
.Select(_ => new IssueAddViewModel(username, repository))
.Subscribe(NavigateTo);
Title = "Issues";
this.WhenAnyValue(x => x.SelectedFilter)
.Subscribe(x =>
{
if (x == 0)
{
Filter = IssuesFilterModel.CreateOpenFilter();
}
else if (x == 1)
{
Filter = IssuesFilterModel.CreateMineFilter(currentUser);
}
else if (x == 2)
{
Filter = IssuesFilterModel.CreateAllFilter();
}
});
this.WhenAnyValue(x => x.Filter)
.Select(x => new IssueListViewModel(username, repository, x))
.Do(x => x.LoadMoreCommand.ExecuteNow())
.Subscribe(x => Issues = x);
this.WhenAnyValue(x => x.Issues)
.Select(x => x.IssueSelected)
.Switch()
.Select(x => new IssueViewModel(username, repository, x))
.Subscribe(NavigateTo);
}
public IssuesViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
_mineFilter = IssuesFilterModel.CreateMineFilter(applicationService.Account.Username);
Filter = _openFilter;
Title = "Issues";
_filterSelection = this.WhenAnyValue(x => x.Filter)
.Select(x =>
{
if (x == null || _openFilter.Equals(x))
{
return(IssueFilterSelection.Open);
}
if (_closedFilter.Equals(x))
{
return(IssueFilterSelection.Closed);
}
if (_mineFilter.Equals(x))
{
return(IssueFilterSelection.Mine);
}
return(IssueFilterSelection.Custom);
})
.ToProperty(this, x => x.FilterSelection);
GoToNewIssueCommand = ReactiveCommand.Create();
GoToNewIssueCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <IssueAddViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.CreatedIssue.IsNotNull().Subscribe(IssuesBacking.Add);
NavigateTo(vm);
});
this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ =>
{
IssuesBacking.Clear();
LoadCommand.ExecuteIfCan();
});
GoToCustomFilterCommand = ReactiveCommand.Create();
}
void SegmentValueChanged(object sender, EventArgs e)
{
var application = Mvx.Resolve <IApplicationService>();
if (_viewSegment.SelectedSegment == 0)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateAllFilter(), true);
}
else if (_viewSegment.SelectedSegment == 1)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateOpenFilter(), true);
}
else if (_viewSegment.SelectedSegment == 2)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateMineFilter(application.Account.Username), true);
}
else if (_viewSegment.SelectedSegment == 3)
{
ViewModel.GoToFiltersCommand.Execute(null);
}
}
void SegmentValueChanged(object sender, EventArgs e)
{
if (_viewSegment.SelectedSegment == 0)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateOpenFilter(), true);
}
else if (_viewSegment.SelectedSegment == 1)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateClosedFilter(), true);
}
else if (_viewSegment.SelectedSegment == 2)
{
ViewModel.Issues.ApplyFilter(IssuesFilterModel.CreateMineFilter(Application.Account.Username), true);
}
else if (_viewSegment.SelectedSegment == 3)
{
var filter = new IssuesFilterViewController(ViewModel.User, ViewModel.Slug, ViewModel.Issues);
var nav = new UINavigationController(filter);
PresentViewController(nav, true, null);
}
}
void SegmentValueChanged(object sender, EventArgs e)
{
// If there is searching going on. Finish it.
//FinishSearch();
if (_viewSegment.SelectedSegment == 0)
{
ViewModel.Filter = IssuesFilterModel.CreateOpenFilter();
}
else if (_viewSegment.SelectedSegment == 1)
{
ViewModel.Filter = IssuesFilterModel.CreateClosedFilter();
}
else if (_viewSegment.SelectedSegment == 2)
{
ViewModel.Filter = IssuesFilterModel.CreateMineFilter(_applicationService.Account.Username);
}
else if (_viewSegment.SelectedSegment == 3)
{
//ShowFilterController(new IssuesFilterViewController(ViewModel.RepositoryOwner, ViewModel.RepositoryName, ViewModel.Issues));
}
}
public IssueListViewModel(
string username, string repository,
IssuesFilterModel filter,
IApplicationService applicationService = null,
IMessageService messageService = null)
{
_filter = filter;
applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>();
messageService = messageService ?? Locator.Current.GetService <IMessageService>();
var currentUser = applicationService.Account.Username;
var issues = new ReactiveList <Issue>(resetChangeThreshold: 10);
Items = issues.CreateDerivedCollection(
x =>
{
var vm = new IssueItemViewModel(x);
vm.GoToCommand.Select(_ => x).Subscribe(_selectSubject);
return(vm);
},
x => x.Title.ContainsKeyword(SearchText),
signalReset: this.WhenAnyValue(x => x.SearchText));
int startPage = 0;
HasMoreIssues = true;
LoadMoreCommand = ReactiveCommand.CreateFromTask(async _ =>
{
var search = new LinkedList <Tuple <string, string> >();
if (_filter != null)
{
if (_filter.Status != null && !_filter.Status.IsDefault())
{
foreach (var a in PropertyToUrl("status", _filter.Status))
{
search.AddLast(a);
}
}
if (_filter.Kind != null && !_filter.Kind.IsDefault())
{
foreach (var a in PropertyToUrl("kind", _filter.Kind))
{
search.AddLast(a);
}
}
if (_filter.Priority != null && !_filter.Priority.IsDefault())
{
foreach (var a in PropertyToUrl("priority", _filter.Priority))
{
search.AddLast(a);
}
}
if (!string.IsNullOrEmpty(_filter.AssignedTo))
{
search.AddLast(Tuple.Create("responsible",
_filter.AssignedTo.Equals("unassigned") ? string.Empty : _filter.AssignedTo));
}
if (!string.IsNullOrEmpty(_filter.ReportedBy))
{
search.AddLast(Tuple.Create("reported_by", _filter.ReportedBy));
}
// For some reason, server side sorting by local_id returns ascending order.
// That's terrible.
if (_filter.OrderBy != IssuesFilterModel.Order.Local_Id)
{
search.AddLast(Tuple.Create("sort", _filter.OrderBy.ToString().ToLower()));
}
if (!string.IsNullOrEmpty(_filter.Milestone))
{
search.AddLast(Tuple.Create("milestone", _filter.Milestone));
}
if (!string.IsNullOrEmpty(_filter.Version))
{
search.AddLast(Tuple.Create("version", _filter.Version));
}
if (!string.IsNullOrEmpty(_filter.Component))
{
search.AddLast(Tuple.Create("component", _filter.Component));
}
}
var x = await applicationService.Client.Issues.GetAll(username, repository, startPage, search: search);
startPage += x.Issues.Count;
issues.AddRange(x.Issues);
HasMoreIssues = !(startPage == x.Count);
}, this.WhenAnyValue(x => x.HasMoreIssues));
LoadMoreCommand.IsExecuting.CombineLatest(issues.IsEmptyChanged, (x, y) => !x && y)
.ToProperty(this, x => x.IsEmpty, out _isEmpty);
_issueAddDisposable = messageService.Listen <IssueAddMessage>(x =>
{
if (DoesIssueBelong(x.Issue))
{
issues.Insert(0, x.Issue);
}
});
_issueDeleteDisposable = messageService.Listen <IssueDeleteMessage>(x =>
{
var deletedLocalId = x.Issue.LocalId;
var deletedIssue = issues.FirstOrDefault(y => deletedLocalId == y.LocalId);
if (deletedIssue != null)
{
issues.Remove(deletedIssue);
}
});
_issueUpdateDisposable = messageService.Listen <IssueUpdateMessage>(x =>
{
var localId = x.Issue.LocalId;
var listIssue = issues.FirstOrDefault(y => localId == y.LocalId);
if (listIssue != null)
{
issues[issues.IndexOf(listIssue)] = x.Issue;
}
});
}
public IssuesFilterViewController(IssuesFilterModel currentFilter)
{
_currentFilter = currentFilter.Clone();
Title = "Filter & Sort";
}
public FilterModel(CodeFramework.Core.Data.Filter filter)
{
Filter = filter;
IssueModel = filter.GetData <IssuesFilterModel>();
}
public IssuesFilterViewController(IssuesFilterModel currentFilter)
{
_currentFilter = currentFilter.Clone();
Title = "Filter & Sort";
}
public FilterModel(CodeFramework.Core.Data.Filter filter)
{
Filter = filter;
IssueModel = filter.GetData<IssuesFilterModel>();
}
public RepositoryIssuesFilterViewModel Init(string repositoryOwner, string repositoryName, IssuesFilterModel model)
{
RepositoryOwner = repositoryOwner;
RepositoryName = repositoryName;
Assignee = model.Assignee;
Creator = model.Creator;
Milestone = model.Milestone;
Labels = model.Labels;
Mentioned = model.Mentioned;
SortType = model.SortType;
State = model.IssueState;
Ascending = model.Ascending;
return(this);
}
public RepositoryIssuesFilterViewModel(ISessionService sessionService, IActionMenuFactory actionMenu)
{
Title = "Filter";
State = IssueState.Open;
SortType = CodeHub.Core.Filters.IssueSort.None;
SaveCommand = ReactiveCommand.CreateAsyncTask(_ => {
var model = new IssuesFilterModel(Assignee, Creator, Mentioned, Labels, Milestone, State, SortType, Ascending);
return(Task.FromResult(model));
});
SaveCommand.Subscribe(_ => Dismiss());
DismissCommand = ReactiveCommand.Create().WithSubscription(_ => Dismiss());
_assigneesCache = new Lazy <Task <IReadOnlyList <User> > >(() =>
sessionService.GitHubClient.Issue.Assignee.GetAllForRepository(RepositoryOwner, RepositoryName));
_milestonesCache = new Lazy <Task <IReadOnlyList <Milestone> > >(() =>
sessionService.GitHubClient.Issue.Milestone.GetAllForRepository(RepositoryOwner, RepositoryName));
_labelsCache = new Lazy <Task <IReadOnlyList <Label> > >(() =>
sessionService.GitHubClient.Issue.Labels.GetAllForRepository(RepositoryOwner, RepositoryName));
this.WhenAnyValue(x => x.Milestone)
.Select(x => x?.Title)
.ToProperty(this, x => x.MilestoneString, out _milestoneString);
this.WhenAnyValue(x => x.Assignee)
.Select(x => x?.Login)
.ToProperty(this, x => x.AssigneeString, out _assigneeString);
this.WhenAnyValue(x => x.Labels)
.Select(x => x ?? new List <Label>())
.Select(x => string.Join(", ", x.Select(y => y.Name)))
.ToProperty(this, x => x.LabelsString, out _labelsString);
SelectAssigneeCommand = ReactiveCommand.Create();
SelectMilestoneCommand = ReactiveCommand.Create();
SelectLabelsCommand = ReactiveCommand.Create();
SelectStateCommand = ReactiveCommand.CreateAsyncTask(async sender => {
var options = Enum.GetValues(typeof(IssueState)).Cast <IssueState>().ToList();
var picker = actionMenu.CreatePicker();
foreach (var option in options)
{
picker.Options.Add(option.Humanize());
}
picker.SelectedOption = options.IndexOf(State);
var ret = await picker.Show(sender);
State = options[ret];
});
SelectSortCommand = ReactiveCommand.CreateAsyncTask(async sender => {
var options = Enum.GetValues(typeof(CodeHub.Core.Filters.IssueSort)).Cast <CodeHub.Core.Filters.IssueSort>().ToList();
var picker = actionMenu.CreatePicker();
foreach (var option in options)
{
picker.Options.Add(option.Humanize());
}
picker.SelectedOption = options.IndexOf(SortType);
var ret = await picker.Show(sender);
SortType = options[ret];
});
}
public IssuesView(IApplicationService applicationService)
{
_applicationService = applicationService;
_mineFilter = IssuesFilterModel.CreateMineFilter(_applicationService.Account.Username);
}
