class ItemResourceWorldListViewSet(NestedViewSetMixin, BoundlexxListViewSet):
serializer_class = URLSimpleWorldSerializer
def get_queryset(self):
item_id = self.kwargs.get("item__game_id")
if item_id not in settings.BOUNDLESS_WORLD_POLL_RESOURCE_MAPPING:
raise Http404
queryset = World.objects.all()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(is_public=True)
if item_id is not None:
queryset = queryset.filter(
worldpoll__resourcecount__item__game_id=item_id).distinct("id")
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of worlds that has this resource on item
timeseries lookup
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(ITEM_RESOURCES_WORLD_LIST_EXAMPLE)
}
} # type: ignore # noqa E501
list.operation_id = "listItemResourceWorlds" # type: ignore # noqa E501
class EmojiViewSet(BoundlexxReadOnlyViewSet):
queryset = Emoji.objects.filter(
active=True).prefetch_related("emojialtname_set")
serializer_class = URLEmojiSerializer
lookup_field = "name"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = EmojiFilterSet
search_fields = ["name", "emojialtname__name"]
ordering = ["-rank", "name"]
ordering_fields: list[str] = []
def get_object(self):
queryset = self.filter_queryset(self.get_queryset())
lookup_name = self.kwargs[self.lookup_field]
obj = get_object_or_404(
queryset,
Q(name=lookup_name) | Q(emojialtname__name=lookup_name))
# May raise a permission denied
self.check_object_permissions(self.request, obj)
return obj
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of emojis from the game Boundless.
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(EMOJI_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves an emojis from the game Boundless.
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": EMOJI_EXAMPLE
}
} # type: ignore # noqa E501
class ItemResourceTimeseriesViewSet(TimeseriesMixin, NestedViewSetMixin,
BoundlexxReadOnlyViewSet):
schema = DescriptiveAutoSchema(tags=["items", "timeseries"])
queryset = ResourceCount.objects.filter(
world_poll__world__active=True,
world_poll__world__is_creative=False,
).select_related("world_poll", "world_poll__world", "item",
"item__resource_data")
serializer_class = URLItemResourceCountTimeSeriesSerializer
time_bucket_serializer_class = ItemResourceCountTimeSeriesTBSerializer
number_fields = ["count"]
lookup_field = "id"
def get_queryset(self):
item_id = self.kwargs.get("id")
if item_id not in settings.BOUNDLESS_WORLD_POLL_RESOURCE_MAPPING:
raise Http404
queryset = super().get_queryset()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(world_poll__world__is_public=True)
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list resource counts for a give item/world combination
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(ITEM_RESOURCE_TIMESERIES_EXAMPLE)
}
} # type: ignore # noqa E501
list.operation_id = "listItemResourceTimeseries" # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a specific resource counts for a give item/world combination
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": ITEM_RESOURCE_TIMESERIES_EXAMPLE
}
} # type: ignore # noqa E501
retrieve.operation_id = "retrieveItemResourceTimeseries" # type: ignore # noqa E501
class SkillViewSet(BoundlexxReadOnlyViewSet):
queryset = (Skill.objects.all().select_related(
"group", "description",
"display_name").prefetch_related("description__strings",
"display_name__strings"))
serializer_class = URLSkillSerializer
lookup_field = "id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = SkillFilterSet
ordering = ["-rank", "id"]
ordering_fields: list[str] = []
search_fields = [
"name",
"description__strings__text",
"display_name__strings__text",
]
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of skills avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(SKILL_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a skill with a given id
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": SKILL_EXAMPLE
}
} # type: ignore # noqa E501
class RecipeViewSet(BoundlexxReadOnlyViewSet):
queryset = (Recipe.objects.all().select_related("output").prefetch_related(
"requirements",
"tints",
"levels",
"levels__inputs",
"levels__inputs__group",
"levels__inputs__item",
"requirements__skill",
))
serializer_class = URLRecipeSerializer
lookup_field = "id"
filter_backends = [
DjangoFilterBackend,
]
filterset_class = RecipeFilterSet
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of recipes avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(RECIPE_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a recipe with a given id
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": RECIPE_EXAMPLE
}
} # type: ignore # noqa E501
class MetalViewSet(BoundlexxReadOnlyViewSet):
queryset = Metal.objects.filter(
active=True).prefetch_related("localizedname_set")
serializer_class = URLMetalSerializer
lookup_field = "game_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = LocalizationFilterSet
search_fields = ["localizedname__name", "game_id"]
ordering = ["-rank", "game_id"]
ordering_fields: list[str] = []
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of metals avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(METAL_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a metal with a given ID
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": METAL_EXAMPLE
}
} # type: ignore # noqa E501
class RecipeGroupViewSet(BoundlexxReadOnlyViewSet):
schema = DescriptiveAutoSchema(tags=["recipes"])
queryset = (RecipeGroup.objects.all().select_related(
"display_name").prefetch_related("members", "display_name__strings"))
serializer_class = URLRecipeGroupSerializer
lookup_field = "id"
filter_backends = [
DjangoFilterBackend,
]
filterset_class = LocalizationFilterSet
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of skill groups avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(RECIPE_GROUP_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a skill group with a given id
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": RECIPE_GROUP_EXAMPLE
}
} # type: ignore # noqa E501
class WorldViewSet(BoundlexxReadOnlyViewSet):
queryset = World.objects.all()
serializer_class = KindOfSimpleWorldSerializer
detail_serializer_class = URLWorldSerializer
lookup_field = "id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = WorldFilterSet
ordering = ["-rank", "id"]
ordering_fields: list[str] = ["sort_name", "start", "end"]
search_fields = [
"name",
"id",
"text_name",
]
def get_queryset(self):
queryset = super().get_queryset()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(is_public=True)
# only get all relations on detail view
if self.detail:
queryset = queryset.select_related("assignment").prefetch_related(
"worldblockcolor_set",
"worldblockcolor_set__item",
"worldblockcolor_set__color",
"worldblockcolor_set__first_world",
"worldblockcolor_set__last_exo",
"worldblockcolor_set__transform_first_world",
"worldblockcolor_set__transform_last_exo",
"itembuyrank_set",
"itemsellrank_set",
)
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of worlds avaiable in Boundless.
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(examples.WORLD_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a worlds with a given id
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": examples.WORLD_EXAMPLE
}
} # type: ignore # noqa E501
@action(
detail=False,
methods=["get"],
serializer_class=KindOfSimpleWorldSerializer,
url_path="simple",
)
def simple(self, request, *args, **kwargs):
"""
Migration/simplication of endpoint has been completeled.
This endpoint is deprecated as it is a copy of `/api/v1/worlds/`.
The functionality of this endpoint will be replaced with that one in the
on 1 May 2020.
"""
return self.list(request, *args, **kwargs)
simple.operation_id = "listWorldsSimple"
simple.deprecated = True
@action(
detail=True,
methods=["get"],
serializer_class=WorldBlockColorsViewSerializer,
url_path="block-colors",
)
def block_colors(
self,
request,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Retrieves the block colors for a given world
"""
world = self.get_object()
show_inactive_colors = request.query_params.get(
"show_inactive_colors", False)
is_default = request.query_params.get("is_default", None)
all_block_colors = list(world.worldblockcolor_set.all())
block_colors = []
for bc in all_block_colors:
if is_default is not None:
if is_default and not bc.is_default:
continue
if not is_default and bc.is_default:
continue
if show_inactive_colors or bc.active:
block_colors.append(bc)
response = BlockColorResponse(world.id, block_colors)
serializer = self.get_serializer_class()(response,
context={
"request": request
})
return Response(serializer.data)
block_colors.example = {
"block_colors": {
"value": examples.WORLD_COLORS_EXAMPLE
}
}
block_colors.operation_id = "listWorldBlockColors"
@action(
detail=True,
methods=["get"],
serializer_class=URLWorldShopStandPriceSerializer,
url_path="shop-stands",
)
def shop_stands(
self,
request,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Gets current Shop Stands for given world
"""
world = self.get_object()
queryset = (ItemShopStandPrice.objects.filter(
world=world,
active=True).select_related("item").order_by("item_id", "price"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
shop_stands.example = {
"shop_stands": {
"value": get_list_example(examples.WORLD_SHOP_STANDS_EXAMPLE)
}
}
shop_stands.operation_id = "listWorldShopStands"
@action(
detail=True,
methods=["get"],
serializer_class=URLWorldRequestBasketPriceSerializer,
url_path="request-baskets",
)
def request_baskets(
self,
request,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Gets current Request Baskets for given world
"""
world = self.get_object()
queryset = (ItemRequestBasketPrice.objects.filter(
world=world,
active=True).select_related("item").order_by("item_id", "-price"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
request_baskets.example = {
"request_baskets": {
"value": get_list_example(examples.WORLD_REQUEST_BASKETS_EXAMPLE)
}
}
request_baskets.operation_id = "listWorldRequestBaskets"
@action(
detail=True,
methods=["get"],
serializer_class=BeaconSerializer,
url_path="beacons",
)
def beacons(
self,
request,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Gets current Beacons for given world
"""
world = self.get_object()
queryset = (Beacon.objects.filter(world=world,
active=True).prefetch_related(
"beaconscan_set",
"beaconplotcolumn_set").order_by(
"location_x", "location_y",
"location_z"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
beacons.operation_id = "listWorldBeacons"
@action(
detail=True,
methods=["get"],
serializer_class=SettlementSerializer,
url_path="settlements",
)
def settlements(
self,
request,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Gets current Settlements for given world
"""
world = self.get_object()
queryset = Settlement.objects.filter(world=world).order_by(
"-prestige", "location_x", "location_z")
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
settlements.operation_id = "listWorldSettlements"
class WorldDistanceViewSet(NestedViewSetMixin, BoundlexxReadOnlyViewSet):
queryset = (WorldDistance.objects.filter(
world_source__active=True, world_dest__active=True).select_related(
"world_source", "world_dest").order_by("distance"))
serializer_class = URLWorldDistanceSerializer
lookup_field = "world_id"
def get_object(self):
queryset = self.filter_queryset(self.get_queryset())
lookup_field = self.lookup_url_kwarg or self.lookup_field
world_id = self.kwargs[lookup_field]
source_world_id = self.kwargs.get("world_source__id", None)
if world_id == source_world_id:
queryset = queryset.filter(world_source__id=world_id,
world_dest__id=world_id)
else:
queryset = queryset.filter(
Q(world_source__id=world_id) | Q(world_dest__id=world_id))
if queryset.count() > 1:
logger.warning(
"Duplicate World Distance calculations! %s %s",
world_id,
source_world_id,
)
obj = queryset.first()
if obj is None:
raise Http404
# May raise a permission denied
self.check_object_permissions(self.request, obj)
return obj
def filter_queryset_by_parents_lookups(self, queryset):
parents_query_dict = self.get_parents_query_dict()
world_id = parents_query_dict.pop("world_source__id", None)
if world_id:
try:
return queryset.filter(
Q(world_source__id=world_id) | Q(world_dest__id=world_id))
except ValueError as ex:
raise Http404 from ex
else:
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of distances to know worlds
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(examples.WORLD_DISTANCES_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves the distance to a specific world
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": examples.WORLD_DISTANCES_EXAMPLE
}
} # type: ignore # noqa E501
class ColorViewSet(BoundlexxReadOnlyViewSet):
queryset = Color.objects.filter(active=True).prefetch_related(
"localizedname_set", "colorvalue_set"
)
serializer_class = URLColorSerializer
lookup_field = "game_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = ColorFilterSet
search_fields = ["localizedname__name", "game_id"]
ordering = ["-rank", "game_id"]
ordering_fields: list[str] = []
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of colors avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {"list": {"value": get_list_example(COLOR_EXAMPLE)}} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a color with a given ID
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {"retrieve": {"value": COLOR_EXAMPLE}} # type: ignore # noqa E501
@action(
detail=True,
methods=["get"],
serializer_class=PossibleItemSerializer,
url_path="sovereign-blocks",
)
def sovereign_blocks(
self,
request,
game_id=None,
):
"""
Gets current Possible Sovereign Blocks choices for given color
"""
color = self.get_object()
queryset = (
WorldBlockColor.objects.filter(color=color, is_default=True)
.filter(
Q(world__isnull=True)
| Q(world__end__isnull=True, world__is_creative=False)
| Q(world__owner__isnull=False, world__is_creative=False)
)
.select_related("item")
.order_by("item__game_id")
.distinct("item__game_id")
)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
sovereign_blocks.operation_id = "listColorSovereignBlocks" # noqa E501
class BlockColorViewSet(
NestedViewSetMixin,
BoundlexxReadOnlyViewSet,
):
schema = DescriptiveAutoSchema()
queryset = (
WorldBlockColor.objects.filter(world__is_creative=False)
.select_related(
"item",
"world",
"item__item_subtitle",
)
.prefetch_related(
"item__localizedname_set",
"item__item_subtitle__localizedname_set",
)
)
serializer_class = URLBlockColorSerializer
lookup_field = "item__game_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = WorldBlockColorFilterSet
search_fields = [
"item__string_id",
"item__item_subtitle__localizedname__name",
"item__localizedname__name",
"world__name",
"world__display_name",
]
ordering = ["-rank", "item__game_id", "color__game_id"]
ordering_fields: list[str] = []
def get_queryset(self):
queryset = super().get_queryset()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(world__is_public=True)
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of the items for a given color
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {"list": {"value": get_list_example(COLOR_BLOCKS_EXAMPLE)}} # type: ignore # noqa E501
list.operation_id = "listColorBlocks" # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves the counts worlds for a given color/item combination
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {"list": {"value": get_list_example(COLOR_BLOCKS_EXAMPLE)}} # type: ignore # noqa E501
retrieve.operation_id = "retrieveColorBlock" # type: ignore # noqa E501
class ItemColorsViewSet(
NestedViewSetMixin,
BoundlexxReadOnlyViewSet,
):
queryset = (WorldBlockColor.objects.filter(
world__is_creative=False, ).select_related(
"color",
"world",
"item",
).prefetch_related("color__localizedname_set"))
lookup_field = "color__game_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = ItemColorFilterSet
search_fields = [
"color__localizedname__name",
]
ordering = ["-rank", "color__game_id", "world_id"]
ordering_fields: list[str] = []
serializer_class = URLItemColorSerializer
detail_serializer_class = URLWorldColorSerializer
def get_queryset(self):
queryset = super().get_queryset()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(world__is_public=True)
if self.action == "list":
queryset = queryset.distinct("rank", "color__game_id")
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of colors for a given item
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(ITEM_COLORS_EXAMPLE)
}
} # type: ignore # noqa E501
list.operation_id = "listItemColors" # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves the list worlds for specific color/item combination
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"list": {
"value": get_list_example(ITEM_COLORS_EXAMPLE)
}
} # type: ignore # noqa E501
retrieve.operation_id = "retrieveItemColors" # type: ignore # noqa E501
class ItemResourceCountViewSet(
NestedViewSetMixin,
BoundlexxReadOnlyViewSet,
):
queryset = ResourceCount.objects.filter(
world_poll__active=True,
world_poll__world__active=True,
world_poll__world__is_creative=False,
).select_related("world_poll", "world_poll__world", "item",
"item__resource_data")
serializer_class = URLItemResourceCountSerializer
lookup_field = "world_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = ItemResourceCountFilterSet
search_fields = [
"world_poll__world__display_name",
"world_poll__world__name",
]
ordering = ["-rank", "world_poll__world_id", "-count"]
ordering_fields: list[str] = [
"count",
"average_per_chunk",
"percentage",
]
def get_queryset(self):
queryset = super().get_queryset()
if not self.request.user.has_perm("boundless.can_view_private"):
queryset = queryset.filter(world_poll__world__is_public=True)
return queryset
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of the counts of the resource by world.
This endpoint will only exist if the given item is a "resource"
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(ITEM_RESOURCE_COUNT_EXAMPLE)
}
} # type: ignore # noqa E501
list.operation_id = "listItemResourceCounts" # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves the counts of the resource on a given world.
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": ITEM_RESOURCE_COUNT_EXAMPLE
}
} # type: ignore # noqa E501
retrieve.operation_id = "retrieveItemResourceCount" # type: ignore # noqa E501
def get_object(self):
queryset = self.filter_queryset(self.get_queryset())
obj = get_object_or_404(
queryset, world_poll__world_id=self.kwargs[self.lookup_field])
# May raise a permission denied
self.check_object_permissions(self.request, obj)
return obj
def get_parents_query_dict(self):
kwargs = super().get_parents_query_dict()
kwargs.pop(self.lookup_field, None)
if "item__game_id" in kwargs:
try:
game_id = int(kwargs["item__game_id"])
except ValueError:
pass
else:
if game_id not in settings.BOUNDLESS_WORLD_POLL_RESOURCE_MAPPING:
raise Http404()
return kwargs
class ItemViewSet(
BoundlexxReadOnlyViewSet, ):
queryset = (Item.objects.filter(active=True).select_related(
"item_subtitle", "list_type", "description").prefetch_related(
"localizedname_set",
"item_subtitle__localizedname_set",
"worldblockcolor_set",
"itembuyrank_set",
"itemsellrank_set",
"list_type__strings",
"description__strings",
))
serializer_class = URLItemSerializer
lookup_field = "game_id"
filter_backends = [
DjangoFilterBackend,
RankedFuzzySearchFilter,
filters.OrderingFilter,
DedupedFilter,
]
filterset_class = ItemFilterSet
search_fields = ["string_id", "localizedname__name", "game_id"]
ordering = ["-rank", "game_id"]
ordering_fields: list[str] = []
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list of items avaiable in Boundless
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(ITEM_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a items with a given ID.
If a `resource_counts_url` is provided, it means this item is
a "resource" in Boundless. `resource_counts_url` provide most
resource counts of the item on all Boundless worlds.
If `has_color` for an image is true and there is an `image_url`, you can
replace the file name from `{item.game_id}.png` to
`{item.game_id}_{color.game_id}.png` to get an image for a specific color.
The color for the default image is based on the `default_color` property.
`has_metal_variants` is the same thing, but for the 5 different types of
metals.
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": ITEM_EXAMPLE
}
} # type: ignore # noqa E501
@action(
detail=True,
methods=["get"],
serializer_class=URLItemShopStandPriceSerializer,
url_path="shop-stands",
)
def shop_stands(
self,
request,
game_id=None,
):
"""
Gets current Shop Stands for given item
"""
item = self.get_object()
queryset = (ItemShopStandPrice.objects.filter(
item=item, active=True).select_related("world").order_by("price"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
shop_stands.example = {
"shop_stands": {
"value": get_list_example(ITEM_SHOP_STAND_EXAMPLE)
}
}
shop_stands.operation_id = "listItemShopStands" # noqa E501
@action(
detail=True,
methods=["get"],
serializer_class=URLItemRequestBasketPriceSerializer,
url_path="request-baskets",
)
def request_baskets(
self,
request,
game_id=None,
):
"""
Gets current Request Baskets for given item
"""
item = self.get_object()
queryset = (ItemRequestBasketPrice.objects.filter(
item=item, active=True).select_related("world").order_by("-price"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
request_baskets.example = {
"request_baskets": {
"value": get_list_example(ITEM_REQUEST_BASKETS_EXAMPLE)
}
}
request_baskets.operation_id = "listItemRequestBaskets" # noqa E501
@action(
detail=True,
methods=["get"],
serializer_class=PossibleColorSerializer,
url_path="sovereign-colors",
)
def sovereign_colors(
self,
request,
game_id=None,
):
"""
Gets current Possible Sovereign Color choices for given item
"""
item = self.get_object()
queryset = (WorldBlockColor.objects.filter(
item=item, is_default=True).filter(
Q(world__isnull=True)
| Q(world__end__isnull=True, world__is_creative=False)
| Q(world__owner__isnull=False, world__is_creative=False)
).select_related("color").order_by("color__game_id").distinct(
"color__game_id"))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
sovereign_colors.example = {
"sovereign_colors": {
"value": get_list_example(ITEM_SOVEREIGN_COLORS_EXAMPLE)
}
}
sovereign_colors.operation_id = "listItemSovereignColors" # noqa E501
class WorldPollViewSet(TimeseriesMixin, NestedViewSetMixin,
BoundlexxReadOnlyViewSet):
schema = DescriptiveAutoSchema(tags=["worlds", "timeseries"])
queryset = (
WorldPoll.objects.all().select_related("world").prefetch_related(
"worldpollresult_set",
"leaderboardrecord_set",
"resourcecount_set",
"resourcecount_set__item",
))
serializer_class = URLWorldPollSerializer
time_bucket_serializer_class = WorldPollTBSerializer
number_fields = [
"worldpollresult__player_count",
"worldpollresult__beacon_count",
"worldpollresult__plot_count",
"worldpollresult__total_prestige",
]
lookup_field = "id"
def list(self, request, *args, **kwargs): # noqa A003
"""
Retrieves the list polls avaiable for give World
"""
return super().list(request, *args, **kwargs) # pylint: disable=no-member
list.example = {
"list": {
"value": get_list_example(wexamples.WORLD_POLL_EXAMPLE)
}
} # type: ignore # noqa E501
def retrieve(
self,
request,
*args,
**kwargs,
): # pylint: disable=arguments-differ
"""
Retrieves a specific poll for a given world
Can pass `latest` or `initial` in place of `id` to retrieve the
newest or first one
"""
return super().retrieve(request, *args, **kwargs) # pylint: disable=no-member
retrieve.example = {
"retrieve": {
"value": wexamples.WORLD_POLL_EXAMPLE
}
} # type: ignore # noqa E501
@action(
detail=True,
methods=["get"],
serializer_class=URLWorldPollLeaderboardSerializer,
)
def leaderboard(
self,
request,
world_id=None,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Retrieves the leaderboard for a given world poll result
"""
world_poll = self.get_object()
serializer = self.get_serializer_class()(world_poll,
context={
"request": request
})
return Response(serializer.data)
leaderboard.example = {
"leaderboard": {
"value": wexamples.WORLD_POLL_LEADERBOARD_EXAMPLE
}
}
leaderboard.operation_id = "listWorldPollLeaderboards"
@action(
detail=True,
methods=["get"],
serializer_class=URLWorldPollResourcesSerializer,
)
def resources(
self,
request,
world_id=None,
id=None, # pylint: disable=redefined-builtin # noqa A002
):
"""
Retrieves the count of resources for a given world poll result
"""
world_poll = self.get_object()
serializer = self.get_serializer_class()(world_poll,
context={
"request": request
})
return Response(serializer.data)
resources.example = {
"resources": {
"value": wexamples.WORLD_POLL_RESOURCES_EXAMPLE
}
}
resources.operation_id = "listWorldPollResources"
