def instance_entities(data):
"""
Given a kind and some json, call insert on that kind
and return the results.
A little safer.
"""
fields = ('id', 'created', 'modified',
'entity_id', 'previous_id', 'status', 'available')
entities = []
if 'cards' in data:
for card_data in data['cards']:
kind = card_data.get('kind')
if kind in card_map:
entities.push(
card_map[kind](omit(card_data, fields))
)
if 'units' in data:
entities = entities + [
Unit(omit(unit_data, fields))
for unit_data in data['units']
]
if 'sets' in data:
entities = entities + [
Set(omit(set_data, fields))
for set_data in data['sets']
]
return entities
def get_card_info_from_name(self, name):
try:
print(f'Getting card info from name: {name}')
name = name.replace(' ', '%20')
url = f'https://db.ygoprodeck.com/api/v6/cardinfo.php?fname={name}'
results = requests.get(url=url)
card_info = json.loads(results.content)
card_sets = []
if not 'No card matching your query was found in the database' in str(card_info):
for card_set in card_info:
sets = []
if 'card_sets' in str(card_set):
cs = card_set['card_sets']
for s in cs:
if len(sets) == 0:
sets.append(Set(set_name=s['set_name'],
set_code=s['set_code']).get_dict_sets())
else:
item_found = False
for ss in sets:
if s['set_code'] == ss['set_code']:
item_found = True
break
if not item_found:
sets.append(Set(set_name=s['set_name'],
set_code=s['set_code']).get_dict_sets())
sets = sorted(sets, key=lambda k:(len(k['set_code']), k['set_code']))
card_sets.append(CardSets(card_name=card_set['name'],
image=card_set['card_images'][0]['image_url_small'],
sets=sets).get_dict_card_sets())
print(f'Card sets: {card_sets}')
return card_sets
except Exception as e:
print(f'TCGP - Occurred the following error trying to get card sets from name: {e}')
raise Exception(e)
def instance(data):
"""
Given a kind and some json, call insert on that kind
and return the results.
"""
if 'card' in data:
return Card(data['card'])
# TODO-1 This needs to also get the right card kind...
elif 'unit' in data:
return Unit(data['unit'])
elif 'set' in data:
return Set(data['set'])
def instance_new_entity(data):
"""
Save as above, but a little safer.
"""
fields = ('id', 'created', 'modified', 'entity_id', 'previous_id',
'status', 'available')
if 'card' in data:
return Card(omit(data['card'], fields))
# TODO-1 This needs to also get the right card kind...
elif 'unit' in data:
return Unit(omit(data['unit'], fields))
elif 'set' in data:
return Set(omit(data['set'], fields))
def create_or_get_set(self, next=True):
"""return current set, create next set automatically if next=True"""
if self.current_set_number:
# current set is on going
return self.sets[self.current_set_number]
elif next:
# get next set number
self.current_set_number = max(
self.sets.keys()) + 1 if self.sets else 1
is_deciding_set = self.current_set_number == self._best_of
self.sets[self.current_set_number] = Set(self,
self.current_set_number,
is_deciding_set)
return self.sets[self.current_set_number]
else:
return None
def instance_new_entity(data):
"""
Given a kind and some json, call insert on that kind
and return the results.
A little safer.
"""
fields = ('id', 'created', 'modified', 'entity_id', 'previous_id',
'status', 'available')
if 'card' in data:
kind = data['card'].get('kind')
if kind in card_map:
return card_map[kind](omit(data['card'], fields))
elif 'unit' in data:
return Unit(omit(data['unit'], fields))
elif 'set' in data:
return Set(omit(data['set'], fields))
def respond_to_card_route(request, card_id):
"""
Record and process a learner's response to a card.
NEXT STATE
POST Respond Card
-> GET Learn Card ...when not ready
-> GET Choose Unit ...when ready, but still units
-> GET View Set Tree ...when ready and done
"""
# TODO-3 simplify this method.
# perhaps smaller methods or move to model layer?
current_user = get_current_user(request)
if not current_user:
return abort(401)
card = get_card_by_kind(card_id)
if not card:
return abort(404)
# Make sure the card is the current one
context = current_user.get_learning_context()
if context.get('card', {}).get('entity_id') != card['entity_id']:
return abort(400)
r = seq_update(current_user, card, request['params'].get('response'))
errors, response, feedback = (r.get('errors'), r.get('response'),
r.get('feedback'))
if errors:
return 400, {
'errors': errors,
'ref': 'wtyOJPoy4bh76OIbYp8mS3LP',
}
set_ = Set(context.get('set'))
unit = Unit(context.get('unit'))
status = judge(unit, current_user)
# If we are done with this current unit...
if status == "done":
buckets = traverse(current_user, set_)
# If there are units to be diagnosed...
if buckets['diagnose']:
unit = buckets['diagnose'][0]
next_card = choose_card(current_user, unit)
next_ = {
'method':
'GET',
'path':
'/s/cards/{card_id}/learn'.format(
card_id=next_card['entity_id']),
}
current_user.set_learning_context(card=next_card.data,
unit=unit.data,
next=next_)
# If there are units to be learned or reviewed...
elif buckets['learn'] or buckets['review']:
next_ = {
'method': 'GET',
'path':
'/s/sets/{set_id}/units'.format(set_id=set_['entity_id']),
}
current_user.set_learning_context(card=None, unit=None, next=next_)
# If we are out of units...
else:
next_ = {
'method': 'GET',
'path':
'/s/sets/{set_id}/tree'.format(set_id=set_['entity_id']),
}
current_user.set_learning_context(card=None, unit=None, next=next_)
# If we are still reviewing, learning or diagnosing this unit...
else:
next_card = choose_card(current_user, unit)
if next_card:
next_ = {
'method':
'GET',
'path':
'/s/cards/{card_id}/learn'.format(
card_id=next_card['entity_id']),
}
current_user.set_learning_context(card=next_card.data, next=next_)
else:
next_ = {}
current_user.set_learning_context(next=next_)
return 200, {
'response': response.deliver(),
'feedback': feedback,
'next': next_,
}
