class PoolInfo(TestCase):
def setUp(self):
user = User.objects.create_user(email='*****@*****.**', password='******')
pool = Pool(name='_Foo', user=user)
pool.save()
library_1 = Library.get_test_library('Library1')
library_2 = Library.get_test_library('Library2')
library_1.save()
library_2.save()
sample_1 = Sample.get_test_sample('Sample1')
sample_2 = Sample.get_test_sample('Sample2')
sample_1.save()
sample_2.save()
pool.libraries.add(library_1)
pool.samples.add(sample_1)
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(*[library_1, library_2])
self.request.samples.add(*[sample_1, sample_2])
def test_pool_info(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('pool_info'), {'pool_id': 1})
self.assertNotEqual(response.content, b'[]')
self.assertEqual(response.status_code, 200)
class GetAllLibrariesAdminTest(TestCase):
_is_staff = True
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**', password='******', is_staff=self._is_staff,
)
user.save()
library = Library.get_test_library('Library')
sample = Sample.get_test_sample('Sample')
library.save()
sample.save()
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
def test_get_all(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('library.get_all'))
self.assertEqual(response.status_code, 200)
self.assertNotEqual(response.content, b'[]')
def test_wrong_http_method(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('library.get_all'))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'[]')
class PoolInfo(TestCase):
def setUp(self):
user = User.objects.create_user(email='*****@*****.**', password='******')
pool = Pool(name='_Foo', user=user)
pool.save()
library_1 = Library.get_test_library('Library1')
library_2 = Library.get_test_library('Library2')
library_1.save()
library_2.save()
sample_1 = Sample.get_test_sample('Sample1')
sample_2 = Sample.get_test_sample('Sample2')
sample_1.save()
sample_2.save()
pool.libraries.add(library_1)
pool.samples.add(sample_1)
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(*[library_1, library_2])
self.request.samples.add(*[sample_1, sample_2])
def test_pool_info(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('pool_info'), {'pool_id': 1})
self.assertNotEqual(response.content, b'[]')
self.assertEqual(response.status_code, 200)
class GetAllLibrariesAdminTest(TestCase):
_is_staff = True
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_staff=self._is_staff,
)
user.save()
library = Library.get_test_library('Library')
sample = Sample.get_test_sample('Sample')
library.save()
sample.save()
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
def test_get_all(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('library.get_all'))
self.assertEqual(response.status_code, 200)
self.assertNotEqual(response.content, b'[]')
def test_wrong_http_method(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('library.get_all'))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'[]')
def create_library_preparation_obj(sample_name, user, sample_status):
sample = create_sample(sample_name, status=sample_status)
sample.save()
request = Request(user=user)
request.save()
request.samples.add(sample)
pool = create_pool(user)
pool.samples.add(sample)
return LibraryPreparation.objects.get(sample=sample)
def create_interview(request):
positions = PositionAll.objects.all()
existing_order = get_user_pending_order(request)
cart_amount = ''
if existing_order!=0:
cart_amount = existing_order.items.all().count()
else:
return redirect(reverse('candidate_cart:order_summary'))
if request.method == 'POST':
request_id = generate_request_id()
request_title = request.POST.get('request_title')
date_interview = request.POST.get('date_interview')
note_interview = request.POST.get('note_interview')
request_position_id = request.POST.get('request_position')
request_position_other = request.POST.get('request_position_other_name')
print(request_position_id,"||||||||||",request_position_other)
request_position = get_object_or_404(PositionAll, position_id=request_position_id)
user_profile = get_object_or_404(Profile, user=request.user)
user_order = Order.objects.get(owner=user_profile, is_ordered=False)
status = get_object_or_404(Status, status_id='1')
request_type = get_object_or_404(RequestType, request_type_id='2')
existing_order = get_user_pending_order(request)
if existing_order!=0:
request_interview = RequestInterview(order = user_order,date_interview = date_interview,note_interview =note_interview)
request_interview.save()
request_detail = Request(request_id=request_id,request_type=request_type,request_interview=request_interview,request_title=request_title,request_position=request_position,request_position_other=request_position_other,owner=user_profile,status=status)
request_detail.save()
# context = {
# 'order': existing_order,
# 'Cart_amount': cart_amount,
# }
#
# return render(request, 'create-interview.html', context)
return redirect(reverse('candidate_cart:update_interview',
kwargs={
'order_id': user_order.ref_code
})
)
context = {
'Positions' : positions,
'order': existing_order,
'Cart_amount': cart_amount,
}
return render(request, 'create-interview.html', context)
class GetAllLibraries(TestCase):
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**', password='******', is_staff=True,
)
user.save()
self.request = Request(user=user)
self.request.save()
def test_get_all(self):
self.client.login(email='*****@*****.**', password='******')
library = Library.get_test_library('Library1')
library.status = 1
library.save()
sample = Sample.get_test_sample('Sample1')
sample.status = 1
sample.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
response = self.client.get(reverse('library.get_all'), {
'quality_check': 'true'
})
self.assertEqual(response.status_code, 200)
self.assertNotEqual(response.content, b'[]')
def test_get_all_empty(self):
self.client.login(email='*****@*****.**', password='******')
library = Library.get_test_library('Library2')
library.save()
sample = Sample.get_test_sample('Sample2')
sample.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
response = self.client.get(reverse('library.get_all'), {
'quality_check': 'true'
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'[]')
class GetAllLibraries(TestCase):
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_staff=True,
)
user.save()
self.request = Request(user=user)
self.request.save()
def test_get_all(self):
self.client.login(email='*****@*****.**', password='******')
library = Library.get_test_library('Library1')
library.status = 1
library.save()
sample = Sample.get_test_sample('Sample1')
sample.status = 1
sample.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
response = self.client.get(reverse('library.get_all'),
{'quality_check': 'true'})
self.assertEqual(response.status_code, 200)
self.assertNotEqual(response.content, b'[]')
def test_get_all_empty(self):
self.client.login(email='*****@*****.**', password='******')
library = Library.get_test_library('Library2')
library.save()
sample = Sample.get_test_sample('Sample2')
sample.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
response = self.client.get(reverse('library.get_all'),
{'quality_check': 'true'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'[]')
def create_pooling_object(user,
save=True,
add_library=False,
add_sample=False,
sample_failed=False):
library = None
sample = None
if add_library:
library = create_library(get_random_name(), 2)
if add_sample:
sample = create_sample(get_random_name(), 2)
pool = create_pool(user)
request = Request(user=user)
request.save()
if library:
request.libraries.add(library)
pool.libraries.add(library)
pooling_object = Pooling.objects.get(library=library)
if sample:
request.samples.add(sample)
pool.samples.add(sample)
# Update the sample instance because after being added to the pool,
# it was modified
sample = sample.__class__.objects.get(pk=sample.pk)
if sample_failed:
sample.status = -1 # failed quality check
sample.save()
pooling_object = sample
else:
sample.status = 3 # passed quality check
sample.save()
pooling_object = Pooling.objects.get(sample=sample)
if save:
pooling_object.save()
return pooling_object
def test_multiple_sample_contains_invalid(self):
"""
Ensure get multiple samples containing invalid ids behaves correctly.
"""
sample = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(sample)
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample.pk, 'blah'])
})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'Invalid payload.')
class TestLibrarySampleTree(BaseTestCase):
""" Tests for the libraries and samples tree. """
def setUp(self):
user = self.create_user('*****@*****.**', 'foo-foo')
self.client.login(email='*****@*****.**', password='******')
library = create_library(self._get_random_name())
sample = create_sample(self._get_random_name())
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
def test_libraries_and_samples_list(self):
""" Ensure get all libraries and samples works correctly. """
response = self.client.get(reverse('libraries-and-samples-list'))
data = response.json()['children'][0]
self.assertEqual(response.status_code, 200)
self.assertIn(self.request.name, data['name'])
def test_multiple_samples(self):
""" Ensure get multiple samples behaves correctly. """
sample1 = create_sample(get_random_name())
sample2 = create_sample(get_random_name())
sample3 = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(*[sample1.pk, sample2.pk, sample3.pk])
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample1.pk, sample2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
samples = [x['name'] for x in data['data']]
self.assertIn(sample1.name, samples)
self.assertIn(sample2.name, samples)
self.assertNotIn(sample3.name, samples)
def index(request, lang):
data = {'lang': lang}
if lang not in LANGUAGES:
return render_to_response('client/404.html', {'data': data}, RequestContext(request))
contact_info = ContactInfo.objects.all()
if contact_info:
data['contact_info'] = contact_info[0]
comments = Comment.objects.filter(deleted=False).order_by('-date')
data['comments'] = comments
order = ''
if lang == 'es':
order = 'spanish_name'
elif lang == 'en':
order = 'english_name'
elif lang == 'de':
order = 'german_name'
elif lang == 'pt':
order = 'portuguese_name'
elif lang == 'fr':
order = 'french_name'
services_list = Service.objects.filter(deleted=False).order_by(order)
data['services'] = services_list
if request.method == 'POST':
if 'btn_comment' in request.POST:
content = request.POST['text_comment']
comment = Comment(content=content)
comment.save()
return HttpResponseRedirect('/services/' + lang)
elif 'btn_suggestion' in request.POST:
content = request.POST['text_suggestion']
suggestion = Suggestion(content=content)
suggestion.save()
return HttpResponseRedirect('/services/' + lang)
elif 'btn_request' in request.POST:
content = request.POST['request']
contact_info = request.POST['contact_info']
req = Request(content=content, contact_info=contact_info)
req.save()
return HttpResponseRedirect('/services/' + lang)
return render_to_response('client/main/index.html', {'data': data}, RequestContext(request))
def test_multiple_libraries(self):
""" Ensure get multiple libraries behaves correctly. """
library1 = create_library(get_random_name())
library2 = create_library(get_random_name())
library3 = create_library(get_random_name())
request = Request(user=self.user)
request.save()
request.libraries.add(*[library1.pk, library2.pk, library3.pk])
response = self.client.get(
reverse('libraries-list'), {
'request_id': request.pk,
'ids': json.dumps([library1.pk, library2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
libraries = [x['name'] for x in data['data']]
self.assertIn(library1.name, libraries)
self.assertIn(library2.name, libraries)
self.assertNotIn(library3.name, libraries)
def create_request(request):
# authenticate
if not check_logged_in(request):
return redirect('access_denied')
# get user
user = User.objects.get(id=request.session.get("user_id"))
# handle new requests
if request.method == 'GET':
context = {
'group_id': user.group.name,
'tags': [x.name for x in Tag.objects.all()],
}
return render(request, "request/create_request.html", context)
if request.method == 'POST':
try:
new_request = Request(
status=request.POST.get("requestStatus", None),
title=request.POST.get("request-title", None),
request_message=request.POST.get("request-message", None),
requester=user,
group=user.group,
response_message=request.POST.get("response-message", None),
)
new_request.clean()
new_request.save()
new_tags = [Tag.objects.get(name=tag_name) for tag_name in request.POST.getlist("details-tags", None)]
new_request.tags.set(new_tags)
return redirect('dashboard')
except ValidationError as error:
context = {
'group_id': user.group.name,
'tags': [x.name for x in Tag.objects.all()],
'error_message': error.message
}
return render(request, "request/create_request.html", context)
class TestSamples(BaseTestCase):
""" Tests for samples. """
def setUp(self):
self.user = self.create_user('*****@*****.**', 'foo-foo')
self.client.login(email='*****@*****.**', password='******')
self.sample = create_sample(self._get_random_name())
self.request = Request(user=self.user)
self.request.save()
self.request.samples.add(self.sample)
def test_single_sample(self):
""" Ensure get single sample behaves correctly. """
response = self.client.get(
reverse(
'samples-detail',
kwargs={'pk': self.sample.pk},
))
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertIn(self.sample.name, data['name'])
def test_single_sample_invalid_id(self):
""" Ensure error is thrown if the id does not exist. """
response = self.client.get(
reverse(
'samples-detail',
kwargs={'pk': -1},
))
self.assertEqual(response.status_code, 404)
def test_multiple_samples(self):
""" Ensure get multiple samples behaves correctly. """
sample1 = create_sample(get_random_name())
sample2 = create_sample(get_random_name())
sample3 = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(*[sample1.pk, sample2.pk, sample3.pk])
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample1.pk, sample2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
samples = [x['name'] for x in data['data']]
self.assertIn(sample1.name, samples)
self.assertIn(sample2.name, samples)
self.assertNotIn(sample3.name, samples)
def test_multiple_sample_contains_invalid(self):
"""
Ensure get multiple samples containing invalid ids behaves correctly.
"""
sample = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(sample)
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample.pk, 'blah'])
})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'Invalid payload.')
def test_add_sample(self):
""" Ensure add sample behaves correctly. """
name = self._get_random_name()
response = self.client.post(
reverse('samples-list'), {
'data':
json.dumps(
[{
'name': name,
'organism': self.sample.organism.pk,
'concentration': 1.0,
'concentration_method':
self.sample.concentration_method.pk,
'read_length': self.sample.read_length.pk,
'sequencing_depth': 1,
'library_protocol': self.sample.library_protocol.pk,
'library_type': self.sample.library_type.pk,
'nucleic_acid_type': self.sample.nucleic_acid_type.pk,
}])
})
data = response.json()
self.assertEqual(response.status_code, 201)
self.assertTrue(data['success'])
self.assertEqual(name, data['data'][0]['name'])
self.assertEqual('Sample', data['data'][0]['record_type'])
def test_add_sample_contains_invalid(self):
""" Ensure add sample containing invalid data behaves correctly. """
name = self._get_random_name()
response = self.client.post(
reverse('samples-list'), {
'data':
json.dumps(
[{
'name': name,
'organism': self.sample.organism.pk,
'concentration': 1.0,
'concentration_method':
self.sample.concentration_method.pk,
'read_length': self.sample.read_length.pk,
'sequencing_depth': 1,
'library_protocol': self.sample.library_protocol.pk,
'library_type': self.sample.library_type.pk,
'nucleic_acid_type': self.sample.nucleic_acid_type.pk,
}, {
'name': self._get_random_name(),
'concentration': 1.0,
'sequencing_depth': 1,
}])
})
data = response.json()
self.assertEqual(response.status_code, 201)
self.assertTrue(data['success'])
self.assertIn('Invalid payload. Some records cannot be added.',
data['message'])
self.assertEqual(len(data['data']), 1)
self.assertEqual(name, data['data'][0]['name'])
def test_add_sample_invalid_json(self):
""" Ensure error is thrown if the JSON object is empty. """
response = self.client.post(reverse('samples-list'), {})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertIn('Invalid payload.', data['message'])
def test_add_sample_invalid_data(self):
""" Ensure error is thrown if the JSON object contains invalid data."""
response = self.client.post(
reverse('samples-list'),
{'data': json.dumps([{
'name': self._get_random_name(),
}])})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertIn('Invalid payload.', data['message'])
def test_update_sample(self):
""" Ensure update sample behaves correctly. """
sample = create_sample(self._get_random_name())
new_name = self._get_random_name()
response = self.client.post(
reverse('samples-edit'), {
'data':
json.dumps(
[{
'pk': sample.pk,
'name': new_name,
'organism': sample.organism.pk,
'concentration': 1.0,
'concentration_method': sample.concentration_method.pk,
'read_length': sample.read_length.pk,
'sequencing_depth': 1,
'library_protocol': sample.library_protocol.pk,
'library_type': sample.library_type.pk,
'nucleic_acid_type': sample.nucleic_acid_type.pk,
}])
})
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()['success'])
self.assertEqual(Sample.objects.get(pk=sample.pk).name, new_name)
def test_update_sample_contains_invalid(self):
""" Ensure update sample containing invalid data behaves correctly. """
sample1 = create_sample(self._get_random_name())
sample2 = create_sample(self._get_random_name())
new_name1 = self._get_random_name()
new_name2 = self._get_random_name()
response = self.client.post(
reverse('samples-edit'), {
'data':
json.dumps(
[{
'pk': sample1.pk,
'name': new_name1,
'organism': sample1.organism.pk,
'concentration': 1.0,
'concentration_method':
sample1.concentration_method.pk,
'read_length': sample1.read_length.pk,
'sequencing_depth': 1,
'library_protocol': sample1.library_protocol.pk,
'library_type': sample1.library_type.pk,
'nucleic_acid_type': sample1.nucleic_acid_type.pk,
}, {
'pk': sample2.pk,
'name': new_name2,
'sample_id': sample2.pk,
'concentration': 1.0,
'sequencing_depth': 1,
}])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
self.assertIn('Invalid payload. Some records cannot be updated.',
data['message'])
self.assertEqual(Sample.objects.get(pk=sample1.pk).name, new_name1)
self.assertEqual(Sample.objects.get(pk=sample2.pk).name, sample2.name)
def test_delete_sample(self):
""" Ensure delete sample behaves correctly. """
sample = create_sample(self._get_random_name())
response = self.client.delete(
reverse(
'samples-detail',
kwargs={'pk': sample.pk},
))
self.assertEqual(response.status_code, 204)
def test_delete_sample_incorrect_id(self):
""" Ensure error is thrown if the id does not exist. """
response = self.client.delete(
reverse(
'samples-detail',
kwargs={'pk': -1},
))
self.assertEqual(response.status_code, 404)
def new_request_candidate(request):
# project_types = ProjectType.objects.all()
# levels = LevelRequest.objects.all()
positions = PositionAll.objects.all()
user = request.user
user_profile = Profile.objects.filter(user=user).first()
if has_role(user, 'hr'):
all_project = Project.objects.all()
else:
all_project = Project.objects.filter(owner=user_profile)
if request.method == 'POST':
request_id = generate_request_id()
print("request_id",request_id)
request_title = request.POST.get('request_title')
project_id = request.POST.get('project_name')
project = Project.objects.filter(id=project_id).first()
print(project_id,"project",project)
position_id = request.POST.get('position_name')
position = PositionField.objects.filter(id=position_id)
print(position_id,"position",position)
tor_employee_amount = position.first().position_tor_amount
empty_employee_amount = int(request.POST.get('empty_employee_amount'))
now_employee_amount = position.first().position_now_amount-empty_employee_amount
requirement = request.POST.get('requirement')
certification = request.POST.get('certification')
note = request.POST.get('note')
owner = get_object_or_404(Profile, user=request.user)
status = get_object_or_404(Status, status_id='1')
request_type = get_object_or_404(RequestType, request_type_id='1')
print(request_title,tor_employee_amount,empty_employee_amount,requirement,certification,note)
print(owner,status,request_type)
request_candidate = RequestCandidate(project=project,
position=position.first(),
tor_employee_amount=tor_employee_amount,
now_employee_amount=now_employee_amount,
empty_employee_amount = empty_employee_amount,
requirement=requirement,
certification=certification,
note=note,)
request_candidate.save()
print("now_employee_amount",int(now_employee_amount))
print(position.first().position_now_amount)
request_detail = Request(request_id=request_id,
request_type=request_type,
request_candidate=request_candidate,
request_title=request_title,
request_position=position.first().position_name,
owner=owner,status=status)
request_detail.save()
position.update(position_now_amount=int(now_employee_amount),
requirement=requirement,
certification=certification,
note=note,)
return redirect('request_candidate')
context = {
'AllProject' : all_project,
'Positions' : positions,
}
template = loader.get_template("create_new_request_candidate.html")
return HttpResponse(template.render(context, request))
def test_save_not_log_user(self):
user = get_user_model().objects.create(username='******')
request = Request(ip='1.2.3.4', user=user)
request.save()
self.assertIsNone(request.user)
def test_save_not_log_ip(self):
request = Request(ip='1.2.3.4')
request.save()
self.assertEqual(settings.REQUEST_IP_DUMMY, request.ip)
def tool_detail(request, id):
if not is_user_logged_in(session=request.session):
return redirect(reverse('sign_in'))
if 'is_shared_zone' not in request.session:
return redirect(reverse('shared_zone:index'))
if request.method == 'GET':
try:
tool = Tool.objects.get(id=id, enabled=1)
pickup_times = User.objects.filter(pk=tool.owner.id).values_list('pickup_days', 'pickup_times')
pickup_times = list(pickup_times)[0]
if pickup_times[0] is None or pickup_times[1] is None:
pickup_times = None
if tool.is_shared_from_home():
pickup_address = tool.owner.get_address()
else:
pickup_address = SharedZone.objects.get(zipcode=tool.owner.zipcode).address
may_leave_comment = False
if Request.objects.filter(borrower=request.session["cool_user"], tool=id, status=Request.RETURNED, may_leave_comment=True).count() > 0:
may_leave_comment = True
context = {
'pickup_address': pickup_address,
'tool': tool,
'borrow': True,
'pickup_times': pickup_times,
'id': id,
'may_leave_comment': may_leave_comment
}
if "format" in request.GET and request.GET["format"] == "json":
data = serializers.serialize("json", [tool])
if pickup_times:
pu_times = {
'days': pickup_times[0],
'hours': pickup_times[1],
}
else:
pu_times = None
response = {'statusCode': 200, 'message': 'OK', 'data': data, 'media': settings.MEDIA_URL, 'pickup_times': pu_times, 'pickup_address': pickup_address}
return JsonResponse(response)
except Tool.DoesNotExist:
context = {
"not_found": 'The item you requested does not exist',
'borrow': True,
'id': id
}
if "format" in request.GET and request.GET["format"] == "json":
response = {'statusCode': 404, 'message': 'The item you requested does not exist'}
return JsonResponse(response)
except Exception as e:
print(e)
if request.method == 'POST':
try:
tool = Tool.objects.get(pk=id, enabled=1)
borrower = User.objects.get(pk=request.session["cool_user"], enabled=1)
tool_request = Request(tool=tool, lender=tool.owner, borrower=borrower, zipcode=borrower.zipcode, shared_from=tool.shared_from)
success_message = "The tool has been requested successfully! Please wait for owner's approval."
if tool.shared_from == Tool.SHED:
tool_request.comment = "Borrowing request approved!"
success_message = "Borrowing request approved!"
tool_request.status = Request.APPROVED
tool.status = Tool.BORROWED
tool.save()
try:
request.session['notification_s'] += 1
except KeyError:
request.session['notification_s'] = 1
try:
optional = "Please return the tool as soon as you finish using it. Remind the shed coordinator to mark the tool as returned."
send_email('request_action.txt', 'request_action.html', {'tool_name': tool_request.tool.name, 'request_status': tool_request.get_status_choices(), 'message': tool_request.comment, 'optional': optional}, "Borrowing Request Information", tool_request.borrower.email)
except Exception as e:
print(e)
tool_request.save()
if tool_request.tool.shared_from == Tool.HOME:
try:
notification = Notification.objects.get(user=tool.owner)
except Notification.DoesNotExist:
notification = Notification(user=tool.owner)
notification.save()
notification.increment_received()
notification.save()
try:
send_email('borrowing_request.txt', 'borrowing_request.html', {'borrower': tool_request.borrower.__str__(), 'tool': tool_request.tool.name}, "Borrowing Request Information", tool_request.lender.email)
except Exception as e:
print(e)
context = {
'tool': tool,
'borrow': True,
'message': success_message,
'id': id
}
if "format" in request.POST and request.POST["format"] == "json":
response = {'statusCode': 200, 'message': success_message}
return JsonResponse(response)
except Tool.DoesNotExist:
context = {
"not_found": 'The item you requested does not exist',
'borrow': True,
'id': id
}
if "format" in request.POST and request.POST["format"] == "json":
response = {'statusCode': 404, 'message': 'The item you requested does not exist'}
return JsonResponse(response)
except Exception as e:
print(e)
context = {
'tool': tool,
'borrow': True,
'id': id
}
return render(request, 'tool_listing/tool_detail.html', context)
class TestLibraries(BaseTestCase):
""" Tests for libraries. """
def setUp(self):
self.user = self.create_user('*****@*****.**', 'foo-foo')
self.client.login(email='*****@*****.**', password='******')
self.library = create_library(self._get_random_name())
self.request = Request(user=self.user)
self.request.save()
self.request.libraries.add(self.library)
def test_single_library(self):
""" Ensure get single library behaves correctly. """
response = self.client.get(
reverse(
'libraries-detail',
kwargs={'pk': self.library.pk},
))
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertIn(self.library.name, data['name'])
def test_single_library_invalid_id(self):
""" Ensure error is thrown if the id does not exist. """
response = self.client.get(
reverse(
'libraries-detail',
kwargs={'pk': -1},
))
self.assertEqual(response.status_code, 404)
def test_multiple_libraries(self):
""" Ensure get multiple libraries behaves correctly. """
library1 = create_library(get_random_name())
library2 = create_library(get_random_name())
library3 = create_library(get_random_name())
request = Request(user=self.user)
request.save()
request.libraries.add(*[library1.pk, library2.pk, library3.pk])
response = self.client.get(
reverse('libraries-list'), {
'request_id': request.pk,
'ids': json.dumps([library1.pk, library2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
libraries = [x['name'] for x in data['data']]
self.assertIn(library1.name, libraries)
self.assertIn(library2.name, libraries)
self.assertNotIn(library3.name, libraries)
def test_multiple_libraries_contains_invalid(self):
"""
Ensure get multiple libraries containing invalid ids behaves correctly.
"""
library = create_library(get_random_name())
request = Request(user=self.user)
request.save()
request.libraries.add(library)
response = self.client.get(reverse('libraries-list'), {
'request_id': request.pk,
'ids': json.dumps([library.pk, 'blah'])
})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'Invalid payload.')
def test_add_library(self):
""" Ensure add library behaves correctly. """
library = create_library(self._get_random_name())
name = self._get_random_name()
response = self.client.post(
reverse('libraries-list'), {
'data':
json.dumps(
[{
'name': name,
'organism': library.organism.pk,
'concentration': 1.0,
'concentration_method':
library.concentration_method.pk,
'read_length': library.read_length.pk,
'sequencing_depth': 1,
'library_protocol': library.library_protocol.pk,
'library_type': library.library_type.pk,
'amplification_cycles': 1,
'index_type': library.index_type.pk,
'index_reads': 0,
'mean_fragment_size': 1,
}])
})
data = response.json()
self.assertEqual(response.status_code, 201)
self.assertTrue(data['success'])
self.assertEqual(name, data['data'][0]['name'])
self.assertEqual('Library', data['data'][0]['record_type'])
def test_add_library_contains_invalid(self):
""" Ensure add library containing invalid data behaves correctly. """
name = self._get_random_name()
response = self.client.post(
reverse('libraries-list'), {
'data':
json.dumps([
{
'name': name,
'organism': self.library.organism.pk,
'concentration': 1.0,
'concentration_method':
self.library.concentration_method.pk,
'read_length': self.library.read_length.pk,
'sequencing_depth': 1,
'library_protocol': self.library.library_protocol.pk,
'library_type': self.library.library_type.pk,
'amplification_cycles': 1,
'index_type': self.library.index_type.pk,
'index_reads': 0,
'mean_fragment_size': 1,
}, {
'name': self._get_random_name(),
'concentration': 1.0,
'sequencing_depth': 1,
'amplification_cycles': 1,
'index_reads': 0,
'mean_fragment_size': 1,
}
])
})
data = response.json()
self.assertEqual(response.status_code, 201)
self.assertTrue(data['success'])
self.assertIn('Invalid payload. Some records cannot be added.',
data['message'])
self.assertEqual(len(data['data']), 1)
self.assertEqual(name, data['data'][0]['name'])
def test_add_library_invalid_json(self):
""" Ensure error is thrown if the JSON object is empty. """
response = self.client.post(reverse('libraries-list'), {})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertIn('Invalid payload.', data['message'])
def test_add_library_invalid_data(self):
""" Ensure error is thrown if the JSON object contains invalid data."""
response = self.client.post(
reverse('libraries-list'),
{'data': json.dumps([{
'name': self._get_random_name(),
}])})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertIn('Invalid payload.', data['message'])
def test_update_library(self):
""" Ensure update library behaves correctly. """
library = create_library(self._get_random_name())
new_name = self._get_random_name()
response = self.client.post(
reverse('libraries-edit'), {
'data':
json.dumps(
[{
'pk': library.pk,
'name': new_name,
'organism': library.organism.pk,
'concentration': 1.0,
'concentration_method':
library.concentration_method.pk,
'read_length': library.read_length.pk,
'sequencing_depth': 1,
'library_protocol': library.library_protocol.pk,
'library_type': library.library_type.pk,
'amplification_cycles': 1,
'index_type': library.index_type.pk,
'index_reads': 0,
'mean_fragment_size': 1,
}])
})
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()['success'])
self.assertEqual(Library.objects.get(pk=library.pk).name, new_name)
def test_update_library_contains_invalid(self):
""" Ensure update library containing invalid data behaves correctly."""
library1 = create_library(self._get_random_name())
library2 = create_library(self._get_random_name())
new_name1 = self._get_random_name()
new_name2 = self._get_random_name()
response = self.client.post(
reverse('libraries-edit'), {
'data':
json.dumps(
[{
'pk': library1.pk,
'name': new_name1,
'organism': library1.organism.pk,
'concentration': 1.0,
'concentration_method':
library1.concentration_method.pk,
'read_length': library1.read_length.pk,
'sequencing_depth': 1,
'library_protocol': library1.library_protocol.pk,
'library_type': library1.library_type.pk,
'amplification_cycles': 1,
'index_type': library1.index_type.pk,
'index_reads': 0,
'mean_fragment_size': 1,
}, {
'pk': library2.pk,
'name': new_name2,
'concentration': 2.0,
'sequencing_depth': 2,
'amplification_cycles': 2,
'index_reads': 0,
'mean_fragment_size': 2,
}])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
self.assertIn('Invalid payload. Some records cannot be updated.',
data['message'])
self.assertEqual(Library.objects.get(pk=library1.pk).name, new_name1)
self.assertEqual(
Library.objects.get(pk=library2.pk).name, library2.name)
# def test_update_library_non_staff(self):
# """
# Ensure a non-staff user cannot update a library created by
# another user.
# """
# self.create_user('*****@*****.**', 'foo-foo', False)
# self.client.login(email='*****@*****.**', password='******')
# pass
def test_delete_library(self):
""" Ensure delete library behaves correctly. """
library = create_library(self._get_random_name())
response = self.client.delete(
reverse(
'libraries-detail',
kwargs={'pk': library.pk},
))
self.assertEqual(response.status_code, 204)
def test_delete_library_incorrect_id(self):
""" Ensure error is thrown if the id does not exist. """
response = self.client.delete(
reverse(
'libraries-detail',
kwargs={'pk': -1},
))
self.assertEqual(response.status_code, 404)
def test_save_not_log_ip(self):
request = Request(ip='1.2.3.4')
request.save()
self.assertEqual(settings.IP_DUMMY, request.ip)
def test_save_anonymous_ip(self):
request = Request(ip='1.2.3.4')
request.save()
self.assertTrue(request.ip.endswith('.1'))
def test_save_anonymous_ip(self):
request = Request(ip='1.2.3.4')
request.save()
self.assertTrue(request.ip.endswith('.1'))
def test_save_not_log_user(self):
user = User.objects.create(username='******')
request = Request(ip='1.2.3.4', user=user)
request.save()
self.assertIsNone(request.user)
def test_save(self):
request = Request(ip='1.2.3.4')
request.save()
def test_save(self):
request = Request(ip='1.2.3.4')
request.save()
def services(request, lang):
contact_info = ContactInfo.objects.all()
comments = Comment.objects.filter(deleted=False).order_by('-date')
data = {'lang': lang, 'comments': comments}
if contact_info:
data['contact_info'] = contact_info[0]
if lang not in LANGUAGES:
return render_to_response('client/404.html', {'data': data}, RequestContext(request))
order = ''
if lang == 'es':
order = 'spanish_name'
elif lang == 'en':
order = 'english_name'
elif lang == 'de':
order = 'german_name'
elif lang == 'pt':
order = 'portuguese_name'
elif lang == 'fr':
order = 'french_name'
if 'service' in request.GET:
id = request.GET['service']
error = False
for x in range(0, len(str(id))):
if not str(id)[x].isdigit():
error = True
break
if not error:
services_list = Service.objects.filter(deleted=False, id=int(id)).order_by(order)
if not services_list:
return render_to_response('client/404.html', {'data': data}, RequestContext(request))
images = Image.objects.filter(deleted=False, service=services_list[0])
if images:
position = random.randrange(0, images.count())
data['image'] = images[position]
data['selected'] = True
data['service'] = id
else:
return render_to_response('client/404.html', {'data': data}, RequestContext(request))
else:
services_list = Service.objects.filter(deleted=False).order_by(order)
images = Image.objects.filter(deleted=False)
if images:
position = random.randrange(0, images.count())
data['image'] = images[position]
data['services'] = services_list
data['images'] = images
if request.method == 'POST':
if 'btn_comment' in request.POST:
content = request.POST['text_comment']
comment = Comment(content=content)
comment.save()
return HttpResponseRedirect('/services/' + lang)
elif 'btn_suggestion' in request.POST:
content = request.POST['text_suggestion']
suggestion = Suggestion(content=content)
suggestion.save()
return HttpResponseRedirect('/services/' + lang)
elif 'btn_request' in request.POST:
content = request.POST['request']
contact_info = request.POST['contact_info']
req = Request(content=content, contact_info=contact_info)
req.save()
return HttpResponseRedirect('/services/' + lang)
return render_to_response('client/services/index.html', {'data': data}, RequestContext(request))
class TestIncomingLibraries(BaseTestCase):
""" Tests for incoming libraries and samples. """
def setUp(self):
user = self.create_user()
self.create_user('*****@*****.**', 'test', False) # non-staff user
# Submission completed
self.library1 = create_library(self._get_random_name(), status=1)
self.sample1 = create_sample(self._get_random_name(), status=1)
self.sample2 = create_sample(self._get_random_name(), status=1)
# Failed library
self.library2 = create_library(self._get_random_name(), status=-1)
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(*[self.library1, self.library2])
self.request.samples.add(*[self.sample1, self.sample2])
def test_incoming_libraries_list(self):
""" Ensure get incoming libraries and samples behaves correctly. """
self.login()
response = self.client.get(reverse('incoming-libraries-list'))
data = response.json()
libraries = [x['name'] for x in data if x['record_type'] == 'Library']
samples = [x['name'] for x in data if x['record_type'] == 'Sample']
self.assertTrue(response.status_code, 200)
self.assertIn(self.library1.name, libraries)
self.assertIn(self.sample1.name, samples)
self.assertIn(self.sample2.name, samples)
self.assertNotIn(self.library2.name, libraries)
def test_incoming_libraries_list_non_staff(self):
"""Ensure error is thrown if a non-staff user tries to get the list."""
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('incoming-libraries-list'))
self.assertTrue(response.status_code, 403)
def test_update_library(self):
""" Ensure update library behaves correctly. """
self.client.login(email='*****@*****.**', password='******')
library = create_library(self._get_random_name(), status=1)
response = self.client.post(
reverse('incoming-libraries-edit'), {
'data':
json.dumps([{
'pk': library.pk,
'record_type': 'Library',
'dilution_factor': 2,
'concentration_facility': 2.0,
}])
})
updated_library = Library.objects.get(pk=library.pk)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()['success'])
self.assertEqual(updated_library.dilution_factor, 2)
self.assertEqual(updated_library.concentration_facility, 2.0)
def test_contains_invalid_records(self):
"""
Ensure update libraries and samples containing invalid records
bahaves correctly.
"""
self.client.login(email='*****@*****.**', password='******')
library1 = create_library(self._get_random_name(), status=1)
library2 = create_library(self._get_random_name(), status=1)
response = self.client.post(
reverse('incoming-libraries-edit'), {
'data':
json.dumps([{
'pk': library1.pk,
'record_type': 'Library',
'concentration_facility': 2.0,
}, {
'pk': library2.pk,
'record_type': 'Library',
'dilution_factor': 'string value',
}])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
self.assertEqual(data['message'], 'Some records cannot be updated.')
self.assertEqual(
Library.objects.get(pk=library1.pk).concentration_facility, 2.0)
def test_contains_invalid_id(self):
"""
Ensure update libraries and samples containing records with
invalid ids bahaves correctly.
"""
self.client.login(email='*****@*****.**', password='******')
library = create_library(self._get_random_name(), status=1)
response = self.client.post(
reverse('incoming-libraries-edit'), {
'data':
json.dumps([{
'pk': library.pk,
'record_type': 'Library',
'concentration_facility': 2.0,
}, {
'pk': 'blah',
'record_type': 'Sample',
'concentration_facility': 2.0,
}])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
self.assertEqual(
Library.objects.get(pk=library.pk).concentration_facility, 2.0)
def test_quality_check_passed(self):
""" Ensure quality check has passed behaves correctly. """
self.client.login(email='*****@*****.**', password='******')
library = create_library(self._get_random_name(), status=1)
response = self.client.post(
reverse('incoming-libraries-edit'), {
'data':
json.dumps([{
'pk': library.pk,
'record_type': 'Library',
'quality_check': 'passed',
}])
})
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()['success'])
self.assertEqual(Library.objects.get(pk=library.pk).status, 2)
def test_quality_check_multiple(self):
""" Ensure quality check has failed behaves correctly. """
self.client.login(email='*****@*****.**', password='******')
sample1 = create_sample(self._get_random_name(), status=1)
sample2 = create_sample(self._get_random_name(), status=1)
response = self.client.post(
reverse('incoming-libraries-edit'), {
'data':
json.dumps([{
'pk': sample1.pk,
'record_type': 'Sample',
'quality_check': 'failed',
}, {
'pk': sample2.pk,
'record_type': 'Sample',
'quality_check': 'compromised',
}])
})
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()['success'])
self.assertEqual(Sample.objects.get(pk=sample1.pk).status, -1)
self.assertEqual(Sample.objects.get(pk=sample2.pk).status, -2)
def test_invalid_json(self):
""" Ensure error is thrown if the JSON object is empty. """
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('incoming-libraries-edit'), {})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertIn('Invalid payload.', data['message'])
