def update_customer_credit(customer_id, credit_limit): """ search an existing customer by customer_id and update their credit limit or raise a ValueError exception if the customer does not exist """ try: with database.transaction(): a_customer = Customer.get(Customer.customer_id == customer_id) logger.info(f'Customer: {customer_id} credit limit is ' f'{a_customer.credit_limit}.') except (IndexError, ValueError, peewee.DoesNotExist): logger.info(f'Customer: {customer_id} not found.') database.close() return with database.transaction(): query = (Customer.update({ Customer.credit_limit: credit_limit }).where(Customer.customer_id == customer_id)) query.execute() a_customer = Customer.get(Customer.customer_id == customer_id) logger.info(f'Customer: {customer_id} credit limit is updated to ' f'{a_customer.credit_limit}.') database.close()
def add_customer(customer_id, customer_name, customer_lastname, customer_home_address, customer_phone_number, customer_email_address, customer_status, customer_credit_limit): '''Adds a customer to the database''' try: with database.transaction(): new_customer = Customer.create( customer_id=customer_id, name=customer_name, lastname=customer_lastname, home_address=customer_home_address, phone_number=customer_phone_number, email_address=customer_email_address, status=customer_status, credit_limit=customer_credit_limit) new_customer.save() logger.info('Database add successful') return new_customer except IntegrityError as i_e: logger.error(i_e) logger.info( 'Customer was not saved.' 'A customer with id of %s already exists.', customer_id) raise IntegrityError
def add_customer(**kwargs): """ This function will add a new customer to the sqlite3 database. keyword args to keep pylint happy are the following: customer_id, name, lastname, home_address, phone_number, email_address, status, credit_limit Ensure you application will create an empty database if one doesn’t exist when the app is first run. Call it customers.db """ try: database.connect() database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite with database.transaction(): new_cust = Customer.create( customer_id=kwargs['customer_id'], name=kwargs['name'], lastname=kwargs['lastname'], home_address=kwargs['home_address'], phone_info=kwargs['phone_number'], email_address=kwargs['email_address'], status=True if kwargs['status'] == 'Active' else False, credit_limit=kwargs['credit_limit']) new_cust.save() # logger.info('Database add successful') except KeyError: logger.error('kwargs not complete') raise ValueError except Exception as thrown_exception: logger.info('Error creating customer') logger.info(thrown_exception) logger.info('See how the database protects our data') finally: database.close()
def search_customer(customer_id): """ This function will return a dictionary object with name, lastname, email address and phone number of a customer or an empty dictionary object if no customer was found. """ ret_dict = {} try: database.connect() database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite with database.transaction(): cust = Customer.get(Customer.customer_id == customer_id) if cust is not None: ret_dict['name'] = cust.name ret_dict['lastname'] = cust.lastname ret_dict['email_address'] = cust.email_address ret_dict['phone_number'] = cust.phone_info logger.info('Database query successful') else: logger.error(f'Customer {customer_id} not found') raise ValueError except Exception as thrown_exception: logger.info(f'Error querying {customer_id}') logger.info(thrown_exception) logger.info('See how the database protects our data') finally: database.close() return ret_dict
def delete_customer(customer_id): '''Deletes a customer with the given customer id. Returns false if no delete happened.''' successful_delete = False with database.transaction(): cust = search_customer(customer_id) if cust is not None: successful_delete = cust.delete_instance() > 0 return successful_delete
def delete_customer(customer_id): """ Delete a customer from the database using customer_id """ logging.info("delete_customer()") # Try to find given customer in the database, just want to see logging error search_customer(customer_id) # Try to delete whether it is found or not with database.transaction(): Customer.delete_by_id(customer_id)
def update_customer_credit(customer_id, new_credit_limit): '''Updates the customer's credit limit''' cust = None with database.transaction(): cust = search_customer(customer_id) if cust is not None: cust.credit_limit = new_credit_limit cust.save() return cust
def delete_customer(customer_id): """ delete a customer from the database """ try: with database.transaction(): a_customer = Customer.get(Customer.customer_id == customer_id) a_customer.delete_instance() logger.info(f'Customer: {customer_id} deleted.') except peewee.DoesNotExist: logger.info(f'Customer: {customer_id} not found.') finally: database.close()
def list_active_customers(): """ return an integer with the number of customers whose status is currently active """ count = None with database.transaction(): count = Customer.select().where(Customer.active).count() logger.info(f'active customer count: {count}') database.close() return count
def delete_customer(customer_id): '''Deletes a customer with the given customer id. Returns false if no delete happened.''' successful_delete = False with database.transaction(): cust = search_customer(customer_id) if cust is not None: successful_delete = cust.delete_instance() > 0 logger.info('Customer %s was deleted.', customer_id) else: logger.info( 'Customer not deleted.' 'Customer with id %s could not be found.', customer_id) return successful_delete
def list_active_customers(): """ gets total number of active customers :return: (int) # of active customers """ with database.transaction(): query = (Customer.select(fn.COUNT( Customer.status).alias('count')).where( Customer.status == 'Active')) LOGGER.info(query) customer_count = [item.count for item in query] LOGGER.info('Number of active customers: %s', customer_count[0]) return customer_count[0]
def update_customer_credit(customer_id, new_credit_limit): '''Updates the customer's credit limit''' cust = None with database.transaction(): cust = search_customer(customer_id) if cust is not None: old_credit_limit = cust.credit_limit cust.credit_limit = new_credit_limit cust.save() logger.info('Customer %s credit was updated from %s to %s.', customer_id, old_credit_limit, new_credit_limit) else: logger.info( 'Customer credit not updated.' 'Customer with id %s could not be found.', customer_id) return cust
def add_customer(customer_id, customer_name, customer_lastname, customer_home_address, customer_phone_number, customer_email_address, customer_status, customer_credit_limit): '''Adds a customer to the database''' with database.transaction(): new_customer = Customer.create(customer_id=customer_id, name=customer_name, lastname=customer_lastname, home_address=customer_home_address, phone_number=customer_phone_number, email_address=customer_email_address, status=customer_status, credit_limit=customer_credit_limit) new_customer.save() logger.info('Database add successful') return new_customer
def search_customer(customer_id): """ Search for a customer in the database using customer_id """ logging.info("search_customer()") result = {} try: with database.transaction(): person = Customer.get_by_id(customer_id) result = { 'name': person.name, 'lastname': person.lastname, 'email_address': person.email_address, 'phone_number': person.phone_number } except DoesNotExist: logging.error( f"Can't find customer data with id = {customer_id} in the database." ) finally: return result
def add_customer(customer_id, name, last_name, home_address, phone_number, email_address, active, credit_limit): """ add a new customer to the database """ try: with database.transaction(): new_customer = Customer.create(customer_id=customer_id, name=name, last_name=last_name, home_address=home_address, phone_number=phone_number, email_address=email_address, active=active, credit_limit=credit_limit) new_customer.save() logger.info(f'Customer {customer_id} add successful') except (peewee.IntegrityError, peewee.OperationalError): logger.info(f'Error adding customer: {customer_id}') finally: database.close()
def update_customer_credit(customer_id, credit_limit): """ This function will search an existing customer by customer_id and update their credit limit or raise a ValueError exception if the customer does not exist. The credit limit stored in the database is returned as a float. The value is 0.0 if the customer_id is not valid. The value is the current value in the database if it _cannot_ be updated, else it is the updated value stored in the databsae """ ret_credit = float(0.0) if credit_limit < 0.0: logger.info(f'Error setting credit limit for {customer_id}') logger.info(f'Credit limit is below 0: {credit_limit}') raise ValueError try: database.connect() database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite with database.transaction(): cust = Customer.get(Customer.customer_id == customer_id) if cust is not None: ret_credit = cust.credit_limit logger.info(f'Updating credit limit from {cust.credit_limit} \ to {credit_limit}') cust.credit_limit = credit_limit ret_credit = cust.credit_limit cust.save() logger.info('Database update successful') else: logger.error(f'Customer {customer_id} not found') raise ValueError except Exception as thrown_exception: logger.info(f'Error querying {customer_id}') logger.info(thrown_exception) logger.info('See how the database protects our data') finally: database.close() return ret_credit
def update_customer(customer_id, credit_limit): """ update customer credit limit by customer id :return: """ try: with database.transaction(): customer_update = Customer.get(Customer.customer_id == customer_id) LOGGER.info('Current limit: %s', customer_update.credit_limit) customer_update.credit_limit = credit_limit LOGGER.info('New credit limit: %s', customer_update.credit_limit) return True except DoesNotExist as err: LOGGER.warning('Customer ID: %s does not exist', customer_id) LOGGER.warning(err) return False
def add_customer(customer_id, firstname, lastname, address, phone, email, status, credit_limit): ''' Add customer to database, handle several peewee exceptions in the event of an error. Args: customer_id (str): Unique customer id (5 characters) firstname (str): Customer's first name lastname (str): Customer's last name address (str): Customer's address phone (str): Customer's phone number (format XXX-XXX-XXXX) email (str): Customer's email address status (boolean): Customer's status (active or not) credit_limit (float): Customer's credit limit in dollars ''' try: with database.transaction(): new_customer = Customer.create( id=customer_id, firstname=firstname, lastname=lastname, address=address, phone=phone, email=email, status=status, credit_limit=credit_limit) new_customer.save() LOGGER.info('Database add successful') except (OperationalError, IntegrityError, DoesNotExist) as exc: LOGGER.info(f'Error creating entry for customer {customer_id}, see error below') LOGGER.info(exc)
def delete_customer(customer_id): """ This function will delete the record of a customer matching customer_id """ try: database.connect() database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite with database.transaction(): cust = Customer.get(Customer.customer_id == customer_id) if cust is not None: cust.delete_instance() logger.info('Database delete successful') else: logger.error(f'Customer {customer_id} not found') raise ValueError except Exception as thrown_exception: logger.info(f'Error getting {customer_id}') logger.info(thrown_exception) logger.info('See how the database protects our data') finally: database.close()
def search_customer(customer_id): """ look up a customer and return a dictionary object with customer information or an empty dictionary object if no customer was found """ customer_info = {} try: with database.transaction(): a_customer = Customer.get(Customer.customer_id == customer_id) customer_info['name'] = a_customer.name customer_info['last name'] = a_customer.last_name customer_info['email address'] = a_customer.email_address customer_info['phone number'] = a_customer.phone_number logger.info(f'Customer: {customer_id} info returned.') except peewee.DoesNotExist: logger.info(f'Customer: {customer_id} not found.') finally: database.close() return customer_info
def add_customer(customer_id, first, last, addr, phone, email, status, limit): """ adds a new customer to Customer table :return: Customer table """ try: LOGGER.info('Creating customer record') with database.transaction(): new_customer = Customer.create(customer_id=customer_id, first_name=first, last_name=last, home_address=addr, phone_number=phone, email_address=email, status=status, credit_limit=limit) new_customer.save() LOGGER.info('Added customer: %s', new_customer.customer_id) except IntegrityError as err: LOGGER.warning('Error creating = ID: %s', customer_id) LOGGER.warning(err) return Customer
def customer_generator(): """ generator to get one customer at a time """ with database.transaction(): all_customers = Customer.select() for customer in all_customers: yield customer