def post(self): cid = self.get_argument('cid') root = self.get_secure_cookie('root') if root != 'suiyue': return self.redirect('/rootlogin') cards = Card.get_by_cid(cid) ext_allowed = ['gif', 'jpg', 'jpeg', 'png'] cpic = cards[0].pic max_size = 2621440 save_dir = os.path.join(os.path.dirname(__file__), "../public/pic/card/") if len(cards)>0: file_name = str(cards[0].cid) error = "" if 'image' in self.request.files: pic = self.request.files['image'][0] ext = pic['filename'].split('.').pop() if ext not in ext_allowed: error="图片格式不支持" self.redirect('/control') if len(pic['body'])>max_size: error="图片太大" self.redirect('/control') cpic = file_name+"."+ext with open(save_dir+cpic,'wb') as up: up.write(pic['body']) Card.change_pic(cid, cpic) self.redirect("/control") else: self.redirect('/control')
def five_completed_tasks(): card1 = Card(1, 1, "Card 1 Done", LISTS[2].id, None, YESTERDAY_DATE) card2 = Card(2, 2, "Card 2 Done", LISTS[2].id, None, YESTERDAY_DATE) card3 = Card(3, 3, "Card 3 Done", LISTS[2].id, None, YESTERDAY_DATE) card4 = Card(4, 4, "Card 4 Done", LISTS[2].id, None, YESTERDAY_DATE) card5 = Card(5, 5, "Card 5 Done", LISTS[2].id, None, YESTERDAY_DATE) return [card1, card2, card3, card4, card5]
def get_card_route(request, card_id): """ Get a specific card given an ID. Show all relevant data, but not used for the learning interface. """ db_conn = request['db_conn'] card = get_card_by_kind(db_conn, card_id) if not card: return abort(404) unit = Unit.get_latest_accepted(db_conn, entity_id=card['unit_id']) if not unit: return abort(404) # TODO-2 SPLITUP create new endpoints for these instead topics = list_topics_by_entity_id(card_id, {}, db_conn) versions = Card.get_versions(db_conn, entity_id=card_id) requires = Card.list_requires(db_conn, entity_id=card_id) required_by = Card.list_required_by(db_conn, entity_id=card_id) params = get_card_parameters({'entity_id': card_id}, db_conn) return 200, { 'card': card.deliver(access='view'), 'card_parameters': (get_card_parameters_values(params) if params else None), 'unit': unit.deliver(), 'topics': [deliver_topic(topic) for topic in topics], 'versions': [version.deliver() for version in versions], 'requires': [require.deliver() for require in requires], 'required_by': [require.deliver() for require in required_by], }
def updateAsInventory(self, context): self.cards = [] if context.update: json = self.api.updateAndGetInitFile(context) else: json = self.api.getInit(context) card_map = json['user_units'] self.name = json['user_data']['name'] + "_inventory" # print('[Deck] inventory for ', self.name) for card in card_map: card_to_add = Card() card_to_add.id = int(card_map[card]['unit_id']) card_to_add.level = int(card_map[card]['level']) print('[Deck] Adding card - id: {0}, level: {1}'.format( card_to_add.id, card_to_add.level)) self.cards.append(card_to_add) self.updateDeckFromXML() print('[Deck] update as inventory - returning') return self.cards
def get_card_route(request, card_id): """ Get a specific card given an ID. Show all relevant data, but not used for the learning interface. """ card = get_card_by_kind(card_id) if not card: return abort(404) unit = Unit.get_latest_accepted(entity_id=card['unit_id']) if not unit: return abort(404) # TODO-2 SPLITUP create new endpoints for these instead topics = Topic.list_by_entity_id(entity_id=card_id) versions = Card.get_versions(entity_id=card_id) requires = Card.list_requires(entity_id=card_id) required_by = Card.list_required_by(entity_id=card_id) params = CardParameters.get(entity_id=card_id) return 200, { 'card': card.deliver(access='view'), 'card_parameters': params.get_values(), 'unit': unit.deliver(), 'topics': [topic.deliver() for topic in topics], 'versions': [version.deliver() for version in versions], 'requires': [require.deliver() for require in requires], 'required_by': [require.deliver() for require in required_by], }
def post(self): uname = self.get_current_user() user = User.get_user_by_name(uname) main = self.get_argument("main") pic = "default.jpg" Card.add_one_card(pic,user[0].uid,main) self.render("wcard.html", msg="投稿成功,谢谢你的idea",user=user)
def get(self): uname = self.get_current_user() user = User.get_user_by_name(uname) order = get_order() card = Card.get_by_porder(order) cid = self.get_argument("cid",None) if cid is not None: card=Card.get_by_cid(cid) article = Article.get_all_Acard(200) usedCard = Card.get_all_card() temp = [] for one in usedCard: if 0 < one.porder and one.porder <= order: temp.append(one) usedCard = temp reArticles = Article.get_all(200) Rarticle = sorted(reArticles,BaseHandler.rank) if len(Rarticle) > 6: Rarticle = Rarticle[:6] Ruser = User.get_all_user(100) if len(Ruser)>9: Ruser = Ruser[:9] if len(usedCard)>3: usedCard = usedCard[:3] self.render("card.html",user=user,Rarticle=Rarticle,Article=article,usedCard=usedCard,Ruser=Ruser,card=card)
def load_latest_game(cls, email): """Return latest game by a user or a new game if one didn't exist.""" with connection: with connection.cursor() as cursor: user = User.get_user_by_email(email) cursor.execute(database.GET_LATEST_GAME_TABLE_BY_EMAIL, (email,)) bulk = cursor.fetchone() print (bulk) if bulk: (game_table_id, timestamp_created, computer_hand_id, player_hand_id, deck_id, user_id, turn_indicator) = bulk else: return cls.new_game(user) # Get Hands cursor.execute(database.GET_HAND_BY_ID, (player_hand_id, )) p_s1, p_v1, p_s2, p_v2, p_s3, p_v3, p_s4, p_v4, p_s5, p_v5,\ uid, mtime = cursor.fetchone() player = User.get_user_by_id(uid) player_hand = Hand(player, Card(p_s1, p_v1), Card(p_s2, p_v2), Card(p_s3, p_v3), Card(p_s4, p_v4), Card(p_s5, p_v5)) cursor.execute(database.GET_HAND_BY_ID, (computer_hand_id, )) c_s1, c_v1, c_s2, c_v2, c_s3, c_v3, c_s4, c_v4, c_s5, c_v5,\ cuid, cmtime = cursor.fetchone() computer = User.get_user_by_id(COMPUTER_UID) computer_hand = Hand(computer, Card(c_s1, c_v1), Card(c_s2, c_v2), Card(c_s3, c_v3), Card(c_s4, c_v4), Card(c_s5, c_v5)) deck = Deck(deck_id) return cls(deck, user, player_hand, computer_hand, game_table_id, turn_indicator)
def apply_card(): u = current_user() if u is None: return abort(403) form = request.form Card.apply_card(u, form) return redirect(url_for(".index"))
def test_query_cards(self): # initialize some sample cards # testing comment user = self.generate_user(COOL_USERNAME, PASSWORD) card_names = [ "Jace, The Mind Sculptor", "Jace's Defeat", "Jace, Vrynn's Prodigy", "Jackal Pup", "Scalding Tarn", "Ancestral Vision", "Serum Visions", "Lightning Bolt", "Forked Bolt", "Boltwing Marauder", "Firebolt" ] for name in card_names: new_card = Card(name) db.session.add(new_card) db.session.commit() # assert that each query for a specific card has exactly one match. # Note for our input that none of the names are substrings of another for name in card_names: sample = Card.query.filter_by( search_name=Card.format_card_name_for_search(name)).first() query = user.query_cards(name) self.assertEqual(len(query), 1) # these queries have the query amount and expected output test_queries = [("Tarn", 1), ("Jace", 3), ("jace", 3), ("Jac", 4), ("bolt", 4), ("vision", 2), ("visions", 1)] for test in test_queries: card_name = test[0] expected_quantity = test[1] query = user.query_cards(card_name) self.assertEqual(len(query), expected_quantity)
def test_get_cards_by_list_id(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) card_id = Card.add("card0", lid0, uid0) card = Card.get(card_id) assert card_id in [card.id for card in Card.get_cards_by_list_id(lid0)]
def test_card_search_name(self): # there's 18000 in this AllCards.json so we only check some of them # This variable can be adjusted to check all of them # To check all 18000 cards, it will take at least 30 seconds # and will bog down other tests NUM_CARDS_TO_CHECK = 100 with open("./data/AllCards.json", "r") as f: card_data = json.load(f) count = 0 for name in card_data: if count < NUM_CARDS_TO_CHECK: new_card = Card(name) db.session.add(new_card) count += 1 db.session.commit() count = 0 for name in card_data: if count < NUM_CARDS_TO_CHECK: card = Card.search_card_by_name(name) self.assertIsNotNone(card) formatted_name = Card.format_card_name_for_search(name) cards = Card.query.filter_by(search_name=formatted_name).all() self.assertEqual(len(cards), 1) count += 1
def test_get_user_ids(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) card_id = Card.add("card0", lid0, uid0) card = Card.get(card_id) assert str(uid0) in [user_id for user_id in card.get_user_ids()]
def choose_card(db_conn, user, unit): """ Given a user and a unit, choose an appropriate card. Return a card instance. """ # TODO-3 simplify this method unit_id = unit['entity_id'] query = (Card.start_accepted_query().filter({ 'unit_id': unit_id }).sample(10)) # TODO-2 index # TODO-3 does this belong as a model method? # TODO-2 is the sample value decent? # TODO-2 has the learner seen this card recently? cards = [Card(d) for d in query.run(db_conn)] if not len(cards): return None previous_response = get_latest_response(user['id'], unit_id, db_conn) if previous_response: learned = previous_response['learned'] # Don't allow the previous card as the next card cards = [ card for card in cards if card['entity_id'] != previous_response['card_id'] ] else: learned = init_learned shuffle(cards) assessment, nonassessment = partition(cards, lambda c: c.has_assessment()) choose_assessment = random() < p_assessment_map[floor(learned * 10)] if choose_assessment: if not len(assessment): return nonassessment[0] for card in assessment: params = get_card_parameters({'entity_id': card['entity_id']}, db_conn) if params: values = get_card_parameters_values(params) guess = values['guess'] slip = values['slip'] correct = calculate_correct(guess, slip, learned) if 0.25 < correct < 0.75: return card else: return card return assessment[0] if len(nonassessment): return nonassessment[0] if len(assessment): return assessment[0] return None
def test_set_and_get_card(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) card_id = Card.add("card0", lid0, uid0) card = Card.get(card_id) assert card.title == 'card0' assert card.list_id == lid0
def cards_with_last_modified_dates(): card1 = Card(1, 1, "Card 1 Todo Yesterday", LISTS[0].id, None, YESTERDAY_DATE) card2 = Card(2, 2, "Card 2 Todo Today", LISTS[0].id, None, TODAY_DATE) card3 = Card(3, 3, "Card 3 Done Yesterday", LISTS[2].id, None, YESTERDAY_DATE) card4 = Card(4, 4, "Card 4 Done Today", LISTS[2].id, None, TODAY_DATE) return [card1, card2, card3, card4]
def test_get_and_test_description(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) card_id = Card.add("card0", lid0, uid0) card = Card.get(card_id) card.set_description('desc') assert 'desc' in card.get_description()
class TestCard: def setup(self): self.numbers_list = [ 9, 43, 62, 74, 90, 2, 27, 75, 78, 82, 41, 56, 63, 76, 86 ] self.card = Card(self.numbers_list) def test_is_empty(self): assert not self.card.is_empty() # Если вычеркнуть все чифры? for item in self.numbers_list: self.card.cross_out(item) assert self.card.is_empty() def test_str(self): result = """ -------------------------- 9 43 62 74 90 2 27 75 78 82 41 56 63 76 86 -------------------------- """ assert result == str(self.card) def test_contains(self): assert 9 in self.card assert 99 not in self.card assert CardNumber(9) in self.card assert CardNumber(99) not in self.card def test_cross_out(self): # Зачеркиваем число которое есть self.card.cross_out(43) result = """ -------------------------- 9 - 62 74 90 2 27 75 78 82 41 56 63 76 86 -------------------------- """ assert str(self.card) == result self.card.cross_out(CardNumber(62)) result = """ -------------------------- 9 - - 74 90 2 27 75 78 82 41 56 63 76 86 -------------------------- """ assert str(self.card) == result # В карточке нет такого числа with raises(CardNotContainsNumberError): self.card.cross_out(CardNumber(99))
def __initialize_deck(self): for suite in self.__suites: for count, name in enumerate(self.__names, start=1): if name == 'ACE': card = Card(suite, name, 'ACE', 10) elif name == 'JACK' or name == 'QUEEN' or name == 'KING': card = Card(suite, name, 'FACE_CARD', 10) else: card = Card(suite, name, 'RANKS', count) self.__cards.append(card)
def post(self): cid = self.get_argument('cid') porder = self.get_argument('porder') root = self.get_secure_cookie('root') if root == 'suiyue': temp = Card.get_by_porder(porder) if len(temp) > 0: Card.change_porder(temp[0].cid, 0) Card.change_porder(cid, porder) self.redirect('/control') else: self.redirect('/rootlogin')
def match_pair(cls, game, pair_1, pair_2): """Match a pair and update game state""" game.attempts += 1 game.put() card_1 = Card.query(Card.game == game.key).filter(Card.index == pair_1).get() card_2 = Card.query(Card.game == game.key).filter(Card.index == pair_2).get() if card_1.matched or card_2.matched: raise RuntimeError('Could not rematch a matched card') form = MatchResultForm() if card_1.value == card_2.value: card_1.matched = True card_1.put() card_2.matched = True card_2.put() game.matched += 2 game.put() form.message = 'Success' else: form.message = 'Fail' # Construct return info form form.card_1 = card_1.to_form() form.card_2 = card_2.to_form() form.matched_count = game.matched if game.matched == 52: game.game_over = True game.put() Card.delete_cards_for_game(game) # Update average attempts of user user = game.user.get() games = Game.get_user_finished_games(user) count = len(games) if user.average_attempts == float('inf'): user.average_attempts = 0 user.average_attempts = ((count - 1) * user.average_attempts + game.attempts) / count user.put() score = Score(user=game.user, date=date.today(), attempts=game.attempts) score.put() form.message = 'Win' # Create history log History.create_history(game=game, card_1=card_1, card_2=card_2, message=form.message) return form
def test_get_cards(self): bid0 = Board.add("board1", "A") lid0 = List.add("List0", bid0) list0 = List.get(lid0) lid1 = List.add("List1", bid0) list1 = List.get(lid1) uid0 = User.add("test1", "password", "*****@*****.**") caid0 = Card.add("card1", lid0, uid0) caid1 = Card.add("card2", lid1, uid0) assert caid0 in [card.id for card in list0.get_cards()] assert caid1 not in [card.id for card in list0.get_cards()]
def post(self): body = request.get_json() card = Card(body["card_number"], body["emp_id"]) try: card.save() except Exception as e: return ( { "msg": "Something went wrong while adding access card to db.", "description": e, }, 500, ) return {"msg": "New card created for employee.", "card": card.json()}, 201
def add(cls, card_id, user_id, content): comment = cls(card_id = card_id, user_id = user_id, content = content) from models.card import Card Card.incr_comment(card_id) try: mysql_session.add(comment) mysql_session.commit() except Exception as e: mysql_session.rollback() print "error in mysql commit:", e raise finally: mysql_session.close() return comment.id
def flush_entities(db_conn, descs): """ Given a list of kinds and entity_ids, return a list filled out with entities. """ output = [] for desc in descs: if desc['kind'] == 'card': card = Card.get_latest_accepted(db_conn, entity_id=desc['id']) card = flip_card_into_kind(card) if card: output.append(card) elif desc['kind'] == 'unit': output.append(Unit.get_latest_accepted( db_conn, entity_id=desc['id'] )) elif desc['kind'] == 'set': output.append(Set.get_latest_accepted( db_conn, entity_id=desc['id'] )) else: output.append(None) return output
def api_card(list_id = None): if request.method == 'GET': list_id = request.args.get('list_id') if list_id != None: cards = Card.get_cards_by_list_id(list_id) return jsonify(json_list=[card.serialize() for card in cards]) else: return jsonify({'code': 404, 'message': 'Card ID not valid.'}) else: try: list_id = long(request.form['list_id']) title = request.form['title'] except KeyError: return jsonify({'code': 400, 'message': 'Bad Request'}) return jsonify({"card_id": Card.add(title, list_id, current_user.id)})
def make_game_easier(cls, game, hint_num): cards = Card.get_cards_for_game(game) unmatched_cards = filter(lambda c: not c.matched, cards) hint_histories = [] while game.matched != 52 and hint_num > 0: card_1 = unmatched_cards[0] card_2 = filter(lambda c: c != card_1 and c.value == card_1.value, unmatched_cards)[0] # Update game state card_1.matched = True card_2.matched = True game.matched += 2 game.attempts += 1 hint_num -= 1 # Update card state unmatched card list unmatched_cards.remove(card_1) unmatched_cards.remove(card_2) card_1.put() card_2.put() # Create history log history = History.create_history(game=game, card_1=card_1, card_2=card_2, message='Hint Match') hint_histories.append(history) game.put() return hint_histories
def get_card_by_kind(db_conn, card_id): """ Given a card data, return a new card model to replace it by kind. """ card = Card.get_latest_accepted(db_conn, card_id) return flip_card_into_kind(card)
def get_card_by_kind(card_id): """ Given a card data, return a new card model to replace it by kind. """ card = Card.get_latest_accepted(card_id) if not card: return data, kind = card.data, card.data.get('kind') map = { 'audio': AudioCard, 'choice': ChoiceCard, 'embed': EmbedCard, 'formula': FormulaCard, 'match': MatchCard, 'number': NumberCard, 'page': PageCard, 'slideshow': SlideshowCard, 'upload': UploadCard, 'video': VideoCard, 'writing': WritingCard, } if kind in map: return map[kind](data)
def post(self): ''' Create new card ''' board = self.get_board(self.request.get('board_id')) card = Card(board_key=board.key, content=self.request.get('content'), author_key=self.current_ganban_user().key) card.put() if settings.SEND_EMAILS: self.send_new_card_email(card) logging.info("Card with id: %s created.", card.key.id()) self.send_channel_message('create', card) self.response.out.write(json.dumps(card.to_dict()))
def test_get_kind(): """ Expect to return kind as string given data. """ kind = entity.get_kind(Card({})) assert kind == 'card'
def flush_entities(db_conn, descs): """ Given a list of kinds and entity_ids, return a list filled out with entities. """ output = [] for desc in descs: if desc['kind'] == 'card': card = Card.get_latest_accepted(db_conn, entity_id=desc['id']) card = flip_card_into_kind(card) if card: output.append(card) elif desc['kind'] == 'unit': output.append(Unit.get_latest_accepted( db_conn, entity_id=desc['id'] )) elif desc['kind'] == 'subject': output.append(Subject.get_latest_accepted( db_conn, entity_id=desc['id'] )) else: output.append(None) return output
def sell_card(self, card_name: str, user_name: str): user_doc_ref = self.firestore_db.collection( self.user_coll_name).document(user_name) user = User.from_dict(user_doc_ref.get().to_dict()) user_owned_cards = [ref.split("/")[-1] for ref in user.cards] card_doc_ref = self.firestore_db.collection( self.card_coll_name).document(card_name) card = Card.from_dict(card_doc_ref.get().to_dict()) if card_name in user_owned_cards: new_value = user.total_currency_value + card.value user.set_coins(*User.get_coins_from_value(new_value)) user_doc_ref.update({ u'cards': firestore_api.ArrayRemove([card_doc_ref.path]), u'galleons': user.galleons, u'sickles': user.sickles, u'knuts': user.knuts }) return user # Return the new values else: raise UnownedItemException( "You cannot sell that card because you do not own it.", user=user)
def test_add_and_get_cards(self): uid0 = User.add("test_user1", "password", "*****@*****.**") user0 = User.get(uid0) uid1 = User.add("test_user2", "password", "*****@*****.**") user1 = User.get(uid1) bid0 = Board.add("board1", "A") lid0 = List.add("List0", bid0) caid0 = Card.add("card1", lid0, uid0) caid1 = Card.add("card2", lid0, uid1) card0 = Card.get(caid0) print caid0, user0.get_card_ids() assert str(caid0) in user0.get_card_ids() assert str(caid1) not in user0.get_card_ids()
def test_get_comments_by_card_id(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) caid0 = Card.add("card1", lid0, uid0) caid1 = Card.add("card2", lid0, uid0) coid0 = Comment.add(caid0, uid0, "comment1") coid1 = Comment.add(caid1, uid0, "comment2") comment0 = Comment.get(coid0) comment1 = Comment.get(coid1) assert coid0 in [comment.id for comment in Comment.get_comments_by_card_id(caid0)] assert coid1 not in [comment.id for comment in Comment.get_comments_by_card_id(caid0)]
def get_version(db_conn, kind, id_): if kind == 'card': card = Card.get(db_conn, id=id_) return flip_card_into_kind(card) elif kind == 'unit': return Unit.get(db_conn, id=id_) elif kind == 'set': return Set.get(db_conn, id=id_)
def get_version(kind, id_): if kind == 'card': return Card.get(id=id_) # TODO-1 This needs to also get the right card kind... elif kind == 'unit': return Unit.get(id=id_) elif kind == 'set': return Set.get(id=id_)
def setUp(self): db.create_all() # initialize 100 cards for x in range(0, 100): new_card = Card("card" + str(x)) db.session.add(new_card) db.session.commit()
def get_rand_card(): """返回随机 card 或 None.""" # 实例化 mark_plan mark_plan = MarkPlan.new() # 实例化 plan plan = Plan(mark_plan.is_updated) c_id = plan.get_random_id() return Card.get_card_by_id(c_id)
def get_card_versions_route(request, card_id): """ Get versions card given an ID. Paginates. """ versions = Card.get_versions(entity_id=card_id, **request['params']) return 200, { 'versions': [version.deliver(access='view') for version in versions] }
def draw(self): with connection: with connection.cursor() as cursor: cursor.execute(database.DRAW_A_CARD, (self.id, )) _id, suit, value, deck = cursor.fetchone() cursor.execute(database.MARK_A_CARD_DRAWN, (datetime.datetime.timestamp( datetime.datetime.now()), _id)) return Card(suit, value)
def test_get_cards(api): response = api.get('https://statsroyale.com/api/cards') assert response.ok cards = [] for card in response.json(): cards.append(Card(**card)) assert len(cards) == 98
def get(self): root = self.get_secure_cookie('root') if root=='suiyue': current_order = get_order() cards = Card.get_all_card() stories = Story.get_all_story() self.render("control.html", order=current_order, cards=cards, stories=stories) else: self.redirect('/rootlogin')
def card_list(request): msg = '' batch_id = int(request.REQUEST.get('batch_id', '0')) page_num = int(request.REQUEST.get('page_num', '1')) if page_num < 1: page_num = 1 page_num = int(request.REQUEST.get('page_num', '1')) page_size = 50 list_data = [] search_type = int(request.REQUEST.get('search_type','0')) status = request.REQUEST.get('status','') sdate = request.REQUEST.get('start_date','') edate = request.REQUEST.get('end_date','') search_val = request.REQUEST.get('search_val','') query = ['1=1'] total_record = 0 card_batch = None list_server = get_server_list() server_id = int(request.REQUEST.get('server_id','0')) if batch_id > 0: query.append(" and batch_id = '%s'"%batch_id) try: card_batch = CardBatch.objects.using('card').get(id = batch_id) key = card_batch.key Card._meta.db_table = Card.get_card_table_name(key) if search_type != 0 and search_val !='': if search_type == 1: query.append(" and number = '%s'"%search_val) elif search_type == 2: query.append(" and player_id = '%s'"%search_val) # elif search_type == 3: # query.append(" and password = '******'"%search_val) if server_id != 0: query.append(" and server_id = %d "%server_id) if status != '': try: status = int(status) query.append(" and status = %d "%status) except: pass if sdate != '' and edate != '': query.append(" AND DATE(`use_time`) >= '%s' AND DATE(`use_time`) <= '%s'"%(sdate,edate)) total_record = Card.objects.using('card').extra(where=[''.join(query)]).count() if total_record > 0: list_data = Card.objects.using('card').extra(where=[''.join(query)]).order_by('-id')[(page_num - 1) * page_size:page_num * page_size] for item in list_data: item.server = '' if item.server_id: the_server = Server.objects.get(id = item.server_id) if the_server: item.server = the_server.name except Exception, e: print('create card number error:', e) msg = '%s'%e
def add_card(): log('调用路由') form = request.form # todo 用户判断 # u = current_user() log(f'Card: {Card}') card_id = Card.new(form) plan = Plan() plan.insert_id(card_id) return redirect(url_for('.review', card_id=card_id))
def post(self): parsed_args = parser.parse_args() card = Card(title=parsed_args['title'], content=parsed_args['content']) if 'links' in parsed_args and parsed_args['links'] is not None: for l in parsed_args['links']: link = Link(url=l['url']) card.links.append(link) session.add(card) session.commit() return card, 201
def test_add_and_get(self): uid0 = User.add("test1", "password", "*****@*****.**") bid0 = Board.add("board1", "A") lid0 = List.add("To Do", bid0) caid0 = Card.add("card1", lid0, uid0) coid0 = Comment.add(caid0, uid0, "comment1") comment0 = Comment.get(coid0) assert caid0 == comment0.card_id assert uid0 == comment0.user_id assert "comment1" == comment0.content
def get_latest_accepted(kind, entity_id): """ Given a kind and an entity_id, pull the latest accepted version out of the database. """ if kind == 'card': return Card.get_latest_accepted(entity_id) # TODO-1 This needs to also get the right card kind... elif kind == 'unit': return Unit.get_latest_accepted(entity_id) elif kind == 'set': return Set.get_latest_accepted(entity_id)
def api_get_card(card_id = None): if card_id == None: return jsonify({'code': 400, 'message': 'Bad Request'}) else: card = Card.get(long(card_id)) if card == None: return jsonify({'code': 404, 'message': 'Page Not Found'}) _list = List.get(card.list_id) return render_template('card.html', card=card, list=_list, edit_card_desc_form=EditCardDescForm(), add_comment_form=AddCommentForm());
def get_latest_accepted(db_conn, kind, entity_id): """ Given a kind and an entity_id, pull the latest accepted version out of the database. """ if kind == 'card': card = Card.get_latest_accepted(db_conn, entity_id) return flip_card_into_kind(card) elif kind == 'unit': return Unit.get_latest_accepted(db_conn, entity_id) elif kind == 'set': return Set.get_latest_accepted(db_conn, entity_id)
def test_language(db_conn, cards_table): """ Expect a card to require a language. """ card, errors = Card.insert({ 'previous_id': 'TJKL35', 'unit_id': 'RUF531', 'name': 'What is?', 'kind': 'video' }) assert len(errors) == 0 card['language'] = 'en'
def test_entity_id(db_conn, cards_table): """ Expect a card to require an entity_id. """ card, errors = Card.insert(db_conn, { 'previous_id': 'TJKL35', 'language': 'en', 'unit_id': 'RUF531', 'name': 'What is?', 'kind': 'video' }) assert len(errors) == 0 assert card['entity_id']
def api_edit_card(card_id = None): if card_id == None: return jsonify({'code': 400, 'message': 'Bad Request'}) else: card = Card.get(long(card_id)) if card == None: return jsonify({'code': 404, 'message': 'Page Not Found'}) try: desc = request.form['desc'] card.set_description(desc) except KeyError: return jsonify({'code': 400, 'message': 'Bad Request'}) return jsonify({'code': 200, 'card_id':card_id})
def test_unit_id(db_conn, cards_table): """ Expect a card to require a unit id. """ card, errors = Card.insert({ 'previous_id': 'TJKL35', 'language': 'en', 'name': 'What is?', 'kind': 'video' }) assert len(errors) == 1 card['unit_id'] = 'RUF531A' card, errors = card.save() assert len(errors) == 0