public static void OnBeforeInsertStep1( IActivity activity, ISession session)
{
//System.Diagnostics.EventLog appLog = new System.Diagnostics.EventLog() ;
//appLog.Source = "SalesLogix Web Client";
//appLog.WriteEntry("Current ActivityId: " + activity.ActivityId);
//Update the activity id's
if(String.IsNullOrEmpty(activity.ActivityId) == false) {
//update the activityid for each activityAttendee record
foreach(IActivityAttendee aa in activity.ActivityAttendees) {
if(String.IsNullOrEmpty(aa.ActivityId) == true || aa.ActivityId.ToString().Trim() == ""
|| aa.ActivityId == "0") {
aa.ActivityId = activity.ActivityId;
}
}
//update the activityid for each expense record
foreach(IActivityExpense ae in activity.ActivityExpenses) {
if(String.IsNullOrEmpty(ae.ActivityId) == true || ae.ActivityId.ToString().Trim() == ""
||ae.ActivityId == "0") {
ae.ActivityId = activity.ActivityId;
}
}
}
}
public void Cancel( Actor self )
{
var unit = self.traits.Get<Unit>();
desiredFacing = unit.Facing;
NextActivity = null;
}
public void Insert(IActivity activity)
{
if (activity == null)
return;
activity.Queue(NextActivity);
NextActivity = activity;
}
public void SwitchActivities(IActivity newActivity)
{
currentActivity.Unload();
currentActivity = newActivity;
currentActivity.Initalize();
currentActivity.LoadContent();
}
public static Dictionary<string, List<ITrailResult>> GetTrailsResultsForActivity(IActivity activity)
{
object[] parameters = new object[1];
parameters[0] = activity;
Dictionary<string, List<ITrailResult>> list = null;
try
{
Version version;
Type type = GetType("TrailsPlugin.Export.Integration", "TrailsPlugin", out version);
if ((type != null)) //&& (version.CompareTo(this.minVersion) >= 0))
{
list = (Dictionary<string, List<ITrailResult>>)type.GetMethod("GetTrailsResultsForActivity").Invoke(null, parameters);
//throw new Exception(list.Count.ToString() + "fero");
}
}
catch (Exception e)
{
string error = e.Message;
if (e.InnerException != null)
{
error += "\n\n" + e.InnerException.Message;
}
throw new Exception(error);
}
return list;
}
public void Queue( IActivity activity )
{
if( NextActivity != null )
NextActivity.Queue( activity );
else
NextActivity = activity;
}
public ActivityWrapper()
{
activity = null;
timeOffset = new TimeSpan();
distanceOffset = 0;
actColor = Color.Black;
}
public static IList<IActivity> GetUniqueRoutesForActivity(IActivity activity, System.Windows.Forms.ProgressBar progressBar)
{
IList<IActivity> results = null;
try
{
if (progressBar == null)
progressBar = new System.Windows.Forms.ProgressBar();
if (GetUniqueRoutes != null)
{
MethodInfo methodInfo = GetUniqueRoutes.GetMethod(findSimilarRoutes);
object resultFromURPlugIn = methodInfo.Invoke(activity, new object[] { activity, progressBar });
results = (IList<IActivity>)resultFromURPlugIn;
}
}
catch (Exception e)
{
// Log error?
throw new Exception(string.Format(IntegrationUtility.OtherPluginExceptionText,
UniquePlugin + ".dll", UniqueRoutesPluginName) + Environment.NewLine, e);
}
if (GetUniqueRoutes == null)
{
throw new Exception(string.Format(IntegrationUtility.OtherPluginExceptionText,
UniquePlugin + ".dll", UniqueRoutesPluginName) + Environment.NewLine);
}
return results;
}
public void SetUp()
{
main = new MainBase();
activity = NewMock<IActivity>();
Stub.On(activity).GetProperty("Start").Will(Return.Value(DateTime.Parse("7:00:00")));
Stub.On(activity).GetProperty("Duration").Will(Return.Value(TimeSpan.Parse("0:30:00")));
}
public IntervalResult(IActivity activity, IntervalResultCache resultCache, double distance)
{
this.activity = activity;
this.resultCache = resultCache;
this.Distance = distance;
this.factor = 1000.0 / distance;
}
public ActivityModel(IActivity activity)
{
Properties = activity.Properties;
Type = activity.Type.ToString();
Message = activity.Message;
Id = activity.Id;
}
public void Cancel(Actor self)
{
if (Interruptible)
{
isCanceled = true;
NextActivity = null;
}
}
public void Cancel( Actor self )
{
IsCanceled = OnCancel( self );
if( IsCanceled )
NextActivity = null;
else if (NextActivity != null)
NextActivity.Cancel( self );
}
/// <summary>
/// Inserts an element into the ActivityCollection at the specified index
/// </summary>
/// <param name="index">
/// The index at which the IActivity is to be inserted.
/// </param>
/// <param name="value">
/// The IActivity to insert.
/// </param>
public virtual void Insert(int index, IActivity value)
{
CheckParent();
mList.Insert(index, value);
value.Parent = mParentActivity;
}
public TrainingResult(IActivity activity, string ZoneDistance, double PercentOfMax, double TrainRaceHR, double Speed)
{
this.activity = activity;
this.ZoneDistance = ZoneDistance;
this.PercentOfMax = PercentOfMax;
this.TrainRaceHR = TrainRaceHR;
this.Speed = Speed;
}
public TemperatureResult(IActivity activity, float temperature, float actual, TimeSpan time, double dist)
{
this.activity = activity;
double f = getTemperatureFactor(temperature) / getTemperatureFactor(actual);
this.EstimatedTime = Predict.scaleTime(time, f);
this.Distance = dist;
this.Temperature = temperature;
}
public AgeResult(IActivity activity, float predAge, float currAge, TimeSpan time, double dist)
{
this.activity = activity;
this.Age = predAge;
this.EstimatedTime = TimeSpan.FromSeconds(PredictWavaTime.WavaPredict(dist, dist, time, predAge, currAge));
this.EstimatedSpeed = dist / EstimatedTime.TotalSeconds;
}
public static void Calculate(IActivity activity, double vdot, TimeSpan time, double distance, double maxHr)
{
Predict.SetAgeSexFromActivity(activity);
m_zones = getZones();
m_percentages = getPercentages(vdot);
m_hrs = getHeartRates(maxHr, m_percentages);
m_paces = getSpeeds(vdot, time, distance, m_percentages);
}
public void ProcessLine(string line)
{
currentActivity.Name = line;
currentActivity.Stop();
lastActivity = currentActivity;
currentActivity = RunningActivity.After(currentActivity, "");
Save();
}
public void Cancel(Actor self)
{
if (!interruptable)
return;
remainingTicks = 0;
NextActivity = null;
}
public void Cancel(Actor self)
{
if (!interruptable)
return;
a = null;
NextActivity = null;
}
public static IList<IActivity> findSimilarRoutes(IActivity refActivity, IList<IActivity> activities, bool activityCompare, bool catCheck, System.Windows.Forms.ProgressBar progressBar)
{
if (refActivity == null ||
refActivity.GPSRoute == null ||
activityCompare && (false/*catCheck && !isAllowedActivity(refActivity)*/))
return new List<IActivity>();
return findSimilarRoutes(refActivity.GPSRoute, refActivity.ReferenceId, activities, activityCompare, progressBar);
}
public ActivitiesViewModel()
{
CurrentActivity = new ScoreMatchActivity
{
Name = "第16次 Score Match",
AvailableDifficulty = new[] { DifficultyKind.Easy, DifficultyKind.Normal, DifficultyKind.Hard, DifficultyKind.Expert }
};
}
public TimePredictionSource(IActivity activity, double UsedDistance, TimeSpan UsedTime, double StartDistance, double offsetTime)
{
this.Activity = activity;
//this.Distance = Distance;
this.UsedDistance = UsedDistance;
this.UsedTime = UsedTime;
this.StartDistance = StartDistance;
this.offsetTime = offsetTime;
}
public ASynchTask(IActivity activity, Action<IActivity> action)
{
Activity = activity;
this.action = action;
backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += BackgroundWorkerDoWork;
backgroundWorker.WorkerSupportsCancellation = true;
backgroundWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerCompleted;
}
public ActivityDetailsControl(IActivity activity)
{
InitializeComponent();
//InitialisedActivities = new Collection<IActivity>();
this.Activity = activity;
fitnessDataHandler = Plugin.dataHandler;
RefreshInfo();
this.PanelChoiceActionBanner.Text = "User Input";
}
public ActivityModel(IActivity activity)
{
Properties = activity.Properties;
Type = activity.Type.ToString();
Message = activity.Message;
Id = activity.Id;
Hint = activity.Hint.ToString();
Source = activity.Source;
}
public static IDictionary<IActivity, IItemTrackSelectionInfo[]> findCommonStretches(IActivity activity, IList<IActivity> activities, System.Windows.Forms.ProgressBar progressBar)
{
IDictionary<IActivity, IItemTrackSelectionInfo[]> results = new Dictionary<IActivity, IItemTrackSelectionInfo[]>();
IDictionary<IActivity, IList<GpsRunningPlugin.Source.PointInfo[]>> p = GpsRunningPlugin.Source.CommonStretches.findSimilarPoints(activity.GPSRoute, activity.Laps, activities, progressBar);
foreach (KeyValuePair<IActivity, IList<GpsRunningPlugin.Source.PointInfo[]>> kp in p)
{
results[kp.Key] = GpsRunningPlugin.Source.CommonStretches.getSelInfo(new DateTime[]{kp.Key.StartTime,activity.StartTime}, kp.Value, false/*GpsRunningPlugin.Source.Settings.UseActive*/);
}
return results;
}
private HashSet<IActivitySchedulingEvent<IResource>> GetOrAddActivity(IActivity activity)
{
HashSet<IActivitySchedulingEvent<IResource>> schedules;
if (!_activitySchedulingEvents.TryGetValue(activity, out schedules))
{
schedules = new HashSet<IActivitySchedulingEvent<IResource>>();
_activitySchedulingEvents.Add(activity, schedules);
}
return schedules;
}
public Person(int index, ReferenceDepthContext context)
{
this.Age = index + 20;
this.Address = new Address(index, context);
this.Alias = new string[] { "Alias" + index };
this.FirstName = DataSource.Names[index];
this.Gender = Gender.Male;
this.HomeNumber = DataSource.HomePhoneNumbers[index];
this.UnserializableSSN = DataSource.SSN[index];
this.FavoriteHobby = new HobbyActivity("Xbox Gaming");
}
public ActivityWrapper(IActivity activity)
{
_activity = activity;
_activity.PropertyChanged += _activity_PropertyChanged;
}
public IDataRogueControl GetControlFromMousePosition(ISystemContainer systemContainer, IActivity activity, MapCoordinate cameraPosition, int x, int y)
{
var playerFov = systemContainer.ActivitySystem.GameplayActivity.Running ? FOVHelper.CalculatePlayerFov(systemContainer) : null;
DoLayout(systemContainer, activity, playerFov);
var mousePoint = new Point(x, y);
var onControls = activity.Controls.Where(c => c.Position.Contains(mousePoint));
return(onControls.LastOrDefault());
}
public void RegisterNotificationChannel(IActivity activity)
{
_activity.Add(activity);
}
async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
await this.logger.LogAsync(activity);
await inner.PostAsync(activity, token);
}
/// <summary>
/// Gets the user list of sprocket combinations
/// </summary>
/// <returns></returns>
public static List <SprocketCombo> GetSprocketCombos(IActivity activity)
{
string id = Options.Instance.GetGearEquipmentId(activity);
return(GetSprocketCombos(id));
}
/// <summary>
/// Swallow activity.
/// </summary>
/// <param name="activity">Activity to be logged.</param>
/// <returns></returns>
async Task IActivityLogger.LogAsync(IActivity activity)
{
}
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var recognizer = await _services.LuisServices[LuisKey].RecognizeAsync(turnContext, cancellationToken);
var topIntent = recognizer?.GetTopScoringIntent();
switch (topIntent.Value.intent)
{
case "Get_Weather_Condition":
{
if (topIntent != null && topIntent.HasValue && topIntent.Value.intent != "None")
{
var location = LuisParser.GetEntityValue(recognizer, Constants.LocationLabel, Constants.LocationPatternLabel);
if (location.ToString() != string.Empty)
{
var ro = await WeatherService.GetWeather(location);
var weather = $"{ro.weather.First().main}({ro.main.temp.ToString("N2")} °C)";
var typing = Activity.CreateTypingActivity();
var delay = new Activity {
Type = "delay", Value = 5000
};
var activities = new IActivity[]
{
typing,
delay,
MessageFactory.Text($"Weather of {location} is: {weather}"),
MessageFactory.Text("Thanks for using our service!")
};
await turnContext.SendActivitiesAsync(activities);
}
else
{
await turnContext.SendActivityAsync("Sorry, I don´t understand");
}
}
else
{
var msg = @"No LUIS intents were found.
This sample is about identifying a city and an intent:
'Find the current weather in a city'
Try typing 'What's the weather in Prague'";
await turnContext.SendActivityAsync(msg);
}
break;
}
case "QnAMaker":
{
var serviceQnAMaker = new QnAMakerService();
var answer = serviceQnAMaker.GetAnswer(turnContext.Activity.Text);
if (answer.Equals(Constants.AnswerNotFound))
{
await turnContext.SendActivityAsync("Lo siento, pero no estoy preparado para este tipo de preguntas.");
}
else
{
await turnContext.SendActivityAsync(answer);
}
break;
}
case "SearchVideo":
{
//var searchVideo = LuisParser.GetEntityValue(recognizer, Constants.VideoLabel, Constants.VideoPatternLabel);
var searchVideo = recognizer.Entities.Last.First[0].ToString();
var serviceVideoIndexer = new VideoIndexerService();
var response = Task.Run(() => serviceVideoIndexer.SearchVideo("valor"));
response.Wait();
var videoList = response.Result;
var reply = (turnContext.Activity as Activity).CreateReply();
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
var card = videoList.Select(r => new ThumbnailCard(r.VideoTitle, r.Description, r.Duration,
new List <CardImage> {
new CardImage(url: r.Thumbnaill, r.VideoTitle)
},
new List <CardAction>
{
new CardAction(ActionTypes.OpenUrl, "ver", null, value: r.UrlVideo, text: "ver", displayText: "ver"),
new CardAction(ActionTypes.OpenUrl, "Descargar", null, value: r.DownloadVideoUrl, text: "Descargar", displayText: "Descargar")
}
).ToAttachment()).ToList();
if (card.Any())
{
await turnContext.SendActivityAsync("Gracias por la espera, estos son los videos que encontré");
reply.Attachments = card;
await turnContext.SendActivityAsync(reply);
}
break;
}
}
}
else if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate)
{
await SendWelcomeMessageAsync(turnContext, cancellationToken);
}
else
{
await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected", cancellationToken : cancellationToken);
}
}
public IGameAction GetAction(GameEntity entity)
{
IGameAction gameActionToReturn = null;
IActivity activity = entity.hasActivity ? entity.activity.Activity : null;
if (activity != null)
{
ActivityStep activityStep = activity.CheckAndResolveStep(entity);
if (activityStep.State == ActivityState.FinishedSuccess)
{
}
else if (activityStep.State == ActivityState.FinishedFailure)
{
_activityInterruptor.FailAndReplace(entity, activity, null);
}
return(activityStep.GameAction);
}
Decision decision = _context.playerDecision.Decision;
if (decision == Decision.None)
{
return(null);
}
if (decision == Decision.PickUp)
{
gameActionToReturn = ResolveForPickUp(entity);
}
else if (decision == Decision.Drop)
{
gameActionToReturn = ResolveForDrop(entity);
}
else if (decision == Decision.Eat)
{
gameActionToReturn = ResolveForEat(entity);
}
else if (decision == Decision.Pass)
{
gameActionToReturn = _actionFactory.CreatePassAction(entity);
}
// todo clean this up
/*else if (decision == Decision.TakeItem1)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 0);
* }
* else if (decision == Decision.TakeItem2)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 1);
* }
* else if (decision == Decision.TakeItem3)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 2);
* }
* else if (decision == Decision.TakeItem4)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 3);
* }
* else if (decision == Decision.TakeItem5)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 4);
* }
* else if (decision == Decision.TakeItem6)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 5);
* }
* else if (decision == Decision.TakeItem7)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 6);
* }
* else if (decision == Decision.TakeItem8)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 7);
* }
* else if (decision == Decision.TakeItem9)
* {
* gameActionToReturn = CreateTakeFromInventoryActionIfPossible(entity, 8);
* }*/
else if (_moveInputs.Contains(decision))
{
gameActionToReturn = ResolveForMove(entity, decision);
}
else if (decision == Decision.Custom0)
{
gameActionToReturn = _actionFactory.CreateLambdaAction(
targetEntity =>
{
targetEntity.ReplaceIntegrity(targetEntity.integrity.MaxIntegrity, targetEntity.integrity.MaxIntegrity);
return(Enumerable.Empty <IActionEffect>());
}, entity);
}
else if (decision == Decision.Custom1)
{
gameActionToReturn = _actionFactory.CreateLambdaAction(actionEntity =>
{
throw new Exception("test pawła 2");
}, entity);
}
else if (decision == Decision.Custom2)
{
gameActionToReturn = ResolveForAlphaNumber(2, entity);
}
else if (decision == Decision.Custom3)
{
gameActionToReturn = ResolveForAlphaNumber(3, entity);
}
else if (decision == Decision.Custom4)
{
gameActionToReturn = ResolveForAlphaNumber(4, entity);
}
else if (decision == Decision.Custom5)
{
gameActionToReturn = ResolveForAlphaNumber(5, entity);
}
if (gameActionToReturn != null)
{
_context.ReplacePlayerDecision(Decision.None, Position.Zero, Position.MinValue);
}
return(gameActionToReturn);
}
public void AddActivity(IActivity activity)
{
activities.Add(activity);
}
public ActivityRuntime(IActivity level)
{
Level = level;
_asyncQueue = new Queue <KeyValuePair <SendOrPostCallback, object> >();
_synchronizationContext = SyncContext.Create((c, s) => _asyncQueue.Enqueue(new KeyValuePair <SendOrPostCallback, object>(c, s)));
}
public DialogTaskManagerBotDataLoader(IBotData inner, IDialogTaskManager dialogTaskManager, IActivity activity, ILocaleFinder localeFinder)
{
SetField.NotNull(out this.inner, nameof(inner), inner);
SetField.NotNull(out this.dialogTaskManager, nameof(dialogTaskManager), dialogTaskManager);
SetField.NotNull(out this.localeFinder, nameof(localeFinder), localeFinder);
SetField.NotNull(out this.activity, nameof(activity), activity);
}
void IEventProducer <IActivity> .Post(IActivity activity, Action onPull)
{
this.queue.Post(activity, onPull);
}
/// <summary>
/// Log an activity to the transcript.
/// </summary>
/// <param name="activity">The activity to transcribe.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public Task LogActivityAsync(IActivity activity)
{
BotAssert.ActivityNotNull(activity);
Trace.TraceInformation(JsonConvert.SerializeObject(activity, serializationSettings));
return(Task.CompletedTask);
}
/// <summary>
/// Used to generate the record properties of the supplied activity
/// </summary>
/// <param name="activity">The full activity for the record</param>
/// <param name="category">The Record Category for this record</param>
/// <param name="gpsTrack">The GPS route of the actual record</param>
/// <param name="hrTrack">The HR track of the actual record</param>
/// <param name="pwrTrack">The power track of the actual record</param>
/// <param name="cadTrack">The cadence track of the actual record</param>
public Record(IActivity activity, RecordCategory category, IGPSRoute gpsTrack, INumericTimeDataSeries hrTrack, INumericTimeDataSeries pwrTrack, INumericTimeDataSeries cadTrack, IDistanceDataTrack distTrack, INumericTimeDataSeries elevTrack, DateTime activityStartTime)
{
// Create new activity from template
IActivity recActivity = (IActivity)Activator.CreateInstance(activity.GetType());
// HACK: Manually Clone 'activity' until a better way is found
recActivity.Category = activity.Category;
recActivity.DistanceMetersTrack = distTrack;
recActivity.ElevationMetersTrack = elevTrack;
recActivity.GPSRoute = gpsTrack;
recActivity.HasStartTime = activity.HasStartTime;
recActivity.HeartRatePerMinuteTrack = hrTrack;
recActivity.Intensity = activity.Intensity;
recActivity.Location = activity.Location;
recActivity.Name = activity.Name;
recActivity.PowerWattsTrack = pwrTrack;
recActivity.CadencePerMinuteTrack = cadTrack;
recActivity.Weather.Conditions = activity.Weather.Conditions;
recActivity.Weather.CurentDirectionDegrees = activity.Weather.CurentDirectionDegrees;
recActivity.Weather.CurentSpeedKilometersPerHour = activity.Weather.CurentSpeedKilometersPerHour;
recActivity.Weather.HumidityPercent = activity.Weather.HumidityPercent;
recActivity.Weather.TemperatureCelsius = activity.Weather.TemperatureCelsius;
recActivity.Weather.WindDirectionDegrees = activity.Weather.WindDirectionDegrees;
recActivity.Weather.WindSpeedKilometersPerHour = activity.Weather.WindSpeedKilometersPerHour;
// Set the start time for the record activity
recActivity.StartTime = activityStartTime;
// Set up the activity info for pulling summary data
ActivityInfo info = ActivityInfoCache.Instance.GetInfo(recActivity);
// Set the record category
this.category = category;
// Max and Min elevation seen over the route
float maxE = float.NegativeInfinity;
float minE = float.PositiveInfinity;
if (activity.GPSRoute != null && activity.GPSRoute.Count > 0)
{
GPSRoute startRoute = new GPSRoute();
for (int i = 0; i < activity.GPSRoute.Count; i++)
{
GPSPoint p = (GPSPoint)activity.GPSRoute[i].Value;
if (p.ElevationMeters > maxE)
{
maxE = p.ElevationMeters;
}
if (p.ElevationMeters < minE)
{
minE = p.ElevationMeters;
}
if (gpsTrack.Count == 0)
{
break;
}
if (p.Equals((GPSPoint)gpsTrack[0].Value))
{
break;
}
else
{
startRoute.Add(activity.GPSRoute.EntryDateTime(activity.GPSRoute[i]), p);
}
}
startDistance = startRoute.TotalDistanceMeters;
}
else if (activity.ElevationMetersTrack != null)
{
for (int i = 0; i < activity.ElevationMetersTrack.Count; i++)
{
if (activity.ElevationMetersTrack[i].Value > maxE)
{
maxE = activity.ElevationMetersTrack[i].Value;
}
if (activity.ElevationMetersTrack[i].Value < maxE)
{
minE = activity.ElevationMetersTrack[i].Value;
}
}
startDistance = 0;
}
this.maxElevation = maxE;
this.minElevation = minE;
this.trueStartDate = activity.StartTime;
this.activity = recActivity;
}
public Task Activity(IActivity activity)
{
return(methods.Activity(activity));
}
private static void ValidateNoneTelemetry(AdaptiveRecognizer recognizer, Mock <IBotTelemetryClient> telemetryClient, DialogContext dc, IActivity activity, RecognizerResult result, int callCount)
{
var eventName = GetEventName(recognizer.GetType().Name);
var(logPersonalInfo, error) = recognizer.LogPersonalInformation.TryGetValue(dc.State);
var expectedTelemetryProps = GetExpectedNoneTelemetryProps(activity, result, logPersonalInfo);
var actualTelemetryProps = (Dictionary <string, string>)telemetryClient.Invocations[callCount - 1].Arguments[1];
telemetryClient.Verify(
client => client.TrackEvent(
eventName,
It.Is <Dictionary <string, string> >(d => HasValidTelemetryProps(expectedTelemetryProps, actualTelemetryProps)),
null),
Times.Exactly(callCount));
}
/// <summary>
/// Gets the user list of the large gears (chainring).
/// </summary>
/// <returns></returns>
public static List <float> GetChainringGears(IActivity activity)
{
string id = Options.Instance.GetGearEquipmentId(activity);
return(Options.Instance.GetBigGears(id));
}
/// <summary>
/// Log activity to trace stream.
/// </summary>
/// <param name="activity">Activity to log.</param>
/// <returns></returns>
async Task IActivityLogger.LogAsync(IActivity activity)
{
Trace.TraceInformation(JsonConvert.SerializeObject(activity));
}
/// <summary> /// Implement updating an activity in the conversation /// </summary> /// <param name="context"></param> /// <param name="activity"></param> /// <returns></returns> protected abstract Task <ResourceResponse> UpdateActivityImplementation(IBotContext context, IActivity activity);
private static IActivity CloneActivity(IActivity activity)
{
activity = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(activity, JsonSettings));
return(activity);
}
/// <summary>
/// Gets a data track representing the raw data used to calculate the gear track.
/// </summary>
/// <param name="activity"></param>
/// <returns>Returns the raw gear track, or an empty INumericTimeDataSeries if none can be calculated.</returns>
public static INumericTimeDataSeries GetRawGearTrack(IActivity activity)
{
return(GearUtils.GetRawGearTrack(activity));
}
public void Fault(IActivity activity, Exception exception) => Fault(activity, exception.Message);
/// <summary>
/// Gets the user list of the small gears (cassette).
/// </summary>
/// <returns></returns>
public static List <float> GetCassetteGears(IActivity activity)
{
string id = Options.Instance.GetGearEquipmentId(activity);
return(Options.Instance.GetSmallGears(id));
}
public void LogActivity(IActivity a, string userId)
{
IDatabase db = redis.GetDatabase();
db.ListLeftPush(String.Format(userActivitiesListKey, userId), JsonConvert.SerializeObject(a, _jsonSettings));
}
/// <summary>
/// Constructs a party instance using the sender (from) of the given activity.
/// </summary>
/// <param name="activity"></param>
/// <returns>A newly created Party instance.</returns>
public static Party CreateSenderParty(IActivity activity)
{
return(new Party(activity.ServiceUrl, activity.ChannelId, activity.From, activity.Conversation));
}
protected override void ActivityExecuted(WorkflowExecutionContext workflowExecutionContext, IActivity activity)
{
var timeStamp = clock.GetCurrentInstant();
workflowExecutionContext.Workflow.ExecutionLog.Add(
new LogEntry(activity.Id, timeStamp, $"Successfully executed at {timeStamp}"));
}
/// <summary>
/// Constructs a party instance using the recipient of the given activity.
/// </summary>
/// <param name="activity"></param>
/// <returns>A newly created Party instance.</returns>
public static Party CreateRecipientParty(IActivity activity)
{
return(new Party(activity.ServiceUrl, activity.ChannelId, activity.Recipient, activity.Conversation));
}
private bool IsReply(IActivity activity)
{
return(string.Equals("bot", activity.From?.Role, StringComparison.InvariantCultureIgnoreCase));
}
public async Task Hello(IDialogContext context, IActivity activity)
{
await context.PostAsync("Hello from RegEx! I am a Photo Organization Bot. I can search your photos, share your photos on Twitter, and order prints of your photos. You can ask me things like 'find pictures of food'.");
}
/// <summary>
/// Gets the equipment id used for a given activity
/// </summary>
/// <returns></returns>
public static string GetActivityEquipmentId(IActivity activity)
{
return(Options.Instance.GetGearEquipmentId(activity));
}
