BeWoPlaner/BeWoPlanerAndroid/AndroidSoapService.asmx.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Web.Services;

using BeWo.Data.Access;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceContracts;
using BeWo.Service.ServiceImplementations;

using BeWoPlanerAndroid.Service;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using Newtonsoft.Json;

namespace BeWoPlanerAndroid
{
    [WebService(Namespace = "bliblablubb.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // Wenn der Aufruf dieses Webdiensts aus einem Skript mithilfe von ASP.NET AJAX zulässig sein soll, heben Sie die Kommentarmarkierung für die folgende Zeile auf. 
    // [System.Web.Script.Services.ScriptService]
    public class AndroidSoapService : WebService
    {
        protected readonly ICustomerService CustomerService = new MobileSessionFacade().CustomerService;
        protected readonly IUserService     UserService     = new MobileSessionFacade().UserService;
        protected readonly IEmployeeService EmployeeService = new MobileSessionFacade().EmployeeService;

        public static string Tenant;

        [WebMethod(EnableSession = true)]
        public string Login(string pTenant, string pUsername, string pPassword)
        {
            MobileSessionFacade.Tenant = pTenant;
            Tenant = pTenant;

            SoapHibernateSessionManager.ConfigureHibernateSession();

            var s = new UserServiceImp();

            if(s.IsUserValid(pUsername, pPassword, null, "SOAPClient", false) == UserValidationResult.UserValid)
            {
                var user = DAOFactory.UserDAO.FindUserByLoginName(pUsername);

                if (user == null || !DAOFactory.SearchDAO.CheckIfEmployeeIsAllowedToChat(user.Employee.Person.Oid.Value))
                {
                    return null;
                }

                if(!DAOFactory.UserDAO.CheckPassword(user, pPassword))
                {
                    return null;
                }

                MobileSessionFacade.LoggedInUser = user;
                
                return user.Employee.Oid.Value + ";" + user.Employee.Person.FirstNameLastName + ";" + user.LoginName + ";" + user.Employee.Person.Oid.Value;
            }

            return null;
        }

        [WebMethod(EnableSession = true)]
        public string TenantNochExistent()
        {
            SoapHibernateSessionManager.ConfigureHibernateSession();

            var customer = CustomerService.GetCompactCustomerDC(46L);

            var result = SerializeObject(customer);

            return result;
        }

        [WebMethod(EnableSession = true)]
        public void UpdateCustomer(string pParam)
        {
            var customerVonAndroidZurueck = JsonConvert.DeserializeObject<CompactCustomerDC>(pParam);

            SoapHibernateSessionManager.ConfigureHibernateSession();
        }

        [WebMethod(EnableSession = true)]
        public string GetAllChatMessagesForSenderAndRecipient(long pSenderPersonOid, long pRecipientPersonOid, string pExceptions, bool pIsForTeam)
        {
            var exceptions = new List<long>();

            if (pExceptions.Length > 0)
            {
                var splittedString = pExceptions.Split(';');
                exceptions = splittedString.Select(item => Convert.ToInt64(item)).ToList();
            }

            var jsonMessages = new List<ChatMessageForJson>();

            var messages = DAOFactory.SearchDAO.FindAllChatMessagesForAndroid(pSenderPersonOid, pRecipientPersonOid, exceptions, pIsForTeam).DoForEach(dfe => jsonMessages.Add(new ChatMessageForJson(dfe.EmpfängerPersonOid, dfe.SenderPersonOid, dfe.IsDelivered, dfe.IstGelesen, dfe.TeamOid, dfe.ChatText, dfe.Uhrzeit, dfe.Oid, dfe.InsTs)));

            //messages.DoForEach(d => Debug.WriteLine("ChatText: " + Encoding.UTF8.GetString(d.ChatText) + "; ByteArray: " + d.ChatText.ToString()));

            foreach(var item in messages)
            {
                var str = "";
                item.ChatText.DoForEach(d => str += d.ToString() + ",");

                var abc = MapperFactory.ChatMessagesDC_ChatMessages.MapToNewDC(item);

                Debug.WriteLine("UTF-8: " + Encoding.UTF8.GetString(item.ChatText)
                            + "\nASCII: " + Encoding.ASCII.GetString(item.ChatText)
                            + "\nUTF-7: " + Encoding.UTF7.GetString(item.ChatText)
                            + "\nBigEndianUnicode: " + Encoding.BigEndianUnicode.GetString(item.ChatText)
                            + "\nUTF-32: " + Encoding.UTF32.GetString(item.ChatText));
            }

            //jsonMessages.DoForEach(m => Debug.WriteLine("Team: " + (m.TeamOid == null ? "Nein" : m.TeamOid.Value.ToString()) + "; Text: " + m.ChatText));

            return JsonConvert.SerializeObject(jsonMessages);
        }

        //[WebMethod(EnableSession = true)]
        //public string GetAllUnreadMessages()
        //{
            
        //}

        [WebMethod(EnableSession = true)]
        public string GetServerAddressByToken(string pToken)
        {
            // Token überprüfen -> wenn falsch oder abgelaufen -> null zurückgeben


            return pToken == null ? null : "das-nur-ein-test;demo";
        }

        [WebMethod(EnableSession = true)]
        public string GetContactsForPerson(long pPersonOid)
        {
            // erst mal nur für Mitarbeiter

            // employee oder customer laden
            var employee = DAOFactory.SearchDAO.FindEmployeeWithPersonOid(pPersonOid);
            var customer = DAOFactory.SearchDAO.FindCustomerWithPersonOid(pPersonOid);

            var isEmployee = customer == null;
            // mit den eigenen Klienten und allen anderen Mitarbeitern

            var customerOids = employee.Employee2CustomerList.Select(s => s.CustomerOid.Value);
            var customers = CustomerService.GetCompactCustomersById(customerOids);

            var employees = EmployeeService.GetAllActiveEmployeesCompact().Where(w => !Equals(w.EmployeeOid, employee.Oid.Value));

            var result = employees.Select(emp => new ChatPerson(emp.PersonOid, emp.FirstName + " " + emp.LastName, false, null, null, emp.Version)).ToList();
            result.AddRange(customers.Select(cus => new ChatPerson(cus.PersonOid, cus.FullName, false, null, null, cus.Version)));

            var teams = DAOFactory.SearchDAO.FindTeamsOfEmployee(employee.Oid.Value).Where(w => w.MemberList.Count > 1);

            foreach(var team in teams)
            {
                var teamMembers = team.MemberList;

                var memberString = "";
                var memberNames = "";
                foreach(var member in teamMembers)
                {
                    memberString += member.Person.Oid.Value;

                    memberNames += member.Person.FirstNameLastName;

                    if(teamMembers.IndexOf(member) < teamMembers.Count - 1)
                    {
                        memberString += ";";
                        memberNames += ", ";
                    }
                }

                result.Add(new ChatPerson(team.Oid.Value, team.Name, true, memberString, memberNames, team.Version.Value));
            }

            return SerializeObject(result);
        }

        private static string SerializeObject(object obj)
        {
            return JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new ShouldSerializeContractResolver(), ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
        }

        public class ChatPerson
        {
            public long Oid { get; set; }

            public string Name { get; set; }

            public bool IsTeam { get; set; }

            public string TeamMemberOids { get; set; }

            public string TeamMemberNames { get; set; }

            public long Version { get; set; }

            public ChatPerson(long pOid, string pName, bool pIsTeam, string pTeamMemberOids, string pTeamMemberNames, long pVersion)
            {
                Oid             = pOid;
                Name            = pName;
                IsTeam          = pIsTeam;
                TeamMemberOids  = pTeamMemberOids;
                TeamMemberNames = pTeamMemberNames;
                Version         = pVersion;
            }
        }

        public class ChatMessageForJson
        {
            public string    ChatText           { get; set; }
            public DateTime  Uhrzeit            { get; set; }
            public long?     EmpfängerPersonOid { get; set; }
            public long?     SenderPersonOid    { get; set; }
            public bool      IsDelivered        { get; set; }
            public int       IstGelesen         { get; set; }
            public long?     TeamOid            { get; set; }
            public long?     Oid                { get; set; }
            public DateTime? InsTs              { get; set; }

            public ChatMessageForJson(long? pRecipientOid, long? pSenderOid, bool pIsDelivered, int pIstGelesen, long? pTeamOid, byte[] pChatTextAsBytes, DateTime pUhrzeit, long? pOid, DateTime? pInsTs)
            {
                EmpfängerPersonOid = pRecipientOid;
                SenderPersonOid    = pSenderOid;
                IsDelivered        = pIsDelivered;
                IstGelesen         = pIstGelesen;
                TeamOid            = pTeamOid;
                Uhrzeit            = pUhrzeit;
                ChatText           = Encoding.UTF8.GetString(pChatTextAsBytes);
                Oid                = pOid;
                InsTs              = pInsTs;
            }
        }
    }
}