BeWoPlaner/Service/Plugins/AiPromptbausteineService.cs

using AICore.Facade;
using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Utils;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceProxy;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions;
using DevExpress.CodeParser.Diagnostics;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Text.Json;
using System.Xml;

namespace BeWo.Service.Plugins
{
	public class AiPromptbausteineService
	{
		public string Tenant => MultitenancyOperationContextExt.Current?.Tenant;

		public IEnumerable<AiPromptbausteinFolderDC> GetAiPromptbausteinFolder(AiActionType aiActionType)
		{
			var own_bib = getOwnFolder(aiActionType);
			var public_bib = getPublicFolders(aiActionType);
			var ownsoft_bib = getOwnsoftFolder(aiActionType);

			var result = new List<AiPromptbausteinFolderDC>() {
				own_bib, public_bib
			};

			if(ownsoft_bib is object)
				result.Add(ownsoft_bib);

			return result;
		}
		
		public IEnumerable<AiPromptbausteinFolderDC> InsertAiPromptbausteinFolder(IEnumerable<AiPromptbausteinFolderDC> folders)
		{
			var entities = MapperFactory.AiPromptbausteinFolder.MapToNewEntities(folders);

			DAOFactory.GenericDAO.Insert(entities);

			return null;
		}

		public IEnumerable<AiPromptbausteinPromptDC> InsertAiPromptbausteinPrompt(IEnumerable<AiPromptbausteinPromptDC> prompts)
		{
			var entities = MapperFactory.AiPromptbausteinPrompt.MapToNewEntities(prompts);

			DAOFactory.GenericDAO.Insert(entities);

			return null;
		}

		public IEnumerable<AiPromptbausteinFolderDC> UpdateAiPromptbausteinFolder(IEnumerable<AiPromptbausteinFolderDC> folders)
		{
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbausteinFolder>(folders.Select(sc => sc.Oid.Value));
			var folders2 = folders.ToList();
			MapperFactory.AiPromptbausteinFolder.MergeWithEntitys(folders2, originale);

			DAOFactory.GenericDAO.Update(originale);

			return null;
		}

		public IEnumerable<AiPromptbausteinPromptDC> UpdateAiPromptbausteinPrompt(IEnumerable<AiPromptbausteinPromptDC> prompts)
		{
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbausteinPrompt>(prompts.Select(sc => sc.Oid.Value));
			var prompts2 = prompts.ToList();
			MapperFactory.AiPromptbausteinPrompt.MergeWithEntitys(prompts2, originale);

			DAOFactory.GenericDAO.Update(originale);

			return null;
		}

		public void DeleteAiPromptbausteinFolder(Dictionary<long, long> oid2version)
		{
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbausteinFolder>(oid2version.Select(e => e.Key));
			originale.DoForEach(or => MapperFactory.AiPromptbausteinFolder.ConcurrencyCheck(oid2version[or.Oid.Value], or));


			DAOFactory.GenericDAO.SetActivationType(originale, BS.Shared.ActivationTypeId.Deleted);
		}
		private void delete_folder_rec(AiPromptbausteinFolder folder)
		{
			foreach (var sub_folder in folder.SubFolders)
			{
				delete_folder_rec(sub_folder);
			}

			DAOFactory.GenericDAO.SetActivationType(folder, BS.Shared.ActivationTypeId.Deleted);
		}

		public void DeleteAiPromptbausteinPrompt(Dictionary<long, long> oid2version)
		{
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbausteinPrompt>(oid2version.Select(e => e.Key));
			originale.DoForEach(or => MapperFactory.AiPromptbausteinPrompt.ConcurrencyCheck(oid2version[or.Oid.Value], or));

			DAOFactory.GenericDAO.SetActivationType(originale, BS.Shared.ActivationTypeId.Deleted);
		}
		
		private AiPromptbausteinFolderDC getOwnFolder(AiActionType aiActionType)
		{
			var own_bib = PredefinedAiPromptbausteinFolders.CreateOwnBibNode(aiActionType);

			var own = DAOFactory.SearchDAO.GetOwnActiveRootAiPromptbausteineFolders(aiActionType);
			var own_dcs = MapperFactory.AiPromptbausteinFolder.MapToNewDCs(own);

			foreach (var dc in own_dcs)
			{
				initOwnFolder(dc);
				dc.ParentFolderOid = own_bib.Oid;
			}

			own_bib.SubFolders.AddRange(own_dcs);

			var own_prompts = DAOFactory.SearchDAO.GetOwnActiveRootAiPromptbausteinePrompts(aiActionType);
			var own_prompts_dcs = MapperFactory.AiPromptbausteinPrompt.MapToNewDCs(own_prompts);

			foreach (var dc in own_prompts_dcs)
			{
				dc.CanEdit = true;
				dc.ParentFolderOid = own_bib.Oid;
			}

			own_bib.SubPrompts.AddRange(own_prompts_dcs);

			return own_bib;
		}
		private void initOwnFolder(AiPromptbausteinFolderDC folder)
		{
			folder.CanAddFolder = true;
			folder.CanAddPrompt = true;
			folder.CanEdit = true;

			foreach (var prompt in folder.SubPrompts)
			{
				prompt.CanEdit = true;
			}

			foreach (var next_folder in folder.SubFolders)
			{
				initOwnFolder(next_folder);
			}
		}

		private AiPromptbausteinFolderDC getPublicFolders(AiActionType aiActionType)
		{
			var temp = new Dictionary<long, AiPromptbausteinFolderDC>();

			var public_bib = PredefinedAiPromptbausteinFolders.CreatePublicBibNode(aiActionType);

			var pub = DAOFactory.SearchDAO.GetPublicActiveRootAiPromptbausteineFolders(aiActionType);
			var pub_dcs = MapperFactory.AiPromptbausteinFolder.MapToNewDCs(pub);

			foreach (var dc in pub_dcs)
			{
				var creator = dc.Creator;
				var creator_oid = creator.EmployeeOid;

				AiPromptbausteinFolderDC folder;
				if (temp.ContainsKey(creator_oid))
				{
					folder = temp[creator_oid];
				}
				else
				{
					folder = PredefinedAiPromptbausteinFolders.CreatePublicSharedBibNode(aiActionType, creator.GetLastNameFirstName());
					public_bib.SubFolders.Add(folder);
					folder.ParentFolderOid = public_bib.Oid;
					temp.Add(creator_oid, folder);
				}

				folder.SubFolders.Add(dc);
				dc.ParentFolderOid = folder.Oid;
			}

			//public_bib.SubFolders.AddRange(pub_dcs);

			return public_bib;
		}
		private AiPromptbausteinFolderDC getOwnsoftFolder(AiActionType aiActionType)
		{
			var prompts = syncOwnSoftPrompts(aiActionType);
			var prompts_dc = MapperFactory.AiPromptbausteinPrompt.MapToNewDCs(prompts);

			var folder = PredefinedAiPromptbausteinFolders.CreateOwnsoftBibNode(aiActionType);

			folder.SubPrompts.AddRange(prompts_dc);

			return folder;
		}
		private IEnumerable<AiPromptbausteinPrompt> syncOwnSoftPrompts(AiActionType aiActionType)
		{
			var comparer = new AiPromptbausteinPromptPromptIdComparer();
			var comparer2 = new AiPromptbausteinPromptComparer2();

			var current_prompts = DAOFactory.SearchDAO.GetOwnSoftPromptbausteinPrompts(aiActionType);
			var current_prompts_actives = current_prompts.Where(x => x.IsActive == ActivationTypeId.Active);
			var current_prompts_deactives = current_prompts.Where(x => x.IsActive != ActivationTypeId.Active);
			var actives_prompts = getOwnSoftPrompts(aiActionType);
			var request_models = MapperFactory.AiPromptbausteinPrompt.MapToNewEntities(actives_prompts);
			var toadd = request_models.Except(current_prompts, comparer);
			var toremove = current_prompts_actives.Except(request_models, comparer);
			var toreadd = current_prompts_deactives.Intersect(request_models, comparer);
			//var tocheckupdate = request_models.Union(current_prompts, comparer);
			//var toupdate = tocheckupdate.;

			foreach (var a in current_prompts)
			{
				foreach (var b in request_models)
				{
					if (!comparer.Equals(a, b))
						continue;

					if(!comparer2.Equals(a, b))
					{
						var dc = MapperFactory.AiPromptbausteinPrompt.MapToNewDC(b);
						MapperFactory.AiPromptbausteinPrompt.MergeWithEntity(dc, a);
						DAOFactory.GenericDAO.Update(a);
					}

					break;
				}
			}

			DAOFactory.GenericDAO.Insert(toadd);
			DAOFactory.GenericDAO.Deactivate(toremove);
			DAOFactory.GenericDAO.SetActivationType(toreadd, ActivationTypeId.Active);

			var prompts = DAOFactory.SearchDAO.GetActiveOwnSoftPromptbausteinPrompts(aiActionType);

			return prompts;
		}
		private List<AiPromptbausteinPromptDC> getOwnSoftPrompts(AiActionType aiActionType)
		{
			try
			{
				var url = MergedConfig.GetSetting(WebConfigSetting.AiPromptsUrl);
				var client = new AiPromptsApiClient(url);
				var response = client.GetAiPrompts(aiActionType);
				return response?.ToList() ?? new List<AiPromptbausteinPromptDC>();
			}
			catch(Exception ex)
			{
				throw ex;
				//var error = ex.ToString();
				//Core.Utils.SendErrorMail("subject - test", "body - test");
				//MailUtils.SendAiModuleErrorMail("GetOwnSoftPrompts", error, Tenant);
			}

			return new List<AiPromptbausteinPromptDC>();
		}
	}
}