from django.db import models from django.conf import settings from django.urls import reverse from sys import maxsize from GeoffreyApp.util import create_token, objects_list_to_json # Create your models here. class APIToken(models.Model): key = models.CharField(default=create_token, max_length=25, unique=True) """ Key used to access the Geoffrey API """ name = models.CharField(max_length=50, blank=True) """ Name of the key """ commands_perm = models.BooleanField(default=False) """ Permission to use the command api """ def __str__(self): if len(self.name): return "{}: {}".format(self.name, self.key) else: return self.key class Player(models.Model): """ Model of a Player """ name = models.CharField(max_length=30, unique=True) """ In Game Username """ mc_uuid = models.CharField(max_length=36, unique=True) """ Minecraft UUID """ discord_uuid = models.CharField(max_length=50, unique=True) """ Discord UUID """ @property def loc_count(self): """ Number of locations the player is an owner of """ return Location.objects.filter(owner=self).count() @property def json(self): """ JSON representation of the Player .. code-block:: json { "name" : "self.name", "mc_uuid": "self.mc_uuid", "discord_uuid": "self.discord_uuid", } """ return {"name": self.name, "mc_uuid": self.mc_uuid, "discord_uuid": self.discord_uuid } @property def link(self): """ href to the player page """ return reverse("GeoffreyPlayerInfo", kwargs={"id": self.id}) def __str__(self): return self.name class Location(models.Model): """Model of a Location""" info_page = None """ Name of the info page view """ DIMENSIONS = ( ('O', 'Overworld'), ('N', 'Nether'), ('E', 'The End') ) """ Possible dimensions for a location to be in """ name = models.CharField(max_length=128, unique=True) """ Name of the location """ x_coord = models.IntegerField() """ X Position """ z_coord = models.IntegerField() """ Z Position """ dimension = models.CharField(max_length=1, choices=DIMENSIONS) """ Dimension of Location """ owner = models.ManyToManyField(Player) """ Owner of Location """ @property def position(self): """ Formatted position of the location """ return "(x={}, z={})".format(self.x_coord, self.z_coord) @property def tunnel(self): """ The tunnel associated if this location, None if no tunnel exists """ try: tunnel = Tunnel.objects.get(location=self) except Tunnel.DoesNotExist: tunnel = None return tunnel @property def get_owners(self): """ List of all the owners of the location """ owner_list = [] for owner in self.owner.all(): owner_list.append(owner.json) return owner_list @property def json(self): """ JSON representation of the location .. code-block:: json { "type": "Base", "name": "Location", "x_coord": 0, "z_coord": 0, "dimension": "O", "owner": [], "tunnel": {}, "link": "/GeoffreyApp/Base/1" } """ return {"type": self.loc_type, "name": self.name, "x_coord": self.x_coord, "z_coord": self.z_coord, "dimension": self.dimension, "owner": self.get_owners, "location": self.position, "tunnel": None if self.tunnel is None else self.tunnel.tunnel_str, "link": self.link } @property def loc_type(self): """ The name of the location type """ str = self.loc_child_obj.__class__.__name__ return str @property def link(self): """ href to the location page """ child = self.loc_child_obj if child is not self: return reverse(child.info_page, kwargs={"id": child.id}) else: return reverse(self.info_page, kwargs={"id": self.id}) @property def loc_child_obj(self): """ Child object """ if hasattr(self, "shop"): return self.shop elif hasattr(self, "base"): return self.base elif hasattr(self, "town"): return self.town elif hasattr(self, "publicfarm"): return self.publicfarm elif hasattr(self, "market"): return self.market else: return self @property def dynmap_url(self): """ Link to the location on the dynmap, none if there is no dynmap """ base_url = getattr(settings, "GEOFFREY_DYNMAP_BASE_URL") world_name = getattr(settings, "GEOFFREY_DYNMAP_WORLD_NAME") if base_url is not None: url = base_url + "/?worldname={}&mapname=surface&zoom=4&x={}&y=65&z={}".format(world_name, self.x_coord, self.z_coord) return url else: return None def __str__(self): return "%s: %s" % (self.loc_child_obj.__class__.__name__, self.name) class PointOfInterest(Location): info_page = "GeoffreyPointOfInterest" class Shop(Location): info_page = "GeoffreyShopInfo" class Base(Location): info_page = "GeoffreyBaseInfo" class Town(Location): info_page = "GeoffreyTownInfo" residents = models.ManyToManyField(Player) """ Players who are members of the town """ @property def get_residents(self): """ List of residents in the town in JSON farm """ residents = self.residents.all() return objects_list_to_json(residents) @property def json(self): """ JSON representation of the town .. code-block:: json { "type": "Town", "name": "Location", "x_coord": 0, "z_coord": 0, "dimension": "O", "owner": [], "tunnel": {}, "link": "/GeoffreyApp/Town/1", "residents": [] } """ json = super().json json["residents"] = self.get_residents return json class Market(Location): info_page = "GeoffreyMarketInfo" def get_shops(self, market_radius=100, limit=10): x = int(self.x_coord) z = int(self.z_coord) shops = Shop.objects.filter(x_coord__range=(x - market_radius, x + market_radius), z_coord__range=(z - market_radius, z + market_radius) )[:limit] return shops @property def json(self): """ JSON representation of the market .. code-block:: json { "type": "Town", "name": "Location", "x_coord": 0, "z_coord": 0, "dimension": "O", "owner": [], "tunnel": {}, "link": "/GeoffreyApp/Market/1", "shops": [] } """ json = super().json json["shops"] = objects_list_to_json(self.get_shops(limit=10)) return json class PublicFarm(Location): info_page = "GeoffreyPublicFarmInfo" class Resource(models.Model): farm = models.ForeignKey(PublicFarm, related_name="resource", on_delete=models.CASCADE) resource_name = models.CharField(max_length=128) @property def json(self): """ JSON representation of the town .. code-block:: json { "name": "Dirt" "farm_id": 1 } """ return {"name": self.resource_name, "farm_id": self.farm_id } class ItemListing(models.Model): item_name = models.CharField(max_length=128) """ Name of the item """ price = models.IntegerField() """ Number of diamonds per amount of items """ amount = models.IntegerField() """ Number of items """ date_restocked = models.DateTimeField(auto_now=True) """ Datetime the item was last restocked """ shop = models.ForeignKey(Shop, related_name="shop_selling", on_delete=models.CASCADE) """ Shop the item is sold at """ @property def normalized_price(self): """ normalized price, price/amount """ if self.amount == 0: return maxsize else: return self.price / self.amount @property def json(self): """ JSON representation of the item .. code-block:: json { "item_name": "dirt", "price": 1, "amount": 1, "date_restocked": 1553264508, "normalized_price": 1, "shop": {} } """ return {"item_name": self.item_name, "price": self.price, "amount": self.amount, "date_restocked": self.date_restocked.timestamp(), "normalized_price": self.normalized_price, "shop": self.shop.json, } def __str__(self): return "Item: %d %s for %d" % (self.amount, self.item_name, self.amount) class Tunnel(models.Model): TUNNEL_NAMES = ( ('N', getattr(settings, 'GEOFFREY_NORTH_TUNNEL', '')), ('E', getattr(settings, 'GEOFFREY_EAST_TUNNEL', '')), ('S', getattr(settings, 'GEOFFREY_SOUTH_TUNNEL', '')), ('W', getattr(settings, 'GEOFFREY_WEST_TUNNEL', '')) ) """ Tunnel Direction """ tunnel_number = models.IntegerField() """ Tunnel coordinate """ tunnel_direction = models.CharField(max_length=1, choices=TUNNEL_NAMES) """ Tunnel Direction """ location = models.ForeignKey(Location, related_name="tunnel_location", on_delete=models.CASCADE) """ Location that the tunnel is connected to """ def __str__(self): return "Tunnel: %s %d" % (self.get_tunnel_direction_display(), self.tunnel_number) @property def json(self): """ JSON representation of the tunnel` .. code-block:: json { "location_name": "Base", "tunnel_direction": "N", "tunnel_number": 500 } """ return {"location_name": self.location.name, "tunnel_direction": self.get_tunnel_direction_display(), "tunnel_number": self.tunnel_number } @property def tunnel_str(self): """ formatted tunnel string """ return "{} {}".format(self.get_tunnel_direction_display(), self.tunnel_number)