def handle_post(self, user, account_info):
phone_number = self.request.get('phone_number')
urlsafe_entity_key = self.request.get('contact_entity_key')
if len(urlsafe_entity_key) > 0:
contact_key = ndb.Key(urlsafe=urlsafe_entity_key)
if contact_key.string_id() == phone_number:
# The phone number is the same, just do a simple edit
contact = contact_key.get()
else:
# The phone number has changed. ugh. Do it the hard way.
logging.info(
"The phone number changed when editing this contact!")
original_contact = contact_key.get()
contact = Contact(parent=account_utils.get_parent_key(user),
id=phone_number)
contact.list_keys = original_contact.list_keys
original_contact.key.delete(
) # Remove the old one to avoid a duplicate contact.
else:
contact = Contact(parent=account_utils.get_parent_key(user),
id=phone_number)
# Update all fields other than the list_keys field. Leave it alone in case this is an edit.
contact.nickname = self.request.get('nickname')
contact.phone_number = phone_number
contact.real_first_name = self.request.get('real_first_name')
contact.real_last_name = self.request.get('real_last_name')
contact.email = self.request.get('email')
contact.other_info = self.request.get('other_info')
contact.put()
self.redirect("/contacts")
def test_apply_raise(self):
self.cont_1 = Contact('Noureddine', 'Kerzazi', 50000)
self.cont_2 = Contact('Bram', 'Adam', 60000)
self.cont_1.apply_raise()
self.cont_2.apply_raise()
self.assertEqual(self.cont_1.pay, 52500)
self.assertEqual(self.cont_2.pay, 63000)
def setUp(self):
self.db_file = 'temp.db'
self.contactDAO = ContactDAO(self.db_file)
self.contactDAO.init_db()
self.contact1 = Contact(6, "R", "Z", "514999666", "*****@*****.**",
True, 20.3)
self.contact2 = Contact(50, "H", "P", "514999666", "*****@*****.**",
False, 20.3)
def test_update_contact_should_set_the_provided_values(self):
contactToUpdate = Contact(3, "Bob", "Kump", "514-554-223",
"*****@*****.**", True, 22.9)
contactToCopy = Contact(1, "John", "Dough", "450-221-998",
"*****@*****.**", False, 40.8)
self.contactDAO.add(contactToUpdate)
self.contactDAO.update(contactToCopy)
res = self.contactDAO.get_by_names("John", "Dough")
self.areContactAttribsEqual(contactToCopy, res)
def test_update_contact_should_return_zero_if_id_does_not_exist(self):
#On définit les valeurs pour la modification
contact1 = Contact(1, "Jean", "Martin", 222, "mail2", True, "date2")
contact2 = Contact(10, "Jean", "Martin", 222, "mail2", True, "date2")
contact3 = Contact(24, "Jean", "Martin", 222, "mail2", True, "date2")
#On tente de mettre à jour les contacts aux id spécifiés
self.assertEqual(self.contactDAO.update(contact1), 0)
self.assertEqual(self.contactDAO.update(contact2), 0)
self.assertEqual(self.contactDAO.update(contact3), 0)
def setUp(self):
self.db_file = 'yourdb.db'
builtins.print = Mock()
contact1 = Contact(12, "Hercules", "The God", "123456",
"*****@*****.**", True, 2232)
contact2 = Contact(15, "Sponge", "Bob", "99885",
"*****@*****.**", True, 55446)
with sqlite3.connect(self.db_file) as connection:
cursor = connection.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS
contact
(id INTEGER PRIMARY KEY,
first_name text,
last_name text,
phone text,
mail text,
updated bool,
updated_date double
)
''')
cursor.execute(
'''
INSERT INTO
contact
(first_name,
last_name,
phone,
mail,
updated,
updated_date)
VALUES
(?,?,?,?,?,?)
''',
(contact2.first_name, contact2.last_name, contact2.phone,
contact2.mail, contact2.updated, contact2.updated_date))
connection.commit()
cursor.execute(
'''
INSERT INTO
contact
(first_name,
last_name,
phone,
mail,
updated,
updated_date)
VALUES
(?,?,?,?,?,?)
''',
(contact1.first_name, contact1.last_name, contact1.phone,
contact1.mail, contact1.updated, contact1.updated_date))
connection.commit()
def test_fullname(self):
self.cont_1 = Contact('Noureddine', 'Kerzazi', 50000)
self.cont_2 = Contact('Bram', 'Adam', 60000)
self.assertEqual(self.cont_1.fullname, 'Noureddine Kerzazi')
self.assertEqual(self.cont_2.fullname, 'Bram Adam')
# Hypothèse: Ici, il y avait un typo: au lieu d'avoir first_name, il y avait juste first
self.cont_1.first_name = 'Noureddine2'
self.cont_2.first_name = 'Bram2'
self.assertEqual(self.cont_1.fullname, 'Noureddine2 Kerzazi')
self.assertEqual(self.cont_2.fullname, 'Bram2 Adam')
def test_email(self):
self.cont_1 = Contact('Noureddine', 'Kerzazi', 50000)
self.cont_2 = Contact('Bram', 'Adam', 60000)
self.assertEqual(self.cont_1.email, '*****@*****.**')
self.assertEqual(self.cont_2.email, '*****@*****.**')
# Hypothèse: Ici, il y avait un typo: au lieu d'avoir first_name, il y avait juste first
self.cont_1.first_name = 'Noureddine2'
self.cont_2.first_name = 'Bram2'
self.assertEqual(self.cont_1.email, '*****@*****.**')
self.assertEqual(self.cont_2.email, '*****@*****.**')
def setUpClass(cls):
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def test_when_add_is_called_it_should_return_an_autoincremented_id(self):
firstId = None
contact1 = Contact(firstId, "testFirstName1", "testLastName1", "911",
"testMail1", True, "testTime1")
firstId = self.contactDAO.add(contact1)
SecondId = None
contact2 = Contact(SecondId, "testFirstName2", "testLastName2", "911",
"testMail2", True, "testTime2")
SecondId = self.contactDAO.add(contact2)
self.assertTrue(SecondId == firstId + 1)
def setUpClass(cls):
cls.test_agent = Contact("Test Agent", "Agent")
cls.test_insured = Contact("Test Insured", "Named Insured")
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def setUpClass(cls):
# print "Setting up TestReturnAccountBalance class..."
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def setUpClass(cls):
print "Setting up TestBillingSchedules class..."
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
db.session.add(cls.policy)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.commit()
print "Class set up!\n"
def test_list_contacts_with_all_updated_items_and_updated_True_should_return_all_contacts(
self):
contact1 = Contact(None, "testFirstName1", "testLastName1", "testNum1",
"testMail1", True, "testTime1")
contact1.id = self.contactDAO.add(contact1)
contact2 = Contact(None, "testFirstName2", "testLastName2", "testNum2",
"testMail2", True, "testTime2")
contact2.id = self.contactDAO.add(contact2)
contactList = self.contactDAO.list(True)
self.assertTrue(
len(contactList) == 2
and self.isSameContact(contact1, contactList[0])
and self.isSameContact(contact2, contactList[1]))
def setUpClass(cls):
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Named Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2018, 10, 1), 1870)
db.session.add(cls.policy)
db.session.commit()
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = 'Monthly'
db.session.commit()
def edit(request):
user = request.user
contact = Contact.objects.by_user(user) or Contact(user=user)
'''
if not contact:
messages.error(request, u'请先上传个人页面')
return HttpResponseRedirect(reverse('contacts_upload'))
'''
if request.method == 'GET':
if request.session.get('contact_info'):
contact_info = request.session.pop('contact_info')
contact.fullname = contact_info.get('fullname')
contact.email = contact_info.get('email')
contact.phone = contact_info.get('phone')
contact.qq = contact_info.get('qq')
contact.douban_id = contact_info.get('douban_id')
form = ContactEditForm(instance=contact)
elif request.method == 'POST':
form = ContactEditForm(request.POST, instance=contact)
if form.is_valid():
form.save()
messages.success(request, u'个人资料已更新')
return HttpResponseRedirect(reverse('root'))
return { 'form': form}
def search_contact(self, search_contact_query):
url = 'search/contacts?query=%s' % search_contact_query
response = self._api._get(url)
contacts = []
for contact in response["results"]:
contacts.append(Contact(**contact))
return contacts
def post(self, cid=None):
try:
data = request.get_json() or {}
name = data["name"]
phone_number = data["phone"]
email = data["email"]
# check for duplicate email id.
contact = Contact.query.filter_by(email_id=email).first()
if contact:
return resp_fail(f"Contact with same email-id already exists.",
status_code=203)
contact = Contact(name=name, phone=phone_number, email=email)
db.session.add(contact)
db.session.commit()
return resp_success(
f"Contact {name}:{phone_number} was created successfully.",
status_code=201)
except KeyError as e:
return resp_fail(f"Missing parameter : {e.args[0]}")
except IntegrityError as e:
db.session.rollback()
logger.info(f"Duplicate contact {name}:{email}")
return resp_fail(f"Contact with same email-id already exists.",
status_code=203)
except Exception as e:
logger.exception(e)
db.session.rollback()
return resp_fail("Something went wrong.", status_code=500)
def add_contact():
# Ici, on veut créer et ajouter à la base de donnée un nouveau Contact
#
# Les données du formulaire fournie par l'utilisateur sont disponibles
# dans request.form qui a cette structure :
# { "name": "Sacha",
# "phone": "0612345678",
# "email": "*****@*****.**",
# "birthday": "16/03/1993"
# }
# 1. Créer l'objet Contact
# note : convertir la valeur associée à "birthday" en objet datetime peut être compliqué.
# Dans un premier temps on peut forcer la valeur à None pour valider que le reste marche...
new_contact = Contact(name=request.form["name"],
email=request.form["email"],
phone=request.form["phone"])
# 2. L'ajouter à la base (et commiter l'ajout)
db.session.add(new_contact)
db.session.commit()
# Une fois le contact ajouté, nous redirigeons l'utilisateur vers la page
# d'acceuil (cela déclenche un rafraichissement de la page)
return redirect("/")
def contact_add_post(request):
"""
Handle ajax post to add a contact.
"""
result = {}
content_type = 'application/json; charset=utf-8'
form = ContactAddForm(request.POST)
if form.is_valid():
contact_email = form.cleaned_data['contact_email']
contact = Contact()
contact.user_email = form.cleaned_data['user_email']
contact.contact_email = contact_email
contact.contact_name = form.cleaned_data['contact_name']
contact.note = form.cleaned_data['note']
contact.save()
result['success'] = True
messages.success(
request,
_(u"Successfully added %s to contacts.") % contact_email)
return HttpResponse(json.dumps(result), content_type=content_type)
else:
return HttpResponseBadRequest(json.dumps(form.errors),
content_type=content_type)
def contact_add(request):
"""
Handle normal request to add a contact.
"""
if request.method != 'POST':
raise Http404
form = ContactAddForm(request.POST)
if form.is_valid():
contact_email = form.cleaned_data['contact_email']
contact = Contact()
contact.user_email = form.cleaned_data['user_email']
contact.contact_email = contact_email
contact.contact_name = form.cleaned_data['contact_name']
contact.note = form.cleaned_data['note']
contact.save()
messages.success(request, _(u"Successfully added %s.") % contact_email)
else:
messages.error(request, _('Failed to add an contact.'))
referer = request.META.get('HTTP_REFERER', None)
if not referer:
referer = SITE_ROOT
return HttpResponseRedirect(referer)
def create_contact():
form = ContactForm()
completion_msg = ""
if form.validate_on_submit():
if form.save.data:
new_contact = Contact(fname=form.fname.data,
lname=form.lname.data,
account_id=form.account_id.data,
pnumber=form.pnumber.data,
email=form.email.data,
street=form.street.data,
city=form.city.data,
state=form.state.data,
postal=form.postal.data,
country=form.country.data,
notes=form.notes.data)
db.session.add(new_contact)
try:
db.session.commit()
except:
completion_msg = "Failed to create contact. Please try again."
if completion_msg == "":
completion_msg = "Success! The contact has been saved."
return redirect(url_for('view_contact'))
else:
completion_msg = "Failed to create contact. Please try again."
return render_template("create_contact.html",
form=form,
completion_msg=completion_msg)
def csvread():
if (request.method == 'POST'):
csvf = request.files['file']
random_hex = secrets.token_hex(8)
_, f_ext = os.path.splitext(csvf.filename)
filename = random_hex + f_ext
file_path = os.path.join(app.root_path, 'static/csv', filename)
csvf.save(file_path)
with open(file_path, newline='') as csvfile:
read = csv.DictReader(csvfile)
for row in read:
name = row['first_name']
surname = row['last_name']
email = row['email']
phone = row['phone']
new_contact = Contact(name=name,
surname=surname,
email=email,
phone=phone)
db.session.add(new_contact)
db.session.commit()
flash('Contacts added successfully', 'success')
return redirect(url_for('contacts'))
else:
return render_template('web/csv.html')
def test_when_verify_contacts_status_is_called_and_contactDAO_deactivate_is_not__called_if_new_contact(
self):
contact = Contact(2, "Elie", "Rouphael", "012-345-6789",
"*****@*****.**", True, (datetime.now().timestamp()))
self.contactDAO.list.return_value = [contact]
self.contactService.verify_contacts_status()
self.contactDAO.deactivate.assert_not_called()
def save_form(self):
if not self.iscomplet():
return
full_name = unicode(self.full_name.text())
phone_number = int(self.phone_number.text().replace('.', ''))
try:
Contact(number=phone_number, name=full_name).save()
except:
self.msg_e_or_c.setText(u"Ce numéro existe déjà")
self.msg_e_or_c.setStyleSheet("color: red")
return
grp = unicode(self.list_grp[self.combo_grp.currentIndex()])
if not grp == "Aucun":
grp = Group.select().where(Group.name == grp).get()
contact = Contact.select().where(
Contact.number == phone_number).get()
ContactGroup(group=grp.id, contact=contact).save()
self.full_name.setText("")
self.phone_number.setText("")
self.msg_e_or_c.setText(
u"Le numéro (<b>{}</b>) à éte bien enregistré".format(
phone_number))
def postQuery():
try:
name = 'def'
emailID = '*****@*****.**'
country = 'apa'
query = 'aa'
if 'name' in request.form:
name = request.form['name']
if 'emailID' in request.form:
emailID = request.form['emailID']
if 'country' in request.form:
country = request.form['country']
if 'query' in request.form:
query = request.form['query']
queryObj = Contact(
name,
emailID,
country,
query
)
db.session.add(queryObj)
db.session.commit()
return jsonify({'message' : 'Query Posted Successfully'}), 201
except:
print (traceback.format_exc())
sys.stdout.flush()
return jsonify({'message': 'Unexpected Error occurred when posting query. Please try again'}), 405
def test_encoding_is_proper(self):
# test_str = unicode("✄", "utf-8")
test_str = u"✄"
name = Contact(first_name=test_str)
name.save()
name2 = Contact.objects.get(first_name=test_str)
self.assertEqual(name.first_name, name2.first_name)
def execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id)
else:
invite_attendee = InviteAttendee(unique_id=guid())
invite_attendee.name = self.name
invite_attendee.email = self.email
invite_attendee.phone = self.phone
contact = None
if self.user and self.unique_id:
contact = Contact.get_by_unique_id(self.unique_id)
elif self.user:
contact = Contact(unique_id=guid(), user=self.user)
# Here we update the contact with the appropiate Data
if contact:
invite_attendee.contact = contact.key
contact.name = self.name
contact.email = self.email
contact.phone = self.phone
contact.put()
invite = Invite.get_by_unique_id(self.invite_id)
invite_attendee.invite = invite.key
invite_attendee.put()
return invite_attendee.unique_id
def get_by_names(self, first_name, last_name):
'''Return contact that has the provided names. If no contact is found
with that id, return None.
'''
with sqlite3.connect(self.db_file) as connection:
cursor = connection.cursor()
cursor.execute(
'''
SELECT
id,
first_name,
last_name,
phone,
mail,
updated,
updated_date
FROM
contact
WHERE
first_name = ? AND last_name = ?
''', (first_name, last_name))
row = cursor.fetchone()
if row is not None:
contact = Contact(*row)
return contact
return row
def setUpClass(cls):
cls.test_agent = Contact("Test Agent", "Agent")
cls.test_insured = Contact("Test Insured", "Named Insured")
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = "Quarterly"
db.session.add(cls.policy)
db.session.commit()
cls.pa = PolicyAccounting(cls.policy.id)
