600 lines
19 KiB
C#
600 lines
19 KiB
C#
using BeWo.ServiceProxy;
|
|
using BeWo.Services;
|
|
using BeWo.ViewModel.ListViewModel;
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.DataContracts.Feature.AI;
|
|
using DevExpress.DataProcessing;
|
|
using DevExpress.Mvvm;
|
|
using DevExpress.Utils.Extensions;
|
|
using DevExpress.Xpf.Layout.Core;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.Remoting.Metadata.W3cXsd2001;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Input;
|
|
using static DevExpress.Utils.Drawing.Helpers.NativeMethods;
|
|
|
|
namespace BeWo.ViewModel.View.Administration
|
|
{
|
|
public class AiPromptbausteinComplexTreeViewModel : WindowViewModel
|
|
{
|
|
private AiPromptbausteinFolderVM _SelectedFolder;
|
|
private AbstractBaseVM _SelectedItem;
|
|
|
|
private IBeWoWindowService WindowService { get; set; }
|
|
private AiActionType AiActionType { get; set; }
|
|
|
|
public AiPromptbausteinFolderListVM Folders { get; set; }
|
|
public AiPromptbausteinFolderVM Favoriten { get; set; }
|
|
|
|
public AiPromptbausteinFolderVM CopiedFolder { get; set; }
|
|
public AiPromptbausteinPromptVM CopiedPrompt { get; set; }
|
|
|
|
public DelegateCommand OpenAddFolderDialogCommand { get; private set; }
|
|
public DelegateCommand OpenEditFolderDialogCommand { get; private set; }
|
|
public DelegateCommand CopyFolderCommand { get; private set; }
|
|
public DelegateCommand PasteFolderCommand { get; private set; }
|
|
public DelegateCommand DeleteFolderCommand { get; private set; }
|
|
|
|
public DelegateCommand OpenAddPromptDialogCommand { get; private set; }
|
|
public DelegateCommand OpenEditPromptDialogCommand { get; private set; }
|
|
public DelegateCommand CopyPromptCommand { get; private set; }
|
|
public DelegateCommand PastePromptCommand { get; private set; }
|
|
public DelegateCommand DeletePromptCommand { get; private set; }
|
|
public DelegateCommand ChangeFavoritenStatePromptCommand { get; private set; }
|
|
|
|
public DelegateCommand OpenAddRoutineDialogCommand { get; private set; }
|
|
public DelegateCommand OpenEditRoutineDialogCommand { get; private set; }
|
|
public DelegateCommand DeleteRoutineCommand { get; private set; }
|
|
public DelegateCommand ChangeFavoritenStateRoutineCommand { get; private set; }
|
|
|
|
public DelegateCommand OpenEditItemDialogCommand { get; private set; }
|
|
public DelegateCommand DeleteItemCommand { get; private set; }
|
|
public DelegateCommand ChangeFavoritenStateItemCommand { get; private set; }
|
|
|
|
public bool CanEditPromptbausteine { get; set; }
|
|
|
|
public AiPromptbausteinFolderVM SelectedFolder
|
|
{
|
|
get => _SelectedFolder;
|
|
set
|
|
{
|
|
var success = SetProperty(ref _SelectedFolder, value, nameof(SelectedFolder));
|
|
|
|
if (SelectedItem is AiPromptbausteinPromptVM vm)
|
|
{
|
|
SelectedItem = null;
|
|
}
|
|
|
|
if (!success)
|
|
return;
|
|
|
|
UpdateFolderCommands();
|
|
UpdatePromptCommands();
|
|
}
|
|
}
|
|
|
|
public AbstractBaseVM SelectedItem
|
|
{
|
|
get => _SelectedItem;
|
|
set {
|
|
var success = SetProperty(ref _SelectedItem, value, nameof(SelectedItem));
|
|
|
|
if (!success)
|
|
return;
|
|
|
|
UpdateItemCommands();
|
|
}
|
|
}
|
|
|
|
public AiPromptbausteinComplexTreeViewModel() : this(null, AiActionType.ServiceRecordConversation)
|
|
{
|
|
if (BeWoApp.IsInDesignMode)
|
|
{
|
|
//ReloadVMList();
|
|
InitDesigner();
|
|
SelectedFolder = Folders.VMList.FirstOrDefault();
|
|
return;
|
|
}
|
|
}
|
|
public AiPromptbausteinComplexTreeViewModel(IBeWoWindowService windowService, AiActionType aiActionType)
|
|
{
|
|
WindowService = windowService;
|
|
AiActionType = aiActionType;
|
|
|
|
OpenAddFolderDialogCommand = new DelegateCommand(OpenAddFolderDialog, canOpenAddFolderDialog, false);
|
|
OpenEditFolderDialogCommand = new DelegateCommand(OpenEditFolderDialog, canOpenEditFolderDialog, false);
|
|
CopyFolderCommand = new DelegateCommand(CopyFolder, canCopyFolder, false);
|
|
PasteFolderCommand = new DelegateCommand(PasteFolder, canPasteFolder, false);
|
|
DeleteFolderCommand = new DelegateCommand(DeleteFolder, canDeleteFolder, false);
|
|
|
|
OpenAddPromptDialogCommand = new DelegateCommand(OpenAddPromptDialog, canOpenAddPromptDialog, false);
|
|
OpenEditPromptDialogCommand = new DelegateCommand(OpenEditPromptDialog, canOpenEditPromptDialog, false);
|
|
CopyPromptCommand = new DelegateCommand(CopyPrompt, canCopyPrompt, false);
|
|
PastePromptCommand = new DelegateCommand(PastePrompt, canPastePrompt, false);
|
|
DeletePromptCommand = new DelegateCommand(OpenDeletePromptDialog, canOpenDeletePromptDialog, false);
|
|
ChangeFavoritenStatePromptCommand = new DelegateCommand(ChangeFavoritenStatePrompt, canChangeFavoritenStatePrompt, false);
|
|
|
|
OpenAddRoutineDialogCommand = new DelegateCommand(OpenAddRoutineDialog, canOpenAddRoutineDialog, false);
|
|
OpenEditRoutineDialogCommand = new DelegateCommand(OpenEditRoutineDialog, canOpenEditRoutineDialog, false);
|
|
DeleteRoutineCommand = new DelegateCommand(OpenDeleteRoutineDialog, canOpenDeleteRoutineDialog, false);
|
|
ChangeFavoritenStateRoutineCommand = new DelegateCommand(ChangeFavoritenStateRoutine, canChangeFavoritenStateRoutine, false);
|
|
|
|
Action executeEditItem = () => ExecuteItem(OpenEditPromptDialog, OpenEditRoutineDialog);
|
|
Func<bool> canExecuteEditItem = () => canExecuteItem(canOpenEditPromptDialog, canOpenEditRoutineDialog);
|
|
OpenEditItemDialogCommand = new DelegateCommand(executeEditItem, canExecuteEditItem, true);
|
|
|
|
Action executeDeleteItem = () => ExecuteItem(OpenDeletePromptDialog, OpenDeleteRoutineDialog);
|
|
Func<bool> canExecuteDeleteItem = () => canExecuteItem(canOpenDeletePromptDialog, canOpenDeleteRoutineDialog);
|
|
DeleteItemCommand = new DelegateCommand(executeDeleteItem, canExecuteDeleteItem, true);
|
|
|
|
Action executeFavoriteItem = () => ExecuteItem(ChangeFavoritenStatePrompt, ChangeFavoritenStateRoutine);
|
|
Func<bool> canExecuteFavoriteItem = () => canExecuteItem(canChangeFavoritenStatePrompt, canChangeFavoritenStateRoutine);
|
|
ChangeFavoritenStateItemCommand = new DelegateCommand(executeFavoriteItem, canExecuteFavoriteItem, true);
|
|
|
|
CanEditPromptbausteine = BeWoApp.HasLoggedOnUserRight(UserRightType.AiModulePromptbausteineEdit);
|
|
}
|
|
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public bool HasCopiedFolder => CopiedFolder is object;
|
|
public bool HasCopiedPrompt => CopiedPrompt is object;
|
|
public CompactEmployeeDC CurrentEmployee => BeWoApp.CompactLoggedOnEmployee;
|
|
|
|
public void UpdateFolderCommands()
|
|
{
|
|
OpenAddFolderDialogCommand.RaiseCanExecuteChanged();
|
|
OpenEditFolderDialogCommand.RaiseCanExecuteChanged();
|
|
CopyFolderCommand.RaiseCanExecuteChanged();
|
|
PasteFolderCommand.RaiseCanExecuteChanged();
|
|
DeleteFolderCommand.RaiseCanExecuteChanged();
|
|
}
|
|
public void UpdatePromptCommands()
|
|
{
|
|
OpenAddPromptDialogCommand.RaiseCanExecuteChanged();
|
|
OpenEditPromptDialogCommand.RaiseCanExecuteChanged();
|
|
CopyPromptCommand.RaiseCanExecuteChanged();
|
|
PastePromptCommand.RaiseCanExecuteChanged();
|
|
DeletePromptCommand.RaiseCanExecuteChanged();
|
|
ChangeFavoritenStatePromptCommand.RaiseCanExecuteChanged();
|
|
OpenAddRoutineDialogCommand.RaiseCanExecuteChanged();
|
|
OpenEditRoutineDialogCommand.RaiseCanExecuteChanged();
|
|
DeleteRoutineCommand.RaiseCanExecuteChanged();
|
|
ChangeFavoritenStateRoutineCommand.RaiseCanExecuteChanged();
|
|
}
|
|
public void UpdateItemCommands()
|
|
{
|
|
OpenEditItemDialogCommand.RaiseCanExecuteChanged();
|
|
DeleteItemCommand.RaiseCanExecuteChanged();
|
|
ChangeFavoritenStateItemCommand.RaiseCanExecuteChanged();
|
|
}
|
|
|
|
internal void ReloadVMList()
|
|
{
|
|
VMFactory.CreateAiPromptbausteinFolderListVMAsync(
|
|
AiActionType,
|
|
listvm =>
|
|
{
|
|
Folders = listvm;
|
|
if (Folders.VMList.Count > 0 && Folders.VMList[0].DataContract.Oid == -5)
|
|
{
|
|
Favoriten = Folders.VMList[0];
|
|
}
|
|
FirePropertyChanged(nameof(Folders));
|
|
});
|
|
}
|
|
|
|
void OpenAddFolderDialog()
|
|
{
|
|
var sel_folder = SelectedFolder;
|
|
var new_vm = sel_folder.SubFolders.CreateNewVM();
|
|
|
|
new_vm.Creator = CurrentEmployee;
|
|
new_vm.Parent = sel_folder;
|
|
new_vm.ParentFolderOid = sel_folder?.DataContract?.Oid;
|
|
new_vm.CanAddFolder = true;
|
|
new_vm.CanAddPrompt = true;
|
|
new_vm.CanEdit = true;
|
|
new_vm.ActionType = AiActionType;
|
|
|
|
var vm = new AiPromptbausteinFolderViewModel(new_vm, true);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
new_vm.UpdateByDataContract(new_dc);
|
|
sel_folder.SubFolders.VMList.Add(new_vm);
|
|
sel_folder.IsExpanded = true;
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
void OpenEditFolderDialog()
|
|
{
|
|
var sel_folder = SelectedFolder;
|
|
var sel_dc = sel_folder.CopyToEmptyDataContract();
|
|
sel_dc.CanEdit = SelectedFolder.CanEdit;
|
|
sel_dc.Oid = sel_folder.DataContract.Oid;
|
|
sel_dc.Version = sel_folder.DataContract.Version;
|
|
var edit_vm = new AiPromptbausteinFolderVM(sel_dc);
|
|
|
|
var vm = new AiPromptbausteinFolderViewModel(edit_vm, false);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
sel_folder.UpdateByDataContract(new_dc);
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
void CopyFolder()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
void PasteFolder()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
void DeleteFolder()
|
|
{
|
|
var sel_folder = SelectedFolder;
|
|
var parent = sel_folder.Parent;
|
|
|
|
var txt = "Möchten Sie den ausgewählten Ordner wirklich löschen?";
|
|
var result = MessageBox.Show(txt, "Hinweis", MessageBoxButton.OKCancel);
|
|
|
|
if (result != MessageBoxResult.OK)
|
|
return;
|
|
|
|
var delete_dc = sel_folder.CommitToDataContract();
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinFolder(delete_dc),
|
|
() => parent.SubFolders.VMList.Remove(sel_folder));
|
|
}
|
|
|
|
bool canOpenAddFolderDialog()
|
|
{
|
|
return CanEditPromptbausteine && (SelectedFolder?.CanAddFolder ?? false);
|
|
}
|
|
bool canOpenEditFolderDialog()
|
|
{
|
|
return CanEditPromptbausteine && (SelectedFolder?.CanEdit ?? false);
|
|
}
|
|
bool canCopyFolder()
|
|
{
|
|
return false;
|
|
//return SelectedFolder.CanEdit;
|
|
}
|
|
bool canPasteFolder()
|
|
{
|
|
return false;
|
|
//return HasCopiedFolder && SelectedFolder.CanAdd;
|
|
}
|
|
bool canDeleteFolder()
|
|
{
|
|
return CanEditPromptbausteine && (SelectedFolder?.CanEdit ?? false);
|
|
}
|
|
|
|
void OpenAddPromptDialog()
|
|
{
|
|
var sel_folder = SelectedFolder;
|
|
var new_vm = sel_folder.SubPrompts.CreateNewVM();
|
|
|
|
new_vm.Creator = CurrentEmployee;
|
|
new_vm.ParentFolderOid = sel_folder.DataContract.Oid;
|
|
new_vm.ShowPrompt = true;
|
|
new_vm.ShowPromptByTenant = true;
|
|
new_vm.CanEdit = true;
|
|
new_vm.ActionType = AiActionType;
|
|
|
|
var vm = new AiPromptbausteinPromptViewModel(new_vm);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
new_vm.UpdateByDataContract(new_dc);
|
|
sel_folder.SubPrompts.VMList.Add(new_vm);
|
|
SelectedItem = new_vm;
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
void OpenEditPromptDialog()
|
|
{
|
|
var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;
|
|
|
|
if (SelectedItem is null)
|
|
throw new Exception("invalid operation");
|
|
|
|
var sel_dc = sel_prompt.CopyToEmptyDataContract();
|
|
sel_dc.CanEdit = sel_prompt.CanEdit;
|
|
sel_dc.Oid = sel_prompt.DataContract.Oid;
|
|
sel_dc.Version = sel_prompt.DataContract.Version;
|
|
var edit_vm = new AiPromptbausteinPromptVM(sel_dc);
|
|
|
|
var vm = new AiPromptbausteinPromptViewModel(edit_vm);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
sel_prompt.UpdateByDataContract(new_dc);
|
|
UpdateSelectedPromptFavorite(sel_prompt);
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
|
|
private void UpdateSelectedPromptFavorite(AiPromptbausteinPromptVM sel_prompt = null)
|
|
{
|
|
if (sel_prompt is null)
|
|
sel_prompt = SelectedItem as AiPromptbausteinPromptVM;
|
|
|
|
if (sel_prompt.IsFavorite && !Favoriten.SubPrompts.VMList.Contains(sel_prompt))
|
|
Favoriten.SubPrompts.VMList.Add(sel_prompt);
|
|
else if (!sel_prompt.IsFavorite && Favoriten.SubPrompts.VMList.Contains(sel_prompt))
|
|
{
|
|
Favoriten.SubPrompts.VMList.Remove(sel_prompt);
|
|
|
|
if (Favoriten.SubRoutines.Count == 0 && Favoriten.SubPrompts.Count == 0)
|
|
{
|
|
var selected_folder = SelectedFolder;
|
|
SelectedFolder = null;
|
|
SelectedFolder = selected_folder;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateSelectedRoutineFavorite(AiPromptbausteinRoutineVM sel_routine = null)
|
|
{
|
|
if (sel_routine is null)
|
|
sel_routine = SelectedItem as AiPromptbausteinRoutineVM;
|
|
|
|
if (sel_routine.IsFavorite && !Favoriten.SubRoutines.VMList.Contains(sel_routine))
|
|
Favoriten.SubRoutines.VMList.Add(sel_routine);
|
|
else if (!sel_routine.IsFavorite && Favoriten.SubRoutines.VMList.Contains(sel_routine))
|
|
{
|
|
Favoriten.SubRoutines.VMList.Remove(sel_routine);
|
|
|
|
if (Favoriten.SubRoutines.Count == 0 && Favoriten.SubPrompts.Count == 0)
|
|
{
|
|
var selected_folder = SelectedFolder;
|
|
SelectedFolder = null;
|
|
SelectedFolder = selected_folder;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CopyPrompt()
|
|
{
|
|
CopiedPrompt = SelectedItem as AiPromptbausteinPromptVM;
|
|
}
|
|
void PastePrompt()
|
|
{
|
|
var copied_dc = CopiedPrompt.CommitToDataContract();
|
|
copied_dc.Creator = CurrentEmployee;
|
|
copied_dc.CanEdit = true;
|
|
copied_dc.IsPublic = false;
|
|
copied_dc.IsFavorite = false;
|
|
copied_dc.Oid = null;
|
|
copied_dc.Version = null;
|
|
copied_dc.ParentFolderOid = SelectedFolder.DataContract.Oid;
|
|
copied_dc.ActionType = AiActionType;
|
|
copied_dc.PromptId = null;
|
|
|
|
var copied_vm = new AiPromptbausteinPromptVM(copied_dc);
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.InsertAiPromptbausteinPrompt(copied_dc),
|
|
new_dc =>
|
|
{
|
|
copied_vm.UpdateByDataContract(new_dc);
|
|
SelectedFolder.SubPrompts.VMList.Add(copied_vm);
|
|
SelectedItem = copied_vm;
|
|
});
|
|
}
|
|
void OpenDeletePromptDialog()
|
|
{
|
|
var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;
|
|
var folder = SelectedFolder;
|
|
|
|
var txt = "Möchten Sie den ausgewählten Prompt wirklich löschen?";
|
|
var result = MessageBox.Show(txt, "Hinweis", MessageBoxButton.OKCancel);
|
|
|
|
if (result != MessageBoxResult.OK)
|
|
return;
|
|
|
|
if (sel_prompt.IsFavorite)
|
|
{
|
|
sel_prompt.IsFavorite = false;
|
|
UpdateSelectedPromptFavorite();
|
|
}
|
|
|
|
var delete_dc = sel_prompt.CommitToDataContract();
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinPrompt(delete_dc),
|
|
() =>
|
|
{
|
|
if (folder.SubPrompts.VMList.Contains(sel_prompt))
|
|
{
|
|
folder.SubPrompts.VMList.Remove(sel_prompt);
|
|
}
|
|
else
|
|
{
|
|
ReloadVMList();
|
|
}
|
|
});
|
|
}
|
|
|
|
void ChangeFavoritenStatePrompt()
|
|
{
|
|
var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;
|
|
|
|
sel_prompt.IsFavorite = !sel_prompt.IsFavorite;
|
|
|
|
var edit_dc = sel_prompt.CommitToDataContract();
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinPrompt(edit_dc),
|
|
new_dc =>
|
|
{
|
|
sel_prompt.UpdateByDataContract(new_dc);
|
|
UpdateSelectedPromptFavorite(sel_prompt);
|
|
});
|
|
}
|
|
|
|
bool canOpenAddPromptDialog()
|
|
{
|
|
return CanEditPromptbausteine && (SelectedFolder?.CanAddPrompt ?? false);
|
|
}
|
|
bool canOpenEditPromptDialog()
|
|
{
|
|
return SelectedItem as AiPromptbausteinPromptVM is object;
|
|
}
|
|
bool canCopyPrompt()
|
|
{
|
|
return CanEditPromptbausteine && SelectedItem as AiPromptbausteinPromptVM is object;
|
|
}
|
|
bool canPastePrompt()
|
|
{
|
|
return canOpenAddPromptDialog() && HasCopiedPrompt;
|
|
}
|
|
bool canOpenDeletePromptDialog()
|
|
{
|
|
return CanEditPromptbausteine && ((SelectedItem as AiPromptbausteinPromptVM)?.CanEdit ?? false);
|
|
}
|
|
|
|
bool canChangeFavoritenStatePrompt()
|
|
{
|
|
return SelectedItem as AiPromptbausteinPromptVM is object;
|
|
}
|
|
|
|
// --- Routine Commands
|
|
|
|
void OpenAddRoutineDialog()
|
|
{
|
|
var sel_folder = SelectedFolder;
|
|
var new_vm = sel_folder.SubRoutines.CreateNewVM();
|
|
|
|
new_vm.Creator = CurrentEmployee;
|
|
new_vm.ParentFolderOid = sel_folder.DataContract.Oid;
|
|
new_vm.CanEdit = true;
|
|
new_vm.ActionType = AiActionType;
|
|
|
|
var vm = new AiPromptbausteinRoutineViewModel(new_vm, Folders);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
new_vm.UpdateByDataContract(new_dc);
|
|
sel_folder.SubRoutines.VMList.Add(new_vm);
|
|
SelectedItem = new_vm;
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
void OpenEditRoutineDialog()
|
|
{
|
|
var sel_prompt = SelectedItem as AiPromptbausteinRoutineVM;
|
|
|
|
if (SelectedItem is null)
|
|
throw new Exception("invalid operation");
|
|
|
|
var sel_dc = sel_prompt.CopyToEmptyDataContract();
|
|
sel_dc.CanEdit = sel_prompt.CanEdit;
|
|
sel_dc.Oid = sel_prompt.DataContract.Oid;
|
|
sel_dc.Version = sel_prompt.DataContract.Version;
|
|
var edit_vm = new AiPromptbausteinRoutineVM(sel_dc);
|
|
|
|
var vm = new AiPromptbausteinRoutineViewModel(edit_vm, Folders);
|
|
|
|
vm.DataSaved += (s, new_dc) =>
|
|
{
|
|
sel_prompt.UpdateByDataContract(new_dc);
|
|
UpdateSelectedRoutineFavorite(sel_prompt);
|
|
};
|
|
|
|
WindowService.Show(vm);
|
|
}
|
|
void OpenDeleteRoutineDialog()
|
|
{
|
|
var sel_prompt = SelectedItem as AiPromptbausteinRoutineVM;
|
|
var folder = SelectedFolder;
|
|
|
|
var txt = "Möchten Sie die ausgewählte Routine wirklich löschen?";
|
|
var result = MessageBox.Show(txt, "Hinweis", MessageBoxButton.OKCancel);
|
|
|
|
if (result != MessageBoxResult.OK)
|
|
return;
|
|
|
|
if (sel_prompt.IsFavorite)
|
|
{
|
|
sel_prompt.IsFavorite = false;
|
|
UpdateSelectedRoutineFavorite();
|
|
}
|
|
|
|
var delete_dc = sel_prompt.CommitToDataContract();
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinRoutine(delete_dc),
|
|
() =>
|
|
{
|
|
if (folder.SubRoutines.VMList.Contains(sel_prompt))
|
|
{
|
|
folder.SubRoutines.VMList.Remove(sel_prompt);
|
|
}
|
|
else
|
|
{
|
|
ReloadVMList();
|
|
}
|
|
});
|
|
}
|
|
void ChangeFavoritenStateRoutine()
|
|
{
|
|
var sel_routine = SelectedItem as AiPromptbausteinRoutineVM;
|
|
|
|
sel_routine.IsFavorite = !sel_routine.IsFavorite;
|
|
|
|
var edit_dc = sel_routine.CommitToDataContract();
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinRoutine(edit_dc),
|
|
new_dc =>
|
|
{
|
|
sel_routine.UpdateByDataContract(new_dc);
|
|
UpdateSelectedRoutineFavorite(sel_routine);
|
|
});
|
|
}
|
|
|
|
bool canOpenAddRoutineDialog() => CanEditPromptbausteine && (SelectedFolder?.CanAddPrompt ?? false);
|
|
bool canOpenEditRoutineDialog() => SelectedItem is AiPromptbausteinRoutineVM;
|
|
bool canOpenDeleteRoutineDialog() => CanEditPromptbausteine && ((SelectedItem as AiPromptbausteinRoutineVM)?.CanEdit ?? false);
|
|
bool canChangeFavoritenStateRoutine() => SelectedItem is AiPromptbausteinRoutineVM;
|
|
|
|
void ExecuteItem(Action prompt_action, Action routine_action)
|
|
{
|
|
if (SelectedItem is AiPromptbausteinPromptVM)
|
|
prompt_action();
|
|
else if (SelectedItem is AiPromptbausteinRoutineVM)
|
|
routine_action();
|
|
else
|
|
throw new NotImplementedException("item is not AiPromptbausteinPromptVM or AiPromptbausteinRoutineVM");
|
|
}
|
|
bool canExecuteItem(Func<bool> prompt_func, Func<bool> routine_func)
|
|
{
|
|
if (SelectedItem is AiPromptbausteinPromptVM)
|
|
return prompt_func();
|
|
else if (SelectedItem is AiPromptbausteinRoutineVM)
|
|
return routine_func();
|
|
|
|
return false;
|
|
}
|
|
|
|
void InitDesigner()
|
|
{
|
|
var root = PredefinedAiPromptbausteinFolders.CreateSubTree(AiActionType.ServiceRecordConversation);
|
|
|
|
var root_vm = new AiPromptbausteinFolderListVM(root);
|
|
|
|
Folders = root_vm;
|
|
}
|
|
}
|
|
}
|