def schema(event, context): create_todos = query.create_class({ 'name': 'todos' }) create_all_todos = query.create_index({ 'name': 'all_todos', 'source': TODOS }) client.query(query.if_expr( query.exists(TODOS), query.get(TODOS), create_todos )) client.query(query.if_expr( query.exists(ALL_TODOS), query.get(ALL_TODOS), create_all_todos )) # create a response response = { "statusCode": 200 } return response
def test_create_role(self): self.admin_client.query( query.create_role({ "name": "a_role", "privileges": { "resource": query.collections(), "actions": { "read": True } } })) self.assertTrue( self.admin_client.query(query.exists(query.role("a_role"))))
def __init__(self, collection_name: str, model): """ Each CRUD requires that: - Fauna client is connected to db - collection_name is created / exists - Collection is created / exists """ self.collection_name = collection_name self.model = model self.client = FaunaClient(secret=settings.FAUNADB_SECRET) if not self.client.query( query.exists(query.database( db_name=settings.FAUNADB_DBNAME, ))): self.database = self.client.query( query.create_database(db_params={ 'name': settings.FAUNADB_DBNAME, }), ) if not self.client.query( query.exists( query.collection(collection_name=collection_name, ))): self.collection = self.client.query( query.create_collection(collection_params={ 'name': collection_name, }), )
def donate(update, context): try: for message in config['message']['donate']: context.bot.send_message(chat_id=update.effective_chat.id, text=message) client.query( q.let( {'user': q.ref(q.collection(users), update.effective_chat.id)}, q.if_( q.exists(q.var('user')), q.update(q.var('user'), {'data': { 'last_command': '', }}), 'Success!'))) except Exception as err: log_error(err)
def help_user(update, context): user = User(update.effective_chat.id) if str(user.chat_id) == str(os.getenv('ADMIN_CHAT_ID')): message = config['message']['help_admin'] else: message = config['message']['help'] context.bot.send_message(chat_id=user.chat_id, text=message) try: client.query( q.let({'user': q.ref(q.collection(users), user.chat_id)}, q.if_( q.exists(q.var('user')), q.update(q.var('user'), {'data': { 'last_command': '', }}), 'Success!'))) except Exception as err: log_error(err)
def test_create_access_providers(self): providerName = 'provider_' issuerName = 'issuer_' jwksUri = 'https://xxx.auth0.com/somewhere' provider = self.admin_client.query( query.create_access_provider({ "name": providerName, "issuer": issuerName, "jwks_uri": jwksUri })) self.assertTrue( self.admin_client.query( query.exists(query.access_provider(providerName)))) self.assertEqual(provider["name"], providerName) self.assertEqual(provider["issuer"], issuerName) self.assertEqual(provider["jwks_uri"], jwksUri) #fails if already exists self.assertRaises( BadRequest, lambda: self.admin_client.query( query.create_access_provider({ "name": providerName, "issuer": issuerName, "jwks_uri": jwksUri }))) #fails without issuer self.assertRaises( BadRequest, lambda: self.admin_client.query( query.create_access_provider({ "name": providerName, "jwks_uri": jwksUri }))) #fails with invalid uri jwksUri = 'https:/invalid-uri' self.assertRaises( BadRequest, lambda: self.admin_client.query( query.create_access_provider({ "name": providerName, "issuer": issuerName, "jwks_uri": jwksUri })))
def test_create_key(self): self.admin_client.query( query.create_database({"name": "database_for_key_test"})) resource = self.admin_client.query( query.create_key({ "database": query.database("database_for_key_test"), "role": "server" })) new_client = self.admin_client.new_session_client( secret=resource["secret"]) new_client.query( query.create_collection({"name": "collection_for_test"})) self.assertTrue( new_client.query( query.exists(query.collection("collection_for_test"))))
def create_database(scheme, domain, port, secret, db_name): # # Create an admin client. This is the client we will use to create the database. # # If you are using the the FaunaDB-Cloud you will need to replace the value of the # 'secret' in the command below with your "secret". # adminClient = FaunaClient(secret=secret, domain=domain, scheme=scheme, port=port) print("Connected to FaunaDB as admin!") # # The code below creates the Database that will be used for this example. Please note that # the existence of the database is evaluated, deleted if it exists and recreated with a single # call to the Fauna DB. # res = adminClient.query( q.if_(q.exists(q.database(db_name)), [ q.delete(q.database(db_name)), q.create_database({"name": db_name}) ], q.create_database({"name": db_name}))) print('DB {0} created: {1}'.format(db_name, res)) # # Create a key specific to the database we just created. We will use this to # create a new client we will use in the remainder of the examples. # res = adminClient.query( q.select(["secret"], q.create_key({ "database": q.database(db_name), "role": "server" }))) print('DB {0} secret: {1}'.format(db_name, res)) return res
def record(self, data: Data) -> QueryResult: """In one query, updates existing topic document with data if document already exists, else create a new document. Parameters ---------- data : Data Parsed message from the MQTT broker. Returns ------- QueryResult See src.types.QueryResult for its signature. """ topic = q.match(self.index, data.get("topic", "")) update_record = q.update(q.select(["ref"], q.get(topic)), {"data": data}) create_record = q.create(self.collection, {"data": data}) result = self.db.query( q.let( {"topic_exists": q.exists(topic)}, q.if_(q.var("topic_exists"), update_record, create_record), )) return result
def test_create_collection(self): self._q(query.create_collection({"name": "collection_for_test"})) self.assertTrue( self._q(query.exists(query.collection("collection_for_test"))))
def test_delete(self): ref = self._create()["ref"] self._q(query.delete(ref)) self.assertFalse(self._q(query.exists(ref)))
def test_foreach(self): refs = [self._create()["ref"], self._create()["ref"]] self._q(query.foreach(query.delete, refs)) for ref in refs: self.assertFalse(self._q(query.exists(ref)))
def _define_match_set(query_filter: sql.Filter) -> QueryExpression: field_name = query_filter.column.name comparison_value = query_filter.value index_name_for_collection = functools.partial(index_name, query_filter.table_name) convert_to_collection_ref_set = functools.partial(convert_to_ref_set, query_filter.table_name) get_info_indexes_with_references = lambda collection_name, field_name: q.map_( q.lambda_("info_index_ref", q.get(q.var("info_index_ref"))), q.paginate( q.match( q.index( index_name( "information_schema_indexes_", column_name="name_", index_type=IndexType.TERM, )), index_name( collection_name, column_name=field_name, index_type=IndexType.REF, ), ), ), ) index_name_for_field = functools.partial(index_name_for_collection, field_name) equality_range = q.range( q.match(q.index(index_name_for_field(IndexType.VALUE))), [comparison_value], [comparison_value], ) if query_filter.checks_whether_equal: if field_name == "ref": assert isinstance(comparison_value, str) return q.singleton( q.ref(q.collection(query_filter.table_name), comparison_value)) return q.let( { "ref_index": q.index(index_name_for_field(IndexType.REF)), "term_index": q.index(index_name_for_field(IndexType.TERM)), "info_indexes": get_info_indexes_with_references(query_filter.table_name, field_name), "comparison_value": comparison_value, }, q.if_( q.exists(q.var("ref_index")), q.match( q.var("ref_index"), get_foreign_key_ref( q.var("comparison_value"), # Assumes that there is only one reference per foreign key # and that it refers to the associated collection's ID field # (e.g. {'associated_table': 'id'}). # This is enforced via NotSupported errors when creating collections. q.select([0, DATA, "referred_table_"], q.var("info_indexes")), ), ), q.if_( q.exists(q.var("term_index")), q.match( q.var("term_index"), q.var("comparison_value"), ), convert_to_collection_ref_set(equality_range), ), ), ) # In the building of Filter objects from SQL tokens, we enforce the convention # of <column name> <operator> <value> for WHERE clauses, so we build the FQL queries # assuming that '>' means 'column value greater than literal value'. I can't think # of a good way to centralize the knowledge of this convention across # all query translation, so I'm leaving this note as a warning. if query_filter.checks_whether_greater_than: inclusive_comparison_range = q.range( q.match(q.index(index_name_for_field(IndexType.VALUE))), [comparison_value], [], ) return convert_to_collection_ref_set( q.difference(inclusive_comparison_range, equality_range)) if query_filter.checks_whether_greater_than_or_equal: inclusive_comparison_range = q.range( q.match(q.index(index_name_for_field(IndexType.VALUE))), [comparison_value], [], ) return convert_to_collection_ref_set(inclusive_comparison_range) if query_filter.checks_whether_less_than: inclusive_comparison_range = q.range( q.match(q.index(index_name_for_field(IndexType.VALUE))), [], [comparison_value], ) return convert_to_collection_ref_set( q.difference(inclusive_comparison_range, equality_range)) if query_filter.checks_whether_less_than_or_equal: inclusive_comparison_range = q.range( q.match(q.index(index_name_for_field(IndexType.VALUE))), [], [comparison_value], ) return convert_to_collection_ref_set(inclusive_comparison_range) raise exceptions.NotSupportedError( f"Unsupported comparison {query_filter.comparison} was received.")
def test_create_function(self): self._q(query.create_function({"name": "a_function", "body": query.query(lambda x: x)})) self.assertTrue(self._q(query.exists(query.function("a_function"))))
def test_create_database(self): self.admin_client.query(query.create_database({"name": "database_for_test"})) self.assertTrue(self.admin_client.query(query.exists(query.database("database_for_test"))))
def create_indexes(client): indexes = [{ "name": "user_by_email", "source": q.collection("users"), "terms": [{ "field": ["data", "email"] }], }, { "name": "products_search_by_name", "source": { "collection": q.collection('products'), "fields": { "wordparts": q.query(lambda product: wordPartsGenerator( q.select(['data', 'name'], product))) } }, "terms": [{ "binding": 'wordparts' }], }, { "name": "products_search_by_category", "source": q.collection('products'), "terms": [{ "field": ["data", "categories"] }], }, { "name": "products_sort_by_name_asc", "source": q.collection('products'), "terms": [{ "field": ["ref"] }], "values": [ { "field": ["data", "name"] }, { "field": ["ref"] }, ] }, { "name": "products_sort_by_price_asc", "source": q.collection('products'), "terms": [{ "field": ["ref"] }], "values": [ { "field": ["data", "price"] }, { "field": ["ref"] }, ] }, { "name": "products_sort_by_price_desc", "source": q.collection('products'), "terms": [{ "field": ["ref"] }], "values": [ { "field": ["data", "price"], "reverse": True }, { "field": ["ref"] }, ] }, { "name": "products_sort_by_created_asc", "source": q.collection('products'), "values": [ { "field": ["data", "createdAt"] }, { "field": ["ref"] }, ] }] client.query( q.map_( lambda index: q.if_(q.exists(q.index(q.select(["name"], index))), True, q.create_index(index)), indexes))
def callback_handler_func(update: Update, context: CallbackContext): user = User(update.effective_chat.id) callback_message = update.callback_query.message.reply_markup.inline_keyboard[ 0][0].callback_data [command, payload] = callback_message.split(sep='=') if command == 'subscribe': user.subscribe_to_anime(payload) elif command == 'unsubscribe': user.unsubscribe_from_anime(payload) elif command == 'getlatest': try: anime_info = scraper.get_anime_info(payload) latest_episode_download_link = shorten( scraper.get_download_link(anime_info['latest_episode_link'], resolution=user.resolution)) markup = [[ InlineKeyboardButton(text='Download', url=latest_episode_download_link) ]] context.bot.send_message(chat_id=user.chat_id, text=anime_info['latest_episode_title'], reply_markup=InlineKeyboardMarkup(markup)) except CannotDownloadAnimeException as err: log_error(err) context.bot.send_message(chat_id=user.chat_id, text="Sorry," + payload + "could not be downloaded at this " "time!") context.bot.send_message(chat_id=os.getenv('ADMIN_CHAT_ID'), text='A user tried to download ' + payload + "but could not due to error: " + str(err)) return except Exception as err: log_error(err) return else: # check if anime is in our anime registry try: anime_from_db = client.query( q.if_( q.exists( q.match(q.index(anime_by_id), anime_info['anime_id'])), q.let( { 'anime': q.get( q.match(q.index(anime_by_id), anime_info['anime_id'])) }, q.if_( q.gt( anime_info['number_of_episodes'], q.select(['data', 'episodes'], q.var('anime'))), q.var('anime'), None)), None)) except errors.NotFound: anime_from_db = None if anime_from_db is not None: send_update_to_subscribed_users( anime_from_db, download_links={ user.resolution: latest_episode_download_link }, anime_info=anime_info) elif command == 'set_resolution': try: new_res = Resolution(payload) user.resolution = new_res context.bot.send_message( chat_id=user.chat_id, text= f'Your desired resolution has been set to {new_res.value}({resolutions[new_res]}).\nThis resolution will be used for your future /subscribe and /latest commands.' ) except ValueError: context.bot.send_message(chat_id=user.chat_id, text='Unidentified resolution level!') context.bot.send_message(chat_id=os.getenv('ADMIN_CHAT_ID'), text='Unidentified resolution level!') else: pass
def test_exists(self): self.assertJson(query.exists(query.collection("widget")), '{"exists":{"collection":"widget"}}') self.assertJson(query.exists(query.collection("widget"), ts=123), '{"exists":{"collection":"widget"},"ts":123}')
def subscribe_to_anime(self, anime_link: str): try: # create a new anime document anime_info = anime_alarm.utils.GGAScraper().get_anime_info( anime_link) print(anime_info['anime_id']) result = client.query( q.let( { 'user_anime_list': q.select(['data', 'animes_watching'], q.get(q.ref(q.collection(users), self.chat_id))), }, q.if_( # check if this anime exists in the db q.exists( q.match(q.index(anime_by_id), anime_info['anime_id'])), # if it exists... q.let( { 'anime_ref': q.select( 'ref', q.get( q.match(q.index(anime_by_id), anime_info['anime_id']))) }, q.if_( # check if user has subscribed to this anime already q.contains_value(q.var('anime_ref'), q.var('user_anime_list')), 'This anime is already on your watch list!', q.do( q.update( q.ref(q.collection(users), self.chat_id), { 'data': { 'animes_watching': q.append( q.var('user_anime_list'), [q.var('anime_ref')]) } }), q.update( q.var('anime_ref'), { 'data': { 'followers': q.add( q.select([ 'data', 'followers' ], q.get( q.var('anime_ref'))), 1) } }), ))), q.let( {'new_anime_id': q.new_id()}, q.do( # create new anime document q.create( q.ref(q.collection(animes), q.var('new_anime_id')), { 'data': { 'title': anime_info['title'], 'followers': 1, 'link': anime_link, 'anime_id': anime_info['anime_id'], 'anime_alias': anime_info['anime_alias'], 'episodes': anime_info['number_of_episodes'], 'last_episode': { 'link': anime_info[ 'latest_episode_link'], 'title': anime_info[ 'latest_episode_title'], }, } }), # add to user's list of subscribed animes q.update( q.ref(q.collection(users), self.chat_id), { 'data': { 'animes_watching': q.append( q.var('user_anime_list'), [ q.ref( q.collection(animes), q.var('new_anime_id')) ]) } }), ))))) if isinstance(result, str): updater.bot.send_message(chat_id=self.chat_id, text=result) else: updater.bot.send_message( chat_id=self.chat_id, text='You are now listening for updates on ' + anime_info['title']) except Exception as err: log_error(err)