private static async Task<bool> ValidateAlias(UserCredentials credentials, string alias) { IExchangeResponse result = null; await Task.Run(() => { var connector = new ExchangeConnector(); result = connector.PerformExchangeRequest(credentials, AccountSettingsViewModel.Instance.ServerUrl, alias, ExchangeRequestType.ValidateAlias); }); return result != null && ((AliasValidationEnvelope) result).Body.Response.IsAliasUnique; }
private static async Task<string> CreateGroup(UserCredentials credentials, string alias, string owner) { IExchangeResponse result = null; await Task.Run(() => { var connector = new ExchangeConnector(); result = connector.PerformExchangeRequest(credentials, AccountSettingsViewModel.Instance.ServerUrl, alias, ExchangeRequestType.CreateGroup, new List<string> { owner }); }); if (result != null) { if (((GroupCreationEnvelope)result).Body.CreateUnifiedGroupResponseMessage.GroupIdentity != null && ((GroupCreationEnvelope)result).Body.CreateUnifiedGroupResponseMessage.GroupIdentity.Type.ToLower() == "smtpaddress") { return ((GroupCreationEnvelope)result).Body.CreateUnifiedGroupResponseMessage.GroupIdentity.Value; } return string.Empty; } return string.Empty; }
private static async Task<SetMemberEnvelope> AddMembersToGroup(UserCredentials credentials, string alias, IEnumerable<string> members) { IExchangeResponse result = null; // add a loop here and add error messages await Task.Run(() => { var connector = new ExchangeConnector(); result = connector.PerformExchangeRequest(credentials, AccountSettingsViewModel.Instance.ServerUrl, alias, ExchangeRequestType.AddMember, members); }); return (SetMemberEnvelope)result; }
/// <summary> /// Gets the concatenated username:password string required for the REST request. /// </summary> /// <param name="credentials">User credentials.</param> /// <returns></returns> private static string GetBasicAuthFormat(UserCredentials credentials) { return Convert.ToBase64String( Encoding.UTF8.GetBytes( string.Concat(credentials.Username, ":", credentials.Password))); }
/// <summary> /// Get the owner of an external distribution list. /// </summary> /// <param name="dl">Distribution list name (alias) without the domain.</param> /// <param name="credentials">User credentials for service access.</param> /// <param name="isValidDl">Indicates if there exists a DL with the alias.</param> /// <returns></returns> public string GetExternalDistributionListOwner(string dl, UserCredentials credentials, out bool isValidDl) { var owner = new StringBuilder(); isValidDl = false; var secureString = new SecureString(); foreach (var c in credentials.Password) secureString.AppendChar(c); var credential = new PSCredential(credentials.Username, secureString); var localUri = new Uri(AccountSettingsViewModel.Instance.ServerUrl); var serverUrl = localUri.GetLeftPart(UriPartial.Authority); var connectionInfo = new WSManConnectionInfo(new Uri(string.Concat(serverUrl, "/powershell-liveid/")), "Microsoft.Exchange", credential) { AuthenticationMechanism = AuthenticationMechanism.Basic, SkipCACheck = true, SkipCNCheck = true, MaximumConnectionRedirectionCount = 4 }; try { var runspace = RunspaceFactory.CreateRunspace(connectionInfo); runspace.Open(); Collection<PSObject> rsResultsresults = null; using (var plPileLine = runspace.CreatePipeline()) { var getGroupCommand = new Command(AppSetup.CmdletGetDistributionGroup); getGroupCommand.Parameters.Add("Identity", dl); plPileLine.Commands.Add(getGroupCommand); rsResultsresults = plPileLine.Invoke(); if (rsResultsresults.Count == 1) { isValidDl = true; var manager = rsResultsresults.First().Properties["ManagedBy"].Value; var owners = manager.ToString().Split(' '); owner.Append(owners[0]); owner.Append('@'); plPileLine.Stop(); } else if (rsResultsresults.Count == 0) { LoggingViewModel.Instance.Logger.Write(string.Concat("GetExternalDistributionListOwner ", Environment.NewLine, "DistributionListNotFound", Environment.NewLine, dl)); } else { LoggingViewModel.Instance.Logger.Write(string.Concat("GetExternalDistributionListOwner ", Environment.NewLine, "NonUniqueDistributionListFound", Environment.NewLine, dl)); } } using (var plPileLine = runspace.CreatePipeline()) { var getAutoritativeDomainCommand = new Command(AppSetup.CmdletGetAuthoritativeDomain); plPileLine.Commands.Add(getAutoritativeDomainCommand); rsResultsresults = plPileLine.Invoke(); var filteredDomainResults = rsResultsresults.Where(cr => ((string)cr.Properties["DomainType"].Value == "Authoritative")); var authoritativeDomain = filteredDomainResults.First().Properties["DomainName"].Value; owner.Append(authoritativeDomain); plPileLine.Stop(); } runspace.Close(); } catch (Exception exception) { LoggingViewModel.Instance.Logger.Write(string.Concat("GetExternalDistributionListOwner ", Environment.NewLine, exception.Message, Environment.NewLine, exception.StackTrace, Environment.NewLine, dl)); } return owner.ToString(); }
/// <summary> /// Core method for performing EWS calls against the Exchange service. /// </summary> /// <param name="credentials">User credentials.</param> /// <param name="exchangeUrl">URL to the EWS endpoint.</param> /// <param name="param">Additional parameters that work with the specific request.</param> /// <param name="requestType">Type of the EWS request.</param> /// <param name="additionalParam">List of additional parameters needed for a request.</param> /// <returns></returns> public IExchangeResponse PerformExchangeRequest(UserCredentials credentials, string exchangeUrl, string param, ExchangeRequestType requestType, IEnumerable<string> additionalParam = null) { var postContent = string.Empty; Type type = null; var authHeaderContent = GetBasicAuthFormat(credentials); var request = (HttpWebRequest) WebRequest.Create(exchangeUrl); request.Method = WebRequestMethods.Http.Post; request.Headers.Add(HttpRequestHeader.Authorization, string.Concat("Basic ", authHeaderContent)); request.UserAgent = "Hummingbird"; request.ContentType = "text/xml"; switch (requestType) { case ExchangeRequestType.ValidateAlias: { LoggingViewModel.Instance.Logger.Write(string.Concat("ExchangeConnector:ValidateAlias ", param)); postContent = Resources.AliasValidationPOST.Replace(AppSetup.GroupIdFiller, param); type = typeof (AliasValidationEnvelope); break; } case ExchangeRequestType.CreateGroup: { LoggingViewModel.Instance.Logger.Write(string.Concat("ExchangeConnector:CreateGroup ", param)); postContent = Resources.GroupCreationPOST.Replace(AppSetup.GroupIdFiller, param); var additionalParamList = additionalParam != null ? additionalParam.ToList() : null; if (additionalParamList != null && additionalParamList.Count == 1) { postContent = postContent.Replace(AppSetup.OwnerSmtpFiller, additionalParamList[0]); } type = typeof (GroupCreationEnvelope); break; } case ExchangeRequestType.GetUnifiedGroupDetails: { LoggingViewModel.Instance.Logger.Write(string.Concat("ExchangeConnector:GetGroupDetails ", param)); postContent = Resources.GetUnifiedGroupsPOST.Replace(AppSetup.GroupSmtpFiller, param); type = typeof (GetUnifiedGroupEnvelope); break; } case ExchangeRequestType.DeleteGroup: { postContent = Resources.DeleteGroupPOST; type = null; break; } case ExchangeRequestType.AddMember: { LoggingViewModel.Instance.Logger.Write(string.Concat("ExchangeConnector:AddMember ", param)); if (additionalParam != null) { using ( var addMemberEnvelopeStream = new MemoryStream(Encoding.UTF8.GetBytes(Resources.SetUnifiedGroupMembersPOST))) { using (var reader = new StreamReader(addMemberEnvelopeStream)) { var serializer = new XmlSerializer(typeof (AddMemberEnvelope)); var deserializedContent = (AddMemberEnvelope) serializer.Deserialize(reader); deserializedContent.Body.SetUnifiedGroupMembershipState.Members = new List<string>(additionalParam); deserializedContent.Body.SetUnifiedGroupMembershipState.GroupIdentity.Value = param; var ns = new XmlSerializerNamespaces(); ns.Add("s", "http://schemas.xmlsoap.org/soap/envelope/"); var xmlWriterSettings = new XmlWriterSettings { OmitXmlDeclaration = true }; using (var textWriter = new StringWriter()) { using (var writer = XmlWriter.Create(textWriter, xmlWriterSettings)) { serializer.Serialize(writer, deserializedContent, ns); postContent = textWriter.ToString(); LoggingViewModel.Instance.Logger.Write( string.Concat("ExchangeConnector:AddMemberPostContent ", postContent)); type = typeof (SetMemberEnvelope); } } } } } else { throw new ArgumentNullException("additionalParam", Resources.ExchangeRequestAddMembersWithoutMembers); } break; } } var processedPostContent = Encoding.UTF8.GetBytes(postContent); request.ContentLength = processedPostContent.Length; using (var requestStream = request.GetRequestStream()) { requestStream.Write(processedPostContent, 0, processedPostContent.Length); } try { var response = (HttpWebResponse) request.GetResponse(); if (response.StatusCode == HttpStatusCode.OK) { using (var responseStream = response.GetResponseStream()) { using (var reader = new StreamReader(responseStream)) { var serializer = new XmlSerializer(type); var translatedResponse = (IExchangeResponse) serializer.Deserialize(reader); return translatedResponse; } } } } catch (Exception exception) { LoggingViewModel.Instance.Logger.Write(string.Concat("ExchangeConnector:Error ", exception.Message, Environment.NewLine, exception.StackTrace)); } return null; }
/// <summary> /// Encrypts and stores the user credentials locally. /// </summary> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> internal bool StoreUserCredentials(string userName, string password) { byte[] credentialsData; IFormatter objectFormatter = new BinaryFormatter(); var credentials = new UserCredentials {Username = userName, Password = password}; using (var stream = new MemoryStream()) { objectFormatter.Serialize(stream, credentials); credentialsData = stream.ToArray(); } var encryptedData = ProtectedData.Protect(credentialsData, _container, DataProtectionScope.CurrentUser); return WriteToLocalAppData(encryptedData); }
private async Task<object> GetGroupInformation(UserCredentials credentials, string groupQualifiedName) { IExchangeResponse result = null; await Task.Run(() => { var connector = new ExchangeConnector(); result = connector.PerformExchangeRequest(credentials, AccountSettingsViewModel.Instance.ServerUrl, groupQualifiedName, ExchangeRequestType.GetUnifiedGroupDetails); }); return (GetUnifiedGroupEnvelope) result; }
private static BulkAddMembersResult AddMembersToGroupSingleBatch(UserCredentials credentials, string alias, IEnumerable<string> members) { var memberList = members.ToList(); var connector = new ExchangeConnector(); IExchangeResponse result = connector.PerformExchangeRequest(credentials, AccountSettingsViewModel.Instance.ServerUrl, alias, ExchangeRequestType.AddMember, memberList); var addMemberResult = new BulkAddMembersResult { StatusCode = result != null ? ((SetMemberEnvelope)result).Body.SetUnifiedGroupMembershipResponseMessage.ResponseCode : string.Empty, MemberCount = memberList.Count }; if (addMemberResult.StatusCode.ToLower() != "noerror" && addMemberResult.StatusCode.ToLower() != "errorinvalidid") { addMemberResult.FailedMembers = memberList; } else if (result != null) { addMemberResult.FailedMembers = ((SetMemberEnvelope)result).Body.SetUnifiedGroupMembershipResponseMessage.FailedMembers; addMemberResult.InvalidMembers = ((SetMemberEnvelope)result).Body.SetUnifiedGroupMembershipResponseMessage.InvalidMembers; } return addMemberResult; }
private static async Task<BulkAddMembersResult[]> AddMembersToGroup(UserCredentials credentials, string alias, List<string> members) { var tasks = new List<Task<BulkAddMembersResult>>(); var results = new List<BulkAddMembersResult>(); for (int i = 0; i < members.Count; i += AddMembersBatchSize) { IEnumerable<string> membersForBatch = members.Skip(i).Take(AddMembersBatchSize); var task = Task.Run(() => AddMembersToGroupSingleBatch(credentials, alias, membersForBatch)); results.Add(await task); } return results.ToArray(); }