Example #1
0
        /// <summary>
        /// 获取联系人
        /// </summary>
        private async void GetContacts()
        {
            //创建联系人存储
            conStore = await ContactStore.CreateOrOpenAsync();

            //联系人查询的结果
            conQueryResult = conStore.CreateContactQuery();
            //联系人集合
            conList = await conQueryResult.GetContactsAsync();

            //显示联系人的集合

            List <Item> list = new List <Item>();

            foreach (StoredContact storCon in conList)
            {
                var properties = await storCon.GetPropertiesAsync();

                list.Add(new Item
                {
                    Name = storCon.GivenName,
                    Id   = storCon.Id
                });
            }
            conListBox.ItemsSource = list;
        }
Example #2
0
        private async void  GetContact(string p)
        {
            //创建联系人存储
            conStore = await ContactStore.CreateOrOpenAsync();

            //联系人查询结果
            ContactQueryResult conQueryResult = conStore.CreateContactQuery();
            //查询联系人
            IReadOnlyList <StoredContact> conList = await conQueryResult.GetContactsAsync();

            List <Item> list = new List <Item>();

            foreach (StoredContact strCon in conList)
            {
                if (strCon.GivenName.Contains(p))
                {
                    list.Add(new Item
                    {
                        Name = strCon.GivenName,
                        Id   = strCon.Id,
                    });
                }
            }
            conListBox.ItemsSource = list;
        }
        private async void FindAndLoadContact(string givenName, string familyName)
        {
            ContactQueryOptions options = new ContactQueryOptions();

            options.OrderBy = ContactQueryResultOrdering.GivenNameFamilyName;
            options.DesiredFields.Clear();
            options.DesiredFields.Add(KnownContactProperties.GivenName);
            options.DesiredFields.Add(KnownContactProperties.FamilyName);
            options.DesiredFields.Add(KnownContactProperties.Email);
            options.DesiredFields.Add(KnownContactProperties.Telephone);

            ContactQueryResult            query    = store.CreateContactQuery(options);
            IReadOnlyList <StoredContact> contacts = await query.GetContactsAsync();

            contact = contacts.First(item =>
                                     item.GivenName == givenName && item.FamilyName == familyName);

            IDictionary <string, object> props = await contact.GetPropertiesAsync();

            firstNameInput.Text = contact.GivenName;
            lastNameInput.Text  = contact.FamilyName;
            if (props.ContainsKey(KnownContactProperties.Email))
            {
                emailInput.Text = (string)props[KnownContactProperties.Email];
            }
            if (props.ContainsKey(KnownContactProperties.Telephone))
            {
                phoneInput.Text = (string)props[KnownContactProperties.Telephone];
            }
        }
Example #4
0
        /// <summary>
        /// Retrieve list of contacts from the store
        /// </summary>
        /// <param name="parameters"></param>
        async public void GetContactsFromStore(string parameters)
        {
            store = await ContactStore.CreateOrOpenAsync(ContactStoreSystemAccessMode.ReadWrite, ContactStoreApplicationAccessMode.ReadOnly);

            ContactQueryOptions options = new ContactQueryOptions();

            options.DesiredFields.Add(KnownContactProperties.Email);
            options.DesiredFields.Add(KnownContactProperties.Address);
            options.DesiredFields.Add(KnownContactProperties.Telephone);

            ContactQueryResult result = store.CreateContactQuery(options);

            IReadOnlyList <StoredContact> contacts = await result.GetContactsAsync();

            string jsContacts = "AppMobi.people = [";

            foreach (StoredContact con in contacts)
            {
                IDictionary <string, object> temps = await con.GetPropertiesAsync();

                string displayName = "";
                Windows.Phone.PersonalInformation.ContactAddress address;
                string familyName = "";
                string givenName  = "";
                string email      = "";
                string telephone  = "";

                if (temps.ContainsKey("DisplayName"))
                {
                    displayName = (string)temps["DisplayName"];
                }

                if (temps.ContainsKey("Address"))
                {
                    address = (Windows.Phone.PersonalInformation.ContactAddress)temps["Address"];
                }

                if (temps.ContainsKey("FamilyName"))
                {
                    familyName = (string)temps["FamilyName"];
                }

                if (temps.ContainsKey("GivenName"))
                {
                    givenName = (string)temps["GivenName"];
                }

                if (temps.ContainsKey("Email"))
                {
                    email = (string)temps["Email"];
                }

                if (temps.ContainsKey("Telephone"))
                {
                    telephone = (string)temps["Telephone"];
                }
            }

            jsContacts += "];";
        }
Example #5
0
        public async Task <string> GetUserIdsMd5InStore()
        {
            logger.debug("Loading saved user ids...");
            ContactStore store = await ContactStore.CreateOrOpenAsync();

            ContactQueryResult            result   = store.CreateContactQuery();
            IReadOnlyList <StoredContact> contacts = await result.GetContactsAsync();

            List <int> userIds = new List <int>();

            foreach (var storedContact in contacts)
            {
                userIds.Add(int.Parse(storedContact.RemoteId));
            }

            userIds.Sort();
            string sortedStr = userIds.Aggregate("", (current, userId) => current + (userId + ","));

            if (sortedStr != "")
            {
                sortedStr = sortedStr.Substring(0, sortedStr.Length - 1);
                logger.debug("sorted str is {0}", sortedStr);
                return(MD5.GetMd5String(sortedStr));
            }

            return("");
        }
Example #6
0
        private static async void CleanContacts()
        {
            ContactStore store = await ContactStore.CreateOrOpenAsync();

            ContactQueryResult            result   = store.CreateContactQuery();
            IReadOnlyList <StoredContact> contacts = await result.GetContactsAsync();

            foreach (var contact in contacts)
            {
                await store.DeleteContactAsync(contact.Id);
            }
        }
Example #7
0
        public static async Task <IReadOnlyList <StoredContact> > GetContactsFromPhoneAsync(CancellationToken token)
        {
            token.ThrowIfCancellationRequested();
            ContactStore store = await ContactStore.CreateOrOpenAsync();

            token.ThrowIfCancellationRequested();
            ContactQueryResult result = store.CreateContactQuery();

            token.ThrowIfCancellationRequested();
            IReadOnlyList <StoredContact> contacts = await result.GetContactsAsync();

            token.ThrowIfCancellationRequested();
            return(contacts);
        }
        private async void GetFriends()
        {
            ContactStore store = await ContactStore.CreateOrOpenAsync();

            ContactQueryResult result = store.CreateContactQuery();



            IReadOnlyList <StoredContact> contacts = await result.GetContactsAsync();

            friendList.Clear();

            foreach (var storedContact in contacts)
            {
                UserModel user = TelegramSession.Instance.GetUser(int.Parse(storedContact.RemoteId));
                friendList.Add(user);
            }
        }
Example #9
0
 /// <summary>
 /// 获取联系人列表
 /// </summary>
 private async void GetContacts()
 {
     conStore = await ContactStore.CreateOrOpenAsync();
     ContactQueryResult conQueryResult = conStore.CreateContactQuery();
     //查询联系人
     IReadOnlyList<StoredContact> conList = await conQueryResult.GetContactsAsync();
     List<Item> list = new List<Item>();
     foreach (StoredContact storCon in conList)
     {
         var properties = await storCon.GetPropertiesAsync();
         list.Add(new Item 
         {
             Name=storCon .GivenName ,
             Id =storCon .Id ,
         });
     }
     conListBox.ItemsSource = list;
 }
Example #10
0
 /// <summary>
 /// 获取联系人
 /// </summary>
 private async void GetContacts()
 {
     //创建联系人存储
     conStore = await ContactStore.CreateOrOpenAsync();
     //联系人查询的结果
     conQueryResult = conStore.CreateContactQuery();
     //联系人集合
     conList = await conQueryResult.GetContactsAsync();
     //显示联系人的集合
    
     List<Item> list = new List<Item>();
     foreach (StoredContact storCon in conList)
     {
         var properties = await storCon.GetPropertiesAsync();
         list.Add(new Item
             {
                 Name = storCon.GivenName,
                 Id =storCon .Id 
             });
     }
     conListBox.ItemsSource = list;
 }    
Example #11
0
 private async void GetContact(string p)
 {
     //创建联系人存储
     conStore = await ContactStore.CreateOrOpenAsync();
     //联系人查询结果
     ContactQueryResult conQueryResult = conStore.CreateContactQuery();
     //查询联系人
     IReadOnlyList<StoredContact> conList = await conQueryResult.GetContactsAsync();
     List<Item> list = new List<Item>();
     foreach (StoredContact strCon in conList)
     {
         if (strCon.GivenName.Contains(p))
         {
             list.Add(new Item
             {
                 Name = strCon.GivenName,
                 Id = strCon.Id,
             });
         }
     }
     conListBox.ItemsSource = list;
 }
Example #12
0
        /// <summary>
        /// 获取联系人列表
        /// </summary>
        private async void GetContacts()
        {
            conStore = await ContactStore.CreateOrOpenAsync();

            ContactQueryResult conQueryResult = conStore.CreateContactQuery();
            //查询联系人
            IReadOnlyList <StoredContact> conList = await conQueryResult.GetContactsAsync();

            List <Item> list = new List <Item>();

            foreach (StoredContact storCon in conList)
            {
                var properties = await storCon.GetPropertiesAsync();

                list.Add(new Item
                {
                    Name = storCon.GivenName,
                    Id   = storCon.Id,
                });
            }
            conListBox.ItemsSource = list;
        }
Example #13
0
        public async Task SyncContactsAsync(List <User> friendsList)
        {
            if (this._synching || this._deleting)
            {
                return;
            }
            this._synching = true;
            friendsList    = friendsList.Take <User>(ContactsManager.MAX_FRIENDS_TO_SYNC).ToList <User>();
            long initiallyLoggedInUser = AppGlobalStateManager.Current.LoggedInUserId;

            try
            {
                SavedContacts savedContacts = await this.GetSavedList();

                List <User>         savedList = savedContacts.SavedUsers;
                Func <User, string> getKey    = (Func <User, string>)(u => u.uid.ToString());

                List <Tuple <User, User> > updatedUsersTuples;
                List <User> createdUsers;
                List <User> deletedUsers;

                ListUtils.GetListChanges <User>(savedList, friendsList, getKey, (Func <User, User, bool>)((u1, u2) =>
                {
                    if (ContactsManager.AreStringsEqualOrNullEmpty(u1.first_name, u2.first_name) && ContactsManager.AreStringsEqualOrNullEmpty(u1.last_name, u2.last_name) && (ContactsManager.AreStringsEqualOrNullEmpty(u1.mobile_phone, u2.mobile_phone) && ContactsManager.AreStringsEqualOrNullEmpty(u1.home_phone, u2.home_phone)) && (ContactsManager.AreStringsEqualOrNullEmpty(u1.site, u2.site) && ContactsManager.AreStringsEqualOrNullEmpty(u1.bdate, u2.bdate)))
                    {
                        return(ContactsManager.AreStringsEqualOrNullEmpty(u1.photo_max, u2.photo_max));
                    }
                    return(false);
                }), out updatedUsersTuples, out createdUsers, out deletedUsers);

                Logger.Instance.Info("ContactsManager got {0} updated users, {1} new users, {2} deleted users", updatedUsersTuples.Count, createdUsers.Count, deletedUsers.Count);
                int totalCountToSync = createdUsers.Count;
                int currentSyncing   = 0;
                if (initiallyLoggedInUser != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                {
                    await this.DoDeleteAllContactsAsync();
                }
                else
                {
                    ContactStore contactStore = await ContactStore.CreateOrOpenAsync();

                    await this.EnsureProvisioned(contactStore);

                    StoredContact meContact = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(AppGlobalStateManager.Current.GlobalState.LoggedInUser));

                    if (meContact != null)
                    {
                        await this.SetContactProperties(meContact, AppGlobalStateManager.Current.GlobalState.LoggedInUser, (User)null);

                        await meContact.SaveAsync();
                    }
                    contactStore.CreateContactQuery();
                    foreach (Tuple <User, User> tuple in updatedUsersTuples)
                    {
                        User updUser      = tuple.Item2;
                        User originalUser = tuple.Item1;
                        if (initiallyLoggedInUser != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                        {
                            await this.DoDeleteAllContactsAsync();

                            return;
                        }
                        try
                        {
                            StoredContact contact = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(updUser));

                            await this.SetContactProperties(contact, updUser, originalUser);

                            if (contact != null)
                            {
                                await contact.SaveAsync();
                            }
                            contact = null;
                        }
                        catch (Exception ex)
                        {
                            Logger.Instance.Error("Failed to update contact for user " + updUser.Name, ex);
                        }
                        updUser      = (User)null;
                        originalUser = (User)null;
                    }
                    //List<Tuple<User, User>>.Enumerator enumerator1 = new List<Tuple<User, User>>.Enumerator();
                    foreach (User user in createdUsers)
                    {
                        User newUser = user;
                        ++currentSyncing;
                        if (initiallyLoggedInUser != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                        {
                            await this.DoDeleteAllContactsAsync();

                            return;
                        }
                        try
                        {
                            if (await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(newUser)) == null)
                            {
                                Stopwatch sw = Stopwatch.StartNew();
                                this.FireSyncStatusChanged(currentSyncing, totalCountToSync);
                                Logger.Instance.Info("ContactsManager begin creating user");
                                StoredContact contact = new StoredContact(contactStore);
                                await this.SetContactProperties(contact, newUser, null);

                                await contact.SaveAsync();

                                Logger.Instance.Info("ContactsManager end creating user");
                                sw.Stop();
                                long num = 500L - sw.ElapsedMilliseconds;
                                if (num > 0L)
                                {
                                    await Task.Delay((int)num);
                                }
                                sw      = null;
                                contact = null;
                            }
                            savedList.Add(newUser);
                        }
                        catch (Exception ex)
                        {
                            Logger.Instance.Error("Failed to create contact for user " + newUser.Name, ex);
                        }
                        newUser = null;
                    }
                    //List<User>.Enumerator enumerator2 = new List<User>.Enumerator();
                    foreach (User user in deletedUsers)
                    {
                        User deletedUser = user;
                        if (initiallyLoggedInUser != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                        {
                            await this.DoDeleteAllContactsAsync();

                            return;
                        }
                        try
                        {
                            StoredContact contactByRemoteIdAsync = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(deletedUser));

                            if (contactByRemoteIdAsync != null)
                            {
                                await contactStore.DeleteContactAsync(contactByRemoteIdAsync.Id);
                            }
                            savedList.Remove(deletedUser);
                        }
                        catch (Exception ex)
                        {
                            Logger.Instance.Error("Failed to delete contact for user " + deletedUser.Name, ex);
                        }
                        deletedUser = null;
                    }
                    //enumerator2 = new List<User>.Enumerator();
                    savedContacts.SyncedDate = DateTime.UtcNow;
                    await this.EnsurePersistSavedContactsAsync();

                    savedContacts      = null;
                    savedList          = null;
                    deletedUsers       = null;
                    createdUsers       = null;
                    updatedUsersTuples = null;
                    contactStore       = null;
                    meContact          = null;
                }
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("Failed to sync contacts. ", ex);
            }
            finally
            {
                this._synching = false;
                this.FireSyncStatusChanged(0, 0);
            }
        }
Example #14
0
        public async Task SyncContactsAsync(List <User> friendsList)
        {
            if (!this._synching && !this._deleting)
            {
                this._synching = true;
                friendsList    = Enumerable.ToList <User>(Enumerable.Take <User>(friendsList, ContactsManager.MAX_FRIENDS_TO_SYNC));
                long loggedInUserId = AppGlobalStateManager.Current.LoggedInUserId;
                try
                {
                    SavedContacts savedContacts = await this.GetSavedList();

                    SavedContacts       savedContacts2 = savedContacts;
                    List <User>         list           = savedContacts2.SavedUsers;
                    List <User>         arg_1E7_0      = list;
                    List <User>         arg_1E7_1      = friendsList;
                    Func <User, string> arg_1E7_2      = new Func <User, string>((u) => { return(u.uid.ToString()); });

                    Func <User, User, bool> arg_1E7_3 = new Func <User, User, bool>((u1, u2) =>
                    {
                        return(ContactsManager.AreStringsEqualOrNullEmpty(u1.first_name, u2.first_name) && ContactsManager.AreStringsEqualOrNullEmpty(u1.last_name, u2.last_name) && ContactsManager.AreStringsEqualOrNullEmpty(u1.mobile_phone, u2.mobile_phone) && ContactsManager.AreStringsEqualOrNullEmpty(u1.home_phone, u2.home_phone) && ContactsManager.AreStringsEqualOrNullEmpty(u1.site, u2.site) && ContactsManager.AreStringsEqualOrNullEmpty(u1.bdate, u2.bdate) && ContactsManager.AreStringsEqualOrNullEmpty(u1.photo_max, u2.photo_max));
                    });

                    List <Tuple <User, User> > list2;
                    List <User> list3;
                    List <User> list4;
                    ListUtils.GetListChanges <User>(arg_1E7_0, arg_1E7_1, arg_1E7_2, arg_1E7_3, out list2, out list3, out list4);
                    Logger.Instance.Info("ContactsManager got {0} updated users, {1} new users, {2} deleted users", new object[]
                    {
                        list2.Count,
                        list3.Count,
                        list4.Count
                    });
                    int count = list3.Count;
                    int num   = 0;
                    if (loggedInUserId != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                    {
                        await this.DoDeleteAllContactsAsync();
                    }
                    else
                    {
                        ContactStore contactStore = await ContactStore.CreateOrOpenAsync();

                        await this.EnsureProvisioned(contactStore);

                        StoredContact storedContact = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(AppGlobalStateManager.Current.GlobalState.LoggedInUser));

                        if (storedContact != null)
                        {
                            await this.SetContactProperties(storedContact, AppGlobalStateManager.Current.GlobalState.LoggedInUser, null);

                            await storedContact.SaveAsync();
                        }
                        contactStore.CreateContactQuery();
                        List <Tuple <User, User> > .Enumerator enumerator = list2.GetEnumerator();
                        //int num2;
                        try
                        {
                            while (enumerator.MoveNext())
                            {
                                Tuple <User, User> var_8_57F = enumerator.Current;
                                User user         = var_8_57F.Item2;
                                User originalUser = var_8_57F.Item1;
                                if (loggedInUserId != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                                {
                                    await this.DoDeleteAllContactsAsync();

                                    return;
                                }
                                try
                                {
                                    StoredContact storedContact2 = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(user));

                                    await this.SetContactProperties(storedContact2, user, originalUser);

                                    if (storedContact2 != null)
                                    {
                                        await storedContact2.SaveAsync();
                                    }
                                    storedContact2 = null;
                                }
                                catch (Exception var_9_7B5)
                                {
                                    Logger.Instance.Error("Failed to update contact for user " + user.Name, var_9_7B5);
                                }
                                user         = null;
                                originalUser = null;
                            }
                        }
                        finally
                        {
                            //if (num2 < 0)
                            //{
                            enumerator.Dispose();
                            //}
                        }
                        enumerator = default(List <Tuple <User, User> > .Enumerator);
                        List <User> .Enumerator enumerator2 = list3.GetEnumerator();
                        try
                        {
                            while (enumerator2.MoveNext())
                            {
                                User user2 = enumerator2.Current;
                                num++;
                                if (loggedInUserId != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                                {
                                    await this.DoDeleteAllContactsAsync();

                                    return;
                                }
                                try
                                {
                                    if (await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(user2)) == null)//todo:bug?
                                    {
                                        Stopwatch stopwatch = Stopwatch.StartNew();
                                        this.FireSyncStatusChanged(num, count);
                                        Logger.Instance.Info("ContactsManager begin creating user", new object[0]);
                                        StoredContact storedContact3 = new StoredContact(contactStore);
                                        await this.SetContactProperties(storedContact3, user2, null);

                                        await storedContact3.SaveAsync();

                                        Logger.Instance.Info("ContactsManager end creating user", new object[0]);
                                        stopwatch.Stop();
                                        long var_11_AF3 = 500L - stopwatch.ElapsedMilliseconds;
                                        if (var_11_AF3 > 0L)
                                        {
                                            await Task.Delay((int)var_11_AF3);
                                        }
                                        stopwatch      = null;
                                        storedContact3 = null;
                                    }
                                    list.Add(user2);
                                }
                                catch (Exception var_12_B82)
                                {
                                    Logger.Instance.Error("Failed to create contact for user " + user2.Name, var_12_B82);
                                }
                                user2 = null;
                            }
                        }
                        finally
                        {
                            //if (num2 < 0)
                            //{
                            enumerator2.Dispose();
                            //}
                        }
                        enumerator2 = default(List <User> .Enumerator);
                        enumerator2 = list4.GetEnumerator();
                        try
                        {
                            while (enumerator2.MoveNext())
                            {
                                User user3 = enumerator2.Current;
                                if (loggedInUserId != AppGlobalStateManager.Current.LoggedInUserId || !AppGlobalStateManager.Current.GlobalState.SyncContacts)
                                {
                                    await this.DoDeleteAllContactsAsync();

                                    return;
                                }
                                try
                                {
                                    StoredContact var_13_D35 = await contactStore.FindContactByRemoteIdAsync(ContactsManager.GetRemoteId(user3));

                                    if (var_13_D35 != null)
                                    {
                                        await contactStore.DeleteContactAsync(var_13_D35.Id);
                                    }
                                    list.Remove(user3);
                                }
                                catch (Exception var_14_DBF)
                                {
                                    Logger.Instance.Error("Failed to delete contact for user " + user3.Name, var_14_DBF);
                                }
                                user3 = null;
                            }
                        }
                        finally
                        {
                            //if (num2 < 0)
                            //{
                            enumerator2.Dispose();
                            //}
                        }
                        enumerator2 = default(List <User> .Enumerator);
                        savedContacts2.SyncedDate = DateTime.UtcNow;
                        await this.EnsurePersistSavedContactsAsync();

                        savedContacts2 = null;
                        list           = null;
                        list4          = null;
                        list3          = null;
                        list2          = null;
                        contactStore   = null;
                        storedContact  = null;
                    }
                }
                catch (Exception var_15_ECB)
                {
                    Logger.Instance.Error("Failed to sync contacts. ", var_15_ECB);
                }
                finally
                {
                    //int num2;
                    //if (num2 < 0)
                    //{
                    this._synching = false;
                    this.FireSyncStatusChanged(0, 0);
                    //}
                }
            }
        }