Example #1
0
    def post(self, request, *args, **kwargs):
        c = Card()
        c.name = request.data.get('name')
        c.spell_type = request.data.get('spell_type')
        c.expansion = request.data.get('expansion')
        c.is_legendary = request.data.get('is_legendary') is 'true'
        c.card_number = request.data.get('card_number')
        c.creature_type = request.data.get('creature_type')
        c.abilities = request.data.get('abilities')
        c.text = request.data.get('text')
        c.flavor_text = request.data.get('flavor_text')
        c.power = request.data.get('power')
        c.defense = request.data.get('defense')
        c.loyalty = request.data.get('loyalty')
        c.artist = request.data.get('artist')
        c.save()
        c.image = request.data.get('file')
        for k, v in request.data.items():
            if k.startswith('mana_'):

                m = Mana.objects.get(name=k[5:])
                mfc = ManaForCard()
                mfc.mana = m
                mfc.card = c
                mfc.quantity = v
                mfc.save()
        c.save()
        return Response(self.serializer_class(c).data)
Example #2
0
def create_test_card(fields: Optional[Dict[str, Any]] = None) -> Card:
    """
    Creates a test card with fields from the given dict
    :param fields: The fields to populate
    :return: A card object
    """
    card = Card()
    card.scryfall_oracle_id = uuid.uuid4()
    card.name = uuid.uuid1()
    card.cmc = 0
    card.num_power = 0
    card.num_toughness = 0
    card.num_loyalty = 0
    card.colour_flags = 0
    card.colour_identity_flags = 0
    card.colour_count = 0
    card.colour_identity_count = 0
    card.colour_sort_key = 0
    card.colour_weight = 0
    card.layout = "normal"
    card.is_reserved = False
    card.is_token = False
    card.converted_mana_cost = 0

    for key, value in (fields or {}).items():
        assert hasattr(card, key)
        setattr(card, key, value)

    card.full_clean()
    card.save()
    return card
Example #3
0
def create_test_card(fields: dict) -> Card:
    """
    Creates a test card with fields from the given dict
    :param fields: The fields to populate
    :return: A card object
    """
    card = Card()
    card.name = 'undefined'
    card.cmc = 0
    card.num_power = 0
    card.num_toughness = 0
    card.num_loyalty = 0
    card.colour_count = 0
    card.colour_sort_key = 0
    card.colour_weight = 0
    card.is_reserved = False

    for key, value in fields.items():
        card.__dict__[key] = value

    card.save()
    return card
Example #4
0
    def handle(self, **options):
        # Mandatory set
        if options['set'] is None:
            print("set argument is missing!")
            sys.exit()

        # set must be valid
        if len(options['set']) != 3:
            print("set is not valid, must be 3 digit")
            sys.exit()

        lang = options['lang'].lower() if len(options['lang']) == 2 else "en"
        set = options['set'].lower()

        with open("data/sets/" + lang + "/" + set + ".json") as f:
            cards = json.load(f)

            counter = 1
            for single_card in cards:
                card = Card.objects.filter(
                    scryfall_id=single_card['id']).first()

                if card is None:
                    card = Card(
                        language=lang,
                        set=set,
                        layout=single_card['layout'],
                        rarity=single_card['rarity'],
                        multiverse_id=single_card['multiverse_ids'].pop(0)
                        if len(single_card['multiverse_ids']) > 0 else "",
                        scryfall_id=single_card['id'],
                        collector_number=single_card['collector_number'],
                    )
                    print(
                        str(counter) + "/" + str(len(cards)) +
                        " New card from " + set + " (" + lang + ") : " +
                        single_card['layout'])  # nopep8

                    faces = []
                    types = []
                    if single_card['layout'] == "normal":
                        # NORMAL layout : 1 Face, 1 Type
                        card.name = single_card[
                            'printed_name'] if "printed_name" in single_card else single_card[
                                'name']

                        face = Face(
                            card=card,
                            illustration_id=single_card['illustration_id'])
                        face.descriptors = get_image_descriptions(
                            single_card['image_uris']['large'])  # nopep8
                        faces.append(face)

                        type = Type(
                            # Only get the card type (ex: Creature — Human Rogue)
                            type=single_card['type_line'].split(" — ").pop(0),
                            face=face,
                        )
                        types.append(type)
                    elif single_card['layout'] == "modal_dfc":
                        # MODAL DOUBLE FACE : 2 Faces, 2 Types
                        for single_face in single_card["card_faces"]:
                            face = Face(
                                card=card,
                                illustration_id=single_face["illustration_id"],
                                name=single_face['printed_name']
                                if "printed_name" in single_face else
                                single_face['name'])
                            face.descriptors = get_image_descriptions(
                                single_face['image_uris']['large'])  # nopep8
                            faces.append(face)

                            if card.name != "":
                                card.name = card.name + " // "

                            card.name = card.name + face.name

                            type = Type(
                                # Only get the card type (ex: Creature — Human Rogue)
                                type=single_face['type_line'].split(" — ").pop(
                                    0),
                                face=face,
                            )
                            types.append(type)

                    if len(faces) > 0 and len(types) > 0:
                        card.save()
                        for face in faces:
                            face.save()
                        for type in types:
                            type.save()