def test_muting_conversation(self):
"""
Add a comment, which will create a conversation for the commenter (user2) and sharedfile owner (admin).
When user2 tries to mute admin's conversation, it should fail and admin's conversation state will remain
unchanged. When muting own converastion, "muted" flag should change to true.
Contingent on user2 being signed in. (see setUp)
"""
comment = Comment(sharedfile_id=self.shf.id, user_id=self.user2.id, body='test')
comment.save()
admin_conversation = Conversation.get('user_id = %s', self.admin.id)
user2_conversation = Conversation.get('user_id = %s', self.user2.id)
self.assertEqual(admin_conversation.muted, 0)
self.assertEqual(user2_conversation.muted, 0)
request = HTTPRequest(self.get_url('/conversations/%s/mute' % admin_conversation.id), 'POST', {'Cookie':'_xsrf=%s;sid=%s' % (self.xsrf, self.sid)}, "_xsrf=%s" % (self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
request = HTTPRequest(self.get_url('/conversations/%s/mute' % user2_conversation.id), 'POST', {'Cookie':'_xsrf=%s;sid=%s' % (self.xsrf, self.sid)}, "_xsrf=%s" % (self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
# refetch from DB, and verify mute flags remain 0.
admin_conversation = Conversation.get('user_id = %s', self.admin.id)
user2_conversation = Conversation.get('user_id = %s', self.user2.id)
self.assertEqual(admin_conversation.muted, 0)
self.assertEqual(user2_conversation.muted, 1)
def add_conversation(user_id):
"""Page to add a conversation. """
# if this user id combo exists
conversation = Conversation.query.filter(
Conversation.user1_id == user_id,
Conversation.user2_id == g.user.id).all()
conversation2 = Conversation.query.filter(
Conversation.user2_id == user_id,
Conversation.user1_id == g.user.id).all()
if conversation:
return redirect(f"/conversations/{conversation[0].id}")
if conversation2:
return redirect(f"/conversations/{conversation2[0].id}")
# else:
if (user_id < g.user.id):
new_conversation = Conversation(user1_id=user_id, user2_id=g.user.id)
else:
new_conversation = Conversation(user1_id=g.user.id, user2_id=user_id)
db.session.add(new_conversation)
db.session.commit()
return redirect(f"/conversations/{new_conversation.id}")
def new_conversation(self, connection, name):
conv = Conversation(name, connection, {})
conv.index = len(self.conversations)
self.conversations.append(conv)
self.conversation_lookup[self.conversation_key(connection, name)] = conv
self.last_key = self.conversation_key(connection, name)
return conv
def post(self, request, *args, **kwargs):
"""
Handles POST requests to 'conversations/start/' route.
"""
form = StartConversationForm(request.POST)
if form.is_valid():
# first create and save a new conversation instance:
conversation = Conversation(
subject=form.cleaned_data.get("subject"),
initiator=request.user)
conversation.save()
# add the current user as a member of the coversation:
conversation.members.add(request.user)
# create and save the new message instance:
message = Message(content=form.cleaned_data.get("message"),
user=request.user,
conversation=conversation)
message.save()
# send the slack message notification:
slack_name = form.cleaned_data.get("invite")
join_link = get_slack_join_link(request, conversation, slack_name)
notify_on_slack(message, slack_name, join_link)
# redirect to the conversation view:
return redirect(
reverse('messenger:conversation',
kwargs={'pk': conversation.pk}))
else:
messages.add_message(request, messages.ERROR,
"Please fill in the fields correctly.")
context = {'form': form}
template = 'messenger/conversation_start.html'
return render(request, template, context)
def test__save_model(self):
model = Conversation._load_model(Conversation)
Conversation._save_model(Conversation, model)
if not os.path.isfile(
'interface/chat/chatbot/combinedmodel/trainedconversationalmodelweights.h5'
):
self.fail('unable to find saved file')
def create_conversation(user_id, conversation):
conversation_type = conversation.get('conversation_type')
conversationees_list = conversation.get('conversationees_list')
conversationees_list = list(set(conversation.get('conversationees_list',[])))
if conversation_type == conversations_config.get('CONVERSATION_DIRECT_TYPE') and len(conversationees_list) != 2:
raise InvalidConversationException('Direct conversations should have 2 conversationees')
ct = ConversationType.get(ConversationType.name == conversation_type)
c = Conversation()
c.conversation_type = ct
p_url = conversation.get('picture','')
picture = None
if p_url:
picture = Photo()
picture.url = p_url
name = conversation.get('name','')
cps = []
myself = None
for index, conversationee in enumerate(conversationees_list):
n = None
p = None
if conversation_type == 'group':
n = name
p = picture
else:
data = get_user_data(index, conversationees_list)
n = data[0]
p = data[1]
cp = ConversationParty()
cp.conversation = c
cp.name = n
cp.user = User.get(User.id==conversationee)
cp.picture = p
cps.append(cp)
if conversationee == user_id:
myself = cp
with database.transaction():
c.save()
if picture:
picture.save()
for cp in cps:
cp.save()
return __jsonify_one_conversation(myself)
def getConversation(self, jid):
if self.isGroupJid(jid):
group = Group.get_or_create(jid = jid)
conversation = Conversation.get_or_create(group = group)[0]
else:
contact = Contact.get_or_create(jid = jid)
conversation = Conversation.get_or_create(contact = contact[0])[0]
return conversation
def conversation(sender_id, receiver_id):
"""
Show a conversation between two users.
"""
form = ConversationForm()
sender = User.query.filter_by(id=sender_id).first()
receiver = User.query.filter_by(id=receiver_id).first()
if not sender or not receiver:
return no_perms("One of the users provided does not exist!")
if sender.id != g.user.id:
receiver = sender
conv = Conversation.query.filter_by(
sender_id=sender_id
).filter_by(
receiver_id=receiver_id
).first() or \
Conversation.query.filter_by(
sender_id=receiver_id
).filter_by(
receiver_id=sender_id
).first()
if request.method == "POST":
if not conv:
if form.content.data and form.subject.data:
conv = Conversation(sender_id=sender_id,
receiver_id=receiver_id,
subject=form.subject.data)
db.session.add(conv)
db.session.commit()
msg = Message(conversation_id=conv.id,
sender=g.user.id,
content=form.content.data)
db.session.add(msg)
db.session.commit()
else:
return no_perms("You didn't input a subject or message!")
elif form.content.data:
msg = Message(conversation_id=conv.id,
sender=g.user.id,
content=form.content.data)
db.session.add(msg)
db.session.commit()
else:
return no_perms("You didn't input a message!")
if conv:
for msg in conv.messages:
msg.sent_at = msg.sent_at.strftime("%b %d, %Y")
conv.messages = Message.query.filter_by(conversation_id=conv.id).all()
return render_template("conversation.html", form=form, conversation=conv,
receiver=receiver)
def ajax_send_words(request):
user_id = request.user_id
be_interested_uuid = request.POST.get('be_interested_uuid')
words = request.POST.get('words', '')
profile = user_tools.get_user_profile_by_user_id(user_id,
need_default=False)
data = ""
if be_interested_uuid and words:
be_interesteds = BeInterested.objects.filter(
uuid=be_interested_uuid)[:1]
if be_interesteds:
conversation = Conversation(be_interested_id=be_interesteds[0].id,
user_id=user_id,
words=words)
conversation.save()
openid = None
if be_interesteds[0].qlm_user_id != user_id:
openid = user_tools.get_openid(be_interesteds[0].qlm_user_id)
else:
job_details = Job.objects.filter(
id=be_interesteds[0].job_id).only('user_id')
if job_details:
openid = user_tools.get_openid(job_details[0].user_id)
send_notice_tool.send_notice(openid)
merge_msg = MergeMsg.objects.filter(
be_interested_id=be_interesteds[0].id)[0] # 既然都可以发送了，肯定有这条记录了
merge_msg.last_words = words
if be_interesteds[0].qlm_user_id == user_id: # 说明发送的这个人是千里马
merge_msg.qlm_have_read = True
merge_msg.zg_have_read = False
merge_msg.update_time = datetime.datetime.now()
else:
merge_msg.qlm_have_read = False
merge_msg.zg_have_read = True
merge_msg.update_time = datetime.datetime.now()
merge_msg.save()
data = {
'user_portrait': profile.portrait,
'user_nick': user_tools.get_user_name(profile),
'words': conversation.words,
'user_uuid': profile.uuid,
'vip_display': "block" if profile.vip else "none",
'create_time':
conversation.create_time.strftime('%Y-%m-%d %H:%M')
}
else:
log.error(
"uid(%s) try to get not exsit be_interested_uuid(%s), maybe attack"
% (user_id, be_interested_uuid))
return HttpResponse(json.dumps(data), content_type='application/json')
def new_conversation_view(request):
if request.method == "POST":
new_conversation = Conversation()
new_conversation.title = request.POST.get("title", "title not found")
if request.POST.get("category", "") != "":
new_conversation.category = Category.objects.get(pk = int(request.POST.get("category")))
new_conversation.save()
categories = Category.objects.all()
context = RequestContext(request, {
"categories": categories
})
return render_to_response("dialog/form_conversation.html", context)
def get_conversation_from_messageid(message_id):
convo = []
convos = Conversation.objects.filter(message_id = message_id)
if convos.count() == 0:
convo = Conversation()
convo.message_id = message_id
convo.save()
else:
convo = convos[0]
if convos.count() > 1:
print "found multiple conversations with message id: %s" % tree.messageID
return convo
def conversation(sender_id, receiver_id):
form = ConversationForm()
sender = User.query.filter_by(id=sender_id).first()
receiver = User.query.filter_by(id=receiver_id).first()
if not sender or not receiver:
return no_perms("One of the users provided does not exist!")
if sender.id != g.user.id:
receiver = sender
conv = Conversation.query.filter_by(sender_id=sender_id).filter_by(
receiver_id=receiver_id).first() or Conversation.query.filter_by(
sender_id=receiver_id).filter_by(receiver_id=sender_id).first()
if request.method == "POST":
if not conv:
if form.content.data and form.subject.data:
conv = Conversation(sender_id=sender_id,
receiver_id=receiver_id,
subject=form.subject.data)
db.session.add(conv)
db.session.commit()
msg = Message(conversation_id=conv.id,
sender=g.user.id,
content=form.content.data)
db.session.add(msg)
db.session.commit()
else:
return no_perms("You didn't input a subject/message!")
elif form.content.data:
msg = Message(conversation_id=conv.id,
sender=g.user.id,
content=form.content.data)
db.session.add(msg)
db.session.commit()
else:
return no_perms("You didn't input a message!")
if conv:
for msg in conv.messages:
msg.sent_at = msg.sent_at.strftime("%b %d, %Y")
conv.messages = Message.query.filter_by(conversation_id=conv.id).all()
return render_template("conversation.html",
form=form,
conversation=conv,
receiver=receiver)
def run_task(data_dir, task_name = 'Conversation'):
data_loader = CornellLoader(data_dir, length = 5000)
sources = data_loader.sources
targets = data_loader.targets
con_config = config(data_loader, sources, targets)
with tf.Session() as sess:
model = Conversation(con_config, sess, sources, targets)
if len(argvs) < 2:
model.build_model(False)
model.run(task_name)
elif argvs[1] == 'demo':
model.build_model(True)
model.demo()
def create_conversation(self, status=ConversationStatus.open):
conversation = Conversation(status=status)
self.session.add(conversation)
self.session.commit()
return conversation
def test_for_user_doesnt_return_muted_conversations(self):
"""
When we create a Comment, conversation gets created for the sharedfile owner and the
commenter. The conversation should appear for the commenter, unless the conversation
gets muted, in which case it doesn't get returned.
"""
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.another_user.id, body='test')
comment.save()
another_user_conversation = Conversation.get('user_id = %s', self.another_user.id)
self.assertEqual(0, another_user_conversation.muted)
self.assertEqual(1, len(Conversation.for_user(self.another_user.id)))
another_user_conversation.muted = 1
another_user_conversation.save()
self.assertEqual(0, len(Conversation.for_user(self.another_user.id)))
def test_deleting_sharedfile_also_mutes_conversations(self):
new_comment = Comment(user_id=self.user.id, sharedfile_id=self.sharedfile.id)
new_comment.save()
self.sharedfile.delete()
muted_conversation = Conversation.get('user_id=%s and sharedfile_id=%s and muted = 1', self.user.id, self.sharedfile.id)
self.assertTrue(muted_conversation)
def test_creating_comment_creates_conversation_for_sharedfile_owner(self):
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.visitor.id, body="just a comment")
comment.save()
new_conversation = Conversation.get("user_id = %s and sharedfile_id = %s", self.user.id, self.sharedfile.id)
self.assertTrue(new_conversation)
def test_creating_a_new_comment_creates_a_conversation(self):
request = HTTPRequest(self.get_url('/p/%s/comment' % self.shf.share_key), 'POST', {'Cookie':'_xsrf=%s;sid=%s' % (self.xsrf, self.sid)}, "body=%s&_xsrf=%s" % (url_escape("a comment"), self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
conversations = Conversation.all()
self.assertEqual(len(conversations), 2)
def list(self, *args, **kwargs):
#res = cherrypy.thread_data.db.get_conversations()
print (Conversation.select())
conversations = []
for item in res:
conversations.append(cherrypy.thread_data.db.dict_factory(item))
return conversations
def test_creating_second_comment_doesnt_create_additional_conversation(self):
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.visitor.id, body="just a comment")
comment.save()
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.visitor.id, body="another comment")
comment.save()
new_conversation = Conversation.where("user_id = %s and sharedfile_id = %s", self.visitor.id, self.sharedfile.id)
self.assertEqual(len(new_conversation), 1)
def echo(conversation_id, message):
conversation = Conversation.find(conversation_id)
participant = conversation.get('participants')[-1]
return {
'id': str(uuid.uuid4()),
'participant': participant,
'content': message.get('content')
}
def post(self):
args = post_conversation_parser.parse_args()
convo = Conversation(group_id=args["group_id"],
tutor_id=args["tutor_id"],
student_id=args["student_id"])
if convo == None:
return 401
db.session.add(convo)
db.session.commit()
return 201
def post(self, request, *args, **kwargs):
"""
Handles POST requests to 'conversations/start/' route.
"""
form = StartConversationForm(request.POST)
if form.is_valid():
# first create and save a new conversation instance:
conversation = Conversation(
subject=form.cleaned_data.get("subject"),
initiator=request.user
)
conversation.save()
# add the current user as a member of the coversation:
conversation.members.add(request.user)
# create and save the new message instance:
message = Message(
content=form.cleaned_data.get("message"),
user=request.user,
conversation=conversation
)
message.save()
# send the slack message notification:
slack_name = form.cleaned_data.get("invite")
join_link = get_slack_join_link(
request,
conversation,
slack_name
)
notify_on_slack(message, slack_name, join_link)
# redirect to the conversation view:
return redirect(reverse(
'messenger:conversation', kwargs={'pk': conversation.pk}
))
else:
messages.add_message(
request,
messages.ERROR,
"Please fill in the fields correctly."
)
context = {'form': form}
template = 'messenger/conversation_start.html'
return render(request, template, context)
def apply(self, *args, **kwargs):
db_conv = Conversation.get(Conversation.conv_id == kwargs.get('conversation_id'))
db_author = User.get(User.gaia_id == kwargs.get('author'))
timestamp = kwargs.get('timestamp')
url_matches = self._url_pattern.match(kwargs.get('message'))
if url_matches:
urls = url_matches.groups()
for url in urls:
if url:
Message.create(content=url, conversation=db_conv, author=db_author, message_type=2, date_created=timestamp)
def post(self, conversation_id):
"""
Mutes a conversation for a user and redirects them to /conversations
"""
current_user_object = self.get_current_user_object()
conversation = Conversation.get('id = %s and user_id = %s',
conversation_id,
current_user_object.id)
if conversation:
conversation.mute()
return self.redirect('/conversations')
def list_conversations(event, context):
conversations = Conversation.all()
response = {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*'
},
'body': json.dumps(conversations)
}
return response
def test_relevant_comments(self):
"""
Conversation.relevant_comments returns all the comments for the conversation at hand.
"""
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.another_user.id, body='test')
comment.save()
another_user_conversation = Conversation.get('user_id = %s', self.another_user.id)
self.assertEqual(1, len(another_user_conversation.relevant_comments()))
comment2 = Comment(sharedfile_id=self.sharedfile.id, user_id=self.another_user.id, body='two')
comment2.save()
self.assertEqual(2, len(another_user_conversation.relevant_comments()))
def get_conversations(self) -> List[ElementConversation]:
return [
ElementConversation(
element=item,
conversation=Conversation(
sender=item.find_by_css_selector(
'span.senders.ellipsis > span')[0].text,
subject=item.find_by_css_selector(
'div.subject > h4 > span.subject-text.ellipsis')
[0].text))
for item in self._browser.find_by_css_selector(
'#conversation-list-rows > section > div.conversation', True)
]
def test_deleting_a_file_will_set_conversation_to_muted(self):
request = HTTPRequest(self.get_url('/p/%s/comment' % self.shf.share_key), 'POST', {'Cookie':'_xsrf=%s;sid=%s' % (self.xsrf, self.sid)}, "body=%s&_xsrf=%s" % (url_escape("a comment"), self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
request = HTTPRequest(self.get_url('/p/%s/comment' % self.shf.share_key), 'POST', {'Cookie':'_xsrf=%s;sid=%s' % (self.xsrf, self.sid)}, "body=%s&_xsrf=%s" % (url_escape("a second comment"), self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
self.shf.delete()
conversations = Conversation.all()
self.assertEqual(conversations[0].muted, 1)
self.assertEqual(conversations[1].muted, 1)
def new_conversation_view(request):
if request.method == "POST":
new_conversation = Conversation()
new_conversation.title = request.POST.get("title", "title not found")
if request.POST.get("category", "") != "":
new_conversation.category = Category.objects.get(
pk=int(request.POST.get("category")))
new_conversation.save()
categories = Category.objects.all()
context = RequestContext(request, {"categories": categories})
return render_to_response("dialog/form_conversation.html", context)
def log(self, conv_id=0):
if conv_id is 0:
self.redirect('/conversations')
else:
try:
conversation = Conversation.get(Conversation.conv_id == conv_id)
except:
# cherrypy.request.session.alerts.warn("Conversation ID not found")
self.redirect('/conversations')
# Now we know there is a conversation with that ID, check for messages
try:
messages = Message.select().where(Message.conversation == conversation and Message.message_type == 1)
print (messages)
return {'conversation': conversation, 'messages': messages}
except:
return {'conversation': conversation, 'no_messages': 1}
def result(request):
if(not request.user.is_authenticated()):
return JsonResponse({'response':'forbidden'})
res = {}
if request.method == 'POST':
received_json_data=json.loads(request.body)
user_input = received_json_data['input']
session_id = received_json_data['session_id']
session = Session.objects.get(id = session_id)
dt = datetime.now()
bot = User.objects.get(username="******")
c = Conversation(text=user_input, date=dt, sender_id=request.user, receiver_id=bot, session_id = session)
c.save()
sara.set_input(user_input)
sara.validate_input()
sara.preprocess_input()
output = sara.print_response()
reply = Conversation(text=output, date=dt, sender_id=bot, receiver_id=request.user, session_id = session)
reply.save()
from emotion.emo.erf import Emotion
emo = Emotion()
result = emo.get_emotion(user_input)
resultant_emo = get_max_emotion(result)
user_profile = UserProfile.objects.get(user = request.user)
if resultant_emo == "joy":
user_profile.joy_count = user_profile.joy_count + 1
elif resultant_emo == "sadness":
user_profile.sad_count = user_profile.sad_count + 1
elif resultant_emo == "anger":
user_profile.ang_count = user_profile.ang_count + 1
elif resultant_emo == "fear":
user_profile.fea_count = user_profile.fea_count + 1
elif resultant_emo == "disgust":
user_profile.dis_count = user_profile.dis_count + 1
user_profile.save()
res = {
'input': user_input,
'output': output
}
# res = json.dumps(res)
# json.dumps(json.JSONDecoder().decode(res))
# res = serializers.serialize('json', res)
return JsonResponse(res, safe=False)
def get_or_create_conversation_from_message(message):
top_message = get_ultimate_parent(message)
convo = Conversation.objects.filter(initial_message__id = top_message.id)
if len(convo) == 0:
convo = Conversation()
convo.subject = top_message.cleaned_subject
convo.creator = top_message.sender
convo.save()
convo.messages.add(top_message)
for person in top_message.all_related_people():
convo.members.add(person)
else:
convo = convo[0]
for person in message.all_related_people():
convo.members.add(person)
convo.messages.add(message)
convo.save()
return convo
def put(self):
args = put_contact_req_parser.parse_args()
if args['id'] is not None:
req = ContactRequest.query.filter_by(id=args['id']).first()
if req is None:
return 401
accepted = False
if args['accepted'].lower() == "true":
accepted = True
if args["group_id"] is not None:
group = Group.query.filter_by(id=args["group_id"]).first()
user = User.query.filter_by(
id=args["requestor_id"]).first()
if group is None or user is None or convo is None:
return 404
group.members.append(user)
convo.participants.append(user)
elif args["tutor_id"] is not None:
temp_convo = Conversation(None, args["student_id"],
args["tutor_id"])
if tmp_convo is None:
return 404
db.session.add(tmp_convo)
db.session.commit()
req.accepted = accepted
req.message = args['message']
req.requestor_id = args['requestor_id']
req.student_id = args['student_id']
req.tutor_id = args['tutor_id']
req.group_id = args['group_id']
db.session.add(req)
db.session.commit()
return 205
def get(self):
logging.info("hi")
user = self.user_model
user.msg_count = 0
msg_count = user.msg_count
user.put()
conversations = Conversation.query(ndb.OR(
user.username == Conversation.sender,
user.username == Conversation.recipient))
notifications = NotifiedMessage.query(NotifiedMessage.person_reference == user.username).fetch(10)
notis_count = len(notifications)
self.response.out.write(template.render('views/messages.html', {'viewer': user,
'conversations': conversations,
'notifications': notifications,
'notis_count': notis_count,
'msg_count': msg_count
}))
def process_voice_scheduling():
call_sid = request.form['CallSid']
if not call_sid:
return 'Unable to respond', 404
app.logger.info('request with call sid = %s', call_sid)
conv, created, msg = Conversation.get_or_new(request.form, call_sid=call_sid)
# if no conversation could be generated, this can happen because there is no
# business registered on the line
if not conv:
app.logger.info('business is not registered')
return create_error_response(msg, twilio_voice=resp)
# if need to register customer
if not conv.identity_affirmed():
if not conv.customer:
# could not find the customer on our DB
return process_iden_conversation("customer is not registered", created=created, conv=conv)
else:
# identified the customer on our DB
return process_iden_conversation("customer is registered", created=created, conv=conv)
return process_iden_conversation("eventhing else", created=False, conv=conv)
def create_message(request, username=None):
"""
view untuk menampilkan pembuatan pesan
"""
to = []
if username:
to.append(username)
if request.POST:
to = request.POST.getlist('to')
form = CreateMessageForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
message = form.cleaned_data['content']
location = form.cleaned_data['location']
conv = Conversation()
conv.title = title
conv.origin = request.user
conv.location = location
conv.save()
Membership.objects.create(user=request.user,
conversation=conv)
to2 = []
for person in to:
to_person = User.objects.get(username=person)
to2.append(to_person)
Membership.objects.create(user=to_person,
conversation=conv)
msg = Message()
msg.conversation = conv
msg.content = message
msg.user = request.user
msg.save()
notification.send(to2, 'new_message',
{'user': request.user, 'message': conv})
messages.info(request, _('Message sent'))
return HttpResponseRedirect(reverse('message_list'))
else:
form = CreateMessageForm()
return render_to_response('message/create_message.html',
{'form': form,
'to': to},
context_instance=(RequestContext(request)))
def get(self, show_only=None, page=None):
current_user_object = self.get_current_user_object()
if not page:
page = 1
page = int(page)
if show_only == 'my-files':
url_format = '/conversations/my-files/%d'
conversations = Conversation.for_user(current_user_object.id,
type='myfiles',
page=page)
conversations_count = Conversation.for_user_count(
current_user_object.id, type='myfiles')
elif show_only == 'my-comments':
url_format = '/conversations/my-comments/%d'
conversations = Conversation.for_user(current_user_object.id,
type='mycomments',
page=page)
conversations_count = Conversation.for_user_count(
current_user_object.id, type='mycomments')
else:
show_only = 'all'
url_format = '/conversations/all/%d'
conversations = Conversation.for_user(current_user_object.id,
page=page)
conversations_count = Conversation.for_user_count(
current_user_object.id)
conversations_marshalled = []
for conversation in conversations:
conversations_marshalled.append({
'sharedfile':
conversation.sharedfile(),
'comments':
conversation.relevant_comments(),
'conversation':
conversation
})
return self.render("conversations/index.html", conversations=conversations_marshalled, \
page=page, count=conversations_count, url_format=url_format, selected=show_only)
def save_conv(request):
if(not request.user.is_authenticated()):
return JsonResponse({'response':'forbidden'})
res = {}
if request.method == 'POST':
received_json_data=json.loads(request.body)
user_input = received_json_data['input']
user_output = received_json_data['output']
session_id = received_json_data['session_id']
session = Session.objects.get(id = session_id)
dt = datetime.now()
bot = User.objects.get(username="******")
c = Conversation(text=user_input, date=dt, sender_id=request.user, receiver_id=bot, session_id = session)
c.save()
c = Conversation(text=user_output, date=dt, sender_id=bot, receiver_id=request.user, session_id = session)
c.save()
from emotion.emo.erf import Emotion
emo = Emotion()
result = emo.get_emotion(user_input)
resultant_emo = get_max_emotion(result)
user_profile = UserProfile.objects.get(user = request.user)
if resultant_emo == "joy":
user_profile.joy_count = user_profile.joy_count + 1
elif resultant_emo == "sadness":
user_profile.sad_count = user_profile.sad_count + 1
elif resultant_emo == "anger":
user_profile.ang_count = user_profile.ang_count + 1
elif resultant_emo == "fear":
user_profile.fea_count = user_profile.fea_count + 1
elif resultant_emo == "disgust":
user_profile.dis_count = user_profile.dis_count + 1
user_profile.save()
return HttpResponse(resultant_emo, content_type='application/json')
def post(self):
recipient = cgi.escape(self.request.get('recipient'))
text = cgi.escape(self.request.get('text'))
sender = cgi.escape(self.request.get('sender'))
#create msg and put
#is this conversation already existed?
#Yes
#attach message
#No create a new one
#owner, sender, msg
#put
#There's a new coming msg to owner
mesg = Message()
mesg.time = datetime.datetime.now() - datetime.timedelta(hours=8)
mesg.sender = sender
mesg.recipient = recipient
mesg.text = text
mesg.put()
owners_temp = []
owners_temp.append(sender)
owners_temp.append(recipient)
temp1 = " ".join((sender, recipient))
temp2 = " ".join((recipient, sender))
recipient_user = User.query(User.username == recipient).get()
if recipient_user:
recipient_user.msg_count += 1
recipient_user.put()
conversation_qry = Conversation.query(ndb.OR(Conversation.owners == temp1, Conversation.owners == temp2)).get()
if conversation_qry:
logging.info("yes")
#logging.info(conversation_qry.owners)
conversation_qry.children.append(mesg.key)
conversation_qry.msg_count = conversation_qry.msg_count + 1
conversation_qry.most_recent_msg = mesg.text
conversation_qry.most_recent_date = str(mesg.time)
conversation_qry.put()
else:
logging.info("noooooooooo")
#logging.info(conversation_qry)
conv = Conversation()
conv.sender = sender
conv.recipient = recipient
conv.owners = " ".join((sender, recipient))
conv.children.append(mesg.key)
conv.msg_count = conv.msg_count + 1
conv.most_recent_msg = mesg.text
conv.most_recent_date = str(mesg.time)
conv.put()
def conversations(self, conv_id=0):
if conv_id is not 0:
self.redirect('/log/' + conv_id)
conversations = Conversation.select().where(Conversation.private == False)
return {'conversations': conversations}
from models import BaseModel, User, Conversation, ConversationParty, Message, MessageType, database
from datetime import datetime
# Messages
m = Message()
m.conversation = Conversation.get(Conversation.id==1)
m.sender = User.get(User.id==1)
m.message_type = MessageType.get(MessageType.name=='directive_quotation_mt')
m.ts = datetime.now()
args = {'currency':'R$',
'per_day_beneficiary_value':'20.50',
'number_of_beneficiaries':'5',
'company_name':'VR',
'company_picture':''
}
with database.transaction():
m.save()
m.run_constructor(args)
m.save()
def append(self, message, **kwargs):
conversation = Conversation(sender=self.sender_id, message=message, **kwargs)
db_session.session.add(conversation)
db_session.session.commit()
def index(request):
conversation_uuid = uuid.uuid4()
c = Conversation(guid=conversation_uuid)
c.save()
return render_to_response('index.html',
{'uuid': str(conversation_uuid)})
def interest_job(request):
user_id = request.user_id
# 1.从vip职位列表那里直接点击感兴趣进来传进来-------job_uuid->job
# 2.通过别人分享链接(分享的职位详情)进来------------share_uuid获取job_id->job
# 3.通过别人分享链接(分享的带推荐录音的职位详情)进来 share_uuid获取recommend_id->job
recommend_uuid = request.GET.get('recommend_uuid', '')
last_share_uuid = request.GET.get('last_share_uuid', '')
job_uuid = request.GET.get('job_uuid', '')
job_details = []
if last_share_uuid: # 通过别人的分享链接进来的1.职位详情2.带录音的职位详情，只要有share_uuid就可以拿到job
if recommend_uuid: # 传recommend_uuid，为带录音的职位详情
recommends = MyRecommend.objects.filter(uuid=recommend_uuid)[:1]
if not recommends:
return HttpResponse("十分抱歉，获取推荐信息失败，请重试。重试失败请联系客服人员")
job_details = Job.objects.filter(id=recommends[0].job_id)[:1]
elif job_uuid:
job_details = Job.objects.filter(uuid=job_uuid)[:1]
if not job_details:
log.error("uid(%s) try to get not exsit job, maybe attack" %
user_id)
return HttpResponse("十分抱歉，获取职位信息失败，请重试。重试失败请联系客服人员")
elif job_uuid: # 说明直接点我感兴趣进来的，没有通过分享
job_details = Job.objects.filter(uuid=job_uuid)[:1]
last_share_uuid = "00000000000000000000000000000000"
if not job_details:
log.error("uid(%s) try to get not exsit job(%s), maybe attack" %
(user_id, job_uuid))
return HttpResponse("十分抱歉，获取职位信息失败，请重试。重试失败请联系客服人员")
be_interested = BeInterested.objects.filter(job_id=job_details[0].id,
qlm_user_id=user_id)[:1]
if not be_interested: # 当前user以前没有对这个职位点击过我感兴趣,则插入数据
be_interested = BeInterested(last_share_uuid=last_share_uuid,
job_id=job_details[0].id,
qlm_user_id=user_id,
uuid=str_tools.gen_uuid())
be_interested.save()
conversation = Conversation(
be_interested_id=be_interested.id,
user_id=user_id,
words="主公，我揭了您的“招贤令”！<span style='color:#8e8e8e;'>(系统代发消息)</span>")
conversation.save()
conversation = Conversation(
create_time=datetime.datetime.fromtimestamp(time.time() + 2),
be_interested_id=be_interested.id,
user_id=job_details[0].user_id,
words=
"管家！快给英雄赐座。容我先批完折子。<span style='color:#8e8e8e;'>(系统代发消息)</span>")
conversation.save()
merge_msg = MergeMsg(
update_time=datetime.datetime.now(),
uuid=str_tools.gen_uuid(),
zg_user_id=job_details[0].user_id,
be_interested_id=be_interested.id,
qlm_user_id=user_id,
last_words=
"管家！快给英雄赐座。容我先批完折子。<span style='color:#8e8e8e;'>(系统代发消息)</span>",
qlm_have_read=True,
zg_have_read=False)
merge_msg.save()
# 更新my_interview表
my_interview = MyInterview(user_id=user_id,
job_id=job_details[0].id,
last_share_uuid=last_share_uuid)
my_interview.save()
else:
be_interested = be_interested[0]
be_interested_uuid = be_interested.uuid
return HttpResponseRedirect("/chat/chat_detail?be_interested_uuid=" +
str(be_interested_uuid))
def get_conversations(auth_username, last_conversations_retrieved_id=None):
"""
This function get list of conversation between two users converting lists of dictionaries
into lists of Conversation model, it calls function from query factory that returns lists of
dictionaries fit Conversation model with the given pagination.
*Parameter:*
- *auth_username*: user who is logging in.
- *last_conversations_retrieved_id*: id of last message retrieved
*Returns:*
- *models.Conversation object*
"""
if last_conversations_retrieved_id is not None:
try:
last_conversations_retrieved_id = int(
last_conversations_retrieved_id)
except ValueError:
raise
if actions.is_user(auth_username) is False:
raise Exception('Username who sent this message does not exist.')
conversations = query_factory.get_conversations(auth_username)
try:
conversations = actions.paginate(
dictionaries_list=conversations,
required_size=20,
start_after_key='id',
start_after_value=last_conversations_retrieved_id)
except TypeError:
raise
if conversations is None:
return None
conversation_list = []
if len(conversations) == 0:
return conversation_list
for conversation in conversations:
to_username = conversation['to_username']
from_username = conversation['from_username']
dictionary = {'id': conversation['id']}
temp = {'from_username': from_username}
dictionary.update(temp)
temp = {'to_username': to_username}
dictionary.update(temp)
new_format = change_time(conversation['created_at'])
temp = {'created_at': new_format}
dictionary.update(temp)
temp = {'text': conversation['text']}
dictionary.update(temp)
temp = {'media_url': conversation['media_url']}
dictionary.update(temp)
direct_message = DirectMessage(dictionary)
dic = {'last_message': direct_message}
if to_username == auth_username:
username = from_username
else:
username = to_username
dictionary = {'username': username}
temp = {'screen_name': conversation['screen_name']}
dictionary.update(temp)
temp = {'profile_image_url': conversation['profile_image_url']}
dictionary.update(temp)
flag = check_follow(auth_username, username)
temp = {'following': flag}
dictionary.update(temp)
flag = check_follow(username, auth_username)
temp = {'follows_you': flag}
dictionary.update(temp)
flag = check_block(auth_username, username)
temp = {'blocked': flag}
dictionary.update(temp)
flag = check_mute(auth_username, username)
temp = {'muted': flag}
dictionary.update(temp)
user = User(dictionary)
dic2 = {'user': user}
dic2.update(dic)
conversation_list.append(Conversation(dic2).to_json())
return conversation_list
def get(self):
conversations = Conversation.query(Conversation.user_keys == self.user.key,
Conversation.visibleto_user_keys == self.user.key).order(-Conversation.modified).fetch()
self.render_json_response(conversations)
def update_conversation(conversation_id, last_message=None): Conversation.update(last_message=last_message).where(Conversation.id==conversation_id).execute()
from models import BaseModel, User, Conversation, ConversationParty, ConversationType, Message, database
from web.chat_config import config as conversation_config
from datetime import datetime
# Conversations and ConversationParties
conversations = []
conversationparties = []
grupo = ConversationType()
grupo.name = conversation_config.get('CONVERSATION_GROUP_TYPE')
c1 = Conversation()
c1.conversation_type = grupo
conversations.append(c1)
# c2 = Conversation()
# c2.conversation_type = grupo
# conversations.append(c2)
# cp133 = ConversationParty()
# cp133.conversation=c2
# cp133.user=User.get(User.username=='ricardinho')
# cp133.name='Vale-Refeição'
# conversationparties.append(cp133)
# cp144 = ConversationParty()
# cp144.conversation=c2
# cp144.user=User.get(User.username=='felipinho')
# cp144.name='Vale-Refeição'
# conversationparties.append(cp144)
def get(self, conv_reference):
user = self.user_model
#parse string
#get messages
temp_query = conv_reference.strip()
temp = temp_query.split('&')
msg_count = user.msg_count
notifications = NotifiedMessage.query(NotifiedMessage.person_reference == user.username).fetch(10)
notis_count = len(notifications)
string1 = str(temp[0])
string1 = str(string1).replace('[','').replace(']','')
string1 = str(string1).replace("'",'').replace("'",'')
string1 = str(string1).replace(" ","")
string1 = str(string1).replace(","," ")
string2 = str(temp[1:2])
string2 = str(string2).replace('[','').replace(']','')
string2 = str(string2).replace("'",'').replace("'",'')
string2 = str(string2).replace(" ","")
string2 = str(string2).replace(","," ")
#logging.info(string2 + " " + string1)
#logging.info(string1 + " " + string2)
temp1 = " ".join((string1, string2)) #conv_ref
temp2 = " ".join((string2, string1)) #conv_ref_inverse
if user.username != string1 and user.username != string2:
self.response.out.write(template.render('views/404notfound.html',{}))
else:
conversation_qry = Conversation.query(ndb.OR(Conversation.owners == temp1, Conversation.owners == temp2)).get()
messages = []
if conversation_qry:
for oneMessage in conversation_qry.children:
logging.info(oneMessage.get())
messages.append(oneMessage.get())
else:
logging.info("not found")
#self.response.out.write(template.render('views/404notfound.html',{})) #prevent people other than tutor and tutee to see this transaction
self.response.out.write(template.render('views/readMessage.html', {'messages': messages,
'user': user,
'temp2': temp2,
'temp1': temp1,
'notifications': notifications,
'notis_count': notis_count,
'msg_count': msg_count
}))
def make_request(stuff_id=None):
form = RequestForm()
message = None
return_url = request.form['return_url']
if form.validate_on_submit():
message = form.message.data
stuff_id = form.stuff_id.data
duration = int(form.duration.data)
unit = int(form.unit.data)
address = Address.query.filter(Address.user_id == current_user.id).first()
if address:
if stuff_id is None or not (stuff_id > ''):
flash(u'İstek gönderilemedi.')
return redirect(return_url)
stuff = Stuff.query.filter(Stuff.id == stuff_id).first()
if stuff.is_wanted == True:
user = stuff.owner
from_user = current_user
else:
user = current_user
from_user = stuff.owner
new_request = Request(
stuff_id=stuff_id,
user_id=user.id,
from_user_id=from_user.id,
duration=(duration * unit)
)
db.session.add(new_request)
new_conversation = Conversation(
title='%s' % stuff.title,
users=[current_user, stuff.owner],
request=new_request
)
db.session.add(new_conversation)
new_message = Message(
from_user=current_user,
to_user=stuff.owner,
conversation=new_conversation,
txt=message
)
db.session.add(new_message)
db.session.commit()
msg_body = render_template('email/request.txt', to_user=user, from_user=from_user,
stuff=stuff, conversation_url=new_conversation.url)
html_msg = render_template('email/request.html', to_user=user, from_user=from_user,
stuff=stuff, conversation_url=new_conversation.url)
if stuff.is_wanted:
msg_subject = u"%s sana %s ödünç vermek istiyor" % (from_user.name, stuff.title)
else:
msg_subject = u"%s için bir talip var!" % stuff.title
msg = MailMessage(
body=msg_body,
html=html_msg,
subject=msg_subject,
sender=(u"Eşya Kütüphanesi", "*****@*****.**"),
recipients=[stuff.owner.email]
)
mail.send(msg)
return redirect(url_for('my_messages'))
else:
flash(u'Ödünç istemek için adres girmelisin.')
return redirect(url_for('new_address'))
else:
flash(u'İstek gönderilemedi. Kaç gün için ödünç istediğini girmelisin.')
return redirect(return_url)
def initdb_command():
"""Reinitializes the database"""
db.drop_all()
db.create_all()
db.session.commit()
users = []
users.append(User('Bob', 'Smith', '*****@*****.**', '1111111111', '123')) #1
users.append(User('Carol', 'Stevens', '*****@*****.**', '1111111111',
'123')) #2
users.append(User('Anna', 'Martin', '*****@*****.**', '1111111111',
'123')) #3
users.append(User('Daniel', 'Rutgers', '*****@*****.**', '1111111111',
'123')) #4
users.append(User('Frank', 'Lorris', '*****@*****.**', '1111111111',
'123')) #5
users.append(User('John', 'McNault', '*****@*****.**', '1111111111',
'123')) #6
users.append(User('Peter', 'Johnson', '*****@*****.**', '1111111111',
'123')) #7
users.append(User('Laura', 'Smith', '*****@*****.**', '1111111111',
'123')) #8
users.append(User('Jennifer', 'Raj', '*****@*****.**', '1111111111',
'123')) #9
users.append(User('Quan', 'Billson', '*****@*****.**', '1111111111',
'123')) #10
users.append(User('Jamil', 'Reckta', '*****@*****.**', '1111111111',
'123')) #11
users.append(User('Victor', 'Rapedip', '*****@*****.**', '1111111111',
'123')) #12
users.append(User('Mark', 'Zuck', '*****@*****.**', '1111111111',
'123')) #13
users.append(User('Laura', 'shpeng', '*****@*****.**', '1111111111',
'123')) #14
for x in users:
db.session.add(x)
db.session.commit()
groups = []
groups.append(
Group('CS1530 Guys', 'A bunch of dudes studying software engineering',
1)) #group 1
groups.append(Group('CS1530 Girls', 'Ladies is pimps too', 1)) #group 2
groups.append(Group('Go Eagles', 'Phily > PIttsburgh',
users[3].id)) #group 3
for x in groups:
db.session.add(x)
db.session.commit()
users[0].groups.append(groups[0])
users[3].groups.append(groups[0])
users[4].groups.append(groups[0])
users[1].groups.append(groups[1])
users[2].groups.append(groups[1])
users[5].groups.append(groups[0])
users[6].groups.append(groups[1])
users[7].groups.append(groups[1])
users[8].groups.append(groups[0])
users[9].groups.append(groups[2])
users[10].groups.append(groups[2])
users[11].groups.append(groups[2])
users[12].groups.append(groups[2])
users[13].groups.append(groups[1])
db.session.commit()
courses = []
courses.append(
Course('Software Engineering',
'Formal methods of software engineering', 'CS', 1530)) #0
courses.append(
Course('Database Management Systems', 'Database Management Systems',
'CS', 1555)) #1
courses.append(Course('Web Applications', 'Web Applications', 'CS',
1520)) #2
courses.append(Course('Operating Systems', 'Operating Systems', 'CS',
1550)) #3
courses.append(
Course('Interface Design Methodology',
'Interface design for mobile applications', 'CS', 1635)) #4
courses.append(
Course('High performance computing',
'Introduction to high performance computing', 'CS', 1645)) #5
courses.append(
Course('Intro to Data Science', 'Intro to Data Science', 'CS',
1656)) #6
courses.append(
Course('Intmdt Prog Using Java', 'Intermediate programming with java',
'CS', 401)) #7
courses.append(
Course('Data Structures', 'Intro to data structures', 'CS', 445)) #8
courses.append(
Course('Intro to System Software', 'Introduction to system software',
'CS', 449)) #9
for x in courses:
db.session.add(x)
db.session.commit()
for i, x in enumerate(users):
if i < 5:
x.current_courses.append(courses[0])
x.current_courses.append(courses[1])
x.current_courses.append(courses[2])
x.current_courses.append(courses[3])
x.current_courses.append(courses[4])
else:
x.current_courses.append(courses[5])
x.current_courses.append(courses[6])
x.current_courses.append(courses[7])
x.current_courses.append(courses[8])
x.current_courses.append(courses[9])
users.append(User('John', 'Doe', '*****@*****.**', '1111111111', '123'))
for i, x in enumerate(users):
if i < 7:
x.past_courses.append(courses[5])
x.past_courses.append(courses[6])
x.past_courses.append(courses[7])
x.past_courses.append(courses[8])
x.past_courses.append(courses[9])
else:
x.past_courses.append(courses[0])
x.past_courses.append(courses[1])
x.past_courses.append(courses[2])
x.past_courses.append(courses[3])
x.past_courses.append(courses[4])
db.session.commit()
groups[0].group_courses.append(courses[0])
groups[1].group_courses.append(courses[0])
groups[2].group_courses.append(courses[3])
db.session.commit()
convos = []
# group_id, tutor_id, student_id
convos.append(Conversation(None, users[2].id, users[3].id)) #1
convos.append(Conversation(groups[0].id, None, users[3].id)) #2
convos.append(Conversation(groups[1].id, None, users[1].id)) #3
convos.append(Conversation(None, users[1].id, users[0].id)) #4
convos.append(Conversation(groups[2].id, None, users[4].id)) #5
convos.append(Conversation(None, users[6].id, users[7].id)) #6
convos.append(Conversation(None, users[9].id, users[8].id)) #7
convos.append(Conversation(None, users[10].id, users[12].id)) #8
for x in convos:
db.session.add(x)
db.session.commit()
messages = []
messages.append(
Message(users[2].id, datetime.datetime.now(),
"What time would be good to meet?", convos[0].id))
messages.append(
Message(users[3].id, datetime.datetime.now(), "Never dumbass LOL",
convos[0].id))
messages.append(
Message(users[2].id, datetime.datetime.now(), "Why can't you help me?",
convos[0].id))
messages.append(
Message(users[3].id, datetime.datetime.now(),
"Was just joking, send me a meeting request", convos[0].id))
messages.append(
Message(users[1].id, datetime.datetime.now(),
"Shalom, looks like a prety cool group", convos[1].id))
messages.append(
Message(groups[0].id, datetime.datetime.now(),
"Yeah I know were pretty sick", convos[1].id))
messages.append(
Message(groups[0].id, datetime.datetime.now(),
"I don't know how to do problem number 3 from quiz 1",
convos[1].id))
messages.append(
Message(groups[0].id, datetime.datetime.now(), "Can anyone help me?",
convos[1].id))
messages.append(
Message(users[1].id, datetime.datetime.now(),
"What is this group for?", convos[2].id))
messages.append(
Message(users[1].id, datetime.datetime.now(), "Read the BIO!",
convos[2].id))
messages.append(
Message(users[1].id, datetime.datetime.now(),
"What grade did you get in data structures?", convos[3].id))
messages.append(
Message(users[0].id, datetime.datetime.now(), "An A-", convos[3].id))
messages.append(
Message(users[1].id, datetime.datetime.now(),
"Great! Let's schedule a tutoring session", convos[3].id))
messages.append(
Message(
users[4].id, datetime.datetime.now(),
"If anyone needs assistance with their homework 3, shoot me a message",
convos[4].id)) #5
messages.append(
Message(groups[2].id, datetime.datetime.now(),
"I think we all do, can we set up a group tutoring session",
convos[4].id))
messages.append(
Message(
users[6].id, datetime.datetime.now(),
"Struggling alot in 445, I saw you recently took that class. Can we set up a tutoring sesson?",
convos[5].id))
messages.append(
Message(users[7].id, datetime.datetime.now(), "Yes absolutely",
convos[5].id))
messages.append(
Message(users[6].id, datetime.datetime.now(),
"Great! Let's schedule a tutoring session", convos[5].id))
messages.append(
Message(
users[9].id, datetime.datetime.now(),
"Struggling alot in 1501, I saw you recently took that class. Can we set up a tutoring sesson?",
convos[6].id))
messages.append(
Message(users[8].id, datetime.datetime.now(), "Yes absolutely",
convos[6].id))
messages.append(
Message(users[9].id, datetime.datetime.now(),
"Great! Let's schedule a tutoring session", convos[6].id))
messages.append(
Message(
users[10].id, datetime.datetime.now(),
"Struggling alot in system architecture, I saw you recently took that class. Can we set up a tutoring sesson?",
convos[7].id))
messages.append(
Message(users[12].id, datetime.datetime.now(), "Yes absolutely",
convos[7].id))
messages.append(
Message(users[10].id, datetime.datetime.now(),
"Great! Let's schedule a tutoring session", convos[7].id))
for x in messages:
db.session.add(x)
db.session.commit()
meeting_reqs = []
meeting_reqs.append(
Meeting(str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")),
"Cathy", courses[2].id, convos[1].id, users[3].id, None))
meeting_reqs.append(
Meeting(str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")),
"Benny", courses[2].id, convos[1].id, None, groups[0].id))
meeting_reqs.append(
Meeting(str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")),
"Hillman", courses[0].id, convos[0].id, users[1].id, None))
meeting_reqs.append(
Meeting(str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")),
"Market", courses[1].id, convos[2].id, users[1].id, None))
for x in meeting_reqs:
db.session.add(x)
db.session.commit()
contact_req = []
contact_req.append(
ContactRequest("Yo yo yo, add me dawg", users[0].id, users[0].id, None,
groups[1].id))
contact_req.append(
ContactRequest("Hiyah I need a tutor", users[2].id, users[2].id,
users[3].id, None))
for x in contact_req:
db.session.add(x)
db.session.commit()
def ajax():
'''Handler for ajax call that accepts a pcap file upload and returns JSON data
with all conversations and packets in pcap file.
'''
# handle file upload
file = request.files['file']
if file:
# add timestamp to escaped file name
pcap_file = str(int(time.time())) + secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], pcap_file))
else:
abort(500)
# process file with tshark command and parse output into a list of packets
tshark_output = subprocess.getoutput('tshark -o column.format:"AbsTime","%Yt","Source IP Address","%us","Source Port","%uS","Destination IP Address","%ud","Destination Port","%uD" -r {}'.format(pcap_file))
tshark_lines = [l.strip() for l in tshark_output.split('\n')]
Packet.protocols = {}
packets = []
for line in tshark_lines:
p = line.split()
try:
dt = datetime.strptime(p[0] + p[1].rstrip('0'), '%Y-%m-%d%H:%M:%S.%f')
except ValueError:
abort(500)
del p[:2]
p.append(dt)
# if we get a packet line with an odd amount of data, ignore it
# this takes care of packets with no source or destination port (e.g. ARP)
if len(p) != 5:
continue
packets.append(Packet(*p))
# get a list of conversations
conversations = []
packets.sort(key=lambda x: x.time)
for p in packets:
# going through time
c = get_conversation(p, conversations)
if not c:
c = Conversation(src_ip=p.src_ip, dst_ip=p.dst_ip, proto=p.proto)
conversations.append(c)
c.packets.append(p)
# prepare data for processing in d3
data_list = []
conv_dict = {}
conv_ctr = len(conversations)
for c in conversations:
c.conv_id = str(conv_ctr)
conv_ctr -= 1
for p in c.packets:
data_list.append((str(p.time), c.conv_id))
conv_dict.update({c.conv_id: {'src_ip': c.src_ip,
'dst_ip': c.dst_ip,
'proto': c.proto,
'first_point': (str(c.packets[0].time), c.conv_id),
'last_point': (str(c.packets[-1].time), c.conv_id)}})
return json.dumps([conv_dict, data_list])
from models import BaseModel, TextContent, MessageContent, Photo, Role, User, UserRoles, MessageType, ConversationType, Conversation, Message, ConversationParty, Quotation, Company, database
try:
database.drop_tables(BaseModel.__subclasses__(), safe = True, cascade = True)
# database.create_tables(BaseModel.__subclasses__())
Photo.create_table()
Role.create_table()
User.create_table()
UserRoles.create_table()
MessageType.create_table()
ConversationType.create_table()
Quotation.create_table()
Company.create_table()
TextContent.create_table()
MessageContent.create_table()
Conversation.create_table()
Message.create_table()
ConversationParty.create_table()
database.create_foreign_key(Conversation, Conversation.last_message)
except Exception as e:
print('Error while creating schema %s' % e)
