/// <summary> /// Get the existing sync state for this item, if it exists and is of the appropriate /// type, else null. /// </summary> /// <remarks>Outlook items are not true objects and don't have a common superclass, /// so we have to use this rather clumsy overloading.</remarks> /// <param name="contact">The item.</param> /// <returns>The appropriate sync state, or null if none.</returns> /// <exception cref="UnexpectedSyncStateClassException">if the sync state found is not of the expected class (shouldn't happen).</exception> public ContactSyncState GetSyncState(Outlook.ContactItem contact) { SyncState result = this.byOutlookId.ContainsKey(contact.EntryID) ? this.byOutlookId[contact.EntryID] : null; CrmId crmId = CheckForDuplicateSyncState(result, contact.GetCrmId()); if (CrmId.IsValid(crmId)) { if (result == null && this.byCrmId.ContainsKey(crmId)) { result = this.byCrmId[crmId]; } else if (result != null && this.byCrmId.ContainsKey(crmId) == false) { this.byCrmId[crmId] = result; result.CrmEntryId = crmId; } } if (result != null && result as ContactSyncState == null) { throw new UnexpectedSyncStateClassException("ContactSyncState", result); } return(result as ContactSyncState); }
/// <summary> /// Get the existing sync state for this item, if it exists and is of the appropriate /// type, else null. /// </summary> /// <remarks>Outlook items are not true objects and don't have a common superclass, /// so we have to use this rather clumsy overloading.</remarks> /// <param name="appointment">The item.</param> /// <returns>The appropriate sync state, or null if none.</returns> /// <exception cref="UnexpectedSyncStateClassException">if the sync state found is not of the expected class (shouldn't happen).</exception> public AppointmentSyncState GetSyncState(Outlook.AppointmentItem appointment) { SyncState result = this.byOutlookId.ContainsKey(appointment.EntryID) ? this.byOutlookId[appointment.EntryID] : null; CrmId crmId = result == null?appointment.GetCrmId() : CheckForDuplicateSyncState(result, appointment.GetCrmId()); if (CrmId.IsValid(crmId)) { if (result == null && this.byCrmId.ContainsKey(crmId)) { result = this.byCrmId[crmId]; } else if (result != null && this.byCrmId.ContainsKey(crmId) == false) { this.byCrmId[crmId] = result; result.CrmEntryId = crmId; } } if (result != null && !(result is AppointmentSyncState)) { throw new UnexpectedSyncStateClassException("AppointmentSyncState", result); } return(result as AppointmentSyncState); }
private bool TryAddRecipientInModule(string moduleName, CrmId meetingId, Outlook.Recipient recipient) { bool result; CrmId id = SetCrmRelationshipFromOutlook(this, meetingId, recipient, moduleName); if (CrmId.IsValid(id)) { string smtpAddress = recipient.GetSmtpAddress(); this.CacheAddressResolutionData( new AddressResolutionData(moduleName, id, smtpAddress)); CrmId accountId = CrmId.Get(RestAPIWrapper.GetRelationship( ContactSynchroniser.CrmModule, id.ToString(), "accounts")); if (CrmId.IsValid(accountId) && SetCrmRelationshipFromOutlook(this, meetingId, "Accounts", accountId)) { this.CacheAddressResolutionData( new AddressResolutionData("Accounts", accountId, smtpAddress)); } result = true; } else { result = false; } return(result); }
/// <summary> /// Find all CRM records related to this recipient of this meeting, and produce address /// resolution data from them. /// </summary> /// <param name="olItem">An appointment, assumed to be a meeting.</param> /// <param name="recipient">A recipient of that meeting request.</param> /// <returns>A list of address resolution objects.</returns> private List <AddressResolutionData> ResolveRecipient(Outlook.AppointmentItem olItem, Outlook.Recipient recipient) { List <AddressResolutionData> result = new List <AddressResolutionData>(); var smtpAddress = recipient.GetSmtpAddress(); Log.Info($"recepientName= {recipient.Name}, recepient= {smtpAddress}"); if (this.meetingRecipientsCache.ContainsKey(smtpAddress)) { result.AddRange(meetingRecipientsCache[smtpAddress]); } else { CrmId meetingId = olItem.GetCrmId(); Dictionary <string, CrmId> moduleIds = new Dictionary <string, CrmId>(); if (CrmId.IsValid(meetingId)) { foreach (string moduleName in new string[] { "Leads", "Users", ContactSynchroniser.CrmModule }) { CrmId moduleId = this.GetInviteeIdBySmtpAddress(smtpAddress, moduleName); if (CrmId.IsValid(moduleId)) { moduleIds[moduleName] = moduleId; AddressResolutionData data = new AddressResolutionData(moduleName, moduleId, smtpAddress); this.CacheAddressResolutionData(data); result.Add(data); } } if (moduleIds.ContainsKey(ContactSynchroniser.CrmModule)) { CrmId accountId = CrmId.Get(RestAPIWrapper.GetRelationship( ContactSynchroniser.CrmModule, moduleIds[ContactSynchroniser.CrmModule].ToString(), "accounts")); if (CrmId.IsValid(accountId) && SetCrmRelationshipFromOutlook(this, meetingId, "Accounts", accountId)) { var data = new AddressResolutionData("Accounts", accountId, smtpAddress); this.CacheAddressResolutionData(data); result.Add(data); } } } } return(result); }
internal override CrmId AddOrUpdateItemFromOutlookToCrm(SyncState <Outlook.AppointmentItem> syncState) { CrmId previousCrmId = syncState.CrmEntryId; CrmId result = base.AddOrUpdateItemFromOutlookToCrm(syncState); if (CrmId.IsValid(result)) { if (CrmId.IsInvalid(previousCrmId)) /* i.e., it's new */ { if (syncState.OutlookItem.Recipients != null) { AddMeetingRecipientsFromOutlookToCrm(syncState.OutlookItem, result); } this.AddOrUpdateMeetingAcceptanceFromOutlookToCRM(syncState.OutlookItem); } } return(result); }
/// <summary> /// Create an appropriate sync state for an contact item. /// </summary> /// <remarks>Outlook items are not true objects and don't have a common superclass, /// so we have to use this rather clumsy overloading.</remarks> /// <param name="contact">The item.</param> /// <returns>An appropriate sync state.</returns> private ContactSyncState CreateSyncState(Outlook.ContactItem contact) { CrmId crmId = contact.GetCrmId(); ContactSyncState result; if (CrmId.IsValid(crmId) && this.byCrmId.ContainsKey(crmId) && this.byCrmId[crmId] != null) { result = CheckUnexpectedFoundState <Outlook.ContactItem, ContactSyncState>(contact, crmId); } else { result = this.SetByOutlookId <ContactSyncState>(contact.EntryID, new ContactSyncState(contact, crmId, ParseDateTimeFromUserProperty(contact.UserProperties[ModifiedDatePropertyName]))); } if (result != null && CrmId.IsValid(crmId)) { this.byCrmId[crmId] = result; } return(result); }
/// <summary> /// Remove all references to this sync state, if I hold any. /// </summary> /// <param name="state">The state to remove.</param> internal void RemoveSyncState(SyncState state) { lock (this.creationLock) { SyncState ignore; try { if (this.byOutlookId[state.OutlookItemEntryId] == state) { this.byOutlookId.TryRemove(state.OutlookItemEntryId, out ignore); } } catch (KeyNotFoundException) { } catch (COMException) { } try { if (CrmId.IsValid(state.CrmEntryId) && this.byCrmId[state.CrmEntryId] == state) { this.byCrmId.TryRemove(state.CrmEntryId, out ignore); } } catch (KeyNotFoundException) { } } }
/// <summary> /// Create an appropriate sync state for an task item. /// </summary> /// <remarks>Outlook items are not true objects and don't have a common superclass, /// so we have to use this rather clumsy overloading.</remarks> /// <param name="task">The item.</param> /// <returns>An appropriate sync state, or null if the task was invalid.</returns> private TaskSyncState CreateSyncState(Outlook.TaskItem task) { TaskSyncState result; CrmId crmId = task.GetCrmId(); if (CrmId.IsValid(crmId) && this.byCrmId.ContainsKey(crmId) && this.byCrmId[crmId] != null) { result = CheckUnexpectedFoundState <Outlook.TaskItem, TaskSyncState>(task, crmId); } else { result = this.SetByOutlookId <TaskSyncState>(task.EntryID, new TaskSyncState(task, crmId, ParseDateTimeFromUserProperty(task.UserProperties[ModifiedDatePropertyName]))); } if (result != null && CrmId.IsValid(crmId)) { this.byCrmId[crmId] = result; } return(result); }
/// <summary> /// True if <see cref="CrmId.IsValid(CrmId)"/> is false of this id. /// </summary> /// <param name="id">The object which may or may not be a valid CRM id.</param> /// <returns>True if <see cref="CrmId.IsValid(CrmId)"/> is false of this id.</returns> public static bool IsInvalid(CrmId id) { return(!CrmId.IsValid(id)); }
/// <summary> /// Validates a CRM id. /// </summary> /// <param name="id">The object which may or may not be a valid CRM id.</param> /// <returns> /// True if `id` is not null, matches <see cref="Validator" /> pattern and /// is of suitable length. /// </returns> public static bool IsValid(CrmId id) { return(id != null && id.IsValid()); }