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 ChangeTimeEntryStopTimeDialogFragment (TimeEntryModel model) : base ()
{
var args = new Bundle ();
args.PutString (TimeEntryIdArgument, model.Id.ToString ());
Arguments = args;
}
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;
}
}
protected BaseDateTimeDialogFragment (TimeEntryModel model) : base ()
{
var args = new Bundle ();
args.PutString (TimeEntryIdArgument, model.Id.ToString ());
Arguments = args;
}
public EditTimeEntryFragment (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 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);
}
protected override void OnCreateActivity (Bundle state)
{
base.OnCreateActivity (state);
var actionBarView = CreateDoneActionBarView ();
DoneFrameLayout = actionBarView.FindViewById<FrameLayout> (Resource.Id.DoneFrameLayout);
DoneFrameLayout.Click += OnDoneFrameLayoutClick;
ActionBar.SetDisplayOptions (
ActionBarDisplayOptions.ShowCustom,
(ActionBarDisplayOptions)((int)ActionBarDisplayOptions.ShowCustom
| (int)ActionBarDisplayOptions.ShowHome
| (int)ActionBarDisplayOptions.ShowTitle));
ActionBar.CustomView = actionBarView;
SetContentView (Resource.Layout.EditTimeEntryActivity);
if (state == null) {
model = GetModelFromIntent ();
if (model == null) {
Finish ();
} else {
FragmentManager.BeginTransaction ()
.Add (Resource.Id.FrameLayout, new EditTimeEntryFragment (model))
.Commit ();
}
}
}
public EditTimeEntryViewController (TimeEntryModel model)
{
this.model = model;
tagsView = new TimeEntryTagsView (model.Id);
timerController = new TimerNavigationController (model);
}
public void Dispose ()
{
durationTimer.Elapsed -= DurationTimerCallback;
durationTimer.Dispose ();
model.PropertyChanged -= OnPropertyChange;
model = null;
}
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 ();
}
}
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 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;
}
}
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 ();
}
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 ();
}
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;
}
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 ();
}
private void OnActiveTimeEntryChanged ()
{
var data = TimeEntryManager.ActiveTimeEntry;
if (activeTimeEntryModel == null) {
activeTimeEntryModel = new TimeEntryModel (data);
} else {
activeTimeEntryModel.Data = data;
}
SyncNotification ();
}
public void ShowNewTimeEntryScreen (TimeEntryModel currentTimeEntry)
{
var startAppIntent = new Intent (Intent.ActionMain)
.AddCategory (Intent.CategoryLauncher)
.AddFlags (ActivityFlags.NewTask)
.SetComponent (
new ComponentName (
context.ApplicationContext.PackageName,
"toggl.joey.ui.activities.MainDrawerActivity"
)
);
context.StartActivity (startAppIntent);
}
public override void OnCreate (Bundle state)
{
base.OnCreate (state);
model = new TimeEntryModel (TimeEntryId);
model.PropertyChanged += OnModelPropertyChanged;
workspaceTagsView = new WorkspaceTagsView (WorkspaceId);
workspaceTagsView.Updated += OnWorkspaceTagsUpdated;
LoadModel ();
LoadTags ();
}
public override async void OnListItemClick(ListView l, View v, int position, long id)
{
RecentTimeEntriesAdapter adapter = null;
if (l.Adapter is HeaderViewListAdapter)
{
var headerAdapter = (HeaderViewListAdapter)l.Adapter;
adapter = headerAdapter.WrappedAdapter as RecentTimeEntriesAdapter;
// Adjust the position by taking into account the fact that we've got headers
position -= headerAdapter.HeadersCount;
}
else if (l.Adapter is RecentTimeEntriesAdapter)
{
adapter = (RecentTimeEntriesAdapter)l.Adapter;
}
if (adapter == null || position < 0 || position >= adapter.Count)
{
return;
}
var data = adapter.GetEntry(position);
if (data == null)
{
return;
}
var model = new TimeEntryModel(data);
// Show a notice about tapping on entries acts as continue.
if (RecentTimeEntryContinueDialogFragment.TryShow(FragmentManager, model))
{
return;
}
// Scroll to top (where the new model will appear)
ListView.SmoothScrollToPosition(0);
DurOnlyNoticeDialogFragment.TryShow(FragmentManager);
var entry = await model.ContinueAsync();
// Notify that the user explicitly started something
var bus = ServiceContainer.Resolve <MessageBus> ();
bus.Send(new UserTimeEntryStateChangeMessage(this, entry));
// Ping analytics
ServiceContainer.Resolve <ITracker> ().SendTimerStartEvent(TimerStartSource.AppContinue);
}
public async Task <Guid> CreateTimeEntry(int userId, TimeEntryModel data)
{
CreateTimeEntry request = new Dto.CreateTimeEntry()
{
UserId = userId,
EntryDate = data.EntryDate,
Hours = data.Hours,
ProjectId = data.ProjectId,
ProjectName = data.ProjectName
};
var response = await timeTrackerApiClient.PostAsync <CreateTimeEntry, CreateTimeEntryResponse>($"/timeentries", request);
return(response.TimeEntryId);
}
private async void LoadRequestedModel ()
{
var store = ServiceContainer.Resolve<IDataStore> ();
var rows = await store.Table<TimeEntryData> ()
.QueryAsync (r => r.Id == TimeEntryId && r.DeletedAt == null);
var data = rows.FirstOrDefault ();
if (data != null) {
TimeEntry = new TimeEntryModel (data);
} else {
ResetModel ();
}
}
protected override void Rebind()
{
if (TimeEntry == null || !CanRebind)
{
return;
}
if (TimeEntry.State == TimeEntryState.Finished || TimeEntry.DeletedAt.HasValue)
{
TimeEntry = TimeEntryModel.GetDraft();
}
base.Rebind();
}
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 ShowNewTimeEntryScreen(TimeEntryModel currentTimeEntry)
{
var startAppIntent = new Intent(Intent.ActionMain)
.AddCategory(Intent.CategoryLauncher)
.AddFlags(ActivityFlags.NewTask)
.SetComponent(
new ComponentName(
context.ApplicationContext.PackageName,
"toggl.joey.ui.activities.MainDrawerActivity"
)
);
context.StartActivity(startAppIntent);
}
public override void OnDestroy ()
{
if (model != null) {
model.PropertyChanged -= OnModelPropertyChanged;
model = null;
}
if (workspaceTagsView != null) {
workspaceTagsView.Updated -= OnWorkspaceTagsUpdated;
workspaceTagsView.Dispose ();
workspaceTagsView = null;
}
base.OnDestroy ();
}
public void Add(TimeEntryModel entry)
{
var grp = data.FirstOrDefault((g) => g.CanContain(entry));
if (grp == null)
{
grp = new Group(entry);
data.Add(grp);
}
else
{
grp.Add(entry);
}
}
public AndroidNotificationManager ()
{
ctx = ServiceContainer.Resolve<Context> ();
notificationManager = (NotificationManager)ctx.GetSystemService (Context.NotificationService);
runningBuilder = CreateRunningNotificationBuilder (ctx);
idleBuilder = CreateIdleNotificationBuilder (ctx);
currentTimeEntry = TimeEntryModel.FindRunning ();
SyncNotification ();
var bus = ServiceContainer.Resolve<MessageBus> ();
subscriptionModelChanged = bus.Subscribe<ModelChangedMessage> (OnModelChanged);
subscriptionSettingChanged = bus.Subscribe<SettingChangedMessage> (OnSettingChanged);
subscriptionAuthChanged = bus.Subscribe<AuthChangedMessage> (OnAuthChanged);
}
private void OnActiveTimeEntryChanged()
{
var data = TimeEntryManager.ActiveTimeEntry;
if (activeTimeEntryModel == null)
{
activeTimeEntryModel = new TimeEntryModel(data);
}
else
{
activeTimeEntryModel.Data = data;
}
SyncNotification();
}
public async Task <IActionResult> Delete(TimeEntryModel timeEntryModel)
{
try
{
TimeNotesUser identityUser = await _userManager.GetUserAsync(User);
await _hourPointsServices.RemoveTimeEntryFromHourPoints(Guid.Parse(identityUser.Id), timeEntryModel.Id);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
return(View(timeEntryModel));
}
}
private string GetProjectName(TimeEntryModel entry)
{
if (entry == null)
{
return(null);
}
else if (entry.Project != null)
{
return(entry.Project.Name);
}
else
{
return(ctx.Resources.GetString(Resource.String.RunningNotificationNoProject));
}
}
public async Task <IActionResult> Edit(TimeEntryModel timeEntryModel)
{
try
{
TimeNotesUser identityUser = await _userManager.GetUserAsync(User);
await _hourPointsServices.UpdateTimeEntryDateHourPointed(timeEntryModel.HourPointsId, timeEntryModel.Id, Guid.Parse(identityUser.Id), timeEntryModel.DateHourPointed);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
private async void OnNavigationBarRightClicked(object sender, EventArgs args)
{
if (isSaving)
{
return;
}
try {
isSaving = true;
var duration = TimeSpan.Zero;
var entered = durationView.EnteredDuration;
if (model == null || model.State == TimeEntryState.New)
{
duration = new TimeSpan(entered.Hours, entered.Minutes, 0);
}
else
{
duration = model.GetDuration();
// Keep the current seconds and milliseconds
duration = new TimeSpan(0, entered.Hours, entered.Minutes, duration.Seconds, duration.Milliseconds);
}
if (model == null)
{
var m = await TimeEntryModel.CreateFinishedAsync(duration);
var controller = new EditTimeEntryViewController(m);
// Replace self with edit controller on the stack
var vcs = NavigationController.ViewControllers;
vcs [vcs.Length - 1] = controller;
NavigationController.SetViewControllers(vcs, true);
// Ping analytics
ServiceContainer.Resolve <ITracker>().SendTimerStartEvent(TimerStartSource.AppManual);
}
else
{
model.SetDuration(duration);
await model.SaveAsync();
NavigationController.PopViewController(true);
}
} finally {
isSaving = false;
}
}
public async Task <IActionResult> Create(TimeEntryModel timeEntryModel)
{
if (ModelState.IsValid)
{
TimeNotesUser identityUser = await _userManager.GetUserAsync(User);
if (identityUser is null)
{
throw new ArgumentException($"Usuário não encontrado na base de dados.");
}
await _hourPointsServices.AddTimeEntryToHourPoints(Guid.Parse(identityUser.Id), _mapper.Map <TimeEntry>(timeEntryModel));
}
return(RedirectToAction(nameof(Index)));
}
private async void LoadData()
{
workspace = new WorkspaceModel(WorkspaceId);
if (TimeEntryId != Guid.Empty)
{
timeEntry = new TimeEntryModel(TimeEntryId);
await Task.WhenAll(workspace.LoadAsync(), timeEntry.LoadAsync());
}
else
{
await workspace.LoadAsync();
}
modelsLoaded = true;
ValidateTagName();
}
public void ShowNewTimeEntryScreen(TimeEntryModel currentTimeEntry)
{
var topVCList = new List <UIViewController> (rootController.ChildViewControllers);
if (topVCList.Count > 0)
{
// Get current VC's navigation
var controllers = new List <UIViewController> (topVCList[0].NavigationController.ViewControllers);
controllers.Add(new EditTimeEntryViewController(currentTimeEntry));
if (ServiceContainer.Resolve <SettingsStore> ().ChooseProjectForNew)
{
controllers.Add(new ProjectSelectionViewController(currentTimeEntry));
}
topVCList[0].NavigationController.SetViewControllers(controllers.ToArray(), true);
}
}
protected override async Task OnContinueAsync()
{
if (DataSource == null)
{
return;
}
await TimeEntryModel.ContinueAsync(DataSource);
if (ContinueCallback != null)
{
ContinueCallback(DataSource);
}
// Ping analytics
ServiceContainer.Resolve <ITracker>().SendTimerStartEvent(TimerStartSource.AppContinue);
}
public AndroidNotificationManager()
{
ctx = ServiceContainer.Resolve <Context> ();
notificationManager = (NotificationManager)ctx.GetSystemService(Context.NotificationService);
runningBuilder = CreateRunningNotificationBuilder(ctx);
idleBuilder = CreateIdleNotificationBuilder(ctx);
currentTimeEntry = TimeEntryModel.FindRunning();
SyncNotification();
var bus = ServiceContainer.Resolve <MessageBus> ();
subscriptionModelChanged = bus.Subscribe <ModelChangedMessage> (OnModelChanged);
subscriptionSettingChanged = bus.Subscribe <SettingChangedMessage> (OnSettingChanged);
subscriptionAuthChanged = bus.Subscribe <AuthChangedMessage> (OnAuthChanged);
}
private void SyncRunningModel()
{
var data = RunningTimeEntryData;
if (data != null)
{
if (backingRunningTimeEntry == null)
{
backingRunningTimeEntry = new TimeEntryModel(data);
}
else
{
backingRunningTimeEntry.Data = data;
}
}
}
public override void OnDestroy()
{
if (model != null)
{
model.PropertyChanged -= OnModelPropertyChanged;
model = null;
}
if (workspaceTagsView != null)
{
workspaceTagsView.Updated -= OnWorkspaceTagsUpdated;
workspaceTagsView.Dispose();
workspaceTagsView = null;
}
base.OnDestroy();
}
private async void LoadData()
{
timeEntry = new TimeEntryModel(TimeEntryId);
workspace = new WorkspaceModel(WorkspaceId);
await Task.WhenAll(timeEntry.LoadAsync(), workspace.LoadAsync());
if (timeEntry.Workspace == null || timeEntry.Workspace.Id == Guid.Empty)
{
// TODO: Better logic to determine if the models are actually non-existent
Dismiss();
}
else
{
modelsLoaded = true;
}
}
public async Task <ActionResult <TimeEntryModel> > GetById(long id)
{
_logger.LogInformation($"Getting a time entry with id: {id}");
var timeEntry = await _dbContext.TimeEntries
.Include(x => x.Project)
.Include(x => x.Project.Client)
.Include(x => x.User)
.SingleOrDefaultAsync(x => x.Id == id);
if (timeEntry == null)
{
return(NotFound());
}
return(TimeEntryModel.FromTimeEntry(timeEntry));
}
public void TestUserLogout()
{
RunAsync(async delegate {
var te1 = TimeEntryModel.GetDraft();
te1 = await TimeEntryModel.StartAsync(te1);
Assert.AreEqual(te1.Id, ActiveManager.ActiveTimeEntry.Id);
Assert.AreEqual(user.Id, ActiveManager.ActiveTimeEntry.UserId);
ActiveManager.PropertyChanged += (sender, e) => {
Assert.AreEqual(ActiveManager.ActiveTimeEntry.UserId, Guid.Empty);
Assert.AreEqual(ActiveManager.ActiveTimeEntry.State, TimeEntryState.New);
};
ServiceContainer.Resolve <AuthManager> ().Forget();
});
}
private void OnActionButtonTouchUpInside (object sender, EventArgs e)
{
if (currentTimeEntry == null) {
currentTimeEntry = TimeEntryModel.GetDraft ();
currentTimeEntry.Start ();
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);
} else {
currentTimeEntry.Stop ();
}
}
public async Task StartStopTimeEntry()
{
if (activeTimeEntryManager.IsRunning)
{
await TimeEntryModel.StopAsync(activeTimeEntryManager.ActiveTimeEntry);
ServiceContainer.Resolve <ITracker>().SendTimerStopEvent(TimerStopSource.Widget);
}
else
{
var startedEntry = await TimeEntryModel.StartAsync(TimeEntryModel.GetDraft());
// Show new screen on platform
widgetUpdateService.ShowNewTimeEntryScreen(new TimeEntryModel(startedEntry));
ServiceContainer.Resolve <ITracker>().SendTimerStartEvent(TimerStartSource.WidgetNew);
}
}
public static async Task StartStopTimeEntry (Context ctx)
{
var manager = ServiceContainer.Resolve<ActiveTimeEntryManager> ();
if (manager.Active == null) {
return;
}
var active = new TimeEntryModel (manager.Active);
if (manager.Active.State == TimeEntryState.Running) {
await active.StopAsync ();
ServiceContainer.Resolve<ITracker> ().SendTimerStopEvent (TimerStopSource.Watch);
} else {
active.Data.Description = ctx.Resources.GetString (Resource.String.WearEntryDefaultDescription);
await active.StartAsync ();
ServiceContainer.Resolve<ITracker> ().SendTimerStartEvent (TimerStartSource.WatchStart);
}
}
private async void LoadTimeEntries()
{
if (currentUserId == null)
{
return;
}
var userId = currentUserId.Value;
var store = ServiceContainer.Resolve <IDataStore> ();
// Load data:
var draftTask = TimeEntryModel.GetDraftAsync();
var runningTask = store.Table <TimeEntryData> ()
.QueryAsync(r => r.State == TimeEntryState.Running && r.DeletedAt == null && r.UserId == userId);
await Task.WhenAll(draftTask, runningTask);
// Check that the user hasn't changed in the mean time
if (userId != currentUserId)
{
return;
}
// Update data
var draftModel = draftTask.Result;
if (draftModel != null)
{
var draftData = draftModel.Data;
if (!draftEntries.UpdateData(draftData))
{
draftEntries.Add(draftData);
}
}
foreach (var entry in runningTask.Result)
{
if (!runningEntries.UpdateData(entry))
{
runningEntries.Add(entry);
}
}
UpdateProperties();
TryEnforceSingleRunning();
}
private static async Task FindAndStopRunning()
{
var userId = ServiceContainer.Resolve <AuthManager> ().GetUserId();
var dataStore = ServiceContainer.Resolve <IDataStore> ();
// Find running tasks:
var runningEntries = await dataStore.Table <TimeEntryData> ()
.Where(r => r.State == TimeEntryState.Running && r.DeletedAt == null && r.UserId == userId)
.ToListAsync()
.ConfigureAwait(false);
var stopTasks = runningEntries.Select(data => TimeEntryModel.StopAsync(data));
await Task.WhenAll(stopTasks).ConfigureAwait(false);
// Ping analytics
ServiceContainer.Resolve <ITracker> ().SendTimerStopEvent(TimerStopSource.Notification);
}
public static async Task <List <SimpleTimeEntryData> > GetTimeEntryData()
{
var store = ServiceContainer.Resolve <IDataStore> ();
var userId = ServiceContainer.Resolve <AuthManager> ().GetUserId();
var entries = await store.Table <TimeEntryData>()
.Where(r => r.State != TimeEntryState.New &&
r.DeletedAt == null &&
r.UserId == userId)
.OrderByDescending(r => r.StartTime)
.ToListAsync();
var uniqueEntries = entries.GroupBy(x => new { x.ProjectId, x.Description })
.Select(grp => grp.First())
.Take(itemCount)
.ToList();
var simpleEntries = new List <SimpleTimeEntryData> ();
foreach (var entry in uniqueEntries)
{
var model = new TimeEntryModel(entry);
await model.LoadAsync();
int color = 0;
String projectName = "";
if (model.Project != null)
{
color = model.Project.Color;
projectName = model.Project.Name;
}
var colorString = ProjectModel.HexColors [color % ProjectModel.HexColors.Length];
simpleEntries.Add(
new SimpleTimeEntryData {
Id = entry.Id,
IsRunning = entry.State == TimeEntryState.Running,
Description = entry.Description,
Project = projectName,
ProjectColor = colorString,
StartTime = entry.StartTime,
StopTime = entry.StopTime ?? DateTime.MinValue
});
}
return(simpleEntries);
}
private async Task RemoveItemPermanentlyAsync(TimeEntryHolder holder)
{
if (holder == null)
{
return;
}
if (holder.TimeEntryDataList.Count > 1)
{
var timeEntryGroup = new TimeEntryGroup(holder.TimeEntryDataList);
await timeEntryGroup.DeleteAsync();
}
else
{
await TimeEntryModel.DeleteTimeEntryDataAsync(holder.TimeEntryDataList.First());
}
}
public void Stop()
{
// Stop listening to timer changes
isStarted = false;
if (subscriptionModelChanged != null)
{
var bus = ServiceContainer.Resolve <MessageBus> ();
bus.Unsubscribe(subscriptionModelChanged);
subscriptionModelChanged = null;
}
if (showRunning)
{
currentTimeEntry = null;
}
}
public void Start()
{
// Start listening to timer changes
if (showRunning)
{
currentTimeEntry = TimeEntryModel.FindRunning();
}
if (subscriptionModelChanged == null)
{
var bus = ServiceContainer.Resolve <MessageBus> ();
subscriptionModelChanged = bus.Subscribe <ModelChangedMessage> (OnModelChanged);
}
isStarted = true;
Rebind();
}
public void TestActiveEntryAfterContinue()
{
RunAsync(async delegate {
var startTime = Time.UtcNow - TimeSpan.FromHours(2);
var te1 = await DataStore.PutAsync(new TimeEntryData {
Description = "Morning meeting",
State = TimeEntryState.Finished,
StartTime = startTime,
ModifiedAt = startTime,
IsDirty = true,
WorkspaceId = workspace.Id,
UserId = user.Id,
});
startTime = Time.UtcNow - TimeSpan.FromHours(1);
var te2 = await DataStore.PutAsync(new TimeEntryData {
Description = "Morning coffee",
State = TimeEntryState.Finished,
StartTime = startTime,
ModifiedAt = startTime,
IsDirty = true,
WorkspaceId = workspace.Id,
UserId = user.Id,
});
Assert.AreNotEqual(te1.Id, ActiveManager.ActiveTimeEntry.Id);
Assert.AreNotEqual(te2.Id, ActiveManager.ActiveTimeEntry.Id);
te1 = await TimeEntryModel.ContinueAsync(te1);
te2 = await GetEntry(te2.Id);
Assert.AreEqual(te1.Id, ActiveManager.ActiveTimeEntry.Id);
Assert.IsTrue(ActiveManager.IsRunning);
Assert.AreEqual(te1.State, TimeEntryState.Running);
Assert.AreEqual(te2.State, TimeEntryState.Finished);
te2 = await TimeEntryModel.ContinueAsync(te2);
te1 = await GetEntry(te1.Id);
Assert.AreEqual(te2.Id, ActiveManager.ActiveTimeEntry.Id);
Assert.IsTrue(ActiveManager.IsRunning);
Assert.AreEqual(te2.State, TimeEntryState.Running);
Assert.AreEqual(te1.State, TimeEntryState.Finished);
});
}
