public virtual Page AddTab <T>(string title, string icon, object data = null) where T : BaseViewModel
{
Page page = ViewModelResolver.ResolveViewModel <T>(data);
page.GetModel().CurrentNavigationServiceName = NavigationServiceName;
_tabs.Add(page);
Page container = CreateContainerPageSafe(page);
container.Title = title;
if (!string.IsNullOrWhiteSpace(icon))
{
container.IconImageSource = icon;
}
FirstTabbedPage.Children.Add(container);
return(container);
}
protected override void OnInitialize()
{
base.OnInitialize();
EventAggregator.Subscribe(this);
_personsListViewModel = ViewModelResolver.Resolve <PersonsListViewModel>();
_filterOptions = new Dictionary <FilterOptions, string>();
_filterOptions.Add(ViewModels.FilterOptions.ALL, "Všechny záznamy");
_filterOptions.Add(ViewModels.FilterOptions.UPCOMMING, "Pouze nadcházející narozeniny");
_filterOptions.Add(ViewModels.FilterOptions.LAST, "Pouze uplynulé narozeniny");
SelectedFilter = ViewModels.FilterOptions.UPCOMMING;
LoadRecords();
}
private async Task LogOut()
{
if (await DisplayAlert(TranslateExtension.GetValue("alert_title_log_out"), TranslateExtension.GetValue("alert_message_log_out_confirm"), TranslateExtension.GetValue("alert_message_yes"), TranslateExtension.GetValue("alert_message_no")))
{
Settings.RemoveCurrentUserName();
Settings.RemoveCurrentPassword();
Settings.RemoveCurrentUser();
Settings.RemoveLoggedIn();
Application.Current.MainPage = new NavigationContainer(ViewModelResolver.ResolveViewModel <ViewModels.Login.LoginViewModel>())
{
BarBackgroundColor = Color.DodgerBlue,
BarTextColor = Color.White
};
}
}
private void LoadPlaylists()
{
var result = _service.GetSoundCloudPlaylists();
if (!result.IsSuccess)
{
return;
}
foreach (var model in result.Data)
{
var viewModel = ViewModelResolver.Resolve <PlaylistViewModel>(model);
viewModel.IsDeletable = false;
viewModel.LoadNextPage.Execute(null);
SoundCloudPlaylists.Add(viewModel);
}
}
public ExecutedTimelineStepViewModel(ExecutedActionSettingsBase settings, ISessionStepActionExecutor executor, ViewModelResolver resolver)
{
executor.ThrowIfNull(nameof(executor));
executor.ThrowIf(e => e.CanExecute(settings) == false,
nameof(executor),
$"Given executor '{executor.GetType().Name}' can not execute settings of type '{settings?.GetType().Name ?? String.Empty}'.");
_executor = executor;
_executor.Completed += (_, args) => Dispatcher.CurrentDispatcher.Invoke(() => Completed?.Invoke(this, args));
_settings = settings;
_resolver = resolver;
if (settings.Content != null && resolver.CanCreate(settings.Content))
{
Content = (ITimelineStepViewModel)resolver.Create(settings.Content);
isContent = true;
}
}
public EyeTrackerCalibrationTimelineStepViewModel(EyeTrackerCalibrationActionSettings settings, IAdaptersManager adapters, ViewModelResolver resolver)
: base(settings)
{
_settings = settings;
_resolver = resolver;
var eyeTracker = adapters.FirstOrDefault(a => a.Code.DeviceType == DeviceType.Physiological.EYETRACKER);
if (eyeTracker != null)
{
_calibrate = eyeTracker?.Calibration;
var adapter = (AdapterViewModel)resolver.Create(eyeTracker);
ConnectCommand = new WrappedCommand(adapter.ExecuteActionCommand, DeviceAction.Connect);
}
Cursor = Cursors.Arrow;
}
private void AddPlaylistImpl()
{
//// TODO Add Playlist-Name Dialog
var playlist = new LocalPlaylistModel();
playlist.Name = "PlaylistName";
var result = _service.Save(playlist);
if (!result.IsSuccess)
{
return;
}
var model = ViewModelResolver.Resolve <PlaylistViewModel>(result.Data);
LocalPlaylists.Add(model);
CurrentPlaylist = model;
}
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
Forms.Init(this, savedInstanceState);
LogOutputService.Initialize();
CrossFirebase.Initialize(this, savedInstanceState, CreateCrossFirebaseSettings());
FirebaseCloudMessagingImplementation.SmallIconRef = Resource.Drawable.ic_push_small;
var compositionRoot = new CompositionRoot();
ViewModelResolver.Initialize(compositionRoot);
Schedulers.Initialize(compositionRoot.ResolveSchedulerService());
HandleIntent(Intent);
CreateNotificationChannelIfNeeded();
LoadApplication(new App());
}
public RibbonFactoryController(
IViewContextProvider viewContextProvider,
VstoContribContext vstoContribContext)
{
this.vstoContribContext = vstoContribContext;
var ribbonTypes = GetTRibbonTypesInAssemblies(vstoContribContext.Assemblies).ToList();
customTaskPaneRegister = new CustomTaskPaneRegister(vstoContribContext.AddinBase);
ribbonViewModelResolver = new ViewModelResolver(
ribbonTypes, customTaskPaneRegister, viewContextProvider,
vstoContribContext);
var ribbonXmlRewriter = new RibbonXmlRewriter(vstoContribContext, ribbonViewModelResolver);
var loadExpression = ((Expression <Action <RibbonFactory> >)(r => r.Ribbon_Load(null)));
string loadMethodName = loadExpression.GetMethodName();
foreach (Type viewModelType in ribbonTypes)
{
ribbonXmlRewriter.LocateAndRegisterViewXml(viewModelType, loadMethodName, vstoContribContext.FallbackRibbonType);
}
}
private void CreateMenuPage <T>(string masterListName) where T : BaseViewModel
{
var masterpage = ViewModelResolver.ResolveViewModel <T>();
var pagelist = masterpage.FindByName(masterListName);
if (pagelist is ListView list)
{
list.ItemSelected += (sender, args) =>
{
if (Pages.ContainsKey(((MenuItems)args.SelectedItem).Title))
{
Detail = Pages[((MenuItems)args.SelectedItem).Title];
}
IsPresented = false;
}
}
;
else
{
throw new Exception("Master list navigation name not the same as xaml");
}
Master = masterpage;
}
public virtual void AddPage <T>(object data = null) where T : BaseViewModel
{
var page = ViewModelResolver.ResolveViewModel <T>(data);
AddPagesToDictionary(page);
}
public void CreateMenuPage <T>() where T : BaseViewModel
{
var masterpage = ViewModelResolver.ResolveViewModel <T>();
Master = masterpage;
}
protected ViewControllerBase(string name, NSBundle p)
: base(name, p)
{
ViewModel = ViewModelResolver?.Resolve <TViewModel>();
}
public MainPage()
{
InitializeComponent();
Detail = new NavigationContainer(ViewModelResolver.ResolveViewModel <PostsAndReviewsViewModel>());
}
public async Task NavigateFromMenu(int id)
{
if (lastPage == id)
{
IsPresented = false;
return;
}
try
{
Page newPage = null;
switch (id)
{
case (int)MenuItemType.Interventions:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Interventions.InterventionsViewModel>();
break;
case (int)MenuItemType.InterventionsNotAssigned:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.InterventionsNotAssigned.InterventionsNotAssignedViewModel>();
break;
case (int)MenuItemType.Quote:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Quotes.QuotesViewModel>();
break;
case (int)MenuItemType.Invoice:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Invoices.InvoicesViewModel>();
break;
case (int)MenuItemType.Issue:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Issues.IssuesViewModel>();
break;
case (int)MenuItemType.Messages:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Messages.MessagesViewModel>();
break;
case (int)MenuItemType.Customers:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Customers.CustomersViewModel>();
break;
case (int)MenuItemType.Addresses:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Addresses.AddressesViewModel>();
break;
case (int)MenuItemType.Equipment:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Equipments.EquipmentsViewModel>();
break;
case (int)MenuItemType.Products:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Products.ProductsViewModel>();
break;
case (int)MenuItemType.Tracking:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.Tracking.TrackingViewModel>();
break;
case (int)MenuItemType.Settings:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.SystemSettings.SettingsViewModel>();
break;
case (int)MenuItemType.About:
newPage = ViewModelResolver.ResolveViewModel <ViewModels.About.AboutViewModel>();
break;
case (int)MenuItemType.LogOut:
await LogOut();
break;
}
if (newPage != null)
{
if (Detail is NavigationPage)
{
((NavigationPage)Detail).NotifyAllChildrenPopped();
}
if (Detail is INavigationService)
{
((INavigationService)Detail).NotifyChildrenPageWasPopped();
}
Detail = new NavigationContainer(newPage)
{
BarBackgroundColor = Color.FromHex("#2196F3"),
BarTextColor = Color.White
};
lastPage = id;
if (Device.RuntimePlatform == Device.Android)
{
await Task.Delay(100);
}
IsPresented = false;
}
}
catch (Exception ex)
{
await DisplayAlert(TranslateExtension.GetValue("alert_title_error"), ex.GetBaseException().Message, TranslateExtension.GetValue("alert_message_ok"));
}
}
protected ViewControllerBase(IntPtr handle)
: base(handle)
{
ViewModel = ViewModelResolver?.Resolve <TViewModel>();
}
private void SetStartPage()
{
var mainPage = ViewModelResolver.ResolvePageModel <LoginViewModel>();
MainPage = new NavigationPageContainer(mainPage);
}
public async Task NavigateFromMenu(HomeMenuItemType type)
{
Debug.WriteLine("ITEM SELECTED");
Page selectedPage = null;
switch (type)
{
case HomeMenuItemType.Home:
selectedPage = ViewModelResolver.ResolveViewModel <HomeViewModel>();
break;
case HomeMenuItemType.CheckIn:
selectedPage = string.IsNullOrWhiteSpace(Host.Url) ? selectedPage = ViewModelResolver.ResolveViewModel <CheckInNonFullUserViewModel>() : selectedPage = ViewModelResolver.ResolveViewModel <CheckInViewModel>();
break;
case HomeMenuItemType.Bookings:
selectedPage = ViewModelResolver.ResolveViewModel <BookingsViewModel>();
break;
case HomeMenuItemType.CheckOut:
selectedPage = ViewModelResolver.ResolveViewModel <CheckOutViewModel>();
break;
case HomeMenuItemType.AddBooking:
selectedPage = ViewModelResolver.ResolveViewModel <BookingCalendarViewModel>();
break;
case HomeMenuItemType.GuestBook:
selectedPage = ViewModelResolver.ResolveViewModel <GuestBookViewModel>();
break;
case HomeMenuItemType.Stats:
selectedPage = ViewModelResolver.ResolveViewModel <StatsViewModel>();
break;
case HomeMenuItemType.Settings:
selectedPage = ViewModelResolver.ResolveViewModel <SettingsViewModel>();
break;
case HomeMenuItemType.PostsAndReviews:
selectedPage = ViewModelResolver.ResolveViewModel <PostsAndReviewsViewModel>();
break;
case HomeMenuItemType.LogOut:
await LogOut();
break;
default:
selectedPage = ViewModelResolver.ResolveViewModel <PostsAndReviewsViewModel>();
break;
}
if (selectedPage == null || type == HomeMenuItemType.LogOut)
{
return;
}
if (Detail is NavigationPage detailPage)
{
detailPage.NotifyAllChildrenPopped();
}
// Default [Works for iOS]
Detail = new NavigationContainer(selectedPage)
{
BarBackgroundColor = (Color)Application.Current.Resources["colorPrimary"],
BarTextColor = Color.White
};
if (Device.RuntimePlatform == Device.Android)
{
await Task.Delay(100);
}
// Work around for nav drawer hide lag [Android]
//var root = Detail.Navigation.NavigationStack[0];
//Detail.Navigation.InsertPageBefore(page, root);
//await Detail.Navigation.PopToRootAsync(false);
IsPresented = false;
}
public void ResolveViewModelWithoutTypeUnitTest(object data, BaseViewModel baseViewModel)
{
Page page = ViewModelResolver.ResolveViewModel(data, baseViewModel);
Assert.NotNull(page);
}
public TabBarViewControllerBase(IntPtr handle)
: base(handle)
{
ViewModel = ViewModelResolver?.Resolve <TViewModel>();
}
protected virtual T Resolve <T>()
where T : class
{
return(ViewModelResolver?.Resolve <T>());
}
public ControlServicesIconsViewModel(IEnumerable <IControlService> services, IModulesService modules, ViewModelResolver resolver)
{
_resolver = resolver;
AddServices(services);
modules.Register <IControlService>(this, AddServices);
}
public TimelinePlaybackViewModel(SessionRecordingViewModel recording, ViewModelResolver resolver, Dispatcher dispatcher)
{
_recording = recording;
_resolver = resolver;
_dispatcher = dispatcher;
}
public WelcomeTimelineStepViewModel(WelcomeActionSettings settings, IAdaptersManager adapters, ViewModelResolver resolver)
: base(settings, resolver)
{
_settings = settings;
Description = _settings.Description?.Lines != null && _settings.Description.Lines.Any()
? String.Join(Environment.NewLine, _settings.Description.Lines)
: String.Empty;
string label = settings.StartButtonLabel?.Trim();
StartButtonLabel = String.IsNullOrWhiteSpace(label) ? null : label;
}
public RibbonXmlRewriter(VstoContribContext vstoContribContext, ViewModelResolver ribbonViewModelResolver)
{
controlCallbackLookup = new ControlCallbackLookup();
this.vstoContribContext = vstoContribContext;
this.ribbonViewModelResolver = ribbonViewModelResolver;
}
async Task PushPageModel(ViewModelFoundation.BaseViewModel pageModel, object data, bool modal = false, bool animate = true)
{
var page = ViewModelResolver.ResolveViewModel(data, pageModel);
await PushPageModelWithPage(page, pageModel, data, modal, animate);
}
public void ResolveViewModelUnitTest(Type type, object data, BaseViewModel baseViewModel)
{
Page page = ViewModelResolver.ResolveViewModel(type, data, baseViewModel);
Assert.NotNull(page);
}
public void ResolveViewModelWithoutViewModelUnitTest(Type type, object data)
{
Page page = ViewModelResolver.ResolveViewModel(type, data);
Assert.NotNull(page);
}
public FragmentBase(bool hasNonTrackableBindings = false)
: base(hasNonTrackableBindings)
{
ViewModel = ViewModelResolver?.Resolve <TViewModel>();
}
