def create(self, params, meta, **kwargs):
validated = kwargs.get('validated')
user = kwargs.get('context').get('user') # user dict
user_id = user.get('user')
project_id = user.get('project')
service = user.get('service')
channel_id = generate_uuid()
self._check_create_params(validated)
body = {
"project_id": project_id,
"created_by": user_id,
"validated_channel": self._check_create_params(validated),
"service": service,
"channel_id": channel_id,
}
rpc_params = self.rpc_client.rpc_call("create_channel",
body,
blocking=False)
return {
"id": channel_id,
"name": body['validated_channel']['name'],
"description": body['validated_channel']['description'],
"type": body['validated_channel']['type'],
"banned_subscribers": [],
"invitees": [],
"joinRequests": [],
"owner": [user_id],
"managers": [user_id],
"subscribers": [user_id],
"tracking_id": rpc_params['tracking_id'],
}
def create_push_segment(self, project_id=None, **kwargs):
"""
Creates a push segment with given args.
Args:
**kwargs (dict): project_id, name, residents
- project_id: project_id
- name (str): name of segment
- residents (dict): object of expressions which represent the audience set of
segment
Returns:
"""
project_id = project_id or kwargs['project_id']
bucket = self.get_bucket(project_id, 'segment')
segment = bucket.get(kwargs['segment_id'])
if segment.exists:
# todo: let client know the new segment id
kwargs['segment_id'] = generate_uuid()
segment = bucket.get(kwargs['segment_id'])
segment.data = {'name': kwargs['name'], 'residents': kwargs['residents'], 'id': kwargs['segment_id']}
segment.add_index('segment_bin', project_id)
for val in kwargs['residents']['sets'].values():
segment.add_index('tag_seg_bin', val['key'])
segment.data.update(self.get_creation_info())
segment.store()
zlogger.info("New segment is created. Project id:{}, segment id:{}".format(
project_id, segment.key))
def create(self, params, meta, **kwargs):
user = kwargs.get('context').get('user') # user dict
project_id = user.get('project_id')
admin_id = user.get('admin_id')
account_id = user.get('account_id')
validated = kwargs.get("validated")
channel_id = generate_uuid()
self._check_create_params(validated)
body = {
"project_id": project_id,
"account_id": account_id,
"admin_id": admin_id,
"service": "roc",
"channel_id": channel_id,
"channel_parameters": validated
}
rpc_params = self.rpc_client.rpc_call("create_channel_as_admin",
body,
blocking=False)
return {
"id": channel_id,
"name": body['channel_parameters']['name'],
"description": body['channel_parameters']['description'],
"type": body['channel_parameters']['type'],
"tracking_id": rpc_params['tracking_id'],
}
def create(self, params, meta, **kwargs):
user = kwargs.get('context').get('user') # user dict
user_id = user.get('user')
project_id = user.get('project')
service = user.get('service')
validated = kwargs.get('validated')
client_id = generate_uuid()
body = {
"target_id": user_id,
"validated_client": validated,
"project_id": project_id,
"service": service,
"client_id": client_id
}
rpc_params = self.rpc_client.rpc_call("create_client",
body,
blocking=False)
return {
"id": client_id,
"tracking_id": rpc_params['tracking_id'],
"app_version": rpc_params['validated_client']['app_version'],
"device_type": rpc_params['validated_client']['device_type'],
"language": rpc_params['validated_client']['language'],
"country": rpc_params['validated_client']['country'],
"os_version": rpc_params['validated_client']['os_version'],
}
def create(self, params, meta, **kwargs):
validated = kwargs.get('validated')
user = kwargs.get('context').get('user') # user dict
user_id = user.get('user')
project_id = user.get('project')
service = user.get('service')
subscriber = SubscriberCache(user.get('project'), user.get('service'), user.get('user'),
rpc_client=self.rpc_client).get_or_set()
contacts_of_user = subscriber['contacts']
channels_of_user = subscriber['channels']
channel = validated['channel']
validated_message = self._check_create_params(user_id, channels_of_user, contacts_of_user,
validated, project_id, service)
validated_message['id'] = generate_uuid()
body = {
"project_id": project_id,
"service": service,
# validated message becomes a dict with keys
# [id, title, body, sentTime, receiver, channel, sender]
"validated_message": validated_message,
}
rpc_params = self.rpc_client.rpc_call("post_message", body, blocking=False)
return {
"id": rpc_params['validated_message']['id'],
"title": rpc_params['validated_message']['title'],
"body": rpc_params['validated_message']['body'],
"sender": rpc_params['validated_message']['sender'],
"receiver": validated['receiver'],
"sentTime": rpc_params['validated_message']['sentTime'],
"channel": channel,
"tracking_id": rpc_params['tracking_id'],
}
def init_zops_models(target_model):
"""
Initialize given target_model class. Assign a uuid to _id attr.
Args:
target_model: Model class
"""
target_model._id = generate_uuid()
target_model.creation_time = datetime.utcnow()
def create(self, params, meta, **kwargs):
validated = kwargs.get('validated')
user = kwargs.get('context').get('user') # user dict
project_id = user.get('project')
service = user.get('service')
segment_id = generate_uuid()
body = dict(project_id=project_id,
**validated,
service=service,
segment_id=segment_id)
rpc_params = self.rpc_client.rpc_call("create_push_segment",
body,
blocking=False)
rpc_params['id'] = segment_id
return rpc_params
def create_client(self, **kwargs):
"""
Creates a new client with given target_id and validated_client.
Args:
**kwargs: project_id, target_id, validated_client
- project_id: project_id
- target_id: id of target who owns client
- validated_client: dict of client information including clientId, token,
appVersion, deviceType, language, country, osVersion.
Returns:
"""
# TODO: device_type's validity should be controlled before this method.
client_bucket = self.get_bucket(kwargs['project_id'], 'client')
target_bucket = self.get_bucket(kwargs['project_id'], 'target')
kwargs['validated_client']['target_id'] = kwargs['target_id']
kwargs['validated_client']['id'] = kwargs['client_id']
kwargs['validated_client'].update(self.get_creation_info())
client = client_bucket.get(kwargs['client_id'])
if client.exists:
# todo: let client know the new client id
kwargs['validated_client']['id'] = generate_uuid()
client = client_bucket.get(kwargs['validated_client']['id'])
client.data = kwargs['validated_client']
target = target_bucket.get(kwargs['target_id'])
client.store()
zlogger.info("Client is created. Project id:{}, target id:{}, client id:{}".format(
kwargs['project_id'], kwargs['target_id'], client.key))
if target.exists:
target.data['clients'][client.key] = ""
zlogger.info("Client: {} is added into Target Object . Project id:{}, target id:{}".format(
client.key, kwargs['project_id'], target.key))
else:
target.data = {'clients': {client.key: ""}}
zlogger.info("Target is created and Client: {} is added. Project id:{}, target id:{}".format(
client.key, kwargs['project_id'], target.key))
target.data['last_update_time'] = datetime.now().strftime(DATETIME_FORMAT)
target.store()
def create(self, params, meta, **kwargs):
validated = kwargs.get('validated')
user = kwargs.get('context').get('user') # user dict
user_id = user.get('user')
project_id = user.get('project')
service = user.get('service')
channel_id = validated.get('channel')
invitee = validated.get('invitee')
actor = self.check_create_request(user, channel_id, invitee)
invite_id = generate_uuid()
body = {
"project_id": project_id,
"inviter": user_id,
"channel": channel_id,
"invite_message": validated.get('invite_message'),
"service": service,
"invite_id": invite_id
}
rpc_params = {}
if actor == "channel-manager":
body['invitee'] = invitee
rpc_params = self.rpc_client.rpc_call("create_invite_by_channel",
body,
blocking=False)
elif actor == "subscriber":
rpc_params = self.rpc_client.rpc_call(
"create_invite_by_subscriber", body, blocking=False)
return {
"id": rpc_params.get('invite_id'),
"inviter": rpc_params.get('inviter'),
"invitee": invitee,
"channel": channel_id,
"invite_message": rpc_params.get('invite_message'),
"approve": "not_evaluated",
"tracking_id": rpc_params.get('tracking_id'),
}
def create(self, params, meta, **kwargs):
validated = kwargs.get('validated')
user = kwargs.get('context').get('user') # user dict
user_id = user.get('user')
project_id = user.get('project')
service = user.get('service')
message_id = generate_uuid()
if not validated['audience'] and not validated['consumers']:
raise HTTPBadRequest(description="Audience or consumers field must be filled")
elif validated['audience'] and validated['consumers']:
raise HTTPBadRequest(description="Audience and consumers field can not be filled at the same time")
body = dict(
target_id=user_id,
validated_message=validated,
project_id=project_id,
service=service,
message_id=message_id
)
rpc_params = self.rpc_client.rpc_call("post_push_message", body, blocking=False)
return {
"id": message_id,
"target_id": rpc_params['target_id'],
"tracking_id": rpc_params['tracking_id'],
"title": rpc_params['validated_message']['title'],
"body": rpc_params['validated_message']['body'],
"type": rpc_params['validated_message']['type'],
"language": rpc_params['validated_message']['language'],
"icon": rpc_params['validated_message']['icon'],
"image": rpc_params['validated_message']['image'],
"badge": rpc_params['validated_message']['badge'],
"audience": rpc_params['validated_message']['audience'],
"schedule_time": rpc_params['validated_message']['schedule_time'],
"extra": rpc_params['validated_message']['extra'],
"consumers": rpc_params['validated_message']['consumers']
}
def post_push_message(self, **kwargs):
"""
Creates a push message with given segment id.
Segment id check must be performed. If it is OK, then segment's resident set must be
retrieved and push operation performed according to the message's type.
`audience` is a segment id, it is retrieved from db. its `residents` field in following
form:
residents = {
"sets": {
"a": {"key": "color", "relation": "=", "value": "blue", "intention": "target"},
"b": {"key": "age", "relation": "<", "value": "55", "intention": "target"},
"c": {"key": "birth_year", "relation": "()", "value": "["1980","2010"]",
"intention": "target"},
"d": {"key": "device", "relation": "=", "value": "apple", "intention": "client"},
},
"expression": "(a U b) - (c n d)"
}
Sets must be obtained from riak concurrently. For each set in the given residents object,
there must be a worker that parses the given set definition, gets keys from riak by using
2i, put it to the redis and map its set_key to the redis key.
Examples:
set: "a": {"key": "level", "relation": "=", "value": "10"}
2i query: level_int, 10
redis_key: Project:Example123:a
redis_key_map: {"a": "Project:Example123:a"}
Main worker sends redis keys of sets to sub-workers, so that they can put them to redis with
expected keys.
Main worker subscribes a redis pub/sub channel after sending jobs to the sub-workers. Each
worker that finishes its job publishes a message to redis channel. Main worker counts the
messages that are published to the channel and when it reach to the number of sets, starts
the evaluation of the expression.
For the evaluation of the expression a SEXPParser instance must be obtained.
sexp = SEXPParser(residents["sets"], residents["expression"], redis_key_map, redis_instance)
`sexp.expression_stack` gives the parsed expression stack
evaluated_set_redis_key = sexp.evaluate_stack() # this is the final redis key
then, evaluate_stack method must be called to evaluate the stack.
Args:
**kwargs: project_id, target_id, validated_message
- project_id
- validated_message: dict of validated message including title, body, type,
language, icon, image, badge, audience.
- target_id: sender of the message
Returns:
"""
if kwargs['validated_message']['audience']:
kwargs['validated_message']["consumers"] = []
segment_id = kwargs['validated_message']['audience']
segment = self.get_obj(kwargs['project_id'], 'segment', segment_id)
residents = segment.data['residents']
intentions = [val['intention'] for val in residents['sets'].values()]
case = 'single' if len(set(intentions)) == 1 else 'mix'
single_case_type = set(intentions).pop() if case == 'single' else None
client_ids = self.calculate_sets(residents, case, single_case_type, kwargs['project_id'])
else:
consumers = kwargs['validated_message']['consumers']
client_ids = self.get_targets_client_ids(kwargs['project_id'], consumers)
bucket = self.get_bucket(kwargs['project_id'], 'push_message')
message = bucket.get(kwargs['message_id'])
if message.exists:
kwargs['validated_message']['id'] = generate_uuid()
message = bucket.get(kwargs['validated_message']['id'])
kwargs['validated_message']['target_id'] = kwargs['target_id']
message.data = kwargs['validated_message']
formatted_time = format(time.time(), '.7f')
timestamp = int(self.last) - int("".join(str(formatted_time).split('.')))
message.add_index('push_message_bin', "{}_{}".format(kwargs['target_id'], timestamp))
message.data.update(self.get_creation_info())
message.store()
self.send_push_message(kwargs['project_id'], kwargs['service'], client_ids, kwargs['validated_message'], message.key)
