def doquit(player, actiion_id):
from bprintf import buff
from models import Message
# if isforce:
# buff.bprintf("You can't be forced to do that\n")
# return
player.rte()
w = player.loadw()
# if(in_fight)
# buff.bprintf("Not in the middle of a fight!\n")
# return
xx = "{} has left the game\n".format(player.name)
buff.bprintf("Ok")
Message.send(player, player, -10000, player.curch, xx)
xx = "[ Quitting Game : {} ]\n".format(player.name)
Message.send(player, player, -10113, 0, xx)
# dumpitems()
player.strength = -1
player.name = ''
player.save(w)
player.curmode = 0
player.curch = 0
player.save(w)
player.alive = False
# crapup("Goodbye")
pass
def regiest_action(request):
if request.method == "POST":
userform = Userform(request.POST)
msg_count = 1
if userform.is_valid():
userform = userform.cleaned_data
t_username = userform.get('username')
user = UserCreationForm({'username':t_username,'password1':userform.get('passwd1'),'password2':userform.get('passwd2')})
verify = getverify()
ret = send(userform.get('email'), t_username, verify)
if ret:
username = t_username
user.save()
userinfo = Userinfo(username=userform.get('username'),activity='0',email=userform.get('email'),telephone=userform.get('telephone'),address=userform.get('address'),verify=security(verify),gender=userform.get('gender'),id=User.objects.get(username = username))
userinfo.save()
user = auth.authenticate(username = username,password = userform.get('passwd1'))
auth.login(request,user)
request.session['user'] = username
user_from = Userinfo.objects.get(username = '******')
user_to = Userinfo.objects.get(username = username)
message = Message(title = NEW_USER_TITLE,body = NEW_USER_BODY,state = 0,date = datetime.now(),user_from = user_from,user_to = user_to)
message.save()
success_msg = '请登录%s查收邮件激活！'.decode('utf-8') % userform.get('email')
return jump_to_success(success_msg)
else:
error_msg = '验证邮件发送失败！'
return jump_to_error(error_msg)
else:
error = "出错了，请重新注册！"
return render_to_response('regiest.html',locals())
else:
return render_to_response('regiest.html',locals())
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 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 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 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 home(request):
"""render contact form
if a form is submitted check if it is valid and save it
"""
ci = RequestContext(request)
tmpl = {}
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
message = Message(
name=form.cleaned_data['name'],
mail=form.cleaned_data['mail'],
message=form.cleaned_data['message']
)
message.save()
tmpl['form'] = MessageForm()
tmpl['success'] = 1
else:
tmpl['form'] = form
tmpl['error'] = 1
else:
form = MessageForm()
tmpl['form'] = form
return render_to_response("message/home.html", tmpl, ci)
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 create(request, project_id):
project = get_object_or_404(
Project,
id=project_id,
is_active=True,
author__is_active=True
)
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
message = Message(
author=request.user,
project=project,
text=form.cleaned_data['text']
)
message.save()
return redirect(
request,
'project-message_list',
[project.id],
{request.url_name: 'True'}
)
else:
form = MessageForm()
params = {'project': project, 'form': form}
params.update(csrf(request))
return response(request, params)
def player_load(self):
logger.debug("---> special(\".g\", {})".format(self))
from message.models import Message
self.curmode = 1
self.curch = -5
self.initme()
ufl = self.loadw()
self.strength = self.person.strength
self.level = self.person.level
if self.person.level < 10000:
self.visible = 0
else:
self.visible = 10000
self.weapon = -1
self.sex = self.person.sex
self.helping = -1
xy = "<s player=\"{}\">{} has entered the game\n</s>".format(self.id, self.name)
xx = "<s player=\"{}\">[ {} has entered the game ]\n</s>".format(self.id, self.name)
Message.send(self, self, -10113, self.curch, xx)
self.rte()
if randperc() < 50:
self.curch = -183
self.goto_channel(self.curch)
Message.send(self, self, -10000, self.curch, xy)
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 write(request,userId):
if request.POST:
to = User.objects.get(id=userId)
message = Message(to_who=to,from_whom=request.user,message_text=request.POST["text"],message_date=timezone.now())
message.save()
return HttpResponseRedirect(reverse('message:om'))
else:
to = User.objects.get(id=userId)
return render(request,"messages/write.html",{"to":to})
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 save(self):
from message.models import Message
connection = Redis.get_connection()
if not self.id:
self.id = next_id('comment')
connection.rpush('{0}:{1}'.format(COMMENT, self.msg_id),
json_encode(self._to_db()))
message = Message(id=self.msg_id)
message.incr_comment()
def form_valid(self, form):
group = Group.objects.get(pk = self.request.POST['group'])
body = self.request.POST['body']
ref = Message.objects.get(pk = self.request.POST['ref']) if self.request.POST['ref'] else None
tag = Tag.tagging(self.request.POST['tag'], self.request.POST['tag_create'], group)
object = Message(body = body, tag = tag, ref = ref, user = self.request.user, group = group)
object.save()
return redirect('/message/' + self.request.POST['group'])
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 borrow_book(request):
if request.method == "POST" and "bookid" in request.POST:
borrower = request.user.id
book = Book.objects.filter(id=request.POST["bookid"])[0]
ownerid = book.ownerid
msg = Message()
msg.originid = borrower
msg.targetid = ownerid
msg.status = 0
msg.createdate = datetime.datetime.now()
msg.content = request.POST["message"]
msg.handler = "/book/apply/"
msg.save()
rel = Borrowrel()
rel.bookid = book.id
rel.owner = ownerid
rel.borrower = borrower
rel.createdate = datetime.datetime.now()
rel.updatedate = datetime.datetime.now()
rel.status = 0
rel.messageid = msg.id
rel.save()
return redirect("/book/borrowed/")
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 new(request):
if request.user.is_authenticated():
if request.POST:
lastname = request.POST['recipient'].split(',')[0]
stud = Student.objects.get(lastName=lastname)
subj = request.POST['subject']
details = request.POST['details']
t = Messagethread(student=stud, subject=subj)
t.save()
m = Message(student=stud, subject=subj, content=details, timestamp=datetime.datetime.now(), thread=t)
m.save()
return allMessages(request)
return HttpResponseRedirect('/login/')
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 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 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 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 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 article_comment(request):
if (request.method == 'POST'):
if request.user.is_authenticated:
article_id = request.POST["article_id"]
content = request.POST["content"]
page_no = request.POST["page_no"]
article = Article.objects.get(id=article_id)
comment = Comment(article=article, content=content, owner=request.user)
comment.save()
link = "/article/detail/%s/?page_no=%s" % (article_id, page_no)
msg = Message(owner=article.owner, content=content, link=link)
msg.save()
return HttpResponse(json.dumps({"state": "success", "msg": "评论成功"}))
else:
return HttpResponse(json.dumps({"state": "unlogin", "msg": "请先登陆再进行评论"}))
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 rte(self):
from db import findend
from message.models import Message
logger.debug("---> rte({})".format(self))
logger.debug('<!' + '-'*70)
w = self.loadw()
if self.cms == -1:
self.cms = findend()
ct = self.cms
block = Message.readmsg(self.cms)
logger.debug(block)
for m in block:
ct = m.id
logger.debug("#%d", ct)
logger.debug(m)
m.mstoout(self)
logger.debug("%s:%s->%s", self.position, self.cms, ct)
self.cms = ct
self.update()
self.eorte()
# extern long vdes,tdes,rdes;
rdes = 0
tdes = 0
vdes = 0
logger.debug('-'*70 + '>')
def messages(request, association_pseudo):
association = get_object_or_404(Association,pseudo=association_pseudo)
if association.est_cachee_a(request.user.profile):
return redirect(index)
membres = Adhesion.objects.filter(association__pseudo = association_pseudo).order_by('-ordre', 'eleve__last_name')
list_messages = Message.accessibles_par(request.user.profile).filter(association__pseudo=association_pseudo).order_by('-date')
return render(request, 'association/messages.html', {'association' : association, 'list_messages': list_messages, 'membres': membres})
def search(request):
query_string = ''
found_messages = None
found_users = None
if ('q' in request.GET) and request.GET['q'].strip():
query_string = request.GET['q']
message_query = get_query(query_string, ['objet', 'contenu'])
user_query = get_query(
query_string,
['first_name', 'last_name', 'phone', 'chambre', 'user__username'])
found_messages = Message.accessibles_par(
request.user.profile).filter(message_query).order_by('-date')
found_users = UserProfile.objects.filter(user_query).order_by(
'user__username')
if query_string.lower() == 'dieu':
found_users = UserProfile.objects.filter(
user__username__in=['11leuren', '15veaux'])
return render(
request, 'recherche/resultats.html', {
'query_string': query_string,
'list_messages': found_messages,
'list_users': found_users
})
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 _send_user_message(message_id, campaign_id):
message = Message.get(message_id)
pub_id = message.publication_id
publication = Publication.get(pub_id)
donor_ids = publication.get_subscribed_donor_ids()
for donor_id in donor_ids:
_email_donor.delay(donor_id, message.id)
def _send_user_message(message_id, campaign_id):
message = Message.get(message_id)
pub_id = message.publication_id
publication = Publication.get(pub_id)
donor_ids = publication.get_subscribed_donor_ids()
for donor_id in donor_ids:
_email_donor.delay(donor_id, message.id)
def reply(request):
if request.user.is_authenticated():
if request.POST:
try:
lastname = request.POST['replyRecipient']
stud = Student.objects.get(lastName=lastname)
subj = request.POST['replySubject']
details = request.POST['responseText']
t = Messagethread.objects.get(subject=subj)
t.save()
m = Message(student=stud, subject=subj, content=details, timestamp=datetime.datetime.now(), thread=t)
m.save()
except ValueError:
return HttpResponse('key Error')
return HttpResponseRedirect('/messages/')
return HttpResponseRedirect('/login/')
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 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 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")
class ReadTest(TestCase):
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.text = 'Message text...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.message = Message(author=user, project=self.project, text=self.text)
self.message.save()
self.client.login(username=self.username, password=self.passwd)
def test_login_required(self):
self.client.logout()
response = self.client.get(READ_URL % self.message.id)
self.assertRedirects(response, LOGIN_URL + '?next=' + READ_URL % self.message.id)
def test_get(self):
response = self.client.get(READ_URL % self.message.id)
self.assertEqual(response.status_code, 200)
def test_invalid_id(self):
response = self.client.get(READ_URL % '2')
self.assertEqual(response.status_code, 404)
def test_deactivated_project(self):
self.project.is_active = False
self.project.save()
response = self.client.get(READ_URL % self.message.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project_author(self):
username = '******'
email = '*****@*****.**'
passwd = 'abc'
user = User.objects.create_user(username, email, passwd)
self.client.logout()
self.client.login(username=username, password=passwd)
self.project.author.is_active = False
self.project.author.save()
response = self.client.get(READ_URL % self.message.id)
self.assertEqual(response.status_code, 404)
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 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 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 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 new_message_action(request, send_to, username=False, msg_count=0):
if request.method == "GET":
return render_to_response("new_message.html", locals())
elif request.method == "POST":
send_to = request.POST.get("send_to", "")
title = request.POST.get("title", "")
body = request.POST.get("body", "")
if len(send_to) == 0 or len(title) == 0 or len(body) == 0:
error = "不能有空白项"
return render_to_response("new_message.html", locals())
else:
user = Userinfo.objects.get(username=username)
try:
send_to = Userinfo.objects.get(username=send_to)
except:
error = "不存在用户： %s".decode("utf-8") % send_to
send_to = ""
return render_to_response("new_message.html", locals())
message = Message(title=title, body=body, state=0, date=datetime.now(), user_from=user, user_to=send_to)
message.save()
return HttpResponseRedirect("/message")
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')
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.text = 'Message text...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.message = Message(author=user, project=self.project, text=self.text)
self.message.save()
self.client.login(username=self.username, password=self.passwd)
def tous(request):
all_messages = Message.accessibles_par(request.user.profile)
paginator = Paginator(all_messages, 15)
page = request.GET.get('page')
try:
list_messages = paginator.page(page)
except PageNotAnInteger:
list_messages = paginator.page(1)
except EmptyPage:
list_messages = paginator.page(paginator.num_pages)
return render(request, 'messages/tous.html', {'list_messages': list_messages})
def send_message(request):
if not request.user.is_authenticated():
return HttpResponse('User is not authenticated');
if request.method == 'POST':
recipient = request.POST['recipient']
message = request.POST['message']
elif request.method == 'GET':
recipient = request.GET['r']
message = request.GET['m']
else:
return HttpResponse('Method not supported')
print(recipient)
print(message)
try:
user = User.objects.get(username__iexact=recipient)
sender_username = request.user.username
m = Message(sender=sender_username, username=recipient, message=message)
m.save()
return HttpResponse(sender_username)
except:
return HttpResponse('Recipient not found')
def borrow_book(request):
if request.method == 'POST' and 'bookid' in request.POST:
borrower = request.user.id
book = Book.objects.filter(id=request.POST['bookid'])[0]
ownerid = book.ownerid
msg = Message()
msg.originid = borrower
msg.targetid = ownerid
msg.status = 0
msg.createdate = datetime.datetime.now()
msg.content = request.POST['message']
msg.handler = '/book/library/'
msg.save()
rel = Borrowrel()
rel.bookid = book.id
rel.owner = ownerid
rel.borrower = borrower
rel.createdate = datetime.datetime.now()
rel.status = 0
rel.messageid = msg.id
rel.save()
return redirect('/book/library/')
def host_auto_find():
# 通过硬件检查结果得到
key_list = settings.REDIS_DB.keys("GD*_hc")
host_list = [ key.split('_')[0] for key in key_list ]
new_host_set = set(host_list)
host_list = settings.REDIS_DB.get("all_host_list")
if host_list is None:
host_list = []
else:
host_list = host_list.split(',')
old_host_set = set(host_list)
margin_set = new_host_set - old_host_set
app = AppService.objects.get(app_name='HOST_STATUS')
if margin_set:
add_ip = get_ip(margin_set)
msg = Message()
msg.create_time = datetime.now()
msg.occur_time = datetime.now()
msg.content = "发现新主机, 主机ID:%s, 对应IP:%s" % (','.join(margin_set), ','.join(add_ip))
msg.save()
ip_list = []
if app.ip_list:
ip_list = app.ip_list.split(',')
ip_list.extend(add_ip)
app.ip_list = ','.join(filterIP(ip_list))
host_list = []
if app.host_list:
host_list = app.host_list.split(',')
app.host_list = ','.join( set(host_list) | margin_set )
app.save()
# 根据监控项变化情况，同步监控点
sync_monitor_point(app)
# 同步应用配置
sync_app_info(app)
# 变更redis
settings.REDIS_DB.set("all_host_list", ','.join(new_host_set))
class DeleteTest(TestCase):
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.text = 'Message text...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.message = Message(author=user, project=self.project, text=self.text)
self.message.save()
self.client.login(username=self.username, password=self.passwd)
def test_login_required(self):
self.client.logout()
response = self.client.get(DELETE_URL % self.message.id)
self.assertRedirects(response, LOGIN_URL + '?next=' + \
DELETE_URL % self.message.id)
def test_get(self):
response = self.client.get(DELETE_URL % self.message.id)
self.assertEqual(response.status_code, 200)
def test_get_project_author(self):
user = User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.message.author = user
self.message.save()
response = self.client.get(DELETE_URL % self.message.id)
self.assertEqual(response.status_code, 200)
def test_post(self):
self.client.post(DELETE_URL % self.message.id)
self.assertEqual(Message.objects.filter(is_active=True).count(), 0)
def test_post_project_author(self):
user = User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.message.author = user
self.message.save()
response = self.client.post(DELETE_URL % self.message.id)
self.assertEqual(Message.objects.filter(is_active=True).count(), 0)
def test_next(self):
response = self.client.post(DELETE_URL % self.message.id + '?next=' + LOGIN_URL)
self.assertRedirects(response, LOGIN_URL + '?message-delete=True')
def test_invalid_id(self):
response = self.client.get(DELETE_URL % '2')
self.assertEqual(response.status_code, 404)
def test_invalid_author(self):
self.client.logout()
User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.client.login(username='******', password='******')
response = self.client.get(DELETE_URL % self.message.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project(self):
self.project.is_active = False
self.project.save()
response = self.client.get(DELETE_URL % self.message.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project_author(self):
user = User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.message.author = user
self.message.save()
self.project.author.is_active = False
self.project.author.save()
self.client.logout()
self.client.login(username='******', password='******')
response = self.client.get(DELETE_URL % self.message.id)
self.assertEqual(response.status_code, 404)
def handle(self, *args, **options):
if len(args) < 3:
log.info('help')
log.info('./manager.py [应用代码] [语言代码] [messages.json文件]')
else:
app = App.objects.get(code=args[0])
lang = args[1]
data = json.loads(path(args[2]).text())
for i in data:
try:
m = Message.objects.get(code=i)
log.info(i)
except:
m = Message(code=i)
m.zh_CN = ''
m.zh_TW = ''
m.ru = ''
m.en = ''
if lang == 'en':
m.en = data[i]['message']
if lang == 'zh_CN':
m.zh_CN = data[i]['message']
if lang == 'zh_TW':
m.zh_TW = data[i]['message']
if lang == 'ru':
m.ru = data[i]['message']
m.save()
m.apps.add(app)
m.save()
def create_message_for_anonymous_but_named_user(user, stream, content):
message = Message(username=user.username, stream=stream, content=content)
message.save()
return message
