def migrate_to_following(self): skip = 0 while True: query = 'MATCH (profile:Pleb) RETURN profile ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for profile in [Pleb.inflate(row[0]) for row in res]: friend_query = 'MATCH (a:Pleb {username: "******"})' \ '-[:FRIENDS_WITH]->(b:Pleb) ' \ 'RETURN b' % profile.username friend_res, _ = db.cypher_query(friend_query) for friend in [ Pleb.inflate(friend_row[0]) for friend_row in friend_res ]: try: profile.follow(friend.username) friend.follow(profile.username) except (ConstraintViolation, Exception): pass self.stdout.write("completed friend migration\n", ending='') return True
def test_is_following_was_following(self): test_pleb = Pleb(username=str(uuid1())).save() rel = self.pleb.following.connect(test_pleb) rel.active = False rel.save() res = test_pleb.is_following(self.pleb.username) self.assertFalse(res)
def setUp(self): settings.CELERY_ALWAYS_EAGER = True self.email = "*****@*****.**" res = create_user_util_test(self.email, task=True) self.assertNotEqual(res, False) wait_util(res) self.pleb = Pleb.nodes.get(email=self.email) self.user = User.objects.get(email=self.email) try: pleb = Pleb.nodes.get( email='*****@*****.**', username="******") pleb.delete() user = User.objects.get( email='*****@*****.**', username="******") user.delete() except (Pleb.DoesNotExist, User.DoesNotExist): pass self.fake_user = User.objects.create_user( first_name='test', last_name='test', email='*****@*****.**', password='******', username='******') self.fake_user.save() self.fake_pleb = Pleb(email=self.fake_user.email, username=self.fake_user.username).save()
def test_three_solutions_different_authors(self): pleb = Pleb(email=str(uuid1()), first_name="test", last_name="test", username=str(uuid1())).save() pleb2 = Pleb(email=str(uuid1()), first_name="test", last_name="test", username=str(uuid1())).save() solution = Solution(content=uuid1(), owner_username=self.pleb.username).save() solution2 = Solution(content=uuid1(), owner_username=pleb.username).save() solution3 = Solution(content=uuid1(), owner_username=pleb2.username).save() self.question.solutions.connect(solution) self.question.solutions.connect(solution2) self.question.solutions.connect(solution3) authors = self.question.get_conversation_authors() self.assertIn(self.pleb.first_name, authors) self.assertIn(self.pleb.last_name, authors) self.assertIn(pleb.first_name, authors) self.assertIn(pleb.last_name, authors) self.assertIn(pleb2.first_name, authors) self.assertIn(pleb2.last_name, authors) self.assertEqual(authors.count(','), 2)
def test_get_solution_ids(self): query = 'MATCH (n:Solution) OPTIONAL MATCH (n)-[r]-() DELETE n, r' db.cypher_query(query) pleb = Pleb(email=str(uuid1()), first_name="test", last_name="test", username=str(uuid1())).save() pleb2 = Pleb(email=str(uuid1()), first_name="test", last_name="test", username=str(uuid1())).save() solution = Solution(content=uuid1(), owner_username=self.pleb.username).save() solution2 = Solution(content=uuid1(), owner_username=pleb.username).save() solution3 = Solution(content=uuid1(), owner_username=pleb2.username).save() self.question.solutions.connect(solution) self.question.solutions.connect(solution2) self.question.solutions.connect(solution3) solutions = self.question.get_solution_ids() self.assertEqual(len(solutions), 3) self.assertIn(solution.object_uuid, solutions) self.assertIn(solution2.object_uuid, solutions) self.assertIn(solution3.object_uuid, solutions)
class TestCreateWallTask(TestCase): def setUp(self): settings.CELERY_ALWAYS_EAGER = True self.email = "*****@*****.**" res = create_user_util_test(self.email, task=True) self.assertNotEqual(res, False) wait_util(res) self.pleb = Pleb.nodes.get(email=self.email) self.user = User.objects.get(email=self.email) try: pleb = Pleb.nodes.get( email='*****@*****.**', username="******") pleb.delete() user = User.objects.get( email='*****@*****.**', username="******") user.delete() except (Pleb.DoesNotExist, User.DoesNotExist): pass self.fake_user = User.objects.create_user( first_name='test', last_name='test', email='*****@*****.**', password='******', username='******') self.fake_user.save() self.fake_pleb = Pleb(email=self.fake_user.email, username=self.fake_user.username).save() def tearDown(self): self.fake_pleb.delete() self.fake_user.delete() settings.CELERY_ALWAYS_EAGER = False def test_create_wall_task_success(self): task_data = { 'username': self.fake_user.username } res = create_wall_task.apply_async(kwargs=task_data) while not res.ready(): time.sleep(1) self.assertFalse(isinstance(res.result, Exception)) def test_create_wall_task_pleb_has_wall(self): wall = Wall(wall_id=str(uuid1())).save() wall.owned_by.connect(self.fake_pleb) self.fake_pleb.wall.connect(wall) task_data = { 'username': self.fake_user.username, } res = create_wall_task.apply_async(kwargs=task_data) while not res.ready(): time.sleep(1) self.assertFalse(isinstance(res.result, Exception))
def test_multiple_posts_multiple_comments_friends(self): wall = self.pleb.get_wall() pleb_array = [] post_array = [] comment_array = [] for item in range(0, 2): test_pleb = Pleb(email=str(uuid1())[:32], username=str(uuid1())[:32]) test_pleb.save() pleb_array.append(test_pleb) for number in range(0, 10): test_post = Post(content='test', object_uuid=str(uuid1()), owner_username=self.pleb.username, wall_owner_username=self.pleb.username) test_post.save() test_post.posted_on_wall.connect(wall) wall.posts.connect(test_post) test_post.owned_by.connect(test_pleb) post_array.append(test_post) for num in range(0, 1): my_comment = Comment(content='test comment', object_uuid=str(uuid1()), owner_username=self.pleb.username) my_comment.save() my_comment.owned_by.connect(test_pleb) test_post.comments.connect(my_comment) comment_array.append(my_comment) my_comment = Comment(content='test comment', object_uuid=str(uuid1()), owner_username=self.pleb.username) my_comment.save() my_comment.owned_by.connect(self.pleb) test_post.comments.connect(my_comment) comment_array.append(my_comment) test_post = Post(content='test', object_uuid=str(uuid1()), owner_username=self.pleb.username, wall_owner_username=self.pleb.username) test_post.save() test_post.posted_on_wall.connect(wall) wall.posts.connect(test_post) test_post.owned_by.connect(self.pleb) request = self.factory.get('/%s' % self.pleb.username) request.user = self.user profile_page = ProfileView.as_view() response = profile_page(request, self.pleb.username) self.assertIn(response.status_code, [status.HTTP_200_OK, status.HTTP_302_FOUND]) for item in pleb_array: item.delete() for post in post_array: post.delete() for comment in comment_array: comment.delete() test_post.delete()
def create_vote_node(node_id, vote_type, voter, parent_object): """ Creates a vote node that we can use to track reputation changes over time for users. This node is hooked up to the object that has been voted on and the user that voted. The node is created every time someone votes and does not get updated when someone changes their vote, it just makes a new one, this may not be the final functionality but this is the current implementation. :param node_id: :param vote_type: :param voter: :param parent_object: :return: """ sb_object = get_parent_votable_content(parent_object) try: current_pleb = Pleb.get(username=voter) except (DoesNotExist, Pleb.DoesNotExist, CypherException, ClientError, IOError) as e: raise create_vote_node.retry(exc=e, countdown=10, max_retries=None) try: owner = Pleb.get(username=sb_object.owner_username) except (DoesNotExist, Pleb.DoesNotExist, CypherException, ClientError, IOError) as e: raise create_vote_node.retry(exc=e, countdown=10, max_retries=None) last_vote = sb_object.get_last_user_vote(current_pleb.username) if sb_object.visibility == 'public': if vote_type == 1: reputation_change = sb_object.up_vote_adjustment else: reputation_change = sb_object.down_vote_adjustment else: reputation_change = 0 try: vote_node = Vote.nodes.get(object_uuid=node_id) except (Vote.DoesNotExist, DoesNotExist): vote_node = Vote(object_uuid=node_id, vote_type=vote_type, reputation_change=reputation_change).save() if last_vote is None: sb_object.first_votes.connect(vote_node) sb_object.last_votes.connect(vote_node) else: sb_object.last_votes.disconnect(last_vote) last_vote.next_vote.connect(vote_node) sb_object.last_votes.connect(vote_node) vote_node.vote_on.connect(sb_object) vote_node.owned_by.connect(current_pleb) if not owner.last_counted_vote_node: owner.last_counted_vote_node = node_id owner.reputation_update_seen = False owner.save() cache.delete(owner.username) # See reputation_change method on pleb for where this is set cache.delete("%s_reputation_change" % owner.username) return True
def complete_order(self, request, object_uuid=None): if request.user.username != "tyler_wiersing" \ and request.user.username != "devon_bleibtrey": return Response({"detail": "You do not have permission to " "perform this action.", "status_code": status.HTTP_403_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN) order = self.get_object() tracking_url = request.data.get("tracking_url", None) if tracking_url: order.tracking_url = tracking_url order.completed = True order.save() order_owner = Pleb.get(order.owner_username) message_data = { 'message_type': 'email', 'subject': 'Sagebrew Order Processed', 'body': 'Hi %s,\nYour Order has been processed and you ' 'can track the delivery here:\n\n%s ' % (order_owner.first_name, tracking_url), 'template': "personal", 'from_user': { 'type': "admin", 'id': settings.INTERCOM_ADMIN_ID_DEVON}, 'to_user': { 'type': "user", 'user_id': order.owner_username} } serializer = IntercomMessageSerializer(data=message_data) if serializer.is_valid(): serializer.save() mission = order.get_mission() mission_owner = Pleb.get(mission.owner_username) message_data = { 'message_type': 'email', 'subject': 'Someone has given you a Gift!', 'body': 'Hi %s,\nSomeone has sent you a Gift from your ' 'Giftlist!\nYou can track the delivery here:\n\n' '%s' % (mission_owner.first_name, tracking_url), 'template': "personal", 'from_user': { 'type': "admin", 'id': settings.INTERCOM_ADMIN_ID_DEVON}, 'to_user': { 'type': "user", 'user_id': mission.owner_username} } serializer = IntercomMessageSerializer(data=message_data) if serializer.is_valid(): serializer.save() return Response(OrderSerializer(order).data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs): wall_pleb = Pleb.get(self.kwargs[self.lookup_field]) friend_with = wall_pleb.is_friends_with(request.user.username) if friend_with is False and wall_pleb.username != request.user.username: return Response( {"detail": "Sorry you are not friends with this" " person."}, status=status.HTTP_400_BAD_REQUEST) serializer = self.get_serializer(data=request.data) if serializer.is_valid(): instance = serializer.save(wall_owner_profile=wall_pleb) spawn_task(task_func=spawn_notifications, task_param={ "from_pleb": request.user.username, "sb_object": serializer.data['object_uuid'], "url": reverse('single_post_page', kwargs={ "object_uuid": serializer.data["object_uuid"] }), "to_plebs": [ self.kwargs[self.lookup_field], ], "notification_id": str(uuid1()), "action_name": instance.action_name }) return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data, context={'request': request}) if serializer.is_valid(): pleb = Pleb.get(request.user.username) parent_object = cache.get(self.kwargs[self.lookup_field]) if parent_object is None: parent_object = SBContent.nodes.get( object_uuid=self.kwargs[self.lookup_field]) # Don't set it here as only questions will be # retrievable/settable serializer.save(owner=pleb, parent_object=parent_object) serializer_data = serializer.data ''' Not doing this yet as I don't know how much info we want to give to someone about there info being flagged. I think we'll just want to notify them just not give them the person who did flag their content. We'll also need to allow them to provide a rebuttal. data = { "username": request.user.username, "flag": serializer_data['object_uuid'], "url": serializer_data['url'], "parent_object": self.kwargs[self.lookup_field] } spawn_task(task_func=create_flag_relations, task_param=data) ''' return Response(serializer_data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def populate_last_reputation_node(self): skip = 0 while True: query = 'MATCH (profile:Pleb) RETURN profile ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for profile in [Pleb.inflate(row[0]) for row in res]: if profile.last_counted_vote_node is not None: continue else: query = 'MATCH (v:Vote)<-[:LAST_VOTES]-' \ '(content:VotableContent)-[:OWNED_BY]->' \ '(p:Pleb {username: "******"}) ' \ 'WITH v ORDER BY v.created DESC ' \ 'RETURN v LIMIT 1' % profile.username res, _ = db.cypher_query(query) if res.one is not None: profile.last_counted_vote_node = res.one['object_uuid'] profile.save() self.stdout.write("completed vote population\n", ending='') return True
def create(self, validated_data): request, _, _, _, _ = gather_request_data(self.context) stripe.api_key = settings.STRIPE_SECRET_KEY stripe.api_version = settings.STRIPE_API_VERSION donor = Pleb.get(request.user.username) token = validated_data.pop('token', None) # TODO add payment_method selection support to direct donations # this pop is just to allow the donation to save using **validated_data validated_data.pop('payment_method', None) donation = Donation(owner_username=donor.username, **validated_data).save() if not donor.stripe_customer_id: customer = stripe.Customer.create( description="Customer for %s" % donor.username, card=token, email=donor.email) donor.stripe_customer_id = customer['id'] donor.save() cache.delete(donor.username) donor.refresh() donor.donations.connect(donation) donation.owned_by.connect(donor) charge = stripe.Charge.create( amount=donation.amount, currency="usd", customer=donor.stripe_customer_id, receipt_email=donor.email, description="Donation to Sagebrew from %s" % donor.username ) donation.stripe_charge_id = charge['id'] donation.save() spawn_task(task_func=check_privileges, task_param={"username": donor.username}) return donation
def create(self, validated_data): request = self.context["request"] owner = Pleb.get(request.user.username) wall_owner = validated_data.pop('wall_owner_profile', None) images = validated_data.pop('images', []) included_urls = validated_data.pop('included_urls', []) uuid = str(uuid1()) url = reverse('profile_page', kwargs={'pleb_username': request.user.username}, request=request) href = reverse('post-detail', kwargs={'object_uuid': uuid}, request=request) post = Post(owner_username=owner.username, wall_owner_username=wall_owner.username, object_uuid=uuid, url=url, href=href, **validated_data).save() post.owned_by.connect(owner) wall = wall_owner.get_wall() post.posted_on_wall.connect(wall) wall.posts.connect(post) [ post.uploaded_objects.connect( UploadedObject.nodes.get(object_uuid=image)) for image in images ] for url in included_urls: try: post.url_content.connect(URLContent.nodes.get(url=url)) except (DoesNotExist, URLContent.DoesNotExist): pass return post
def create(self, request, *args, **kwargs): croppic = request.query_params.get('croppic', 'false').lower() editor = request.query_params.get('editor', 'false').lower() file_object = request.data.get('file_object', None) if file_object is None: file_object = request.data.get('file', None) if file_object is None: file_object = request.data.get('img', None) serializer = self.get_serializer(data={"file_object": file_object}, context={'request': request}) if serializer.is_valid(): owner = Pleb.get(request.user.username) upload = serializer.save(owner=owner) if croppic == 'true': return Response( { "status": "success", "url": upload.url, "width": upload.width, "height": upload.height }, status=status.HTTP_200_OK) if editor == 'true': return Response({"files": [serializer.data]}, status=status.HTTP_200_OK) return Response(serializer.data, status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_notification_from(self, obj): query = 'MATCH (a:Notification {object_uuid: "%s"})-' \ '[:NOTIFICATION_FROM]->(b:Pleb) RETURN b' % obj.object_uuid res, _ = db.cypher_query(query) if res.one is None: return {} return PlebSerializerNeo(Pleb.inflate(res[0][0])).data
def create(self, validated_data): request = self.context["request"] # Note that DRF requires us to use the source as the key here but # tags prior to serializing mission = None tags = validated_data.pop('get_tags', []) owner = Pleb.get(request.user.username) mission_id = validated_data.get('mission', '') if mission_id: mission = Mission.get(mission_id) validated_data['owner_username'] = owner.username uuid = str(uuid1()) validated_data['content'] = render_content( validated_data.get('content', "")) url = reverse('question_detail_page', kwargs={ 'question_uuid': uuid, "slug": slugify(validated_data['title']) }, request=request) href = reverse('question-detail', kwargs={'object_uuid': uuid}, request=request) soup = BeautifulSoup(validated_data['content'], "lxml").get_text() question = Question(url=url, href=href, object_uuid=uuid, summary=smart_truncate(soup), **validated_data).save() question.owned_by.connect(owner) if mission is not None: mission.associated_with.connect(question) for tag in tags: query = 'MATCH (t:Tag {name:"%s"}) WHERE NOT t:AutoTag ' \ 'RETURN t' % slugify(tag) res, _ = db.cypher_query(query) if not res.one: if (request.user.username == "devon_bleibtrey" or request.user.username == "tyler_wiersing" or owner.reputation >= 1250): tag_obj = Tag(name=slugify(tag)).save() question.tags.connect(tag_obj) else: continue else: tag_obj = Tag.inflate(res.one) question.tags.connect(tag_obj) spawn_task(task_func=update_tags, task_param={"tags": tags}) if validated_data.get('external_location_id', None) is not None: spawn_task( task_func=create_location_tree, task_param={"external_id": question.external_location_id}) spawn_task(task_func=add_auto_tags_to_question_task, task_param={"object_uuid": question.object_uuid}) spawn_task(task_func=create_question_summary_task, task_param={'object_uuid': question.object_uuid}) question.refresh() cache.set(question.object_uuid, question) return question
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data, context={"request": request}) if serializer.is_valid(): question = Question.nodes.get( object_uuid=self.kwargs[self.lookup_field]) instance = serializer.save(question=question) query = "MATCH (a:Question {object_uuid:'%s'})-[:OWNED_BY]->" \ "(b:Pleb) RETURN b" % (self.kwargs[self.lookup_field]) res, col = db.cypher_query(query) question_owner = Pleb.inflate(res[0][0]) serializer = serializer.data to_plebs = [question_owner.username] mission = question.get_mission(question.object_uuid) if mission: to_plebs.append(mission['owner_username']) spawn_task(task_func=spawn_notifications, task_param={ "from_pleb": request.user.username, "sb_object": serializer['object_uuid'], "url": reverse( 'single_solution_page', kwargs={"object_uuid": serializer["object_uuid"]}), # TODO discuss notifying all the people who have provided # solutions on a given question. "to_plebs": to_plebs, "notification_id": str(uuid1()), 'action_name': instance.action_name }) # Not going to add until necessary for search # spawn_task(task_func=add_solution_to_search_index, # task_param={"solution": serializer}) return Response(serializer, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def remove_profiles(self, instance): for profile in self.data['profiles']: profile_pleb = Pleb.get(username=profile) instance.accountants.disconnect(profile_pleb) profile_pleb.campaign_accountant.disconnect(instance) cache.delete("%s_accountants" % instance.object_uuid) return instance
def update_view_count_task(object_uuid, username): try: profile = Pleb.get(username) except (Pleb.DoesNotExist, DoesNotExist) as e: raise update_view_count_task.retry(exc=e, max_retries=5, countdown=45) sb_object = cache.get(object_uuid) if sb_object is None: sb_object = Searchable.nodes.get(object_uuid=object_uuid) query = 'MATCH (a:Pleb {username: "******"})-[b:VIEWED]->' \ ' (c:Searchable {object_uuid: "%s"}) RETURN b' % ( username, object_uuid) res, col = db.cypher_query(query) if len(res) == 0: res = update_view_count(sb_object) if isinstance(res, Exception): raise update_view_count_task.retry(exc=res, countdown=5, max_retries=None) relationship = profile.viewed.connect(sb_object) sb_object.viewed_by.connect(profile) else: relationship = profile.viewed.relationship(sb_object) relationship.times_viewed += 1 relationship.save() return True
def repopulate_elasticsearch(self): # Profiles skip = 0 while True: query = 'MATCH (profile:Pleb) RETURN DISTINCT profile ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for profile in [Pleb.inflate(row[0]) for row in res]: update_search_object.apply_async(kwargs={ "object_uuid": profile.object_uuid, "label": "pleb" }) # Questions skip = 0 while True: query = 'MATCH (question:Question) RETURN DISTINCT question ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for question in [Question.inflate(row[0]) for row in res]: update_search_object.apply_async(kwargs={ "object_uuid": question.object_uuid, "label": "question" }) # Quests skip = 0 while True: query = 'MATCH (quest:Quest) RETURN DISTINCT quest ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for quest in [Quest.inflate(row[0]) for row in res]: update_search_object.apply_async(kwargs={ "object_uuid": quest.object_uuid, "label": "quest" }) # Missions skip = 0 while True: query = 'MATCH (mission:Mission) RETURN DISTINCT mission ' \ 'SKIP %s LIMIT 25' % skip skip += 24 res, _ = db.cypher_query(query) if not res.one: break for mission in [Mission.inflate(row[0]) for row in res]: update_search_object.apply_async(kwargs={ "object_uuid": mission.object_uuid, "label": "mission" })
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) if serializer.is_valid(): serializer.save(owner=Pleb.get(self.request.user.username)) return Response(serializer.data, status=status.HTTP_200_OK) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def dispatch(self, *args, **kwargs): profile = Pleb.get(username=self.request.user.username) if self.request.user.username == 'tyler_wiersing' \ or self.request.user.username == 'devon_bleibtrey' or \ profile.reputation >= 10000: return super(CouncilView, self).dispatch(*args, **kwargs) return redirect('profile_page', pleb_username=self.request.user.username)
def create(self, request, *args, **kwargs): object_uuid = self.kwargs[self.lookup_field] now = str(datetime.now(pytz.utc)) vote_data = request.data serializer = self.get_serializer(data=vote_data, context={"request": request}) if not Pleb.get(request.user.username).is_verified: return Response( { "detail": "Sorry, you cannot vote unless you are verified!", "status": status.HTTP_401_UNAUTHORIZED, "developer_message": "A user can only vote on content " "if they are verified." }, status=status.HTTP_401_UNAUTHORIZED) if serializer.is_valid(): parent_object_uuid = self.kwargs[self.lookup_field] vote_status = int(serializer.validated_data['vote_type']) handle_vote(parent_object_uuid, vote_status, request.user.username, now) async_result = cache.get("%s_%s_vote" % (request.user.username, object_uuid)) task_params = { "username": request.user.username, "object_uuid": object_uuid } if async_result is not None: # if there is already a task lined up, # revoke it and spawn a new one async_result.revoke() # spawn a task which will execute 30 seconds from now # potential improvement here is to have a way to detect if the new_task = spawn_task(spawn_user_updates, task_param=task_params, countdown=30) cache.set("%s_%s_vote" % (request.user.username, object_uuid), new_task) search_result = cache.get("%s_vote_search_update" % object_uuid) if search_result is not None: search_result.revoke() task_param = {"object_uuid": object_uuid} spawned = spawn_task(task_func=update_search_object, task_param=task_param, countdown=10) cache.set("%s_vote_search_update" % object_uuid, spawned) return Response({ "detail": "Successfully created or modified " "vote.", "status": status.HTTP_200_OK, "developer_message": None }) else: return Response(serializer.errors, status=400)
def endorsements(self, request, object_uuid=None): serialized = [] endorsements = Mission.get_endorsements(object_uuid) page = self.paginate_queryset(endorsements) for node in page: if "Pleb" in node.labels: serialized.append(PlebSerializerNeo(Pleb.inflate(node.e)).data) if "Quest" in node.labels: serialized.append(QuestSerializer(Quest.inflate(node.e)).data) return self.get_paginated_response(serialized)
def update(self, instance, validated_data): current_moderators = cache.get( "%s_moderators" % instance.owner_username, []) for profile in \ list(set(validated_data['profiles']) - set( current_moderators)): profile_pleb = Pleb.get(username=profile) instance.moderators.connect(profile_pleb) cache.delete("%s_moderators" % instance.owner_username) return instance
def update(self, instance, validated_data): request, _, _, _, _ = gather_request_data(self.context) stripe.api_key = settings.STRIPE_SECRET_KEY stripe.api_version = settings.STRIPE_API_VERSION mission = validated_data.pop('mission', None) quest = validated_data.pop('quest', None) payment_method = validated_data.pop('payment_method', None) donor = Pleb.get(instance.owner_username) quest_desc = quest.title \ if quest.title else "%s %s" % (quest.first_name, quest.last_name) mission_desc = mission.get_mission_title() description = "Gift purchase to %s's mission for %s" % (quest_desc, mission_desc) payment_method = payment_method if payment_method is not None \ else donor.stripe_default_card_id stripe_res = stripe.Charge.create(customer=donor.stripe_customer_id, amount=instance.total, currency="usd", description=description, receipt_email=donor.email, source=payment_method) instance.stripe_charge_id = stripe_res['id'] instance.paid = True instance.save() message_data = { 'message_type': 'email', 'subject': 'New Gift', 'body': get_template('orders/email/new_order.html').render( Context({ 'first_name': quest.first_name, 'mission_title': mission_desc, "donor_first_name": donor.first_name, "donor_last_name": donor.last_name, })), 'template': "personal", 'from_user': { 'type': "admin", 'id': settings.INTERCOM_ADMIN_ID_DEVON }, 'to_user': { 'type': "user", 'user_id': quest.owner_username } } serializer = IntercomMessageSerializer(data=message_data) serializer.is_valid(raise_exception=True) serializer.save() return instance
def update(self, instance, validated_data): current_accountants = cache.get( "%s_accountants" % instance.object_uuid, []) for profile in \ list(set(validated_data['profiles']) - set( current_accountants)): profile_pleb = Pleb.get(username=profile) instance.accountants.connect(profile_pleb) profile_pleb.campaign_accountant.connect(instance) cache.delete("%s_accountants" % instance.object_uuid) return instance
def update_search_query(username, query_param, keywords): """ This task creates a search query node then calls the task to create and attach keyword nodes to the search query node :param username: :param query_param: :param keywords: :return: """ try: res, _ = db.cypher_query("MATCH (a:Pleb {username:'******'}) RETURN a" % username) if res.one: res.one.pull() pleb = Pleb.inflate(res.one) else: raise update_search_query.retry(exc=DoesNotExist( "Profile with username: "******"%s does not exist" % username), countdown=3, max_retries=None) except (CypherException, IOError) as e: raise update_search_query.retry(exc=e, countdown=3, max_retries=None) try: search_query = SearchQuery.nodes.get(search_query=query_param) if pleb.searches.is_connected(search_query): rel = pleb.searches.relationship(search_query) rel.times_searched += 1 rel.last_searched = datetime.now(pytz.utc) rel.save() return True else: rel = pleb.searches.connect(search_query) rel.save() search_query.searched_by.connect(pleb) return True except (SearchQuery.DoesNotExist, DoesNotExist): search_query = SearchQuery(search_query=query_param) search_query.save() search_query.searched_by.connect(pleb) rel = pleb.searches.connect(search_query) rel.save() for keyword in keywords: keyword['query_param'] = query_param spawned = spawn_task(task_func=create_keyword, task_param=keyword) if isinstance(spawned, Exception) is True: return spawned return True except (CypherException, IOError) as e: raise update_search_query.retry(exc=e, countdown=3, max_retries=None) except Exception as e: raise update_search_query.retry(exc=e, countdown=3, max_retries=None)
def crop(self, request, object_uuid=None): resize = self.request.query_params.get("resize", "false").lower() croppic = self.request.query_params.get('croppic', 'false').lower() img_file = urllib2.urlopen(request.data['imgUrl']) read_file = img_file.read() file_object = BytesIO(read_file) image = Image.open(file_object) image_format = image.format crop_serializer = CropSerializer(data=request.data) if crop_serializer.is_valid(): crop_data = crop_serializer.data else: return Response(crop_serializer.errors, status=status.HTTP_400_BAD_REQUEST) if resize == 'true': image = resize_image(image, int(crop_data['resize_width']), int(crop_data['resize_height'])) cropped_image = crop_image2(image, crop_data['crop_width'], crop_data['crop_height'], crop_data['image_x1'], crop_data['image_y1']) # Fill cropped image into buffer file_stream = BytesIO() cropped_image.save(file_stream, format=image_format) file_stream.seek(0) # Upload cropped pic and then run serializer # Not the best solution but simplifies the logic. If someone has a # better approach feel free to update. Perhaps an InMemoryFile passed # to the serializer file_name = "%s-%sx%s.%s" % (object_uuid, crop_data['crop_width'], crop_data['crop_height'], image_format.lower()) serializer = upload_modified_image(file_name, file_stream.read(), request, object_uuid) if serializer.is_valid(): owner = Pleb.get(request.user.username) upload = serializer.save(owner=owner) if croppic == 'true': profile_page_url = reverse( "profile_page", kwargs={"pleb_username": request.user.username}, request=request) return Response( { "status": "success", "url": upload.url, "profile": profile_page_url }, status=status.HTTP_200_OK) return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)