BeWoPlaner/Service/ServiceImplementations/QueryServiceImp.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.ServiceModel;

using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Security;
using BeWo.Service.Plugins;
using BeWo.Service.ServiceContracts;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;
using Newtonsoft.Json;
using Utils = BeWo.Service.Core.Utils;

namespace BeWo.Service.ServiceImplementations
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
    public class QueryServiceImp : IQueryService
    {
        public string ExecuteQuery(long pQueryOid, List<QueryParamDC> parameter)
        {
            try
            {
                DataTable table = null;
                Query lQuery = DAOFactory.GenericDAO.LoadByID<Query>(pQueryOid);

                string sql = lQuery.Sql;
                if (!String.IsNullOrEmpty(sql))
                {
                    if (parameter != null && parameter.Count > 0)
                    {
                        sql = this.ReplaceQueryParameter(sql, parameter);
                    }

                    sql = CheckAndModifySqlByUserRights(lQuery, sql);

                    table = DAOFactory.AdoDAO.ExecuteQuery(sql).Tables[0];
                }
                if (table == null)
                {
                    table = new DataTable("emptytable");
                }
                var temp = BS.Shared.Core.Utils.XMLSerializeToString(table);
                return temp;
            }
            catch (Exception e)
            {
                // ToDo: 14.03.2023 Fehler in MySql-Syntax von Berichten in Tabelle query!
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private string CheckAndModifySqlByUserRights(Query lQuery, string sql)
        {
            var user = UserRightHelper.GetLoggedInUser();

            if (sql.Contains(":AllTeamOids"))
            {
                var liste = GetAllEmployeeTeams(user.Employee);

                sql = sql.Replace(":AllTeamOids", string.Join(",", liste.Select(t => t.Oid.Value)));
            }
            if (sql.Contains(":AllCustomerOids"))
            {
                var liste = GetEmployeeCustomerOids(user.Employee);

                sql = sql.Replace(":AllCustomerOids", string.Join(",", liste));
            }
            if (sql.Contains(":AllTeamCustomerOids"))
            {
                var liste = GetTeamRelatedCustomerOids(user.Employee);

                sql = sql.Replace(":AllTeamCustomerOids", string.Join(",", liste));
            }
            return sql;
        }

        public List<long> GetTeamRelatedCustomerOids(Employee emp)
        {
            var result = new List<long>();

            var teams = GetAllEmployeeTeams(emp);

            teams.DoForEach(team =>
            {
                var customers = DAOFactory.SearchDAO.FindCustomerOfTeam(team.Oid.Value);
                result.AddRangeIfElementsNotIn(customers.Select(c => c.Oid.Value));
                //team.MemberList.Where(member => member.Oid.HasValue && member.Oid != emp.Oid.Value).DoForEach(member =>
                //{
                //    // Nur, wo der Klient auch vom Team betreut wird
                //    result.AddRangeIfElementsNotIn(
                //        member.Employee2CustomerList.Where(
                //            employee2Customer => employee2Customer.CustomerOid.HasValue &&
                //                                    employee2Customer.Customer.Team2CustomerList.Any(team2Customer => team2Customer.TeamOid.HasValue)
                //        ).Select(employee2Customer => employee2Customer.CustomerOid.Value)
                //    );
                //});
            });

            return result;
        }

        public List<long> GetEmployeeCustomerOids(Employee emp)
        {
            var result = new List<long>();

                result.AddRangeIfElementsNotIn(
                    emp.Employee2CustomerList.Where(
                        employee2Customer => employee2Customer.CustomerOid.HasValue &&
                                                employee2Customer.Customer.Team2CustomerList.Any(team2Customer => team2Customer.TeamOid.HasValue)
                    ).Select(employee2Customer => employee2Customer.CustomerOid.Value)
                );

            return result;
        }

        private List<Team> GetAllEmployeeTeams(Employee emp)
        {
            var teams = new List<Team>();

            teams.AddRange(DAOFactory.SearchDAO.FindLeadingTeams(emp.Oid.Value));
            teams.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.FindTeamsOfEmployee(emp.Oid.Value));

            return teams;
        }

        public List<QueryDC> GetAllQueriesOfType(QueryType pType)
        {
            try
            {
                var qs = PluginLoader.FindClass<QueryService>();

                return qs.GetAllQueriesOfType(pType);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string PrepareQueryReport(string dataTableJsonString, string id)
        {
            try
            {
                var lResult = id + ".xml";
                
                var tenant = MultitenancyOperationContextExt.Current?.Tenant ?? SessionFacade.Tenant;

                // FaC: C:\Users\Lyndon Jetten\Entwicklung\BeWo\Host\demo\temp\
                // MoK: C:\Users\Lyndon Jetten\Entwicklung\BeWo\BeWoPlanerMobil\demo\temp

                var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
                if(baseDirectory.Contains("BeWoPlanerMobil"))
                {
                    baseDirectory = baseDirectory.Replace("BeWoPlanerMobil", "Host");
                }

                var lDir = BS.Shared.Core.Utils.CreateSavePath(baseDirectory, tenant + @"\temp");
                var lPath = BS.Shared.Core.Utils.CreateSavePath(lDir, lResult);

                var table = BS.Shared.Core.Utils.XMLDeserializeFromString<DataTable>(dataTableJsonString);
                BS.Shared.Core.Utils.XMLSerialize(lPath, table);

                return lResult;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // Hack: We don't use the ReportTypes in Webservice Calls,
        // but the Client needs to know them for Calling ASP Sites
        public void ReportTypes(ReportTypes pType)
        {
        }

        private string GetParamterKeyName(QueryParamDC item)
        {
            return GetParamterKeyName(item.Name);
        }

        private string GetParamterKeyName(string itemName)
        {
            string key = itemName;
            key = key.Replace(" ", "_");

            return key;
        }

        private string ReplaceQueryParameter(string sql, List<QueryParamDC> parameter)
        {
            string newsql = sql;
            foreach (var item in parameter)
            {
                //if (item.Value != null)
                //{
                switch (item.ParamType)
                {
                    case QueryParameterType.SupportConcept:
                    case QueryParameterType.Employee:
                    case QueryParameterType.Customer:
                    case QueryParameterType.Team:
                    case QueryParameterType.Organisation:
                        long oid2 = 0;

                        if (item.Value != null)
                        {
                            Int64.TryParse(item.Value.ToString(), out oid2);
                        }
                        newsql = newsql.Replace(":" + GetParamterKeyName(item), String.Format("{0}", oid2));
                        break;
                    case QueryParameterType.Month:

                        if (item.Value is DateTime)
                        {
                            DateTime dt = (DateTime)item.Value;

                            newsql = newsql.Replace(":" + GetParamterKeyName(item) + "_MM", String.Format("{0:MM}", dt));
                            newsql = newsql.Replace(":" + GetParamterKeyName(item) + "_Start", String.Format("{0:yyyy-MM}-01", dt));
                            dt = dt.AddMonths(1);
                            newsql = newsql.Replace(":" + GetParamterKeyName(item) + "_End", String.Format("{0:yyyy-MM}-01", dt));
                        }

                        break;
                    case QueryParameterType.Date:
                        if (item.Value != null && item.Value is DateTime)
                        {
                            DateTime dt = (DateTime)item.Value;

                            newsql = newsql.Replace(":" + GetParamterKeyName(item), String.Format("{0:yyyy-MM-dd}", dt));

                        }
                        else
                        {
                            newsql = newsql.Replace(":" + GetParamterKeyName(item), String.Format("{0:yyyy-MM-dd}", DateTime.MinValue));
                        }
                        break;
                    case QueryParameterType.DateRange:
                        if (item.Value is DateTimeSpan)
                        {
                            DateTimeSpan dts = (DateTimeSpan)item.Value;
                            if (!String.IsNullOrEmpty(item.DefaultValue) && item.DefaultValue.ToLower().Contains("aktueller monat"))
                            {
                                DateTime aktuellerMonat = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);

                                if (dts.StartDate == DateTime.MinValue)
                                {
                                    dts.StartDate = aktuellerMonat;
                                }
                                if (dts.EndDate.Date == DateTime.MaxValue.Date)
                                {
                                    dts.EndDate = aktuellerMonat.AddMonths(1).AddDays(-1);
                                }
                            }
                            string[] itemNames = item.Name.Split(new[] { '_' });

                            newsql = newsql.Replace(":" + GetParamterKeyName(itemNames[0]), String.Format("{0:yyyy-MM-dd}", dts.StartDate));
                            if (itemNames.Length > 1)
                            {
                                DateTime endDate = dts.EndDate;
                                if (endDate < DateTime.MaxValue.Date)
                                    endDate = endDate.AddDays(1);
                                newsql = newsql.Replace(":" + GetParamterKeyName(itemNames[1]), String.Format("{0:yyyy-MM-dd}", endDate));
                            }
                        }

                        break;
                    case QueryParameterType.Year:
                        if (item.Value is DateTime)
                        {
                            DateTime dt = (DateTime)item.Value;

                            newsql = newsql.Replace(":year", String.Format("{0:yyyy-MM-dd}", dt));

                            newsql = newsql.Replace(":" + GetParamterKeyName(item) + "_Start", String.Format("{0:yyyy-MM}-01", dt));
                            newsql = newsql.Replace(":" + GetParamterKeyName(item) + "_End", String.Format("{0:yyyy-MM}-01", dt.AddYears(1)));

                            newsql = newsql.Replace(":yyyy", String.Format("{0:yyyy}", dt));
                        }
                        break;
                    case QueryParameterType.CurrentUser:
                    case QueryParameterType.CurrentEmployee:
                        if (item.Value != null)
                        {
                            long oid;
                            if (Int64.TryParse(item.Value.ToString(), out oid))
                            {
                                newsql = newsql.Replace(":" + GetParamterKeyName(item), String.Format("{0}", oid));
                            }
                        }

                        break;
                    case QueryParameterType.ValueListEntryType:
                        if (item.Value != null)
                        {
                            long oid;
                            if (Int64.TryParse(item.Value.ToString(), out oid))
                            {
                                String[] names = item.Name.Split('_');
                                newsql = newsql.Replace(":" + names[0], String.Format("{0}", oid));
                            }
                        }

                        break;
                    default:
                        if (item.Value != null)
                        {
                            newsql = newsql.Replace(":" + GetParamterKeyName(item.Name), item.Value.ToString());
                        }
                        break;
                }
                //}
            }

            return newsql;
        }
    }
}