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)); }