public async Task Activity_call_with_valid_payload_should_be_valid()
{
var mockContext = new Mock <IDurableOrchestrationContext>();
var retryOptions = new RetryOptions(
firstRetryInterval: TimeSpan.FromSeconds(5),
maxNumberOfAttempts: 3);
var item = new TransactionItem
{
Id = Guid.NewGuid().ToString(),
AccountFromId = Guid.NewGuid().ToString(),
AccountToId = Guid.NewGuid().ToString(),
Amount = 100.00M,
State = SagaState.Pending.ToString()
};
var activity = new Activity <TransactionItem>
{
FunctionName = nameof(OrchestratorActivity.SagaOrchestratorActivity),
Input = item,
Context = mockContext.Object
};
mockContext
.Setup(x => x.CallActivityWithRetryAsync <TransactionItem>(activity.FunctionName, retryOptions, activity.Input))
.ReturnsAsync(item);
ActivityResult <TransactionItem> result = await ActivityFactory.CallActivityWithRetryAndTimeoutAsync(activity);
Assert.True(result.Valid);
Assert.NotNull(result.Item);
Assert.Equal(result.ExceptionMessage, string.Empty);
}
public async Task InvokeAsync_SetsActivityProperties(int statusCode, ActivityResult result)
{
string scheme = "https";
int localPort = 8080;
Task RequestDelegate(HttpContext context)
{
context.Response.StatusCode = statusCode;
context.Request.Scheme = scheme;
context.Connection.LocalPort = localPort;
return(Task.CompletedTask);
}
HttpContext context = new DefaultHttpContext();
IMiddleware middleware = new ActivityEnrichmentMiddleware();
Activity activity = new Activity("TestName").Start();
await middleware.InvokeAsync(context, RequestDelegate).ConfigureAwait(false);
activity.Stop();
activity.AssertResult(result);
activity.AssertTag(ActivityTagKeys.SubType, $"{scheme}:{localPort}");
activity.AssertTag(ActivityTagKeys.Metadata, statusCode.ToString());
}
public void OnStop_UsingReplaySettingsAndResult_CallesLogReplayIfNeeded(ActivityResult result, bool replayLog, bool shouldBeCalled)
{
Activity activity = new Activity(nameof(OnStop_UsingReplaySettingsAndResult_CallesLogReplayIfNeeded)).SetResult(result);
Mock <IOptionsMonitor <OmexLoggingOptions> > mockOptions = new Mock <IOptionsMonitor <OmexLoggingOptions> >();
mockOptions.Setup(m => m.CurrentValue).Returns(new OmexLoggingOptions()
{
ReplayLogsInCaseOfError = shouldBeCalled,
});
IOptions <OmexLoggingOptions> options = Options.Create(new OmexLoggingOptions {
ReplayLogsInCaseOfError = replayLog
});
LogEventReplayerMock replayerMock = new LogEventReplayerMock();
ReplayableActivityStopObserver observer = new ReplayableActivityStopObserver(replayerMock, mockOptions.Object);
observer.OnStop(activity, null);
if (shouldBeCalled)
{
Assert.AreEqual(activity, replayerMock.Activity);
}
else
{
Assert.IsNull(replayerMock.Activity);
}
}
private void OpenFileHyperLink_Click(object sender, RoutedEventArgs e)
{
Hyperlink hyperlink = sender as Hyperlink;
OpenFileDialog openFileDialog = new OpenFileDialog()
{
Filter = "Fichier Studio des Langues Professeur|*.sdlp|Fichier Studio des Langues Elèves|*.sdle"
};
if (hyperlink.Tag as string == "Result")
{
openFileDialog.FilterIndex = 2;
}
if ((bool)openFileDialog.ShowDialog())
{
Hide();
if (Path.GetExtension(openFileDialog.FileName) == ".sdlp")
{
new MainWindow(ActivityPathParser.ParserInvert(openFileDialog.FileName), ref teacher).ShowDialog();
}
else if (Path.GetExtension(openFileDialog.FileName) == ".sdle")
{
ActivityResult activityResult = ActivityResult.Open(openFileDialog.FileName);
new ResultViewer(activityResult).ShowDialog();
}
if (!isClosed)
{
ShowDialog();
}
}
}
public ActivityResult Run(PipelineContext context)
{
var pipe = context.Pipeline as WeiboCleanPipeline;
var result = new ActivityResult();
result.ObjectType = typeof(int);
var weibolist = context[pipe.WeiboContextKey] as IEnumerable <Weibo_detailed>;
using (var db = ContextFactory.GetMediaAnalysisContext())
{
db.Configuration.AutoDetectChangesEnabled = false;
db.Configuration.ValidateOnSaveEnabled = false;
if (weibolist != null)
{
foreach (var item in weibolist)
{
item.Processed = true;
db.Weibo_detailed.Attach(item);
db.Entry(item).State = System.Data.Entity.EntityState.Modified;
}
}
try
{
result.Result = db.SaveChanges();
}
catch (Exception ex)
{
////@@TODO LOG
Debug.WriteLine(ex);
}
}
return(result);
}
public override ActivityResult Execute(IEvent e)
{
var data = Selector != null?e.GetEventData(Selector) : e.GetEventData();
Variables[VariableName] = data;
return(ActivityResult.Success());
}
public ActivityResult Run(PipelineContext context)
{
var pipe = context.Pipeline as NewsAnalysisPipeline;
ActivityResult result = new ActivityResult();
IDictionary <long, SentimentResult> dict = new Dictionary <long, SentimentResult>();
SentimentAnalyzer analyzer = new SentimentAnalyzer();
if (pipe != null)
{
var newsList = context[pipe.NewsContextKey] as IEnumerable <NewsStream>;
if (newsList != null)
{
var textList = newsList.Select(i => new KVPair <string, string> {
Key = i.Id.ToString(), Value = i.NewsArticleDescription
}).ToList();
var sentiment = analyzer.BatchAnalyze(textList).Result;
for (var i = 0; i < textList.Count; i++)
{
var id = newsList.ElementAt(i).Id;
dict.Add(id, sentiment.FirstOrDefault(s => s.Key == id.ToString())?.Value);
}
}
}
result.Result = dict;
result.ObjectType = dict.GetType();
return(result);
}
protected override async void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
ActivityResult?.Invoke(requestCode, resultCode, data);
var mediaPickerService = (MultiMediaPickerService)ComponentFactory.Resolve <IMultiMediaPickerService>();
await mediaPickerService.OnActivityResult(requestCode, resultCode, data);
}
public Task <ActivityResult> Run(PipelineContext context)
{
var pipe = context.Pipeline as WeiboCleanPipeline;
ActivityResult result = new ActivityResult();
List <Weibo_Retweeted> retweetedInfo = new List <Weibo_Retweeted>();
var weibolist = context[pipe.WeiboContextKey] as IEnumerable <Weibo_detailed>;
if (weibolist != null)
{
var retweetedList = weibolist.Where(i => !string.IsNullOrEmpty(i.retweeted_mid));
foreach (var item in retweetedList)
{
var line = new Weibo_Retweeted
{
mid = item.mid,
id_from = item.retweeted_uid,
id_to = item.user_uid,
weight = 1
};
retweetedInfo.Add(line);
}
}
result.Result = retweetedInfo;
result.ObjectType = retweetedInfo.GetType();
return(Task.FromResult(result));
}
protected override void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
if (requestCode != (int)Request.Voice)
{
return;
}
if (resultCode != Result.Ok)
{
return;
}
var results = data.GetStringArrayListExtra(RecognizerIntent.ExtraResults);
if (results.Count <= 0)
{
return;
}
var result = string.Join(" ", results);
_voiceResultValue = result;
if (_onVoiceResult != null)
{
_onVoiceResult.Start();
}
if (ActivityResult != null)
{
ActivityResult.Invoke(this, new ActivityResultArgs()
{
RequestCode = requestCode, ResultCode = resultCode, Data = data
});
}
}
public static ActivityResult Run([ActivityTrigger] IDurableActivityContext context)
{
return(ActivityResult.Fulfilled(nameof(BookHotelActivity), new Hotel
{
BookingId = Guid.NewGuid()
}));
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
//Since we set the request code to 1 for both the camera and photo gallery, that's what we need to check for
if (requestCode == 0)
{
if (resultCode == Result.Ok)
{
ActivityResult?.Invoke(this, new ActivityResultEventArgs {
Intent = data
});
Task.Run(() =>
{
if (App.ImageIdToSave != null)
{
var documentsDirectry = ActivityContext.GetExternalFilesDir(Android.OS.Environment.DirectoryPictures);
string pngFilename = System.IO.Path.Combine(documentsDirectry.AbsolutePath, App.ImageIdToSave + "." + FileFormatEnum.JPEG.ToString());
if (File.Exists(pngFilename))
{
Java.IO.File file = new Java.IO.File(documentsDirectry, App.ImageIdToSave + "." + FileFormatEnum.JPEG.ToString());
Android.Net.Uri uri = Android.Net.Uri.FromFile(file);
//Read the meta data of the image to determine what orientation the image should be in
var originalMetadata = new ExifInterface(pngFilename);
int orientation = GetRotation(originalMetadata);
var fileName = App.ImageIdToSave + "." + FileFormatEnum.JPEG.ToString();
HandleBitmap(uri, orientation, fileName);
}
}
});
}
}
else if (requestCode == 1)
{
if (resultCode == Result.Ok)
{
if (data.Data != null)
{
//Grab the Uri which is holding the path to the image
Android.Net.Uri uri = data.Data;
string fileName = null;
if (App.ImageIdToSave != null)
{
fileName = App.ImageIdToSave + "." + FileFormatEnum.JPEG.ToString();
var pathToImage = GetPathToImage(uri);
var originalMetadata = new ExifInterface(pathToImage);
int orientation = GetRotation(originalMetadata);
HandleBitmap(uri, orientation, fileName);
}
}
}
}
}
public Activity(string activityName, string typeName, ActivityResult result)
{
ActivityName = activityName;
TypeName = typeName;
Console.WriteLine($"Activity {ActivityName}:{TypeName} started.");
stopWatch = Stopwatch.StartNew();
}
public ActivityScore(ActivityResult activityResult, int activityScore, Percentage newMissionScore, P p, Type nextActivity)
{
NextActivity = nextActivity;
NewMissionScore = newMissionScore;
P = p;
ActivityResult = activityResult;
Score = activityScore;
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
ActivityResult?.Invoke(this, new ActivityResultEventArgs()
{
RequestCode = requestCode, ResultCode = resultCode, Data = data
});
base.OnActivityResult(requestCode, resultCode, data);
}
public WorkflowState Visit <TActivity, TInput, TOutput>(GraphNode <TContext, TActivity, TInput, TOutput> node) where TActivity : IActivity <TInput, TOutput>
{
TActivity activity;
if (typeof(TActivity) == typeof(GenericActivity))
{
activity = (TActivity)(object)new GenericActivity(m_ActivityExecutor, node.ActivityType, node.Name);
}
else
{
activity = m_Factory.Create <TActivity, TInput, TOutput>();
}
ActivityResult result = m_Resuming ? activity.Resume(output => node.ProcessOutput(m_Context, output), m_Closure) : activity.Execute(node.GetActivityInput(m_Context), output => node.ProcessOutput(m_Context, output));
var logItem = m_Execution.AddLog(node.Name);
m_Resuming = false;
logItem.Status = result;
if (result == ActivityResult.Pending)
{
m_Execution.State = WorkflowState.InProgress;
return(WorkflowState.InProgress);
}
if (result == ActivityResult.None)
{
m_Execution.State = WorkflowState.Corrupted;
return(WorkflowState.Corrupted);
}
logItem.End = DateTime.Now;
var next = node.Edges.SingleOrDefault(e => e.Condition(m_Context, result));
if (next != null)
{
var nextNode = m_Nodes[next.Node];
var nextResult = nextNode.Accept(this);
return(nextResult);
}
//TODO: =="end" is not good idea
if (node.Name == "end" && result == ActivityResult.Succeeded)
{
m_Execution.State = WorkflowState.Complete;
return(WorkflowState.Complete);
}
m_Execution.State = WorkflowState.Corrupted;
return(WorkflowState.Corrupted);
}
public async Task Activity_call_with_invalid_payload_should_be_invalid()
{
Activity <TransactionItem> activity = null;
ActivityResult <TransactionItem> result = await ActivityFactory.CallActivityWithRetryAndTimeoutAsync(activity);
Assert.False(result.Valid);
Assert.NotNull(result.Item);
Assert.NotEmpty(result.ExceptionMessage);
}
/// <summary>
/// Create the result instance for this activity
/// </summary>
public static ActivityResult Create(bool success, long value)
{
var activityResult = new ActivityResult
{
Numeric = value,
Success = success,
};
return(activityResult);
}
public ResultViewer(ActivityResult activityResult)
{
InitializeComponent();
Title += activityResult.ActivityName + " - " + activityResult.Student.FirstName + " " + activityResult.Student.LastName;
ActivityNameTextBlock.Text = activityResult.ActivityName;
ActivityTextTextBlock.Text = activityResult.GetTextToDisplay();
NumberOfFoundWordsTextBlock.Text = activityResult.FoundWords.Count + "/" + activityResult.NumberOfWordsTotal;
}
private void ActionButton_Click(object sender, RoutedEventArgs e)
{
var curItem = ((ListBoxItem)ResultsListView.ContainerFromElement((Button)sender));
selectedActivity = curItem.Content as ActivityResult;
cm = FindResource("ActionContextMenu") as ContextMenu;
cm.PlacementTarget = sender as Button;
cm.IsOpen = true;
}
public static ActivityResult Run([ActivityTrigger] IDurableActivityContext context)
{
var input = context.GetInput <Dictionary <string, object> >();
var booking = JsonConvert.DeserializeObject <Booking>(input["Booking"].ToString());
return(ActivityResult.Fulfilled(nameof(BookFlightActivity), new Flight
{
FlightId = Guid.NewGuid()
}));
}
private async Task MoreActivity()
{
UserContentProvider user = new UserContentProvider();
List <ActivityResult> result = await user.QueryFriendActivities(
ActivityResult[ActivityResult.Count - 1].ActivityId - 1, GlobalValue.CurrentUserContext.UserId, GlobalValue.CurrentUserContext.MobileToken);
foreach (var item in result)
{
ActivityResult.Add(ConvertToActivityItem(item));
}
}
public virtual void init(ActivityResult para_acResult)
{
acResultData = para_acResult;
//GhostbookManager gbMang = GhostbookManager.getInstance();
//IGBActivityReference acRef = gbMang.getActivityReferenceMaterial();
// Update the activity icon on the result screen.
//Transform reqAcSymbol = Resources.Load<Transform>("Prefabs/Ghostbook/ActivitySymbolsBig/BigSymbols_"+acResultData.getAcID());
//Transform activitySymbolHolder = transform.FindChild("ActivityButton").FindChild("Activity Symbol");
//activitySymbolHolder.GetComponent<SpriteRenderer>().sprite = reqAcSymbol.GetComponent<SpriteRenderer>().sprite;
}
public void SetResult_SetsValue(ActivityResult result)
{
Activity activity1 = new Activity("SetResultTest1");
Activity activity2 = new Activity("SetResultTest2");
activity1.SetResult(ActivityResult.SystemError); // set some value intially to check that it could be updated
activity1.SetResult(result);
CheckThatKeyNotDuplicated(activity1.TagObjects);
activity1.AssertResult(result);
Assert.IsNull(activity2.GetTag(ActivityTagKeys.Result));
}
public ActivityResult Run(PipelineContext context)
{
var pipe = context.Pipeline as NewsAnalysisPipeline;
var result = new ActivityResult();
result.ObjectType = typeof(int);
var obj = context.Result.ActivityResults["ExtractKeyWord"];
var resultDict = Convert.ChangeType(obj.Result, obj.ObjectType) as IDictionary <long, List <string> >;
var newsList = context[pipe.NewsContextKey] as IEnumerable <NewsStream>;
using (var db = ContextFactory.GetMediaAnalysisContext())
{
db.Configuration.AutoDetectChangesEnabled = false;
db.Configuration.ValidateOnSaveEnabled = false;
foreach (var item in newsList)
{
var keywords = resultDict.ContainsKey(item.Id) ? resultDict[item.Id] : null;
if (keywords.Any())
{
var keyword = string.Join(" ", keywords);
item.KeyWords = keyword;
}
else
{
if (!string.IsNullOrEmpty(item.Title))
{
var length = item.Title.Length > 20 ? 20 : item.Title.Length;
item.KeyWords = item.Title.Substring(0, length);
}
else
{
item.KeyWords = "Empty";
}
}
db.NewsStreams.Attach(item);
db.Entry(item).State = System.Data.Entity.EntityState.Modified;
}
try
{
result.Result = db.SaveChanges();
}
catch (Exception ex)
{
////@@TODO LOG
Debug.WriteLine(ex);
}
}
return(result);
}
public override ActivityResult Execute(IEvent e)
{
var text = Selector != null?e.GetEventData(Selector).ToString() : e.GetEventData().ToString();
if (Template != null)
{
Console.WriteLine(Template.Replace(Selector, text));
}
else
{
Console.WriteLine(text);
}
return(ActivityResult.Success());
}
public static async Task <bool> PersistSagaStateAsync(
TransactionItem transactionItem, SagaState state, IDurableOrchestrationContext context, ILogger log)
{
TransactionItem item = TransactionFactory.BuildTransactionItemByState(transactionItem, state);
ActivityResult <TransactionItem> result = await PersistSagaStateAsync(context, item);
if (!result.Valid)
{
log.LogError(result.ExceptionMessage);
return(false);
}
return(true);
}
public static ActivityResult Run([ActivityTrigger] IDurableActivityContext context)
{
var input = context.GetInput <Dictionary <string, object> >();
if (Guid.Parse(input["ClientId"].ToString()) == Guid.Parse("5a308090-1ea9-4f3f-bfb6-892adfe51c02"))
{
throw new Exception("Test exception");
}
return(ActivityResult.Fulfilled(nameof(PaymentActivity), new Payment
{
PaymentId = Guid.NewGuid()
}));
}
private void UploadComplete(object sender, ActivityResult e)
{
UploadError.Visible = !e.Success;
UploadSuccess.Visible = e.Success;
// Enable all the device detection options if not already set if it worked.
if (e.Success)
{
Manager.Enabled = true;
Manager.AutoUpdate = true;
Manager.ShareUsage = true;
Manager.ImageOptimiserEnabled = true;
Manager.MemoryMode = false;
}
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/user/account
string AccountSid = "{{ account_sid }}";
string AuthToken = "{{ auth_token }}";
string WorkspaceSid = "{{ workspace_sid }}";
var client = new TaskRouterClient(AccountSid, AuthToken);
ActivityResult activityResult = client.ListActivities(WorkspaceSid);
foreach (Activity activity in activityResult.Activities)
{
Console.WriteLine(activity.FriendlyName);
}
}
public override ActivityResult Execute(IEvent e)
{
try
{
if (e.GetEventData() != null)
{
object data = Condition.Selector != null?e.GetEventData(Condition.Selector) : e.GetEventData();
switch (Condition.Operator)
{
case ConditionOperator.EQ:
if (data.Equals(Condition.ExpectedValue))
{
ExecuteDoNodes(e);
}
else
{
ExecuteElseNodes(e);
}
break;
case ConditionOperator.NE:
if (!data.Equals(Condition.ExpectedValue))
{
ExecuteDoNodes(e);
}
else
{
ExecuteElseNodes(e);
}
break;
default:
break;
}
}
else
{
throw new Exception("Expected condition in ConditionEvent.");
}
}
catch (Exception ex)
{
return(ActivityResult.Failure(ex));
}
return(ActivityResult.Success());
}
public override void init(ActivityResult para_acResultData)
{
base.init(para_acResultData);
acPKey = acResultData.getAcID();
}
public override void init(ActivityResult para_acResultData)
{
base.init(para_acResultData);
//GhostbookManager gbMang = GhostbookManager.getInstance();
//IGBActivityReference acRef = gbMang.getActivityReferenceMaterial();
acPKey = acResultData.getAcID();
}
protected void recordPresentedConfig(ILevelConfig para_config)
{
if(acResultData == null) { acResultData = new ActivityResult(); }
acResultData.addPresentedContent(para_config);
Debug.Log("Registered Presented Content");
}
protected void recordOutcomeForConfig(LevelOutcome para_outcome)
{
if(acResultData == null) { acResultData = new ActivityResult(); }
acResultData.addOutcomeEntry(para_outcome);
}
protected void recordActivityStart()
{
bool successFlag = true;
if(acSessionMetaData == null)
{
loadActivitySessionMetaData();
if(acSessionMetaData == null) { successFlag = false; }
}
if(successFlag)
{
acSessionMetaData.recordActivityStart();
if(acResultData == null)
{
acResultData = new ActivityResult();
}
}
}
