protected async override Task RemoveTimeEntryHolderAsync(TimeEntryHolder holder)
{
DateGroup dateGroup;
TimeEntryGroup timeEntryGroup;
TimeEntryData timeEntry;
if (FindExistingEntry(holder.TimeEntryData, out dateGroup, out timeEntryGroup, out timeEntry))
{
// Get items indexes.
var entryGroupIndex = GetEntryGroupIndex(timeEntryGroup);
var dateGroupIndex = GetDateGroupIndex(dateGroup);
dateGroup.Remove(timeEntryGroup);
// Notify removed entry group.
await UpdateCollectionAsync(timeEntryGroup, NotifyCollectionChangedAction.Remove, entryGroupIndex);
// Notify or update Date group.
if (dateGroup.TimeEntryGroupList.Count == 0)
{
dateGroups.Remove(dateGroup);
await UpdateCollectionAsync(dateGroup, NotifyCollectionChangedAction.Remove, dateGroupIndex);
}
else
{
await UpdateCollectionAsync(dateGroup, NotifyCollectionChangedAction.Replace, dateGroupIndex);
}
}
}
public async Task RestoreItemFromUndoAsync()
{
if (LastRemovedItem != null)
{
await AddTimeEntryHolderAsync(LastRemovedItem);
LastRemovedItem = null;
}
}
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());
}
}
protected async override Task AddTimeEntryHolderAsync(TimeEntryHolder holder)
{
var entryGroup = new TimeEntryGroup(holder.TimeEntryDataList);
bool isNewGroup;
DateGroup grp = GetDateGroupFor(entryGroup.Data, out isNewGroup);
grp.Add(entryGroup);
Sort();
// Update Date group.
var groupIndex = GetDateGroupIndex(grp);
var groupAction = isNewGroup ? NotifyCollectionChangedAction.Add : NotifyCollectionChangedAction.Replace;
await UpdateCollectionAsync(grp, groupAction, groupIndex);
// Add time entry group.
var newIndex = GetEntryGroupIndex(entryGroup);
await UpdateCollectionAsync(entryGroup, NotifyCollectionChangedAction.Add, newIndex);
}
public async Task RemoveItemWithUndoAsync(int index)
{
// Get data holder
var timeEntryHolder = GetHolderFromIndex(index);
if (timeEntryHolder == null)
{
return;
}
// Remove previous if exists
if (LastRemovedItem != null)
{
await RemoveItemPermanentlyAsync(LastRemovedItem);
}
if (timeEntryHolder.State == TimeEntryState.Running)
{
await TimeEntryModel.StopAsync(timeEntryHolder.TimeEntryData);
}
LastRemovedItem = timeEntryHolder;
// Remove item only from list
await RemoveTimeEntryHolderAsync(timeEntryHolder);
// Create Undo timer
if (undoTimer != null)
{
undoTimer.Elapsed -= OnUndoTimeFinished;
undoTimer.Close();
}
// Using the correct timer.
undoTimer = new System.Timers.Timer((UndoSecondsInterval + 1) * 1000);
undoTimer.AutoReset = false;
undoTimer.Elapsed += OnUndoTimeFinished;
undoTimer.Start();
}
private async void OnUndoTimeFinished(object sender, ElapsedEventArgs e)
{
await RemoveItemPermanentlyAsync(LastRemovedItem);
LastRemovedItem = null;
}
protected virtual Task RemoveTimeEntryHolderAsync(TimeEntryHolder holder)
{
throw new NotImplementedException("You can't call this method in base class " + GetType().Name);
}
protected virtual async Task UpdateCollectionAsync(object data, NotifyCollectionChangedAction action, int newIndex, int oldIndex = -1, bool isRange = false)
{
if (updateMode != UpdateMode.Immediate)
{
return;
}
NotifyCollectionChangedEventArgs args;
if (isRange)
{
args = CollectionEventBuilder.GetRangeEvent(action, newIndex, oldIndex);
}
else
{
args = CollectionEventBuilder.GetEvent(action, newIndex, oldIndex);
}
// Update collection.
if (args.Action == NotifyCollectionChangedAction.Add)
{
if (args.NewItems.Count == 1 && data != null)
{
if (data is IDateGroup)
{
ItemCollection.Insert(args.NewStartingIndex, data);
}
else
{
var timeEntryList = GetListOfTimeEntries(data);
var newHolder = new TimeEntryHolder(timeEntryList);
await newHolder.LoadAsync();
ItemCollection.Insert(args.NewStartingIndex, newHolder);
}
}
else
{
var holderTaskList = new List <Task> ();
var currentItems = new List <object> (UpdatedList);
if (args.NewStartingIndex == 0)
{
ItemCollection.Clear();
}
for (int i = args.NewStartingIndex; i < args.NewStartingIndex + args.NewItems.Count; i++)
{
var item = currentItems [i];
if (item is IDateGroup)
{
ItemCollection.Insert(i, item);
}
else
{
var timeEntryList = GetListOfTimeEntries(item);
var timeEntryHolder = new TimeEntryHolder(timeEntryList);
ItemCollection.Insert(i, timeEntryHolder);
holderTaskList.Add(timeEntryHolder.LoadAsync());
}
}
await Task.WhenAll(holderTaskList);
}
}
if (args.Action == NotifyCollectionChangedAction.Move)
{
var savedItem = ItemCollection [args.OldStartingIndex];
ItemCollection.RemoveAt(args.OldStartingIndex);
ItemCollection.Insert(args.NewStartingIndex, savedItem);
}
if (args.Action == NotifyCollectionChangedAction.Remove)
{
ItemCollection.RemoveAt(args.OldStartingIndex);
}
if (args.Action == NotifyCollectionChangedAction.Replace)
{
if (data is IDateGroup)
{
ItemCollection [args.NewStartingIndex] = data;
}
else
{
var oldHolder = (TimeEntryHolder)ItemCollection.ElementAt(args.NewStartingIndex);
var timeEntryList = GetListOfTimeEntries(data);
await oldHolder.UpdateAsync(timeEntryList);
// Weird case,
// For further investigation
if (args.NewStartingIndex > ItemCollection.Count)
{
return;
}
ItemCollection [args.NewStartingIndex] = oldHolder;
}
}
// Dispatch Observable collection event.
var handler = CollectionChanged;
if (handler != null)
{
handler(this, args);
}
}
public void Bind(TimeEntryHolder datasource)
{
DataSource = datasource;
if (DataSource == null || Handle == IntPtr.Zero)
{
return;
}
var color = Color.Transparent;
var ctx = ServiceContainer.Resolve <Context> ();
if (!String.IsNullOrWhiteSpace(DataSource.ProjectName))
{
color = Color.ParseColor(ProjectModel.HexColors [DataSource.Color % ProjectModel.HexColors.Length]);
ProjectTextView.SetTextColor(color);
ProjectTextView.Text = DataSource.ProjectName;
}
else
{
ProjectTextView.Text = ctx.GetString(Resource.String.RecentTimeEntryNoProject);
ProjectTextView.SetTextColor(ctx.Resources.GetColor(Resource.Color.dark_gray_text));
}
if (String.IsNullOrWhiteSpace(DataSource.ClientName))
{
ClientTextView.Text = String.Empty;
ClientTextView.Visibility = ViewStates.Gone;
}
else
{
ClientTextView.Text = String.Format("{0} • ", DataSource.ClientName);
ClientTextView.Visibility = ViewStates.Visible;
}
if (String.IsNullOrWhiteSpace(DataSource.TaskName))
{
TaskTextView.Text = String.Empty;
TaskTextView.Visibility = ViewStates.Gone;
}
else
{
TaskTextView.Text = String.Format("{0} • ", DataSource.TaskName);
TaskTextView.Visibility = ViewStates.Visible;
}
if (String.IsNullOrWhiteSpace(DataSource.Description))
{
DescriptionTextView.Text = ctx.GetString(Resource.String.RecentTimeEntryNoDescription);
}
else
{
DescriptionTextView.Text = DataSource.Description;
}
BillableView.Visibility = DataSource.IsBillable ? ViewStates.Visible : ViewStates.Gone;
var shape = ColorView.Background as GradientDrawable;
if (shape != null)
{
shape.SetColor(color);
}
RebindTags();
RebindDuration();
}
protected async override Task RemoveTimeEntryHolderAsync(TimeEntryHolder holder)
{
await RemoveEntryAsync(holder.TimeEntryData);
}
protected async override Task AddTimeEntryHolderAsync(TimeEntryHolder holder)
{
await AddOrUpdateEntryAsync(holder.TimeEntryData);
}
