BeWoPlaner/Service/Plugins/AiPromptbausteineService.cs

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;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace BeWo.Service.Plugins
{
	public class AiPromptbausteineService
	{
		public IEnumerable<AiPromptbausteinTreeDC> GetAiPromptbausteineSubTree(AiActionType aiActionType)
		{
			if (aiActionType == AiActionType.ServiceRecord)
				throw new ArgumentException("AiActionType nicht implementiert", nameof(aiActionType));

			var sub_roots = DAOFactory.SearchDAO.GetActiveRootAiPromptbausteine(aiActionType);
			var sub_roots_dcs = MapperFactory.AiPromptbausteinTreeTree.MapToNewDCs(sub_roots);
			var root = AiPromptbausteinTreeBuilder.GenerateSubtree(aiActionType, sub_roots_dcs);

			return new List<AiPromptbausteinTreeDC> { root };
		}

		public IEnumerable<AiPromptbausteinDC> GetAiPromptbausteine()
		{
			var allAiPromptbausteine = DAOFactory.GenericDAO.GetAll<AiPromptbaustein>();
			var dcs = MapperFactory.AiPromptbausteinDC_AiPromptbaustein.CreateDcList(allAiPromptbausteine);
			return dcs;
		}

		public IEnumerable<AiPromptbausteinTreeDC> GetAiPromptbausteineTree()
		{
			var sub_roots = DAOFactory.SearchDAO.GetActiveRootAiPromptbausteine();
			var sub_roots_dcs = MapperFactory.AiPromptbausteinTreeTree.MapToNewDCs(sub_roots);
			var roots = AiPromptbausteinTreeBuilder.GenerateTree(sub_roots_dcs);

			return roots;
		}

		public IEnumerable<AiPromptbausteinTreeDC> CreateAiPromptbausteineTree(IEnumerable<AiPromptbausteinTreeDC> aiPromptbausteinDCs)
		{
			var aiPromptbausteine = MapperFactory.AiPromptbausteinTreeTree.MapToNewEntities(aiPromptbausteinDCs);

			DAOFactory.GenericDAO.Insert(aiPromptbausteine);

			// Solange wie Return Objekt nicht vom Client verarbeitet wird
			return null;

			var dcs = MapperFactory.AiPromptbausteinTreeTree.MapToNewDCs(aiPromptbausteine);

			return dcs;
		}

		public IEnumerable<AiPromptbausteinDC> CreateAiPromptbausteine(IEnumerable<AiPromptbausteinDC> aiPromptbausteinDCs)
		{
			var aiPromptbausteine = MapperFactory.AiPromptbausteinDC_AiPromptbaustein.MapToNewEntities(aiPromptbausteinDCs);

			DAOFactory.GenericDAO.Insert(aiPromptbausteine);

			var dcs = MapperFactory.AiPromptbausteinDC_AiPromptbaustein.MapToNewDCs(aiPromptbausteine);

			return dcs;
		}

		public Dictionary<long, long> UpdateAiPromptbausteineTree(IEnumerable<AiPromptbausteinTreeDC> aiPromptbausteinDCs)
		{
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbausteinTree>(aiPromptbausteinDCs.Select(sc => sc.Oid.Value));
			var aiPromptbausteinDCs2 = aiPromptbausteinDCs.ToList();
			MapperFactory.AiPromptbausteinTreeTree.MergeWithEntitys(aiPromptbausteinDCs2, originale);

			DAOFactory.GenericDAO.Update(originale);

			// Solange wie Return Objekt nicht vom Client verarbeitet wird
			return null;

			return originale.ToOidVersionDictionary();
		}

		public Dictionary<long, long> UpdateAiPromptbausteine(IEnumerable<AiPromptbausteinDC> aiPromptbausteinDCs)
		{
			var aiPromptbausteine = MapperFactory.AiPromptbausteinDC_AiPromptbaustein.MapToNewEntities(aiPromptbausteinDCs);

			/*
			var originale = DAOFactory.GenericDAO.LoadByIDs<AiPromptbaustein>(aiPromptbausteinDCs.Select(sc => sc.Oid.Value));
			foreach (var item in aiPromptbausteinDCs)
			{
				item.ActivationType = ActivationTypeId.Active;
			}
			MapperFactory.AiPromptbausteinTree.MergeWithEntitys(aiPromptbausteinDCs, originale);
			*/

			DAOFactory.GenericDAO.Update(aiPromptbausteine);

			// todo: dictionary erstellen
			throw new System.NotImplementedException();
		}

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

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

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

				IList<AiPromptbaustein> toBeDeleted = new List<AiPromptbaustein>();

				foreach (var aiPromptbaustein in originale)
				{
					AddAiPromptbausteinAndChildsToList(aiPromptbaustein, toBeDeleted);
				}

				DAOFactory.GenericDAO.Delete(toBeDeleted);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		private void AddAiPromptbausteinAndChildsToList(AiPromptbaustein aiPromptbaustein, IList<AiPromptbaustein> aiPromptbausteinListe)
		{
			var children = DAOFactory.SearchDAO.GetChildAiPromptbausteine(aiPromptbaustein);

			foreach (var child in children)
			{
				AddAiPromptbausteinAndChildsToList(child, aiPromptbausteinListe);
			}

			aiPromptbausteinListe.Add(aiPromptbaustein);
		}



		public IEnumerable<AiPromptbausteinFolderDC> GetAiPromptbausteinFolder(AiActionType aiActionType)
		{
			var own_bib = PredefinedAiPromptbausteinFolders.CreateOwnBibNode(aiActionType);
			var shared_bib = PredefinedAiPromptbausteinFolders.CreateSharedBibNode(aiActionType);
			var public_bib = PredefinedAiPromptbausteinFolders.CreatePublicBibNode(aiActionType);

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

			foreach (var dc in own_dcs)
			{
				initOwnFolder(dc);
			}

			own_bib.SubFolders.AddRange(own_dcs);

			return new List<AiPromptbausteinFolderDC>() {
				own_bib, shared_bib, public_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);
			}
		}

		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);
		}
	}
}