def _get_gcm_client(self, recipient_type=None):
if recipient_type == "ios":
try:
key = GCM['IOS_API_KEY']
assert key is not None
return GCMClient(api_key=key)
except (KeyError, AssertionError):
raise ImproperlyConfigured(
"The IOS_API_KEY must be defined in order to deliver "
"push notifications to iOS devices"
)
return GCMClient(api_key=GCM['API_KEY'])
def android(tokens, val, project_id):
"""
Sends push message to android clients.
Args:
- tokens(list): client token list
- val(dict): including title, body, type, language, icon, image, badge.
"""
path = VAULT_PUSH_FCM_PATH.format(project_id=project_id)
data = vault.read(path=path)['data']
api_key = data['api_key']
client = GCMClient(api_key=api_key)
alert = val['extra']
options = {
'notification': {
'title': val['title'],
'body': val['body'],
'sound': 'default',
'color': "#009999",
"icon": val['icon'] or 'default'
},
'collapse_key': 'collapse_key',
'delay_while_idle': True,
# todo push message time to live
'time_to_live': 604800,
}
return client.send(tokens, alert, **options)
def _send(self, device_key, payload):
if not self._api_key:
raise PushAuthException()
gcm_client = GCMClient(self._api_key)
try:
response = gcm_client.send([device_key], payload)
if response.errors:
raise response.errors.pop()
canonical_id = None
if response.canonical_ids:
canonical_id = response.canonical_ids[0].new_id
return canonical_id
except GCMAuthError:
raise PushAuthException()
except (GCMMissingRegistrationError, GCMInvalidRegistrationError,
GCMUnregisteredDeviceError):
raise PushInvalidTokenException()
except (GCMInvalidPackageNameError, GCMMismatchedSenderError,
GCMMessageTooBigError, GCMInvalidDataKeyError,
GCMInvalidTimeToLiveError):
raise PushInvalidDataException()
except (GCMTimeoutError, GCMInternalServerError,
GCMDeviceMessageRateExceededError):
raise PushServerException()
def gcm_message():
if request.form.get('message'):
gcmClient = GCMClient(api_key=os.environ.get('GCM_API_KEY'))
alert = {
'subject': 'Subject goes here', # TODO: set a better subject
'message': request.form.get('message')
}
session = db.Session()
gcm_id_list = [user.gcm_id for user in session.query(db.User).all()]
session.close()
response = gcmClient.send(gcm_id_list,
alert,
time_to_live=3600)
if response:
return ApiResponse({
'message': 'Mesazhi u dergua'
})
else:
return ApiResponse({
'message': 'Father, why have you forsaken me?'
})
else:
return ApiResponse({
'message': 'Can\'t send a blank message...'
})
def create_campaign():
session = db.Session()
data = json.loads(request.data)
hospital_id = request.args.get('hospital_id', 0)
# hospital = session.query(db.Hospital).filter_by(_id=hospital_id).first()
hospital = session.query(db.Hospital).first()
name = data['name']
message = data['message']
bloodtypes = data['bloodtypes']
start_date = datetime.datetime.now()
end_date = datetime.datetime.now() + datetime.timedelta(days=10)
campaign = db.Campaign(hospital._id, name, message, start_date, end_date)
session.add(campaign)
session.commit()
for bloodtype in bloodtypes:
campaign_blood = db.CampaignBlood(campaign._id, bloodtype)
session.add(campaign_blood)
session.commit()
gcmClient = GCMClient(api_key=os.environ.get('GCM_API_KEY'))
alert = {
'subject': 'Fushate e re',
'message': campaign.hospital.name,
'data': {
'id': campaign._id,
'name': name,
'hospital': {
'name': campaign.hospital.name,
'latitude': campaign.hospital.latitude,
'longitude': campaign.hospital.longitude,
},
'message': message,
'start_date': to_timestamp(start_date),
'end_date': to_timestamp(end_date)
}
}
interested_users = session.query(db.User).filter(db.User.blood_type.in_(bloodtypes))
gcm_id_list = [user.gcm_id for user in interested_users]
session.close()
response = gcmClient.send(gcm_id_list, alert, time_to_live=3600)
if response:
return ApiResponse({
'status': 'ok'
})
else:
return ApiResponse({
'status': 'some error occurred'
})
def send_push(data_for_push, message):
GCMC_android = GCMClient(api_key=key_android)
GCMC_ios = GCMClient(api_key=key_ios)
for l in data_for_push:
if l[0]:
try:
push(GCMC_android, message, l[1])
except:
GCMC_android = GCMClient(api_key=key_android)
try:
push(GCMC_android, message, l[1])
except:
GCMC_android = GCMClient(api_key=key_android)
else:
try:
push(GCMC_ios, message, l[1])
except:
traceback.print_exc()
GCMC_ios = GCMClient(api_key=key_ios)
try:
push(GCMC_ios, message, l[1])
except:
GCMC_ios = GCMClient(api_key=key_ios)
def gcm_client():
"""Return GCM client."""
return GCMClient(api_key='1234')
def __init__(self, dbInfo, GCMKey=''):
self.conn = psycopg2.connect(dbInfo)
self.gcm_server = GCMClient(GCMKey)
from flask import Flask, jsonify, render_template
from flask import abort
from flask import make_response, request
import requests
import json
from pushjack import GCMClient
import sqlite3 as sql
DATABASE = 'SmartlockUser.db'
client = GCMClient(api_key='AIzaSyAG4qhcqNqkJLtBQTmljCI8ijWuBtFY_YM')
app = Flask(__name__)
app.config.from_object(__name__)
app.secret_key = 'my key'
#-------------------------------------------------ANDROID-APP-POST-REQUESTS-------------------------------------------------------------------------
#save details of user into database
@app.route('/smartlock/regis', methods=['POST'])
def create_user():
Username = request.json['Username']
Password = request.json['Password']
Regiskey = request.json['Regiskey']
con = sql.connect("SmartlockUser.db")
cur = con.cursor()
cur.execute(
"INSERT INTO SmartlockUser (Username,Password,Regiskey) VALUES (?,?,?)",
(Username, Password, Regiskey))
from .model import Pushno as obj
from module.customer.model import CustomerBusinesses as business
from module.user.model import Users
from .__init__ import \
__pushno_head__ as __head__, \
__pushno_heads__ as __heads__
from .pushno_valid import \
resource_fields, resource_fields_wrap, \
field_inputs, field_inputs_wrap,\
field_inputs_post, resource_fields_post,\
field_inputs_send, resource_fields_send
gcm_client = GCMClient(api_key=settings.GCM_API_KEY)
#FIXME: use config
apns_client = APNSClient(certificate=settings.APNS_API_KEY,
default_error_timeout=10,
default_expiration_offset=2592000,
default_batch_size=1000)
# TODO: need limit max sender?
class PushnoReg(Resource):
response = None
args = None
args_wrap = None
def __init__(self):
