public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
this.SavedResults.Clear();
base.OnStart();
string path = (string)row[base.FilePathParameterName];
try
{
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
using (BinaryReader binaryReader = new BinaryReader(fileStream))
{
byte[] fileData = binaryReader.ReadBytes((int)fileStream.Length);
this.SavedResults.Add(new BinaryFileObject(Path.GetFileName(path), fileData));
base.OnComplete(true, null);
}
}
}
catch (FileNotFoundException exception)
{
base.OnComplete(false, exception);
}
catch (UnauthorizedAccessException exception2)
{
base.OnComplete(false, exception2);
}
catch (DirectoryNotFoundException exception3)
{
base.OnComplete(false, exception3);
}
catch (PathTooLongException exception4)
{
base.OnComplete(false, exception4);
}
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
if (this.dataObject == null)
{
if (this.creator != null)
{
this.dataObject = this.creator.Create(this.table);
return;
}
ConstructorInfo constructor = this.type.GetConstructor(new Type[0]);
if (null != constructor)
{
this.dataObject = constructor.Invoke(new object[0]);
return;
}
}
else
{
if (store.GetDataObject(this.dataObjectName) != null)
{
this.dataObject = store.GetDataObject(this.dataObjectName);
}
IConfigurable configurable = this.DataObject as IConfigurable;
if (configurable != null)
{
try
{
configurable.ResetChangeTracking();
}
catch (NotImplementedException)
{
}
}
}
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
base.OnStart();
string path = (string)row[base.FilePathParameterName];
try
{
using (FileStream fileStream = new FileStream(path, FileMode.Create))
{
byte[] array = (byte[])row[this.FileDataParameterName];
fileStream.Write(array, 0, array.Length);
base.OnComplete(true, null);
}
}
catch (UnauthorizedAccessException exception)
{
base.OnComplete(false, exception);
}
catch (DirectoryNotFoundException exception2)
{
base.OnComplete(false, exception2);
}
catch (PathTooLongException exception3)
{
base.OnComplete(false, exception3);
}
catch (SecurityException exception4)
{
base.OnComplete(false, exception4);
}
catch (IOException exception5)
{
base.OnComplete(false, exception5);
}
}
public virtual bool IsRunnable(DataRow row, DataObjectStore store)
{
if (!string.IsNullOrEmpty(this.RunnableLambdaExpression))
{
return((bool)ExpressionCalculator.CalculateLambdaExpression(ExpressionCalculator.BuildColumnExpression(this.RunnableLambdaExpression), typeof(bool), row, null));
}
return(this.RunnableTester == null || this.RunnableTester.IsRunnable(row));
}
public override bool IsRunnable(DataRow row, DataObjectStore store)
{
bool flag = true;
if (!string.IsNullOrEmpty(this.DataObjectName))
{
flag = (store.GetModifiedPropertiesBasedOnDataObject(row, this.DataObjectName).Count > 0);
}
return(flag && base.IsRunnable(row, store));
}
private void bindingSource_ListChanged(object sender, ListChangedEventArgs e)
{
BindingSource bindingSource = (BindingSource)sender;
IVersionable versionable = bindingSource.DataSource as IVersionable;
if (versionable != null)
{
if (!this.datasourceVersions.ContainsKey(bindingSource))
{
this.datasourceVersions[bindingSource] = versionable.ExchangeVersion;
this.DisableControlsByVersion(bindingSource, versionable);
return;
}
ExchangeObjectVersion exchangeObjectVersion = this.datasourceVersions[bindingSource];
if (!exchangeObjectVersion.IsSameVersion(versionable.ExchangeVersion))
{
this.datasourceVersions[bindingSource] = versionable.ExchangeVersion;
this.EnableControlsByVersion(bindingSource, versionable);
return;
}
}
else
{
DataTable dataTable = bindingSource.DataSource as DataTable;
if (dataTable != null)
{
DataObjectStore dataObjectStore = dataTable.ExtendedProperties["DataSourceStore"] as DataObjectStore;
if (dataObjectStore != null)
{
foreach (string text in dataObjectStore.GetKeys())
{
IVersionable versionable2 = dataObjectStore.GetDataObject(text) as IVersionable;
if (versionable2 != null)
{
if (this.dataSourceInTableVersions.ContainsKey(text))
{
ExchangeObjectVersion exchangeObjectVersion2 = this.dataSourceInTableVersions[text];
if (!exchangeObjectVersion2.IsSameVersion(versionable2.ExchangeVersion))
{
this.dataSourceInTableVersions[text] = versionable2.ExchangeVersion;
this.EnableControlsByVersion(bindingSource, versionable2);
}
}
else
{
this.dataSourceInTableVersions[text] = versionable2.ExchangeVersion;
this.DisableControlsByVersion(bindingSource, versionable2);
}
}
}
}
}
}
}
public DataObjectStore Clone()
{
DataObjectStore dataObjectStore = new DataObjectStore();
dataObjectStore.ModifiedColumns.AddRange(this.ModifiedColumns);
dataObjectStore.ModifiedColumnsAfterCreation.AddRange(this.ModifiedColumnsAfterCreation);
foreach (string key in this.store.Keys)
{
dataObjectStore.store[key] = (DataObjectProfile)this.store[key].Clone();
}
return(dataObjectStore);
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
base.OnStart();
object value = row[base.FileDataParameterName];
try
{
using (new OpenConnection(FormatListFileSaveSaver.connection))
{
object[] value2 = null;
string variableName = "FormatEnumerationLimit";
int num = -1;
object variable = this.GetVariable(variableName, FormatListFileSaveSaver.connection);
if (variable != null)
{
int.TryParse(variable.ToString(), out num);
}
this.SetVariable(variableName, -1, FormatListFileSaveSaver.connection);
using (MonadCommand monadCommand = new MonadCommand("Format-List", FormatListFileSaveSaver.connection))
{
monadCommand.Parameters.Add(new MonadParameter("InputObject", value));
value2 = monadCommand.Execute();
}
using (MonadCommand monadCommand2 = new MonadCommand("Out-File", FormatListFileSaveSaver.connection))
{
monadCommand2.Parameters.Add(new MonadParameter("InputObject", value2));
monadCommand2.Parameters.Add(new MonadParameter("FilePath", row[base.FilePathParameterName]));
monadCommand2.Execute();
}
if (num != -1)
{
this.SetVariable(variableName, num, FormatListFileSaveSaver.connection);
}
base.OnComplete(true, null);
}
}
catch (CommandExecutionException exception)
{
base.OnComplete(false, exception);
}
catch (CmdletInvocationException exception2)
{
base.OnComplete(false, exception2);
}
catch (PipelineStoppedException exception3)
{
base.OnComplete(false, exception3);
}
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
this.dataObject = this.Type.GetConstructor(new Type[0]).Invoke(new object[0]);
foreach (ParameterProfile parameterProfile in this.paramInfos)
{
if (parameterProfile.IsRunnable(row))
{
object obj = row[parameterProfile.Reference];
if (DBNull.Value.Equals(obj))
{
obj = null;
}
this.Type.GetProperty(parameterProfile.Name).SetValue(this.dataObject, obj, null);
}
}
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
this.DataHandler.ProgressReport += base.OnProgressReport;
try
{
this.DataHandler.Save(interactionHandler as CommandInteractionHandler);
}
finally
{
this.DataHandler.ProgressReport -= base.OnProgressReport;
}
if (!this.DataHandler.HasWorkUnits || !this.DataHandler.WorkUnits.HasFailures)
{
store.ClearModifiedColumns(row, this.DataObjectName);
}
}
public bool IsRunnable(DataRow row)
{
if (this.ParameterType == ParameterType.ModifiedColumn)
{
DataObjectStore dataObjectStore = row.Table.ExtendedProperties["DataSourceStore"] as DataObjectStore;
if (dataObjectStore == null || !dataObjectStore.ModifiedColumns.Contains(this.Reference))
{
return(false);
}
}
if (!string.IsNullOrEmpty(this.RunnableLambdaExpression))
{
return((bool)ExpressionCalculator.CalculateLambdaExpression(ExpressionCalculator.BuildColumnExpression(this.RunnableLambdaExpression), typeof(bool), row, null));
}
return(this.runnableTester == null || this.runnableTester.IsRunnable(row));
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
object[] array = this.Command.Execute();
switch (array.Length)
{
case 0:
break;
case 1:
this.dataObject = array[0];
break;
default:
return;
}
}
private void SetConstraintsFromBinding(Binding binding)
{
if (binding.BindingManagerBase != null)
{
if (!this.IsFormatModeAndBindingCompatible(this.ownerControl.FormatMode, binding))
{
throw new InvalidOperationException();
}
PropertyDescriptorCollection itemProperties = binding.BindingManagerBase.GetItemProperties();
PropertyDescriptor propertyDescriptor = itemProperties.Find(binding.BindingMemberInfo.BindingField, true);
if (propertyDescriptor != null)
{
FilterValuePropertyDescriptor filterValuePropertyDescriptor = propertyDescriptor as FilterValuePropertyDescriptor;
Type propertyType;
if (filterValuePropertyDescriptor != null)
{
propertyType = filterValuePropertyDescriptor.ValuePropertyType;
}
else
{
propertyType = propertyDescriptor.PropertyType;
}
object obj = (binding.DataSource is BindingSource) ? ((BindingSource)binding.DataSource).DataSource : binding.DataSource;
DataTable dataTable = obj as DataTable;
if (dataTable != null)
{
DataObjectStore dataObjectStore = dataTable.ExtendedProperties["DataSourceStore"] as DataObjectStore;
if (dataObjectStore != null)
{
DataColumn dataColumn = dataTable.Columns[binding.BindingMemberInfo.BindingField];
ColumnProfile columnProfile = dataColumn.ExtendedProperties["ColumnProfile"] as ColumnProfile;
if (!string.IsNullOrEmpty(columnProfile.DataObjectName))
{
Type dataObjectType = dataObjectStore.GetDataObjectType(columnProfile.DataObjectName);
if (null != dataObjectType)
{
obj = dataObjectType;
propertyType = dataObjectType.GetProperty(columnProfile.MappingProperty).PropertyType;
}
}
}
}
PropertyDefinitionConstraint[] propertyDefinitionConstraints = PropertyConstraintProvider.GetPropertyDefinitionConstraints(obj, binding.BindingMemberInfo.BindingField);
this.SetConstraintsFromType(propertyType, propertyDefinitionConstraints);
}
}
}
public override void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos)
{
if (!string.IsNullOrEmpty(this.CommandTextLambdaExpression))
{
this.DataHandler.CommandText = (string)ExpressionCalculator.CalculateLambdaExpression(ExpressionCalculator.BuildColumnExpression(this.CommandTextLambdaExpression), typeof(string), row, null);
}
this.DataHandler.Parameters.Clear();
if (!string.IsNullOrEmpty(this.DataObjectName))
{
this.DataHandler.Parameters.AddWithValue("Instance", store.GetDataObject(this.DataObjectName));
}
else
{
this.DataHandler.KeepInstanceParamerter = true;
}
MonadSaveTask.BuildParametersCore(row, paramInfos, this.DataHandler.Parameters);
this.workUnitDescription = MonadSaveTask.BuildParametersDescription(row, paramInfos);
this.DataHandler.ClearParameterNames();
this.DataHandler.SpecifyParameterNames(store.GetModifiedPropertiesBasedOnDataObject(row, this.DataObjectName));
}
public override void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos)
{
base.BuildParameters(row, store, paramInfos);
this.paramInfos = paramInfos;
}
public override void Execute(TaskProfileBase profile, DataRow row, DataObjectStore store)
{
this.ConnectTo((string)row["TargetForest"]);
base.Execute(profile, row, store);
}
public override bool IsRunnable(DataRow row, DataObjectStore store)
{
return(true);
}
public virtual void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos)
{
}
public override void Execute(TaskProfileBase profile, DataRow row, DataObjectStore store)
{
profile.Run(null, row, store);
}
public void BuildParameters(DataRow row, DataObjectStore store)
{
this.runner.BuildParameters(row, store, this.GetEffectiveParameters());
}
internal override void Run(CommandInteractionHandler interactionHandler, DataRow row, DataObjectStore store)
{
(base.Runner as Reader).Run(interactionHandler, row, store);
}
internal override void Run(CommandInteractionHandler interactionHandler, DataRow row, DataObjectStore store)
{
this.Saver.Run(interactionHandler, row, store);
if (this.Saver.SavedResults.Count > 0)
{
foreach (string text in this.SavedResultMapping.Keys)
{
object value = (text != "WholeObjectProperty") ? this.Saver.SavedResults[0].GetType().GetProperty(text).GetValue(this.Saver.SavedResults[0], null) : this.Saver.SavedResults[0];
row[this.SavedResultMapping[text]] = value;
}
}
}
public virtual Reader CreateBulkReader(string dataObjectName, DataObjectStore store, DataTable table)
{
return(new BulkEditReaderTask(store.GetDataObjectType(dataObjectName), store.GetDataObjectCreator(dataObjectName), dataObjectName, table));
}
public override void Run(object interactionHandler, DataRow row, DataObjectStore store)
{
this.dataObject = new List <object>(this.Command.Execute());
}
public abstract void Execute(TaskProfileBase profile, DataRow row, DataObjectStore store);
public abstract void Run(object interactionHandler, DataRow row, DataObjectStore store);
public bool IsRunnable(DataRow row, DataObjectStore store)
{
return(this.runner.IsRunnable(row, store));
}
public override void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos)
{
this.Command.Parameters.Clear();
MonadSaveTask.BuildParametersCore(row, paramInfos, this.Command.Parameters);
}
internal abstract void Run(CommandInteractionHandler interactionHandler, DataRow row, DataObjectStore store);
public override void Execute(TaskProfileBase profile, DataRow row, DataObjectStore store)
{
ReaderTaskProfile readerTaskProfile = profile as ReaderTaskProfile;
if (readerTaskProfile != null && !readerTaskProfile.HasPermission() && this.IsPropertyPage)
{
return;
}
Stopwatch stopwatch = new Stopwatch();
MonadCommand monadCommand = null;
if (profile.Runner is MonadReadTask)
{
monadCommand = ((MonadReadTask)profile.Runner).Command;
}
else if (profile.Runner is GroupReadTask)
{
monadCommand = ((GroupReadTask)profile.Runner).Command;
}
else if (profile.Runner is MonadSaveTask)
{
monadCommand = ((MonadSaveTask)profile.Runner).Command;
}
else if (profile.Runner is MonadPipelineSaveTask)
{
monadCommand = ((MonadPipelineSaveTask)profile.Runner).Command;
}
else if (!(profile.Runner is CreateDataObjectReader))
{
if (profile.Runner is MembersSaveTask)
{
(profile.Runner as MembersSaveTask).UpdateConnection(this.connection);
}
else if (profile.Runner is GroupSaveTask)
{
(profile.Runner as GroupSaveTask).UpdateConnection(this.connection);
}
else if (profile.Runner is ClientPermissionSaveTask)
{
(profile.Runner as ClientPermissionSaveTask).UpdateConnection(this.connection);
}
}
if (monadCommand != null)
{
monadCommand.Connection = this.connection;
}
try
{
if (monadCommand != null)
{
ExTraceGlobals.DataFlowTracer.TracePerformance <string, Guid, RunspaceState>((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In runspace {1}[State:{2}], before executing command '{0}' .", monadCommand.CommandText, monadCommand.Connection.RunspaceProxy.InstanceId, monadCommand.Connection.RunspaceProxy.State);
}
stopwatch.Start();
profile.Run(null, row, store);
}
catch (CommandExecutionException)
{
if (!profile.IgnoreException)
{
throw;
}
}
catch (CmdletInvocationException)
{
if (!profile.IgnoreException)
{
throw;
}
}
catch (PipelineStoppedException)
{
if (!profile.IgnoreException)
{
throw;
}
}
finally
{
stopwatch.Stop();
if (monadCommand != null)
{
ExTraceGlobals.DataFlowTracer.TracePerformance((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In the runspace {1}[State:{2}], {3} Milliseconds are taken to finish the command {0}.", new object[]
{
monadCommand.CommandText,
monadCommand.Connection.RunspaceProxy.InstanceId,
monadCommand.Connection.RunspaceProxy.State,
stopwatch.ElapsedMilliseconds
});
}
}
}
