public ProjectMutator(MutatingEngine <MutatingContext <ProjectFile> > engine, ProjectFileWorkspace workspace)
{
_engine = engine;
_workspace = workspace;
NewProject = engine.EventSource(mc => new AddProject(mc.GetChange <NewProjectChange>().Project),
context => context.Change is NewProjectChange);
RemovedProject = engine.EventSource(mc => new RemoveProject(mc.GetChange <RemoveProjectChange>().Project),
context => context.Change is RemoveProjectChange);
NewLanguage = engine.EventSource(mc => mc.GetChange <LanguageChange>().ToEventData(),
context => context.Change is LanguageChange);
NewImport = engine.EventSource(mc => mc.GetChange <AddImportChange>().ToEventData(),
context => context.Change is AddImportChange);
RemoveImport = engine.EventSource(mc => mc.GetChange <RemoveImportChange>().ToData(),
context => context.Change is RemoveImportChange);
NewLanguage.RespondOn(null, newLang =>
{
if (workspace.ProjectFile.GlobalLanguages.Contains(newLang.ActiveLanguage))
{
return;
}
if (!Projects.All(p => p.ActiveLanguages.Contains(newLang.ActiveLanguage)))
{
return;
}
_engine.Mutate(nameof(AddLanguage) + "Global-Single",
obs => obs.Select(context => context.Update(new GlobalLanguageChange(newLang.ActiveLanguage),
context.Data with
{
GlobalLanguages = context.Data.GlobalLanguages.Add(newLang.ActiveLanguage)
})));
});
public MainWindow(IViewModel <MainWindowViewModel> model, LocLocalizer localizer, IMainWindowCoordinator mainWindowCoordinator, IDialogCoordinator coordinator, ProjectFileWorkspace workspace)
: base(model)
{
_localizer = localizer;
_mainWindowCoordinator = mainWindowCoordinator;
_coordinator = coordinator;
_workspace = workspace;
InitializeComponent();
_mainWindowCoordinator.TitleChanged += () => Dispatcher.BeginInvoke(new Action(MainWindowCoordinatorOnTitleChanged));
_mainWindowCoordinator.IsBusyChanged += IsBusyChanged;
Closing += OnClosing;
Closed += async(sender, args) =>
{
Shutdown?.Invoke(this, EventArgs.Empty);
await Task.Delay(TimeSpan.FromSeconds(60));
Process.GetCurrentProcess().Kill(false);
};
_coordinator.OnWindowConstructed
+= window =>
{
SfSkinManager.SetVisualStyle(window, VisualStyles.Blend);
};
}
public SourceMutator(MutatingEngine <MutatingContext <ProjectFile> > engine, ProjectFileWorkspace workspace)
{
_engine = engine;
_workspace = workspace;
SaveRequest = engine.EventSource(mc => new SaveRequest(_workspace.ProjectFile), context => !(context.Change is ResetChange));
ProjectReset = engine.EventSource(mc => new ProjectRest(_workspace.ProjectFile), context => context.Change is ResetChange);
SourceUpdate = engine.EventSource(mc => new SourceUpdated(mc.Data.Source), context => context.Change is SourceChange);
}
public CenterViewModel(ILifetimeScope lifetimeScope, Dispatcher dispatcher, IOperationManager manager, LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
IMainWindowCoordinator mainWindow, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
Receive <IncommingEvent>(e => e.Action());
Views = this.RegisterUiCollection <ProjectViewContainer>(nameof(Views)).AndAsync();
CurrentProject = RegisterProperty <int?>(nameof(CurrentProject));
AddProject(new Project().WithProjectName("Dummy"));
public CenterViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, IOperationManager manager,
LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
IMainWindowCoordinator mainWindow, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
var proxy = Context.ActorOf <ObservableActor>("Loading_Proxy");
this.Receive <IncommingEvent>(e => e.Action());
Views = this.RegisterUiCollection <ProjectViewContainer>(nameof(Views)).BindToList(out var viewList);
CurrentProject = RegisterProperty <int?>(nameof(CurrentProject));
AddProject(new Project {
ProjectName = "Dummy"
});
public MainWindow(IViewModel <MainWindowViewModel> model, LocLocalizer localizer,
IMainWindowCoordinator mainWindowCoordinator, IDialogCoordinator coordinator,
ProjectFileWorkspace workspace,
CommonUIFramework framework, IOperationManager operationManager)
: base(model)
{
_localizer = localizer;
_mainWindowCoordinator = mainWindowCoordinator;
_coordinator = coordinator;
_workspace = workspace;
_framework = framework;
InitializeComponent();
var diag = (IDialogCoordinatorUIEvents)_coordinator;
diag.ShowDialogEvent += o => this.ShowDialog(o);
diag.HideDialogEvent += () => Dialogs.CurrentSession?.Close();
_mainWindowCoordinator.TitleChanged +=
() => Dispatcher.BeginInvoke(new Action(MainWindowCoordinatorOnTitleChanged));
_mainWindowCoordinator.IsBusyChanged += IsBusyChanged;
Closing += OnClosing;
Closed += async(_, _) =>
{
SaveLayout();
Shutdown?.Invoke(this, EventArgs.Empty);
await Task.Delay(TimeSpan.FromSeconds(60));
Process.GetCurrentProcess().Kill(false);
};
operationManager.OperationFailed
.ObserveOnDispatcher()
.Subscribe(f =>
{
Snackbar.MessageQueue ??= new SnackbarMessageQueue(TimeSpan.FromSeconds(5));
Snackbar.MessageQueue.Enqueue($"{f.Status ?? " / "}");
});
}
public ProjectMutator(MutatingEngine <MutatingContext <ProjectFile> > engine, ProjectFileWorkspace workspace)
{
_engine = engine;
_workspace = workspace;
NewProject = engine.EventSource(
c => c.Select(mc => new AddProject(mc.GetChange <NewProjectChange>().Project)),
c => from context in c
from change in context.Change
select change is NewProjectChange);
RemovedProject = engine.EventSource(c => c.Select(mc => new RemoveProject(mc.GetChange <RemoveProjectChange>().Project)),
c => from context in c
from change in context.Change
select change is RemoveProjectChange);
NewLanguage = engine.EventSource(c => c.Select(mc => mc.GetChange <LanguageChange>().ToEventData()),
c => from context in c
from change in context.Change
select change is LanguageChange);
NewImport = engine.EventSource(c => c.Select(mc => mc.GetChange <AddImportChange>().ToEventData()),
c => from context in c
from change in context.Change
select change is AddImportChange);
RemoveImport = engine.EventSource(c => c.Select(mc => mc.GetChange <RemoveImportChange>().ToData()),
c => from context in c
from change in context.Change
select change is RemoveImportChange);
NewLanguage.RespondOn(null, mayNewLang =>
Do(from newlang in mayNewLang
where !workspace.ProjectFile.GlobalLanguages.Contains(newlang.ActiveLanguage)
where Projects.All(p => p.ActiveLanguages.Contains(newlang.ActiveLanguage))
select Action(() => _engine.Mutate(nameof(AddLanguage) + "Global-Single",
c => from context in c
select context.WithChange(new GlobalLanguageChange(newlang.ActiveLanguage))))));
}
public ProjectViewModel(ILifetimeScope lifetimeScope, Dispatcher dispatcher, LocLocalizer localizer, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
#region Init
var loadTrigger = new CommandTrigger();
Receive <IncommingEvent>(e => e.Action());
IsEnabled = RegisterProperty <bool>(nameof(IsEnabled)).WithDefaultValue(!workspace.ProjectFile.IsEmpty);
ProjectEntrys = this.RegisterUiCollection <ProjectEntryModel>(nameof(ProjectEntrys))
.AndAsync();
SelectedIndex = RegisterProperty <int>(nameof(SelectedIndex));
var self = Context.Self;
void TryUpdateEntry((string ProjectName, string EntryName, ActiveLanguage Lang, string Content) data)
{
var(projectName, entryName, lang, content) = data;
self.Tell(new UpdateRequest(entryName, lang, content, projectName));
}
void TryRemoveEntry((string ProjectName, string EntryName) data)
{
var(projectName, entryName) = data;
self.Tell(new RemoveRequest(entryName, projectName));
}
OnPreRestart += (exception, o) => Self.Tell(new InitProjectViewModel(workspace.Get(_project)));
void InitProjectViewModel(InitProjectViewModel obj)
{
_project = obj.Project.ProjectName;
Languages !.Add(new ProjectViewLanguageModel(localizer.ProjectViewLanguageBoxFirstLabel, true));
Languages.AddRange(obj.Project.ActiveLanguages.Select(al => new ProjectViewLanguageModel(al.Name, false)));
SelectedIndex += 0;
foreach (var projectEntry in obj.Project.Entries.OrderBy(le => le.Key))
{
ProjectEntrys.Add(new ProjectEntryModel(obj.Project, projectEntry, TryUpdateEntry, TryRemoveEntry));
}
ImportetProjects !.AddRange(obj.Project.Imports);
loadTrigger.Trigger();
}
Receive <InitProjectViewModel>(InitProjectViewModel);
#endregion
#region New Entry
IEnumerable <NewEntryInfoBase> GetEntrys()
{
var list = ImportetProjects.ToList();
list.Add(_project);
var allEntrys = list.SelectMany(pro => workspace.Get(pro).Entries.Select(e => e.Key)).ToArray();
return(allEntrys.Select(e => new NewEntryInfo(e)).OfType <NewEntryInfoBase>()
.Concat(allEntrys
.Select(s => s.Split('_', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault())
.Where(s => !string.IsNullOrWhiteSpace(s))
.Distinct(StringComparer.Ordinal)
.Select(s => new NewEntrySuggestInfo(s !))));
}
void AddEntry(EntryAdd entry)
{
if (_project != entry.Entry.Project)
{
return;
}
ProjectEntrys.Add(new ProjectEntryModel(workspace.Get(_project), entry.Entry, TryUpdateEntry, TryRemoveEntry));
}
NewCommad
.ThenFlow(this.ShowDialog <INewEntryDialog, NewEntryDialogResult?, IEnumerable <NewEntryInfoBase> >(GetEntrys),
b =>
{
b.Mutate(workspace.Entrys).With(em => em.EntryAdd, em => res => em.NewEntry(_project, res !.Name)).ToSelf()
.Then(b2 => b2.Action(AddEntry));
})
public MainWindowViewModel(ILifetimeScope lifetimeScope, Dispatcher dispatcher, IOperationManager operationManager, LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
AppConfig config, IDialogFactory dialogFactory, IViewModel <CenterViewModel> model, IMainWindowCoordinator mainWindowCoordinator, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
Receive <IncommingEvent>(e => e.Action());
var last = QueryProperty.Create <ProjectFile?>();
var loadingOperation = QueryProperty.Create <OperationController?>();
var self = Self;
CenterView = this.RegisterViewModel(nameof(CenterView), model);
workspace.Source.ProjectReset.RespondOn(null, pr => last.Value = pr.ProjectFile);
#region Restarting
OnPreRestart += (exception, o) =>
{
if (last != null)
{
Self.Tell(last);
}
};
Receive <ProjectFile>(workspace.Reset);
#endregion
#region Operation Manager
RunningOperations = RegisterProperty <IEnumerable <RunningOperation> >(nameof(RunningOperations)).WithDefaultValue(operationManager.RunningOperations);
RenctFiles = RegisterProperty <RenctFilesCollection>(nameof(RenctFiles)).WithDefaultValue(new RenctFilesCollection(config, s => self.Tell(new InternlRenctFile(s))));
NewCommad.WithExecute(operationManager.Clear, b => operationManager.ShouldClear(b, AddResource)).ThenRegister("ClearOp");
NewCommad.WithExecute(operationManager.CompledClear, b => operationManager.ShouldCompledClear(b, AddResource)).ThenRegister("ClearAllOp");
#endregion
#region Save As
UpdateSource?SaveAsProject()
{
var targetFile = dialogFactory.ShowSaveFileDialog(null, true, false, true, "transp", true,
localizer.OpenFileDialogViewDialogFilter, true, true, localizer.MainWindowMainMenuFileSaveAs, Directory.GetCurrentDirectory(), out var result);
if (result != true && CheckSourceOk(targetFile))
{
return(null);
}
return(new UpdateSource(targetFile !));
}
bool CheckSourceOk(string?source)
{
if (!string.IsNullOrWhiteSpace(source))
{
return(false);
}
UICall(() => dialogCoordinator.ShowMessage(localizer.CommonError, localizer.MainWindowModelLoadProjectSourceEmpty !));
return(true);
}
NewCommad.WithCanExecute(b => b.FromProperty(last, file => file != null && !file.IsEmpty))
.ThenFlow(SaveAsProject, b => b.Send.ToModel(CenterView))
.ThenRegister("SaveAs");
#endregion
#region Open File
Receive <InternlRenctFile>(o => OpentFileSource(o.File));
async Task <LoadedProjectFile?> SourceSelectedFunc(SourceSelected s)
{
if (s.Mode != OpenFileMode.OpenExistingFile)
{
return(await NewFileSource(s.Source));
}
OpentFileSource(s.Source);
return(null);
}
void OpentFileSource(string?source)
{
if (CheckSourceOk(source))
{
return;
}
mainWindowCoordinator.IsBusy = true;
loadingOperation.Value = operationManager.StartOperation(string.Format(localizer.MainWindowModelLoadProjectOperation, Path.GetFileName(source) ?? source));
if (!workspace.ProjectFile !.IsEmpty)
{
workspace.ProjectFile.Operator.Tell(ForceSave.Force(workspace.ProjectFile));
}
ProjectFile.BeginLoad(Context, loadingOperation.Value.Id, source !, "Project_Operator");
}
SupplyNewProjectFile?ProjectLoaded(LoadedProjectFile obj)
{
if (loadingOperation !.Value != null)
{
if (obj.Ok)
{
loadingOperation.Value.Compled();
}
else
{
mainWindowCoordinator.IsBusy = false;
loadingOperation.Value.Failed(obj.ErrorReason?.Message ?? localizer.CommonError);
return(null);
}
}
loadingOperation.Value = null;
if (obj.Ok)
{
RenctFiles.Value.AddNewFile(obj.ProjectFile.Source);
}
last !.Value = obj.ProjectFile;
return(new SupplyNewProjectFile(obj.ProjectFile));
}
NewCommad.WithCanExecute(b => b.NotNull(loadingOperation))
.ThenFlow(
SourceSelected.From(this.ShowDialog <IOpenFileDialog, string?>(TypedParameter.From(OpenFileMode.OpenExistingFile)), OpenFileMode.OpenExistingFile),
b =>
{
b.Func(SourceSelectedFunc).ToSelf()
.Then(b2 => b2.Func(ProjectLoaded !).ToModel(CenterView));
})
public ProjectViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, LocLocalizer localizer,
ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
#region Init
Languages = this.RegisterUiCollection <ProjectViewLanguageModel>(nameof(Languages))
.BindToList(out var languages);
ProjectEntrys = this.RegisterUiCollection <ProjectEntryModel>(nameof(ProjectEntrys))
.BindToList(out var projectEntrys);
ImportetProjects = this.RegisterUiCollection <string>(nameof(ImportetProjects))
.BindToList(out var importprojects);
var loadTrigger = new Subject <Unit>();
this.Receive <IncommingEvent>(e => e.Action());
IsEnabled = RegisterProperty <bool>(nameof(IsEnabled)).WithDefaultValue(!workspace.ProjectFile.IsEmpty);
SelectedIndex = RegisterProperty <int>(nameof(SelectedIndex));
var self = Context.Self;
void TryUpdateEntry((string ProjectName, string EntryName, ActiveLanguage Lang, string Content) data)
{
var(projectName, entryName, lang, content) = data;
self.Tell(new UpdateRequest(entryName, lang, content, projectName));
}
void TryRemoveEntry((string ProjectName, string EntryName) data)
{
var(projectName, entryName) = data;
self.Tell(new RemoveRequest(entryName, projectName));
}
Start.Subscribe(_ => Self.Tell(new InitProjectViewModel(workspace.Get(_project))));
void InitProjectViewModel(InitProjectViewModel obj)
{
_project = obj.Project.ProjectName;
languages.Edit(l =>
{
l.Add(new ProjectViewLanguageModel(localizer.ProjectViewLanguageBoxFirstLabel, true));
l.AddRange(obj.Project.ActiveLanguages.Select(al => new ProjectViewLanguageModel(al.Name, false)));
});
SelectedIndex += 0;
projectEntrys.AddRange(obj.Project.Entries.OrderBy(le => le.Key).Select(le
=> new ProjectEntryModel(obj.Project, le, TryUpdateEntry, TryRemoveEntry)));
importprojects.AddRange(obj.Project.Imports);
loadTrigger.OnNext(Unit.Default);
}
this.Receive <InitProjectViewModel>(InitProjectViewModel);
#endregion
#region New Entry
IEnumerable <NewEntryInfoBase> GetEntrys()
{
var list = ImportetProjects !.ToList();
list.Add(_project);
var allEntrys = list.SelectMany(pro => workspace.Get(pro).Entries.Select(e => e.Key)).ToArray();
return(allEntrys.Select(e => new NewEntryInfo(e)).OfType <NewEntryInfoBase>()
.Concat(allEntrys
.Select(s => s.Split('_', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault())
.Where(s => !string.IsNullOrWhiteSpace(s))
.Distinct(StringComparer.Ordinal)
.Select(s => new NewEntrySuggestInfo(s !))));
}
void AddEntry(EntryAdd entry)
{
if (_project != entry.Entry.Project)
{
return;
}
projectEntrys.Add(new ProjectEntryModel(workspace.Get(_project), entry.Entry, TryUpdateEntry,
TryRemoveEntry));
}
NewCommad.WithFlow(ob => ob.Select(_ => GetEntrys())
.Dialog(this).Of <INewEntryDialog, NewEntryDialogResult?>()
.NotNull()
.Mutate(workspace.Entrys).With(em => em.EntryAdd, em => res => em.NewEntry(_project, res.Name))
.ObserveOnSelf()
.Subscribe(AddEntry))
.ThenRegister("NewEntry");
#endregion
#region Remove Request
void RemoveEntry(EntryRemove entry)
{
if (_project != entry.Entry.Project)
{
return;
}
var index = ProjectEntrys !.FindIndex(em => em.EntryName == entry.Entry.Key);
if (index == -1)
{
return;
}
projectEntrys !.RemoveAt(index);
}
Receive <RemoveRequest>(obs => obs.Mutate(workspace.Entrys)
.With(em => em.EntryRemove, em => rr => em.RemoveEntry(rr.ProjectName, rr.EntryName))
.ObserveOnSelf()
.Subscribe(RemoveEntry));
#endregion
#region Update Request
void UpdateEntry(EntryUpdate obj)
{
if (_project != obj.Entry.Project)
{
return;
}
var model = ProjectEntrys !.FirstOrDefault(m => m.EntryName == obj.Entry.Key);
model?.Update(obj.Entry);
}
Receive <UpdateRequest>(obs => obs.Mutate(workspace.Entrys).With(em => em.EntryUpdate,
em => ur => em.UpdateEntry(ur.ProjectName, ur.Language, ur.EntryName, ur.Content))
.ObserveOnSelf()
.Subscribe(UpdateEntry));
#endregion
#region Imports
void AddImport(AddImport obj)
{
var(projectName, import) = obj;
if (projectName != _project)
{
return;
}
importprojects !.Add(import);
}
IEnumerable <string> GetImportableProjects()
{
var pro = workspace.Get(_project);
return(workspace.ProjectFile.Projects.Select(p => p.ProjectName)
.Where(p => p != _project && !pro.Imports.Contains(p)));
}
ImportSelectIndex = RegisterProperty <int>(nameof(ImportSelectIndex)).WithDefaultValue(-1);
NewCommad.WithCanExecute(from trigger in loadTrigger
select GetImportableProjects().Any())
.WithFlow(ob => ob.Select(_ => GetImportableProjects())
.Dialog(this).Of <IImportProjectDialog, ImportProjectDialogResult?>()
.NotNull()
.Mutate(workspace.Projects).With(pm => pm.NewImport, pm => r => pm.AddImport(_project, r.Project))
.ObserveOnSelf()
.Subscribe(AddImport))
.ThenRegister("AddImport");
void RemoveImport(RemoveImport import)
{
var(targetProject, toRemove) = import;
if (_project != targetProject)
{
return;
}
importprojects !.Remove(toRemove);
}
NewCommad.WithCanExecute(ImportSelectIndex.Select(i => i != -1))
.WithFlow(ob => ob.Select(_ => new InitImportRemove(ImportetProjects[ImportSelectIndex]))
.Mutate(workspace.Projects).With(pm => pm.RemoveImport,
pm => ir => pm.TryRemoveImport(_project, ir.ToRemove))
.Subscribe(RemoveImport))
.ThenRegister("RemoveImport");
workspace.Projects.NewImport.ToUnit().Subscribe(loadTrigger).DisposeWith(this);
workspace.Projects.RemoveImport.ToUnit().Subscribe(loadTrigger).DisposeWith(this);
#endregion
#region AddLanguage
void AddActiveLanguage(AddActiveLanguage language)
{
if (language.ProjectName != _project)
{
return;
}
languages.Add(new ProjectViewLanguageModel(language.ActiveLanguage.Name, false));
foreach (var model in ProjectEntrys)
{
model.AddLanguage(language.ActiveLanguage);
}
}
NewCommad.WithFlow(ob => ob
.Select(_ => workspace.Get(_project).ActiveLanguages.Select(al => al.ToCulture()).ToArray())
.Dialog(this).Of <ILanguageSelectorDialog, AddLanguageDialogResult?>()
.NotNull()
.Mutate(workspace.Projects)
.With(pm => pm.NewLanguage, pm => d => pm.AddLanguage(_project, d.CultureInfo))
.Subscribe(AddActiveLanguage))
.ThenRegister("AddLanguage");
#endregion
}
public static CommandQuery NoEmptyProjectFile(this CommandQueryBuilder builder, ProjectFileWorkspace workspace) => builder.FromEventSource(workspace.Source.ProjectReset, rest => !rest.ProjectFile.IsEmpty, new ProjectRest(workspace.ProjectFile));
public MainWindowViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher,
IOperationManager operationManager, LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
AppConfig config, IDialogFactory dialogFactory, IViewModel <CenterViewModel> model,
IMainWindowCoordinator mainWindowCoordinator, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
this.Receive <IncommingEvent>(e => e.Action());
var last = new RxVar <ProjectFile?>(null);
var loadingOperation = new RxVar <OperationController?>(null);
var self = Self;
CenterView = this.RegisterViewModel(nameof(CenterView), model);
workspace.Source.ProjectReset.RespondOn(null, pr => last.Value = pr.ProjectFile);
#region Restarting
Start.Subscribe(_ =>
{
if (last != null)
{
Self.Tell(last);
}
});
this.Receive <ProjectFile>(workspace.Reset);
#endregion
#region Operation Manager
RunningOperations = RegisterProperty <IEnumerable <RunningOperation> >(nameof(RunningOperations))
.WithDefaultValue(operationManager.RunningOperations);
RenctFiles = RegisterProperty <RenctFilesCollection>(nameof(RenctFiles))
.WithDefaultValue(new RenctFilesCollection(config, s => self.Tell(new InternlRenctFile(s))));
NewCommad.WithExecute(operationManager.Clear, operationManager.ShouldClear()).ThenRegister("ClearOp");
NewCommad.WithExecute(operationManager.CompledClear, operationManager.ShouldCompledClear())
.ThenRegister("ClearAllOp");
#endregion
#region Save As
IObservable <UpdateSource> SaveAsProject()
{
var targetFile = dialogFactory.ShowSaveFileDialog(null, true, false, true, "transp", true,
localizer.OpenFileDialogViewDialogFilter, true, true, localizer.MainWindowMainMenuFileSaveAs,
Directory.GetCurrentDirectory());
return(targetFile.NotEmpty()
.SelectMany(CheckSourceOk)
.Where(d => d.Item1)
.Select(r => new UpdateSource(r.Item2)));
}
async Task <(bool, string)> CheckSourceOk(string source)
{
if (!string.IsNullOrWhiteSpace(source))
{
return(true, source);
}
await UICall(()
=> dialogCoordinator.ShowMessage(localizer.CommonError,
localizer.MainWindowModelLoadProjectSourceEmpty !));
return(false, source);
}
NewCommad.WithCanExecute(last.Select(pf => pf != null && !pf.IsEmpty))
.WithFlow(ob => ob.SelectMany(_ => SaveAsProject())
.ToModel(CenterView))
.ThenRegister("SaveAs");
#endregion
#region Open File
IDisposable NewProjectFile(IObservable <SourceSelected> source) => source
.SelectMany(SourceSelectedFunc)
.NotNull()
.ObserveOnSelf()
.Select(ProjectLoaded)
.ToModel(CenterView !);
this.Receive <InternlRenctFile>(o => OpentFileSource(o.File));
IObservable <LoadedProjectFile?> SourceSelectedFunc(SourceSelected s)
{
if (s.Mode != OpenFileMode.OpenExistingFile)
{
return(NewFileSource(s.Source));
}
OpentFileSource(s.Source);
return(Observable.Return <LoadedProjectFile?>(null));
}
void OpentFileSource(string?rawSource)
{
Observable.Return(rawSource)
.NotEmpty()
.SelectMany(CheckSourceOk)
.Select(p => p.Item2)
.Do(_ => mainWindowCoordinator.IsBusy = true)
.SelectMany(source => operationManager
.StartOperation(string.Format(localizer.MainWindowModelLoadProjectOperation,
Path.GetFileName(source)))
.Do(op => loadingOperation !.Value = op)
.Select(operationController => (operationController, source)))
.Do(_ =>
{
if (!workspace.ProjectFile.IsEmpty)
{
workspace.ProjectFile.Operator.Tell(ForceSave.Force(workspace.ProjectFile));
}
})
.ObserveOnSelf()
.Subscribe(pair
=> ProjectFile.BeginLoad(Context, pair.operationController.Id, pair.source,
"Project_Operator"));
}
SupplyNewProjectFile?ProjectLoaded(LoadedProjectFile obj)
{
try
{
if (loadingOperation !.Value != null)
{
if (obj.Ok)
{
loadingOperation.Value.Compled();
}
else
{
loadingOperation.Value.Failed(obj.ErrorReason?.Message ?? localizer.CommonError);
return(null);
}
}
loadingOperation.Value = null;
if (obj.Ok)
{
RenctFiles !.Value.AddNewFile(obj.ProjectFile.Source);
}
last !.Value = obj.ProjectFile;
return(new SupplyNewProjectFile(obj.ProjectFile));
}
finally
{
mainWindowCoordinator.IsBusy = false;
}
}
NewCommad.WithCanExecute(loadingOperation.Select(oc => oc == null))
.WithFlow(obs => NewProjectFile(obs.Dialog(this, TypedParameter.From(OpenFileMode.OpenExistingFile))
.Of <IOpenFileDialog, string?>()
.Select(s => SourceSelected.From(s, OpenFileMode.OpenExistingFile))))
.ThenRegister("OpenFile");
NewProjectFile(Receive <SourceSelected>()).DisposeWith(this);
Receive <LoadedProjectFile>(ob => ob.Select(ProjectLoaded).ToModel(CenterView !));
#endregion
#region New File
IObservable <LoadedProjectFile?> NewFileSource(string?source)
{
source ??= string.Empty;
var data = new LoadedProjectFile(string.Empty,
ProjectFile.NewProjectFile(Context, source, "Project_Operator"), null, true);
if (File.Exists(source))
{
//TODO NewFile Filog Message
var result = UICall(async()
=> await dialogCoordinator.ShowMessage(localizer.CommonError !, "", null));
return(result.Where(b => b == true).Do(_ => mainWindowCoordinator.IsBusy = true).Select(_ => data));
}
mainWindowCoordinator.IsBusy = true;
return(Observable.Return(data));
}
NewCommad.WithCanExecute(loadingOperation.Select(oc => oc == null))
.WithFlow(obs => obs.Dialog(this, TypedParameter.From(OpenFileMode.OpenNewFile))
.Of <IOpenFileDialog, string?>()
.Select(s => SourceSelected.From(s, OpenFileMode.OpenNewFile))
.ToSelf())
.ThenRegister("NewFile");
#endregion
#region Analyzing
AnalyzerEntries = this.RegisterUiCollection <AnalyzerEntry>(nameof(AnalyzerEntries))
.BindToList(out var analyterList);
var builder = new AnalyzerEntryBuilder(localizer);
void IssuesChanged(IssuesEvent obj)
{
analyterList.Edit(l =>
{
var(ruleName, issues) = obj;
l.Remove(AnalyzerEntries.Where(e => e.RuleName == ruleName));
l.AddRange(issues.Select(builder.Get));
});
}
this.RespondOnEventSource(workspace.Analyzer.Issues, IssuesChanged);
#endregion
#region Build
var buildModel = lifetimeScope.Resolve <IViewModel <BuildViewModel> >();
buildModel.InitModel(Context, "Build-View");
BuildModel = RegisterProperty <IViewModel <BuildViewModel> >(nameof(BuildModel)).WithDefaultValue(buildModel);
#endregion
}
