def test_feed_stream_tickets_preferences_enabled(c):
c.get('/pull', follow_redirects=True) # NOTE: initial pull to fill stacks
display_settings = Display_store.query.first()
display_settings.prefix = True
display_settings.always_show_ticket_number = True
display_settings.tmp = 3
db.session.commit()
tickets = Serial.get_waiting_list_tickets(limit=8)
processed_tickets = Serial.get_processed_tickets(limit=8, offset=1)
current_ticket = Serial.get_last_pulled_ticket()
response = c.get('/feed', follow_redirects=True)
assert response.status == '200 OK'
assert response.json.get('con') == current_ticket.office.display_text
assert response.json.get('cott') == current_ticket.task.name
assert response.json.get('cot') == current_ticket.display_text
for i, ticket in enumerate(tickets):
assert ticket.name in response.json.get(f'w{i + 1}')
assert f'{ticket.office.prefix}{ticket.number}' in response.json.get(f'w{i + 1}')
for i, ticket in enumerate(processed_tickets):
assert ticket.name in response.json.get(f'p{i + 1}')
assert f'{ticket.office.prefix}{ticket.number}' in response.json.get(f'p{i + 1}')
def test_feed_office_with_preferences_enabled(c):
c.get('/pull', follow_redirects=True) # NOTE: initial pull to fill stacks
with c.application.app_context():
# NOTE: enable settings to always display ticket number and prefix
display_settings = Display_store.query.first()
display_settings.prefix = True
display_settings.always_show_ticket_number = True
db.session.commit()
current_ticket = Serial.get_last_pulled_ticket()
tickets = Serial.get_waiting_list_tickets(
office_id=current_ticket.office.id, limit=8)
response = c.get(f'/feed/{current_ticket.office.id}',
follow_redirects=True)
assert response.status == '200 OK'
assert response.json.get('con') == current_ticket.office.display_text
assert response.json.get('cott') == current_ticket.task.name
assert response.json.get('cot') == current_ticket.display_text
for i, ticket in enumerate(tickets):
assert ticket.name in response.json.get(f'w{i + 1}')
assert f'{ticket.office.prefix}{ticket.number}' in response.json.get(
f'w{i + 1}')
def test_delete_ticket(c):
ticket = Serial.all_clean().first()
auth_token = AuthTokens.get()
response = c.delete(f'{BASE}/{ticket.id}',
follow_redirects=True,
headers={'Authorization': auth_token.token})
assert response.status == '204 NO CONTENT'
assert response.data == b''
assert Serial.get(ticket.id) is None
def test_get_ticket(c):
ticket = Serial.all_clean().first()
auth_token = AuthTokens.get()
response = c.get(f'{BASE}/{ticket.id}',
follow_redirects=True,
headers={'Authorization': auth_token.token})
assert response.status == '200 OK'
assert Serial.get(response.json.get('id')).id == ticket.id
assert all(p in response.json for p in get_module_columns(Serial)) is True
def test_update_ticket(c):
ticket = Serial.all_clean().first()
new_name = 'new testing name'
auth_token = AuthTokens.get()
response = c.put(f'{BASE}/{ticket.id}',
follow_redirects=True,
headers={'Authorization': auth_token.token},
json={'name': new_name})
assert response.status == '200 OK'
assert Serial.get(response.json.get('id')).name == new_name
assert all(p in response.json for p in get_module_columns(Serial)) is True
def test_pull_tickets_from_all(_, c):
ticket_to_be_pulled = do_until_truthy(
fill_tickets, lambda: Serial.query.order_by(Serial.number).filter(
Serial.number != 100, Serial.p != True).first())
response = c.get(f'/pull', follow_redirects=True)
assert response.status == '200 OK'
assert ticket_to_be_pulled is not None
assert ticket_to_be_pulled.p is False
assert Serial.get(
ticket_to_be_pulled.id).number == ticket_to_be_pulled.number
assert Serial.get(ticket_to_be_pulled.id).p is True
def test_update_ticket(c):
ticket = Serial.get()
if not ticket.p:
ticket.pull(ticket.office.id)
assert ticket.status != TICKET_UNATTENDED
c.post(f'/serial_u/{ticket.id}/testing',
data={
'value': ticket.name,
'printed': not ticket.n,
'status': TICKET_UNATTENDED
})
assert Serial.get(ticket.id).status == TICKET_UNATTENDED
def test_update_common_task_offices(c):
task = Task.get_first_common()
unchecked_office = task.offices[0]
checked_office = task.offices[1]
unchecked_office_tickets_numbers = [
ticket.number for ticket in Serial.all_clean().filter_by(
task_id=task.id, office_id=unchecked_office.id)
]
old_name = task.name
new_name = f'{uuid4()}'.replace('-', '')
c.post(f'/task/{task.id}',
data={
'name': new_name,
f'check{checked_office.id}': True
},
follow_redirects=True)
updated_task = Task.query.filter_by(name=new_name).first()
assert Task.query.filter_by(name=old_name).first() is None
assert updated_task is not None
assert len(task.offices) >= len(updated_task.offices)
assert checked_office.id in ids(updated_task.offices)
assert unchecked_office.id not in ids(updated_task.offices)
# Test unchecked office tickets were migrated
for number in unchecked_office_tickets_numbers:
ticket = Serial.query.filter_by(number=number).first()
assert ticket is not None
assert ticket.office_id != unchecked_office.id
def main():
tickets = Serial.all_clean()
number_of_tickets = tickets.count()
if number_of_tickets:
tickets.delete()
db.session.commit()
self.log(f'DeleteTickets(Task): {number_of_tickets} deleted.')
def get(self):
''' Pull a ticket from the waiting list. '''
ticket_id = request.args.get('ticket_id', None, type=int)
office_id = request.args.get('office_id', None, type=int)
ticket = Serial.get(ticket_id)
if ticket_id and not ticket:
abort(message='Ticket not found', code=HTTPStatus.NOT_FOUND)
next_ticket = ticket or Serial.get_next_ticket()
if not next_ticket:
abort(message='No tickets left to pull',
code=HTTPStatus.NOT_FOUND)
next_ticket.pull(office_id, self.auth_token and self.auth_token.id)
return next_ticket, HTTPStatus.OK
def test_delete_all_tickets(c):
auth_token = AuthTokens.get()
response = c.delete(f'{BASE}',
follow_redirects=True,
headers={'Authorization': auth_token.token})
assert response.status == '204 NO CONTENT'
assert response.data == b''
assert Serial.all_clean().count() == 0
def test_new_printed_ticket_with_aliases(c, monkeypatch):
last_ticket = None
mock_printer = MagicMock()
monkeypatch.setattr(escpos.printer, 'Usb', mock_printer)
# NOTE: set ticket setting to printed
printer_settings = Printer.get()
touch_screen_settings = Touch_store.get()
touch_screen_settings.n = False
printer_settings.vendor = 150
printer_settings.product = 3
printer_settings.in_ep = 170
printer_settings.out_ep = 170
# NOTE: setting aliases
office_alt = 'Department'
task_alt = 'Mission'
ticket_alt = 'Token'
aliases = Aliases.get()
aliases.office = office_alt
aliases.task = task_alt
aliases.ticket = ticket_alt
db.session.commit()
task = choice(Task.query.all())
last_ticket = Serial.query.filter_by(task_id=task.id)\
.order_by(Serial.number.desc()).first()
name = 'TESTING PRINTED TICKET'
response = c.post(f'/serial/{task.id}',
data={'name': name},
follow_redirects=True)
new_ticket = Serial.query.filter_by(task_id=task.id)\
.order_by(Serial.number.desc()).first()
office = new_ticket.office
tickets = Serial.all_office_tickets(office.id, desc=False)\
.filter(Serial.number != new_ticket.number)
cur_ticket = tickets.first()
assert response.status == '200 OK'
assert last_ticket.number != new_ticket.number
assert new_ticket.name == name
assert mock_printer().text.call_count == 12
assert mock_printer().set.call_count == 7
mock_printer().set.assert_called_with(align='left', height=1, width=1)
mock_printer().cut.assert_called_once()
mock_printer().text.assert_any_call(
f'\n{office_alt} : {office.prefix}{office.name}\n')
mock_printer().text.assert_any_call(
f'\n{office.prefix}.{new_ticket.number}\n')
mock_printer().text.assert_any_call(
f'\n{ticket_alt}s ahead : {tickets.count()}\n')
mock_printer().text.assert_any_call(
f'\n{task_alt} : {new_ticket.task.name}\n')
mock_printer().text.assert_any_call(
f'\nCurrent {ticket_alt.lower()} : {office.prefix}.{cur_ticket and cur_ticket.number}\n'
)
def test_pull_ticket(c):
auth_token = AuthTokens.get()
response = c.get(f'{BASE}/pull',
follow_redirects=True,
headers={'Authorization': auth_token.token})
ticket = Serial.get(response.json.get('id'))
assert response.status == '200 OK'
assert ticket is not None
assert ticket.p is True
assert all(p in response.json for p in get_module_columns(Serial)) is True
def put(self, ticket_id):
''' Update a specific ticket. '''
ticket = Serial.get(ticket_id)
if not ticket:
abort(message='Ticket not found', code=HTTPStatus.NOT_FOUND)
api.payload.pop('id', '')
ticket.query.update(api.payload)
db.session.commit()
return ticket, HTTPStatus.OK
def fill_tickets(entry_number=ENTRY_NUMBER * 2):
for _ in range(entry_number):
last_ticket = Serial.query.order_by(Serial.number.desc()).first()
number = (last_ticket.number if last_ticket else 100) + 1
name = choice(NAMES)
task = choice(Task.query.all())
office = choice(task.offices)
db.session.add(Serial(number=number, office_id=office.id,
task_id=task.id, name=name, n=True))
db.session.commit()
def get(self):
''' Get list of tickets. '''
chunk = request.args.get('chunk', 1, type=int)
processed = request.args.get('processed', False, type=bool)
tickets = Serial.all_clean()
if processed:
tickets = tickets.filter_by(p=True)
return tickets.paginate(chunk,
per_page=LIMIT_PER_CHUNK,
error_out=False).items, HTTPStatus.OK
def test_list_tickets(c):
auth_token = AuthTokens.get()
response = c.get(BASE,
follow_redirects=True,
headers={'Authorization': auth_token.token})
assert response.status == '200 OK'
assert len(response.json) > 0
assert LIMIT_PER_CHUNK > len(response.json)
for t in response.json:
assert Serial.get(t.get('id')) is not None
assert all(p in t for p in get_module_columns(Serial)) is True
def test_list_office(c):
office = choice(Office.query.all())
tickets = Serial.all_office_tickets(office.id)\
.filter(Serial.number != 100)\
.order_by(Serial.p, Serial.timestamp.desc())\
.limit(10)
response = c.get(f'/offices/{office.id}', follow_redirects=True)
page_content = response.data.decode('utf-8')
assert response.status == '200 OK'
for ticket in tickets:
assert f'<b> {office.prefix}{ticket.number}.</b>' in page_content
def test_list_office_with_common_task(c):
with c.application.app_context():
task = Task.get_first_common()
office = choice(task.offices)
tickets = Serial.all_office_tickets(office.id)\
.filter(Serial.number != 100)\
.order_by(Serial.p, Serial.timestamp.desc())\
.limit(10)
response = c.get(f'/offices/{office.id}', follow_redirects=True)
page_content = response.data.decode('utf-8')
assert response.status == '200 OK'
for ticket in tickets:
assert f'<b> {office.prefix}{ticket.number}.</b>' in page_content
def test_background_tasks_delete_tickets(c, get_bg_task):
task_enabled = True
task_every = 'second'
task_time = None
response = c.post('/background_tasks', data={
'cache_tts_enabled': False,
'cache_tts_every': 'second',
'delete_tickets_enabled': task_enabled,
'delete_tickets_every': task_every,
'delete_tickets_time': task_time
}, follow_redirects=True)
task = get_bg_task('DeleteTickets')
assert response.status == '200 OK'
assert task.settings.enabled == task_enabled
assert task.settings.every == task_every
assert task.settings.time is None
assert Serial.all_clean().count() == 0
def test_single_row_feed(_, c):
if not Settings.get().single_row:
c.get('/settings/single_row', follow_redirects=True)
assert Settings.get().single_row is True
c.get(f'/pull', follow_redirects=True)
current_ticket = Serial.get_last_pulled_ticket(0)
expected_parameters = {
f'w{_index + 1}': f'{_index + 1}. {number}'
for _index, number in enumerate(
range(current_ticket.number + 1, current_ticket.number + 9))
}
response = c.get('/feed')
for key, value in expected_parameters.items():
assert response.json.get(key) == value
def test_pull_tickets_from_common_task(_, c):
settings = Settings.get()
settings.strict_pulling = False
db.session.commit()
task = Task.get_first_common()
office = choice(task.offices)
ticket_to_be_pulled = do_until_truthy(
fill_tickets, lambda: Serial.query.order_by(Serial.number).filter(
Serial.number != 100, Serial.p != True, Serial.task_id == task.id).
first())
response = c.get(f'/pull/{task.id}/{office.id}', follow_redirects=True)
pulled_ticket = Serial.get(ticket_to_be_pulled.id)
assert response.status == '200 OK'
assert ticket_to_be_pulled is not None
assert ticket_to_be_pulled.p is False
assert pulled_ticket is not None
assert pulled_ticket.task_id == task.id
assert pulled_ticket.office_id == office.id
def fill_tasks(entry_number=ENTRY_NUMBER):
for _ in range(entry_number):
name = f'TEST{randint(10000, 99999999)}'
offices = []
# First task will be uncommon task and the second is common
number_of_offices = 1 if _ == 0 else 2 if _ == 1 else choice(range(1, 5))
while number_of_offices > len(offices):
office = choice(Office.query.all())
if office not in offices:
offices.append(office)
task = Task(name)
db.session.add(task)
db.session.commit()
task.offices = offices
# Add tasks initial tickets
db.session.add(Serial(number=100, office_id=office.id, task_id=task.id))
db.session.commit()
def post(self):
''' Generate a new ticket. '''
registered = api.payload.get('n', False)
name_or_number = api.payload.get('name', None)
task = Task.get(api.payload.get('task_id', None))
office = Office.get(api.payload.get('office_id', None))
if not task:
abort(message='Task not found', code=HTTPStatus.NOT_FOUND)
if registered and not name_or_number:
abort(message='Name must be entered for registered tickets.',
code=HTTPStatus.NOT_FOUND)
ticket, exception = Serial.create_new_ticket(
task, office, name_or_number)
if exception:
abort(message=str(exception))
return ticket, HTTPStatus.OK
def test_generate_ticket(c):
name = 'new testing name'
task = Task.get()
office = task.offices[0]
auth_token = AuthTokens.get()
response = c.post(f'{BASE}',
follow_redirects=True,
headers={'Authorization': auth_token.token},
json={
'name': name,
'task_id': task.id,
'office_id': office.id
})
ticket = Serial.get(response.json.get('id'))
assert response.status == '200 OK'
assert ticket is not None
assert ticket.name == name
assert ticket.task_id == task.id
assert ticket.office_id == office.id
assert all(p in response.json for p in get_module_columns(Serial)) is True
def delete(self):
''' Delete all tickets. '''
Serial.all_clean().delete()
db.session.commit()
return '', HTTPStatus.NO_CONTENT
