def api_login_post():
# process user login
email = request.headers.get('email')
password = request.headers.get('password')
remember = True if request.headers.get('remember') else False
firebaseToken = request.headers.get('firebase_token')
user = User.query.filter_by(email=email).first()
if user and check_password_hash(user.password, password):
print("==> New user logged in: ", email)
if firebaseToken and firebaseToken != '':
print("This user need to setup firebase...")
# subscribe to followed topic using new firebase token
if user.subscribeAll:
messaging.subscribe_to_topic([firebaseToken], 'all')
print('Subscribe to all')
cs = []
for c in user.channels:
cs.append(c.id)
messaging.subscribe_to_topic([firebaseToken], c.id)
print('Subscribe to channels: ', cs)
# Identity can be any data that is json serializable
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
return jsonify(access_token=access_token,
refresh_token=refresh_token), 200
else:
return jsonify(msg='Email or password is incorrect!'), 400
async def register(request):
data = await request.json()
subscriber_id = data['subscriber_id']
tokens = [subscriber_id]
messaging.subscribe_to_topic(tokens, 'updates')
return JSONResponse({'success': True})
def test_invalid_topic(self, topic):
expected = 'Topic must be a non-empty string.'
with pytest.raises(ValueError) as excinfo:
messaging.subscribe_to_topic('test-token', topic)
assert str(excinfo.value) == expected
with pytest.raises(ValueError) as excinfo:
messaging.unsubscribe_from_topic('test-tokens', topic)
assert str(excinfo.value) == expected
def test_topic_management_timeout(self):
self.fcm_service._client.session.mount(
'https://iid.googleapis.com',
testutils.MockAdapter(
json.dumps({'results': [{}, {
'error': 'error_reason'
}]}), 200, self.recorder))
messaging.subscribe_to_topic(['1'], 'a')
assert len(self.recorder) == 1
assert self.recorder[0]._extra_kwargs['timeout'] == 4
def test_invalid_tokens(self, tokens):
expected = 'Tokens must be a string or a non-empty list of strings.'
if isinstance(tokens, six.string_types):
expected = 'Tokens must be non-empty strings.'
with pytest.raises(ValueError) as excinfo:
messaging.subscribe_to_topic(tokens, 'test-topic')
assert str(excinfo.value) == expected
with pytest.raises(ValueError) as excinfo:
messaging.unsubscribe_from_topic(tokens, 'test-topic')
assert str(excinfo.value) == expected
def test_subscribe_to_topic_non_json_error(self, status):
_, recorder = self._instrument_iid_service(status=status, payload='not json')
with pytest.raises(messaging.ApiCallError) as excinfo:
messaging.subscribe_to_topic('foo', 'test-topic')
reason = 'Unexpected HTTP response with status: {0}; body: not json'.format(status)
code = messaging._MessagingService.IID_ERROR_CODES.get(
status, messaging._MessagingService.UNKNOWN_ERROR)
assert str(excinfo.value) == reason
assert excinfo.value.code == code
assert len(recorder) == 1
assert recorder[0].method == 'POST'
assert recorder[0].url == self._get_url('iid/v1:batchAdd')
def test_subscribe_to_topic_error(self, status):
_, recorder = self._instrument_iid_service(
status=status, payload=self._DEFAULT_ERROR_RESPONSE)
with pytest.raises(messaging.ApiCallError) as excinfo:
messaging.subscribe_to_topic('foo', 'test-topic')
assert str(excinfo.value) == 'error_reason'
code = messaging._MessagingService.IID_ERROR_CODES.get(
status, messaging._MessagingService.UNKNOWN_ERROR)
assert excinfo.value.code == code
assert len(recorder) == 1
assert recorder[0].method == 'POST'
assert recorder[0].url == self._get_url('iid/v1:batchAdd')
def create_match(db, user, matching_user):
"""Does all the setup for creating a new match"""
# Create a new match
_, match = db.collection("matches").add({
"users": [
db.collection("users").document(user["id"]),
db.collection("users").document(matching_user["id"]),
]
})
message = {
"content": db.collection("matches").document(match.id),
"type": "match",
"sender": None,
"createdAt": datetime.now(),
}
# Add message to conversations with Aida
db.collection("users").document(
user["id"]).collection("messages").add(message)
db.collection("users").document(
matching_user["id"]).collection("messages").add(message)
tokens = []
if user.get("notification_token"):
tokens.append(user["notification_token"])
if matching_user.get("notification_token"):
tokens.append(matching_user["notification_token"])
if not tokens:
return
# Setup notifications for messages between users
topic = f"/topics/match-{match.id}"
messaging.subscribe_to_topic(
tokens=tokens,
topic=topic,
)
# Send a match notification to both users
messaging.send(
messaging.Message(
notification=messaging.Notification(
title="Aida", body="I've found you a match! 😍"),
topic=topic,
))
def send_to_topic():
# [START send_to_topic]
# The topic name can be optionally prefixed with "/topics/".
topic = 'notify'
# See documentation on defining a message payload.
message = messaging.Message(
data={
'score': '850',
'time': '2:45',
},
topic=topic,
)
# Send a message to the devices subscribed to the provided topic.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)
registration_tokens = [
'chCK9jrYEQ8:APA91bEf0ZxbIsw0yCvHw1SrnitL1iDLV3eus-bXcfnuyDCSHlJwyh2saKLpEpHrJUDJT6ExcF0YIk0oA83Ps_IjlBk-MAxX3_74m6fQtHql1kP5Ks0lehn2xbdbA5TQ87aj6B0_R2kN',
# ...
]
# Unubscribe the devices corresponding to the registration tokens from the
# topic.
response = messaging.subscribe_to_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response, 'tokens were subscribed successfully')
def subscribe_to_topic(topic, tokens, app):
# [START subscribe]
# Subscribe the devices corresponding to the registration tokens to the
# topic.
response = messaging.subscribe_to_topic(tokens, topic, app)
# See the TopicManagementResponse reference documentation
# for the contents of response.
return response.success_count
def test_subscribe_to_topic(self, args):
_, recorder = self._instrument_iid_service()
resp = messaging.subscribe_to_topic(args[0], args[1])
self._check_response(resp)
assert len(recorder) == 1
assert recorder[0].method == 'POST'
assert recorder[0].url == self._get_url('iid/v1:batchAdd')
assert json.loads(recorder[0].body.decode()) == args[2]
def register_topic(self, list_registration_token, name_topic):
"""
Function to add or create group under name is topic
:param list_registration_token: [list, registration, token] in list format
:param name_topic: name of the groups consists of token's app
:return: None
"""
response = messaging.subscribe_to_topic(list_registration_token,
name_topic)
print(response.success_count, 'tokens were subscribed successfully')
return
def add_subscriber_to_topic(token, dist_id):
registration_tokens = [token]
topic = _get_topic_from_dist_id(dist_id)
response = messaging.subscribe_to_topic(registration_tokens, topic)
if dist_id not in _get_all_subscribed_dists_from_db():
doc_ref = db.collection(u'static').document(u'topics_subscribed')
dist_name = get_dist_name_from_id_db(dist_id)
doc = {str(dist_id): {"name": dist_name, "count": 0}}
doc_ref.set(doc, merge=True)
return response.success_count
def api_profile_update():
user_email = get_jwt_identity()
print("user identity (email): ", user_email)
subscribeAll=request.headers.get('subscribeAll')
firebaseToken = request.headers.get('firebaseToken')
user = User.query.filter_by(email=user_email).first()
if subscribeAll == 0 or subscribeAll == '0':
user.subscribeAll = False
messaging.unsubscribe_from_topic(firebaseToken, "all")
elif subscribeAll == 1 or subscribeAll == '1':
user.subscribeAll = True
messaging.subscribe_to_topic(firebaseToken, "all")
else:
return jsonify(msg = "Invalid value"), 400
db.session.commit()
return jsonify(msg = "Successfully update subscribe/Unsubscribe to all"), 200
def send_notification_to_all(message):
registration_tokens = list(
User.objects.exclude(fcm_token__isnull=True).exclude(
fcm_token__exact='').values_list('fcm_token', flat=True))
topic = 'events'
messaging.subscribe_to_topic(registration_tokens, topic)
message = messaging.Message(
android=messaging.AndroidConfig(
ttl=datetime.timedelta(seconds=3600),
priority='normal',
notification=messaging.AndroidNotification(
title=message["title"],
body=message["message"],
),
),
topic=topic,
)
response = messaging.send(message)
print(response)
messaging.unsubscribe_from_topic(registration_tokens, topic)
def refresh_subscription(push_token, topics):
"""
1. Initialize firebase
2. find tags to add / remove
3. update
:param push_token: required
:param topics: tagObjs
:return:
"""
# if you use multiple environments (e.g. dev,prod..)
_id = "environment-or-app-id"
if _id not in topics:
topics.append(_id)
_initialize_firebase()
try:
followed_tags = _get_topics_by_token(push_token)
except:
followed_tags = []
new_tags = [topic for topic in topics if topic not in followed_tags]
old_tags = [topic for topic in followed_tags if topic not in topics]
for topic in new_tags:
try:
messaging.subscribe_to_topic([push_token], topic)
logging.info("Topic %s added to %s" % (topic, push_token))
except:
logging.error("Could not subscribe %s to %s" % (push_token, topic))
for topic in old_tags:
try:
messaging.unsubscribe_from_topic([push_token], topic)
logging.info("Topic %s removed from %s" % (topic, push_token))
except:
logging.error("Could not unsubscribe %s from %s" %
(topic, push_token))
return
def fcm_subscribe(tokens, topic):
"""
Subscribe the given tokens to a specific FCM topic.
:param tokens: list of FCM tokens
:param topic: FCM topic/category slug
:return: success True/False
"""
try:
_ = messaging.subscribe_to_topic(tokens, topic)
except messaging.ApiCallError as e:
return False
except ValueError as e:
return False
return True
def subscribe_to_topic():
topic = 'highScores'
# [START subscribe]
# These registration tokens come from the client FCM SDKs.
registration_tokens = [
'YOUR_REGISTRATION_TOKEN_1',
# ...
'YOUR_REGISTRATION_TOKEN_n',
]
# Subscribe the devices corresponding to the registration tokens to the
# topic.
response = messaging.subscribe_to_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were subscribed successfully')
def __get_chunk_topic__(self,chunk):
# print(chunk)
topic = ",".join(chunk).encode('utf-8')
topic_sha = hashlib.sha1(topic).hexdigest()
topic_ref = db.reference('all_user_topics_test/{0}'.format(topic_sha))
topic_result = topic_ref.get()
if topic_result is None:
register_response = messaging.subscribe_to_topic(chunk, topic_sha)
self.__handle_register_response__(register_response)
topic_ref.set(topic_sha)
topic_result = topic_sha
return topic_result
def subscribe_to_topic():
topic = 'highScores'
# [START subscribe]
# These registration tokens come from the client FCM SDKs.
# TODO Custom token
registration_tokens = [
'fZJPLFb62PWItwCqle2AoF:APA91bG1V5xxVBjSUVRr2kJkuqGWjG0Tbkywsi_hB1Ss27RgIpCjYSAGGtkm4nL2_vEQKQJ0oWImfp6oQ2VleLch-6_OZuAkkSqGVhVWu80tSa2OK6xvNiPoFJt1Dio_kRk0cDb5Tr-h',
# ...
'deXMEcpHQzc:APA91bGH6_kXLK1OaiaHCimQrvadTNpVMiCm14i7PkT59rL7yC7dyVDedgSp2Mq5rHIA4AuajwYXd8FlaLPyoDbndBbPcp78T_yDgAJg2JlLefrGW5et4lEQMIdApAOcJ3G9xi2FC6ke',
]
# Subscribe the devices corresponding to the registration tokens to the
# topic.
response = messaging.subscribe_to_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were subscribed successfully')
def __create_or_get_topic__(self,user_ids):
if not self.__is_list_of_strings__(user_ids):
raise TypeError("user_id must be a list when sending bulk message")
topic = ",".join(user_ids).encode('utf-8')
topic_sha = hashlib.sha1(topic).hexdigest()
topic_ref = db.reference('topics/{0}'.format(topic_sha))
topic_result = topic_ref.get()
if topic_result is None:
tokens = self.__get_token_list__(user_ids)
register_response = messaging.subscribe_to_topic(tokens, topic_sha)
self.__handle_register_response__(register_response)
topic_ref.set(topic_sha)
topic_result = topic_sha
return topic_result
def api_subscribes_post():
user_email = get_jwt_identity()
print("user identity (email): ", user_email)
id = request.headers.get("playerid")
token = request.headers.get('firebasetoken')
user = User.query.filter_by(email=user_email).first()
player = Player.query.filter_by(id=id).first()
if user and player and token:
res = messaging.subscribe_to_topic(tokens = [token], topic=id)
user.channels.append(player)
db.session.commit()
return jsonify(msg="Successfully create new relation"), 200
else:
return jsonify(msg="There is no Pro Player with id %s" % id), 400
def update_topic_registrations():
topics = map(toString, range(21))
tokens = {}
for topic in topics:
tokens[topic] = []
# get database reference
ref = db.reference('/')
# get user data
snapshot = ref.get()
# parse
users = snapshot["users"]
for key, val in users.items():
tokens[str(val['numTimesPerDay'])].append(key)
# register each topic
for topic, tokens in tokens.items():
if tokens != []:
token_reg_res = messaging.subscribe_to_topic(tokens, topic)
print(token_reg_res)
else:
print("'{}' Topic Empty".format(topic))
def subscribe_to_topics(self, registration_token, topics):
registration_tokens = [registration_token]
for topic in topics:
messaging.subscribe_to_topic(registration_tokens, topic)
cred = credentials.Certificate(
'/home/alex/Downloads/chat/threshold-chat-firebase-adminsdk-fg92b-3258681a34.json'
)
# This is registration token received on mobile phone from the client FCM SDKs.
# There is no way to receive it in Python: it is specific to the given app installation on the phone.
# Every chat client has such a token. All the communication is encrypted with this token.
# How it is received - see Android application at
# https://medium.com/@min2bhandari/firebase-cloud-messaging-with-kotlin-165ac1b0d841
# Replace this token with yours!
registration_token = "eT6B_xQRRFGVtK8xa71zBp:APA91bE9IK2wQtJkoLvEQdjhASPvmdFzxJs-sWedpbh3nSbUWinmtVZ10A8bun4YxG5UXaQHK3ExRZajQSYetdk-Yil-TEkKNjz03b_n45Yp5zV9ZHExtlIlbwr5dd5ukpNSQbx9RkuO"
reg_token2 = "e7Kvae-1T7m54syh-qcDs1:APA91bH4CFtJCssNcPN1OEubMat88zXzW7qrzA2zHzPtzQ6lJa1ddNYuEAAXcDxqXcgvoIKjLc6jOYtYW7QcysgHXRKFLe6AU69kNVqvOZlaTQuA3cHtE8YK1BYFb8wFkrYYpexBrrVf"
# default initialization based on
# export GOOGLE_APPLICATION_CREDENTIALS="/home/alex/Downloads/chat/threshold-chat-firebase-adminsdk-fg92b-3258681a34.json"
# Mentor will give this file. You must not commit it into GitHub!!!
# firebase_admin.initialize_app()
# initialization with explicitly indicated credentials
firebase_admin.initialize_app(cred)
# Now we can subscribe the client to our Chat.
resp = messaging.subscribe_to_topic(registration_token, "ThresholdChat")
# you may check success as follows
# print(resp.success_count)
# 1
# From this point the client will receive messages (Notifications will appear in PopUps in the phone's tray)
def subscribe(self, code: str, locator: str) -> bool:
messaging.subscribe_to_topic(tokens=[locator], topic=code)
return True
def subscribe(token, topic):
messaging.subscribe_to_topic(token, topic)
def test_subscribe():
resp = messaging.subscribe_to_topic(_REGISTRATION_TOKEN, 'mock-topic')
assert resp.success_count + resp.failure_count == 1
def subscribe_to_topic(topic, user):
if not firebase_ins:
firebase_admin.initialize_app(cred, {'projectId': firebase_app})
token = user.userprofile.device_token
if token:
messaging.subscribe_to_topic(tokens=[token], topic=topic, app=None)
options={
'project-id':
'vandyhacks-dbd1b',
'storageBucket':
'vandyhacks-dbd1b.appspot.com',
'databaseURL':
'https://vandyhacks-dbd1b.firebaseio.com'
})
while (True):
# Subscribe to the topic used for communication
topic = 'bcdMessaging' # bcd stands for our project, BottleCompositionDetector
registrationToken = 'AAAArSnKi2M:APA91bGEnpiiHpihogal7C5A34sLBcr8fPThAGHh1lr-s_DnWhAlm2_ODdWaoFmHdqVqX3KmElJBX_rKVjf_tsmQKBaduyNFfbPbF4B1c4gfZA-LgKruYgN7Eg0zPnBBbH0VcAGhMN3j'
subResponse = messaging.subscribe_to_topic(registrationToken, topic)
ref = db.reference('messageVH')
name = ref['name']
bucket = storage.bucket()
imageBlob = bucket.blob(name)
imageBlob.download_to_filename("imageToRead.jpg")
inputFile = cv2.imread("imageToRead.jpg")
#model = tf.keras.applications.VGG16(weights="")
model = tf.keras.models.load_model("convNetModel.h5")