示例#1
0
        void GroupContacts(IEnumerable <ContactModel> list)
        {
            Contacts = new ObservableCollection <ObservableGroupCollection <ContactModel> >();

            foreach (var item in list.GroupBy((arg) => arg.LastName?.First()).OrderBy((arg) => arg.Key))
            {
                var group = new ObservableGroupCollection <ContactModel>()
                {
                    Key = item.Key?.ToString()?.ToUpper()
                };

                foreach (var x in item)
                {
                    group.Add(x);
                }

                Contacts.Add(group);
            }
        }
        public override void Init(object initData)
        {
            base.Init(initData);

            if (initData is CompanyModel)
            {
                Company = ((CompanyModel)initData);

                Contacts = new ObservableCollection <ObservableGroupCollection <ContactModel> >();

                var a = new ObservableGroupCollection <ContactModel>()
                {
                    Key = "Contacts"
                };

                foreach (var item in ((CompanyModel)initData).Contacts)
                {
                    a.Add(item);
                }

                Contacts.Add(a);
            }
        }
示例#3
0
        async void GetData()
        {
            IsLoading = true;


            var checkins = await StoreManager.CheckinStore.GetCheckinsByContactId(Contact.Contact.Id);

            var opportunities = await StoreManager.OpportunityStore.GetOpportunitiesByContactId(Contact.Contact.Id);

            var notes = await StoreManager.NoteStore.GetRemindersByContactId(Contact.Contact.Id);


            DetailSource = new ObservableCollection <ObservableGroupCollection <ContactDetailCellModel> >();

            var actions = new ObservableGroupCollection <ContactDetailCellModel>()
            {
                Key = "Actions à venir"
            };

            if (notes != null && notes.Any())
            {
                foreach (var item in notes)
                {
                    actions.Add(new ContactDetailCellModel(ContactDetailCellModelType.Action, item)
                    {
                        CellModelType = ContactDetailCellModelType.Action
                    });
                }
            }
            else
            {
                actions.Add(new ContactDetailCellModel(ContactDetailCellModelType.Empty, null));
            }


            var opportunity = new ObservableGroupCollection <ContactDetailCellModel>()
            {
                Key = "Opportunités", Detail = ""
            };

            if (opportunities != null && opportunities.Any())
            {
                opportunity.Detail = $"{opportunities.Count()} opportunités";

                long Total = 0;

                foreach (var item in opportunities)
                {
                    opportunity.Add(new ContactDetailCellModel(ContactDetailCellModelType.Opportunity, item)
                    {
                        TagColor = "#ff6565"
                    });
                    Total += item.Amount;
                }

                opportunity.Detail += $" - {Total} €";
            }
            else
            {
                opportunity.Add(new ContactDetailCellModel(ContactDetailCellModelType.Empty, null));
            }


            var activity = new ObservableGroupCollection <ContactDetailCellModel>()
            {
                Key = "Flux d’activités"
            };

            if (checkins != null && checkins.Any())
            {
                foreach (var item in checkins)
                {
                    var user = await StoreManager.UserStore.GetItemAsync(item.UserId);

                    var checkinType = await StoreManager.CheckinTypeStore.GetItemAsync(item.CheckinTypeId);

                    if (user != null)
                    {
                        item.UserName = user.Name;
                    }
                    if (checkinType != null)
                    {
                        item.Subject = checkinType.Name;
                    }

                    activity.Add(new ContactDetailCellModel(ContactDetailCellModelType.Activity, item)
                    {
                        CellModelType = ContactDetailCellModelType.Activity
                    });
                }
            }
            else
            {
                activity.Add(new ContactDetailCellModel(ContactDetailCellModelType.Empty, null));
            }

            DetailSource.Add(actions);
            DetailSource.Add(opportunity);
            DetailSource.Add(activity);

            IsLoading = false;
        }
        async void GetData()
        {
            IsLoading = true;

            var noti_data = await StoreManager.NotificationStore.GetNotificationsByUserId(Settings.UserId);

            Notifications = new ObservableCollection <ObservableGroupCollection <NotificationModel> >();


            var a = new ObservableGroupCollection <NotificationModel>()
            {
                Key = "Aujourd’hui"
            };

            foreach (var item in noti_data.Where((arg) => arg.DatabaseInsertAt.Date == DateTime.Now.Date))
            {
                a.Add(new NotificationModel(item));
            }


            var b = new ObservableGroupCollection <NotificationModel>()
            {
                Key = "Hier"
            };

            foreach (var item in noti_data.Where((arg) => arg.DatabaseInsertAt.Date == DateTime.Now.Date.AddDays(-1).Date))
            {
                b.Add(new NotificationModel(item));
            }

            if (a.Any())
            {
                Notifications.Add(a);
            }

            if (b.Any())
            {
                Notifications.Add(b);
            }


            var leftOverNotifications = noti_data.Where((arg) => arg.DatabaseInsertAt.Date != DateTime.Now.Date.AddDays(-1).Date&& arg.DatabaseInsertAt.Date != DateTime.Now.Date);


            var grouped = leftOverNotifications.OrderByDescending((arg) => arg.DatabaseInsertAt.Month).GroupBy((arg) => arg.DatabaseInsertAtMonth);

            foreach (var item in grouped)
            {
                var c = new ObservableGroupCollection <NotificationModel>()
                {
                    Key = item.Key
                };

                foreach (var x in item)
                {
                    c.Add(new NotificationModel(x));
                }

                Notifications.Add(c);
            }


            IsEmpty = !Notifications.Any();

            IsLoading = false;
        }
示例#5
0
        async Task GetData()
        {
            var contacts_data = await StoreManager.ContactStore.GetItemsAsync(true, true);

            var company_data = await StoreManager.CompanyStore.GetItemsAsync(true, true);

            #region Contacts

            Contacts = new ObservableCollection <ObservableGroupCollection <ContactModel> >();

            foreach (var item in contacts_data.GroupBy((arg) => arg.Lastname?.First()).OrderBy((arg) => arg.Key))
            {
                var group = new ObservableGroupCollection <ContactModel>()
                {
                    Key = item.Key?.ToString()?.ToUpper()
                };

                foreach (var x in item)
                {
                    ContactModel t;
                    group.Add(t = new ContactModel(x));
                }

                Contacts.Add(group);
            }

            #endregion

            #region Comapnies


            Companies = new ObservableCollection <ObservableGroupCollection <CompanyModel> >();

            foreach (var item in company_data?.Where((arg) => arg.Name != null).OrderBy((arg) => arg.Name))
            {
                var group = new ObservableGroupCollection <CompanyModel>()
                {
                    Key = item.Name?.First().ToString()?.ToUpper()
                };

                List <ContactModel> contacts = new List <ContactModel>();

                foreach (var x in Contacts)
                {
                    contacts.AddRange(x.Where((arg) => arg.Contact.CompanyId == item.Id));
                }

                group.Add(new CompanyModel(item)
                {
                    Contacts = new ObservableCollection <ContactModel>(contacts)
                });

                Companies.Add(group);
            }

            #endregion

            AllContacts = Contacts;

            AllCompanies = Companies;

            TabSelectedChanged(TabIndex);
        }
示例#6
0
        void Search()
        {
            if (TabIndex == 0)
            {
                if (!string.IsNullOrWhiteSpace(SearchText))
                {
                    List <ContactModel> search_results = new List <ContactModel>();

                    foreach (var item in AllContacts)
                    {
                        var res = item.Where((arg) => arg.Name.ToLower().Contains(SearchText.ToLower()));
                        search_results.AddRange(res);
                    }

                    Contacts = new ObservableCollection <ObservableGroupCollection <ContactModel> >();

                    foreach (var item in search_results.GroupBy((arg) => arg.LastName?.First()).OrderBy((arg) => arg.Key))
                    {
                        var group = new ObservableGroupCollection <ContactModel>()
                        {
                            Key = item.Key?.ToString()?.ToUpper()
                        };

                        foreach (var x in item)
                        {
                            group.Add(x);
                        }

                        Contacts.Add(group);
                    }
                }
                else
                {
                    Contacts = AllContacts;
                }
            }
            else
            {
                if (!string.IsNullOrWhiteSpace(SearchText))
                {
                    List <CompanyModel> search_results = new List <CompanyModel>();

                    foreach (var item in AllCompanies)
                    {
                        var res = item.Where((arg) => arg.CompanyName.ToLower().Contains(SearchText.ToLower()));
                        search_results.AddRange(res);
                    }

                    Companies = new ObservableCollection <ObservableGroupCollection <CompanyModel> >();

                    foreach (var item in search_results.GroupBy((arg) => arg.CompanyName?.First()).OrderBy((arg) => arg.Key))
                    {
                        var group = new ObservableGroupCollection <CompanyModel>()
                        {
                            Key = item.Key?.ToString()?.ToUpper()
                        };

                        foreach (var x in item)
                        {
                            group.Add(x);
                        }

                        Companies.Add(group);
                    }
                }
                else
                {
                    Companies = AllCompanies;
                }
            }

            FilterData();
        }