BeWoPlaner/Service/Plugins/AiPromptbausteineService.cs

using AICore.Facade;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Utils;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BS.Shared;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions;
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 IEnumerable<AiPromptbausteinFolderDC> GetAiPromptbausteinFolder(AiActionType aiActionType)
		{
			var own_bib = PredefinedAiPromptbausteinFolders.CreateOwnBibNode(aiActionType);
			//var shared_bib = PredefinedAiPromptbausteinFolders.CreateSharedBibNode(aiActionType);
			var public_bib = GetPublicFolders(aiActionType);
			var ownsoft_bib = GetOwnsoftFolder(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 result = new List<AiPromptbausteinFolderDC>() {
				own_bib, public_bib
			};

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

			return result;
		}
		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;
		}

		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 GetOwnsoftFolder(AiActionType aiActionType)
		{
			var client = new AiPromptsApiClient();

			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 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();
			var request_models = MapperFactory.AiPromptbausteinPrompt.MapToNewEntities(actives_prompts);
			var comparer = new AiPromptbausteinPromptPromptIdComparer();
			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);

			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()
		{
			var client = new AiPromptsApiClient();
			var response = client.GetAiPrompts();
			return response.Data.ToList();
		}
	}
}