public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable<MatcherWithAction> matchersWithActions)
{
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
name.AssertNotNull(nameof(name));
matchersWithActions.AssertNotNull(nameof(matchersWithActions));
if (setCount < 0)
{
throw new ArgumentException("setCount cannot be less than zero.", "setCount");
}
if (repetitionCount < 0)
{
throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount");
}
this.logger = loggerService.GetLogger(this.GetType());
this.speechService = speechService;
this.name = name;
this.setCount = setCount;
this.repetitionCount = repetitionCount;
this.matchersWithActions = matchersWithActions.ToImmutableList();
using (var dummyExecutionContext = new ExecutionContext())
{
this.duration = this
.GetEventsWithActions(dummyExecutionContext)
.SelectMany(x => x.Actions)
.Select(x => x.Duration)
.DefaultIfEmpty()
.Aggregate((running, next) => running + next);
}
}
public static Parser<IAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return BreakActionParser.GetParser(delayService, speechService)
.Or<IAction>(MetronomeActionParser.GetParser(audioService, delayService, loggerService))
.Or<IAction>(PrepareActionParser.GetParser(delayService, speechService))
.Or<IAction>(SayActionParser.GetParser(speechService))
.Or<IAction>(WaitActionParser.GetParser(delayService))
.Or<IAction>(DoNotAwaitActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService))
.Or<IAction>(ParallelActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService))
.Or<IAction>(SequenceActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService));
}
public static Parser <Exercise> GetParser(
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from name in HeadingParser.GetParser(2)
from _ in VerticalSeparationParser.Parser
from setAndRepetitionCount in setAndRepetitionCountParser
from __ in VerticalSeparationParser.Parser
from matchersWithActions in GetMatchersWithActionsParser(audioService, delayService, loggerService, speechService).Optional()
select new Exercise(
loggerService,
speechService,
name,
setAndRepetitionCount.Item1,
setAndRepetitionCount.Item2,
matchersWithActions.GetOrElse(Enumerable.Empty <MatcherWithAction>())));
}
public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable <MatcherWithAction> matchersWithActions)
{
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
name.AssertNotNull(nameof(name));
matchersWithActions.AssertNotNull(nameof(matchersWithActions));
if (setCount < 0)
{
throw new ArgumentException("setCount cannot be less than zero.", "setCount");
}
if (repetitionCount < 0)
{
throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount");
}
this.logger = loggerService.GetLogger(this.GetType());
this.speechService = speechService;
this.name = name;
this.setCount = setCount;
this.repetitionCount = repetitionCount;
this.matchersWithActions = matchersWithActions.ToImmutableList();
using (var dummyExecutionContext = new ExecutionContext())
{
this.duration = this
.GetEventsWithActions(dummyExecutionContext)
.SelectMany(x => x.Actions)
.Select(x => x.Duration)
.DefaultIfEmpty()
.Aggregate((running, next) => running + next);
}
}
public static Parser <DoNotAwaitAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from _ in Parse.IgnoreCase("don't")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from ___ in Parse.IgnoreCase("wait:")
from ____ in VerticalSeparationParser.Parser.AtLeastOnce()
from actions in ActionListParser.GetParser(indentLevel + 1, audioService, delayService, loggerService, speechService)
let child = new SequenceAction(actions)
select new DoNotAwaitAction(
loggerService,
child));
}
public static Parser<DoNotAwaitAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
from _ in Parse.IgnoreCase("don't")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from ___ in Parse.IgnoreCase("wait:")
from ____ in VerticalSeparationParser.Parser.AtLeastOnce()
from actions in ActionListParser.GetParser(indentLevel + 1, audioService, delayService, loggerService, speechService)
let child = new SequenceAction(actions)
select new DoNotAwaitAction(
loggerService,
child);
}
public static Parser <IAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return(BreakActionParser.GetParser(delayService, speechService)
.Or <IAction>(MetronomeActionParser.GetParser(audioService, delayService, loggerService))
.Or <IAction>(PrepareActionParser.GetParser(delayService, speechService))
.Or <IAction>(SayActionParser.GetParser(speechService))
.Or <IAction>(WaitActionParser.GetParser(delayService))
.Or <IAction>(DoNotAwaitActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService))
.Or <IAction>(ParallelActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService))
.Or <IAction>(SequenceActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService)));
}
public SayAction(ISpeechService speechService, string speechText)
{
speechService.AssertNotNull(nameof(speechService));
speechText.AssertNotNull(nameof(speechText));
this.speechService = speechService;
this.speechText = speechText;
}
public SayAction(ISpeechService speechService, string speechText)
{
speechService.AssertNotNull(nameof(speechService));
speechText.AssertNotNull(nameof(speechText));
this.speechService = speechService;
this.speechText = speechText;
}
public static Parser<SayAction> GetParser(ISpeechService speechService)
{
speechService.AssertNotNull(nameof(speechService));
return
from _ in Parse.IgnoreCase("say")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from speechText in StringLiteralParser.Parser
select new SayAction(speechService, speechText);
}
public static Parser <SayAction> GetParser(ISpeechService speechService)
{
speechService.AssertNotNull(nameof(speechService));
return
(from _ in Parse.IgnoreCase("say")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from speechText in StringLiteralParser.Parser
select new SayAction(speechService, speechText));
}
public WaitWithPromptAction(IDelayService delayService, ISpeechService speechService, TimeSpan duration, string promptSpeechText)
{
delayService.AssertNotNull(nameof(delayService));
speechService.AssertNotNull(nameof(speechService));
promptSpeechText.AssertNotNull(nameof(promptSpeechText));
if (duration < TimeSpan.Zero)
{
throw new ArgumentException("duration must be greater than or equal to zero.", "duration");
}
this.innerAction = new SequenceAction(GetInnerActions(delayService, speechService, duration, promptSpeechText));
}
public WaitWithPromptAction(IDelayService delayService, ISpeechService speechService, TimeSpan duration, string promptSpeechText)
{
delayService.AssertNotNull(nameof(delayService));
speechService.AssertNotNull(nameof(speechService));
promptSpeechText.AssertNotNull(nameof(promptSpeechText));
if (duration < TimeSpan.Zero)
{
throw new ArgumentException("duration must be greater than or equal to zero.", "duration");
}
this.innerAction = new SequenceAction(GetInnerActions(delayService, speechService, duration, promptSpeechText));
}
public static IResult<ExercisePrograms> TryParse(
string input,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
input.AssertNotNull(nameof(input));
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return ExerciseProgramsParser.GetParser(audioService, delayService, loggerService, speechService).TryParse(input);
}
public static Parser <ExercisePrograms> GetParser(
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from _ in VerticalSeparationParser.Parser
from exercisePrograms in ExerciseProgramParser.GetParser(audioService, delayService, loggerService, speechService).DelimitedBy(Parse.WhiteSpace.Many()).Optional()
from __ in Parse.WhiteSpace.Many().End()
select new ExercisePrograms(exercisePrograms.GetOrElse(Enumerable.Empty <ExerciseProgram>())));
}
public static Parser<ExerciseProgram> GetParser(
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
from name in HeadingParser.GetParser(1)
from _ in Parse.WhiteSpace.Many()
from exercises in ExerciseParser.GetParser(audioService, delayService, loggerService, speechService).DelimitedBy(Parse.WhiteSpace.Many()).Optional()
select new ExerciseProgram(loggerService, name, exercises.GetOrElse(Enumerable.Empty<Exercise>()));
}
public static Parser<ExercisePrograms> GetParser(
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
from _ in VerticalSeparationParser.Parser
from exercisePrograms in ExerciseProgramParser.GetParser(audioService, delayService, loggerService, speechService).DelimitedBy(Parse.WhiteSpace.Many()).Optional()
from __ in Parse.WhiteSpace.Many().End()
select new ExercisePrograms(exercisePrograms.GetOrElse(Enumerable.Empty<ExerciseProgram>()));
}
public static Parser <ExerciseProgram> GetParser(
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from name in HeadingParser.GetParser(1)
from _ in Parse.WhiteSpace.Many()
from exercises in ExerciseParser.GetParser(audioService, delayService, loggerService, speechService).DelimitedBy(Parse.WhiteSpace.Many()).Optional()
select new ExerciseProgram(loggerService, name, exercises.GetOrElse(Enumerable.Empty <Exercise>())));
}
public static Parser<PrepareAction> GetParser(
IDelayService delayService,
ISpeechService speechService)
{
delayService.AssertNotNull(nameof(delayService));
speechService.AssertNotNull(nameof(speechService));
return
from _ in Parse.IgnoreCase("prepare")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from ___ in Parse.IgnoreCase("for")
from ____ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from duration in TimeSpanParser.Parser
select new PrepareAction(
delayService,
speechService,
duration);
}
public static Parser <PrepareAction> GetParser(
IDelayService delayService,
ISpeechService speechService)
{
delayService.AssertNotNull(nameof(delayService));
speechService.AssertNotNull(nameof(speechService));
return
(from _ in Parse.IgnoreCase("prepare")
from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from ___ in Parse.IgnoreCase("for")
from ____ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
from duration in TimeSpanParser.Parser
select new PrepareAction(
delayService,
speechService,
duration));
}
public static Parser <IEnumerable <IAction> > GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
((from _ in Parse.String(" ").Or(Parse.String("\t")).Repeat(indentLevel)
from __ in Parse.String("* ")
from action in ActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService).Token(HorizontalWhitespaceParser.Parser)
select action).DelimitedBy(NewLineParser.Parser));
}
public static Parser<IEnumerable<IAction>> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from _ in Parse.String(" ").Or(Parse.String("\t")).Repeat(indentLevel)
from __ in Parse.String("* ")
from action in ActionParser.GetParser(indentLevel, audioService, delayService, loggerService, speechService).Token(HorizontalWhitespaceParser.Parser)
select action).DelimitedBy(NewLineParser.Parser);
}
public static Parser<ParallelAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
from _ in Parse.IgnoreCase("parallel:")
from __ in VerticalSeparationParser.Parser.AtLeastOnce()
from actions in ActionListParser.GetParser(indentLevel + 1, audioService, delayService, loggerService, speechService)
select new ParallelAction(actions);
}
public static Parser <ParallelAction> GetParser(
int indentLevel,
IAudioService audioService,
IDelayService delayService,
ILoggerService loggerService,
ISpeechService speechService)
{
if (indentLevel < 0)
{
throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
}
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
loggerService.AssertNotNull(nameof(loggerService));
speechService.AssertNotNull(nameof(speechService));
return
(from _ in Parse.IgnoreCase("parallel:")
from __ in VerticalSeparationParser.Parser.AtLeastOnce()
from actions in ActionListParser.GetParser(indentLevel + 1, audioService, delayService, loggerService, speechService)
select new ParallelAction(actions));
}
public ExerciseProgramsViewModel(
IAudioService audioService,
IDelayService delayService,
IExerciseDocumentService exerciseDocumentService,
ILoggerService loggerService,
ISchedulerService schedulerService,
ISpeechService speechService,
IStateService stateService,
IScreen hostScreen,
ExerciseProgramViewModelFactory exerciseProgramViewModelFactory)
{
audioService.AssertNotNull(nameof(audioService));
delayService.AssertNotNull(nameof(delayService));
exerciseDocumentService.AssertNotNull(nameof(exerciseDocumentService));
loggerService.AssertNotNull(nameof(loggerService));
schedulerService.AssertNotNull(nameof(schedulerService));
speechService.AssertNotNull(nameof(speechService));
stateService.AssertNotNull(nameof(stateService));
hostScreen.AssertNotNull(nameof(hostScreen));
exerciseProgramViewModelFactory.AssertNotNull(nameof(exerciseProgramViewModelFactory));
this.exerciseDocumentService = exerciseDocumentService;
this.stateService = stateService;
this.logger = loggerService.GetLogger(this.GetType());
this.hostScreen = hostScreen;
this.disposables = new CompositeDisposable();
var documentsFromCache = this
.stateService
.GetAsync <string>(exerciseProgramsCacheKey)
.Where(x => x != null)
.Select(x => new DocumentSourceWith <string>(DocumentSource.Cache, x));
var documentsFromService = this
.exerciseDocumentService
.ExerciseDocument
.Where(x => x != null)
.Select(x => new DocumentSourceWith <string>(DocumentSource.Service, x));
var documents = documentsFromCache
.Catch((Exception ex) => Observable.Empty <DocumentSourceWith <string> >())
.Concat(documentsFromService)
.Do(x => this.logger.Debug("Received document from {0}.", x.Source))
.Publish();
var safeDocuments = documents
.Catch((Exception ex) => Observable.Empty <DocumentSourceWith <string> >());
var results = documents
.ObserveOn(schedulerService.TaskPoolScheduler)
.Select(
x =>
{
IResult <ExercisePrograms> parsedExercisePrograms;
using (this.logger.Perf("Parsing exercise programs from {0}.", x.Source))
{
parsedExercisePrograms = ExercisePrograms.TryParse(x.Item, audioService, delayService, loggerService, speechService);
}
return(new DocumentSourceWith <IResult <ExercisePrograms> >(x.Source, parsedExercisePrograms));
})
.Publish();
var safeResults = results
.Catch((Exception ex) => Observable.Empty <DocumentSourceWith <IResult <ExercisePrograms> > >());
safeResults
.Select(x => x.Item.WasSuccessful ? null : x.Item.ToString())
.ObserveOn(schedulerService.MainScheduler)
.Subscribe(x => this.ParseErrorMessage = x)
.AddTo(this.disposables);
results
.Select(x => !x.Item.WasSuccessful ? ExerciseProgramsViewModelStatus.ParseFailed : x.Source == DocumentSource.Cache ? ExerciseProgramsViewModelStatus.LoadedFromCache : ExerciseProgramsViewModelStatus.LoadedFromService)
.Catch((Exception ex) => Observable.Return(ExerciseProgramsViewModelStatus.LoadFailed))
.ObserveOn(schedulerService.MainScheduler)
.Subscribe(x => this.Status = x)
.AddTo(this.disposables);
safeResults
.Select(x => x.Item.WasSuccessful ? x.Item.Value : null)
.ObserveOn(schedulerService.MainScheduler)
.Subscribe(x => this.Model = x)
.AddTo(this.disposables);
this.WhenAnyValue(x => x.Model)
.Select(x => x == null ? null : x.Programs.CreateDerivedCollection(y => exerciseProgramViewModelFactory(y)))
.ObserveOn(schedulerService.MainScheduler)
.Subscribe(x => this.Programs = x)
.AddTo(this.disposables);
safeDocuments
.Where(x => x.Source == DocumentSource.Service)
.SelectMany(x => this.stateService.SetAsync(exerciseProgramsCacheKey, x.Item))
.Subscribe()
.AddTo(this.disposables);
results
.Connect()
.AddTo(this.disposables);
documents
.Connect()
.AddTo(this.disposables);
this
.WhenAnyValue(x => x.SelectedProgram)
.Where(x => x != null)
.Subscribe(x => this.hostScreen.Router.Navigate.Execute(x))
.AddTo(this.disposables);
this
.hostScreen
.Router
.CurrentViewModel
.OfType <ExerciseProgramsViewModel>()
.Subscribe(x => x.SelectedProgram = null)
.AddTo(this.disposables);
}
