Ejemplo n.º 1
0
    def get_org_info(self, org_id):
        cache_key = "%d.%d.json" % (org_id, self.bot.dimension)

        # check cache for fresh value
        cache_result = self.cache_service.retrieve(self.CACHE_GROUP, cache_key,
                                                   self.CACHE_MAX_AGE)

        is_cache = False
        if cache_result:
            result = json.loads(cache_result)
            is_cache = True
        else:
            url = "http://people.anarchy-online.com/org/stats/d/%d/name/%d/basicstats.xml?data_type=json" % (
                self.bot.dimension, org_id)

            r = requests.get(url)
            try:
                result = r.json()

                # if org has no members, org does not exist
                if result[0]["NUMMEMBERS"] == 0:
                    result = None
            except ValueError as e:
                self.logger.warning(
                    "Error marshalling value as json: %s" % r.text, e)
                result = None

            if result:
                # store result in cache
                self.cache_service.store(self.CACHE_GROUP, cache_key,
                                         json.dumps(result))
            else:
                # check cache for any value, even expired
                cache_result = self.cache_service.retrieve(
                    self.CACHE_GROUP, cache_key)
                if cache_result:
                    result = json.loads(cache_result)
                    is_cache = True

        if not result:
            return None

        org_info = result[0]
        org_members = result[1]
        last_updated = result[2]

        new_org_info = DictObject({
            "counts": {
                "gender": {
                    "Female": org_info["FEMALECOUNT"],
                    "Male": org_info["MALECOUNT"],
                    "Neuter": org_info["NEUTERCOUNT"],
                },
                "breed": {
                    "Atrox": org_info["ATROXCOUNT"],
                    "Nanomage": org_info["NANORACECOUNT"],
                    "Opifex": org_info["OPIFEXCOUNT"],
                    "Solitus": org_info["SOLITUSCOUNT"],
                },
                "profession": {
                    "Monster": org_info["MONSTERCOUNT"],
                    "Adventurer": org_info["ADVENTURERCOUNT"],
                    "Agent": org_info["AGENTCOUNT"],
                    "Bureaucrat": org_info["BTCOUNT"],
                    "Doctor": org_info["DOCTORCOUNT"],
                    "Enforcer": org_info["ENFCOUNT"],
                    "Engineer": org_info["ENGINEEERCOUNT"],
                    "Fixer": org_info["FIXERCOUNT"],
                    "Keeper": org_info["KEEPERCOUNT"],
                    "Martial Artist": org_info["MACOUNT"],
                    "Meta-Physicist": org_info["METACOUNT"],
                    "Nano-Technician": org_info["NANOCOUNT"],
                    "Shade": org_info["SHADECOUNT"],
                    "Soldier": org_info["SOLIDERCOUNT"],
                    "Trader": org_info["TRADERCOUNT"],
                }
            },
            "min_level": org_info["MINLVL"],
            "num_members": org_info["NUMMEMBERS"],
            "dimension": org_info["ORG_DIMENSION"],
            "governing_type": org_info["GOVERNINGNAME"],
            "max_level": org_info["MAXLVL"],
            "org_id": org_info["ORG_INSTANCE"],
            "objective": org_info["OBJECTIVE"],
            "description": org_info["DESCRIPTION"],
            "history": org_info["HISTORY"],
            "avg_level": org_info["AVGLVL"],
            "name": org_info["NAME"],
            "faction": org_info["SIDE_NAME"],
            "faction_id": org_info["SIDE"],
        })

        with self.db.transaction():
            members = {}
            for org_member in org_members:
                char_info = DictObject({
                    "name":
                    org_member["NAME"],
                    "char_id":
                    org_member["CHAR_INSTANCE"],
                    "first_name":
                    org_member["FIRSTNAME"],
                    "last_name":
                    org_member["LASTNAME"],
                    "level":
                    org_member["LEVELX"],
                    "breed":
                    org_member["BREED"],
                    "dimension":
                    org_member["CHAR_DIMENSION"],
                    "gender":
                    org_member["SEX"],
                    "faction":
                    org_info["SIDE_NAME"],
                    "profession":
                    org_member["PROF"],
                    "profession_title":
                    org_member["PROF_TITLE"],
                    "ai_rank":
                    org_member["DEFENDER_RANK_TITLE"],
                    "ai_level":
                    org_member["ALIENLEVEL"],
                    "pvp_rating":
                    org_member["PVPRATING"],
                    "pvp_title":
                    none_to_empty_string(org_member["PVPTITLE"]),
                    "head_id":
                    org_member["HEADID"],
                    "org_id":
                    org_info.get("ORG_INSTANCE", 0),
                    "org_name":
                    org_info.get("NAME", ""),
                    "org_rank_name":
                    org_member.get("RANK_TITLE", ""),
                    "org_rank_id":
                    org_member.get("RANK", 0),
                    "source":
                    "people.anarchy-online.com"
                })

                if not is_cache:
                    self.pork_service.save_character_info(char_info)

                # prefetch char ids from chat server
                self.character_service._send_lookup_if_needed(char_info.name)

                members[char_info.char_id] = char_info

        if len(members) == 0:
            return None
        else:
            return DictObject({
                "org_info":
                new_org_info,
                "org_members":
                members,
                "last_updated":
                int(
                    datetime.datetime.strptime(
                        last_updated, "%Y/%m/%d %H:%M:%S").timestamp())
            })
Ejemplo n.º 2
0
    def get_character_info(self, char):
        # if we have entry in database and it is less than a day old, use that
        char_info = self.get_from_database(char)
        if char_info and char_info.last_updated > (int(time.time()) - 86400):
            # TODO append "(cache)" to source field
            return char_info

        char_name = self.character_manager.resolve_char_to_name(char)
        url = "http://people.anarchy-online.com/character/bio/d/%d/name/%s/bio.xml?data_type=json" % (
            self.bot.dimension, char_name)

        r = requests.get(url)
        json = r.json()
        if json:
            char_info_json = json[0]
            org_info_json = json[1] if json[1] else {}

            char_info = MapObject({
                "name":
                char_info_json["NAME"],
                "char_id":
                char_info_json["CHAR_INSTANCE"],
                "first_name":
                char_info_json["FIRSTNAME"],
                "last_name":
                char_info_json["LASTNAME"],
                "level":
                char_info_json["LEVELX"],
                "breed":
                char_info_json["BREED"],
                "dimension":
                char_info_json["CHAR_DIMENSION"],
                "gender":
                char_info_json["SEX"],
                "faction":
                char_info_json["SIDE"],
                "profession":
                char_info_json["PROF"],
                "profession_title":
                char_info_json["PROFNAME"],
                "ai_rank":
                char_info_json["RANK_name"],
                "ai_level":
                char_info_json["ALIENLEVEL"],
                "pvp_rating":
                char_info_json["PVPRATING"],
                "pvp_title":
                none_to_empty_string(char_info_json["PVPTITLE"]),
                "head_id":
                char_info_json["HEADID"],
                "org_id":
                org_info_json.get("ORG_INSTANCE", 0),
                "org_name":
                org_info_json.get("NAME", ""),
                "org_rank_name":
                org_info_json.get("RANK_TITLE", ""),
                "org_rank_id":
                org_info_json.get("RANK", 0),
                "source":
                "people.anarchy-online.com"
            })

            self.save_character_info(char_info)
            return char_info
        else:
            # return cached info from database, even tho it's old
            return char_info
Ejemplo n.º 3
0
    def get_character_info(self, char, max_cache_age=86400):
        char_id = self.character_service.resolve_char_to_id(char)
        char_name = self.character_service.resolve_char_to_name(char)

        t = int(time.time())

        # if we have entry in database and it is within the cache time, use that
        char_info = self.get_from_database(char_id=char_id,
                                           char_name=char_name)
        if char_info:
            char_info.cache_age = t - char_info.last_updated

            if char_info.cache_age < max_cache_age and char_info.source != "chat_server":
                return char_info

        if not char_name:
            return char_info

        url = "http://people.anarchy-online.com/character/bio/d/%d/name/%s/bio.xml?data_type=json" % (
            self.bot.dimension, char_name)

        r = requests.get(url)
        try:
            json = r.json()
        except ValueError as e:
            self.logger.debug(
                "Error marshalling value as json for url '%s': %s" %
                (url, r.text), e)
            json = None

        if json:
            char_info_json = json[0]
            org_info_json = json[1] if json[1] else {}

            char_info = DictObject({
                "name":
                char_info_json["NAME"],
                "char_id":
                char_info_json["CHAR_INSTANCE"],
                "first_name":
                char_info_json["FIRSTNAME"],
                "last_name":
                char_info_json["LASTNAME"],
                "level":
                char_info_json["LEVELX"],
                "breed":
                char_info_json["BREED"],
                "dimension":
                char_info_json["CHAR_DIMENSION"],
                "gender":
                char_info_json["SEX"],
                "faction":
                char_info_json["SIDE"],
                "profession":
                char_info_json["PROF"],
                "profession_title":
                char_info_json["PROFNAME"],
                "ai_rank":
                char_info_json["RANK_name"],
                "ai_level":
                char_info_json["ALIENLEVEL"],
                "pvp_rating":
                char_info_json["PVPRATING"],
                "pvp_title":
                none_to_empty_string(char_info_json["PVPTITLE"]),
                "head_id":
                char_info_json["HEADID"],
                "org_id":
                org_info_json.get("ORG_INSTANCE", 0),
                "org_name":
                org_info_json.get("NAME", ""),
                "org_rank_name":
                org_info_json.get("RANK_TITLE", ""),
                "org_rank_id":
                org_info_json.get("RANK", 0),
                "source":
                "people.anarchy-online.com"
            })

            self.save_character_info(char_info)

            char_info.cache_age = 0
            return char_info
        else:
            # return cached info from database, even tho it's old, and set cache_age (if it exists)
            if char_info:
                char_info.cache_age = t - char_info.last_updated

            return char_info