def startSession(): if 'android_id' in request.args: android_id = request.args.get('android_id') if android_id in []: return jsonify({'debug': 'True', 'ip': '52.74.20.228'}) # VERSION SPECIFIC app_version = int(request.headers.get( 'App-Version')) if 'App-Version' in request.headers else 0 # Search().getContentData(key="recommendations") # Search().getContentData(key="most_searched") reading_multiplier = webapp.config[ 'NEW_READING_RATE'] if app_version >= 6030000 else webapp.config[ 'NEW_READING_RATE'] - 0.01 data = { 'most_searched': Collection(4).getObj()['items'], 'recommendations': Collection(5).getObj()['items'], 'categories': Search.getSearchCategoriesForApp(), 'return_days': webapp.config['DEFAULT_RETURN_DAYS'], 'reading_multiplier': reading_multiplier, 'time_slots': Order.getTimeSlotsForOrder(), 'user_model': None } if 'user_id' in request.args: user_id = request.args.get('user_id') if user_id and int(user_id) > -1: user = User(user_id) user.getOrderSlots() data['user_model'] = user.getObj() user.logMetadata(app_version) return jsonify(data)
def copy_collection_from( user: InternalUserDTO, src_collection_uuid: UUID, dst_collection_uuid: UUID, ) -> CollectionDTO: try: src_collection = Collection.find_readable_or_fail(user, src_collection_uuid) except ModelNotFoundError: raise PermissionError() copy_items_by_collection_uuid(src_collection_uuid, dst_collection_uuid) src_collection.session.commit() collection = Collection.find_readable_or_fail(user, dst_collection_uuid) return to_model(collection, CollectionDTO)
def copy_collection_to_new( user: InternalUserDTO, src_collection_uuid: UUID, dst_collection_dto: CollectionDTO, ) -> CollectionDTO: try: src_collection = Collection.find_readable_or_fail(user, src_collection_uuid) except ModelNotFoundError: raise PermissionError() dst_collection_dto.provider_uuid = user.provider_uuid dst_collection = Collection.create(**dst_collection_dto.to_dict()) copy_items_by_collection_uuid(src_collection_uuid, dst_collection.uuid) src_collection.session.commit() return to_model(dst_collection, CollectionDTO)
def test_tv_items_query(self): u = User(username='******', password='******', email='*****@*****.**') tv1 = TV(name='a', serialized='1', img_sm='/', new_episode=3, update_detail='w:1') tv2 = TV(name='b', serialized='1', img_sm='/', new_episode=4, update_detail='w:2') tv3 = TV(name='c', serialized='1', img_sm='/', new_episode=5, update_detail='w:3') db.session.add(u) db.session.add(tv1) db.session.add(tv2) db.session.add(tv3) db.session.commit() c = Collection(user_id=u.id, name='w') c.add_tv(tv1) c.add_tv(tv2) c.add_tv(tv3) db.session.commit() r = c.tv_items_query() assert isinstance(r, BaseQuery) for i in r.all(): assert i in c.tv_items_list()
def test_tv_items_list(self): u = User(username='******', password='******', email='*****@*****.**') tv1 = TV(name='a', serialized='1', img_sm='/', new_episode=3, update_detail='w:1') tv2 = TV(name='b', serialized='1', img_sm='/', new_episode=4, update_detail='w:2') tv3 = TV(name='c', serialized='1', img_sm='/', new_episode=5, update_detail='w:3') db.session.add(u) db.session.add(tv1) db.session.add(tv2) db.session.add(tv3) db.session.commit() c = Collection(user_id=u.id, name='w') c.add_tv(tv1) c.add_tv(tv2) c.add_tv(tv3) db.session.commit() r = c.tv_items_list() r_id = [i.id for i in r] assert isinstance(r, list) assert tv1.id in r_id assert tv2.id in r_id assert tv3.id in r_id assert len(r) == 3
def test_remove_tv(self): u = User(username='******', password='******', email='*****@*****.**') tv1 = TV(name='a', serialized='1', img_sm='/', new_episode=3, update_detail='w:1') tv2 = TV(name='b', serialized='1', img_sm='/', new_episode=4, update_detail='w:2') tv3 = TV(name='c', serialized='1', img_sm='/', new_episode=5, update_detail='w:3') db.session.add(u) db.session.add(tv1) db.session.add(tv2) db.session.add(tv3) db.session.commit() c = Collection(user_id=u.id, name='w') c.add_tv(tv1) c.add_tv(tv2) c.add_tv(tv3) db.session.commit() c.remove_tv(tv1) db.session.commit() assert c.tv == '2;3' c.remove_tv(2) db.session.commit() assert c.tv == '3' with pytest.raises(ValueError): c.remove_tv('a')
def add_collection(current_user): if not check_session(): return jsonify({'message': 'You are not logged in!', 'isLoggedIn': False}) request_data = request.get_json(silent=True, force=True) if not (request_data or request_data['name']): return jsonify({'message': 'Something went wrong!', 'isAdded': False}) same_named_collection = None for collection in current_user.collections: if collection.name == request_data['name']: same_named_collection = collection break if same_named_collection: return jsonify({'message': 'You already have collection named'+request_data['name'], 'isAdded': False}) new_collection = Collection(name=request_data['name']) db.session.add(new_collection) current_user.collections.append(new_collection) db.session.commit() new_collection_response = {"id": new_collection.id, "name": new_collection.name, "createdAt": new_collection.createdAt, "updatedAt": new_collection.updatedAt, "translationsQuantity": 0, "learnedQuantity": 0} return jsonify({'isAdded': True, 'newCollection': new_collection_response})
def save_data(self, movie_data_list, collections_list, genre_data_list, production_companies_list, production_countries_list): movie_objects = Movie.get_or_create(*movie_data_list) for n, movie in enumerate(movie_objects): if collections_list[n] is not None: collection_object = Collection.get_or_create( collections_list[n])[0] movie.is_part_of.connect(collection_object) for n, genres in enumerate(genre_data_list): movie = movie_objects[n] genres_objects = Genre.get_or_create(*genres) [movie.genres.connect(genre) for genre in genres_objects] for n, production_companies in enumerate(production_companies_list): movie = movie_objects[n] production_companies_objects = ProductionCompany.get_or_create( *production_companies) [ movie.produced_by.connect(production_company) for production_company in production_companies_objects ] for n, production_country in enumerate(production_countries_list): movie = movie_objects[n] production_country_objects = ProductionCountry.get_or_create( *production_country) [ movie.produced_in.connect(production_country) for production_country in production_country_objects ]
def get(self, collection_uid=None): """Get a list of a user's collections, or """ request_args = get_current_request_args() user_uid = request_args.get('user_uid') if user_uid is not None: user = User.get_not_deleted(uid=user_uid) if user is None: raise ResourceNotFound('User not found') else: user = get_current_user() if collection_uid is not None: collection = Collection.get_not_deleted(uid=collection_uid, user_id=user.id) if collection is None: raise ResourceNotFound('Collection not found') return api_success_response(collection.as_json()) pagination = user.collections.paginate() return api_success_response( data=[collection.as_json() for collection in pagination.items()], meta=pagination.meta)
def create_collection(params): """Create a collection and return the ORM object of the collection created""" collection = Collection(**params) collection.save() return collection
def create_collection_items( user: InternalUserDTO, collection_uuid: UUID, items: List[ItemDTO], replace: bool = False, ) -> List[ItemDTO]: collection = Collection.find_writeable_or_fail(user, collection_uuid) if replace: Item.where(collection_uuid=collection.uuid).delete() new_items: List[Item] = [ Item(**{ **item.to_dict(), **{ "uuid": uuid4() } }) for item in items ] Item.session.bulk_save_objects(new_items) Item.session.commit() uuids = [] for item in new_items: if isinstance(item.uuid, str): uuids.append(UUID(item.uuid)) else: uuids.append(item.uuid) fetched_items = Item.find_writeable(user, uuids) return to_models(fetched_items, ItemDTO)
def collect_blog(blog_id): collection = Collection(UserID=current_user.UserID, BlogID=blog_id) if db.session.add(collection): db.session.commit() return "success" else: return "fail"
def create_collection( user: InternalUserDTO, collection: CollectionDTO ) -> CollectionDTO: collection.provider_uuid = user.provider_uuid collection = Collection(**collection.to_dict()) collection.save() collection.session.commit() return to_model(collection, CollectionDTO)
def test_tv_id_list(self): u = User(username='******', password='******', email='*****@*****.**') db.session.add(u) db.session.commit() c = Collection(user_id=u.id, tv='1;2;3', name='w') db.session.add(c) db.session.commit() assert c.tv_id_list() == ['1', '2', '3']
def collection_private(db, provider, request): from app.models import Collection collection = Collection.create(name="test-collection-private1", is_public=False, provider_uuid=provider["uuid"]) Collection.session.commit() return collection.to_dict()
def collection2(db, provider2, request): from app.models import Collection collection = Collection.create(name="test-collection1", is_public=True, provider_uuid=provider2["uuid"]) Collection.session.commit() return collection.to_dict()
def test_save_load(self): u = User(username='******', password='******', email='*****@*****.**') db.session.add(u) db.session.commit() c = Collection(user_id=u.id, name='w') db.session.add(c) db.session.commit() assert Collection.query.get(1).user_id == u.id
def create_collection_item(user: InternalUserDTO, collection_uuid: UUID, item_dto: ItemDTO) -> ItemDTO: coll = Collection.find_writeable_or_fail(user, collection_uuid) item_dto.collection_uuid = coll.uuid # type: ignore item = Item(**item_dto.to_dict()) item.save() item.session.commit() return to_model(item, ItemDTO)
def getMultiplePanels(): cursor = mysql.connect().cursor() cursor.execute( """SELECT collection_id FROM collections WHERE active = 1 AND partial_order = 1 ORDER BY collection_id DESC""") panels = [] for col_id in cursor.fetchall(): panels.append(Collection(col_id).getObj()) return json.dumps(panels)
def update_collection_by_uuid( user: InternalUserDTO, collection_uuid: UUID, collection_update: CollectionDTO ) -> CollectionDTO: collection = Collection.find_writeable_or_fail(user, collection_uuid) collection.name = collection_update.name collection.is_public = collection_update.is_public collection.save() collection.session.commit() return to_model(collection, CollectionDTO)
def delete(self, collection_uid): """Delete a collection""" collection = Collection.get_active(collection_uid) if collection is None: raise ResourceNotFound('Collection not found') collection.delete() return api_deleted_response()
def generateData(numUser,numCategory,numBlog): User.fake(numUser) Follow.fake(numUser) Category.fake(numCategory) Blog.fake(numBlog,numUser) Comment.fake(numBlog,numUser) BlogCategory.fake(numBlog,numCategory*5) BlogLabel.fake(numBlog) BlogLike.fake(numBlog*20,numUser,numBlog) CommentLike.fake(numBlog*30,numUser,numBlog*8) Collection.fake(numBlog*10,numUser,numBlog)
def creates1(): form = CollectionForm() if form.validate_on_submit(): collection = Collection(name=form.name.data, numb=form.numb.data, user_id=current_user.id) #current_user.add_collection(collection) db.session.add(collection) db.session.commit() flash('Congratulations, you added deal "'+str(form.name.data) + '" on '+form.numb.data.strftime('%d.%m.%Y')+'!') return render_template('creates1.html', title='Collection create', form=form) return render_template('creates1.html', title='Collection create', form=form)
def uncollect_blog(blog_id): if len( Collection.query.filter_by(UserID=current_user.UserID, BlogID=blog_id)) == 0: return "fail" collection = Collection(UserID=current_user.UserID, BlogID=blog_id) if db.session.delete(collection): db.session.commit() return "success" else: return "fail"
def patch(self, collection_uid): request_data = get_current_request_data() collection = Collection.get_active(collection_uid) if collection is None: raise ResourceNotFound('Collection not found') params = self.__validate_collection_update_params(request_data) collection = self.edit_collection(collection, params) return api_success_response(collection.as_json())
def collect_school_dynamic(): try: collection = Collection(request.args.get("collection_id"), session["user_number"], session["user_type"], request.args.get('dynamic_type')) id = str(uuid.uuid1()) collection.id = id db.session.add(collection) db.session.commit() return json.dumps({'code': 1, "id": id}) except: return json.dumps({"code": -1})
def collection(): collection_id = request.args.get('id') collection = Collection.fetch_by_id(collection_id) photos = collection.fetch_photos() photos_json = json.dumps(photos) loaded_photos = json.loads(photos_json) return render_template('collection.html', photos=loaded_photos, name=collection.name, info=collection.info)
def insert_into_db(word): subtitle = Subtitle(directory="") sentence = subtitle.get_word_sentence(word) collection = Collection( name=word, collect_time=date.today(), full_sentence=sentence ) db.session.add(collection) try: db.session.commit() except: db.session.rollback()
def addCol(): jsons = {} blog_id = getBlogID(request.form['url']) if Collection.query.filter(Collection.user_id == session['id'], Collection.blog_id == blog_id).first(): jsons['isSuccess'] = 9 # 已经收藏 return jsonify(jsons) col_add = Collection(user_id=session['id'], blog_id=blog_id) db.session.add(col_add) db.session.commit() UserLogAdd(session['id'], session['username'], 105, "博客id:" + str(blog_id)) jsons['isSuccess'] = 0 return jsonify(jsons)
def put(self, collection_uid, post_uid): """Add a post to a collection""" collection = Collection.get_not_deleted(uid=collection_uid) if collection is None: raise ResourceNotFound('Collection not found') post = Post.get_not_deleted(uid=post_uid) if post is None: raise ResourceNotFound('Post not found') post.update(collection_id=collection.id) return api_success_response()