ownSoft/BeWoPlaner
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ListViewModel nicht mehr so überladen, nur noch für reine VM Liste. Commands und co in View/

Browse Source
This commit is contained in:
Rene Evertz
2025-06-30 13:05:29 +02:00
parent b37e9acdfa
commit 6fff7ad6d2
2 changed files with 1 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
BeWo/View/Detail/AI/AiConversationChatView.xaml.cs
View File

@@ -33,7 +33,7 @@ namespace BeWo.View.Detail.AI
{
InitializeComponent();
DataContext = viewModel;
ViewModel = viewModel;
((INotifyCollectionChanged)listview_messages.Items).CollectionChanged += listview_messages_CollectionChanged;
popup_settings.Closed += (s, e) => ViewModel.UpdateConfig();

394
BeWo/ViewModel/ListViewModel/AiConversationListVM.cs
View File

@@ -28,16 +28,6 @@ namespace BeWo.ViewModel.ListViewModel
{
public class AiConversationListVM : AbstractDCListMapperVM<AiConversationDC, AiConversationVM>
{
private bool _IsSettingsOpen;
private bool _IsCloneOpen;
private bool _IsSending;
private string _MessageInput;
private string _ContextInput;
private AiModelDC _SelectedModel;
private AiConfigVM _Config;
public AiConversationListVM() : this(null)
{
if (BeWoApp.IsInDesignMode)
@@ -48,393 +38,9 @@ namespace BeWo.ViewModel.ListViewModel
public AiConversationListVM(List<AiConversationDC> pDCs) : base(pDCs)
{
Models = new BS.Shared.Core.ObservableSortCollection<AiModelDC>();
bool sendCanExecute() => SelectedVM is object && !string.IsNullOrWhiteSpace(MessageInput) && !IsSending;
SendNewMessageCommand = new DelegateCommand(SendNewMessage, sendCanExecute);
OpenNewConversationCommand = new DelegateCommand(OpenNewConversation, () => BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleChatAdd));
bool startconvCanExecute() => !string.IsNullOrWhiteSpace(MessageInput) && !IsSending;
StartConversationWithMessageCommand = new DelegateCommand(StartConversationWithMessage, startconvCanExecute);
ReloadConfigCommand = new DelegateCommand(ReloadConfig);
ReloadConversationsCommand = new DelegateCommand(ReloadConversations);
ReloadModelsCommand = new DelegateCommand(ReloadModels);
bool openCanExecute() => (BeWoApp.AppSettings?.ModuleAiSettingsEnabled ?? true) && BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleViewSetting);
OpenSettingCommand = new DelegateCommand(OpenSetting, openCanExecute, false);
OpenCloneCommand = new DelegateCommand(OpenClone, () => BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleChatClone) && SelectedVM is object);
CloneCommand = new DelegateCommand(Clone);
AskDeleteCommand = new DelegateCommand(AskDelete, () => BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleChatDelete) && SelectedVM is object);
SelectedVMChanged += (s, e) => FirePropertyChanged(nameof(IsNewConversationVisible));
}
public event EventHandler SendNewMessageSuccess;
public DelegateCommand SendNewMessageCommand { get; set; }
public DelegateCommand OpenNewConversationCommand { get; set; }
public DelegateCommand StartConversationWithMessageCommand { get; set; }
//public DelegateCommand RequestNewConversationCommand { get; set; }
//public DelegateCommand TestCommand { get; set; }
public DelegateCommand AskDeleteCommand { get; set; }
public DelegateCommand ReloadConfigCommand { get; set; }
public DelegateCommand ReloadConversationsCommand { get; set; }
public DelegateCommand ReloadModelsCommand { get; set; }
public DelegateCommand OpenSettingCommand { get; set; }
public DelegateCommand OpenCloneCommand { get; set; }
public DelegateCommand CloneCommand { get; set; }
public ObservableCollection<AiModelDC> Models { get; set; }
public AiModelDC SelectedModel
{
get { return _SelectedModel; }
set
{
if (_SelectedModel == value)
return;
_SelectedModel = value;
FirePropertyChanged(nameof(SelectedModel));
}
}
public AiConfigVM Config
{
get { return _Config; }
set
{
if (Config == value)
return;
_Config = value;
FirePropertyChanged(nameof(Config));
}
}
public string MessageInput
{
get { return _MessageInput; }
set
{
if (MessageInput == value)
return;
_MessageInput = value;
FirePropertyChanged(nameof(MessageInput));
}
}
public string ContextInput
{
get { return _ContextInput; }
set
{
if (ContextInput == value)
return;
_ContextInput = value;
FirePropertyChanged(nameof(ContextInput));
}
}
public bool IsSettingsOpen
{
get => _IsSettingsOpen;
set
{
_IsSettingsOpen = value;
FirePropertyChanged(nameof(IsSettingsOpen));
}
}
public bool IsCloneOpen
{
get => _IsCloneOpen;
set
{
_IsCloneOpen = value;
FirePropertyChanged(nameof(IsCloneOpen));
}
}
public bool IsSending
{
get => _IsSending;
set
{
_IsSending = value;
FirePropertyChanged(nameof(IsSending));
}
}
public bool IsNewConversationVisible => SelectedVM is null;
public int UIContext { get; set; }
public long? ReferenceObjectOid { get; set; }
public Dictionary<TableID, long[]> ContextBeWoObjects { get; set; }
private void StartConversationWithMessage()
{
StartSending();
try
{
var message = MessageInput;
var conv = new AiConversationDC();
conv.Created = DateTime.Now;
conv.Updated = DateTime.Now;
conv.UIContext = UIContext;
conv.ContextBeWoObjects = ContextBeWoObjects;
conv.Messages = new List<AiConversationMessageDC>()
{
new AiConversationMessageDC()
{
Message = message,
Role = AiConversationMessageRole.User
}
};
var vm = InsertConverstion(conv);
ServiceFacade.DoAiEnhancedServiceAsnyc(
x => x.CreateAiConversationWithMessage(conv, Config.SelectedModel.Oid.Value, message),
dc => UpdateConverstion(vm, dc),
e => EndSending());
}
catch(Exception ex)
{
EndSending();
}
}
private void OpenNewConversation()
{
SelectedVM = null;
}
private void SendNewMessage()
{
StartSending();
try
{
var conv = SelectedVM;
var msg_dc = new AiConversationMessageDC();
msg_dc.Message = MessageInput;
msg_dc.Role = AiConversationMessageRole.User;
msg_dc.Created = DateTime.Now;
var msg_vm = new AiConversationMessageVM(msg_dc);
conv.Messages.VMList.Add(msg_vm);
ServiceFacade.DoAiEnhancedServiceAsnyc(
x => x.SendNewMessage(conv.DataContract.Oid.Value, MessageInput),
(messages) =>
{
if (messages.Count != 2)
throw new InvalidOperationException("message count: " + messages.Count);
msg_vm.DataContract = messages[0];
conv.Messages.VMList.Add(new AiConversationMessageVM(messages[1]));
MessageInput = string.Empty;
EndSending();
SendNewMessageSuccess?.Invoke(this, EventArgs.Empty);
},
(exception) =>
{
conv.Messages.VMList.Remove(msg_vm);
EndSending();
}
);
}
catch (Exception ex) {
EndSending();
}
}
private void StartSending()
{
if (IsSending)
throw new InvalidOperationException("Sendet bereits");
IsSending = true;
}
private void EndSending()
{
if (!IsSending)
throw new InvalidOperationException("Sendet nicht");
IsSending = false;
}
private void Test()
{
throw new NotImplementedException();
//var limit = 5;
//var models = ServiceFacade.DoOperationsEnhancedServiceSnyc(x => x.GetAiModels());
//Models.MakeEqualTo(models);
//VMList.Clear();
//foreach (var vm in Models)
//{
// var dc = new AiConversationDC();
// dc.Created = DateTime.Now;
// dc.Displayname = "Example";
// dc.Modell = vm.ToString();
// var pvm = new AiConversationVM(dc);
// VMList.Add(pvm);
//}
//var msg = "Wie alt ist Frau Müller?";
//var context = "Frau Müller wurde am 1.1.1950 geboren. Aktuelle haben wir folgende Universalzeit: " + DateTime.Now.ToUniversalTime();
//for (var i = 0; i < limit; i++)
//{
// foreach (var vm in VMList)
// {
// ServiceFacade.DoOperationsEnhancedServiceAsnyc(x => x.SendNewMessage(vm.CommitToDataContract(), context, msg), (message) =>
// {
// vm.Messages.VMList.Add(new AiConversationMessageVM(message));
// });
// }
//}
}
private AiConversationVM InsertConverstion(AiConversationDC dc)
{
var vm = new AiConversationVM(dc);
VMList.Insert(0, vm);
SelectedVM = vm;
return vm;
}
private void UpdateConverstion(AiConversationVM vm, AiConversationDC dc)
{
vm.UpdateByDataContract(dc);
MessageInput = string.Empty;
EndSending();
SendNewMessageSuccess?.Invoke(this, EventArgs.Empty);
}
private void ReloadConfig()
{
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiConfig(), (x) =>
{
if (Config is null)
Config = new AiConfigVM(x);
else
Config.Update(x);
});
}
public void UpdateConfig()
{
if (!Config.IsDirty)
return;
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiConfig(Config.CommitToDataContract()), (x) =>
{
Config.Update(x);
});
}
private void ReloadModels()
{
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiModels(), (x) =>
{
Models.MakeEqualTo(x);
if (Config.SelectedModel is null && Models.Any())
Config.SelectedModel = Models.First();
});
}
private void ReloadConversations()
{
var ui_context = UIContext;
var reference = ReferenceObjectOid;
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiConversations(ui_context, reference), (x) =>
{
x.Reverse();
var vms = new AiConversationListVM(x);
VMList.MakeEqualTo(vms.VMList);
});
}
private void OpenSetting()
{
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiModels(), (x) =>
{
Models.MakeEqualTo(x);
IsSettingsOpen = true;
});
}
private void OpenClone()
{
foreach (var message in SelectedVM.Messages.VMList)
{
message.IsChecked = true;
}
IsCloneOpen = true;
}
private void Clone()
{
var conv = SelectedVM;
AiConversationMessageVM last = null;
foreach (var msg in conv.Messages.VMList)
{
if (!msg.IsChecked)
break;
last = msg;
}
var conv_oid = conv.DataContract.Oid.Value;
var msg_oid = last?.DataContract.Oid;
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.CloneAiConversation(conv_oid, msg_oid), dc =>
{
InsertConverstion(dc);
CloseClone();
});
}
private void CloseClone()
{
IsCloneOpen = false;
}
public void AskDelete()
{
var selected = SelectedVM;
var oid = selected.DataContract.Oid.Value;
var msg = $"Wollen Sie die ausgewählte Konversation ({oid}) löschen?";
if (MessageBox.Show(msg, "Konversation löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning) ==
MessageBoxResult.Yes)
{
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiConversation(oid), () => {
VMList.Remove(selected);
CommandManager.InvalidateRequerySuggested();
//SelectedVM = VMList.FirstOrDefault();
});
}
}
#region Designer
private void InitDesigner()
{