Esempio n. 1
0
        private void ImportContacts(GoogleContact gc, List<ImportModel> contacts)
        {
            var person = Query(new PersonByUserId {UserId = GetCurrentUserId()});

            var existingPeople = Query(new PeopleAlreadyImported
                {
                    Emails = new HashSet<string>(from m in contacts.Distinct()
                                                 select m.EmailAddress.ToLower())
                });

            using (var bulkInsert = Store.BulkInsert())
            {
                foreach (var importModel in contacts)
                {
                    //don't import yourself
                    if (importModel.EmailAddress.ToLower() == User.Identity.Name) continue;

                    //if we already have a person record for this address
                    if (existingPeople.ContainsKey(importModel.EmailAddress.ToLower())) continue;

                    var newPerson = new Person
                    {
                        EmailAddress = importModel.EmailAddress.ToLower(),
                        Name = importModel.Name,
                        Id = Guid.NewGuid().ToString(),
                        Friends = new List<Friend>
                            {
                                new Friend
                                    {
                                        PersonId = person.Id,
                                        Rating = 0
                                    }
                            }
                    };
                    bulkInsert.Store(newPerson);
                    existingPeople.Add(newPerson.EmailAddress, newPerson);
                }

                person.Friends = person.Friends.Union(from i in contacts
                                                      let email = i.EmailAddress.ToLower()
                                                  where !person.Friends.Any(f => f.PersonId == existingPeople[email].Id)
                                                  select new Friend
                                                  {
                                                      PersonId = existingPeople[email].Id
                                                  }).ToList();
            }
            RavenSession.Delete(gc);
        }
Esempio n. 2
0
        private ActionResult OAuthCallback()
        {
            IAuthorizationState auth = client.ProcessUserAuthorization(Request);
            Session["auth"] = auth;
            var authFactory = new GAuthSubRequestFactory("cp", "Geeks Dilemma") {Token = auth.AccessToken};
            var service = new ContactsService(authFactory.ApplicationName) {RequestFactory = authFactory};

            var query = new ContactsQuery(ContactsQuery.CreateContactsUri("default"));
            query.NumberToRetrieve = 1000;
            ContactsFeed contacts = service.Query(query);
            ViewBag.ImportFrom = "Google";
            var userId = GetCurrentUserId();

            DeletePreviousImportIfNecessary(userId);

            var googleContact = new GoogleContact
                {
                    UserId = userId,
                    Contacts = (from ContactEntry entry in contacts.Entries
                                from email in entry.Emails
                                where entry.Name != null
                                where email != null
                                select new ImportModel
                                    {
                                        Import = false,
                                        EmailAddress = email.Address.ToLower(),
                                        Name = entry.Name.FullName
                                    }).ToList()
                };

            RavenSession.Store(googleContact);

            return View("Import");
        }
Esempio n. 3
0
        private List<ImportModel> GetImportModels(GoogleContact contact,
            out int totalPages,
            int pageIndex = 0, 
            int pageSize = 10, 
            string search = null)
        {
            var result = (from im in contact.Contacts
                          where (string.IsNullOrEmpty(search)
                              || (im.Name != null && im.Name.Contains(search))
                              || (im.EmailAddress != null && im.EmailAddress.Contains(search)))
                          select im).OrderBy(friend => friend.Name);

            totalPages = (int)Math.Ceiling((double)result.Count() / pageSize);
            return result.Skip(pageIndex * pageSize).Take(pageSize).ToList();
        }