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 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 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 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