def twitter_profile(self, request, pk=None): contact = self.get_contact_by_pk(request, pk) # Response to user twitter_profile = {} if contact.twitter != '': query = { 'query': { 'bool': { 'must': [{ 'term': { 'data.Username': contact.twitter } }] } } } es_twitter_profile = es.search(index='tweets', doc_type='user', body=query) if ('hits' in es_twitter_profile and 'hits' in es_twitter_profile['hits']): if len(es_twitter_profile['hits']['hits']) > 0: twitter_profile = es_twitter_profile['hits']['hits'][0][ '_source']['data'] return Response(twitter_profile, {})
def verify(self, request, pk=None): publication = self.get_publication_by_pk(request, pk) publication.verified = True publication.save() serializer = PublicationSerializer(publication) return Response(serializer.data, {})
def archive(self, request, pk=None): email = self.get_email_by_pk(request, pk) email.archived = True email.save() serializer = EmailSerializer(email) return Response(serializer.data, {})
def bulk_attach(self, request): if 'file' in request.FILES: files = self._file_to_file_object(request) serializer = FileSerializer(files, many=True) return Response(serializer.data, {}) raise ParseError()
def send(self, request, pk=None): email = self.get_email_by_pk(request, pk) if not email.is_sent: self._send_emails([email]) serializer = EmailSerializer(email) return Response(serializer.data, {})
def instagram_profile(self, request, pk=None): contact = self.get_contact_by_pk(request, pk) instagram_profile = {} if contact.instagram != '': query = { 'query': { 'bool': { 'must': [{ 'term': { 'data.Username': contact.instagram } }] } } } es_instagram_profile = es.search(index='instagrams', doc_type='user', body=query) if ('hits' in es_instagram_profile and 'hits' in es_instagram_profile['hits']): if len(es_instagram_profile['hits']['hits']) > 0: instagram_profile = es_instagram_profile['hits']['hits'][ 0]['_source']['data'] return Response(instagram_profile, {})
def upload(self, request, pk=None): media_list = self.get_media_list_by_pk(request, pk) if 'file' in request.FILES: xlsx_file = request.FILES.get('file') random_number = binascii.b2a_hex(os.urandom(15)) original_file_name = xlsx_file._name file_name = xlsx_file._name.replace(' ', '') generated_file_name = ''.join( [str(request.user.pk), random_number, file_name]) xlsx_file._name = generated_file_name file = File(file=xlsx_file) file.original_name = original_file_name file.file_exists = True file.file_name = generated_file_name file.created_by = request.user file.save() media_list.file = file media_list.save() serializer = FileSerializer(file) return Response(serializer.data, {}) raise ParseError()
def campaigns(self, request): if request.user and request.user.is_authenticated(): campaigns = Campaign.objects.filter( created_by=request.user, ).order_by('-created') serializer = CampaignSerializer(campaigns, many=True) return Response(serializer.data, {}) raise NotAuthenticated()
def destroy(self, request, pk, format=None): if request.user and request.user.is_authenticated(): media_list = self.get_media_list_by_pk(request, pk) media_list.is_deleted = True media_list.save() serializer = MediaListSerializer(media_list) return Response(serializer.data, {}) raise NotAuthenticated()
def me(self, request): if request.user and request.user.is_authenticated(): if request.method == 'GET': serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) elif request.method == 'PATCH': user_profile = UserProfile.objects.get(user=request.user) if ('emailsignatures' in request.data): user_profile.email_signatures = request.data[ 'emailsignatures'] if ('emailsignature' in request.data): user_profile.email_signature = request.data[ 'emailsignature'] user_profile.save() serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) raise NotAuthenticated
def sheets(self, request, pk=None): sheet_names = [] file = self.get_file_by_pk(request, pk) wb = load_workbook(file.file, read_only=True) if wb: sheetnames = wb.get_sheet_names() data = {'names': sheetnames} return Response(sheetnames, {})
def retrieve(self, request, pk=None): if request.user and request.user.is_authenticated(): contact = self.get_contact_by_pk(request, pk) included = self.get_contact_included(contact) print included serializer = ContactSerializer(contact) return Response(serializer.data, included) raise NotAuthenticated()
def remove_tags(self, request, pk=None): media_list = self.get_media_list_by_pk(request, pk) if 'tags' in request.data: for tag in request.data['tags']: media_list.tags.remove(tag) media_list.save() serializer = MediaListSerializer(media_list) return Response(serializer.data, {}) raise ParseError()
def remove_tags(self, request, pk=None): contact = self.get_contact_by_pk(request, pk) if 'tags' in request.data: for tag in request.data['tags']: contact.tags.remove(tag) contact.save() serializer = ContactSerializer(contact) return Response(serializer.data, {}) raise ParseError()
def feedback(self, request, pk=None): user = self.get_user_by_pk(request, pk) user_profile = UserProfile.objects.get(user=user) if 'reason' in request.data and 'feedback' in request.data: user_profile.trial_expire_reason = request.data['reason'] user_profile.trial_expire_feedback = request.data['feedback'] user_profile.save() serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) raise ParseError()
def plan_details(self, request, pk=None): user = self.get_user_by_pk(request, pk) user_profile = UserProfile.objects.get(user=user) return Response( { 'planname': 'Growing Business', 'emailaccounts': 10, 'dailyemailsallowed': 10000, 'emailssenttoday': 7, 'ontrial': False }, {})
def attach(self, request, pk=None): email = self.get_email_by_pk(request, pk) if 'file' in request.FILES: files = self._file_to_file_object(request) for file in files: email.attachments.add(file) email.save() serializer = EmailSerializer(email) return Response(serializer.data, {}) raise ParseError()
def add_attachments(self, request, pk=None): if 'attachments' in request.data: email = self.get_email_by_pk(request, pk) for attachment in request.data['attachments']: # Add that attachment to the email file = File.objects.get(pk=attachment) email.attachments.set(file) email.save() serializer = EmailSerializer(email) return Response(serializer.data, {}) raise ParseError()
def database_profile(self, request, pk=None): database_profile = {} publication = self.get_publication_by_pk(request, pk) if publication.url != '': publication_enhance_url = urlparse(publication.url) publication_enhance_url = publication_enhance_url.netloc r = requests.get(('https://enhance.newsai.org/company/' + publication_enhance_url)) database_profile = r.json() if 'data' in database_profile: database_profile = database_profile['data'] return Response(database_profile, {})
def duplicate(self, request, pk=None): user_profile = UserProfile.objects.get(user=request.user) media_list = self.get_media_list_by_pk(request, pk) if 'name' in request.data: clients = media_list.clients contacts = media_list.contacts and media_list.contacts.all() fields_map = (media_list.fields_map and media_list.fields_map.all()) tags = media_list.tags and media_list.tags.all() file = media_list.file team = media_list.team media_list.name = request.data['name'] media_list.pk = None media_list.created = datetime.datetime.now() media_list.updated = datetime.datetime.now() media_list.created_by = request.user media_list.team = user_profile.team media_list.save() if clients.count() > 0: media_list.clients.add(*clients) if contacts.count() > 0: media_list.contacts.add(*contacts) if fields_map.count() > 0: for field_map in fields_map: # Create field map with a new id field_map.pk = None field_map.created = datetime.datetime.now() field_map.updated = datetime.datetime.now() field_map.save() # Add that field map to the media list media_list.fields_map.add(field_map) if tags: # Add tags from previous list to new list for tag in tags: media_list.tags.add(tag) if file: media_list.file = file if team: media_list.team = team media_list.save() serializer = MediaListSerializer(media_list) return Response(serializer.data, {}) raise ParseError()
def remove_past_employers(self, request, pk=None): contact = self.get_contact_by_pk(request, pk) if 'employers' in request.data: for employer_id in request.data['employers']: try: publication = Publication.objects.get(pk=employer_id) contact.past_employers.remove(publication) contact.save() except Publication.DoesNotExist: continue serializer = ContactSerializer(contact) return Response(serializer.data, {}) raise ParseError()
def remove_from_lists(self, request, pk=None): contact = self.get_contact_by_pk(request, pk) if 'listids' in request.data: for list_id in request.data['listids']: try: media_list = MediaList.objects.get(pk=list_id) media_list.contacts.remove(contact) media_list.save() except MediaList.DoesNotExist: continue serializer = ContactSerializer(contact) return Response(serializer.data, {}) raise ParseError()
def remove_integration(self, request, pk=None): if self.request.user and self.request.user.is_authenticated(): user = self.get_user_by_pk(request, pk) user_profile = UserProfile.objects.get(user=user) user_profile.gmail = False user_profile.outlook = False user_profile.external_email = False user_profile.save() serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) raise NotAuthenticated
def remove_email(self, request, pk=None): user = self.get_user_by_pk(request, pk) user_profile = UserProfile.objects.get(user=user) if 'email' in request.data: if request.data['email'] in user_profile.sendgrid_emails: user_profile.sendgrid_emails.remove(request.data['email']) user_profile.sendgrid_emails = list( set(user_profile.sendgrid_emails)) user_profile.save() serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) raise ParseError()
def change_name(self, request, pk=None): user = self.get_user_by_pk(request, pk) change = False if 'firstname' in request.data: user.first_name = request.data['firstname'] change = True if 'lastname' in request.data: user.last_name = request.data['lastname'] change = True if change: user.save() serializer = UserSerializer(self.request.user) return Response(serializer.data, {})
def add_custom_field(self, request, pk=None): media_list = self.get_media_list_by_pk(request, pk) if ('name' in request.data and 'value' in request.data and 'customfield' in request.data and 'hidden' in request.data): field_map = CustomFieldsMap( name=request.data['name'], value=request.data['value'], custom_field=request.data['customfield'], hidden=request.data['hidden']) field_map.save() media_list.fields_map.add(field_map) serializer = MediaListSerializer(media_list) return Response(serializer.data, {}) raise ParseError()
def update(self, request, pk=None, partial=None, *args, **kwargs): ''' parameters: contact object ''' partial = kwargs.pop('partial', False) instance = self.get_object() serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) self.perform_update(serializer) if getattr(instance, '_prefetched_objects_cache', None): # If 'prefetch_related' has been applied to a queryset, we need to # forcibly invalidate the prefetch cache on the instance. instance._prefetched_objects_cache = {} return Response(serializer.data['data'], {})
def upload(self, request): if 'file' in request.FILES: image_file = request.FILES.get('file') random_number = binascii.b2a_hex(os.urandom(15)) original_file_name = image_file._name file_name = image_file._name.replace(' ', '') generated_file_name = ''.join( [str(request.user.pk), random_number, file_name]) image_file._name = generated_file_name file = EmailImage(file=image_file) file.original_name = original_file_name file.file_name = generated_file_name file.created_by = request.user file.save() serializer = EmailImageSerializer(file) return Response(serializer.data, {}) raise ParseError()
def limits(self, request): if request.user and request.user.is_authenticated(): # Use email model manager emails = Email.objects.emails_by_user_today(request.user) print emails # Setup emails sendgrid = 0 outlook = 0 gmail = 0 smtp = 0 # Loop through emails for email in emails: if email.method == 'sendgrid': sendgrid += 1 elif email.method == 'outlook': outlook += 1 elif email.method == 'gmail': gmail += 1 elif email.method == 'smtp': smtp += 1 data = { 'sendgrid': sendgrid, 'sendgridLimits': 2500, 'outlook': outlook, 'outlookLimits': 500, 'gmail': gmail, 'gmailLimits': 500, 'smtp': smtp, 'smtpLimits': 2000 } return Response(data, {}) raise NotAuthenticated()
def add_email(self, request, pk=None): user = self.get_user_by_pk(request, pk) user_profile = UserProfile.objects.get(user=user) if 'email' in request.data: email = request.data['email'] # Check if it already exists in user # if (email in user_profile.sendgrid_emails or user.email == # email): # Create an email code object with # an invitation code to send to the user email_code = EmailCode(invite_code=str(uuid.uuid4()), email=str(request.data['email']), created_by=user) email_code.save() # Send user email self.send_add_email(user, email_code) # Return user profile serializer = UserSerializer(self.request.user) return Response(serializer.data, {}) raise ParseError()