public static async Task<EditTimeEntryGroupViewModel> Init (List<string> timeEntryIds)
 {
     var timeEntryList = await GetTimeEntryDataList (timeEntryIds);
     var model = new TimeEntryModel (timeEntryList.Last ());
     await model.LoadAsync ();
     return new EditTimeEntryGroupViewModel (model, timeEntryList);
 }

        private async void OnActionButtonTouchUpInside (object sender, EventArgs e)
        {
            if (isActing) {
                return;
            }
            isActing = true;

            try {
                if (currentTimeEntry != null && currentTimeEntry.State == TimeEntryState.Running) {
                    await currentTimeEntry.StopAsync ();

                    // Ping analytics
                    ServiceContainer.Resolve<ITracker>().SendTimerStopEvent (TimerStopSource.App);
                } else if (timeEntryManager != null) {
                    currentTimeEntry = (TimeEntryModel)timeEntryManager.Draft;
                    if (currentTimeEntry == null) {
                        return;
                    }

                    await currentTimeEntry.StartAsync ();

                    var controllers = new List<UIViewController> (parentController.NavigationController.ViewControllers);
                    controllers.Add (new EditTimeEntryViewController (currentTimeEntry));
                    if (ServiceContainer.Resolve<SettingsStore> ().ChooseProjectForNew) {
                        controllers.Add (new ProjectSelectionViewController (currentTimeEntry));
                    }
                    parentController.NavigationController.SetViewControllers (controllers.ToArray (), true);

                    // Ping analytics
                    ServiceContainer.Resolve<ITracker>().SendTimerStartEvent (TimerStartSource.AppNew);
                }
            } finally {
                isActing = false;
            }
        }

        public EditTimeEntryFragment (TimeEntryModel model)
        {
            var args = new Bundle ();
            args.PutString (TimeEntryIdArgument, model.Id.ToString ());

            Arguments = args;
        }

        bool RecordTime(TimeEntry timeEntry, Task task)
        {
            var timeEntryModel = new TimeEntryModel
            {
                Date = GetCompatibleDate(timeEntry).ToString("O"),
                Notes = timeEntry.Comment,
                TimeString = timeEntry.MinutesSpent + "m",
                DurationSeconds = timeEntry.MinutesSpent*60,
                ProjectId = timeEntry.Project?.Id,
                TaskId = task?.Id,
                WorkItems = new List<string>(), // TODO: add functionality for tracking WorkItems
            };

            var post = new RestRequest
            {
                Resource = "Time/Save",
                Method = Method.POST,
                RequestFormat = DataFormat.Json
            };

            post.AddBody(timeEntryModel);

            var result = _api.Execute<TimeEntryModel>(post);
            return result != null;
        }

 public void TestSqliteIgnoreOnTimeEntry ()
 {
     var cache = new AttributeLookupCache<SQLite.IgnoreAttribute> ();
     var entry = new TimeEntryModel ();
     Assert.IsTrue (cache.HasAttribute (entry, TimeEntryModel.PropertyWorkspace));
     Assert.IsFalse (cache.HasAttribute (entry, TimeEntryModel.PropertyStartTime));
 }

        public RecentTimeEntryContinueDialogFragment (TimeEntryModel model)
        {
            var args = new Bundle ();
            args.PutString (TimeEntryIdArgument, model.Id.ToString ());

            Arguments = args;
        }

        public async void StartStopTimeEntry()
        {
            if (isActing) {
                return;
            }
            isActing = true;

            try {
                if (currentTimeEntry != null && currentTimeEntry.State == TimeEntryState.Running) {
                    await currentTimeEntry.StopAsync ();

                    // Ping analytics
                    ServiceContainer.Resolve<ITracker>().SendTimerStopEvent (TimerStopSource.Widget);
                } else if (timeEntryManager != null) {
                    currentTimeEntry = (TimeEntryModel)timeEntryManager.Draft;
                    if (currentTimeEntry == null) {
                        return;
                    }
                    await currentTimeEntry.StartAsync ();

                    // Show new screen on platform
                    widgetUpdateService.ShowNewTimeEntryScreen (currentTimeEntry);

                    // Ping analytics
                    ServiceContainer.Resolve<ITracker>().SendTimerStartEvent (TimerStartSource.WidgetNew);
                }
            } finally {
                isActing = false;
            }
        }

        public ChangeTimeEntryStopTimeDialogFragment (TimeEntryModel model) : base ()
        {
            var args = new Bundle ();
            args.PutString (TimeEntryIdArgument, model.Id.ToString ());

            Arguments = args;
        }

        protected BaseDateTimeDialogFragment (TimeEntryModel model) : base ()
        {
            var args = new Bundle ();
            args.PutString (TimeEntryIdArgument, model.Id.ToString ());

            Arguments = args;
        }

        public static bool TryShow (FragmentManager fragmentManager, TimeEntryModel model)
        {
            var settingsStore = ServiceContainer.Resolve<SettingsStore> ();
            if (settingsStore.ReadContinueDialog)
                return false;

            new RecentTimeEntryContinueDialogFragment (model).Show (fragmentManager, "notice_dialog");
            return true;
        }

        private void ContinueTimeEntry (TimeEntryModel model)
        {
            var entry = model.Continue ();

            var bus = ServiceContainer.Resolve<MessageBus> ();
            bus.Send (new UserTimeEntryStateChangeMessage (this, entry));

            DurOnlyNoticeDialogFragment.TryShow (FragmentManager);
        }

        public override void OnCreate (Bundle state)
        {
            base.OnCreate (state);

            model = Model.ById<TimeEntryModel> (TimeEntryId);
            if (model == null) {
                Dismiss ();
            }
        }

        public override void OnCreate (Bundle state)
        {
            base.OnCreate (state);

            timeEntry = Model.ById<TimeEntryModel> (TimeEntryId);
            workspace = Model.ById<WorkspaceModel> (WorkspaceId);
            if (workspace == null) {
                Dismiss ();
            }
        }

 private async void LoadData ()
 {
     model = new TimeEntryModel (TimeEntryId);
     await model.LoadAsync ();
     if (model.Workspace == null || model.Workspace.Id == Guid.Empty) {
         Dismiss ();
     } else {
         modelLoaded = true;
     }
 }

 private async void LoadData ()
 {
     model = new TimeEntryModel (TimeEntryId);
     await model.LoadAsync ();
     if (model.Workspace == null || model.Workspace.Id == Guid.Empty) {
         // Invalid model, do nothing.
     } else {
         modelLoaded = true;
     }
 }

        public void OnStart ()
        {
            currentEntry = TimeEntryModel.FindRunning () ?? TimeEntryModel.GetDraft ();

            // Start listening for changes model changes
            var bus = ServiceContainer.Resolve<MessageBus> ();
            subscriptionModelChanged = bus.Subscribe<ModelChangedMessage> (OnModelChanged);

            canRebind = true;
            Rebind ();
        }

        EditTimeEntryGroupViewModel (TimeEntryModel model, List<TimeEntryData> timeEntryList)
        {
            this.model = model;
            this.timeEntryList = timeEntryList;
            this.durationTimer = new Timer();

            this.model.PropertyChanged += OnPropertyChange;
            this.durationTimer.Elapsed += DurationTimerCallback;

            ServiceContainer.Resolve<ITracker> ().CurrentScreen = "Edit Grouped Time Entry";
            UpdateView ();
        }

        EditTimeEntryViewModel (TimeEntryModel model, List<TagData> tagList)
        {
            this.model = model;
            durationTimer = new Timer ();
            TagList = tagList;

            model.PropertyChanged += OnPropertyChange;
            durationTimer.Elapsed += DurationTimerCallback;

            ServiceContainer.Resolve<ITracker> ().CurrentScreen = "Edit Time Entry";
            UpdateView ();
        }

        private void OnActiveTimeEntryChanged ()
        {
            var data = TimeEntryManager.ActiveTimeEntry;

            if (activeTimeEntryModel == null) {
                activeTimeEntryModel = new TimeEntryModel (data);
            } else {
                activeTimeEntryModel.Data = data;
            }

            SyncNotification ();
        }

        public CreateProjectDialogFragment (TimeEntryModel timeEntry, WorkspaceModel workspace, int color)
        {
            var args = new Bundle ();

            if (timeEntry != null) {
                args.PutString (TimeEntryIdArgument, timeEntry.Id.ToString ());
            }
            args.PutString (WorkspaceIdArgument, workspace.Id.ToString ());
            args.PutInt (ProjectColorArgument, color);

            Arguments = args;
        }