def test_post_filter(self):
# create company
c1 = Company(id=1,
company_name='Paint pods',
company_address='Boise',
company_zipcode='83706',
company_website='Paintteam.com',
company_phone_number='20867832',
company_email='*****@*****.**')
c2 = Company(id=2,
company_name='Bob Team',
company_address='Salt Lake City',
company_zipcode='81504',
company_website='Paintteam.com',
company_phone_number='2086783456',
company_email='*****@*****.**')
db.session.add(c1)
db.session.add(c2)
db.session.commit()
# create four users
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create services
s1 = Service(parent_id=1, title='plumbing')
s2 = Service(parent_id=2, title='electrical')
db.session.add(s1)
db.session.add(s2)
db.session.commit()
# create four posts
now = datetime.utcnow()
p1 = Post(body="post from john",
timestamp=now + timedelta(seconds=1),
service_id=1,
company_id=1)
p2 = Post(body="post from john",
timestamp=now + timedelta(seconds=1),
service_id=1,
company_id=1)
p3 = Post(body="Test post",
timestamp=now + timedelta(seconds=1),
service_id=2,
company_id=2)
p4 = Post(body="test post",
timestamp=now + timedelta(seconds=1),
service_id=2,
company_id=2)
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# check service_posts function
check1 = u1.filter_posts(1, "Boise", "None", "None")
# check that the correct posts are returned
self.assertEqual(check1.count(), 2)
def test_service_posts(self):
# create services
s1 = Service(parent_id=1, title='plumbing')
s2 = Service(parent_id=2, title='electrical')
db.session.add(s1)
db.session.add(s2)
db.session.commit()
# create four posts
now = datetime.utcnow()
p1 = Post(body="post from john",
timestamp=now + timedelta(seconds=1),
service_id=1)
p2 = Post(body="post from john",
timestamp=now + timedelta(seconds=1),
service_id=1)
p3 = Post(body="post from john",
timestamp=now + timedelta(seconds=1),
service_id=2)
db.session.add_all([p1, p2, p3])
db.session.commit()
# check service_posts function
check1 = s1.service_posts()
check2 = s2.service_posts()
# check that the correct posts are returned
self.assertEqual(check1.count(), 2)
self.assertEqual(check2.count(), 1)
def test_view_all(self):
"""Test if view all works"""
res1 = Service("maintenance", "request descriptions", "location", "1")
res1.add()
res2 = Service("maintenance", "request descriptions", "location", "1")
res2.add()
res = self.request.view_all()
count = len(res)
self.assertEqual(count, 2)
def setup(self):
super(TestGetService, self).setup()
now = pendulum.now('UTC')
with self.app.app_context():
db.session.add(Framework(
id=123,
name="expired",
slug="expired",
framework="g-cloud",
status="expired",
))
db.session.commit()
db.session.add(FrameworkLot(
framework_id=123,
lot_id=1
))
db.session.add(
Supplier(code=1, name=u"Supplier 1",
addresses=[Address(address_line="{} Dummy Street 1",
suburb="Dummy",
state="ZZZ",
postal_code="0000",
country='Australia')])
)
db.session.add(Service(service_id="123-published-456",
supplier_code=1,
updated_at=now,
created_at=now,
status='published',
data={'foo': 'bar'},
lot_id=1,
framework_id=1))
db.session.add(Service(service_id="123-disabled-456",
supplier_code=1,
updated_at=now,
created_at=now,
status='disabled',
data={'foo': 'bar'},
lot_id=1,
framework_id=1))
db.session.add(Service(service_id="123-enabled-456",
supplier_code=1,
updated_at=now,
created_at=now,
status='enabled',
data={'foo': 'bar'},
lot_id=1,
framework_id=1))
db.session.add(Service(service_id="123-expired-456",
supplier_code=1,
updated_at=now,
created_at=now,
status='enabled',
data={'foo': 'bar'},
lot_id=1,
framework_id=123))
db.session.commit()
def test_fetch_by_userid(self):
"""Test if filter by userid works"""
res1 = Service("maintenance", "request descriptions", "location", "1")
req = res1.add()
res2 = Service("maintenance", "request descriptions", "location", "1")
req = res2.add()
res = self.request.fetch_by_userid("1")
request_description = len(res)
self.assertEqual(request_description, 2)
def test_add_existing_user_to_another_service_doesnot_change_old_permissions(
notify_db_session, ):
user = create_user()
service_one = Service(
name="service_one",
email_from="service_one",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(service_one, user)
assert user.id == service_one.users[0].id
test_user_permissions = Permission.query.filter_by(service=service_one,
user=user).all()
assert len(test_user_permissions) == 8
other_user = User(
name="Other Test User",
email_address="*****@*****.**",
password="******",
mobile_number="+447700900987",
)
save_model_user(other_user)
service_two = Service(
name="service_two",
email_from="service_two",
message_limit=1000,
restricted=False,
created_by=other_user,
)
dao_create_service(service_two, other_user)
assert other_user.id == service_two.users[0].id
other_user_permissions = Permission.query.filter_by(service=service_two,
user=other_user).all()
assert len(other_user_permissions) == 8
other_user_service_one_permissions = Permission.query.filter_by(
service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 0
# adding the other_user to service_one should leave all other_user permissions on service_two intact
permissions = []
for p in ["send_emails", "send_texts", "send_letters"]:
permissions.append(Permission(permission=p))
dao_add_user_to_service(service_one, other_user, permissions=permissions)
other_user_service_one_permissions = Permission.query.filter_by(
service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 3
other_user_service_two_permissions = Permission.query.filter_by(
service=service_two, user=other_user).all()
assert len(other_user_service_two_permissions) == 8
def setup_class(cls):
app.config['SQLALLCHEMY_DATABASE_URI'] = 'sqlite://'
db.create_all()
u1 = User(username='******')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
s1 = Service(name='vision', version='v1', updated=datetime.utcnow())
s2 = Service(name='translate', version='v3', updated=datetime.utcnow())
db.session.add_all([u1, u2, u3, s1, s2])
db.session.commit()
def test_create_service(notify_db_session):
user = create_user()
create_letter_branding()
assert Service.query.count() == 0
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type="central",
created_by=user,
)
dao_create_service(service, user)
assert Service.query.count() == 1
service_db = Service.query.one()
assert service_db.name == "service_name"
assert service_db.id == service.id
assert service_db.email_from == "email_from"
assert service_db.research_mode is False
assert service_db.prefix_sms is True
assert service.active is True
assert user in service_db.users
assert service_db.organisation_type == "central"
assert service_db.crown is None
assert not service.letter_branding
assert not service.organisation_id
def create_service_model(user=None,
service_name="Test service",
restricted=False,
count_as_live=True,
research_mode=False,
active=True,
email_from=None,
prefix_sms=True,
message_limit=1000,
organisation_type='other',
go_live_user=None,
go_live_at=None,
crown=True,
organisation=None,
smtp_user=None):
service = Service(
name=service_name,
message_limit=message_limit,
restricted=restricted,
email_from=email_from if email_from else service_name.lower().replace(
' ', '.'),
created_by=user if user else create_user_model(),
prefix_sms=prefix_sms,
organisation_type=organisation_type,
go_live_user=go_live_user,
go_live_at=go_live_at,
crown=crown,
smtp_user=smtp_user,
organisation=organisation if organisation else Organisation(
id=uuid.uuid4(), name='sample organization'))
service.active = active
service.research_mode = research_mode
service.count_as_live = count_as_live
return service
def test_create_service_creates_a_history_record_with_current_data(
notify_db_session):
user = create_user()
create_letter_branding()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(service, user)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 1
service_from_db = Service.query.first()
service_history = Service.get_history_model().query.first()
assert service_from_db.id == service_history.id
assert service_from_db.name == service_history.name
assert service_from_db.version == 1
assert service_from_db.version == service_history.version
assert user.id == service_history.created_by_id
assert service_from_db.created_by.id == service_history.created_by_id
def test_fetch_by_id(self):
"""Test if the method finds the exactly specified id"""
res = Service("maintenance", "request descriptions", "location", "1")
req = res.add()
foundrequest = self.request.fetch_by_id(1)
self.assertEqual(foundrequest['id'], 1)
self.assertFalse(self.request.fetch_by_id(4), False)
def post():
host = request.remote_addr
port = request.get_json().get('port')
name = request.get_json().get('name')
service = Service.query.filter_by(name=name).first()
current_app.logger.info(
f"Searching for service {name}, result: {service}")
if not service:
current_app.logger.info(f"No service with name {name} "
f"were found. Creating new one")
service = Service(name)
db.session.add(service)
db.session.commit()
service = Service.query.filter_by(name=name).first()
instance = Instance(host, port, service.id)
# TODO: make error exception
db.session.add(instance)
db.session.commit()
return response(204)
def test_dao_fetch_service_creator(notify_db_session):
active_user_1 = create_user(email="*****@*****.**", state="active")
active_user_2 = create_user(email="*****@*****.**", state="active")
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=active_user_1,
)
dao_create_service(
service,
active_user_1,
service_permissions=[
SMS_TYPE,
EMAIL_TYPE,
INTERNATIONAL_SMS_TYPE,
],
)
service.created_by_id = active_user_2.id
service.name = "New Name"
dao_update_service(service)
assert Service.query.count() == 1
history_model = Service.get_history_model()
entries = history_model.query.all()
assert len(entries) == 2
assert entries[1].created_by_id == active_user_2.id
assert active_user_1 == dao_fetch_service_creator(service.id)
def create_service():
service_from_request = get_json_from_request('service')
validation_result, validation_errors = valid_service_submission(
service_from_request)
if not validation_result:
return jsonify(error="Invalid JSON",
error_details=validation_errors), 400
user = User.query.get(service_from_request['userId'])
if not user:
return jsonify(error="failed to create service - invalid user"), 400
try:
token = Token(token=uuid4(), type='client')
db.session.add(token)
db.session.flush()
service = Service(name=service_from_request['name'],
created_at=datetime.utcnow(),
token_id=token.id,
active=True,
restricted=True,
limit=current_app.config['MAX_SERVICE_LIMIT'])
service.users.append(user)
db.session.add(service)
db.session.commit()
return jsonify(service=service.serialize()), 201
except IntegrityError as e:
print(e.orig)
db.session.rollback()
abort(400, "failed to create service")
def test_should_reject_notification_if_job_id_not_on_service(notify_api, notify_db, notify_db_session, notify_config):
service = Service(
id=1000,
name="unrelated service",
created_at=datetime.now(),
active=True,
restricted=True,
limit=100
)
job = Job(id=1000, name="job test", created_at=datetime.now())
job.service = service
db.session.add(service)
db.session.add(job)
db.session.commit()
response = notify_api.test_client().post(
'/sms/notification',
headers={
'Authorization': 'Bearer 1234'
},
data=json.dumps({
"notification": {
"to": "+441234512345",
"message": "Some message",
"jobId": 1000
}
}),
content_type='application/json'
)
data = json.loads(response.get_data())
assert response.status_code == 400
assert data['error'] == 'Invalid job id for these credentials'
def get_list_service(quote_df, db):
li_no_service = [] #a enlever apres que ça marche
taille = len(quote_df)
for i, tup in enumerate(quote_df.itertuples()):
if i % 10 == 0:
print(f"{i} / {taille} service processed")
company = Company.query.filter_by(company_name=tup.nom_entreprise)
if company.count() == 1:
service_params = {'companies': company.all()}
li_label = []
for lab_serv in tup.type_prestation.split(','):
label_service = Label_service.query.filter_by(label=lab_serv)
if label_service.count() != 1:
label_service = Label_service(label=lab_serv)
li_label.append(label_service)
else:
li_label.append(label_service.first())
service_params['label_services'] = li_label
quote = Quote.query.filter_by(ref_quote=tup.ref_devis)
if quote.count() != 0:
service_params['quotes'] = quote.all()
service = Service(**service_params)
db.session.add(service)
db.session.commit()
else: # ?? si pas compagnie on ajoute pas ?
li_no_service.append({
'nb_comp': company.count(),
'nom_entreprise': tup.nom_entreprise,
'ref_quote': tup.ref_devis,
})
return li_no_service #a enlever apres que ça marche
def test_is_owner(self):
"""Test if reuest belong to a user"""
res = Service("maintenance", "request descriptions", "location", "1")
req = res.add()
foundrequest = self.request.is_owner(1, 1)
self.assertEqual(foundrequest, True)
self.assertFalse(self.request.is_owner(1, 2), False)
def get_request(reqid):
if request.method == 'PUT':
request_details = request.get_json()
check_details = validdate_req_data(request_details)
if check_details is not "valid":
return jsonify({"message": check_details}), 400
else:
if requestObj.fetch_by_id(reqid) is False:
return jsonify({"message": "The request doesnt exist"}), 404
else:
if requestObj.is_owner(reqid, g.userid) is False:
return jsonify({"message": "Sorry you cant edit this request"}), 401
else:
try:
category = request_details['category']
description = request_details['description']
location = request_details['location']
req = Service(category, location, description, g.userid)
res = req.update(reqid)
return jsonify({"message": "Update succesfful", "response": res}), 201
except Exception as error:
# an error occured when trying to update request
response = {'message': str(error)}
return jsonify(response), 401
item = requestObj.fetch_by_id(reqid)
if item is False:
return jsonify({"message": "The request doesnt exist"}), 404
else:
return jsonify(item), 200
def notify_service(notify_db, notify_db_session):
user = create_user()
service = Service.query.get(current_app.config['NOTIFY_SERVICE_ID'])
if not service:
service = Service(
name='Notify Service',
message_limit=1000,
restricted=False,
email_from='notify.service',
created_by=user,
prefix_sms=False,
)
dao_create_service(service=service,
service_id=current_app.config['NOTIFY_SERVICE_ID'],
user=user)
data = {
'service': service,
'email_address': "*****@*****.**",
'is_default': True,
}
reply_to = ServiceEmailReplyTo(**data)
db.session.add(reply_to)
db.session.commit()
return service, user
def setservice(json):
service = Service.query.filter_by(
date=datetime.datetime.now().date()).first()
if not service:
service = Service()
if all(i in json and json[i] for i in
["sandwich1", "sandwich2", "sandwich3", "commi1", "commi2"]):
for i in [["sandwich1", "sandwich1_id"], ["sandwich2", "sandwich2_id"],
["sandwich3", "sandwich3_id"], ["commi1", "commi1_id"],
["commi2", "commi2_id"]]:
setattr(service, i[1],
User.query.filter_by(username=json[i[0]]).first().id)
else:
dummy = User.query.filter_by(username="******").first().id
for i in [
"sandwich1_id", "sandwich2_id", "sandwich3_id", "commi1_id",
"commi2_id"
]:
setattr(service, i[1], dummy)
service.sandwich1 = False
service.sandwich2 = False
service.sandwich3 = False
if not service.date:
db.session.add(service)
db.session.commit()
lsservice(broadcast=True)
def setup_service(db_session,
service_name="Sample service",
user=None,
restricted=False,
limit=1000,
email_from=None,
permissions=None,
research_mode=None):
if user is None:
user = create_user()
if email_from is None:
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': limit,
'restricted': restricted,
'email_from': email_from,
'created_by': user,
'crown': True
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=permissions)
if research_mode:
service.research_mode = research_mode
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_update_service_creates_a_history_record_with_current_data(notify_db_session):
user = create_user()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
dao_create_service(service, user)
assert Service.query.count() == 1
assert Service.query.first().version == 1
assert Service.get_history_model().query.count() == 1
service.name = 'updated_service_name'
dao_update_service(service)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 2
service_from_db = Service.query.first()
assert service_from_db.version == 2
assert Service.get_history_model().query.filter_by(name='service_name').one().version == 1
assert Service.get_history_model().query.filter_by(name='updated_service_name').one().version == 2
def test_create_service_with_organisation(notify_db_session):
user = create_user(email='*****@*****.**')
organisation = create_organisation(
name='Some local authority', organisation_type='local', domains=['local-authority.gov.uk'])
assert Service.query.count() == 0
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type='central',
created_by=user)
dao_create_service(service, user)
assert Service.query.count() == 1
service_db = Service.query.one()
organisation = Organisation.query.get(organisation.id)
assert service_db.name == "service_name"
assert service_db.id == service.id
assert service_db.email_from == 'email_from'
assert service_db.research_mode is False
assert service_db.prefix_sms is True
assert service.active is True
assert user in service_db.users
assert service_db.organisation_type == 'local'
assert service_db.crown is None
assert not service.letter_branding
assert service.organisation_id == organisation.id
assert service.organisation == organisation
def post(self, id):
service = Service(name=api.payload['name'],
category=api.payload['category'],
company_id=id)
db.session.add(service)
db.session.commit()
return api.payload
def test_create_nhs_service_get_default_branding_based_on_email_address(
notify_db_session,
branding_name_to_create,
expected_branding,
email_address,
organisation_type,
):
user = create_user(email=email_address)
letter_branding = create_letter_branding(name=branding_name_to_create)
email_branding = create_email_branding(name=branding_name_to_create)
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type=organisation_type,
created_by=user,
)
dao_create_service(service, user)
service_db = Service.query.one()
if expected_branding:
assert service_db.letter_branding == letter_branding
assert service_db.email_branding == email_branding
else:
assert service_db.letter_branding is None
assert service_db.email_branding is None
def init_services() -> None:
""" services table init """
project_backend = get_cwd()
service_path = os.path.join(project_backend, 'config/base/services.yml')
if not os.path.isfile(service_path):
raise RuntimeError(f"The file {service_path} does not exist.")
with open(service_path, 'r', encoding='utf-8') as load_file:
service_data = yaml.load(load_file, Loader=FullLoader)
query_service_dict = dict(
db.session.query(Service.code, Service).all()
)
for code, service_values in service_data.items():
if query_service_dict.get(code):
query_service = query_service_dict.get(code)
for key, value in service_values.items():
if hasattr(query_service, key):
setattr(query_service, key, value)
else:
service = Service()
for key, value in service_values.items():
if hasattr(service, key):
setattr(service, key, value)
db.session.add(service)
db.session.commit()
info = "services table init successfully!"
print(info)
def sample_broadcast_service(notify_db_session, broadcast_organisation):
user = create_user()
service_name = 'Sample broadcast service'
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': 1000,
'restricted': False,
'email_from': email_from,
'created_by': user,
'crown': True,
'count_as_live': False,
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=[BROADCAST_TYPE])
insert_or_update_service_broadcast_settings(service, channel="severe")
dao_add_service_to_organisation(service, current_app.config['BROADCAST_ORGANISATION_ID'])
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def insert_service():
service = Service(
name='Richmond Clinic'
)
db.session.add(service)
db.session.commit()
return service
def create_service(
user=None,
service_name="Sample service",
service_id=None,
restricted=False,
service_permissions=[EMAIL_TYPE, SMS_TYPE],
research_mode=False,
active=True,
email_from=None,
prefix_sms=True,
message_limit=1000,
organisation_type='central'
):
service = Service(
name=service_name,
message_limit=message_limit,
restricted=restricted,
email_from=email_from if email_from else service_name.lower().replace(' ', '.'),
created_by=user or create_user(email='{}@digital.cabinet-office.gov.uk'.format(uuid.uuid4())),
prefix_sms=prefix_sms,
organisation_type=organisation_type
)
dao_create_service(service, service.created_by, service_id, service_permissions=service_permissions)
service.active = active
service.research_mode = research_mode
return service
def test_service_add_company(self):
# create service
s1 = Service(parent_id=1, title='plumbing')
s2 = Service(parent_id=2, title='electrical')
db.session.add(s1)
db.session.add(s2)
db.session.commit()
# create company
c1 = Company(company_name='Paint Team',
company_address='123 Main St.',
company_website='Paintteam.com',
company_phone_number='2086783456',
company_email='*****@*****.**')
c2 = Company(company_name='Bob Team',
company_address='123 Main St.',
company_website='Paintteam.com',
company_phone_number='2086783456',
company_email='*****@*****.**')
db.session.add(c1)
db.session.add(c2)
db.session.commit()
# add company to service
check1 = s1.add_company(c1)
db.session.commit()
check2 = s2.add_company(c1)
db.session.commit()
# check that the connection was made
self.assertEqual(c1.services.count(), 2)
self.assertEqual(s1.companies.first().company_name, 'Paint Team')
self.assertEqual(c1.services.first().id, 1)
print(c1.services.first().id)
# remove companies
check3 = s2.remove_company(c1)
# check that it was removed
self.assertEqual(c1.services.count(), 1)
# add services to company
check4 = c2.services.append(s1)
# check that the connection was made
self.assertEqual(c2.services.count(), 1)
self.assertEqual(c2.services.first().title, 'plumbing')
