protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var command = Command.Get(context);
var checkExitCode = CheckExitCode.Get(context);
var shellStream = ShellStream.Get(context);
var shellExpectedPrompt = ShellExpectedPrompt.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(TimeoutMS.Get(context), cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
if (task.Exception != null)
{
throw task.Exception;
}
// Outputs
return((ctx) => {
Result.Set(ctx, task.Result);
});
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
var imageFilePath = ImageFilePath.Get(context);
if (!File.Exists(imageFilePath))
{
throw new FileNotFoundException(imageFilePath);
}
if (!Directory.Exists(Path.GetDirectoryName(imageFilePath)))
{
throw new ArgumentException(string.Format(Resources.ValidationValueFullPath_Error, Resources.ChangeWallpaper_ImageFilePath_DisplayName));
}
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
// Outputs
return((ctx) => {
Result.Set(ctx, task.Result);
});
}
protected override IAsyncResult BeginExecute(NativeActivityContext context, AsyncCallback callback, object state)
{
string restApiUrl = RestApiUrl.Get(context);
if (!restApiUrl.EndsWith("/"))
{
restApiUrl += "/";
}
string client_id = ClientId.Get(context);
string client_secret;
if (ClientSecretSecure.Get(context) != null)
{
client_secret = SecureStringToString(ClientSecretSecure.Get(context));
}
else
{
client_secret = ClientSecretInsecure.Get(context);
}
string redirect_uri = RedirectUrl.Get(context);
int serverTimeout = TimeoutMS.Get(context);
authAgent = new AuthenticationAgent(restApiUrl, client_id, client_secret, redirect_uri, serverTimeout);
authAgent.GetAuthUrl();
ScheduleAuthActivities(context);
AuthenticateAsyncDelegate = new Action(AuthenticateAsync);
return(AuthenticateAsyncDelegate.BeginInvoke(callback, state));
}
protected override void Execute(CodeActivityContext context)
{
Int32 _timeout = TimeoutMS.Get(context);
CallWithTimeout(new Action(() => {
try
{
string credName = CredentialName.Get(context);
IntPtr credPtr = new IntPtr();
WReadCred(credName, CRED_TYPE.GENERIC, CRED_PERSIST.LOCAL_MACHINE, out credPtr);
if (credPtr.ToInt32() == 0)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "凭证不存在");
return;
}
Credential lRawCredential = (Credential)Marshal.PtrToStructure(credPtr, typeof(Credential));
SecureString securePassWord = new SecureString();
foreach (char c in lRawCredential.CredentialBlob)
{
securePassWord.AppendChar(c);
}
UserName.Set(context, lRawCredential.UserName);
PassWord.Set(context, securePassWord);
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "读取凭证执行过程出错", e.Message);
}
}), _timeout);
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
/* I'm guessing these inputs are useless! They aren't passed to the timeout exec.
* var endpointURL = EndpointURL.Get(context);
* var apiKey = APIKey.Get(context);
* var queryData = QueryData.Get(context);
*/
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
// Prepare result for return
// probably task.Result and finalResult are actually the same and this is useless (?)
JObject jsonResponse = JObject.Parse(task.Result);
string finalResult = jsonResponse.ToString();
// Outputs
return((ctx) => {
EndpointResult.Set(ctx, finalResult);
});
}
protected override async Task <Action <NativeActivityContext> > ExecuteAsync(NativeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
var orchestratorName = OrchestratorName.Get(context);
var clientID = ClientID.Get(context);
var userKey = UserKey.Get(context);
var tenantName = TenantName.Get(context);
var existingAccessToken = ExistingAccessToken.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
await task;
return((ctx) => {
// Schedule child activities
if (Body != null)
{
ctx.ScheduleAction <IObjectContainer>(Body, _objectContainer, OnCompleted, OnFaulted);
}
// Outputs
AccessToken.Set(ctx, null);
});
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
CancellationTokenSource cancellationTokenSource2 = (CancellationTokenSource)(context.UserState = new CancellationTokenSource());
int timeout = TimeoutMS.Get(context);
Task <List <MailMessage> > messages = GetMessages(context, cancellationTokenSource2.Token);
TaskCompletionSource <List <MailMessage> > taskCompletionSource = new TaskCompletionSource <List <MailMessage> >(state);
TaskHandler(callback, messages, taskCompletionSource, cancellationTokenSource2.Token, timeout);
return(taskCompletionSource.Task);
}
protected override void Execute(CodeActivityContext context)
{
string attribute_str = Attribute.Get(context);
string attribute_value = Value.Get(context);
try
{
Int32 _timeout = TimeoutMS.Get(context);
Thread.Sleep(_timeout);
latch = new CountdownEvent(1);
Thread td = new Thread(() =>
{
if (Selector.Expression == null)
{
//ActiveElement处理
}
else
{
var selStr = Selector.Get(context);
UiElement element = GetValueOrDefault(context, this.Element, null);
if (element == null && selStr != null)
{
element = UiElement.FromSelector(selStr);
}
if (element != null)
{
element.SetForeground();
mshtml.IHTMLDocument2 currDoc = null;
SHDocVw.InternetExplorer ieBrowser = GetIEFromHWndClass.GetIEFromHWnd((int)element.WindowHandle, out currDoc);
mshtml.IHTMLElement currEle = GetIEFromHWndClass.GetEleFromDoc(
element.GetClickablePoint(), (int)element.WindowHandle, currDoc);
currEle.setAttribute(attribute_str, attribute_value);
}
else
{
UIAutomationCommon.HandleContinueOnError(context, ContinueOnError, Localize.LocalizedResources.GetString("msgNoElementFound"));
}
}
refreshData(latch);
});
td.TrySetApartmentState(ApartmentState.STA);
td.IsBackground = true;
td.Start();
latch.Wait();
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "出现异常", e.Message);
if (ContinueOnError.Get(context))
{
}
}
}
protected override System.IAsyncResult BeginExecute(AsyncCodeActivityContext context, System.AsyncCallback callback, object state)
{
string connString = null;
string provName = null;
string sql = string.Empty;
int commandTimeout = TimeoutMS.Get(context);
if (commandTimeout < 0)
{
throw new ArgumentException(UiPath.Database.Activities.Properties.Resources.TimeoutMSException, "TimeoutMS");
}
Dictionary <string, Tuple <object, ArgumentDirection> > parameters = null;
try
{
sql = Sql.Get(context);
DbConnection = ExistingDbConnection.Get(context);
connString = ConnectionString.Get(context);
provName = ProviderName.Get(context);
if (Parameters != null)
{
parameters = new Dictionary <string, Tuple <object, ArgumentDirection> >();
foreach (var param in Parameters)
{
parameters.Add(param.Key, new Tuple <object, ArgumentDirection>(param.Value.Get(context), param.Value.Direction));
}
}
}
catch (Exception ex)
{
HandleException(ex, ContinueOnError.Get(context));
}
// create the action for doing the actual work
Func <DBExecuteCommandResult> action = () =>
{
DBExecuteCommandResult executeResult = new DBExecuteCommandResult();
if (DbConnection == null)
{
DbConnection = new DatabaseConnection().Initialize(connString, provName);
}
if (DbConnection == null)
{
return(executeResult);
}
executeResult = new DBExecuteCommandResult(DbConnection.Execute(sql, parameters, commandTimeout, CommandType), parameters);
return(executeResult);
};
context.UserState = action;
return(action.BeginInvoke(callback, state));
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
// Outputs
return((ctx) => {
ModelGroupData.Set(ctx, task.Result);
});
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
int num = TimeoutMS.Get(context);
string body = Body.Get(context);
MailMessage mailMessage = MailMessage.Get(context);
if (mailMessage == null)
{
throw new ArgumentNullException("MailMessage对象不能为空！");
}
MailMessage message = mailMessage;
List <string> attachments = new List <string>();
foreach (InArgument <string> file in Files)
{
AddAttachments(attachments, file.Get(context));
}
foreach (string item in AttachmentsCollection.Get(context).EmptyIfNull())
{
AddAttachments(attachments, item);
}
num = ((num <= 0) ? DefaultTimeoutMS : num);
using (CancellationTokenSource timeoutCts = new CancellationTokenSource(num))
{
using (CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken))
{
try
{
await OutlookAPI.ReplyToAsync(message, body, attachments, ReplyAll, cts.Token);
}
catch (OperationCanceledException)
{
if (timeoutCts.IsCancellationRequested)
{
throw new TimeoutException();
}
throw;
}
}
}
return(delegate
{
});
}
protected override async Task <Action <NativeActivityContext> > ExecuteAsync(NativeActivityContext context, CancellationToken ct)
{
string javaPath = JavaPath.Get(context);
var javaExec = _javaExeWindows;
#if NETCOREAPP
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
javaExec = _javaExeLinux;
}
#endif
if (javaPath != null)
{
javaPath = Path.Combine(javaPath, "bin", javaExec);
if (!File.Exists(javaPath))
{
throw new ArgumentException(Resources.InvalidJavaPath, Resources.JavaPathDisplayName);
}
}
_invoker = new JavaInvoker(javaPath);
int initTimeout = TimeoutMS.Get(context);
if (initTimeout < 0)
{
throw new ArgumentException(UiPath.Java.Activities.Properties.Resources.TimeoutMSException, "TimeoutMS");
}
try
{
await _invoker.StartJavaService(initTimeout);
}
catch (Exception e)
{
Trace.TraceError($"Error initializing Java Invoker: {e}");
throw new InvalidOperationException(string.Format(Resources.JavaInitiazeException, e.ToString()));
}
ct.ThrowIfCancellationRequested();
return(ctx =>
{
ctx.ScheduleAction(Body, _invoker, OnCompleted, OnFaulted);
});
}
protected override IAsyncResult BeginExecute(NativeActivityContext context, AsyncCallback callback, object state)
{
string restApiUrl = RestApiUrl.Get(context);
if (!restApiUrl.EndsWith("/"))
{
restApiUrl += "/";
}
string client_id = ClientId.Get(context);
string client_secret;
if (ClientSecretSecure.Get(context) != null)
{
client_secret = SecureStringToString(ClientSecretSecure.Get(context));
}
else
{
client_secret = ClientSecretInsecure.Get(context);
}
string redirect_uri = RedirectUrl.Get(context);
int serverTimeout = TimeoutMS.Get(context);
authAgent = new AuthenticationAgent(restApiUrl, client_id, client_secret, redirect_uri, serverTimeout);
if (AuthentificationTokenIn.Get(context) != null)
{
authAgent.authToken = JsonConvert.DeserializeObject <AuthToken>(AuthentificationTokenIn.Get(context));
authAgent.GetAuthUrl();
authAgent.authCode = JsonConvert.DeserializeObject <ConcurrentDictionary <string, string> >(AuthentificationCodeIn.Get(context));
AuthenticateAsyncDelegate = new Action(ConfigureAuthentification);
}
else
{
authAgent.GetAuthUrl();
ScheduleAuthActivities(context);
AuthenticateAsyncDelegate = new Action(AuthenticateAsync);
}
return(AuthenticateAsyncDelegate.BeginInvoke(callback, state));
}
protected override void Execute(CodeActivityContext context)
{
Int32 _timeout = TimeoutMS.Get(context);
CallWithTimeout(new Action(() => {
try
{
string credName = CredentialName.Get(context);
string userName = UserName.Get(context);
SecureString credentialName = PassWord.Get(context);
IntPtr inP = Marshal.SecureStringToBSTR(credentialName);
string passWord = Marshal.PtrToStringBSTR(inP);
WriteCred(credName, userName, passWord, CRED_TYPE.GENERIC, CRED_PERSIST.LOCAL_MACHINE);
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "设置凭证执行过程出错", e.Message);
}
}), _timeout);
}
protected override async Task <Action <NativeActivityContext> > ExecuteAsync(NativeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var activityTimeout = TimeoutMS.Get(context);
var host = Host.Get(context);
var port = Port.Get(context);
var username = Username.Get(context);
var password = Password.Get(context);
var shellExpectedPrompt = ShellExpectedPrompt.Get(context);
var proxyHost = ProxyHost.Get(context);
var proxyPort = ProxyPort.Get(context);
var proxyUsername = ProxyUsername.Get(context);
var proxyPassword = ProxyPassword.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(activityTimeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
if (task.Exception != null)
{
throw task.Exception;
}
_objectContainer.Add(sshClient);
_objectContainer.Add(currentShellStream);
_objectContainer.Add(expectedPromptRegex);
return((ctx) => {
// Schedule child activities
if (Body != null)
{
ctx.ScheduleAction <IObjectContainer>(Body, _objectContainer, OnCompleted, OnFaulted);
}
});
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
CancellationTokenSource cancellationTokenSource2 = (CancellationTokenSource)(context.UserState = new CancellationTokenSource());
Receiver reciever = new Receiver(To.Get(context), Cc.Get(context), Bcc.Get(context));
bool isNewMessage = false;
MailMessage mailMessage = MailMessage.Get(context);
string body = Body.Get(context);
if (mailMessage == null)
{
mailMessage = new MailMessage();
mailMessage.Subject = Subject.Get(context);
mailMessage.Body = body;
isNewMessage = true;
}
mailMessage.IsBodyHtml = IsBodyHtml;
int timeout = TimeoutMS.Get(context);
Task task = SendMailTask(context, reciever, mailMessage, cancellationTokenSource2.Token, isNewMessage, body);
TaskCompletionSource <object> taskCompletionSource = new TaskCompletionSource <object>(state);
TaskHandler(callback, task, taskCompletionSource, cancellationTokenSource2.Token, mailMessage, isNewMessage, timeout);
return(taskCompletionSource.Task);
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
var filePath = FilePath.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, filePath, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)).ConfigureAwait(false) != task)
{
if (ThrowFileException && _latestFileException != null)
{
throw _latestFileException;
}
throw new TimeoutException(Resources.Timeout_Error);
}
await task.ConfigureAwait(false);
// Outputs
return((ctx) => FileInfo.Set(ctx, new FileInfo(filePath)));
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var timeout = TimeoutMS.Get(context);
var inputImage = InputImage.Get(context);
var positionX = PositionX.Get(context);
var positionY = PositionY.Get(context);
var width = Width.Get(context);
var height = Height.Get(context);
var blur = Blur.Get(context);
var blurAmount = BlurAmount.Get(context);
// Set a timeout on the execution
var task = ExecuteWithTimeout(context, cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) != task)
{
throw new TimeoutException(Resources.Timeout_Error);
}
Image returnImage;
// Check if activity should blur or hide part of the image
if (blur)
{
// Convert image to bytestream
ImageConverter _imageConverter = new ImageConverter();
byte[] imageByteStream = (byte[])_imageConverter.ConvertTo(inputImage, typeof(byte[]));
// Create image from bytestream for MagickImage use
var magickimage = new MagickImage(imageByteStream);
// Blur part of image
magickimage.RegionMask(new MagickGeometry(positionX, positionY, width, height));
magickimage.GaussianBlur(blurAmount, 25);
magickimage.RemoveRegionMask();
// Convert MagickInmage to Bytestream
var imageBytesOut = magickimage.ToByteArray();
MemoryStream ms = new MemoryStream(imageBytesOut);
// Create return image from bytestream
returnImage = Image.FromStream(ms);
}
else
{
// Create graphics context with returnImage
returnImage = inputImage;
using (Graphics g = Graphics.FromImage(returnImage))
{
// Define brush and rectangle
SolidBrush blackBrush = new SolidBrush(Color.Black);
Rectangle rect = new Rectangle(positionX, positionY, width, height);
// Fill rectangle
g.FillRectangle(blackBrush, rect);
// Cleanup
g.Dispose();
}
}
// Outputs
return((ctx) => {
OutputImage.Set(ctx, returnImage);
});
}
protected async override Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
string connString = null;
SecureString connSecureString = null;
string provName = null;
string sql = string.Empty;
int commandTimeout = TimeoutMS.Get(context);
DatabaseConnection existingConnection = null;
DBExecuteCommandResult affectedRecords = null;
if (commandTimeout < 0)
{
throw new ArgumentException(Resources.TimeoutMSException, "TimeoutMS");
}
Dictionary <string, Tuple <object, ArgumentDirection> > parameters = null;
var continueOnError = ContinueOnError.Get(context);
try
{
sql = Sql.Get(context);
existingConnection = DbConnection = ExistingDbConnection.Get(context);
connString = ConnectionString.Get(context);
connSecureString = ConnectionSecureString.Get(context);
provName = ProviderName.Get(context);
if (Parameters != null)
{
parameters = new Dictionary <string, Tuple <object, ArgumentDirection> >();
foreach (var param in Parameters)
{
parameters.Add(param.Key, new Tuple <object, ArgumentDirection>(param.Value.Get(context), param.Value.Direction));
}
}
ConnectionHelper.ConnectionValidation(existingConnection, connSecureString, connString, provName);
// create the action for doing the actual work
affectedRecords = await Task.Run(() =>
{
DBExecuteCommandResult executeResult = new DBExecuteCommandResult();
if (DbConnection == null)
{
DbConnection = new DatabaseConnection().Initialize(connString ?? new NetworkCredential("", connSecureString).Password, provName);
}
if (DbConnection == null)
{
return(executeResult);
}
executeResult = new DBExecuteCommandResult(DbConnection.Execute(sql, parameters, commandTimeout, CommandType), parameters);
return(executeResult);
});
}
catch (Exception ex)
{
HandleException(ex, continueOnError);
}
finally
{
if (existingConnection == null)
{
DbConnection?.Dispose();
}
}
return(asyncCodeActivityContext =>
{
AffectedRecords.Set(asyncCodeActivityContext, affectedRecords.Result);
foreach (var param in affectedRecords.ParametersBind)
{
var currentParam = Parameters[param.Key];
if (currentParam.Direction == ArgumentDirection.Out || currentParam.Direction == ArgumentDirection.InOut)
{
currentParam.Set(asyncCodeActivityContext, param.Value.Item1);
}
}
});
}
protected override void Execute(NativeActivityContext context)
{
try
{
Int32 _timeout = TimeoutMS.Get(context);
Thread.Sleep(_timeout);
latch = new CountdownEvent(1);
Thread td = new Thread(() =>
{
if (Selector.Expression == null)
{
Browser getBrowser = currBrowser.Get(context);
if (getBrowser != null)
{
if (getBrowser.getIEBrowser() != null)
{
if (UiBrowser != null)
{
UiBrowser.Set(context, getBrowser);
}
}
context.ScheduleAction(Body, getBrowser, OnCompleted, OnFaulted);
}
}
else
{
var allBrowsers = new SHDocVw.ShellWindows();
switch (BrowserType)
{
case BrowserTypes.IE:
{
var selStr = Selector.Get(context);
UiElement element = UiElement.FromSelector(selStr);
IntPtr handle = IntPtr.Zero;
if (element != null)
{
handle = element.WindowHandle;
}
mshtml.IHTMLDocument2 currDoc = null;
SHDocVw.InternetExplorer ieBrowser = GetIEFromHWndClass.GetIEFromHWnd((int)handle, out currDoc);
Browser thisBrowser = new Browser();
thisBrowser.SetIEBrowser(ieBrowser);
if (UiBrowser != null)
{
UiBrowser.Set(context, thisBrowser);
}
ArrayList list = new ArrayList();
var allShellWindows = new SHDocVw.ShellWindows();
foreach (SHDocVw.InternetExplorer browser in allShellWindows)
{
list.Add(browser);
}
CommonVariable.BrowsersList = list;
context.ScheduleAction(Body, thisBrowser);
break;
}
case BrowserTypes.Chrome:
{
break;
}
case BrowserTypes.Firefox:
{
break;
}
default:
break;
}
}
refreshData(latch);
});
td.TrySetApartmentState(ApartmentState.STA);
td.IsBackground = true;
td.Start();
latch.Wait();
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "出现异常", e.Message);
if (ContinueOnError.Get(context))
{
}
}
}
