def contact(request):
'''Creates a view for adding contact, and saves the new contact to database.'''
contacts = Contact.objects.all()
contracts = Contract.objects.all()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
firstname = form.cleaned_data['firstname']
lastname = form.cleaned_data['lastname']
email = form.cleaned_data['email']
options = request.POST.getlist('contract')
try:
contact = Contact()
contact.firstname = firstname
contact.lastname = lastname
contact.email = email
contract_dates = [str(x) for x in options]
for cd in contract_dates:
if cd:
cr = Contract.objects.get(from_date = cd)
contact.contract = cr
contact.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = ContactForm()
context = {'contacts' : contacts, 'contracts': contracts, 'form' :form}
return render(request, 'contacts/contact.html', context )
def call(request):
"""Returns TwiML instructions to Twilio's POST requests"""
response = twiml.Response()
phone_number = request.POST.get('phoneNumber', '').lstrip('1')
if phone_number:
"""If the browser sent a phoneNumber param, we know this request
is an outgoing call from the pyphone"""
for c in '()-':
phone_number = phone_number.replace(c, '')
phone_number = '+1' + phone_number
direction = 'outgoing'
with response.dial(callerId=settings.TWILIO_NUMBER) as r:
r.number(request.POST['phoneNumber'])
else:
"""Otherwise we assume this request is an incoming call."""
direction = 'incoming'
with response.dial() as r:
r.client('caller')
phone_number = request.GET.get('From', '')
try:
contact = Contact.objects.get(number=phone_number)
except ObjectDoesNotExist:
contact = Contact(number=phone_number)
contact.save()
call = Call(
contact=contact,
direction=direction,
)
call.save()
return HttpResponse(str(response))
def handle(self, *args, **options):
contact_data = list(csv.DictReader(open(args[0],'rb')))
# Check first row for List entries and add new lists to db.
# List entries are prefixed with "List: ", e.g. "List: master"
list_lkup = get_list_lkup(contact_data[0])
# Load Contact records
updated = 0
for row in contact_data:
# Create/Update contact
payload, list_memberships = process_row(row, list_lkup)
try:
contact = Contact.objects.get(email_address=payload['email_address'])
contact.__dict__.update(payload)
except Contact.DoesNotExist:
contact = Contact(**payload)
contact.status = 'active'
contact.save()
updated += 1
# Update Contact's List entries
lists_added_to = 0
for contact_list in list_memberships:
# If Contact/List combo already exists, it will violate
# a uniqueness constraint and raise an IntegrityError
try:
membership = ListMembership(contact=contact, contact_list=contact_list)
membership.save()
lists_added_to += 1
except IntegrityError:
pass
print "Created/Updated: %s with %s lists" % (contact, lists_added_to)
print "Created/Updated %s Contacts" % updated
def contact(request):
if request.method == 'POST':
listing_id = request.POST['listing_id']
listing = request.POST['listing']
name = request.POST['name']
email = request.POST['email']
phone = request.POST['phone']
message = request.POST['message']
user_id = request.POST['user_id']
realtor_email = request.POST['realtor_email']
if request.user.is_authenticated:
# user_id = request.POST['user_id']
has_contacted = Contact.objects.all().filter(user_id=user_id,listing_id=listing_id)
if has_contacted:
messages.error(request,"You have already made an inquiry for this home")
return redirect('/listings/'+listing_id)
contact = Contact(listing=listing, listing_id=listing_id, name=name, email=email, phone=phone,
message=message, user_id=user_id)
contact.save()
# send email
send_mail(
'Property Listing Inquiry',
'there has been inquiry for this house'+listing + '.Sign in to admin panel for more info',
'*****@*****.**',
[realtor_email,'*****@*****.**'],
fail_silently=False
)
messages.success(request, "Your inquiry has been made successfully, Realtor will get to you soon")
return redirect('/listings/' + listing_id)
def form_valid(self,form):
new_company = form.save(commit=False)
# get from request Contact data
contact = Contact(phone_number=self.request.POST['phone_number'],
email=self.request.POST['email'],
street=self.request.POST['street'],
city=self.request.POST['city'],
postcode=self.request.POST['postcode'],
country=self.request.POST['country'],
website=self.request.POST['website'])
contact.save()
# write user's first and last names
full_name = self.request.POST['full_user_name']
register_user = self.request.user
if len(full_name.split(' '))==2:
print('name is twofold')
register_user.first_name = full_name.split(' ')[0]
register_user.last_name = full_name.split(' ')[1]
register_user.save()
# connect the new company with Contact model
new_company.contact = contact
new_company.save()
# connect data - company, user and contact
current_user = UserProfile.objects.get(user=register_user)
current_user.name = full_name
new_company.userprofile_set.add(current_user)
contact.userprofile_set.add(current_user)
return super(AddCompany, self).form_valid(form)
def contact(request):
data = location.sitemap()
if request.method == "POST":
full_name = request.POST["name"]
email = request.POST["email"]
phone = request.POST["phone_number"]
subject = request.POST["msg_subject"]
message = request.POST["message"]
checkbox = request.POST["checkbox"]
if checkbox == 'on':
checkbox = True
else:
checkbox = False
contact_form = Contact(full_name=full_name,
email=email,
phone=phone,
subject=subject,
message=message,
checkbox=checkbox)
contact_form.save()
messages.success(
request,
"Thank you for contacting us. A representative will respond to you shortly!"
)
return redirect("home")
return render(request, 'pages/contact.html', data)
def handle(self, *args, **options):
faker = Faker()
# print(faker.name())
# print(faker.email())
for i in range(1000):
contact = Contact(name=faker.name(), email=faker.email(), favorited=faker.boolean(), tags='')
contact.save()
def contact(request):
if request.method == 'POST':
listing_id = request.POST['listing_id']
listing = request.POST['listing']
name = request.POST['name']
email = request.POST['email']
message = request.POST['message']
user_id = request.POST['user_id']
phone = request.POST['phone']
if request.user.is_authenticated:
user_id = request.user.id
has_contacted = Contact.objects.all().filter(listing_id=listing_id,
user_id=user_id)
if has_contacted:
messages.error(request, 'You have alreay made inquire')
return redirect('/listings/' + listing_id)
contact = Contact(listing_id=listing_id,
listing=listing,
name=name,
email=email,
message=message,
user_id=user_id,
phone=phone)
contact.save()
messages.success(request, 'Your request was submitted')
return redirect('/listings/' + listing_id)
def handle(self, *args, **options):
Contact.objects.all().delete()
for i in range(50):
contact_data = requests.get('https://randomuser.me/api/').json()
contact_data = contact_data['results'][0]
name = contact_data['name']['first'] + ' ' + contact_data['name']['last']
age = contact_data['dob']['age']
contact = Contact(name=name, age=age, image=None)
contact.save()
image_url = contact_data['picture']['large']
image_response = requests.get(image_url)
image_data = BytesIO()
image_data.write(image_response.content)
file_name = image_url.split('/')[-1]
contact.image.save(file_name, files.File(image_data))
contact.save()
print(str(round(i/50*100,2))+'%')
print(name)
def test_can_create_contact_message(self):
contact = Contact(book_id=1,
book="Test book title",
user_id=1,
message="Test message")
contact.save()
self.assertEqual(contact.message, "Test message")
class ContactsDetailViewTestCase(TestCase):
def setUp(self):
self.name = 'test'
self.email = '*****@*****.**'
self.url = "/contacts/1/"
self.contact = Contact(name=self.name, email=self.email)
self.user = User.objects.create(username="******")
self.client = APIClient()
self.client.force_authenticate(user=self.user)
self.contact.save()
def test_can_fetch_a_contact(self):
response = self.client.get(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["name"], self.name)
def test_can_update_a_contact(self):
update = dict(name="test123", email="*****@*****.**")
response = self.client.put(self.url, update, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["name"], update["name"])
def test_can_delete_a_contact(self):
response = self.client.delete(self.url, format='json', follow=True)
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT)
def contact(request):
if request.method == 'POST':
listing_id = request.POST['listing_id']
listing = request.POST['listing']
name = request.POST['name']
email = request.POST['email']
phone = request.POST['phone']
message = request.POST['message']
user_id = request.POST['user_id']
realtor_email = request.POST['realtor_email']
if request.user.is_authenticated:
user_id = request.user.id
has_contacted = Contact.objects.all().filter(listing_id=listing_id, user_id=user_id,)
if has_contacted:
messages.error(request, 'You Already Submitted a Request for This Listing')
return redirect('/listings/'+listing_id)
contact = Contact(listing=listing, listing_id=listing_id, name=name, email=email,
phone=phone, message=message, user_id=user_id)
contact.save()
send_mail(
'property Listing Enquiry',
'There Has Been An Enquiry For ' + listing + 'Sign into Admin Panel For More',
'*****@*****.**',
[realtor_email, '*****@*****.**'],
fail_silently=False
)
messages.success(request, 'Successfully Submitted Request')
return redirect('/listings/'+listing_id)
def save(self, event = None):
assert event
contact = Contact(first_name = self.cleaned_data['first_name'],
middle_initial = self.cleaned_data['middle_initial'],
last_name = self.cleaned_data['last_name'],
title = self.cleaned_data['title'],
email = self.cleaned_data['email'],
phone1 = self.cleaned_data['phone1'],
addr1_row1 = self.cleaned_data['addr1_row1'],
addr1_row2 = self.cleaned_data['addr1_row2'],
addr1_city = self.cleaned_data['addr1_city'],
addr1_state = self.cleaned_data['addr1_state'],
addr1_zip = self.cleaned_data['addr1_zip'],
addr1_country = self.cleaned_data['addr1_country'])
contact.save()
registrant = Registrant(event = event,
contact = contact,
pending = True,
discount_code = self.cleaned_data['discount_code'])
registrant.save()
return registrant
def contact(request):
'''Creates a view for adding contact, and saves the new contact to database.'''
contacts = Contact.objects.all()
contracts = Contract.objects.all()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
firstname = form.cleaned_data['firstname']
lastname = form.cleaned_data['lastname']
email = form.cleaned_data['email']
options = request.POST.getlist('contract')
try:
contact = Contact()
contact.firstname = firstname
contact.lastname = lastname
contact.email = email
contract_dates = [str(x) for x in options]
for cd in contract_dates:
if cd:
cr = Contract.objects.get(from_date=cd)
contact.contract = cr
contact.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = ContactForm()
context = {'contacts': contacts, 'contracts': contracts, 'form': form}
return render(request, 'contacts/contact.html', context)
def handle(self, *args, **options):
Contact.objects.all().delete()
# open the file containing the json
with open('./contacts/management/commands/contacts.json', 'r') as file:
# reading the text in the file
text = file.read()
# turning that json string into a python dictionary
data = json.loads(text)
# looping over the contact data inside that dictionary
for contact_data in data['contacts']:
# getting out the contact data into local variables
first_name = contact_data['first_name']
last_name = contact_data['last_name']
birthday = contact_data['birthday']
email = contact_data['email']
phone_number = contact_data['phone_number']
is_cell = contact_data['is_cell']
comments = contact_data['comments']
# create a contact from our data
contact = Contact(first_name=first_name,
last_name=last_name,
birthday=birthday,
email=email,
phone_number=phone_number,
is_cell=is_cell,
comments=comments)
# save the contact to the database
contact.save()
class ContactsSearchViewTestCase(TestCase):
def setUp(self):
self.url = "/search/?q={}"
user = User.objects.create(username="******")
self.client = APIClient()
self.client.force_authenticate(user=user)
self.first_contact = Contact(name="test abc", email="*****@*****.**")
self.second_contact = Contact(name="admin", email="*****@*****.**")
self.first_contact.save()
self.second_contact.save()
def test_can_search_by_name(self):
q = "abc"
response = self.client.get(self.url.format(q),
format='json',
follow=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0]["name"], self.first_contact.name)
def test_can_search_by_email(self):
q = "email"
response = self.client.get(self.url.format(q),
format='json',
follow=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0]["email"], self.second_contact.email)
def contact_view(request):
if request.method == 'POST':
listing_id = request.POST['listing_id']
listing = request.POST['listing']
name = request.POST['name']
email = request.POST['email']
phone = request.POST['phone']
message = request.POST['phone']
user_id = request.POST['user_id']
realtor_email = request.POST['realtor_email']
if request.user.is_authenticated:
user_id = request.user.id
has_contacted = Contact.objects.all().filter(listing_id=listing_id,
user_id=user_id)
if has_contacted:
messages.error(request, 'Siz oldin bu uy haqida soragansiz')
return redirect('/listings/' + listing_id)
contact = Contact(listing_id=listing_id,
listing=listing,
name=name,
email=email,
phone=phone,
message=message,
user_id=user_id)
contact.save()
messages.success(
request,
'Sizni habaringiz Yollandi tez orada siz bilan boglanamiz')
return redirect('/listings/' + listing_id)
def inquiry(request):
if request.method == "POST":
car_id = request.POST['car_id']
car_title = request.POST['car_title']
user_id = request.POST['user_id']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
customer_need = request.POST['customer_need']
phone = request.POST['phone']
city = request.POST['city']
state = request.POST['state']
email = request.POST['email']
message = request.POST['message']
if request.user.is_authenticated:
user_id = request.user.id
has_contacted = Contact.objects.all().filter(car_id = car_id, user_id = user_id)
if has_contacted:
messages.error(request,"You have already made enquiry about this car")
return redirect('/cars/'+car_id)
contact = Contact(
car_id=car_id, car_title=car_title, user_id=user_id,
first_name=first_name, last_name=last_name, customer_need=customer_need,
city=city, state=state, email=email, message=message
)
contact.save()
messages.success(request, "Contact Saved")
return redirect('/cars/'+car_id)
def parse_csv(data):
"""Parse CSV and try to add data.
Only if not double
Returns:
[<total records quantity>, <imported records>, <doubles quantity>, <errors quantity>]
"""
imported = 0
doubles = 0
errors = 0
data_read = [row for row in data]
for row in data_read:
contact = Contact(
name=row[0],
company=row[1],
email=row[2],
phone=row[3],
interest=row[4],
)
existing_contact = Contact.objects.filter(
name=row[0],
company=row[1],
email=row[2],
phone=row[3],
interest=row[4],
)
if existing_contact.count() == 0:
imported += 1
contact.save()
else:
doubles += 1
return [len(data_read), imported, doubles, errors]
def test_most_recent_text_body(self):
"""test that most_recent_text_body helper function returns the right text body."""
contact = Contact(name="test", number='+12345678910')
contact.save()
text = Text(body="this is a test", sender="Them", contact=contact)
text.save()
self.assertEqual(contact.most_recent_text_body(), text.body)
def contact2(request):
if request.method == 'POST':
pet_id = request.POST['pet_id']
pet = request.POST['pet']
name = request.POST['name']
email = request.POST['email']
phone = request.POST['phone']
message = request.POST['message']
contact = Contact(pet_id=pet_id,
pet=pet,
name=name,
email=email,
phone=phone,
message=message)
contact.save()
#send an email function
send_mail(
'Hi! ' + name +
' Thank you for your message', #subject person´s name
'We´ll be in touch shortly!', #message
email, #from email
['*****@*****.**'], #to email
)
messages.success(
request, 'Thank you for your message! We´ll be in touch shortly! ')
return redirect('index')
def save(self, *args, **kwargs):
if not self.id:
contact = Contact(owner=self,
full_name=self.full_name,
mobile=self.mobile)
super().save(*args, **kwargs)
contact.save()
super().save(*args, **kwargs)
def create(self, request, format=None):
serializer = ContactSerializer(data=request.data)
contact = Contact(name=request.data['name'],
phone_number=request.data['phone_number'],
image='/images/what.png')
contact.save()
return redirect('/')
return Response({'detail': 'Contact created'})
def import_csv(imported_file):
for i, v in enumerate(imported_file.splitlines()):
if i == 0:
continue
else:
v = v.split(',')
contact = Contact(firstName=v[0], lastName=v[1], phone=v[2], email=v[3])
contact.save()
def test_instance_deleted(self):
c = Contact(code="1", name="contact1", email="*****@*****.**")
c.save()
c.delete()
self.assertEqual(
len(Contact.history.all()),
2 # created + deleted audits
)
def create(self, request):
serializer = ContactSerializer
new_contact = Contact(name=request.data['name'],
phone_number=request.data['number'],
pic=request.data['pic'])
new_contact.save()
return redirect('/')
return Response({'detail': 'Contact Created'})
def test_can_fetch_all_contacts(self):
name, email = "test", "*****@*****.**"
contact = Contact(name=name, email=email)
contact.save()
response = self.client.get(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0]["name"], name)
def inquiry(request):
if request.method == "POST":
car_id = request.POST['car_id']
car_title = request.POST['car_title']
user_id = request.POST['user_id']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
customer_need = request.POST['customer_need']
city = request.POST['city']
state = request.POST['state']
email = request.POST['email']
phone = request.POST['phone']
message = request.POST['message']
# for sending error if user already making inquiry.
if request.user.is_authenticated:
user_id = request.user.id
has_connected = Contact.objects.all().filter(car_id=car_id,
user_id=user_id)
# if user_id is already exists
if has_connected:
messages.error(
request,
'You already make inquiry please wait until get first response'
)
return redirect('/cars/' + car_id)
# save elements in contact model
contact = Contact(car_id=car_id,
car_title=car_title,
user_id=user_id,
first_name=first_name,
last_name=last_name,
customer_need=customer_need,
city=city,
state=state,
email=email,
phone=phone,
message=message)
# sending messages to admin whenever new inquiry posted .
admin_info = User.objects.get(is_superuser=True)
admin_email = admin_info.email
send_mail(
'New inquiry', # subject
'You have new inquiry for ' + car_title +
'. Please login to your admin panel', # message
'*****@*****.**', # admin gmail
[admin_email],
fail_silently=False,
)
# saving post to models
contact.save()
# inquiry posted successfully to admin by customer
messages.success(request, "Your inquiry saved we will back you soon")
# redirect to cars page
return redirect('/cars/' + car_id)
def addData(request):
if request.method == "POST":
name1 = request.POST["name"]
number1 = request.POST["number"]
address1 = request.POST["address"]
newContact = Contact(name=name1, number=number1, address=address1)
newContact.save()
return HttpResponse(alert(f"Added ({name1},{number1},{address1})"))
return HttpResponse("make post request")
def setUp(self):
c = Contact(
name='URLResolveTestCase',
company='Стероиды и Ко',
email='*****@*****.**',
phone='+71234567890',
interest=None,
)
c.save()
def test_queryset_deleted(self):
c = Contact(code="1", name="contact1", email="*****@*****.**")
c.save()
Contact.objects.all().delete()
self.assertEqual(
len(Contact.history.all()),
1 # created audit only
# deleted audit is not created
# use bulk_delete_with_history for deleted audits
)
def test_new_text_redirects_on_success(self):
"""Test that creating a new contact successfully redirects."""
user1 = User()
user1.save()
self.client.force_login(user1)
jabba = Contact(name="Jabba", number="+9999999999")
jabba.save()
response = self.client.post(reverse_lazy('new_text'),
{'number': "9999999999"})
self.assertTrue(response.status_code == 302)
def update_person(self, request, pk, format=None):
print("cheese and crackers")
queryset = Contact.objects.all.get(pk=pk)
serializer = ContactSerializer(queryset, data=request.data)
contact = Contact(name=request.data['name'],
phone_number=request.data['phone_number'],
image='/images/what.png')
contact.save()
return redirect('/')
return Response({'detail': 'Contact edited'})
def test_contact_needed_detect_not_contacted_at_all(self):
# GIVEN: new contact without last contact date
contact = Contact(firstName='Test', lastName='Test', age=33, notificationsFrequency=24, gender=1, isActive=True)
contact.save()
# WHEN: run get_contact_needed
results = StatsView.get_contact_needed()
# THEN: expect the given contact in the results
self.assertIn(contact, results)
def test_most_recent_text_body_longer_body(self):
"""Test helper function returns truncated text body."""
contact = Contact(name="test", number='+12345678910')
contact.save()
text = Text(body="this is a sample text for testing",
sender="Them",
contact=contact)
text.save()
truncated_text = "this is a sample tex..."
self.assertEqual(contact.most_recent_text_body(), truncated_text)
def test_contact_queryset_returns_contact_attributes_in_json(self):
"""Test that a call to the contact api contains contact attributes."""
user1 = User()
user1.save()
self.client.force_login(user1)
jabba = Contact(name="Jabba", number="+2068675309")
jabba.save()
contacts = self.client.get('/api/contacts/list/')
self.assertTrue("+2068675309" in contacts.content.decode())
self.assertTrue("Jabba" in contacts.content.decode())
def test_contact_needed_postponed_but_active_again(self):
# GIVEN: new contact without last contact date and postponed in past
contact = Contact(firstName='Test', lastName='Test', age=33, notificationsFrequency=24, gender=1, isActive=True,
postponed=timezone.now()-datetime.timedelta(days=1))
contact.save()
# WHEN: run get_contact_needed
results = StatsView.get_contact_needed()
# THEN: expect the given contact in the results
self.assertIn(contact, results)
def test_contact_needed_but_scheduled_not_detected(self):
# GIVEN: new contact without last contact date but with scheduled message
contact = Contact(firstName='Test', lastName='Test', age=33, notificationsFrequency=24, gender=1, isActive=True,
lastContact=timezone.now())
contact.save()
message = Message(type='SMS', recipientName='Test test', contact=contact, recipientPhone="1234", body="test",
sendAtDate=timezone.now(), state="QUEUED")
message.save()
# WHEN: run get_contact_needed
results = StatsView.get_contact_needed()
# THEN: expect the given contact NOT in the results
self.assertNotIn(contact, results)
def test_should_save_a_contact_belonging_to_a_category(self):
category = Category(name="friend")
category.save()
self.assertEqual(1, len(Category.objects.filter()))
contact = Contact()
contact.name = "ben"
contact.email_address = "brainychip.gmail.com"
contact.category = category
contact.save()
self.assertEqual(contact.category, category)
def editformprocessor(request):
logger.debug(request.POST['code'])
if request.POST['code']:
nc = Contact.objects.filter(owner=request.user).filter(code=request.POST['code'])[0]
else:
nc = Contact(code=GetNewCode(Contact.objects.filter(owner_id = request.user.id)), owner = request.user)
nc.client = Client.objects.filter(owner_id = request.user.id).filter(code=request.POST['clientid'])[0]
nc.fio = request.POST['fio']
nc.email = request.POST['email']
if (request.POST['birthday']):
stdate = datetime.datetime.strptime(str(request.POST['birthday']), "%Y-%m-%d");
nc.birthday = stdate
nc.position = request.POST['position']
nc.phone = request.POST['phone']
nc.save();
return entry(request)
def test_state_contact_needed_last_contact_present(self):
# GIVEN: active contact with last contact older than notification frequency
contact = Contact(firstName='Test',
lastName='Test',
lastContact=timezone.now() - datetime.timedelta(hours=36),
postponed=timezone.now() - datetime.timedelta(hours=24),
email='*****@*****.**',
phone='12341234',
age=33,
gender=1,
notificationsFrequency=24,
isActive=True,
notes='Test notes')
contact.save()
# THEN: state should be contact needed
self.assertEqual(contact.state, 'CONTACT_NEEDED')
def update_contacts(request):
if request.method == 'POST':
for i in range(int(request.POST['total_contacts'])):
try:
c = Contact()
c.user = request.user
c.name = request.POST['name' + str(i)]
c.email = request.POST['email' + str(i)]
c.save()
except Exception:
print 'none'
return HttpResponseRedirect(reverse('dashboard'))
else:
return HttpResponseRedirect(reverse('accounts'))
def test_state_disabled(self):
# GIVEN: disabled contact
contact = Contact(firstName='Test',
lastName='Test',
lastContact=timezone.now(),
postponed=timezone.now(),
email='*****@*****.**',
phone='12341234',
age=33,
gender=1,
notificationsFrequency=24,
isActive=False,
notes='Test notes')
contact.save()
# THEN: state should be disabled
self.assertEqual(contact.state, 'DISABLED')
def test_state_postponed_past(self):
# GIVEN: active contact with postponed in past
contact = Contact(firstName='Test',
lastName='Test',
lastContact=timezone.now(),
postponed=timezone.now() - datetime.timedelta(hours=24),
email='*****@*****.**',
phone='12341234',
age=33,
gender=1,
notificationsFrequency=24,
isActive=True,
notes='Test notes')
contact.save()
# THEN: state should not be postponed
self.assertNotEqual(contact.state, 'POSTPONED')
def readData(self, filePath):
data = csv.DictReader(open(filePath , encoding='utf-8'))
count = 0
print('reading: %s' % filePath)
for row in data:
count += 1
sys.stdout.write('.')
sys.stdout.flush()
contact = Contact()
contact.given_name = row['GivenName']
contact.surname = row['Surname']
contact.street_address = row['StreetAddress']
contact.city = row['City']
contact.zip_code = row['ZipCode']
contact.country = row['Country']
contact.email_address = row['EmailAddress']
contact.telephone_number = row['TelephoneNumber']
contact.save()
print('\nready: %d contacts read' % count)
def test_state_planned_contact(self):
# GIVEN: active contact with queued message
contact = Contact(firstName='Test',
lastName='Test',
lastContact=timezone.now(),
postponed=timezone.now() - datetime.timedelta(hours=24),
email='*****@*****.**',
phone='12341234',
age=33,
gender=1,
notificationsFrequency=24,
isActive=True,
notes='Test notes')
contact.save()
message = Message(type='SMS', recipientName='Test test', contact=contact, recipientPhone="1234", body="test",
sendAtDate=timezone.now(), state="QUEUED")
message.save()
# THEN: state should be contact planned
self.assertEqual(contact.state, 'CONTACT_PLANNED')
def saveWhatsapp(phone, type_message, message):
try:
contact = ContactNumber.objects.get(phone=phone)
except ContactNumber.DoesNotExist:
# If number phone not exist
contact = Contact(nickname=phone)
contact.save()
contact_number = ContactNumber(contact=contact,
country_code='591',
phone=phone)
contact_number.save()
print ('===========')
print ('type_message')
print ('===========')
# if type_message is not 'image' and type_message is not 'video' and type_message is not 'audio':
if type_message is 'text':
whatsapp = MessageCenterReceived(contact=contact,
message_received=message)
whatsapp.save()
def test_creating_a_new_contact_and_save_it_to_db(self):
#create a new contact
contact = Contact()
contact.name = 'Kostyantyn'
contact.surname = 'Surename'
contact.birthdate = timezone.now()
contact.bio = 'My bio'
contact.save()
all_contacts = Contact.objects.all()
self.assertEqual(len(all_contacts), 1)
db_contact = all_contacts[0]
self.assertEqual(db_contact.name, 'Kostyantyn')
self.assertEqual(db_contact.surname, 'Surename')
self.assertEqual(db_contact.birthdate, contact.birthdate)
self.assertEqual(db_contact.bio, 'My bio')
contactdetails = ContactDetail()
contactdetails.jabber = 'jabber'
contactdetails.email = '*****@*****.**'
contactdetails.skype = 'skype'
contactdetails.other = 'bla-bla-bla'
contactdetails.save()
contact.contactdetails = contactdetails
contact.save()
all_contacts = Contact.objects.all()
self.assertEqual(len(all_contacts), 1)
db_contact=all_contacts[0]
self.assertEqual(db_contact.contactdetails.jabber, 'jabber')
self.assertEqual(db_contact.contactdetails.email, '*****@*****.**')
self.assertEqual(db_contact.contactdetails.skype, 'skype')
self.assertEqual(db_contact.contactdetails.other, 'bla-bla-bla')
def new(request):
user_profile = request.user.userprofile_set.filter()[0]
form_categories = Category.objects.filter(owner=user_profile)
if request.method == "GET":
current_user = request.user
form = ContactForm(current_user=current_user)
user_profile = request.user.userprofile_set.filter()[0]
form_categories = Category.objects.filter(owner=user_profile)
return render(request, 'contacts/new_contact_form.html', {'form':form,
'title':"New Contact",
'categories':form_categories})
else:
form = ContactForm(data=request.POST, current_user=request.user)
if form.is_valid():
try:
user_profile = get_user_profile(request)
age = form.cleaned_data['age']
name = form.cleaned_data['name']
public = form.cleaned_data['public']
category_id = form.cleaned_data['category']
category = Category.objects.filter(id=category_id)[0]
contact = Contact(age=age, name=name, public=public, owner=user_profile, category=category)
contact.save()
messages.add_message(request, messages.SUCCESS, "Contact successfully created" )
return redirect('/contacts/')
except:
messages.add_message(request, messages.ERROR, "Contact creation unsuccessful" )
return render(request, 'contacts/new_contact_form.html', {'form':form,
'title':"New Contact",
'categories': form_categories})
else:
messages.add_message(request, messages.ERROR, "Contact creation unsuccessful" )
return render(request, 'contacts/new_contact_form.html', {'form':form,
'title':"New Contact",
'categories': form_categories})
def contact_edit(request, abonent_id, contact_id=0):
if contact_id != '0' :
message = u'Изменение контактной информации'
new = False
contact = Contact.objects.get(pk=contact_id)
else:
message = u'Добавление нового контакта'
new = True
contact = Contact()
try:
abonent = Abonent.objects.get(pk = abonent_id)
except:
raise Http404
if request.method == 'POST':
form = ContactModelForm(request.POST, instance=contact)
if form.is_valid():
form.save(commit=False)
contact.abonent=abonent
contact.save()
return HttpResponseRedirect(reverse('contacts', args=[abonent_id]))
else:
print form.errors
else:
form = ContactModelForm(instance=contact)
header = 'Контакт'
breadcrumbs = [({'url':reverse('contacts', args=[abonent.pk]),'title':'Контакты'})]
return render_to_response('generic/generic_edit.html', {
'header' : header,
'form': form,
'breadcrumbs':breadcrumbs,
'abonent': abonent,
'extend': 'abonent/main.html', },
context_instance = RequestContext(request))
def issues(request):
from contacts.models import Contact, ContactGroup
grupos = ContactGroup.objects.all()
if request.method == "POST":
if 'file' in request.FILES:
import xlrd
from django.conf import settings
file = request.FILES['file']
wb = xlrd.open_workbook(file_contents=file.read())
sh = wb.sheet_by_index(0)
for rownum in range(1,sh.nrows):
row = sh.row_values(rownum)
ctc = Contact()
ctc.name = row[0]
ctc.last_name = row[1]
ctc.email = row[2]
ctc.grupo = ContactGroup.objects.get(pk=row[3])
ctc.save()
form = UploadFileForm()
return simple.direct_to_template(
request,
'issues.html',
extra_context = {
'grupos':grupos,
'formMass':form,
}
)
def view_contact_import(request):
form = ImportContactsForm()
message = ''
errorList = []
if request.method == 'POST':
form = ImportContactsForm(request.POST,request.FILES)
my_file = request.FILES['file']
if form.is_valid():
with open('/var/www/yellowpage/media/xls/'+my_file.name, 'wb+') as destination:
for chunk in my_file.chunks():
destination.write(chunk)
xls = xlrd.open_workbook('/var/www/yellowpage/media/xls/'+my_file.name)
sheet = xls.sheet_by_index(0)
completed = 0
for row_index in range(1, sheet.nrows):
try:
code = sheet.cell_value(row_index,0).capitalize()
#if str(code) == "":
#
contact = Contact(code=code)
contact.surname = sheet.cell_value(row_index,1).capitalize()
contact.name = sheet.cell_value(row_index,2).capitalize()
contact.street = sheet.cell_value(row_index,3).capitalize()
contact.zip = str(sheet.cell_value(row_index,4))
contact.city = sheet.cell_value(row_index,5).capitalize()
contact.province = Province.objects.get(code=sheet.cell_value(row_index,6))
contact.email = sheet.cell_value(row_index,8)
contact.phone_number = sheet.cell_value(row_index, 7)
contact.birthdate = str(sheet.cell_value(row_index,12))
#Settore
sectorString = str(sheet.cell_value(row_index, 10))
professionString = str(sheet.cell_value(row_index, 9))
profession = Work.objects.filter(name=professionString)
if not profession:
sector = Sector.objects.filter(name=sectorString)
if not sector:
sector = Sector(name=sectorString)
sector.save()
#Professione
profession = Work(name=professionString, sector=Sector.objects.get(pk=sector.pk))
profession.save()
else:
profession = profession[0]
contact.work = Work.objects.get(name=profession.name)
contact.save()
completed += 1
#Certificato
cabinet = Cabinet.objects.get(pk=ContactCertFile.CABINET_ID)
current_user = request.user
file = ContactCertFile(contact=Contact.objects.get(pk=contact.pk))
uploadedFile = UploadedFile(title="Certificato Vuoto", cabinet=cabinet, file_ref="/cabinet/cert_empty.pdf", owner=current_user)
uploadedFile.save()
file.file = uploadedFile
file.expiry = str(sheet.cell_value(row_index,11))
file.save()
except Exception as e:
print '%s (%s)' % (e.message, type(e))
errorList.append(sheet.cell_value(row_index,0).capitalize() + " " + e.message)
message = 'Report Import: %d contatti importati correttamente. ' % completed
return render_to_response('admin/contacts/view_contact_import.html',{'form':form, 'message':message, 'errorList': errorList}, context_instance=RequestContext(request))
contacts = [
{
"firstName": "Alex",
"lastName": "Iskander",
"preferredName": "Alex",
"email": "*****@*****.**",
"groups": ["Christmas Party", "Greetings", "Friends", "Employees"]
},
{
"firstName": "John",
"lastName": "Doe",
"preferredName": "Johnny",
"email": "*****@*****.**",
"groups": ["Credit Unions", "Friends"]
},
{
"firstName": "Smeagol",
"lastName": "Kentucky", # Uh... what?
"preferredName": "Gollum",
"email": "*****@*****.**",
"groups": ["Greetings"]
}
]
for c in contacts:
contact = Contact(firstName=c["firstName"],lastName=c["lastName"],preferredName=c["preferredName"],email=c["email"])
contact.save()
for g in c["groups"]:
gmap[g].contacts.add(contact)
gmap[g].save()
def import_json(imported_file):
for json_contact in json.loads(imported_file):
contact = Contact(firstName=json_contact['firstName'], lastName=json_contact['lastName'],
phone=json_contact['phone'], email=json_contact['email'])
contact.save()
def import_xml(imported_file):
raw_xml = xmldict.xml_to_dict(imported_file)['root']['item']
for item in raw_xml:
contact = Contact(firstName=item['firstName']['#text'], lastName=item['lastName']['#text'],
phone=item['phone']['#text'], email=item['email']['#text'])
contact.save()
def index(request, form_class=ContactForm, template_name="form.html"):
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email', None)
first_name = form.cleaned_data.get('first_name', None)
last_name = form.cleaned_data.get('last_name', None)
if listed_in_email_block(email):
# listed in the email blocks - it's a spam email we want to block
# log the spam
log_defaults = {
'event_id' : 130999,
'event_data': 'SPAM detected in email from %s %s, %s.' \
% (first_name, last_name, email),
'description': 'email spam detected',
'user': request.user,
'request': request,
}
EventLog.objects.log(**log_defaults)
# redirect normally so they don't suspect
return HttpResponseRedirect(reverse('form.confirmation'))
address = form.cleaned_data.get('address', None)
city = form.cleaned_data.get('city', None)
state = form.cleaned_data.get('state', None)
zipcode = form.cleaned_data.get('zipcode', None)
country = form.cleaned_data.get('country', None)
phone = form.cleaned_data.get('phone', None)
url = form.cleaned_data.get('url', None)
message = form.cleaned_data.get('message', None)
contact_kwargs = {
'first_name': first_name,
'last_name': last_name,
'message': message,
}
contact = Contact(**contact_kwargs)
contact.creator_id = 1 # TODO: decide if we should use tendenci base model
contact.owner_id = 1 # TODO: decide if we should use tendenci base model
contact.save()
if address or city or state or zipcode or country:
address_kwargs = {
'address': address,
'city': city,
'state': state,
'zipcode': zipcode,
'country': country,
}
obj_address = Address(**address_kwargs)
obj_address.save() # saves object
contact.addresses.add(obj_address) # saves relationship
if phone:
obj_phone = Phone(number=phone)
obj_phone.save() # saves object
contact.phones.add(obj_phone) # saves relationship
if email:
obj_email = Email(email=email)
obj_email.save() # saves object
contact.emails.add(obj_email) # saves relationship
if url:
obj_url = URL(url=url)
obj_url.save() # saves object
contact.urls.add(obj_url) # saves relationship
site_name = get_setting('site', 'global', 'sitedisplayname')
message_link = get_setting('site', 'global', 'siteurl')
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'contacts', 'contactrecipients')
if recipients:
if notification:
extra_context = {
'reply_to': email,
'contact':contact,
'first_name':first_name,
'last_name':last_name,
'address':address,
'city':city,
'state':state,
'zipcode':zipcode,
'country':country,
'phone':phone,
'email':email,
'url':url,
'message':message,
'message_link':message_link,
'site_name':site_name,
}
notification.send_emails(recipients,'contact_submitted', extra_context)
try: user = User.objects.filter(email=email)[0]
except: user = None
if user:
event_user = user
event_id = 125115
else:
event_user = AnonymousUser()
event_id = 125114
log_defaults = {
'event_id' : event_id,
'event_data': 'Contact Form (id:%d) submitted by %s' % (contact.pk, email),
'description': '%s added' % contact._meta.object_name,
'user': event_user,
'request': request,
'instance': contact,
}
EventLog.objects.log(**log_defaults)
return HttpResponseRedirect(reverse('form.confirmation'))
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
form = form_class()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
e22 = Event.objects.get(pk=22) e23 = Event.objects.get(pk=23) e40 = Event.objects.get(pk=40) e41 = Event.objects.get(pk=41) e43 = Event.objects.get(pk=43) e44 = Event.objects.get(pk=44) e60 = Event.objects.get(pk=60) ciacci = Contact() ciacci.type = "C" ciacci.status = "I" ciacci.name = "MANILA" ciacci.surname = "CIACCI" ciacci.email = "" ciacci.code = "CCCMNL00XX00E999" ciacci.save() print "created " + str(ciacci) e21.consultant = ciacci e44.consultant = ciacci e21.save() e44.save() print "associated " + str(ciacci) + " to " + str(e21) print "associated " + str(ciacci) + " to " + str(e44) traino = Contact() traino.type = "C" traino.status = "I" traino.name = "TRAINO" traino.surname = "TRAINO" traino.email = "" traino.code = "TQRNXL00ZX00E999" traino.save()
def view_main(request):
contact = Contact.objects.all().filter(owner=request.user)
provinces = Province.objects.all()
sectors = Sector.objects.all()
ref_files = ContactRefFile.objects.filter(contact=contact)
cert_files = ContactCertFile.objects.filter(contact=contact)
form = ContactForm()
today = datetime.datetime.now()
events = Event.objects.all().filter(date__gte=today,is_public=True).order_by('date')
iscrizioni = []
#print contact
if len(contact)>0:
iscrizioni = EventSignup.objects.all().filter(contact=contact[0])
signups = []
for s in iscrizioni:
signups.append(s.event)
#print signups
if request.method == 'POST':
form = ContactForm(request.POST)
if contact and form.is_valid():
up_contact = Contact.objects.get(code=contact[0].code)
province = Province.objects.filter(id=form.cleaned_data["province"])[0]
work = Work.objects.filter(id=form.cleaned_data["work"])[0]
up_contact.name=form.cleaned_data["name"]
up_contact.surname=form.cleaned_data["surname"]
up_contact.street = form.cleaned_data["street"]
up_contact.province = province
up_contact.birthdate = form.cleaned_data["birthdate"]
up_contact.city = form.cleaned_data["city"]
up_contact.zip = form.cleaned_data["zip"]
up_contact.civic = form.cleaned_data["civic"]
up_contact.email = form.cleaned_data["email"]
up_contact.sex = form.cleaned_data["sex"]
up_contact.phone_number=form.cleaned_data["phone_number"]
up_contact.work=work
up_contact.save()
messages.success(request, "Informazioni Aggiornate!!")
return HttpResponseRedirect('/frontend/main')
elif form.is_valid():
province = Province.objects.filter(id=form.cleaned_data["province"])[0]
work = Work.objects.filter(id=form.cleaned_data["work"])[0]
my_contact = Contact(name=form.cleaned_data["name"], surname=form.cleaned_data["surname"], street=form.cleaned_data["street"], province=province,
birthdate = form.cleaned_data["birthdate"],sex = form.cleaned_data["sex"], city=form.cleaned_data["city"], zip=form.cleaned_data["zip"], civic = form.cleaned_data["civic"], email=form.cleaned_data["email"], phone_number=form.cleaned_data["phone_number"], work=work, code = form.cleaned_data["code"], owner = request.user)
my_contact.save()
work_str = "0"
event_files = []
if contact:
contact_entry = contact[0]
work_str = str(contact_entry.work.id)
# Search for event files
files = []
# print "### Searching for contact_id: %s" % contact_entry.code
for signup in EventSignup.objects.filter(contact=contact_entry, presence=True):
# print "### Searching for file for event: %s [%d]" % (signup, signup.event_id)
for file in EventFile.objects.filter(event=signup.event):
# print "### Found file: %s" % file
files.append(file)
# Not sure why EventSignup allow for duplicate signup per event, as result,
# need to create a unique list of files per user
# ToDo: Find out why EventSignup allow for duplicate signup and fix it if bug and remove the create of the unique list below
event_files = set(files)
return render_to_response(
'frontend/main.html',
{
"contact": contact,
"form": form,
"provinces": provinces,
"sectors": sectors,
"events": events,
"signups": signups,
"work_str": work_str,
"ref_files": ref_files,
"event_files": event_files,
"cert_files": cert_files
},
context_instance=RequestContext(request)
)
def test_should_save_an_invalid_model(self):
contact = Contact()
contact.save()
self.assertTrue(Contact.objects.count(), 1)
def test_should_save_partial_contact(self):
contact = Contact()
contact.name = "ben"
contact.email_address = "brainychip.gmail.com"
contact.save()
self.assertEqual(Contact.objects.count(), 1)
