def find(string):
global address_book
res = AddressBook()
for key, value in address_book.items():
if value.search(string):
res[key] = value
if not res:
return 'wrong command! Try again, please!'
return res
class TestAddressBook:
client = mysql.connector.connect(host="localhost",
user="******",
password="******",
database="address_book_new")
mycursor = client.cursor()
address_book = AddressBook()
def test_create_table(self):
"""
:return: to check if table is created or not
"""
record_list = []
table_name = "contacts"
self.address_book.create_table()
self.mycursor.execute("SHOW TABLES")
record = self.mycursor.fetchall()
for values in record:
record_list.append(values[0])
assert table_name in record_list, "Table not created"
def test_insert_values(self):
"""
:return: to check number of rows inserted
"""
result = self.address_book.insert_value_to_table()
assert result == 5, "Values not inserted"
def test_delete_row(self):
"""
:return: to check if row referenced is deleted or not
"""
name = "Hannah"
result = self.address_book.delete_row(name)
assert result == 1, "Row not deleted"
def test_update_row(self):
"""
:return: update a row
"""
result = self.address_book.update_row()
assert result == 1, "Field not updated"
def __init__(self, master, guiQueue):
'''
The class constructor for ConnectionManager. Sets up socket server,
broadcasting, and runs session_setup
:param MainWindow master: The master is the MainWindow object to send and receive messages with.
:param Queue guiQueue: The queue to write commands for the GUI code to.
'''
self.guiQueue = guiQueue
self.master = master
self.host = self.get_hostname()
self.port = 1298 #TCP and UDP server port.
self.username = ""
self.userList = AddressBook()
self.connections = {}
self.helpString = '''Available commands:
/help - Displays help information.
/ip - Displays ip address of this computer.
/join <username or ip> - Connects to specified username or ip.
/list - Shows a list of available users.
/quit - Ends current chat.
'''
#Create socket to listen for incoming connections
self.serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.serverSocket.bind((self.host, self.port))
self.serverSocket.listen(5)
#Open broadcast socket and start listening.
self.connections["Broadcast"] = Connection(
"Broadcast", UDPSocket(self.host, self.port), self)
self.connections["Broadcast"].start_listening()
#Begin session setup
self.listenerThread = threading.Thread(target=self.session_setup)
self.listenerThread.start()
#!/usr/bin/env python
# ProxyModel
# By Stefano Borini 2013. CC-SA
import sys
import os
sys.path.insert(
0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..",
"Common"))
from PyQt4 import QtCore, QtGui
from AddressBookCSV import AddressBookCSV
from AddressBookXML import AddressBookXML
from AddressBook import AddressBook
from AddressBookView import AddressBookView
app = QtGui.QApplication(sys.argv)
csv1_model = AddressBookCSV("../Common/file1.csv")
xml_model = AddressBookXML("../Common/file.xml")
csv2_model = AddressBookCSV("../Common/file2.csv")
address_book = AddressBook([csv1_model, xml_model, csv2_model])
view = AddressBookView(address_book)
view.show()
app.exec_()
from flask import Flask, redirect, url_for, request, render_template
from AddressBook import AddressBook
app = Flask(__name__)
AB = AddressBook()
@app.route('/')
def mainpage():
#- page
#- menu
#- creating, updating, searching and removing
contacts = AB.get_contacts()
return render_template('index.html', len=len(contacts), contacts=contacts)
@app.route('/create', methods=['POST'])
def create_record():
if request.method == 'POST':
AB.add_contact(request.form['name'], request.form['address'],
request.form['bday'], request.form['phone'],
request.form['email'], request.form['profession'],
request.form['interests'])
return redirect('/')
else:
return "Invalid reguest"
@app.route('/update/<int:id>')
def update_record(id):
if request.method == 'GET':
import pickle
from pathlib import Path
from Name import Name
from Phone import Phone
from Birthday import Birthday
from Record import Record
from AddressBook import AddressBook
end_cycle = False
address_book = AddressBook()
hello_func = lambda string: 'How can i help you?'
def serialize_pickle(address_book_path, address_book):
with open(address_book_path, 'wb') as fh:
pickle.dump(address_book, fh)
def deserialize_pickle(address_book_path):
with open(address_book_path, 'rb') as fh:
unpacked = pickle.load(fh)
return unpacked
#i don't use ValueError, because i want to allow use numbers as names for contact
def input_error(func):
def inner(string):
try:
return func(string)
def setUp(self):
self.ab = AddressBook();
from AddressBook import AddressBook
ad = AddressBook("AddressBook.txt")
ad.viewControls()
from AddressBook import AddressBook ab = AddressBook()
