public override async void ViewAppearing()
{
base.ViewAppearing();
_token = _messenger.Subscribe <SelectedOpChangedMessage>(async msg =>
{
await LoadOperationCommand.ExecuteAsync();
if (_preferences.Get(UserSettingsKeys.ShowAgentsFromAnyTeam, false) is false)
{
// Force refresh agents pins to only show current OP agents
Agents.Clear();
await RaisePropertyChanged(() => Agents);
}
await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty);
});
_tokenReload ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await LoadOperationCommand.ExecuteAsync());
_tokenLiveLocation ??= _messenger.Subscribe <TeamAgentLocationUpdatedMessage>(async msg => await RefreshTeamAgentPositionCommand.ExecuteAsync(msg));
_tokenLinkUpdated ??= _messenger.Subscribe <LinkDataChangedMessage>(UpdateLink);
_tokenMarkerUpdated ??= _messenger.Subscribe <MarkerDataChangedMessage>(UpdateMarker);
_tokenRefreshAllAgentsLocations ??= _messenger.Subscribe <RefreshAllAgentsLocationsMessage>(async msg => await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty));
await LoadOperationCommand.ExecuteAsync();
await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty);
}
public void Subscribe()
{
Debug.WriteLine("Starting subscribing tracking messages");
if (_tokenStart != null)
{
Debug.WriteLine("You are trying to subscribe, already subscribed");
return;
}
_tokenStart = _messenger.Subscribe <StartTrackingMessage>(m =>
{
Debug.WriteLine("Started tracking");
StartTime = m.TimeStamp;
Duration = m.Duration;
Token = m.Token;
IsTracking = true;
});
_tokenStop = _messenger.Subscribe <StopTrackingMessage>(m =>
{
Debug.WriteLine("Stopped tracking");
IsTracking = false;
});
_tokenLocation = _messenger.Subscribe <LocationMessage>(m =>
{
Debug.WriteLine($"Location(WP) tracking {m.Lat} {m.Lng}");
if (CheckIfNotExpired() && !m.IsError)
{
Debug.WriteLine("Sending position");
_sendPositionService.SendPosition(Token, new Position(m.Lat, m.Lng), m.Address, m.Accuracy);
}
});
}
public void Subscribe()
{
if (_tokenStart != null)
{
return;
}
_tokenStart = _messenger.Subscribe <StartTrackingMessage>(m =>
{
_startTime = m.TimeStamp;
_duration = m.Duration;
_token = m.Token;
IsTracking = true;
});
_tokenStop = _messenger.Subscribe <StopTrackingMessage>(m =>
{
IsTracking = false;
});
_tokenLocation = _messenger.Subscribe <LocationMessage>(m =>
{
if (CheckIfNotExpired() && !m.IsError)
{
_sendPositionService.SendPosition(_token, new Position(m.Lat, m.Lng), m.Address, m.Accuracy);
}
});
}
public TimerService(IMvxMessenger messageService)
{
_messageService = messageService;
_stopTimerMessageToken = messageService.Subscribe <StopTimerServiceMessage <T> >(StopTimer);
_startTimerMessageToken = messageService.Subscribe <StartTimerServiceMessage <T> >(StartTimer);
}
public InventoryViewModel(IDataService dataService,
IMvxMessenger messenger,
IBackupService oneDriveService)
: base(dataService, messenger, oneDriveService)
{
_dataService = dataService;
_messenger = messenger;
// Only register message once (prevents multiple calls)
if (_messenger.CountSubscriptionsFor <ItemQuantityUpMessage>() == 0)
{
_upToken = _messenger.Subscribe <ItemQuantityUpMessage>(message =>
{
ItemQuantityUpCommand.Execute(message.Item);
});
}
if (_messenger.CountSubscriptionsFor <ItemQuantityDownMessage>() == 0)
{
_downToken = _messenger.Subscribe <ItemQuantityDownMessage>(message =>
{
ItemQuantityDownCommand.Execute(message.Item);
});
}
_refreshToken = _messenger.Subscribe <CollectionChangedMessage>(Refresh);
Items = _dataService.AllItems();
}
public LiveCardPresenter()
{
_messenger = Mvx.Resolve<IMvxMessenger>();
_messenger.Subscribe<ServiceStartedMessage>(onServiceStart);
_messenger.Subscribe<ServiceDestroyedMessage>(onServiceDestroyed);
_messenger.Subscribe<GlassShowViewModelMessage>(onShowViewModel);
}
public TestViewModel(IMvxMessenger messenger)
{
_messenger = messenger;
_receivedTokenDisposable = _messenger.Subscribe<TokenChangedMessage>(msg =>
{
if(msg == null) return;
var token = msg.NewToken;
if(token == null) return;
Issuer = token.Issuer;
Audience = token.Audience;
IdentityProvider = token.IdentityProvider;
ExpiresOn = token.ExpiresOn;
RawToken = token.RawToken;
});
_loggedInTokenDisposable =
_messenger.Subscribe<LoggedInMessage>(async msg =>
{
//Validate token here, i.e. call your Web Service
await Task.Delay(2000);
//Calling this immediately, can result in nothing happening
//MvxAndroidTask might still be "showing".
_messenger.Publish(new CloseSelfMessage(this) {Close = true});
});
}
public HomeViewModel(IDeviceService deviceService, IShareService shareService, ISettings settings,
ILocationService locationService, IMvxMessenger messenger, ISendPositionService sendPositionService, IPopupService popupService, ITimerService timer)
{
_deviceService = deviceService;
_shareService = shareService;
_settings = settings;
_locationService = locationService;
_messenger = messenger;
_sendPositionService = sendPositionService;
_popupService = popupService;
_timer = timer;
Title = "TrackMe";
PossibleTimes = new PossibleTimeProvider().GetPossibleTimes().ToObservable();
SelectedTime = new PossibleTime(240);
_deviceService.LocationStatusChanged += (sender, args) =>
{
GpsStatus = args.Status;
if (!_locationService.IsWatching && args.Status == LocationStatus.Started)
{
_locationService.StartWatching();
}
};
GpsStatus = _deviceService.LocationStatus;
_locationMessageToken = _messenger.Subscribe <LocationMessage>(GotLocation);
_requestStartTrackingToken = _messenger.Subscribe <RequestStartTrackingMessage>(OnRequestStartTracking);
_messenger.Subscribe <CloseAppMessage>(message =>
{
_messenger.Publish(new StopTrackingMessage(this, true, Token, PrivateToken, _timeEnd));
});
TrackConnectionStatus();
}
public override void ViewAppeared()
{
base.ViewAppeared();
_token ??= _messenger.Subscribe <NewOpAvailableMessage>(msg => RefreshAvailableOpsCommand.Execute());
_tokenDebug ??= _messenger.SubscribeOnMainThread <MessageFrom <SettingsViewModel> >(msg =>
{
if (MenuItems.Any(x => x.ViewModelType == typeof(LogsViewModel)))
{
return;
}
MenuItems.Add(new MenuItem()
{
Icon = "mdi-record", Title = "Live FCM Logs", ViewModelType = typeof(LogsViewModel)
});
RaisePropertyChanged(() => MenuItems);
_preferences.Set(UserSettingsKeys.DevModeActivated, true);
});
_tokenOps ??= _messenger.Subscribe <MessageFrom <OperationsListViewModel> >(msg => RefreshAvailableOpsCommand.Execute());
RefreshAvailableOpsCommand.Execute();
}
public SplitDetailViewModel(IActivityService activityService, ITwilioService twilioService, IDialogService dialogService, IMvxPhoneCallTask phoneCallTask, IMvxMessenger messenger, IProspectService prospectService, IMvxNavigationService navigationService)
{
Messenger = messenger;
_prospectService = prospectService;
_navigationService = navigationService;
_phoneCallTask = phoneCallTask;
_dialogService = dialogService;
_twilioService = twilioService;
_activityService = activityService;
Phones = new ObservableCollection <KeyValuePair <string, string> >();
Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <ProspectChangedMessage>(message => Prepare(new KeyValuePair <Prospect, User>(message.UpdatedProspect, User)), MvxReference.Strong);
Messenger.Subscribe <UserLogoutMessage>(message => UserLogout(), MvxReference.Strong);
Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong);
Messenger.Subscribe <ProspectChangedMessage>(message =>
{
RaisePropertyChanged(() => EmailEntered);
RaisePropertyChanged(() => StreetAddressEntered);
RaisePropertyChanged(() => MobilePhoneEntered);
RaisePropertyChanged(() => HomePhoneEntered);
RaisePropertyChanged(() => WorkPhoneEntered);
RaisePropertyChanged(() => AllowCalling);
RaisePropertyChanged(() => AllowEmailing);
RaisePropertyChanged(() => AllowTexting);
},
MvxReference.Strong);
}
public MainViewModel(IOctoService octoService, IWebsocketService websocketService, IMvxNavigationService navigationService, IMvxMessenger messenger)
{
_token_octo_message = messenger.Subscribe <OctoMessage>(OnOctoMessage);
_token_currrent_message = messenger.Subscribe <CurrentMessage>(OnCurrentMessage);
_octoService = octoService;
_websocketService = websocketService;
_navigationService = navigationService;
}
public override async void ViewAppearing()
{
base.ViewAppearing();
_token ??= _messenger.Subscribe <SelectedOpChangedMessage>(async msg => await RefreshCommand.ExecuteAsync());
_tokenFromMap ??= _messenger.Subscribe <MessageFor <AssignmentsListViewModel> >(async msg => await RefreshCommand.ExecuteAsync());
_tokenRefresh ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await RefreshCommand.ExecuteAsync());
await RefreshCommand.ExecuteAsync();
}
public BrowseImagesViewModel(IMvxMessenger messenger,
IBooruPostsProviderFactory postsProviderFactory)
{
_messenger = messenger;
_settingsUpdatedToken = _messenger.Subscribe <SettingsUpdatedMessage>(SettingsUpdated);
_resetToken = _messenger.Subscribe <ResetBooruImagesMessage>(DropImages);
_booruPostsProvider = postsProviderFactory.Create();
BindingOperations.EnableCollectionSynchronization(BooruImages, _booruImagesLockObj);
}
public override async void ViewAppearing()
{
base.ViewAppearing();
_token ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await RefreshCommand.ExecuteAsync());
_tokenRefreshLink ??= _messenger.Subscribe <LinkDataChangedMessage>(msg => RefreshLinkCommand.Execute(msg.LinkData));
_tokenRefreshMarker ??= _messenger.Subscribe <MarkerDataChangedMessage>(msg => RefreshMarkerCommand.Execute(msg.MarkerData));
await RefreshCommand.ExecuteAsync();
}
public TrafficCardViewModel(IMvxMessenger messenger, ITrafficCardResponseService trafficCardResponseService, IMvxNavigationService navigationService, IUserService userService)
{
Messenger = messenger;
_trafficCardResponseService = trafficCardResponseService;
_navigationService = navigationService;
_userService = userService;
Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <TrafficCardResponseChangedMessage>(message => ResponseUpdated(message.ChangedResponse), MvxReference.Strong);
}
public LandingViewModel(IMvxNavigationService navigationService, IDialogService dialogService, IAuthenticator authService, IMvxMessenger messenger, IUserService userService)
{
_navigationService = navigationService;
_dialogService = dialogService;
_authService = authService;
_userService = userService;
Messenger = messenger;
Messenger.Subscribe <SMSReceivedMessage>(message => Process(message.SMSActivityReceived), MvxReference.Strong);
Messenger.Subscribe <ExtendReloadTime>(message => Extend(message.ExtendMinutes), MvxReference.Strong);
}
public EnterResultsViewModel(ITeamsService service, IMvxMessenger messenger, IGAService gaService)
{
_teamsService = service;
_messenger = messenger;
_gaService = gaService;
_teamsChangedToken = messenger.Subscribe<TeamsChangedMessage> (OnTeamsChanged);
_resultsChangedToken = messenger.Subscribe<ResultsChangedMessage> (OnResultsChanged);
DataLoader = new DataLoader ();
}
public EnterResultsViewModel(ITeamsService service, IMvxMessenger messenger, IGAService gaService)
{
_teamsService = service;
_messenger = messenger;
_gaService = gaService;
_teamsChangedToken = messenger.Subscribe <TeamsChangedMessage> (OnTeamsChanged);
_resultsChangedToken = messenger.Subscribe <ResultsChangedMessage> (OnResultsChanged);
DataLoader = new DataLoader();
}
public DailyToDoViewModel(IMvxMessenger messenger, IAuthenticator authService, IUserDefinedCodeService userDefinedCodeService, IActivityService activityService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService)
{
Messenger = messenger;
_authService = authService;
_activityService = activityService;
_collectionFactory = collectionFactory;
_navigationService = navigationService;
_userDefinedCodeService = userDefinedCodeService;
dismissedMessengerToken = Messenger.Subscribe <TaskDismissedMessage>(message => RemoveTask(message.Activity));
completedMessengerToken = Messenger.Subscribe <TaskCompletedMessage>(message => RemoveTask(message.Activity));
}
public SMSInboxViewModel(IUserService userService, IMvxMessenger messenger, IAuthenticator authService, IProspectService prospectService, IActivityService activityService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService)
{
Messenger = messenger;
_authService = authService;
_activityService = activityService;
_collectionFactory = collectionFactory;
_navigationService = navigationService;
_prospectService = prospectService;
_userService = userService;
messengerToken = Messenger.Subscribe <SMSReceivedMessage>(message => AddMessage(message));
messengerSentToken = Messenger.Subscribe <SMSSentMessage>(message => AddSentMessage(message));
}
public DirectMethodCommunicationViewModel(IDeviceService deviceService,
ITranslationsService translationsService,
IDeviceSettingDataService deviceSettingDataService,
IMvxMessenger messageService)
{
_deviceService = deviceService;
_translationsService = translationsService;
_deviceSettingDataService = deviceSettingDataService;
_directMethodStatusChangedMessageToken = messageService.Subscribe <DirectMethodStatusUpdatedMessage>(HandleDirectMethodStatusChanged);
_deviceConnectionStatusChangedMessageToken = messageService.Subscribe <DeviceConnectionChangedMessage>(HandleDeviceConnectionStatus);
}
public CobuyerViewModel(IMvxMessenger messenger, ICobuyerService cobuyerService, IMvxNavigationService navigationService, IUserService userService)
{
Messenger = messenger;
_cobuyerService = cobuyerService;
_navigationService = navigationService;
_userService = userService;
Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <CobuyerChangedMessage>(message => CobuyerUpdated(message.UpdatedCobuyer), MvxReference.Strong);
Messenger.Subscribe <CobuyerAddedMessage>(message => CobuyerAdded(message.AddedCobuyer), MvxReference.Strong);
}
public ActivitiesViewModel(IMvxMessenger messenger, IActivityService activitiesService, IMvxNavigationService navigationService, IUserService userService)
{
Messenger = messenger;
_activitiesService = activitiesService;
_navigationService = navigationService;
_userService = userService;
Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong);
Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong);
Messenger.Subscribe <ProspectChangedMessage>(message => ProspectChanged(message.UpdatedProspect), MvxReference.Strong);
}
static void Initialize(IMvxMessenger messenger)
{
Gai.SharedInstance.DispatchInterval = 60;
Gai.SharedInstance.TrackUncaughtExceptions = true;
Gai.SharedInstance.GetTracker(TrackingId);
screenNameToken = messenger.Subscribe <GaScreenNameMessage>((m) => SetScreenName(m));
int count = messenger.CountSubscriptionsFor <GaScreenNameMessage>();
eventToken = messenger.Subscribe <GaEventMessage>(CreateEvent);
exceptionToken = messenger.Subscribe <GaExceptionMessage>(CreateException);
performanceToken = messenger.Subscribe <GaPerformanceTimingMessage>(CreatePerformanceMetric);
publishToken = messenger.Subscribe <GaPublishMessage>(PublishAll);
}
/// <summary>
/// Initializes a new instance of the <see cref="RouteViewModel" /> class.
/// </summary>
/// <param name="logFactory">The log provider.</param>
/// <param name="navigationService">The navigation service.</param>
public RouteViewModel(ILoggerFactory logFactory, IMvxNavigationService navigationService, IRideService rideService, ILocationService locationService, IMvxMessenger messenger)
: base(logFactory, navigationService)
{
this._rideService = rideService;
this._locationService = locationService;
this._messenger = messenger;
this._token = messenger.Subscribe <MvxLocationMessage>(this.OnLocationUpdated);
this._token = messenger.Subscribe <MvxTabIndexMessenger>(this.OnTabIndexUpdated);
stopwatch = new Stopwatch();
stopwatch.Reset();
Loader = new TaskLoaderNotifier <SessionMap>();
}
public SplitMasterViewModel(IUserService userService, IMvxMessenger messenger, IDialogService dialogService, IAuthenticator authService, ICommunityService communityService, IProspectService prospectService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService)
{
Messenger = messenger;
_dialogService = dialogService;
_authService = authService;
_communityService = communityService;
_prospectService = prospectService;
_collectionFactory = collectionFactory;
_navigationService = navigationService;
_userService = userService;
Messenger.Subscribe <ProspectChangedMessage>(message => ProspectUpdated(message.UpdatedProspect), MvxReference.Strong);
Messenger.Subscribe <ProspectAssignedMessage>(message => ProspectAssigned(message.AssignedProspect), MvxReference.Strong);
Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong);
}
public AddressMapViewModel(IMvxNavigationService navigationService,
IConnection connection, IMvxMessenger messenger,
IPermissionDependency permissionDependency, IGoogleMapsApiService googleMapsApiService,
IGoogleMapTableAccess googleMapTableAccess, IQuickMessageDependency quickMessageDependency)
{
_navigationService = navigationService;
_connection = connection;
_messenger = messenger;
_permissionDependency = permissionDependency;
_googleMapsApiService = googleMapsApiService;
_googleMapTableAccess = googleMapTableAccess;
_quickMessageDependency = quickMessageDependency;
Title = "Address Book";
Init();
_token = _messenger.Subscribe <AddressResult>((addr) =>
{
try
{
if (addr != null)
{
if (!AddedAddresses.Any(x => x.PlaceId == addr.Address.PlaceId))
{
_googleMapTableAccess.Insert(addr.Address);
AddedAddresses.Add(addr.Address);
ExecuteSelect(addr.Address);
}
}
}
catch (Exception ex)
{
_quickMessageDependency.ShowToastMessage(ex.Message);
}
});
}
public FolderControllerViewModel(IFolderObserver observer, IMvxMessenger hub)
{
this.observer = observer;
this.hub = hub;
this.files = new Dictionary<string, DateTime>(64);
this.mvxSubscriptionToken = hub.Subscribe<NewFileMessage>(this.NewFileReceived);
}
public MessagesViewModel(IMessageService messageService, IChatService chatService, IMvxMessenger messenger)
{
_messageService = messageService;
_chatService = chatService;
_chatMessageSubscriptionToken = messenger.Subscribe <ChatMessage>(OnNewMessage);
MessageItemViewModels = new MvxObservableCollection <MessageItemViewModel>();
}
public MenuViewModel(IMvxNavigationService navigationService, IMvxMessenger messenger)
{
_navigationService = navigationService;
_token = messenger.Subscribe <UpdateLanguageMessage>(OnUpdateLanguageMessage);
MenuItemList = new MvxObservableCollection <CommonMenuItem>()
{
new CommonMenuItem {
Icon = "\uf015", Code = "Home", Name = AppResources.Menu_Home
},
new CommonMenuItem {
Icon = "\uf201", Code = "Chart", Name = AppResources.Menu_Chart
},
//new CommonMenuItem{Icon = "\uf03a", Name = "Edit"},
new CommonMenuItem {
Icon = "\uf013", Code = "Settings", Name = AppResources.Menu_Settings
},
//new CommonMenuItem{Icon = "\uf1e0", Name = "Share" },
//new CommonMenuItem{Icon = "\uf118", Name = "Like Me!" },
//new CommonMenuItem{Icon = "\uf0e0", Name = "Feedback" },
//new CommonMenuItem{Icon = "\uf4c4", Name = "Help" },
new CommonMenuItem {
Icon = "\uf129", Code = "About", Name = AppResources.Menu_About
},
};
}
public ScanViewModel(IMvxMessenger mvxMessenger)
{
_mvxMessenger = mvxMessenger;
_scanSubscriptionTokenToken =
_mvxMessenger.Subscribe<ScanMessage>(OnScan);
}
public RestaurantDetailViewModel()
{
IMvxMessenger messenger = Mvx.Resolve <IMvxMessenger>();
_token = messenger.Subscribe <RatingChangeMessage>(RatingChangeHandler);
_dataService = Mvx.Resolve <IDataService>();
}
public void LogIn(
string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled,
string identityProviderName = null)
{
var root = Application.Current.RootVisual as Frame;
_messageHub = Mvx.Resolve<IMvxMessenger>();
_subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message =>
{
_response = message.TokenResponse;
if (_response != null)
{
onLoggedIn(_response);
}
else
{
assumeCancelled();
}
if (root == null) return;
if (root.CanGoBack)
root.GoBack();
});
if (root != null)
{
root.Navigate(
new Uri(
string.Format(
"/Cheesebaron.MvxPlugins.AzureAccessControl.WindowsPhone;component/Views/AccessControlWebAuthView.xaml?url={0}&name={1}",
WebUtility.UrlEncode(url), WebUtility.UrlEncode(identityProviderName)),
UriKind.Relative));
}
}
public DataViewModel(IMvxMessenger hub, IDataStorage<DataSample> data)
{
this.hub = hub;
this.data = data;
this.mvxSubscriptionToken = hub.Subscribe<NewDataMessage>(a => this.RaisePropertyChanged(() => this.DataList));
}
public MainViewModel(ISampleAppService sampleappservice, IMvxMessenger messenger)
{
_sampleAppService = sampleappservice;
ReloadList();
_messenger = messenger;
_listChangedToken = _messenger.Subscribe<SampleAppChangedMessage>(OnListChanged);
}
public GoalEditViewModel()
{
//this.DefaultViewModel["Lebensmittel"] = ds.CurrentLebensmittel;
//this.DefaultViewModel["Items"] = ds.LebensmittelConsumed;
//this.DefaultViewModel["SelectedConsumed"] = ds.SelectedConsumed;
//this.DefaultViewModel["Search"] = ds.LebensmittelResult;
//this.DefaultViewModel["CurrentLebensmittel"] = ds.CurrentLebensmittel;
//this.DefaultViewModel["SummaryConsumedDay"] = ds.SummaryConsumedDay;
//this.DefaultViewModel["SummaryConsumedDaytime"] = ds.SummaryConsumedDaytime;
//SelectedConsumed = null;
_messenger = Mvx.Resolve<IMvxMessenger>();
//_logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn));
_synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync"));
SaveDailyCommand = new MvxCommand(SaveDaily, canSaveDaily);
NewRecord = false;
WorkoutMinutes = new ObservableCollection<int>() { 20, 40, 60 };
WorkoutDays = new ObservableCollection<int>() { 1, 3, 5 };
_goal_Endurance = CurrentGoal.Goal_Endurance;
_goal_FatLoss = CurrentGoal.Goal_FatLoss;
_goal_Muscle = CurrentGoal.Goal_Muscle;
OnPropertyChanged("Goal_Muscle");
OnPropertyChanged("Goal_Endurance");
OnPropertyChanged("Goal_FatLoss"); ;
}
public HomeViewModel(IServicioDatos servicioDatos, IMvxMessenger messenger)
{
_servicioDatos = servicioDatos;
CmdNuevo = new MvxCommand(RunNuevo);
_token = messenger.Subscribe <ViewModelMessage>(OnViewModelMessage);
Task.Run(CargarLista);
}
public SessionListingViewModel(ISessionService sessionService, IMvxMessenger mvxMessenger)
{
SessionService = sessionService;
_messageToken = mvxMessenger.Subscribe <RefreshRequestMessage>(OnRefreshRequested);
Title = "Sessions";
}
public BaseViewModel(IMvxMessenger messenger) : base()
{
_messenger = messenger;
_token = _messenger.Subscribe<ReloadDataMessage>(async _ =>
await ReloadDataAsync());
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="nav"></param>
/// <param name="events"></param>
/// <param name="sync"></param>
public BettrFitDataSource()
{
_sync = new SyncDataViewModel();
Server = "https://www.bettrfit.com";
UserData = new UserVM();
UserGoals = new ObservableCollection<UserGoalVM>();
Auth = new WebAccess.ServiceReference.AuthData();
UserDaily = new ObservableCollection<UserDailyVM>();
NutritionPlanFavorites = new ObservableCollection<NutritionPlanFavoriteVM>();
NutritionPlanLeb = new ObservableCollection<LebensmittelVM>();
SummaryConsumedDaytime = new WebAccess.ServiceReference.SummaryData();
SummaryConsumedDay = new WebAccess.ServiceReference.SummaryData();
_messenger = Mvx.Resolve<IMvxMessenger>();
_mapper = new InitMapper();
_messenger.Subscribe<NetworkEvent>(m => IsNetworkAvailable = m.IsAvailable);
LoadAll();
CheckLogin();
//if (ret == 0)
//{
// _EventAggregator = Container.Resolve<IEventAggregator>();
// _EventAggregator.GetEvent<LoggedInEvent>().Publish(true);
// _ds._loggedIn = true;
//}
}
public void LogIn(string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled, string identityProviderName = null)
{
var webAuthController = new AccessControlWebAuthController { RawUrl = url, IdentityProviderName = identityProviderName };
_messageHub = Mvx.Resolve<IMvxMessenger>();
_subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message =>
{
webAuthController.OnCancel();
if (message.TokenResponse != null)
onLoggedIn(message.TokenResponse);
else
assumeCancelled();
});
var navControl = new UINavigationController(webAuthController)
{
Title = identityProviderName,
NavigationBarHidden = false,
};
webAuthController.NavigationItem.LeftBarButtonItem = new UIBarButtonItem("Cancel", UIBarButtonItemStyle.Done,
(sender, args) =>
{
webAuthController.OnCancel();
assumeCancelled();
});
var modalHost = Mvx.Resolve<IMvxTouchModalHost>();
modalHost.PresentModalViewController(navControl, true);
}
public MyRidesViewModel(
IMyShuttleClient myShuttleClient,
IApplicationSettingServiceSingleton applicationSettingService,
IMvxMessenger messenger)
{
if (myShuttleClient == null)
{
throw new ArgumentNullException("myShuttleClient");
}
if (applicationSettingService == null)
{
throw new ArgumentNullException("applicationSettingService");
}
if (messenger == null)
{
throw new ArgumentNullException("messenger");
}
_myShuttleClient = myShuttleClient;
_applicationSettingService = applicationSettingService;
_messenger = messenger;
_token = _messenger.Subscribe <ReloadDataMessage>(_ => InitializeActions());
InitializeActions();
InitializeCommands();
}
public FlashCardSetListViewModel(IFlashCardManager flashCardManager, IMvxMessenger messenger, IStudySettingsService settingsService)
{
_flashCardManager = flashCardManager;
_messenger = messenger;
_settingsService = settingsService;
GetFlashCardSetList();
_flashCardSetSubscriptionToken = _messenger.Subscribe<FlashCardSetListChangedMessage>(OnListChanged);
}
public FirstViewModel(IMvxMessenger messenger, IMvxNFCReadTask readTask, IMvxNFCWatcher watcher)
{
_messenger = messenger;
_nfcReadTask = readTask;
_watcher = watcher;
_messageToken = messenger.Subscribe<MvxNFCMessageReceived>(MessageRecieved);
}
public MainViewModel(IOCRService ocrService, IMvxPictureChooserTask pictureChooser, IMvxMessenger messenger)
{
OCRService = ocrService;
PictureChooser = pictureChooser;
Messenger = messenger;
Messenger.Subscribe<PictureMessage>(async msg => await OnPictureReceivedAsync(msg));
}
public AlertsViewModel()
{
_messenger = Mvx.Resolve<IMvxMessenger>();
_service = Mvx.Resolve<IAlertService>();
_fileService = Mvx.Resolve<IMvxFileStore>();
_localDbService = Mvx.Resolve<ILocalDataService>();
// NetworkConnectionHelper = Mvx.Resolve<IConnectivity> ();
_messenger.Subscribe<FollowsChanged>( async x => await ExecuteRefreshCommand(), MvxReference.Strong);
}
public NutritionPlanOverviewViewModel()
{
_ds = BettrFitDataSource.Instance;
_messenger = Mvx.Resolve<IMvxMessenger>();
_synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync"));
CurrentDate = DateTime.Now;
NutritionPlanCreateCommand = new MvxCommand(OnCreateNutritionPlan);
}
public MainViewModel()
{
_ds = BettrFitDataSource.Instance;
_messenger = Mvx.Resolve<IMvxMessenger>();
_mapNav = new Dictionary<string, Type>();
_mapNav.Add(menuNutritionPlan, typeof(NutritionPlanOverviewViewModel));
_mapNav.Add(menuNutritiondiary, typeof(NutritionPlanMainViewModel));
_mapNav.Add(menuGoals, typeof(GoalOverviewViewModel));
_mapNav.Add(menuNutrition, typeof(NutritionPlanMainViewModel));
_mapNav.Add(menuWeight, typeof(DailyDataOverviewViewModel));
_mapNav.Add("Login", typeof(LoginViewModel));
_mapNav.Add("Login mit Facebook", typeof(FirstViewModel));
_mapNav.Add(CultureHelper.GetLocalString("Register|Registrieren"), typeof(RegisterViewModel));
NavCommands = new ObservableCollection<NavEntry>();
NavCommand = new MvxCommand<string>(OnNavCommand);
LogoffCommand = new MvxCommand(OnLogoffCommand);
RefreshCommand = new MvxCommand(OnRefreshCommand);
ShowInfoCommand = new MvxCommand(OnShowInfo);
FeedbackCommand = new MvxCommand(OnFeedbackCommand);
ShakeCommand = new MvxCommand(()=>_messenger.Publish(new ShakeEvent(this)));
ShowAGBCommand = new MvxCommand(OnShowAGB);
_logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn));
_synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync"));
_nonetworktoken = _messenger.SubscribeOnMainThread<NetworkEvent>(m =>
{
IsNetworkAvailable = m.IsAvailable;
});
LoginChanged(_ds.IsLoggedIn());
//var client = WebService.Instance.WS;
RaisePropertyChanged("Sync");
IsNotRefreshing = true;
}
public FollowsViewModel(IFollowService service, IMvxMessenger messenger)
{
_messenger = messenger;
_service = service;
RefleshFollows();
_messenger.Subscribe<FollowsChanged>(x =>
{
RefleshFollows();
}, MvxReference.Strong);
}
public SideMenuViewModel(IAuthenticationService authService, IMvxMessenger messenger, ILocalizationService localizationService )
:base(authService, messenger)
{
this.ShouldSubscribeToSessionChange = true;
this._localizationService = localizationService;
_languageChangeToken = messenger.Subscribe<LanguageChangedMessage>((message) =>
{
RaisePropertyChanged(() => NewLanguage);
});
PropertyChanged += propertyChanged;
}
/// <summary>
/// Creates a Statistic ViewModel with custom start and end date
/// </summary>
/// <param name="startDate">Start date to select data from.</param>
/// <param name="endDate">End date to select date from.</param>
protected StatisticViewModel(DateTime startDate, DateTime endDate, IMvxMessenger messenger)
{
StartDate = startDate;
EndDate = endDate;
this.messenger = messenger;
token = messenger.Subscribe<DateSelectedMessage>(message =>
{
StartDate = message.StartDate;
EndDate = message.EndDate;
Load();
});
}
public BootstrapViewModel(IMvxMessenger messenger)
: base()
{
_messenger = messenger;
_sendMessageClickedToken = _messenger.Subscribe<SendMessageClicked> (msg => {
Click ();
});
Items = new ObservableCollection<ItemViewModel> ();
Items.Add (new ItemViewModel ());
Items.Add (new ItemViewModel ());
}
public InboxViewModel(IInboxService inboxService,
IMvxMessenger mvxMessenger)
{
_inboxService = inboxService;
_mvxMessenger = mvxMessenger;
// fill our Inbox up with Items of Stuff from IInboxService
ReloadInbox();
// subscribe to Inbox Changed messages to react to changes in inbox service
_inboxChangedSubToken =
_mvxMessenger.Subscribe<InboxChangedMessage>(OnInboxChanged);
}
public FirstViewModel(IKittenGenesisService service, IMvxMessenger messenger)
{
_messenger = messenger;
var newList = new List<Kitten>();
for (var i = 0; i < 100; i++)
{
var newKitten = service.CreateNewKitten(i.ToString());
newList.Add(newKitten);
}
_messenger.Subscribe<KittenAcceptedMessage>(message => KittenAcceptedCommand.Execute(message.Kitten));
Kittens = newList;
}
public ProductSearchViewModel(
IProductCodeDataService productCodeDataService,
IProductDataService productDataService,
IMvxMessenger messenger,
IBarCodeScanner scanner)
{
_scanner = scanner;
_productCodeDataService = productCodeDataService;
_productDataService = productDataService;
_messenger = messenger;
_messenger.Subscribe<EntityMessage<Product>>(ProductChange);
}
public void LogIn(string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled, string identityProviderName = null)
{
_onLoggedIn = onLoggedIn;
_assumeCancelled = assumeCancelled;
_messageHub = Mvx.Resolve<IMvxMessenger>();
_subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message =>
{
_response = message.TokenResponse;
});
var intent = new Intent(Mvx.Resolve<IMvxAndroidGlobals>()
.ApplicationContext, typeof(AccessControlWebAuthActivity));
intent.PutExtra("cheesebaron.mvxplugins.azureaccesscontrol.droid.Url", url);
StartActivityForResult(LoginIdentityRequestCode, intent);
}
public ModifyPaymentViewModel(IPaymentRepository paymentRepository,
IAccountRepository accountRepository,
IDialogService dialogService,
IPaymentManager paymentManager,
ISettingsManager settingsManager,
IMvxMessenger messenger, IBackupManager backupManager)
{
this.dialogService = dialogService;
this.paymentManager = paymentManager;
this.settingsManager = settingsManager;
this.backupManager = backupManager;
this.paymentRepository = paymentRepository;
this.accountRepository = accountRepository;
token = messenger.Subscribe<CategorySelectedMessage>(ReceiveMessage);
}
public MakeStuffActionableViewModel(IMvxMessenger mvxMessenger,
IInboxService inboxService,
IProjectService projectService,
IActionService actionService)
{
_mvxMessenger = mvxMessenger;
_inboxService = inboxService;
_projectService = projectService;
_actionService = actionService;
ReloadProjects();
// subscribe to Projects Changed messages to react to changes in project service
_projectsChangedSubToken =
_mvxMessenger.Subscribe<ProjectsChangedMessage>(OnProjectsChanged);
_isSingleActionProject = true;
}
public DailyDataEditViewModel()
{
//this.DefaultViewModel["Lebensmittel"] = ds.CurrentLebensmittel;
//this.DefaultViewModel["Items"] = ds.LebensmittelConsumed;
//this.DefaultViewModel["SelectedConsumed"] = ds.SelectedConsumed;
//this.DefaultViewModel["Search"] = ds.LebensmittelResult;
//this.DefaultViewModel["CurrentLebensmittel"] = ds.CurrentLebensmittel;
//this.DefaultViewModel["SummaryConsumedDay"] = ds.SummaryConsumedDay;
//this.DefaultViewModel["SummaryConsumedDaytime"] = ds.SummaryConsumedDaytime;
//SelectedConsumed = null;
_messenger = Mvx.Resolve<IMvxMessenger>();
//_logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn));
_synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync"));
SaveDailyCommand = new MvxCommand(SaveDaily, canSaveDaily);
NewRecord = false;
}
public NutritionPlanCreateViewModel()
{
_ds = BettrFitDataSource.Instance;
_messenger = Mvx.Resolve<IMvxMessenger>();
_synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync"));
CurrentDate = DateTime.Now;
NutritionPlanCreateCommand = new MvxCommand(OnCreateNutritionPlan);
SelectedDate = DateTime.Now;
PlanList = new ObservableCollection<string>();
AllPlans = new ObservableCollection<NutritionPlanVM>();
fillPlanlist();
_ds.CalcBMR(_ds.UserData, ref _bmr, ref _act, ref _weight,ref _calcString);
SelectedCalories = (int)(ACT*0.9d);
}
