def comment(request):
if request.method == "POST":
article_id = int(request.POST.get("article_id"))
article = Article.objects.get(id=article_id)
content = request.POST.get("comment")
current_no = request.POST.get("current_no")
to_comment_id = int(request.POST.get("to_comment_id", 0))
c = Comment(article=article, content=content, status=0)
c.owner = request.user
if to_comment_id != 0:
to_comment = Comment.objects.get(id=to_comment_id)
else:
to_comment = None
c.to_comment = to_comment
c.save()
if c.to_comment:
msg = Message(owner=c.to_comment.owner, status=-1)
msg.content = "{}回复了你的评论:{}".format(c.owner, c.to_comment.content)
msg.link = "{}?page_no={}".format(c.article.id, current_no)
else:
msg = Message(owner=c.article.owner, status=-1)
msg.content = "{}回复了你的文章;{}".format(c.owner, c.article.title)
msg.link = "{}?page_no={}".format(c.article.id, current_no)
msg.save()
if Comment.objects.filter(id=c.id):
a = {"status": "ok"}
return json_response(a)
else:
a = "err"
return json_response(a)
def handle(self, *args, **options):
if options['messages']:
nb_messages = options['messages']
else:
nb_messages = DEFAULT_NB_MESSAGES
if options['users']:
nb_users = options['users']
else:
nb_users = DEFAULT_NB_USERS
users = []
print("Starting the generation...")
for _ in range(0, nb_users):
username = "******".format(
DUMMY_USERNAMES[randrange(0, len(DUMMY_USERNAMES))], uuid4())
user = User(username=username, email='{}@asd.com'.format(username))
user.save()
users.append(user)
print("Created {} users.".format(nb_users))
for _ in range(0, nb_messages):
message = Message(sender=users[randrange(0, len(users))],
recipient=users[randrange(0, len(users))],
content=DUMMY_CONTENTS[randrange(
0, len(DUMMY_CONTENTS))])
message.save()
print("Created {} messages. Success!".format(nb_messages))
def comment(request):
if request.method == "POST":
article_id = request.POST['article_id']
content = request.POST['content'].strip()
to_comment_id = int(request.POST.get("to_comment_id", 0))
article = Article.objects.get(id=article_id)
user = request.user
if not content:
return json_response({"status": "err", "msg": "内容不能为空"})
if to_comment_id != 0:
to_comment = Comment.objects.get(id=to_comment_id)
else:
to_comment = None
c = Comment(owner=user,
article=article,
content=content,
status=0,
to_comment=to_comment)
c.save()
link = "http://%s/article/detail/%s" % (request.get_host(), article_id)
print(link)
contents = "有人评论你‘" + content + "'"
m = Message(owner=user, content=contents, link=link, status=1)
m.save()
return json_response({"status": "ok", "msg": ""})
else:
return render(request, "article/article_detail.html")
def post(self, request, *args, **kwargs):
"""
Checkes if Bid has already been accepted. Accepts the bid if not.
If already has enough chosen bids, automataically updates the job.
"""
pk = kwargs['pk']
bid = Bid.objects.get(pk=pk)
job = bid.job
context = {}
profile = Person.objects.get(person=self.request.user)
if 'hire' in request.POST:
number_of_hired_workers = len(job.bid_set.filter(is_chosen=True))
#Checks if Job already has enough chosen bids
if number_of_hired_workers != job.number_employee:
bid.is_chosen = True
status = "Hired!"
receiver = bid.bidder
job.jobworker_set.create(worker=receiver)
name = '%s %s' % (profile.firstname, profile.lastname[0])
message = """
<a href='%s'> %s</a> has chosen your bid at <a href='%s'> %s</a>
""" % (profile.get_absolute_url(), name, job.get_absolute_url(), job)
m = Message(title="Chosen Bidder",
content=message,
receiver=receiver,
sender=profile)
m.save()
receiver.person.email
subject = "%s has chosen your bid at %s" % (name, job)
message = "Congrats! please check your home page for further details"
to = receiver.person.email
#send_mail(subject,message,'*****@*****.**',[to],fail_silently=False)
context = {'profile': profile, 'job': job}
email_content = render_to_string('email/bid_accept.html',
context)
send_mail(subject,
email_content,
'*****@*****.**', [to],
fail_silently=False)
#check if already has enough people
job.save()
bid.save()
number_of_hired_workers = len(
job.bid_set.filter(is_chosen=True))
if number_of_hired_workers == job.number_employee:
job.has_winner = True
job.save()
else:
status = "Already Hired the required people!"
elif 'unhire' in request.POST:
bid.is_chosen = False
job = job
job.has_winner = False
status = "Unhired!"
bid.save()
context['status'] = status
context['back'] = job.get_absolute_url()
return render_to_response('success.html',
context,
context_instance=RequestContext(request))
def post(request):
serializer = MessageSerializer(many=False, data=request.data)
if serializer.is_valid():
message = serializer.validated_data
a = Application.objects.get(pk=request.data['application'])
del message['application']
message['author_name'] = a.name
message['thumb_url'] = a.thumb_url
m = Message(a, message['title'], message['text'], message['color'])
if Slack.post_message(m):
return Response(None, status=204)
else:
return Response({"error": "Something happened"}, status=500)
else:
return Response(serializer.errors, status=400)
def media_create(request, *args, **kwargs):
if request.method == 'POST':
contract_id = kwargs.get('pk')
contract = Contract.objects.get(pk=contract_id)
message = Message()
message.sent_by = contract.discussion.influencer.user
message.sent_to = contract.discussion.campaign.agent
message.discussion = contract.discussion
message.content = "I have uploaded post media. Please take a look at <a href='/campaigns/contracts/" + str(
contract.id
) + "?post_actived=0d(this)'>here</a> and let me know your thought."
message.save()
res_dialog = asyncio.run(
get_dialogs(request.session['chat_session_token'],
contract.discussion_id))
asyncio.run(
send_message(request.session['chat_session_token'],
res_dialog['_id'], message.content))
media = Media()
media.title = request.POST.get('media_title')
media.media = request.FILES['media_file']
media.file_name = request.FILES['media_file'].name
media.upload_by = Influencer.objects.get(user=request.user)
media.contract = contract
media.save()
return redirect('/campaigns/contracts/' + str(contract_id) +
'?post_actived=0')
def receive_message(self, incoming_sms: IncomingSms):
phone_number = incoming_sms.from_number
try:
charity_user = CharityUser.objects.get(phone_number=phone_number)
except:
charity_user = CharityUser(phone_number=phone_number)
charity_user.save()
message = Message()
message.status = MessageStatus.DELIVERED
message.message = incoming_sms.body
message.charity_user = charity_user
message.save()
# fix type here define __str__
message = str(message.message)
match_object = re.search("^subscribe (.*)", message)
if match_object:
topic_name = match_object.group(1)
topic = list(NewsletterTopic.objects.filter(name=topic_name))[0]
charity_user.subscribed_newsletter_topics.add(topic)
charity_user.save()
return MessagingResponse()
match_object = re.search("^unsubscribe (.*)", message)
if match_object:
topic_name = match_object.group(1)
topic = list(NewsletterTopic.objects.filter(name=topic_name))[0]
charity_user.subscribed_newsletter_topics.remove(topic)
charity_user.save()
return MessagingResponse()
return MessagingResponse()
def create_client_message(request, *args, **kwargs):
if request.method == 'POST':
campaign_id = request.POST.get('campaign_id')
campaign = Campaign.objects.get(pk=campaign_id)
content = request.POST.get('content')
type = request.POST.get('type')
message = Message()
if type == 'CA':
message.sent_by = campaign.client
message.sent_to = campaign.agent
else:
message.sent_by = campaign.agent
message.sent_to = campaign.client
message.campaign = campaign
message.content = content
message.save()
return render(
request, 'messages/client_message_body.html', {
'channel_messages':
Message.objects.filter(
campaign__id=campaign_id).order_by('sent_at'),
'description':
campaign
})
def form_valid(self, form, **kwargs):
''' Validates the form of Comment
also puts the bidder and job
'''
self.object = form.save(commit=False)
job = self.request.session['job']
form.instance.job = job
person = Person.objects.get(person=self.request.user)
form.instance.commentor = person
profile = person
profile_class = profile.person_class.person_class
if profile_class == 'doer':
receiver = job.creator
elif profile_class == 'poster':
receiver = self.object.receiver
message = """
<a href='%s'>%s</a> has reviewed you on task <a href='%s'> %s</a>.
View your <a href='%s'>profile</a> to see.
""" % (person.get_absolute_url, person, job.get_absolute_url(), job,
receiver.get_absolute_url())
m = Message(title="Comment",
content=message,
receiver=receiver,
sender=person)
m.save()
return super(CommentCreateView, self).form_valid(form)
def create(self, validated_data):
data = {
k: v
for k, v in validated_data.items() if k != "message_user_id"
}
message = Message(**data)
message.charity_user = CharityUser.objects.get(
pk=validated_data["message_user_id"])
return message
def create_message(user, stream, content):
if isinstance(user, AnonymousButNamedUser):
return create_message_for_anonymous_but_named_user(
user, stream, content)
if not user_is_enabled(user):
raise UserIsNotEnabledException
message = Message(user=user, stream=stream, content=content)
message.save()
return message
def receive(self, text_data):
text_data_json = json.loads(text_data)
msg_text = text_data_json['msg_text']
m = Message(msg_text=msg_text,
msg_sender=User.objects.get(user_name=self.user_name),
msg_group=Group.objects.get(pk=self.group_id))
m.save()
# Send message to room group
async_to_sync(self.channel_layer.group_send)(self.room_group_name,
self.message_to_dict(m))
def new_message(self,data):
message = Message(
content= str(data['message']['content'].replace("\n", " ")),
contact_id= int(data['message']['contact']),
chat_id=int(data['message']['chat'])
)
message.save()
serializer = MessageSerializer(message)
content = {
'command': 'new_message',
'message': serializer.data
}
return self.send_chat_message(content)
def messages(first_user, second_user):
messages = []
for _ in range(0, 10):
message = Message(
sender=first_user,
recipient=second_user,
content='test'
)
message.save()
messages.append(message)
return messages
def index():
initdb();
messages = Message.query.order_by(Message.timestamp.desc()).all()
form = HelloForm()
if form.validate_on_submit():
name = form.name.data
body = form.body.data
message = Message(body=body, name=name)
db.session.add(message)
db.session.commit()
flash('Your message have been sent to the world!')
return redirect(url_for('index'))
return render_template('index.html', form=form, messages=messages)
def create_message(request, *args, **kwargs):
if request.method == 'POST':
discussion_id = request.POST.get('discussion_id')
if request.POST.get('dialog_id'):
dialog_id = request.POST.get('dialog_id')
discussion = Discussion.objects.get(pk=discussion_id)
content = request.POST.get('content')
type = request.POST.get('type')
if type == 'CO':
budget = request.POST.get('budget')
contract = Contract()
contract.contract_title = request.POST.get('title')
contract.contract_terms = request.POST.get('terms')
contract.contract_status = 'OF'
contract.contract_budget = budget
contract.discussion = discussion
contract.save()
content = content + "<br/>You can accept or decline this offer <a href='#' onclick='contract_agree(this)' data-id='" + str(
contract.id) + "'>here</a>!"
# QB chat send message from agent to influencer
# asyncio.run(send_message(
# request.session['chat_session_token'],
# dialog_id,
# content
# ))
message = Message()
if type == 'IA':
message.sent_by = discussion.influencer.user
message.sent_to = discussion.campaign.agent
if type == 'AI' or type == 'CO':
message.sent_by = discussion.campaign.agent
message.sent_to = discussion.influencer.user
message.discussion = discussion
message.content = content
message.save()
if dialog_id:
return HttpResponse(contract.id)
else:
return render(
request, 'messages/message_body.html', {
'channel_messages':
Message.objects.filter(
discussion__id=discussion_id).order_by('sent_at'),
})
def send_message(self, request, id=None):
chat = get_object_or_404(self.queryset, id=id)
user = get_object_or_404(Member.objects.all().filter(chat=chat), user=request.user)
try:
message = Message(
user=request.user,
chat=chat,
text=request.data['text'],
)
message.save()
serializer = MessageSerializer(message)
return Response({'message': serializer.data}, status=status.HTTP_200_OK)
except KeyError:
return Response({}, status=status.HTTP_400_BAD_REQUEST)
def add_message(req):
content = req.POST.get('text', '')
if content == '':
return JsonResponse(
{
'errorCode': 'invalid_request',
'errorMessage': 'Invalid request, no text parameter'
},
status=400)
thread, created = Thread.objects.get_or_create(profile=req.user.profile)
# rate limit
if (thread.is_pending):
last_staff_msg = Message.objects.filter(is_staff=True,
thread=thread.id)
ratelimit_hour = timezone.now() - timedelta(hours=6)
time_check = ratelimit_hour
if (last_staff_msg and last_staff_msg[0].timestamp > ratelimit_hour):
# chose last hour, or the last time a staff replied
time_check = last_staff_msg[0].timestamp
count = Message.objects.filter(timestamp__gt=time_check).count()
if (count >= 5):
return JsonResponse(
{
'errorCode':
'ratelimit',
'errorMessage':
'Please wait for a response before trying to send further requests.'
},
status=400)
thread.is_pending = True
thread.save()
message = Message(thread=thread, content=content)
message.save()
template_email(settings.DEFAULT_FROM_EMAIL, settings.HELP_INCHARGE,
'[Mag:help] : ' + req.user.email, 'admin_help_request', {
'user': req.user.profile,
'message': message
})
return HttpResponse(status=200)
def reply(request):
if not request.user.is_authenticated():
return redirect('/home')
sender = request.user
pid = request.POST.get('pid', None)
receiver = User.objects.get(id=pid)
subject = request.POST.get('subject', None)
text = request.POST.get('message', None)
reply = Message(sender=sender,
receiver=receiver,
subject=subject,
message=text)
reply.save()
request.session['message'] = "Message Sent Successfully"
request.session['message_type'] = True
return redirect(profile)
def submessage(request):
msgs = Message.objects.all()[:2]
name = request.POST.get('name', '')
email = request.POST.get('email', '')
phone_num = request.POST.get('address', '')
mess = request.POST.get('message', '')
if name != '':
msg = Message()
msg.name = name
msg.email = email
msg.phone_num = phone_num
msg.messages = mess
msg.save()
return render(request, 'show.html', {
'msgs': msgs,
})
def send(request):
if not request.user.is_authenticated() or not request.user.is_active:
return HttpResponse("-1")
receiver = User.objects.get(username=request.POST.get('to'))
sender = User.objects.get(username=request.POST.get('from'))
body = request.POST.get('body')
i = 0
current = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M')
profile = receiver.get_profile()
profile.notify = profile.notify + 1
profile.save()
chats = Chat.objects.all()
message = Message(receiver=receiver,
sender=sender,
body=body,
time=current)
message.save()
for chat in chats:
if (chat.receiver == receiver
and chat.sender == sender) or (chat.receiver == sender
and chat.sender == receiver):
temp = Chat.objects.get(id=chats[i].id)
temp.notify = temp.notify + 1
print temp.notify
temp.messages.append(message)
temp.time = current
temp.save()
#print i
return HttpResponse("2")
else:
i = i + 1
if i == len(chats):
print "2"
messages = []
messages.append(message)
chat = Chat(notify=1,
time=current,
receiver=receiver,
sender=sender,
messages=messages)
chat.save()
return HttpResponse("1")
def create_message(request):
token = request.headers.get('Authorization')[6:]
form = MessageForm(request.POST, request.FILES)
if form.is_valid():
# print(request.POST, request.FILES)
data = request.POST
my_id = Token.objects.filter(key=token).values('user_id')[0]['user_id']
message = Message(chat_id=data['chat_id'], user_id=my_id, content=data['content'])
session = boto3.Session()
s3_client = session.client(service_name='s3',
endpoint_url='http://hb.bizmrg.com',
aws_access_key_id='ns3JMEzqS7GkxRcCuvRDVh',
aws_secret_access_key='8DvkXKZkUdebaEkBfnyGKhJBZaMaW4ybJdxwiN2WzeEv')
if request.POST['attachment_type'] == 'null':
print('without attachment')
message.save()
return JsonResponse({'Result':'Message created without attachment'})
elif request.POST['attachment_type'] == 'images':
print('with images')
message.save()
uploaded_file = request.FILES.getlist('media')
for file in uploaded_file:
print(file)
url_location = 'attachments/chat' + data['chat_id'] + '/' + data['attachment_type'] + '/' + file.name + '-' + str(hash(file))
s3_client.put_object(Bucket='z3hdro_messenger', Key=url_location, Body = file)
attach = Attachment(chat_id=data['chat_id'], user_id=my_id, message_id=message.id, type_attachment=data['attachment_type'], url = url_location)
attach.save()
return JsonResponse({'Result':'Message created with image attachment'})
elif request.POST['attachment_type'] == 'audio_message':
print('with audio')
message.save()
uploaded_file = request.FILES['media']
url_location = 'attachments/chat' + data['chat_id'] + '/' + data['attachment_type'] + '/' + 'audio-' + str(hash(uploaded_file))
s3_client.put_object(Bucket='z3hdro_messenger', Key=url_location, Body = uploaded_file)
attach = Attachment(chat_id=data['chat_id'], user_id=my_id, message_id=message.id, type_attachment=data['attachment_type'], url = url_location)
attach.save()
return JsonResponse({'Result':'Message created with audiorecord attachment'})
elif request.POST['attachment_type'] == 'geolocation':
print('with geolocation')
message.save()
attach = Attachment(chat_id=data['chat_id'], user_id=my_id, message_id=message.id, type_attachment=data['attachment_type'], url = data['geolocation_url'])
attach.save()
return JsonResponse({'Result':'Message created with geolocation'})
return JsonResponse({'error':'unexpected bug'}, status=400)
return JsonResponse({'error': form.errors}, status=400, json_dumps_params={'ensure_ascii': False})
def post(self, request, format=None):
if request.data['receiver_id']:
#получаем отправителя и получателя
sender = User.objects.get(username=request.user.username)
receiver = User.objects.get(id=request.data['receiver_id'])
msg = Message()
msg.text = request.data['text']
msg.save()
msg.sender.add(sender)
msg.receiver.add(receiver)
msg.save()
return Response({'status': True})
else:
return HttpResponseBadRequest()
def create_message(request, pk):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
data = form.cleaned_data
m = Message(user=request.user,
char=Chat.objects.get(id=pk),
content=data['text'])
m.save()
text = "Сообщение отправлено"
else:
text = "Ошибка при обработке данных"
else:
text = "Ошибка при отправке сообщения"
id = pk
return render_to_response('message/textform.html', {
'text': text,
'id': id
})
def createMessage(root):
message = Message().defaultFields()
# Handle messageID here
for messageID in root.iter(TAG_PREFIX + 'MessageID'):
message.messageID = messageID.text
# Handle Prescriber here
for prescriber in root.iter(TAG_PREFIX + 'Prescriber'):
handlePrescriber(message, prescriber)
# Handle Patient here
for patient in root.iter(TAG_PREFIX + 'Patient'):
handlePatient(message, patient)
# Handle Medication here
for medication in root.iter(TAG_PREFIX + 'MedicationPrescribed'):
handleMedication(message, medication)
# Handle Pharmacy here
for pharmacy in root.iter(TAG_PREFIX + 'Pharmacy'):
handlePharmacy(message, pharmacy)
handleGeographicData(message)
return message
def ReplyMessage(request, mid):
reply_to = Message.objects.get(pk=mid)
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
data = form.cleaned_data
quoted_message = Message.objects.get(pk=mid)
subject = data.get('subject')
body = data.get('message')
reply_message = Message(subject=subject, body=body)
Inbox(request.user).reply_to_message(quoted_message=quoted_message,
reply_message=reply_message)
messages.info(request, "Reply Sent", extra_tags="reply-confirm")
return redirect('instructor:Inbox')
else:
form = MessageForm()
context = {'MessageForm': form, 'mid': mid, 'reply_to': reply_to}
return render(request, 'instructor/ReplyToMessage.html', context)
def form_valid(self, form, **kwargs):
job = self.request.session['job']
profile = Person.objects.get(person=self.request.user)
form.instance.job = job
form.instance.person = profile
ids = []
for d in job.discussion_set.all():
if d.person != profile:
ids.append(d.person.id)
receiver = Person.objects.filter(id__in=ids)
for person in receiver:
message = """
<a href='%s'>%s</a> has a comment on task <a href='%s'> %s</a>
""" % (profile.get_absolute_url(), profile, job.get_absolute_url(), job)
m = Message(title="Comment",
content=message,
receiver=person,
sender=profile)
m.save()
return super(AddDiscussion, self).form_valid(form)
def send_msg(msg: Msg):
from message.models import Message, Recipient, Templates, Error
from datetime import datetime
template = Templates.objects.get(id=msg.id_template)
msg_db = Message(subject=msg.subject,
text=msg.text,
id_template=template)
msg_db.save()
email = Email(AccountSMTP)
for recipient in msg.recipients:
recipient_db = Recipient(email=recipient, id_message=msg_db)
recipient_db.save()
error = email.send([recipient],
msg.subject,
html=template.html.format(**msg.variables))
if error:
Error(id_message=msg_db, description=error).save()
else:
recipient_db.send = datetime.now()
recipient_db.save()
def comment_create(request):
parm = {}
to_comment_id = int(request.POST.get("to_comment_id", 0))
print("to_comment_id", to_comment_id)
parm["content"] = request.POST.get("content")
parm["article_id"] = request.POST.get("article_id")
parm["b_id"] = request.POST.get("b_id")
parm["page_no"] = request.POST.get("page_no")
ok = {"status": "ok", "msg": "发布成功"}
err = {"status": "err", "msg": "发布失败"}
# article_id =64
# content =request.POST["content"]
article_id = parm["article_id"]
content = parm["content"]
article_id = int(article_id)
article = Article.objects.get(id=article_id)
name = request.user
link = "http://%s/article/%s/%s/detail?page_no=%s" % (
request.get_host(), parm["b_id"], parm["article_id"], parm["page_no"])
form = CommentForm(request.POST)
if to_comment_id != 0:
to_comment = Comment.objects.get(id=to_comment_id)
owner = to_comment.owner
else:
to_comment = None
owner = article.owner
if form.is_valid():
comment = Comment(article=article,
owner=name,
content=content,
to_comment=to_comment,
status=0)
comment.save()
message = Message(owner=owner, content=content, link=link, status=0)
message.save()
return HttpResponse(json.dumps(ok))
else:
return HttpResponse(json.dumps(err))
def post(self, request, *args, **kwargs):
"""
Button for adding new BIDDING, COMMENTING, and DISCUSSION.
gets session of job to be passed to bid, comment, or discusion application
"""
profile = Person.objects.get(person=request.user)
kaakay = Person.objects.get(slug=kwargs['slug'])
request.session['kaakay'] = kaakay
context = {'status': request.session['kaakay']}
kaakay = self.request.session['kaakay']
poster = Person.objects.get(person=self.request.user)
message = "<a href='%s'>%s</a> wants you for task" % (
poster.get_absolute_url(), poster)
m = Message(title="Poster wants you!",
content=message,
receiver=kaakay,
sender=profile)
m.save()
return HttpResponseRedirect('/job/post')
