void ISimulationInformationServiceCallback.ReceiveNotificationDictionary(string statementName, Dictionary<string, object> dict)
 {
     if (this.NotificationReceived != null)
     {
         this.NotificationReceived(statementName + ": " + dict.ToDebugString());
     }
 }
Example #2
0
        internal string Parse(string args, DataType dataType, bool disableSpeech) {
            if (args.Contains("{mute}") || args.Contains("{widget}")) {
                args = args.Replace("{mute}", string.Empty).Replace("{widget}", string.Empty);
                disableSpeech = true;
            }

            if (args.Contains("</lock>")) // lock is extension of judo parser. No need for extra parsing
                if (dataType.Equals(DataType.html))
                    return Judoers.JudoParser(args).Replace("\r", string.Empty).Replace("\n", "<br />");
                else
                    return Judoers.JudoParser(args);

            string[] InstructionSets = args.Split(';');
            var results = new Dictionary<string, KeyValuePair<string, string>>();

            foreach (string Instruction in InstructionSets)
                if (Instruction.Trim() != string.Empty) {
                    var exe = Execute(Instruction.Trim(), disableSpeech).Replace("\r", string.Empty);
                    if (exe.EndsWith("\n"))
                        exe = exe.Substring(0, exe.LastIndexOf("\n"));
                    var key = Instruction.Trim().Replace(" ", "_").Replace("%", string.Empty);
                    try {
                        results.Add(key, new KeyValuePair<string, string>(Instruction.Trim(), exe));
                    }
                    catch {
                        // Duplicate keys are not allowed.
                    }
                }

            switch (dataType) {
                case DataType.html:
                    return results.ToDebugString().Replace("<", "&lt;").Replace(">", "&gt;").Replace("\n", "<br />");
                case DataType.json:
                    return results.ToJson();
            }
            return results.ToDebugString();
        }
Example #3
0
        private static string FormatGetOrSetExecuteSqlCommandKey <T>([NotNull] string sql, CommandType cmdType, [CanBeNull] Dictionary <string, object> parameters)
        {
            Guard.NotEmpty(sql, nameof(sql));

            var sb = new StringBuilder();

            sb.Append($"GetOrSetExecuteSqlCommand<{Name<T>()}>: [ \n\tSql = {sql},");

            if (parameters != null && parameters.Any())
            {
                sb.Append($"\n\tParameters = {parameters.ToDebugString()},");
            }

            sb.Append($"\n\tCommandType = {cmdType} ]");

            return(sb.ToString());
        }
Example #4
0
        public async Task <bool> SendRecover(EmailFormModel emailFormModel, int UserId)
        {
            //cria o hash com os dados
            Dictionary <string, string> dict = new Dictionary <string, string>
            {
                { "dateCreate", DateTime.Now.ToString("o") },
                { "dateExpire", DateTime.Now.AddHours(24).ToString("o") },
                { "userId", UserId.ToString() },
                { "Method", "RecoverPassword" }
            };

            var hash = CryptAES.Encrypt(dict.ToDebugString());

            var message = new MailMessage();

            message.To.Add(new MailAddress(emailFormModel.FromEmail, emailFormModel.FromName));
            message.From    = new MailAddress(_MyEmail, "JDKB - Base de Conhecimento");
            message.Subject = "Recuperar senha";
            message.Body    =
                "<!DOCTYPE html>" +
                "<html>" +
                "<head>" +
                "<title>JDKB - Recuperar senha</title>" +
                "</head>" +
                "<body style=\"margin:0;padding:10px;font-family:Helvetica,Arial,sans-serif;font-weight:300;background-color:#ffffff;max-width:600px;margin:0 auto;text-align:center;color:#333333;\">" +
                "<h2 style=\"color:#0fad00\">Olá " + emailFormModel.FromName + "</h2>" +
                "<p style=\"font-size:20px;color:#5C5C5C;\">" +
                "    Para redefinir sua senha, clique no link abaixo: (esse link vai expirar em 24 horas):" +
                "</p>" +
                "<a href=\"" + GetURL() + "Recoverconfirm?hash=" + hash + "\" target=\"_blank\" style=\"background-color:#1979bb;display:inline-block;padding:7px 15px;border-radius:5px;color:#fff;text-decoration:none;margin-bottom:40px\">Redefinir minha senha</a>" +
                "<p style=\"font-size:10px;color:gray;\">" +
                "Se você não solicitou a recuperação da senha, favor desconsiderar esse email" +
                "</p>" +
                "</body>" +
                "</html>";
            message.IsBodyHtml = true;

            using (var _smtp = GetSmtp())
            {
                await _smtp.SendMailAsync(message);
            }

            return(await Task.FromResult(true));
        }
        private static long GetResult(string data)
        {
            Commands = data.Split("\r\n").Select(x => x.Split(' ').ToArray()).ToList();

            Thread = new Dictionary <string, long>()
            {
                { "a", 1 },
                { "b", 0 },
                { "c", 0 },
                { "d", 0 },
                { "e", 0 },
                { "f", 0 },
                { "g", 0 },
                { "h", 0 }
            };

            Pos = 0;

            var counter = 0;

            while (!IsDone(0))
            {
                var line     = Commands.ElementAt(Pos);
                var command  = line[0];
                var register = line[1];
                var value    = line[2];

                Pos += ExecuteCommand(command, register, value);

                CommandsExecuted.Add($"{command} {register} {value}");
                CommandsResult.Add($"{Thread.ToDebugString()} - Pos: {Pos}");

                Console.WriteLine(CommandsExecuted.ElementAt(counter));
                Console.WriteLine(CommandsResult.ElementAt(counter));

                counter++;

                if (counter == 100)
                {
                }
            }

            return(GetRegisterValue("h"));
        }
#pragma warning restore 414, 649

        public override string ToString()
        {
            return(string.Format("[PublicUser: Id={0}, DisplayName={1}, Identities={2}, PublicProperties={3}]", Id, DisplayName, Identities.ToDebugString(), _publicProperties.ToDebugString()));
        }
Example #7
0
 ICmd BuildToDialogUnit(Dictionary <string, string> keyValuePairs)
 {
     foreach (var factory in dialogUnitFactoryList)
     {
         if (factory.CanBuild(keyValuePairs))
         {
             return(factory.BuildDialogUnit(keyValuePairs));
         }
     }
     throw new ArgumentException(string.Format("沒有……哪裡都沒有可以用的unitFactory……\ndialog={0}", keyValuePairs.ToDebugString()));
 }
Example #8
0
 private void TestingUpdateThrottleTriggerAxis(Dictionary <string, float> values)
 {
     Log($"Update ThrottleTriggerAxis: {values.ToDebugString()}");
 }
Example #9
0
 private void TestingUpdateThrottleTouchpad(Dictionary <string, float> values)
 {
     Log($"Update ThrottleTouchpad: {values.ToDebugString()}");
 }
Example #10
0
 private void TestingUpdateStickTouchpad(Dictionary <string, float> values, bool pressed)
 {
     Log($"Update StickTouchpad: {values.ToDebugString()}, pressed: {pressed}");
 }
Example #11
0
 private void TestingUpdateStickXyz(Dictionary <string, float> values)
 {
     Log($"Update StickXyz: {values.ToDebugString()}");
 }
        // obviously everything coming in from the in-game chat is a string.
        // we have to take that string and chop it up, work out what command is being executed
        // then parse/cast/convert arguments as necessary.
        public void ParseAdminCommand(Character sender, string text, IRequest request, Channel channel, ISessionManager sessionManager, ChannelManager channelmanager)
        {
            string[] command = text.Split(new char[] { ',' });

            // channel is not secured. must be secured first.
            if (channel.Type != ChannelType.Admin)
            {
                if (command[0] == "#secure")
                {
                    channel.SetAdmin(true);
                    channel.SendMessageToAll(sessionManager, sender, "Channel Secured.");
                    return;
                }

                channel.SendMessageToAll(sessionManager, sender, "Channel must be secured before sending commands.");
                return;
            }

            if (command[0] == "#shutdown")
            {
                DateTime shutdownin = DateTime.Now;
                int      minutes    = 1;
                if (!int.TryParse(command[2], out minutes))
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }
                shutdownin = shutdownin.AddMinutes(minutes);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "message", command[1] },
                    { "date", shutdownin }
                };

                string cmd = string.Format("serverShutDown:relay:{0}", GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#shutdowncancel")
            {
                string cmd = string.Format("serverShutDownCancel:relay:null");
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#jumpto")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int zone);
                err = !int.TryParse(command[2], out int x);
                err = !int.TryParse(command[3], out int y);
                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "zoneID", zone },
                    { "x", x },
                    { "y", y }
                };

                string cmd = string.Format("jumpAnywhere:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#moveplayer")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int characterID);
                err = !int.TryParse(command[2], out int zoneID);
                err = !int.TryParse(command[3], out int x);
                err = !int.TryParse(command[4], out int y);
                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                // get the target character's session.
                var charactersession = sessionManager.GetByCharacter(characterID);

                if (charactersession.Character.ZoneId == null)
                {
                    channel.SendMessageToAll(sessionManager, sender, string.Format("ERR: Character with ID {0} does not have a zone. Are they docked?", characterID));
                    return;
                }

                // get destination zone.
                var zone = request.Session.ZoneMgr.GetZone(zoneID);

                if (charactersession.Character.ZoneId == null)
                {
                    channel.SendMessageToAll(sessionManager, sender, string.Format("ERR: Invalid Zone ID {0}", zoneID));
                    return;
                }

                // get a teleporter object to teleport the player.
                TeleportToAnotherZone tp = new TeleportToAnotherZone(zone);

                // we need the player (robot, etc) to teleport on the origin zone
                var player = request.Session.ZoneMgr.GetZone((int)charactersession.Character.ZoneId).GetPlayer(charactersession.Character.ActiveRobotEid);
                //var player = zone.GetPlayer(charactersession.Character.Eid);

                // set the position.
                tp.TargetPosition = new Position(x, y);

                // do it.
                tp.DoTeleportAsync(player);
                tp = null;

                channel.SendMessageToAll(sessionManager, sender, string.Format("Moved Character {0}-{1} to Zone {2} @ {3},{4}", characterID, charactersession.Character.Nick, zone.Id, x, y));
            }
#if DEBUG
            if (command[0] == "#currentzonecleanobstacleblocking")
            {
                string cmd = string.Format("zoneCleanObstacleBlocking:zone_{0}:null", sender.ZoneId);
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzonedrawblockingbyeid")
            {
                bool err = false;
                err = !Int64.TryParse(command[1], out Int64 eid);

                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "eid", eid }
                };

                string cmd = string.Format("zoneDrawBlockingByEid:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzoneremoveobjectbyeid")
            {
                bool err = false;
                err = !Int64.TryParse(command[1], out Int64 eid);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "target", eid }
                };

                string cmd = string.Format("zoneRemoveObject:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonecreateisland")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int lvl);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "low", lvl }
                };

                string cmd = string.Format("zoneCreateIsland:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzoneplacewall")
            {
                string cmd = string.Format("zonePlaceWall:zone_{0}:null", sender.ZoneId);
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzoneclearwalls")
            {
                string cmd = string.Format("zoneClearWalls:zone_{0}:null", sender.ZoneId);
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzoneadddecor")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int definition);
                err = !int.TryParse(command[2], out int x);
                err = !int.TryParse(command[3], out int y);
                err = !int.TryParse(command[4], out int z);
                err = !double.TryParse(command[5], out double qx);
                err = !double.TryParse(command[6], out double qy);
                err = !double.TryParse(command[7], out double qz);
                err = !double.TryParse(command[8], out double qw);
                err = !double.TryParse(command[9], out double scale);
                err = !int.TryParse(command[10], out int cat);

                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "definition", definition },
                    { "x", x *256 },
                    { "y", y *256 },
                    { "z", z *256 },
                    { "quaternionX", qx },
                    { "quaternionY", qy },
                    { "quaternionZ", qz },
                    { "quaternionW", qw },
                    { "scale", scale },
                    { "category", cat }
                };

                string cmd = string.Format("zoneDecorAdd:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#adddecortolockedtile")
            {
                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var terrainLock = player.GetPrimaryLock() as TerrainLock;
                if (terrainLock == null)
                {
                    return;
                }

                double x = terrainLock.Location.X;
                double y = terrainLock.Location.Y;
                double z = terrainLock.Location.Z;

                bool err = !double.TryParse(command[2], out double scale);
                err = !int.TryParse(command[1], out int definition);

                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "definition", definition },
                    { "x", (int)x * 256 },
                    { "y", (int)y * 256 },
                    { "z", (int)z * 256 },
                    { "quaternionX", (double)0 },
                    { "quaternionY", (double)0 },
                    { "quaternionZ", (double)0 },
                    { "quaternionW", (double)0 },
                    { "scale", scale },
                    { "category", 1 }
                };

                string cmd = string.Format("zoneDecorAdd:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonedeletedecor")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int idno);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "ID", idno }
                };

                string cmd = string.Format("zoneDecorDelete:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zoneclearlayer")
            {
                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "layerName", command[1] }
                };

                string cmd = string.Format("zoneClearLayer:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonesetplantspeed")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int speed);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "speed", speed }
                };

                string cmd = string.Format("zoneSetPlantsSpeed:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonesetplantmode")
            {
                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "mode", command[1] }
                };

                string cmd = string.Format("zoneSetPlantsMode:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#currentzonerestoreoriginalgamma")
            {
                string cmd = string.Format("zoneRestoreOriginalGamma:zone_{0}:null", sender.ZoneId);
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonedrawblockingbydefinition")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int def);
                int[] defs = new int[1];
                defs[0] = def;

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "definition", defs }
                };

                string cmd = string.Format("zoneDrawBlockingByDefinition:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#addblockingtotiles")
            {
                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position pos = (item as TerrainLock).Location;
                        zone.Terrain.Blocks.SetValue(pos, new BlockingInfo()
                        {
                            Obstacle = true
                        });
                        item.Cancel(); // cancel this lock. we processed it.
                    }
                }

                channel.SendMessageToAll(sessionManager, sender, string.Format("Added Blocking To {0} Tiles.", lockedtiles.Count));
            }

            if (command[0] == "#removeblockingfromtiles")
            {
                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position pos = (item as TerrainLock).Location;
                        zone.Terrain.Blocks.SetValue(pos, new BlockingInfo()
                        {
                            Obstacle = false
                        });
                        item.Cancel(); // cancel this lock. we processed it.
                    }
                }

                channel.SendMessageToAll(sessionManager, sender, string.Format("Removed Blocking From {0} Tiles.", lockedtiles.Count));
            }

            if (command[0] == "#zonedecorlock")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int id);
                err = !int.TryParse(command[2], out int locked);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "ID", id },
                    { "locked", locked }
                };

                string cmd = string.Format("zoneDecorLock:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            if (command[0] == "#zonetileshighway")
            {
                bool.TryParse(command[1], out bool adddelete);
                bool.TryParse(command[2], out bool keeplock);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position           pos = (item as TerrainLock).Location;
                        TerrainControlInfo ti  = zone.Terrain.Controls.GetValue(pos);
                        ti.Highway = adddelete;
                        zone.Terrain.Controls.SetValue(pos, ti);
                        if (!keeplock)
                        {
                            item.Cancel(); // cancel this lock. we processed it.
                        }
                    }
                }
                channel.SendMessageToAll(sessionManager, sender, string.Format("Altered state of control layer on {0} Tiles (Highway)", lockedtiles.Count));
            }

            if (command[0] == "#zonetilesconcretea")
            {
                bool.TryParse(command[1], out bool adddelete);
                bool.TryParse(command[2], out bool keeplock);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position           pos = (item as TerrainLock).Location;
                        TerrainControlInfo ti  = zone.Terrain.Controls.GetValue(pos);
                        ti.ConcreteA = adddelete;
                        zone.Terrain.Controls.SetValue(pos, ti);
                        if (!keeplock)
                        {
                            item.Cancel(); // cancel this lock. we processed it.
                        }
                    }
                }
                channel.SendMessageToAll(sessionManager, sender, string.Format("Altered state of control layer on {0} Tiles (ConcreteA)", lockedtiles.Count));
            }

            if (command[0] == "#zonetilesconcreteb")
            {
                bool.TryParse(command[1], out bool adddelete);
                bool.TryParse(command[2], out bool keeplock);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position           pos = (item as TerrainLock).Location;
                        TerrainControlInfo ti  = zone.Terrain.Controls.GetValue(pos);
                        ti.ConcreteB = adddelete;
                        zone.Terrain.Controls.SetValue(pos, ti);
                        if (!keeplock)
                        {
                            item.Cancel(); // cancel this lock. we processed it.
                        }
                    }
                }
                channel.SendMessageToAll(sessionManager, sender, string.Format("Altered state of control layer on {0} Tiles (ConcreteB)", lockedtiles.Count));
            }

            if (command[0] == "#zonetilesroaming")
            {
                bool.TryParse(command[1], out bool adddelete);
                bool.TryParse(command[2], out bool keeplock);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position           pos = (item as TerrainLock).Location;
                        TerrainControlInfo ti  = zone.Terrain.Controls.GetValue(pos);
                        ti.Roaming = adddelete;
                        zone.Terrain.Controls.SetValue(pos, ti);
                        if (!keeplock)
                        {
                            item.Cancel(); // cancel this lock. we processed it.
                        }
                    }
                }
                channel.SendMessageToAll(sessionManager, sender, string.Format("Altered state of control layer on {0} Tiles (Roaming)", lockedtiles.Count));
            }

            if (command[0] == "#zonetilesPBSTerraformProtected")
            {
                bool.TryParse(command[1], out bool adddelete);
                bool.TryParse(command[2], out bool keeplock);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtiles = player.GetLocks();

                using (new TerrainUpdateMonitor(zone))
                {
                    foreach (Lock item in lockedtiles)
                    {
                        Position           pos = (item as TerrainLock).Location;
                        TerrainControlInfo ti  = zone.Terrain.Controls.GetValue(pos);
                        ti.PBSTerraformProtected = adddelete;
                        zone.Terrain.Controls.SetValue(pos, ti);
                        if (!keeplock)
                        {
                            item.Cancel(); // cancel this lock. we processed it.
                        }
                    }
                }
                channel.SendMessageToAll(sessionManager, sender, string.Format("Altered state of control layer on {0} Tiles (PBSTerraformProtected)", lockedtiles.Count));
            }

            //MissionTestResolve - DEBUG ONLY
            if (command[0] == "#testmissions")
            {
                int.TryParse(command[1], out int charID);
                int.TryParse(command[2], out int zoneID);
                int.TryParse(command[3], out int level);
                int.TryParse(command[4], out int numAttempts);
                int.TryParse(command[5], out int displayFlag);
                int.TryParse(command[6], out int singleFlag);
                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { k.characterID, charID },
                    { k.zone, zoneID },
                    { k.level, level },
                    { "display", displayFlag },
                    { "attempts", numAttempts },
                    { "single", singleFlag },
                };

                string cmd = string.Format("{0}:relay:{1}", Commands.MissionResolveTest.Text, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));

                channel.SendMessageToAll(sessionManager, sender, string.Format("Running missionresolve test {0}", dictionary.ToDebugString()));
            }
#endif

            if (command[0] == "#giveitem")
            {
                int.TryParse(command[1], out int definition);
                int.TryParse(command[2], out int qty);

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "definition", definition },
                    { "quantity", qty }
                };


                string cmd = string.Format("createItem:relay:{0}", GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));

                channel.SendMessageToAll(sessionManager, sender, string.Format("Gave Item {0} ", definition));
            }


            if (command[0] == "#getlockedtileproperties")
            {
                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                var lockedtile = player.GetPrimaryLock();

                TerrainControlInfo ti = zone.Terrain.Controls.GetValue((lockedtile as TerrainLock).Location);

                channel.SendMessageToAll(sessionManager, sender, string.Format("Tile at {0},{1} has the following flags..", (lockedtile as TerrainLock).Location.X, (lockedtile as TerrainLock).Location.Y));
                channel.SendMessageToAll(sessionManager, sender, "TerrainControlFlags:");
                foreach (TerrainControlFlags f in Enum.GetValues(typeof(TerrainControlFlags)))
                {
                    if (ti.Flags.HasFlag(f) && f != TerrainControlFlags.Undefined)
                    {
                        channel.SendMessageToAll(sessionManager, sender, string.Format("{0}", f.ToString()));
                    }
                }

                BlockingInfo bi = zone.Terrain.Blocks.GetValue((lockedtile as TerrainLock).Location);

                channel.SendMessageToAll(sessionManager, sender, "BlockingFlags:");
                foreach (BlockingFlags f in Enum.GetValues(typeof(BlockingFlags)))
                {
                    if (bi.Flags.HasFlag(f) && f != BlockingFlags.Undefined)
                    {
                        channel.SendMessageToAll(sessionManager, sender, string.Format("{0}", f.ToString()));
                    }
                }

                PlantInfo pi = zone.Terrain.Plants.GetValue((lockedtile as TerrainLock).Location);

                channel.SendMessageToAll(sessionManager, sender, "PlantType:");
                foreach (PlantType f in Enum.GetValues(typeof(PlantType)))
                {
                    if (pi.type.HasFlag(f) && f != PlantType.NotDefined)
                    {
                        channel.SendMessageToAll(sessionManager, sender, string.Format("{0}", f.ToString()));
                    }
                }

                channel.SendMessageToAll(sessionManager, sender, "GroundType:");
                foreach (GroundType f in Enum.GetValues(typeof(GroundType)))
                {
                    if (pi.groundType.HasFlag(f))
                    {
                        channel.SendMessageToAll(sessionManager, sender, string.Format("{0}", f.ToString()));
                    }
                }
            }

            if (command[0] == "#setvisibility")
            {
                bool.TryParse(command[1], out bool visiblestate);

                var character = request.Session.Character;
                var zone      = request.Session.ZoneMgr.GetZone((int)character.ZoneId);
                var player    = zone.GetPlayer(character.ActiveRobotEid);

                player.HasGMStealth = !visiblestate;

                channel.SendMessageToAll(sessionManager, sender, string.Format("Player {0} visibility is {1}", player.Character.Nick, visiblestate));
            }

            if (command[0] == "#zonedrawstatmap")
            {
                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { "type", command[1] }
                };

                string cmd = string.Format("zoneDrawStatMap:zone_{0}:{1}", sender.ZoneId, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }


            if (command[0] == "#listplayersinzone")
            {
                int.TryParse(command[1], out int zoneid);

                channel.SendMessageToAll(sessionManager, sender, string.Format("Players On Zone {0}", zoneid));
                channel.SendMessageToAll(sessionManager, sender, string.Format("  AccountId    CharacterId    Nick    Access Level    Docked?    DockedAt    Position"));
                foreach (Character c in sessionManager.SelectedCharacters.Where(x => x.ZoneId == zoneid))
                {
                    channel.SendMessageToAll(sessionManager, sender, string.Format("   {0}       {1}        {2}        {3}       {4}       {5}      {6}",
                                                                                   c.AccountId, c.Id, c.Nick, c.AccessLevel, c.IsDocked, c.GetCurrentDockingBase().Eid, c.GetPlayerRobotFromZone().CurrentPosition));
                }
            }

            if (command[0] == "#countofplayers")
            {
                foreach (IZone z in request.Session.ZoneMgr.Zones)
                {
                    channel.SendMessageToAll(sessionManager, sender, string.Format("Players On Zone {0}: {1}", z.Id, z.Players.ToList().Count));
                }
            }

            if (command[0] == "#unsecure")
            {
                channel.SetAdmin(false);
                channel.SendMessageToAll(sessionManager, sender, "Channel is now public.");
            }

            if (command[0] == "#addtochannel")
            {
                int.TryParse(command[1], out int characterid);

                var c = sessionManager.GetByCharacter(characterid);

                channelmanager.JoinChannel(channel.Name, c.Character, ChannelMemberRole.Operator, string.Empty);

                channel.SendMessageToAll(sessionManager, sender, string.Format("Added character {0} to channel ", c.Character.Nick));
            }

            if (command[0] == "#removefromchannel")
            {
                int.TryParse(command[1], out int characterid);

                var c = sessionManager.GetByCharacter(characterid);

                channelmanager.LeaveChannel(channel.Name, c.Character);

                channel.SendMessageToAll(sessionManager, sender, string.Format("Removed character {0} from channel ", c.Character.Nick));
            }

            if (command[0] == "#listrifts")
            {
                foreach (IZone z in request.Session.ZoneMgr.Zones)
                {
                    var rift = z.Units.OfType <Rift>();
                    foreach (Rift r in rift)
                    {
                        channel.SendMessageToAll(sessionManager, sender, string.Format("Rift - Zone: {0}, Position: ({1}), Destination Zone:{2}", r.Zone, r.CurrentPosition, r.DestinationStrongholdZone));
                    }
                }
            }


            if (command[0] == "#flagplayernameoffensive")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int characterID);
                err = !bool.TryParse(command[2], out bool isoffensive);

                var charactersession = sessionManager.GetByCharacter(characterID);
                charactersession.Character.IsOffensiveNick = isoffensive;

                channel.SendMessageToAll(sessionManager, sender, string.Format("Player with nick {0} is offensive:{1}", charactersession.Character.Nick, charactersession.Character.IsOffensiveNick));
            }

            //FreeAllLockedEP for account - by request of player
            if (command[0] == "#unlockallep")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int accountID);
                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { k.accountID, accountID }
                };

                string cmd = string.Format("{0}:relay:{1}", Commands.ExtensionFreeAllLockedEpCommand.Text, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
            }

            //EPBonusCommands
            if (command[0] == "#epbonusset")
            {
                bool err = false;
                err = !int.TryParse(command[1], out int bonusBoost);
                err = !int.TryParse(command[2], out int hours);
                if (err)
                {
                    throw PerpetuumException.Create(ErrorCodes.RequiredArgumentIsNotSpecified);
                }

                Dictionary <string, object> dictionary = new Dictionary <string, object>()
                {
                    { k.bonus, bonusBoost },
                    { k.duration, hours }
                };

                string cmd = string.Format("{0}:relay:{1}", Commands.EPBonusSet.Text, GenxyConverter.Serialize(dictionary));
                request.Session.HandleLocalRequest(request.Session.CreateLocalRequest(cmd));
                channel.SendMessageToAll(sessionManager, sender, "EP Bonus Set with command: " + dictionary.ToDebugString());
            }
        }
Example #13
0
        public static void HubspotPost(string fname, string lname, string email, string company, string phone, string promo, string seats, string source, string utkCookie, ProductType version)
        {
            Dictionary <string, string> dictFormValues = new Dictionary <string, string>();

            dictFormValues.Add("firstname", fname);
            dictFormValues.Add("lastname", lname);
            dictFormValues.Add("email", email);
            dictFormValues.Add("phone", phone);
            dictFormValues.Add("company", company);
            dictFormValues.Add("campaign", promo);
            dictFormValues.Add("marketingsource", source);
            dictFormValues.Add("lifecyclestage", "salesqualifiedlead");
            dictFormValues.Add("type_of_sql", "Trial");
            int numSeats = 0;

            int.TryParse(seats, out numSeats);
            dictFormValues.Add("no_of_users", numSeats.ToString());


            //dictFormValues.Add("recent_conversion_event_name", "TS Trial Sign Up");
            dictFormValues.Add("product_edition", GetProductVersionName(version));
            //dictFormValues.Add("hubspot_owner_id", GetSalesGuyHubSpotID(salesGuy));

            int    intPortalID = 448936;
            string strFormGUID = "0ddd21dd-ed3a-4282-afc8-26707a31d04e";

            // Tracking Code Variables
            string strHubSpotUTK = utkCookie;
            string strIpAddress  = System.Web.HttpContext.Current.Request.UserHostAddress;

            // Page Variables
            string strPageTitle = "TS";
            string strPageURL   = System.Web.HttpContext.Current.Request.Url.AbsoluteUri;

            // Do the post, returns true/false
            string strError = "";
            bool   blnRet   = Do_Post_To_HubSpot_FormsAPI(intPortalID, strFormGUID, dictFormValues, strHubSpotUTK, strIpAddress, strPageTitle, strPageURL, ref strError);

            if (!blnRet)
            {
                ExceptionLogs.LogException(LoginUser.Anonymous, new Exception("Error Posting To HUB SPOT"), "HUB SPOT", dictFormValues.ToDebugString());
            }
        }
 internal void StartSyncToInstances(IEnumerable <string> instances)
 {
     OperationsSyncManager.mIsBroadcasting = true;
     InputMapper.Instance.StartOperationsSync();
     foreach (string instance in instances)
     {
         Dictionary <string, string> dictionary = new Dictionary <string, string>()
         {
             {
                 "instance",
                 MultiInstanceStrings.VmName
             }
         };
         try
         {
             HTTPUtils.SendRequestToEngine("startSyncConsumer", dictionary, MultiInstanceStrings.VmName, 0, (Dictionary <string, string>)null, false, 1, 0, instance, "bgp");
         }
         catch (Exception ex)
         {
             Logger.Error("Exception in Post request failed. vmclient = {0}, data = {1}. Err : {2}", (object)instance, (object)dictionary.ToDebugString <string, string>(), (object)ex.ToString());
         }
     }
 }
 public void SetReferrer(string referrerId, string eventName, Dictionary <string, string> customData, Action onSuccess, Action <GetSocialError> onFailure)
 {
     LogRequest("setReferrer", "referrerId=" + referrerId + "; eventName=" + eventName + "; customData=" + customData.ToDebugString());
     WithHadesClient(client =>
     {
         var response = client.setReferrer(SessionId, referrerId, eventName, customData);
         Ui(() =>
         {
             LogResponse("setReferrer", response);
             onSuccess.SafeCall();
         });
     }, onFailure);
 }