def post(self, request, *args, **kwargs):
form = MessageForm( request.POST )
if form.is_valid():
data = form.cleaned_data
users_t = data["users"].split(",")
message = Message(
author = request.user,
text = data["text"],
title = data["title"],
date = datetime.now()
)
message.save()
message.users.add( request.user )
for user in users_t:
user = user.strip()
try:
if user != request.user.username:
message.users.add( User.objects.get( username = user ) )
except User.DoesNotExist as e:
print user + " does not exist."
message.save()
return HttpResponseRedirect("/mailbox/list.html" )
else:
data = {
"MEDIA_URL" : MEDIA_URL,
"user" : request.user,
"form" : form
}
data.update( csrf( request ) )
return render_to_response( self.template_name, data )
def create_message_for_user(user, channel_id, text):
"""
Create a new message
"""
uc = UserChannel.objects.get(channel_id=channel_id, user_server__user=user)
message = Message(channel_id=channel_id, user_channel=uc, text=text)
message.save()
return message
def create_message_for_user(user, channel_id, text):
"""
Create a new message
"""
uc = UserChannel.objects.get(
channel_id=channel_id, user_server__user=user)
message = Message(channel_id=channel_id, user_channel=uc, text=text)
message.save()
return message
def create(self, validated_data):
# print('serial, create:')
user = self.context['request'].user
# print('self.context', self.context)
# validated data {'room': 'general', 'body': 'ok'}
room = validated_data['room']
msg_body = validated_data['body']
msg = Message(room=room, body=msg_body, user=user)
msg.save()
return msg
def create_message(sender, channel_id, text, user_channel_id):
"""
Create a new message
"""
try:
uc = UserChannel.objects.get(channel_id=channel_id, nickname=sender)
except UserChannel.DoesNotExist:
uc = UserChannel(channel_id=channel_id, nickname=sender)
uc.save()
message = Message(channel_id=channel_id, user_channel=uc, text=text)
message.save()
return message
def create_message(sender, channel_id, text, user_channel_id):
"""
Create a new message
"""
try:
uc = UserChannel.objects.get(channel_id=channel_id, nickname=sender)
except UserChannel.DoesNotExist:
uc = UserChannel(channel_id=channel_id, nickname=sender)
uc.save()
message = Message(channel_id=channel_id, user_channel=uc, text=text)
message.save()
return message
def contacttouser(request):
if request.method == 'POST':
form = contacttouser_form(request.POST)
if form.is_valid():
if form.cleaned_data['send_to_all']:
for customer in Customer.objects.all():
msg = Message(sender=Manager.objects.get(pk=10).user,
receiver=customer.user,
create_time=datetime.datetime.now(),
text=form.cleaned_data['text'],
seen=False)
msg.save()
else:
if form.cleaned_data['receiver'] != None:
customer = Customer.objects.get(
pk=form.cleaned_data['receiver'])
msg = Message(sender=Manager.objects.get(pk=10).user,
receiver=customer.user,
create_time=datetime.datetime.now(),
text=form.cleaned_data['text'],
seen=False)
msg.save()
if form.cleaned_data['receiver'] != None or form.cleaned_data[
'send_to_all']:
return redirect('/manager/')
else:
form = contacttouser_form()
user_information = Customer.objects.all()
context = {'user_information': user_information, 'form': form}
return render(request, 'manager/contacttouser.html', context)
def post_new_message(request):
data = request.POST
to_id = data.get('to',0)
message = data.get('message',None)
try:
to_user = User.objects.get(id=to_id)
except User.DoesNotExist:
to_user = None
if to_user and message:
message_obj = Message(message=message,msg_from=request.user,msg_to=to_user)
message_obj.save()
result = {'from_id':message_obj.msg_from.id,'from_name':message_obj.msg_from.username,'message':message_obj.message,'time':str(message_obj.created_on.strftime("%I:%M %p %d, %b %Y"))}
return HttpResponse(json.dumps(result),content_type='application/json')
def checkin(request):
try:
imei = int(request.POST['imei'])
mtype = str(request.POST['type'])
except:
return HttpResponseBadRequest(content=json.dumps({
'status': 'error',
'reason': 'all of imei, type, latitude and longitude POST options are required'
}), content_type='application/json')
try:
latitude = float(request.POST['latitude'])
longitude = float(request.POST['longitude'])
except:
latitude = None
longitude = None
if mtype not in ('logon', 'heartbeat', 'low_battery', 'sos', 'tracker'):
return HttpResponseBadRequest(content=json.dumps({
'status': 'error',
'reason': 'allowed values for type: logon, heartbeat, low_battery, sos, tracker'
}), content_type='application/json')
try:
u = Unit.objects.get(imei=imei)
except:
return HttpResponseNotFound(content=json.dumps({
'status': 'error',
'reason': 'unit not found'
}))
MESSAGE_TYPES = {
'logon': 1,
'heartbeat': 2,
'low_battery': 3,
'sos': 4,
'tracker': 5
}
m = Message(
message_type=MESSAGE_TYPES[mtype],
latitude=latitude,
longitude=longitude,
unit=u
)
m.save()
return HttpResponse(content=json.dumps({
'status': 'ok'
}), content_type='application/json')
def save_msg(request, to_user, auth_code):
authmsg = create_authmsg(request, to_user, auth_code)
aeskeyp1, aeskeyp2, cphr_authmsg = cncrypto.aes_encrypt_authcode(authmsg)
cphr_aeskeyp1 = cncrypto.rsa_encrypt_aeskey(to_user.pubkey, aeskeyp1)
msg = Message()
msg.from_org = request.user.get_profile().organization
msg.to_user = to_user
msg.sysid = str(uuid.uuid4())
msg.enc_msg = cphr_authmsg
msg.save()
key = Key()
key.message = msg
key.sysid = str(uuid.uuid4())
key.key = cphr_aeskeyp1
key.min_to_expire = 1
key.save()
from_email = "%s <*****@*****.**>" % (
request.user.get_profile().organization.name)
subject = "Authorization request"
body = """
<a href="secdef://%s/%s">Tap Here</a> to get your authentication code.
""" % (msg.sysid, urllib.quote_plus(base64.b64encode(aeskeyp2)))
print body
email_msg = EmailMessage(subject, body, from_email, [to_user.email])
email_msg.content_subtype = "html"
email_msg.send()
def create(self, validated_data):
user = self.context['request'].user
recipient = get_object_or_404(
User, id=validated_data['recipient']['id'])
body = ''
if 'body' in validated_data:
body = validated_data['body']
else:
body = None
msg = Message(recipient=recipient,
body=body, user=user)
send_email_on_message_send(msg)
msg.save()
return msg
def fetch_messages(self, data):
messages = Message.last_50_messages()
content = {
'command': 'messages',
'messages': self.messages_to_json(messages)
}
self.send_message(content)
def conversations_list(user: User):
dialog_msgs = Message.user_msgs(user)
all_conversations = []
used_interlocutors = set()
for msg in dialog_msgs:
if msg.sender == user:
interlocutor = msg.receiver
else:
interlocutor = msg.sender
if interlocutor not in used_interlocutors:
all_conversations.append({
"object": interlocutor,
"date": msg.date_sent
})
used_interlocutors.add(interlocutor)
for group in user.inside_group_chats.all():
msg = Message.objects.filter(
group_chat_in=group).order_by('-date_sent').first()
if msg is None:
_date = group.date_created
else:
_date = msg.date_sent
all_conversations.append({"object": group, "date": _date})
all_conversations.sort(key=lambda o: o["date"], reverse=True)
return all_conversations
def chat_by_user(request, chat_username):
if chat_username == request.user.username:
return redirect(reverse('chat_list'))
chat_user = get_object_or_404(User, username=chat_username)
msg_form = MessageForm(request.POST or None)
if msg_form.is_valid():
msg_text = msg_form.cleaned_data['msg_text']
Message.objects.create(receiver=chat_user,
sender=request.user,
msg_text=msg_text)
return redirect(reverse('chat_by_user', args=[chat_username]))
cur_user_msgs = Message.user_msgs(request.user)
msgs_by_user = cur_user_msgs.filter(
Q(sender=chat_user) | Q(receiver=chat_user)).order_by('date_sent')
all_conversations = conversations_list(request.user)
context = {
'all_conversations': all_conversations,
'msg_form': msg_form,
'new_all_msgs': msgs_by_user,
'chat_user': chat_user,
'chat_username': chat_username,
}
return render(request, 'core/chat.html', context)
def create_messages(self, convo_obj):
"""Gets the latest messages from soundcloud and saves them"""
messages = self.get_messages(convo_obj.convo_id)
for message in messages:
message_time = parser.parse(message['sent_at'])
if Message.objects.filter(conversation=convo_obj,
sent_at=message_time).exists() is not True:
message = Message(
conversation=convo_obj,
user_id=convo_obj.user_id,
user_name=convo_obj.user_name,
sent_at=message_time,
message=message['content']
)
message.save()
logger.info('created message: %s', message)
def test_negative_creation(self):
with self.assertRaises(TypeError) as error:
message = Message(sender=None,
receiver=self.kingdom2,
message='Test message')
self.assertEqual(str(error.exception),
'sender cannot be empty of NULL')
with self.assertRaises(TypeError) as error:
message = Message(sender={
'sender': 'ken',
'receiver': 'gap',
'message': 'test'
},
receiver=self.kingdom2,
message='Test message')
self.assertEqual(str(error.exception),
'sender must be of type Kingdom')
def cast_vote(self, name, message_text):
"""
:param name: kingdom name
:param message_text:
Create message object and add them to vote ballot
"""
kingdom = Kingdom.get_kingdom(name)
ruler_kingdom = Kingdom.get_kingdom('space')
message_obj = Message(ruler_kingdom, kingdom, message_text)
self.vote_ballot.append(message_obj)
def __cast_votes(self):
# competing_kingdoms will all send messages to other kingdoms
for ckingdom_name in self.competing_kingdoms.keys():
for kingdom_name in KINGDOMS.keys():
if kingdom_name != ckingdom_name:
sender = Kingdom.get_kingdom(ckingdom_name)
receiver = Kingdom.get_kingdom(kingdom_name)
message_txt = MessageTable.get_random_message()
message_obj = Message(sender, receiver, message_txt)
self.vote_ballot.append(message_obj)
def save(
self,
sender,
):
recipients = self.cleaned_data['recipients']
subject = self.cleaned_data['subject']
body = self.cleaned_data['body']
file = self.cleaned_data['file']
message_list = []
for r in recipients:
message = Message(
subject=subject,
body=body,
sender=sender,
receiver=User.objects.get(username=r),
file=file,
)
message.save()
message_list.append(message)
return message_list
def sendmessage(request):
cu = auth_session(request)
if cu == None:
raise
response_data = {}
response_data['success'] = 0
try:
toUser = User.objects.get(sysid=request.POST['uid'])
msg = request.POST['msg']
msysid = str(uuid.uuid4())
m = Message(from_user=cu, to_user=toUser, enc_msg=msg, sysid=msysid)
m.save()
response_data['msgid'] = msysid
response_data['success'] = 1
except User.DoesNotExist:
pass
return render_to_json(response_data)
def test_register_user_already_exists(self, mock_tasks):
u = G(User)
c = G(Conversation)
m = Message(
user_name=u.user_name,
user_id=u.user_id,
conversation=c,
message='register',
sent_at=datetime.now()
)
user, created = self.processor.register_user(m)
self.assertFalse(created)
def _gen_messages(
row: Series,
col_names: List[str],
messages: List[Message],
importance_coefficient: float = 1.0,
polarity: float = 0.0,
) -> None:
location = row["location"]
location_type = row["location_type"]
timestamp_type = row["timestamp_type"]
agent = row["agent"]
agent_type = row["agent_type"]
timestamp = row["timestamp"]
if isinstance(timestamp, float):
timestamp = str(int(timestamp))
if not timestamp.startswith("202"):
return
for col_name in col_names:
value_type = col_name
value = row[col_name]
outlierness_col_name = col_name + ":outlierness"
outlierness = row.get(outlierness_col_name, None)
if not outlierness:
outlierness = row.get(col_name + ":grouped_by_time:outlierness",
None)
if value is None or value == "" or (isinstance(value, float)
and isnan(value)):
# 'value' is effectively undefined, do not REALLY generate the message.
continue
fact = Fact(
location="[ENTITY:{}:{}]".format(location_type, location),
location_type=location_type,
value=value,
value_type=value_type,
timestamp=timestamp,
timestamp_type=timestamp_type,
agent=agent,
agent_type=agent_type,
outlierness=outlierness,
)
message = Message(facts=fact,
importance_coefficient=importance_coefficient,
polarity=polarity)
messages.append(message)
def new_message(request):
"""
Display form for message
**Context**
message form
**Template:**
:template:`form_new_message.html`
"""
if request.method == 'POST':
space = Space.objects.get(uid=request.POST.get('space'))
message = Message(uid=uuid1(), content=request.POST.get('content'), user=request.user, space=space,
date=timezone.now())
if request.FILES:
message.file = request.FILES['file']
message.save()
context = {'result': 'Success', 'uid': str(message.uid), 'content': message.content,
'user': message.user.username, 'date': 'Dzisiaj'}
else:
context = None
return HttpResponse(json.dumps(context), content_type="application/json")
def post_new_message(request):
data = request.POST
to_id = data.get('to', 0)
message = data.get('message', None)
try:
to_user = User.objects.get(id=to_id)
except User.DoesNotExist:
to_user = None
if to_user and message:
message_obj = Message(message=message,
msg_from=request.user,
msg_to=to_user)
message_obj.save()
result = {
'from_id': message_obj.msg_from.id,
'from_name': message_obj.msg_from.username,
'message': message_obj.message,
'time':
str(message_obj.created_on.strftime("%I:%M %p %d, %b %Y"))
}
return HttpResponse(json.dumps(result), content_type='application/json')
def _combine(self, registry: Registry, language: str, first: Message,
second: Message) -> Message:
log.debug("Combining two templates:")
log.debug("\t{}".format([c.value for c in first.template.components]))
log.debug("\t{}".format([c.value for c in second.template.components]))
shared_prefix = self._get_combinable_prefix(first, second)
log.debug(f"Shared prefix is {[e.value for e in shared_prefix]}")
combined = [c for c in first.template.components]
# TODO At the moment everything is considered either positive or negative, which is sometimes weird.
# Add neutral sentences.
conjunctions = registry.get("conjunctions").get(language, None)
if not conjunctions:
conjunctions = (defaultdict(lambda x: "NO-CONJUNCTION-DICT"), )
if first.polarity != first.polarity:
combined.append(
Literal(
conjunctions.get("inverse_combiner",
"MISSING-INVERSE-CONJUCTION")))
else:
combined.append(
Literal(
conjunctions.get("default_combiner",
"MISSING-DEFAULT-CONJUCTION")))
combined.extend(second.template.components[len(shared_prefix):])
log.debug("Combined thing is {}".format([c.value for c in combined]))
new_message = Message(
facts=first.facts +
[fact for fact in second.facts if fact not in first.facts],
importance_coefficient=first.importance_coefficient,
)
new_message.template = Template(combined)
new_message.prevent_aggregation = True
return new_message
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessageForm()
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash(_('Your message has been sent.'))
return redirect(url_for('user', username=recipient))
return render_template('send_message.html',
title=_('Send Message'),
form=form,
recipient=recipient)
def test_register_response(self, mock_tasks):
self.mock_wallet.return_value.get_new_address.return_value = '1'
convo = Conversation(
convo_id='test',
last_message_time=datetime.now()
)
convo.save()
Message(
user_name='bopeep2',
user_id='whatev',
conversation=convo,
message='register',
sent_at=datetime.now()
).save()
self.processor.process_messages()
self.assertEqual(User.objects.get(user_name='bopeep2').deposit_address, '1')
def _create_message(buttons=None, from_user=None, **kwargs):
# if chat is not specified - assume inline message
inline = not bool(kwargs.get('chat') or kwargs.get('chat_id'))
msg_id = ('id' in kwargs and kwargs.pop('id')) or get_id()
if not inline:
chat_id = kwargs.get('chat_id') or kwargs.get('chat').id
msg_id = Message.get_id(chat_id, msg_id)
fields = {
'id': msg_id,
'date': timezone.now(),
'from_user': from_user or create_user(),
'inline_message_id': msg_id if inline else None,
**kwargs,
}
msg = Message.objects.create(**fields)
if buttons:
msg.set_buttons(buttons)
return msg
def webapp_new_message(request, uuid):
template = loader.get_template('annonce.html')
context = {}
conversation = Conversation.objects.get(pk=uuid)
query = request.POST['q'] or None
if query is not None:
Message(conversation=conversation, transmitter=request.user, receiver=request.user, content=query).save()
messages = Message.objects.filter(conversation=conversation)
ad = Ad.objects.get(conversation=conversation)
context.update({
'conversation': conversation,
'messages': messages,
'ad': ad
})
return HttpResponse(template.render(context, request))
def test_kingdom_result(self):
"""
Unit test case for kingdom_result method. Used in Problem1
"""
voting_machine = VotingMachine()
vote_ballot = []
all_kingdoms = ['land', 'air', 'ice']
competing_kingdoms = {'space': []}
for name in all_kingdoms:
sender = Kingdom.get_kingdom('space')
receiver = Kingdom.get_kingdom(name)
message_txt = 'oaaawaalaa1d22n333a4444pzmzmzmzaztzozh'
message_obj = Message(sender, receiver, message_txt)
vote_ballot.append(message_obj)
voting_machine.execute(vote_ballot, competing_kingdoms)
ruler, allies = voting_machine.kingdom_result('space', 2)
self.assertEqual(ruler, 'Space')
self.assertEqual(allies, 'Land, Air, Ice')
def send_message(request):
getUser = getUserFromToken(request)
me = UserProfile.objects.get(user_id=getUser.id)
msg = Message(sender=me, receiver=getUser, text=request.POST.get("text"))
msg.save()
def _gen_messages(
self,
row: Series,
col_names: List[str],
messages: List[Message],
importance_coefficient: float = 1.0,
polarity: float = 0.0,
) -> None:
location = row["location"]
location_type = row["location_type"]
timestamp_type = row["timestamp_type"]
agent = row["agent"]
agent_type = row["agent_type"]
timestamp = row["timestamp"]
if isinstance(timestamp, float):
timestamp = str(int(timestamp))
# Retain this + last years' monthly stuff. Skip older monthly stuff.
if timestamp_type == "month":
year, month = timestamp.split("M")
if int(year) < datetime.now().year - 1:
return
# For yearly stuff, keep the last three years.
elif timestamp_type == "year":
if int(timestamp) < datetime.now().year - 3:
return
for col_name in col_names:
value_type = col_name
value = row[col_name]
outlierness_col_name = col_name + ":outlierness"
outlierness = row.get(outlierness_col_name, None)
# There are potentially multiple outlierness values to choose from, corresponding to multiple ways of
# grouping the data. TODO: Smarter way to select which on the use
if not outlierness:
outlierness = row.get(
col_name + ":grouped_by_time:outlierness", None)
if value is None or value == "" or (isinstance(value, float)
and isnan(value)):
# 'value' is effectively undefined, do not REALLY generate the message.
continue
fact = Fact(
location="[ENTITY:{}:{}]".format(location_type, location),
location_type=location_type,
value=value,
value_type=value_type,
timestamp=timestamp,
timestamp_type=timestamp_type,
agent=agent,
agent_type=agent_type,
outlierness=outlierness,
)
message = Message(facts=fact,
importance_coefficient=importance_coefficient,
polarity=polarity)
messages.append(message)
def _actions_handler(self, actions):
logger.debug('receive actions to handle {}'.format(actions))
for action in actions:
logger.debug('actions handle with type {}'.format(action.type))
if action.type == ScenarioActionType.SEND_MESSAGE.name:
if self.bot_chat.language == 'ru':
if action.parameters.ru_message_text:
ru_message = Message('',
action.parameters.ru_message_text)
send_message(self.chat_id, ru_message)
elif self.bot_chat.language == 'en':
if action.parameters.en_message_text:
en_message = Message('',
action.parameters.en_message_text)
send_message(self.chat_id, en_message)
elif self.bot_chat.language == 'uz':
if action.parameters.uz_message_text:
uz_message = Message('',
action.parameters.uz_message_text)
send_message(self.chat_id, uz_message)
elif action.type == ScenarioActionType.SEND_FILE:
pass
elif action.type == ScenarioActionType.SEND_BUTTONS.name:
btns = []
for button in action.parameters.buttons:
if self.bot_chat.language == 'ru':
if button.ru_message_text:
btns.append([
Button(button.id,
button.ru_message_text[0]).__dict__
])
elif self.bot_chat.language == 'en':
if button.en_message_text:
btns.append([
Button(button.id,
button.en_message_text[0]).__dict__
])
elif self.bot_chat.language == 'uz':
if button.uz_message_text:
btns.append([
Button(button.id,
button.uz_message_text[0]).__dict__
])
if len(btns) > 0:
keyboard = Keyboard('keyboard', btns)
send_message(self.chat_id, keyboard)
elif action.type == ScenarioActionType.REDIRECT_TO_QUEUE.name:
redirect_chat(self.bot_chat.language,
action.parameters.queue_name, self.chat_id)
elif action.type == ScenarioActionType.CLOSE_CHAT.name:
close_chat(self.chat_id)
elif action.type == ScenarioActionType.SEND_REQUEST_TO_ANOTHER_SERVICE.name:
pass
elif action.type == ScenarioActionType.CONDITION_CHECK.name:
condition_id = action.parameters.condition_check_param.condition_id
success_check_step_id = action.parameters.condition_check_param.success_check_step_id
fail_check_step_id = action.parameters.condition_check_param.fail_check_step_id
condition_check = self.get_condition_by_id(condition_id)
steps = self._get_state_by_id(
self.bot_chat.bot_scenario_state_id).steps
if condition_check():
logger.debug('success check step with step_id {}'.format(
success_check_step_id))
self._steps_handler(steps=steps,
step_id=success_check_step_id)
else:
logger.debug('fail check step with step_id {}'.format(
fail_check_step_id))
self._steps_handler(steps=steps,
step_id=fail_check_step_id)
elif action.type == ScenarioActionType.BUTTON_CHECK.name:
if self.bot_chat.keyboard_response_button_id:
target_state = self._get_state_by_button_id(
self.bot_chat.keyboard_response_button_id)
if target_state:
target_state_id = target_state.state_id
self.bot_chat.bot_scenario_target_state_id = target_state_id
self.bot_chat.save()
self.transmit()
elif action.type == ScenarioActionType.SEND_FILE_TO_CLIENT.name:
file = FileMessage('file_operator',
action.parameters.file.__dict__)
send_message(self.chat_id, file)
def test_split_umid(self):
assert Message.split_id('a_b') == ['a', 'b']
def test_get_id(self):
assert Message.get_id('a', 'b', 'c') == 'c'
assert Message.get_id('a', 'b') == 'a_b'
assert Message.get_id('a', 'b_c') == 'b_c'
assert Message.get_id('a', None) == 'a'
