Beispiel #1
0
        private async void OnDataChange(DataChangeMessage msg)
        {
            var entry = msg.Data as TimeEntryData;

            if (entry == null)
            {
                return;
            }

            // Save message to async buffer
            await bufferBlock.SendAsync(msg);

            if (isUpdatingCollection)
            {
                return;
            }

            isUpdatingCollection = true;

            // Get messages from async buffer
            while (bufferBlock.Count > 0)
            {
                var receivedMsg = await bufferBlock.ReceiveAsync();
                await ProcessUpdateMessage(receivedMsg);
            }

            isUpdatingCollection = false;
        }
Beispiel #2
0
 private void OnDataChange(DataChangeMessage msg)
 {
     if (User.Matches(msg.Data))
     {
         User = new UserData((UserData)msg.Data);
     }
 }
Beispiel #3
0
 private void OnDataChange(DataChangeMessage msg)
 {
     if (msg.Data is TagData)
     {
         OnDataChange((TagData)msg.Data, msg.Action);
     }
     else if (msg.Data is TimeEntryTagData)
     {
         OnDataChange((TimeEntryTagData)msg.Data, msg.Action);
     }
 }
        private void OnDataChange(DataChangeMessage msg)
        {
            var dataObject = msg.Data as CommonData;

            if (dataObject != null)
            {
                if (!dataObject.IsDirty || dataObject.RemoteRejected)
                {
                    return;
                }
            }

            Run(SyncMode.Auto);
        }
Beispiel #5
0
        private async Task ProcessUpdateMessage(DataChangeMessage msg)
        {
            var entry      = msg.Data as TimeEntryData;
            var isExcluded = entry.DeletedAt != null ||
                             msg.Action == DataAction.Delete ||
                             entry.State == TimeEntryState.New;

            if (isExcluded)
            {
                await RemoveEntryAsync(entry);
            }
            else
            {
                await AddOrUpdateEntryAsync(new TimeEntryData (entry));
            }
        }
Beispiel #6
0
        private void OnDataChange(DataChangeMessage msg)
        {
            if (data.Matches(msg.Data))
            {
                var updatedData = (T)msg.Data;
                var isDeleted   = msg.Action == DataAction.Delete ||
                                  updatedData.DeletedAt != null;

                if (isDeleted)
                {
                    ResetIds();
                }
                else
                {
                    Data = Duplicate(updatedData);
                }
            }
        }
Beispiel #7
0
        private void OnDataChange(DataChangeMessage msg)
        {
            var entry = msg.Data as TimeEntryData;

            if (entry == null)
            {
                return;
            }

            var isExcluded = entry.DeletedAt != null ||
                             msg.Action == DataAction.Delete ||
                             entry.State == TimeEntryState.New;

            if (isExcluded)
            {
                RemoveEntry(entry);
            }
            else
            {
                AddOrUpdateEntry(new TimeEntryData(entry));
            }
        }
Beispiel #8
0
        private void OnDataChange(DataChangeMessage msg)
        {
            var clientData = msg.Data as ClientData;

            if (clientData == null)
            {
                return;
            }

            var isExcluded = msg.Action == DataAction.Delete ||
                             clientData.DeletedAt.HasValue ||
                             clientData.WorkspaceId != workspaceId;
            var existingData = dataObjects.FirstOrDefault(r => r.Matches(clientData));

            if (isExcluded)
            {
                if (existingData != null)
                {
                    dataObjects.Remove(existingData);
                    OnUpdated();
                }
            }
            else
            {
                clientData = new ClientData(clientData);

                if (existingData == null)
                {
                    dataObjects.Add(clientData);
                }
                else
                {
                    dataObjects.UpdateData(clientData);
                }

                Sort();
                OnUpdated();
            }
        }
Beispiel #9
0
 private void OnDataChange(DataChangeMessage msg)
 {
     if (msg.Data is UserData)
     {
         OnDataChange((UserData)msg.Data);
     }
     else if (msg.Data is WorkspaceData)
     {
         OnDataChange((WorkspaceData)msg.Data, msg.Action);
     }
     else if (msg.Data is ProjectData)
     {
         OnDataChange((ProjectData)msg.Data, msg.Action);
     }
     else if (msg.Data is TaskData)
     {
         OnDataChange((TaskData)msg.Data, msg.Action);
     }
     else if (msg.Data is ClientData)
     {
         OnDataChange((ClientData)msg.Data, msg.Action);
     }
 }
        private void OnDataChange(DataChangeMessage msg)
        {
            var entry = msg.Data as TimeEntryData;

            if (entry == null)
            {
                return;
            }

            var authManager = ServiceContainer.Resolve <AuthManager> ();
            var isExcluded  = msg.Action == DataAction.Delete ||
                              entry.DeletedAt.HasValue ||
                              entry.State == TimeEntryState.New ||
                              entry.StartTime < queryStartDate ||
                              entry.UserId != authManager.GetUserId();

            Group         grp;
            TimeEntryData existingEntry;

            if (data.Find(entry, out grp, out existingEntry))
            {
                if (isExcluded)
                {
                    grp.Remove(entry);
                    if (grp.IsEmpty)
                    {
                        data.Remove(grp);
                    }
                    else
                    {
                        data.Sort();
                    }
                    OnUpdated();
                }
                else
                {
                    var groupChanged = !grp.CanContain(entry);

                    if (groupChanged)
                    {
                        // Remove from old group:
                        grp.Remove(entry);
                        if (grp.IsEmpty)
                        {
                            data.Remove(grp);
                        }

                        // Add entry to correct group
                        data.Add(entry);
                        data.Sort();
                        OnUpdated();
                    }
                    else
                    {
                        // Update group and resort data:
                        grp.Update(entry);
                        data.Sort();
                        OnUpdated();
                    }
                }
            }
            else if (!isExcluded)
            {
                data.Add(entry);
                data.Sort();
                OnUpdated();
            }
        }
Beispiel #11
0
 void OnDataChange(DataChangeMessage obj)
 {
     Items = _dataService.GetCheckListItems(_checkList);
 }
Beispiel #12
0
 void OnDataChange(DataChangeMessage obj)
 {
     Items = _dataService.AllItems();
 }