public void Should_UpdateEntry()
{
_powerShell.Commands.Clear();
var mySM = new MockServiceManager();
ServiceManager.Provider = () => mySM;
var hfe = new HostFileEntry()
{
Address = "127.0.0.2",
Hostname = "abc.com"
};
mySM.SetupExistingHostList(new [] { hfe });
PSCommand psCmd = new PSCommand();
psCmd.AddCommand("Set-HfHostAddress");
psCmd.AddParameter("Hostname", hfe.Hostname);
psCmd.AddParameter("Address", "11.11.11.11");
_powerShell.Commands = psCmd;
_powerShell.Invoke();
mySM.MockFileService.Verify(h => h.WriteEntries(
It.Is <IEnumerable <HostFileEntry> >(en => en.Any(writeEntry =>
string.Compare(writeEntry.Hostname, hfe.Hostname) == 0 &&
string.Compare(writeEntry.Address, "11.11.11.11") == 0))));
// END FUNCTION
}
private PSCommand RegisterCommand(Match match, PSCommand cmdlet, string cmdletNameGroup, string parameterSetGroup)
{
cmdlet.AddCommand(new Command(match.Groups[cmdletNameGroup].Value, false, true));
CaptureCollection captures = match.Groups[parameterSetGroup].Captures;
string[] array = new string[captures.Count];
for (int i = 0; i < array.Length; i++)
{
array[i] = captures[i].Value;
}
int j = 0;
while (j < array.Length)
{
if (j == 0 && !array[j].StartsWith("-"))
{
cmdlet.AddArgument(array[j]);
j++;
}
else if (j + 1 == array.Length || (j + 1 < array.Length && array[j + 1].StartsWith("-")))
{
cmdlet.AddParameter(array[j].Substring(1), true);
j++;
}
else
{
cmdlet.AddParameter(array[j].Substring(1), this.UnwrapValue(array[j + 1]));
j += 2;
}
}
return(cmdlet);
}
public PowerShellResults <MailboxSearchRow> StartSearch(Identity[] identities, StartMailboxSearchParameters parameters)
{
List <Identity> list = new List <Identity>();
if (parameters != null && parameters.Resume)
{
list.AddRange(identities);
}
else
{
foreach (Identity identity in identities)
{
PowerShellResults <MailboxSearch> @object = base.GetObject <MailboxSearch>("Get-MailboxSearch", identity);
if (@object.Succeeded && @object.HasValue)
{
if ([email protected][0].IsEstimateOnly)
{
PSCommand pscommand = new PSCommand().AddCommand("Set-MailboxSearch");
pscommand.AddParameter("Identity", identity);
pscommand.AddParameter("EstimateOnly", true);
pscommand.AddParameter("ExcludeDuplicateMessages", false);
pscommand.AddParameter("LogLevel", LoggingLevel.Suppress);
pscommand.AddParameter("Force", true);
PowerShellResults powerShellResults = base.Invoke(pscommand);
if (!powerShellResults.Succeeded)
{
break;
}
}
list.Add(identity);
}
}
}
return(base.InvokeAndGetObject <MailboxSearchRow>(new PSCommand().AddCommand("Start-MailboxSearch"), list.ToArray(), parameters));
}
public void Should_ThrowOnUnknownHostEntry()
{
_powerShell.Commands.Clear();
var mySM = new MockServiceManager();
ServiceManager.Provider = () => mySM;
var hfe = new HostFileEntry()
{
Address = "127.0.0.2",
Hostname = "abc.com"
};
mySM.SetupExistingHostList(new[] { hfe });
PSCommand psCmd = new PSCommand();
psCmd.AddCommand("Set-HfHostAddress");
psCmd.AddParameter("Hostname", hfe.Hostname + "aa");
psCmd.AddParameter("Address", hfe.Hostname + "11.11.11.11");
try
{
_powerShell.Commands = psCmd;
_powerShell.Invoke();
}
catch (CmdletInvocationException cex)
{
throw cex.InnerException ?? cex;
}
// END FUNCTION
}
// Token: 0x0600003D RID: 61 RVA: 0x00002F64 File Offset: 0x00001164
protected virtual void CreateMigrationBatch(MailboxId migrationMailbox, byte[] csvFile)
{
for (int i = 0; i < 3; i++)
{
try
{
using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(base.Context, base.Context.ApplicationName))
{
PSCommand pscommand = new PSCommand();
pscommand.AddCommand("New-MigrationBatch");
pscommand.AddParameter("XO1", true);
pscommand.AddParameter("CSVData", csvFile);
pscommand.AddParameter("Partition", migrationMailbox);
anchorRunspaceProxy.RunPSCommand <PSObject>(pscommand);
}
base.Context.Logger.Log(MigrationEventType.Information, "Successfully created new migration batch against {0}", new object[]
{
migrationMailbox
});
break;
}
catch (InvalidRunspaceStateException ex)
{
base.Context.Logger.Log(MigrationEventType.Error, "PS Runspace was closed so command could not be run : {0}", new object[]
{
ex
});
}
}
}
/// <summary>
/// Creates a new file or project from a specified template and
/// places it in the destination path. This ultimately calls
/// Invoke-Plaster in PowerShell.
/// </summary>
/// <param name="templatePath">The folder path containing the template.</param>
/// <param name="destinationPath">The folder path where the files will be created.</param>
/// <returns>A boolean-returning Task which communicates success or failure.</returns>
public async Task <bool> CreateFromTemplate(
string templatePath,
string destinationPath)
{
this.logger.Write(
LogLevel.Verbose,
$"Invoking Plaster...\n\n TemplatePath: {templatePath}\n DestinationPath: {destinationPath}");
PSCommand command = new PSCommand();
command.AddCommand("Invoke-Plaster");
command.AddParameter("TemplatePath", templatePath);
command.AddParameter("DestinationPath", destinationPath);
var errorString = new System.Text.StringBuilder();
await this.powerShellContext.ExecuteCommand <PSObject>(
command,
errorString,
new ExecutionOptions
{
WriteOutputToHost = false,
WriteErrorsToHost = true,
InterruptCommandPrompt = true
});
// If any errors were written out, creation was not successful
return(errorString.Length == 0);
}
void IOrganizationOperation.SetTenantUpgradeCapability(string identity, bool tenantUpgradeCapabilityEnabled)
{
using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers"))
{
PSCommand pscommand = new PSCommand();
pscommand.AddCommand("Set-Mailbox");
pscommand.AddParameter("Identity", identity);
pscommand.AddParameter("Arbitration");
pscommand.AddParameter("Force");
pscommand.AddParameter("TenantUpgrade", tenantUpgradeCapabilityEnabled);
try
{
anchorRunspaceProxy.RunPSCommand <Mailbox>(pscommand);
}
catch (MigrationPermanentException ex)
{
this.Context.Logger.Log(MigrationEventType.Error, "Unable to set TenantUpgrade capability for '{0}': {1}", new object[]
{
identity,
ex
});
throw;
}
}
}
// Отключение ActiveSync и WebApp у пользователя
private void DisableActiveSyncWebAppPS(string userLogin, string mailServerAdr, string login, SecureString password, ref string errorMsg)
{
PSCredential credential = new PSCredential(login, password);
WSManConnectionInfo connectionInfo = new WSManConnectionInfo((new Uri(mailServerAdr)), "http://schemas.microsoft.com/powershell/Microsoft.Exchange", credential);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
Runspace runspace = System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace(connectionInfo);
PowerShell powershell = PowerShell.Create();
PSCommand command = new PSCommand();
command.AddCommand("Set-CASMailbox");
command.AddParameter("Identity", userLogin);
command.AddParameter("ActiveSyncEnabled", false);
command.AddParameter("OWAEnabled", false);
powershell.Commands = command;
try
{
runspace.Open();
powershell.Runspace = runspace;
powershell.Invoke();
}
catch (Exception ex)
{
errorMsg = ex.Message;
}
finally
{
runspace.Dispose();
runspace = null;
powershell.Dispose();
powershell = null;
}
}
/// <summary>
/// This method removes an existing AD group
/// </summary>
/// <param name="group_identity"></param>
/// <returns></returns>
public MSActorReturnMessageModel RemoveADGroup(string group_identity)
{
UtilityController util = new UtilityController();
try
{
using (PowerShell powershell = PowerShell.Create())
{
PSCommand command = new PSCommand();
command.AddCommand("Remove-ADGroup");
command.AddParameter("identity", group_identity);
command.AddParameter("confirm", false);
powershell.Commands = command;
powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
throw powershell.Streams.Error[0].Exception;
}
powershell.Streams.ClearStreams();
MSActorReturnMessageModel successMessage = new MSActorReturnMessageModel(SuccessCode, "");
return(successMessage);
}
}
catch (Exception e)
{
if (!e.Message.Contains(cantFindObjectError))
{
return(util.ReportError(e));
}
return(util.ReportHiddenError(e));
}
}
/// <summary>
/// Sets the list of breakpoints for the current debugging session.
/// </summary>
/// <param name="scriptFile">The ScriptFile in which breakpoints will be set.</param>
/// <param name="lineNumbers">The line numbers at which breakpoints will be set.</param>
/// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
/// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
public async Task <BreakpointDetails[]> SetBreakpoints(
ScriptFile scriptFile,
int[] lineNumbers,
bool clearExisting = true)
{
IEnumerable <Breakpoint> resultBreakpoints = null;
if (clearExisting)
{
await this.ClearBreakpointsInFile(scriptFile);
}
if (lineNumbers.Length > 0)
{
PSCommand psCommand = new PSCommand();
psCommand.AddCommand("Set-PSBreakpoint");
psCommand.AddParameter("Script", scriptFile.FilePath);
psCommand.AddParameter("Line", lineNumbers.Length > 0 ? lineNumbers : null);
resultBreakpoints =
await this.powerShellContext.ExecuteCommand <Breakpoint>(
psCommand);
return
(resultBreakpoints
.Select(BreakpointDetails.Create)
.ToArray());
}
return(new BreakpointDetails[0]);
}
/// <summary>
/// Sets the list of breakpoints for the current debugging session.
/// </summary>
/// <param name="scriptFile">The ScriptFile in which breakpoints will be set.</param>
/// <param name="lineNumbers">The line numbers at which breakpoints will be set.</param>
/// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
/// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
public async Task <BreakpointDetails[]> SetBreakpoints(
ScriptFile scriptFile,
int[] lineNumbers,
bool clearExisting = true)
{
IEnumerable <Breakpoint> resultBreakpoints = null;
if (clearExisting)
{
await this.ClearBreakpointsInFile(scriptFile);
}
if (lineNumbers.Length > 0)
{
// Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
// quoted and have those wildcard chars escaped.
string escapedScriptPath = PowerShellContext.EscapeWildcardsInPath(scriptFile.FilePath);
PSCommand psCommand = new PSCommand();
psCommand.AddCommand("Set-PSBreakpoint");
psCommand.AddParameter("Script", escapedScriptPath);
psCommand.AddParameter("Line", lineNumbers.Length > 0 ? lineNumbers : null);
resultBreakpoints =
await this.powerShellContext.ExecuteCommand <Breakpoint>(
psCommand);
return
(resultBreakpoints
.Select(BreakpointDetails.Create)
.ToArray());
}
return(new BreakpointDetails[0]);
}
public PowerShellResults <NewUMMailboxConfiguration> GetConfigurationForNewUMMailbox(Identity identity, UMEnableSelectedPolicyParameters properties)
{
properties.FaultIfNull();
PSCommand pscommand = new PSCommand().AddCommand("Enable-UMMailbox");
pscommand.AddParameter("Identity", identity);
pscommand.AddParameter("ValidateOnly");
if (properties.UMMailboxPolicy != null)
{
pscommand.AddParameter("UMMailboxPolicy", properties.UMMailboxPolicy);
}
PowerShellResults <NewUMMailboxConfiguration> powerShellResults = base.Invoke <NewUMMailboxConfiguration>(pscommand);
if (!powerShellResults.Succeeded)
{
powerShellResults.ErrorRecords = Array.FindAll <ErrorRecord>(powerShellResults.ErrorRecords, (ErrorRecord x) => !(x.Exception is CouldNotGenerateExtensionException) && !(x.Exception is SipResourceIdAndExtensionsNeededException) && !(x.Exception is E164ResourceIdNeededException));
}
if (powerShellResults.SucceededWithValue)
{
PowerShellResults <UMMailboxPolicy> powerShellResults2 = powerShellResults.MergeErrors <UMMailboxPolicy>(base.GetObject <UMMailboxPolicy>("Get-UMMailboxPolicy", properties.UMMailboxPolicy));
if (powerShellResults2.SucceededWithValue)
{
powerShellResults.Value.Policy = powerShellResults2.Value;
}
}
return(powerShellResults);
}
RecipientWrapper IOrganizationOperation.GetUser(string organizationId, string userId)
{
RecipientWrapper result;
using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers"))
{
PSCommand pscommand = new PSCommand();
pscommand.AddCommand("Get-User");
pscommand.AddParameter("Organization", organizationId);
pscommand.AddParameter("Identity", userId);
User user;
try
{
user = anchorRunspaceProxy.RunPSCommandSingleOrDefault <User>(pscommand);
}
catch (Exception ex)
{
this.Context.Logger.Log(MigrationEventType.Error, "MigrationPermanentException from GetUser '{0}'.{1}", new object[]
{
userId,
ex
});
if (ex.InnerException is ManagementObjectNotFoundException)
{
throw new UserNotFoundException(userId, ex.InnerException);
}
throw;
}
result = new RecipientWrapper(user);
}
return(result);
}
public bool StartCode(string login, string password) /// Check if the credentials are valid
{
string connectionUri = "https://outlook.office365.com/powershell-liveid/";
// string connectionUri = "https://ps.outlook.com/powershell/";
SecureString secpassword = new SecureString();
foreach (char c in password)
{
secpassword.AppendChar(c);
}
PSCredential credential = new PSCredential(login, secpassword);
runspace = RunspaceFactory.CreateRunspace();
command = new PSCommand(); command.AddCommand("New-PSSession");
command.AddParameter("ConfigurationName", "Microsoft.Exchange");
command.AddParameter("ConnectionUri", new Uri(connectionUri));
command.AddParameter("Credential", credential);
command.AddParameter("Authentication", "Basic");
powershell.Commands = command; runspace.Open();
powershell.Runspace = runspace; result = powershell.Invoke();
if (powershell.Streams.Error.Count > 0 || result.Count != 1)
{
return(false);
}
CredsAreValid = true;
return(true);
}
/// <summary>
/// Gets an array of commands that can be run sequentially to set $profile and run the profile commands.
/// </summary>
/// <param name="shellId">The id identifying the host or shell used in profile file names.</param>
/// <param name="useTestProfile">used from test not to overwrite the profile file names from development boxes</param>
/// <returns>An array of commands.</returns>
internal static PSCommand[] GetProfileCommands(string shellId, bool useTestProfile)
{
List <PSCommand> commands = new List <PSCommand>();
string allUsersAllHosts = HostUtilities.GetFullProfileFileName(null, false, useTestProfile);
string allUsersCurrentHost = HostUtilities.GetFullProfileFileName(shellId, false, useTestProfile);
string currentUserAllHosts = HostUtilities.GetFullProfileFileName(null, true, useTestProfile);
string currentUserCurrentHost = HostUtilities.GetFullProfileFileName(shellId, true, useTestProfile);
PSObject dollarProfile = HostUtilities.GetDollarProfile(allUsersAllHosts, allUsersCurrentHost, currentUserAllHosts, currentUserCurrentHost);
PSCommand command = new PSCommand();
command.AddCommand("set-variable");
command.AddParameter("Name", "profile");
command.AddParameter("Value", dollarProfile);
command.AddParameter("Option", ScopedItemOptions.None);
commands.Add(command);
string[] profilePaths = new string[] { allUsersAllHosts, allUsersCurrentHost, currentUserAllHosts, currentUserCurrentHost };
foreach (string profilePath in profilePaths)
{
if (!System.IO.File.Exists(profilePath))
{
continue;
}
command = new PSCommand();
command.AddCommand(profilePath, false);
commands.Add(command);
}
return(commands.ToArray());
}
/// <summary>
/// Uses _savedCredential in order to enter into a remote session with a remote machine. If _savedCredential is null, method will instead
/// use InvokeScript to prompt/enter into a session without saving credentials.
/// </summary>
/// <param name="powerShell">This should be an already instanstiated PowerShell object, and should be inside of a using. If
/// powerShell is null, method will return without performing any action.</param>
/// <param name="remoteName">Machine to connect to.</param>
private void EnterCredentialedRemoteSession(PowerShell powerShell, string remoteName, int port, bool useSSL)
{
if (powerShell == null)
{
// callee is expected to passs in an already inalized PowerShell object to this method
return;
}
if (_savedCredential == null)
{
InvokeScript(powerShell, string.Format(DebugEngineConstants.EnterRemoteSessionDefaultCommand, remoteName));
return;
}
PSCommand enterSession = new PSCommand();
enterSession.AddCommand("Enter-PSSession").AddParameter("ComputerName", remoteName).AddParameter("Credential", _savedCredential);
if (port != -1)
{
// check for user specified port
enterSession.AddParameter("-Port", port);
}
if (useSSL)
{
// if told to use SSL from options dialog, add the SSL parameter
enterSession.AddParameter("-UseSSL");
}
powerShell.Runspace = _runspace;
powerShell.Commands.Clear();
powerShell.Commands = enterSession;
powerShell.Invoke();
}
public PowerShellResults <DeviceAccessRuleRow> NewObject(NewDeviceAccessRule properties)
{
if (properties.DeviceTypeQueryString == null)
{
throw new FaultException(Strings.DeviceTypeRequired);
}
if (properties.DeviceModelQueryString == null)
{
throw new FaultException(Strings.DeviceModelRequired);
}
PSCommand pscommand = new PSCommand().AddCommand("New-ActiveSyncDeviceAccessRule").AddParameters(properties);
if (!properties.DeviceTypeQueryString.IsWildcard && properties.DeviceModelQueryString.IsWildcard)
{
pscommand.AddParameter(ActiveSyncDeviceAccessRuleSchema.Characteristic.Name, DeviceAccessCharacteristic.DeviceType);
pscommand.AddParameter(ActiveSyncDeviceAccessRuleSchema.QueryString.Name, properties.DeviceTypeQueryString.QueryString);
}
else
{
if (!properties.DeviceTypeQueryString.IsWildcard || properties.DeviceModelQueryString.IsWildcard)
{
throw new FaultException(Strings.InvalidDeviceAccessCharacteristic);
}
pscommand.AddParameter(ActiveSyncDeviceAccessRuleSchema.Characteristic.Name, DeviceAccessCharacteristic.DeviceModel);
pscommand.AddParameter(ActiveSyncDeviceAccessRuleSchema.QueryString.Name, properties.DeviceModelQueryString.QueryString);
}
return(base.Invoke <DeviceAccessRuleRow>(pscommand));
}
/// <summary>
/// Add user to an AD group
/// </summary>
/// <param name="group_identity"></param>
/// <param name="group_member"></param>
/// <returns></returns>
public MSActorReturnMessageModel AddADGroupMember(string group_identity, string group_member)
{
try
{
using (PowerShell powershell = PowerShell.Create())
{
PSCommand command = new PSCommand();
command.AddCommand("Add-ADGroupMember");
command.AddParameter("identity", group_identity);
command.AddParameter("member", group_member);
powershell.Commands = command;
powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
throw powershell.Streams.Error[0].Exception;
}
powershell.Streams.ClearStreams();
MSActorReturnMessageModel successMessage = new MSActorReturnMessageModel(SuccessCode, "");
return(successMessage);
}
}
catch (Exception e)
{
return(util.ReportError(e));
}
}
static void Main(string[] args)
{
string uname = Console.ReadLine();
string pwd = Console.ReadLine();
PSCommand psCommand = new PSCommand();
psCommand.AddScript("$PSHome");
PowerShell ps = PowerShell.Create();
ps.Commands = psCommand;
Collection <PSObject> results = ps.Invoke();
Console.WriteLine("results length::" + results.Count);
foreach (PSObject res in results)
{
Console.WriteLine("Res val::" + res.ToString());
}
Runspace runspace = RunspaceFactory.CreateRunspace();
runspace.Open();
ps.Runspace = runspace;
results = ps.Invoke();
Console.WriteLine("results length::" + results.Count);
foreach (PSObject res in results)
{
Console.WriteLine("Res val::" + res.ToString());
}
PSCommand rmcommand = new PSCommand();
string exchangeUri = "https://outlook.office365.com/powershell-liveid/";
Uri uri = new Uri(exchangeUri);
rmcommand.AddCommand("New-PSSession");
rmcommand.AddParameter("ConfigurationName", "Microsoft.Exchange");
rmcommand.AddParameter("ConnectionUri", uri);
SecureString password = new SecureString();
foreach (char c in pwd)
{
password.AppendChar(c);
}
PSCredential creds = new PSCredential(uname, password);
rmcommand.AddParameter("Credential", creds);
rmcommand.AddParameter("Authentication", "Basic");
rmcommand.AddParameter("AllowRedirection");
ps.Commands = rmcommand;
Collection <PSObject> result = ps.Invoke();
Console.ReadLine();
}
/// <summary>
/// Analyze a given script using PSScriptAnalyzer.
/// </summary>
/// <param name="scriptContent">The contents of the script to analyze.</param>
/// <param name="settings">The settings file to use in this instance of analysis.</param>
/// <returns>An array of markers indicating script analysis diagnostics.</returns>
public Task <ScriptFileMarker[]> AnalyzeScriptAsync(string scriptContent, Hashtable settings)
{
// When a new, empty file is created there are by definition no issues.
// Furthermore, if you call Invoke-ScriptAnalyzer with an empty ScriptDefinition
// it will generate a ParameterBindingValidationException.
if (string.IsNullOrEmpty(scriptContent))
{
return(Task.FromResult(Array.Empty <ScriptFileMarker>()));
}
var command = new PSCommand()
.AddCommand("Invoke-ScriptAnalyzer")
.AddParameter("ScriptDefinition", scriptContent)
.AddParameter("Severity", s_scriptMarkerLevels);
object settingsValue = settings ?? _settingsParameter;
if (settingsValue != null)
{
command.AddParameter("Settings", settingsValue);
}
else
{
command.AddParameter("IncludeRule", _rulesToInclude);
}
return(GetSemanticMarkersFromCommandAsync(command));
}
void IOrganizationOperation.InvokeOrganizationCmdlet(string organizationId, string cmdlet, bool configOnly)
{
using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers"))
{
PSCommand pscommand = new PSCommand();
pscommand.AddCommand(cmdlet);
pscommand.AddParameter("Identity", organizationId);
if (configOnly && cmdlet.Contains("Start-OrganizationUpgrade"))
{
pscommand.AddParameter("ConfigOnly");
}
try
{
anchorRunspaceProxy.RunPSCommand <PSObject>(pscommand);
}
catch (MigrationPermanentException ex)
{
this.Context.Logger.Log(MigrationEventType.Error, "{0} '{1}' failed due to {2}", new object[]
{
cmdlet,
organizationId,
ex
});
throw;
}
}
}
public static void RemoveAllFolderPermissions(string mailbox, string folder)
{
PSCommand commands = new PSCommand();
if (folder == "\\Top of Information Store")
{
folder = "\\";
}
string folderPath = mailbox + ":" + folder;
SwitchParameter noConfirm = new SwitchParameter();
Collection <PSObject> currentPermissions = GetFolderPermissions(mailbox, folder);
foreach (PSObject permission in currentPermissions)
{
if (permission.Properties["User"].Value.ToString() != "Default" && permission.Properties["User"].Value.ToString() != "Anonymous")
{
commands.Clear();
commands.AddCommand("Remove-MailboxFolderPermission");
commands.AddParameter("Identity", folderPath);
commands.AddParameter("User", permission.Properties["User"].Value.ToString());
commands.AddParameter("Confirm", noConfirm);
runPowershellCommands(commands);
}
}
}
/// <summary>
/// This method changes the surname of a user in AD.
/// </summary>
/// <param name="employeeid"></param>
/// <param name="samaccountname"></param>
/// <param name="field"></param>
/// <param name="value"></param>
/// <returns></returns>
public MSActorReturnMessageModel ChangeUserValueDriver(string employeeid, string samaccountname, string field, string value)
{
try
{
if (value == "")
{
value = null;
}
string dName;
PSObject user = util.getADUser(employeeid, samaccountname);
if (user == null)
{
throw new Exception("User was not found.");
}
dName = user.Properties["DistinguishedName"].Value.ToString();
using (PowerShell powershell = PowerShell.Create())
{
PSCommand command = new PSCommand();
command.AddCommand("Set-ADUser");
command.AddParameter("Identity", dName);
if (field.ToLower() == "ipphone")
{
if (value != null)
{
Hashtable attrHash = new Hashtable
{
{ field, value }
};
command.AddParameter("replace", attrHash);
}
else
{
String[] attrArray = new String[1];
attrArray[0] = field;
command.AddParameter("clear", attrArray);
}
}
else
{
command.AddParameter(field, value);
}
command.AddParameter("ErrorVariable", "Err");
powershell.Commands = command;
powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
throw powershell.Streams.Error[0].Exception;
}
powershell.Streams.ClearStreams();
MSActorReturnMessageModel successMessage = new MSActorReturnMessageModel(SuccessCode, "");
return(successMessage);
}
}
catch (Exception e)
{
return(util.ReportError(e));
}
}
public PowerShellResults ResetPIN(Identity identity)
{
PSCommand pscommand = new PSCommand().AddCommand("Set-UMMailboxPIN");
pscommand.AddParameter("Identity", Identity.FromExecutingUserId());
pscommand.AddParameter("PinExpired", true);
return(base.Invoke(pscommand));
}
public PowerShellResults <InboxRule> GetObject(Identity identity)
{
PSCommand pscommand = new PSCommand().AddCommand("Get-InboxRule");
pscommand.AddParameter("DescriptionTimeFormat", EcpDateTimeHelper.GetWeekdayDateFormat(true));
pscommand.AddParameter("DescriptionTimeZone", RbacPrincipal.Current.UserTimeZone);
return(base.GetObject <InboxRule>(pscommand, identity));
}
public PowerShellResults StartLogging(Identity[] identities, BaseWebServiceParameters parameters)
{
PSCommand pscommand = new PSCommand().AddCommand("Set-CASMailbox");
pscommand.AddParameter("Identity", Identity.FromExecutingUserId());
pscommand.AddParameter("ActiveSyncDebugLogging", true);
return(base.Invoke(pscommand));
}
private PowerShellResults ComparePasscode(Identity identity, string passcode)
{
PSCommand pscommand = new PSCommand().AddCommand("Compare-TextMessagingVerificationCode");
pscommand.AddParameter("Identity", identity);
pscommand.AddParameter("VerificationCode", passcode);
return(base.Invoke(pscommand));
}
/// <summary>
/// Sample execution scenario 2: Asynchronous
/// </summary>
/// <remarks>
/// Executes a PowerShell script asynchronously with script output and event handling.
/// </remarks>
static void ExecuteAsynchronously()
{
using (PowerShell PowerShellInstance = PowerShell.Create())
{
// this script has a sleep in it to simulate a long running script
//PowerShellInstance.AddScript("$s1 = 'test1'; $s2 = 'test2'; $s1; write-error 'some error';start-sleep -s 7; $s2");
//PowerShellInstance.AddScript("Invoke-Command");
//PowerShellInstance.AddParameter("ScriptBlock", "test.ps1");
PowerShellInstance.AddScript("Set-ExecutionPolicy");
PowerShellInstance.AddParameter("ExecutionPolicy", "ByPass");
PowerShellInstance.Invoke();
PSCommand cmd = new PSCommand();
String machinename = "localhost";
String file = AppDomain.CurrentDomain.BaseDirectory + "\\test.ps1";
cmd.AddCommand("Invoke-Command");
cmd.AddParameter("ComputerName", machinename);
//cmd.AddParameter("FilePath", file);
cmd.AddParameter("ScriptBlock", ScriptBlock.Create(file));
PowerShellInstance.Commands = cmd;
// prepare a new collection to store output stream objects
PSDataCollection <PSObject> outputCollection = new PSDataCollection <PSObject>();
outputCollection.DataAdded += outputCollection_DataAdded;
// the streams (Error, Debug, Progress, etc) are available on the PowerShell instance.
// we can review them during or after execution.
// we can also be notified when a new item is written to the stream (like this):
PowerShellInstance.Streams.Error.DataAdded += Error_DataAdded;
// begin invoke execution on the pipeline
// use this overload to specify an output stream buffer
IAsyncResult result = PowerShellInstance.BeginInvoke <PSObject, PSObject>(null, outputCollection);
// do something else until execution has completed.
// this could be sleep/wait, or perhaps some other work
while (result.IsCompleted == false)
{
Console.WriteLine("Waiting for pipeline to finish...");
Thread.Sleep(1000);
// might want to place a timeout here...
}
Console.WriteLine("Execution has stopped. The pipeline state: " + PowerShellInstance.InvocationStateInfo.State);
foreach (PSObject outputItem in outputCollection)
{
//TODO: handle/process the output items if required
Console.WriteLine(outputItem.BaseObject.ToString());
}
}
}
public static Collection <PSObject> GetMailboxes()
{
PSCommand commands = new PSCommand();
commands.AddCommand("Get-Mailbox");
commands.AddParameter("RecipientTypeDetails", "UserMailbox");
commands.AddParameter("SortBy", "Name");
return(runPowershellCommands(commands));
}
public static Collection <PSObject> GetGroups()
{
PSCommand commands = new PSCommand();
commands.AddCommand("Get-Group");
commands.AddParameter("RecipientTypeDetails", "MailUniversalSecurityGroup");
commands.AddParameter("SortBy", "Name");
return(runPowershellCommands(commands));
}
