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