/// <summary>
        /// Here we have a form where users can sign up to have a compost truck come and collect
        /// organic food waste from their homes.  The application needs to do some complex logic
        /// behind the scenes when a user signs up, like send emails and queue up messages to an AWS SQS queue,
        /// where route planning services subscribe to consume data. We use the Command Pattern to encapsulate
        /// requests for these emails and queuing operations, allowing us to set different commands
        /// to be executed at the start and end of any particular business process, and to decouple the objects
        /// that encapsulate the data needed to perform an operation from the executors. Here we set commands
        /// to be executed during the process of signing up our new user for the service.
        /// </summary>
        private static void Main()
        {
            var logger     = new ConsoleLogger();
            var cloudQueue = new CloudQueue(logger);
            var emailer    = new Emailer(logger);

            Console.OutputEncoding = System.Text.Encoding.UTF8;
            logger.LogInfo("🌱 Welcome to the Neighborhood Composter Sign Up Application");
            logger.LogInfo("------------------------------------------------------------");

            logger.LogInfo("What's your name?");
            var name = Console.ReadLine();

            logger.LogInfo("What's your email address?");
            var emailAddress = Console.ReadLine();

            logger.LogInfo("What's your home address?");
            var address = Console.ReadLine();

            logger.LogInfo($"Thanks, {name}! A compost vehicle will stop to pick up your compost every Saturday", ConsoleColor.Green);

            var newUserHandler = new NewUserHandler(logger);

            // Our SetOnStart and SetOnFinish methods prepare hooks in the business
            // process of signing a user up for service.
            newUserHandler.SetOnStart(new NewCustomerEmailCommand(logger, emailer, name, emailAddress));
            newUserHandler.SetOnFinish(new AddressQueueCommand(logger, cloudQueue, address));

            newUserHandler.SignUpUser();
        }
Example #2
0
        public static void Switch(GPSPClient client, Dictionary <string, string> recv)
        {
            string command = recv.Keys.First();

            try
            {
                switch (command)
                {
                case "search":
                    SearchHandler.SearchUsers(client, recv);
                    break;

                case "valid":
                    ValidHandler.IsEmailValid(client, recv);
                    break;

                case "nicks":
                    NickHandler.SearchNicks(client, recv);
                    break;

                case "pmatch":
                    PmatchHandler.PlayerMatch(client, recv);
                    break;

                case "check":
                    CheckHandler.CheckProfileid(client, recv);
                    break;

                case "newuser":
                    NewUserHandler.NewUser(client, recv);
                    break;

                case "searchunique":
                    SearchUniqueHandler.SearchProfileWithUniquenick(client, recv);
                    break;

                case "others":
                    OthersHandler.SearchOtherBuddy(client, recv);
                    break;

                case "otherslist":
                    OthersListHandler.SearchOtherBuddyList(client, recv);
                    break;

                case "uniquesearch":
                    UniqueSearchHandler.SuggestUniqueNickname(client, recv);
                    break;

                default:
                    LogWriter.Log.Write("[GPSP] received unknown data " + command, LogLevel.Debug);
                    GameSpyUtils.PrintReceivedGPDictToLogger(command, recv);
                    GameSpyUtils.SendGPError(client, GPErrorCode.Parse, "An invalid request was sended.");
                    break;
                }
            }
            catch (Exception e)
            {
                LogWriter.Log.WriteException(e);
            }
        }
Example #3
0
 /// <summary>
 /// Creates a new TCP Server
 /// </summary>
 /// <param name="IP">IP to listen on (use 0.0.0.0 for all sockets)</param>
 /// <param name="Port">Port to listen on</param>
 public TcpServer(string IP, int Port)
 {
     Srv            = new TcpListener(new IPEndPoint(IPAddress.Parse(IP), Port));
     NewConnection += new NewConnectionHandler(NET_NewConnection);
     NewUser       += new NewUserHandler(NET_NewUser);
     CurrentAsync   = null;
 }
Example #4
0
        // Token: 0x0600003B RID: 59 RVA: 0x00003653 File Offset: 0x00003653
        public void OnNewUser(User user)
        {
            NewUserHandler userRegHandler = this.UserRegHandler;

            if (userRegHandler != null)
            {
                userRegHandler(user);
            }
        }
Example #5
0
        void NotifyActiveUser(ActiveUser user)
        {
            if (NewUserHandler != null)
            {
                Delegate[] invkList = NewUserHandler.GetInvocationList();

                foreach (NewActiveUser handler in invkList)
                {
                    try {
                        IAsyncResult ar = handler.BeginInvoke(user, null, null);
                        Console.WriteLine("[Server]: User {0} Logged in", user.Username);
                    }
                    catch (Exception e) {
                        NewUserHandler -= handler;
                    }
                }
            }
        }
Example #6
0
        public static void Switch(GPSPSession session, Dictionary <string, string> recv)
        {
            string command = recv.Keys.First();

            try
            {
                switch (command)
                {
                case "search":
                    SearchHandler search = new SearchHandler(recv);
                    search.Handle(session);
                    break;

                case "valid":    //is email format valid
                    ValidHandler valid = new ValidHandler(recv);
                    valid.Handle(session);
                    break;

                case "nicks":    // search an user with nick name
                    NickHandler nick = new NickHandler(recv);
                    nick.Handle(session);
                    break;

                case "pmatch":
                    PmatchHandler pmatch = new PmatchHandler(recv);
                    pmatch.Handle(session);
                    break;

                case "check":
                    CheckHandler check = new CheckHandler(recv);
                    check.Handle(session);
                    break;

                case "newuser":    //create an new user
                    NewUserHandler newUser = new NewUserHandler(recv);
                    newUser.Handle(session);
                    break;

                case "searchunique":    //search an user with uniquenick
                    SearchUniqueHandler searchUnique = new SearchUniqueHandler(recv);
                    searchUnique.Handle(session);
                    break;

                case "others":    //search
                    OthersHandler others = new OthersHandler(recv);
                    others.Handle(session);
                    break;

                case "otherslist":    //search other players friend list to see who is in his list?
                    OthersListHandler othersList = new OthersListHandler(recv);
                    othersList.Handle(session);
                    break;

                case "uniquesearch":    //search a user with uniquenick and namespaceid
                    UniqueSearchHandler uniqueSearch = new UniqueSearchHandler(recv);
                    uniqueSearch.Handle(session);
                    break;

                default:
                    session.UnknownDataRecived(command, recv);
                    break;
                }
            }
            catch (Exception e)
            {
                LogWriter.Log.WriteException(e);
                Error.ErrorMsg.SendGPSPError(session, Enumerator.GPErrorCode.General, 0);
            }
        }
Example #7
0
        public static void Switch(GPCMClient client, Dictionary <string, string> recv, GPCMConnectionUpdate OnSuccessfulLogin, GPCMStatusChanged OnStatusChanged)
        {
            string command = recv.Keys.First();

            try
            {
                switch (command)
                {
                case "inviteto":
                    InviteToHandler.AddFriends(client, recv);
                    break;

                case "login":
                    LoginHandler.ProcessLogin(client, recv, OnSuccessfulLogin, OnStatusChanged);
                    break;

                case "getprofile":
                    GetProfileHandler.SendProfile(client, recv);
                    break;

                case "addbuddy":
                    AddBuddyHandler.Addfriends(client, recv);
                    break;

                case "delbuddy":
                    DelBuddyHandler.Handle(client, recv);
                    break;

                case "updateui":
                    UpdateUiHandler.UpdateUi(client, recv);
                    break;

                case "updatepro":
                    UpdateProHandler.UpdateUser(client, recv);
                    break;

                case "registernick":
                    RegisterNickHandler.RegisterNick(client, recv);
                    break;

                case "logout":
                    client.DisconnectByReason(DisconnectReason.NormalLogout);
                    break;

                case "status":
                    StatusHandler.UpdateStatus(client, recv, OnStatusChanged);
                    break;

                case "newuser":
                    NewUserHandler.NewUser(client, recv);
                    break;

                case "ka":
                    KAHandler.SendKeepAlive(client);
                    break;

                default:
                    LogWriter.Log.Write("[GPCM] received unknown data " + command, LogLevel.Debug);
                    GameSpyUtils.SendGPError(client, GPErrorCode.General, "An invalid request was sended.");
                    break;
                }
            }
            catch (Exception e)
            {
                LogWriter.Log.WriteException(e);
            }
        }