Ejemplo n.º 1
0
        private void HandleGet(HttpRequest req, Map jsondata)
        {
            EstateInfo estateInfo;
            string     estateName;
            uint       estateID;

            if ((jsondata.TryGetValue("name", out estateName) &&
                 m_EstateService.TryGetValue(estateName, out estateInfo)) ||
                (jsondata.TryGetValue("id", out estateID) &&
                 m_EstateService.TryGetValue(estateID, out estateInfo)))
            {
                /* found estate via name or via id */
            }
            else
            {
                m_WebIF.ErrorResponse(req, AdminWebIfErrorResult.NotFound);
                return;
            }

            var res = new Map();

            res.Add("estate", estateInfo.ToJsonMap(m_WebIF));
            var regionMap   = m_EstateService.RegionMap[estateInfo.ID];
            var regionsdata = new AnArray();

            foreach (UUID regionid in regionMap)
            {
                RegionInfo rInfo;
                var        regiondata = new Map
                {
                    ["ID"] = regionid
                };
                if (m_RegionStorageService.TryGetValue(regionid, out rInfo))
                {
                    regiondata.Add("Name", rInfo.Name);
                }
                regionsdata.Add(regiondata);
            }
            res.Add("regions", regionsdata);

            m_WebIF.SuccessResponse(req, res);
        }
Ejemplo n.º 2
0
        public void ChangeEstateCmd(List <string> args, Common.CmdIO.TTY io, UUID limitedToScene)
        {
            EstateInfo estateInfo;
            uint       estateID;

            if (limitedToScene != UUID.Zero)
            {
                io.WriteFormatted("create region not allowed from restricted console");
            }
            else if (args[0] == "help" || args.Count < 3)
            {
                io.Write("change estate <estateid> parameters...\n\n" +
                         "Parameters:\n" +
                         "name <name>\n" +
                         "parentestateid <id>\n" +
                         "owner <uui>|<uuid>|<firstname>.<lastname>\n" +
                         "pricepermeter <value>\n" +
                         "billablefactor <factor>\n" +
                         "abuseemail <email>");
            }
            else if (!uint.TryParse(args[2], out estateID))
            {
                io.WriteFormatted("{0} is not a valid number.", args[2]);
            }
            else if (!m_EstateService.TryGetValue(estateID, out estateInfo))
            {
                io.WriteFormatted("Estate with id {0} does not exist.", estateID);
            }
            else
            {
                int  argi;
                bool changeEstateData = false;
                for (argi = 3; argi < args.Count; argi += 2)
                {
                    switch (args[argi].ToLower())
                    {
                    case "name":
                        estateInfo.Name  = args[argi + 1];
                        changeEstateData = true;
                        break;

                    case "abuseemail":
                        estateInfo.AbuseEmail = args[argi + 1];
                        changeEstateData      = true;
                        break;

                    case "parentestateid":
                        if (!uint.TryParse(args[argi + 1], out estateInfo.ParentEstateID))
                        {
                            io.WriteFormatted("{0} is not a number", args[argi + 1]);
                            return;
                        }
                        changeEstateData = true;
                        break;

                    case "owner":
                        if (!m_AvatarNameService.TranslateToUUI(args[argi + 1], out estateInfo.Owner))
                        {
                            io.WriteFormatted("{0} is not a valid owner.", args[argi + 1]);
                            return;
                        }
                        changeEstateData = true;
                        break;

                    case "billablefactor":
                        if (!double.TryParse(args[argi + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out estateInfo.BillableFactor))
                        {
                            io.WriteFormatted("{0} is not a valid float number.", args[argi + 1]);
                            return;
                        }
                        changeEstateData = true;
                        break;

                    case "pricepermeter":
                        if (!int.TryParse(args[argi + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out estateInfo.PricePerMeter))
                        {
                            io.WriteFormatted("{0} is not a valid integer number.", args[argi + 1]);
                            return;
                        }
                        changeEstateData = true;
                        break;

                    default:
                        io.WriteFormatted("Parameter {0} is not valid.", args[argi]);
                        return;
                    }
                }

                if (changeEstateData)
                {
                    try
                    {
                        m_EstateService.Update(estateInfo);
                    }
                    catch (Exception e)
                    {
                        io.WriteFormatted("Could not change estate parameters: {0}", e.Message);
                    }

                    /* trigger estate data update */
                    foreach (UUID regionid in m_EstateService.RegionMap[estateInfo.ID])
                    {
                        SceneInterface scene;
                        if (m_Scenes.TryGetValue(regionid, out scene))
                        {
                            scene.TriggerEstateUpdate();
                        }
                    }
                }
            }
        }
Ejemplo n.º 3
0
        public bool Run()
        {
            string estateName = "Test Estate";
            uint   estateId   = 100;
            UUID   covenantId = UUID.Random;

            m_Log.Info("Testing non-existence of estate via name");
            if (m_EstateService.ContainsKey(estateName))
            {
                return(false);
            }
            m_Log.Info("Testing non-existence of estate via id");
            if (m_EstateService.ContainsKey(estateId))
            {
                return(false);
            }
            m_Log.Info("Creating estate");
            EstateInfo info = new EstateInfo()
            {
                ID             = estateId,
                Name           = estateName,
                Owner          = m_EstateOwner,
                CovenantID     = covenantId,
                AbuseEmail     = "*****@*****.**",
                Flags          = RegionOptionFlags.AllowDirectTeleport,
                BillableFactor = 5,
                PricePerMeter  = 2,
                ParentEstateID = 2
            };

            m_EstateService.Add(info);
            m_Log.Info("Testing existence of estate via name");
            if (!m_EstateService.ContainsKey(estateName))
            {
                return(false);
            }
            m_Log.Info("Testing existence of estate via id");
            if (!m_EstateService.ContainsKey(estateId))
            {
                return(false);
            }

            EstateInfo retrievedInfo;

            m_Log.Info("Testing retrieval via name");
            if (!m_EstateService.TryGetValue(estateName, out retrievedInfo))
            {
                return(false);
            }
            if (!CompareEstates(info, retrievedInfo))
            {
                return(false);
            }

            m_Log.Info("Testing retrieval via id");
            if (!m_EstateService.TryGetValue(estateId, out retrievedInfo))
            {
                return(false);
            }
            if (!CompareEstates(info, retrievedInfo))
            {
                return(false);
            }

            m_Log.Info("Testing update");
            info.Name           = "New Test Estate";
            info.ParentEstateID = 3;
            estateName          = info.Name;
            m_EstateService.Update(info);

            m_Log.Info("Testing retrieval via old name");
            if (m_EstateService.TryGetValue("Test Estate", out retrievedInfo))
            {
                return(false);
            }

            m_Log.Info("Testing retrieval via name");
            if (!m_EstateService.TryGetValue(estateName, out retrievedInfo))
            {
                return(false);
            }
            if (!CompareEstates(info, retrievedInfo))
            {
                return(false);
            }

            m_Log.Info("Testing retrieval via id");
            if (!m_EstateService.TryGetValue(estateId, out retrievedInfo))
            {
                return(false);
            }
            if (!CompareEstates(info, retrievedInfo))
            {
                return(false);
            }

            m_Log.Info("Testing deletion");
            if (!m_EstateService.Remove(estateId))
            {
                return(false);
            }
            m_Log.Info("Testing non-existence of estate via name");
            if (m_EstateService.ContainsKey(estateName))
            {
                return(false);
            }
            m_Log.Info("Testing non-existence of estate via id");
            if (m_EstateService.ContainsKey(estateId))
            {
                return(false);
            }

            return(true);
        }