private static IncomingServer GetServerTypeByMaxPort(List <IncomingServer> servers, ServerType type)
        {
            IncomingServer returnVal = null;

            List <IncomingServer> serversByType = servers.FindAll(srv => srv.Type == type);

            if (serversByType.Count > 0)
            {
                int maxPort = serversByType.Max(srv => srv.Port);
                returnVal = serversByType.Find(srv => srv.Port == maxPort);
            }

            return(returnVal);
        }
        private static PollingConfigValues ChooseIncomingServer(EmailProvider provider, string emailAddress, ServerType incomingServerPreference)
        {
            PollingConfigValues returnVal;

            IncomingServer chosenImap = GetServerTypeByMaxPort(provider.IncomingServers, ServerType.IMAP);
            IncomingServer chosenPop  = GetServerTypeByMaxPort(provider.IncomingServers, ServerType.POP3);

            switch (incomingServerPreference)
            {
            case ServerType.IMAP:
                returnVal = MapIncomingServer(chosenImap != null ? chosenImap : chosenPop, emailAddress);
                break;

            case ServerType.POP3:
                returnVal = MapIncomingServer(chosenPop != null ? chosenPop : chosenImap, emailAddress);
                break;

            default:
                if (chosenImap != null && chosenPop != null)
                {
                    if (chosenImap.Port < 900 && chosenPop.Port > 900)
                    {
                        returnVal = MapIncomingServer(chosenPop, emailAddress);
                    }
                    else
                    {
                        returnVal = MapIncomingServer(chosenImap, emailAddress);
                    }
                }
                else if (chosenImap != null && chosenPop == null)
                {
                    returnVal = MapIncomingServer(chosenImap, emailAddress);
                }
                else if (chosenImap == null && chosenPop != null)
                {
                    returnVal = MapIncomingServer(chosenPop, emailAddress);
                }
                else
                {
                    returnVal = null;
                }
                break;
            }

            return(returnVal);
        }
        private static PollingConfigValues MapIncomingServer(IncomingServer input, string emailAddress)
        {
            PollingConfigValues returnVal = new PollingConfigValues();

            returnVal.Username = input.GetUsernameFormatted(emailAddress);

            returnVal.UsePolling   = true;
            returnVal.PollInterval = 10;

            switch (input.Type)
            {
            case ServerType.IMAP:
                returnVal.EmailType = EmailType.IMAP;
                break;

            case ServerType.POP3:
                returnVal.EmailType = EmailType.POP3;
                if (input.Pop3 != null && input.Pop3.CheckInterval != null)
                {
                    returnVal.PollInterval = input.Pop3.CheckInterval.Minutes;
                }
                break;
            }

            returnVal.Server = input.Hostname;
            returnVal.Port   = input.Port;

            switch (input.SocketType)
            {
            case SocketType.Plain:
                returnVal.SSLType = SSLType.None;
                break;

            case SocketType.SSL:
                returnVal.SSLType = SSLType.SSL;
                break;

            case SocketType.STARTTLS:
                returnVal.SSLType = SSLType.TLS;
                break;
            }

            return(returnVal);
        }
 public TimeOutServerTest(IncomingServer incomingServer)
 {
     _incomingServer = incomingServer;
     _timeoutObject  = new ManualResetEvent(false);
     _incoming       = true;
 }