def register(request):
if request.method == 'POST':
formUser = f.FormReg(request.POST)
if formUser.is_valid():
formUser.save()
NewCustomUser = CustomUser(user=formUser.instance)
NewCustomUser.save()
user = authenticate(username=request.POST['username'],
password=request.POST['password1'])
login(request, user)
return render(request,
template_name='reg.html',
context={'form': formUser})
elif 'code' in request.GET:
auth_code = request.GET.get('code')
auth_token = yandex_oauth.get_oauth_json(auth_code)['access_token']
user_json = yandex_oauth.get_account_info(auth_token)
return render(request,
template_name='reg.html',
context={
'login': user_json['login'],
'email': user_json['default_email']
})
return render(request,
template_name='reg.html',
context={'registered': False})
def validate(self, attrs):
authenticate_kwargs = {
self.username_field: attrs[self.username_field],
'password': attrs['password']
}
try:
authenticate_kwargs['request'] = self.context['request']
except KeyError:
pass
user = CustomUser.authenticate(**authenticate_kwargs)
if user is None or not user.is_active:
raise exceptions.AuthenticationFailed(
self.error_messages['no_active_account'],
'no_active_account',
)
else:
user_dict = dict()
for attr in ATTRS:
user_dict[attr] = user.__getattribute__(attr)
user_dict['of_node'] = CustomUser.determine_permissions(
authenticate_kwargs['email'], user)
refresh = self.get_token(user)
return {
'user': user_dict,
'tokens': {
'refresh': str(refresh),
'access': str(refresh.access_token)
}
}
def fill_db_users():
for i in range(len(names)):
param = {
'email': emails[i],
'password': passwords[i],
'first_name': names[i],
'middle_name': middlenames[i],
'last_name': lastnames[i]
}
CustomUser.create(**param)
def restore_object(self, attrs, instance=None):
if instance is not None:
for k, v in attrs.iteritems():
setattr(instance, k, v)
return instance
confirm_pw = attrs.get('confirm_password')
del attrs['confirm_password']
customUser = CustomUser(**attrs)
customUser.confirm_password = confirm_pw
#customUser.company = customUser.company.company_id # hack to return only the company ID instead of entire object
return CustomUser(**attrs)
def setUp(self):
CustomUser(id=1,
first_name='Bohdan',
last_name='Dubas',
phone='123456789',
email='*****@*****.**',
is_active=False).save()
self.user = CustomUser.objects.get(id=1)
Blog(id=22,
name='TestName',
description='TestDescription',
author=self.user).save()
self.blog = Blog.objects.get(id=22)
Post(id=333,
title='TestPost',
content='Just testing post',
author=self.user,
blog=self.blog).save()
self.post = Post.objects.get(id=333)
Comment(id=4444,
author=self.user,
post=self.post,
content='Great post!',
created_at=TEST_DATE).save()
self.comment = Comment.objects.get(id=4444)
def get_all_users(request):
ul = list(CustomUser.get_all())
return render(request,
'authentication/get_all.html',
context={
'users_list': ul,
})
def get_orders(request):
if not request.user.is_authenticated:
messages.info(request, "Log in first!")
return redirect("authorise")
if CustomUser.get_by_email(request.user.email).role == 1:
return render(request, "get_orders.html", {"orders": Order.objects.all()})
return render(request, "get_orders.html", {"orders": Order.objects.all().filter(user_id=request.user.id)})
def list(self, request, companyid, id):
user = CustomUser.objects(id=id).first()
if user is not None:
serializedData = CustomUserSerializer(user)
return Response(serializedData.data)
return HttpResponse("No editable record for " + id + " found!", status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data: dict) -> 'CustomUser':
"""
Create Custom User
:param validated_data: Dictionary with required fields for Custom User
:return: :class:`.CustomUser` object
"""
return CustomUser.create(**validated_data)
def setUp(self):
CustomUser(id=1,
first_name='Bohdan',
last_name='Dubas',
phone='123456789',
email='*****@*****.**',
is_active=False).save()
self.user = CustomUser.objects.get(id=1)
def test_get_by_email_positive(self):
user = CustomUser.get_by_email('*****@*****.**')
self.assertEqual(user.id, 1)
self.assertEqual(user.first_name, 'Bohdan')
self.assertEqual(user.last_name, 'Dubas')
self.assertEqual(user.phone, '123456789')
self.assertEqual(user.email, '*****@*****.**')
self.assertFalse(user.is_active)
def create_new_order(request):
req = request.POST
user = CustomUser.get_by_email(req.get('user_email'))
book = Book.get_by_id(req.get('book_id'))
plated_end_at = req.get('plated_end_at')
new_order = Order.create(user, book, plated_end_at)
return render(request,
'order/neworder.html',
context={'new_order': new_order})
def home_view(request):
template_name = "home.html"
context = {}
context["count_of_users"] = CustomUser.get_count()
context["count_of_books"] = Book.get_count()
context["count_of_orders"] = Order.get_count()
context["page_title"] = "Home"
return render(request, template_name, context)
def get_all_orders(request):
ol = list(Order.get_all())
usrs = [CustomUser.get_by_id(order.user_id) for order in ol]
return render(request,
'order/get_all.html',
context={
'orders_list': ol,
'users': usrs
})
def delete(self, request, companyid, id):
queryset = CustomUser.objects(id=id).first()
if queryset is not None and self.request.method == 'DELETE':
try:
queryset.delete()
except Exception as e:
return HttpResponse(str(e), status=status.HTTP_400_BAD_REQUEST)
return HttpResponse('User with ID ' + id + ' deleted', status=status.HTTP_200_OK)
def get_user_by_id(request, id=0):
user_found = CustomUser.get_by_id(id)
ord = [order for order in list(Order.get_all()) if order.user.id == id]
return render(request,
'authentication/get_user_by_id.html',
context={
'user': user_found,
'orders': ord
})
def setUp(self):
""" Create a user object to be used by the tests """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
self.user = CustomUser(id=111, email='*****@*****.**', password='******', first_name='fname',
middle_name='mname',
last_name='lname')
self.user.save()
self.user_free = CustomUser(id=222, email='*****@*****.**', password='******', first_name='2fname',
middle_name='2mname',
last_name='2lname')
self.user_free.save()
self.author1 = Author(id=101, name="author1", surname="s1", patronymic="p1")
self.author1.save()
self.author2 = Author(id=102, name="author2", surname="s2", patronymic="p2")
self.author2.save()
self.book1 = Book(id=101, name="book1", description="description1", count=1)
self.book1.save()
self.book1.authors.add(self.author1)
self.book1.save()
self.book2 = Book(id=102, name="book2", description="description2")
self.book2.save()
self.book2.authors.add(self.author2)
self.book2.save()
self.book3 = Book(id=103, name="book3", description="description3")
self.book3.save()
self.book3.authors.add(self.author1)
self.book3.authors.add(self.author2)
self.book3.save()
self.order1 = Order(id=101, user=self.user, book=self.book1, plated_end_at=TEST_DATE)
self.order1.save()
self.order2 = Order(id=102, user=self.user, book=self.book2, plated_end_at=TEST_DATE)
self.order2.save()
self.order3 = Order(id=103, user=self.user, book=self.book3, end_at=TEST_DATE_END, plated_end_at=TEST_DATE)
self.order3.save()
def setUp(self):
""" Create a user object to be used by the tests """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
CustomUser(id=111,
email='*****@*****.**',
password='******',
first_name='fname',
middle_name='mname',
last_name='lname').save()
CustomUser(id=4,
email='*****@*****.**',
password='******',
first_name='fname',
middle_name='mname',
last_name='lname',
created_at=time_mock,
role=1).save()
def test_activate_positive(self):
CustomUser(id=22,
first_name='Helen',
last_name='Demkiv',
phone='123456789',
email='*****@*****.**',
is_active=False).save()
url = reverse('authentication:activate', kwargs={'token': '*****@*****.**'})
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
def setUp(self):
CustomUser(id=1,
first_name='Bohdan',
last_name='Dubas',
phone='123456789',
email='*****@*****.**',
is_active=True).save()
self.user = CustomUser.objects.get(id=1)
self.user.set_password('password')
self.client = Client()
def _get_superadmin():
try:
result = None
company = Company.objects(company_id=0).first()
user = CustomUser.objects(company=company.id).first()
if user is not None and user.is_superadmin == True:
result = user
return result
except Exception as e:
print 'exception ' + str(e)
return str(e)
def test_create(self):
user = CustomUser.create(first_name='Helen',
last_name='Demkiv',
phone='987654321',
email='*****@*****.**',
password='******')
self.assertEqual(user.first_name, 'Helen')
self.assertEqual(user.last_name, 'Demkiv')
self.assertEqual(user.phone, '987654321')
self.assertEqual(user.email, '*****@*****.**')
self.assertFalse(user.is_active)
def test_update_full(self):
""" Test of the CustomUser.create(args) method """
user_to_update = CustomUser.objects.get(id=4)
user_to_update.update('John', 'Smith', 'Jr.', '123456', 1, True)
user_to_expect = CustomUser(id=4,
password='******',
first_name='John',
middle_name='mnSmithame',
last_name='Jr.',
role=1,
is_active=True)
self.assertEqual(user_to_update, user_to_expect)
def test_get_by_email_positive(self):
"""Positive test of the CustomUser.get_by_email() method"""
user_returned = CustomUser.get_by_email('*****@*****.**')
self.assertEqual(user_returned.id, 111)
self.assertEqual(user_returned.email, '*****@*****.**')
self.assertEqual(user_returned.password, '1234')
self.assertEqual(user_returned.first_name, 'fname')
self.assertEqual(user_returned.middle_name, 'mname')
self.assertEqual(user_returned.last_name, 'lname')
self.assertEqual(user_returned.created_at, TEST_DATE)
self.assertEqual(user_returned.updated_at, TEST_DATE)
self.assertEqual(user_returned.is_active, False)
def test_update_first_name_and_role(self):
""" Test of the CustomUser.create(args) method """
user_to_update = CustomUser.objects.get(id=4)
user_to_expect = CustomUser(first_name='John',
role=0,
id=user_to_update.id,
password=user_to_update.password,
middle_name=user_to_update.middle_name,
last_name=user_to_update.last_name,
is_active=user_to_update.is_active)
user_to_update.update(first_name='John', role=0)
user_to_update = CustomUser.objects.get(id=4)
self.assertEqual(user_to_update, user_to_expect)
def get_order_by_id(request, id=0):
order_found = Order.get_by_id(id)
usr = CustomUser.get_by_id(order_found.user_id)
bk = Book.get_by_id(order_found.book_id)
al = [authors for authors in list(bk.authors.all())]
return render(request,
'order/get_order_by_id.html',
context={
'order': order_found,
'user': usr,
'book': bk,
'authors_list': al
})
def signUp(request):
if request.method == 'POST': #If 'submit' button has been pressed
formUser = FormReg(request.POST)
if formUser.is_valid(): #If input data is correct
#Instance of PvPGN Profile
newPvPGNProfile = createPvPGNProfile(request.POST['username'],
request.POST['password1'],
request.POST['email'])
#Instance of Django user
formUser.save()
#Instance of model which is contains relation between PvPGN profile and Django user
NewCustomUser = CustomUser(user=formUser.instance,
pvpgn_user=newPvPGNProfile)
NewCustomUser.save()
#And authentication
user = authenticate(username=request.POST['username'],
password=request.POST['password1'])
login(request, user)
return redirect('/')
return render(request,
template_name='signUp.html',
context={'form': formUser})
return render(request, template_name='signUp.html')
def test_create_positive(self):
""" Positive Test of the CustomUser.create method """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
user_returned = CustomUser.create('*****@*****.**', '1234', 'fname', 'mname', 'lname')
self.assertIsInstance(user_returned, CustomUser)
self.assertEqual(user_returned.email, '*****@*****.**')
self.assertEqual(user_returned.first_name, 'fname')
self.assertEqual(user_returned.middle_name, 'mname')
self.assertEqual(user_returned.last_name, 'lname')
self.assertEqual(user_returned.created_at, TEST_DATE)
self.assertEqual(user_returned.updated_at, TEST_DATE)
self.assertEqual(user_returned.role, 0)
self.assertEqual(user_returned.is_active, False)
def make_order_view(request):
context = {}
template_name = "make_order.html"
user = CustomUser.get_by_id(request.user.id)
if request.method == "GET":
form = MakeOrderForm(request.GET)
if form.is_valid():
book = Book.get_by_id(request.GET.get("book").split("//")[1])
date = form.data["plated_end_at"]
new_order = Order.create(user=user, book=book, plated_end_at=date)
return redirect("order_details", pk=new_order.id)
else:
form = MakeOrderForm()
context["page_title"] = "Make order"
context["form"] = form
return render(request, template_name, context)
def put(self, request, companyid, id):
user = CustomUser.objects(id=id).first()
if user is not None:
try:
data = json.loads(request.body)
user.email = data.get('email', None)
user.username = data.get('username', None)
user.timezone = data.get('timezone', None)
user.save()
password = data.get('password', None)
confirm_password = data.get('confirm_password', None)
if password and confirm_password and password == confirm_password:
user.set_password(password)
user.save()
update_session_auth_hash(request, user)
return HttpResponse('User ' + user.username + ' updated', status=status.HTTP_200_OK)
except Exception as e:
return HttpResponse(str(e), status=status.HTTP_400_BAD_REQUEST)
def find_order(request):
context = {}
orders = None
template_name = "order-search.html"
target_book = request.GET.get('book')
if target_book:
target_book = target_book.split("//")[-1]
target_user = request.GET.get('user')
if target_user:
target_user = target_user.split("//")[-1]
if request.method == "GET":
if target_book:
orders = Order.objects.filter(book=Book.get_by_id(target_book))
if target_user:
orders = Order.objects.filter(
user=CustomUser.get_by_id(target_user))
context["page_title"] = "Find order"
context["orders"] = orders
return render(request, template_name, context)
# def find_order(request):
# context = {}
# orders = None
# template_name = "order-search.html"
# target_book = request.GET.get('book')
# if target_book:
# target_book = target_book.split("//")[-1]
# target_user = request.GET.get('user')
# if target_user:
# target_user = target_user.split("//")[-1]
# if request.method == "GET":
# if target_book:
# orders = Order.objects.filter(book=Book.get_by_id(target_book))
# if target_user:
# orders = Order.objects.filter(user=CustomUser.get_by_id(target_user))
#
# context["page_title"] = "Find order"
# context["orders"] = orders
# return render(request, template_name, context)
def setUp(self):
CustomUser(id=1,
first_name='Bohdan',
last_name='Dubas',
phone='123456789',
email='*****@*****.**',
is_active=False).save()
self.user = CustomUser.objects.get(id=1)
Blog(id=22,
name='TestName',
description='TestDescription',
author=self.user,
created_at=TEST_DATE).save()
Blog(id=333,
name='OlderBlog',
description='Should be last in array',
author=self.user).save()
self.blog = Blog.objects.get(id=22)
self.new_blog = Blog.objects.get(id=333)
def exportToPdf(company_id, user_id, template_name, source_type, content_type, phantomjs_script, url, token, sessionid, authenticatedAccount, file_name): #, output, error
try:
user_id = ObjectId(user_id)
output = NamedTemporaryFile(delete=False)
error = NamedTemporaryFile(delete=False)
external_process = Popen(["phantomjs", phantomjs_script, url, token, sessionid, authenticatedAccount, file_name], stdout=output, stderr=error) #
external_process.communicate(30)
export_file = open(file_name, 'rb')
exportFile = ExportFile(company_id=company_id, owner_id=user_id, source=template_name, source_type=source_type, type=content_type, file_name=os.path.basename(file_name))
exportFile.file.put(export_file, content_type=content_type)
exportFile.save()
try:
message = 'PDF file successfully exported'
notification = Notification()
#notification.company_id = company_id
notification.owner = user_id
notification.module = 'Exports'
notification.type = 'Background task'
notification.method = os.path.basename(__file__)
notification.message = message
notification.success = True
notification.read = False
notification.save()
user = CustomUser.objects(id=user_id).first()
if user is not None:
html_msg = '<p>Hola ' + user['first_name'] + '</p><p>Your export of data from ' + template_name + ' is ready. It is available in My Exports with the file name ' + os.path.basename(file_name) + '.</p><p>Cheers</p><p>The Claritix crew<p>'
send_mail('[Claritix] Your PDF export is baked and ready', '', '*****@*****.**', [user['email']], html_message=html_msg)
except Exception as e:
send_notification(dict(
type='error',
success=False,
message=str(e)
))
except Exception as e:
print 'exception was ' + str(e)
return str(e)
def test_create_negative_not_saved_user(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
user = CustomUser()
order = Order.create(user, self.book2, TEST_DATE_END)
self.assertIsNone(order)
class TestOrderModel(TestCase):
"""Class for CustomUser Model test"""
def setUp(self):
""" Create a user object to be used by the tests """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
self.user = CustomUser(id=111,
email='*****@*****.**',
password='******',
first_name='fname',
middle_name='mname',
last_name='lname')
self.user.save()
self.user_free = CustomUser(id=222,
email='*****@*****.**',
password='******',
first_name='2fname',
middle_name='2mname',
last_name='2lname')
self.user_free.save()
self.author1 = Author(id=101,
name="author1",
surname="s1",
patronymic="p1")
self.author1.save()
self.author2 = Author(id=102,
name="author2",
surname="s2",
patronymic="p2")
self.author2.save()
self.book1 = Book(id=101,
name="book1",
description="description1",
count=1)
self.book1.save()
self.book1.authors.add(self.author1)
self.book1.save()
self.book2 = Book(id=102, name="book2", description="description2")
self.book2.save()
self.book2.authors.add(self.author2)
self.book2.save()
self.book3 = Book(id=103, name="book3", description="description3")
self.book3.save()
self.book3.authors.add(self.author1)
self.book3.authors.add(self.author2)
self.book3.save()
self.order1 = Order(id=101,
user=self.user,
book=self.book1,
plated_end_at=TEST_DATE)
self.order1.save()
self.order2 = Order(id=102,
user=self.user,
book=self.book2,
plated_end_at=TEST_DATE)
self.order2.save()
self.order3 = Order(id=103,
user=self.user,
book=self.book3,
end_at=TEST_DATE_END,
plated_end_at=TEST_DATE)
self.order3.save()
def test__str__end_at_is_None(self):
"""Test of the CustomUser.__str__() method"""
order_returned = str(Order.objects.get(id=101))
order_to_expect = "'id': 101, " \
"'user': CustomUser(id=111), " \
"'book': Book(id=101), " \
"'created_at': '2017-04-10 12:00:00+00:00', " \
"'end_at': None, " \
"'plated_end_at': '2017-04-10 12:00:00+00:00'"
self.assertEqual(order_returned, order_to_expect)
def test__str__end_at_is_not_None(self):
"""Test of the CustomUser.__str__() method"""
order = str(Order.objects.get(id=103))
order_to_expect = "'id': 103, " \
"'user': CustomUser(id=111), " \
"'book': Book(id=103), " \
"'created_at': '2017-04-10 12:00:00+00:00', " \
"'end_at': '2017-04-25 12:00:00+00:00', " \
"'plated_end_at': '2017-04-10 12:00:00+00:00'"
self.assertEqual(order, order_to_expect)
def test__repr__(self):
"""Test of the CustomUser.__repr__() method"""
user_returned = repr(Order.objects.get(id=102))
user_to_expect = "Order(id=102)"
self.assertEqual(user_returned, user_to_expect)
def test_get_by_id_positive(self):
"""Positive test of the CustomUser.get_by_id() method"""
order = Order.get_by_id(101)
self.assertEqual(order.id, 101)
self.assertEqual(order.user, self.user)
self.assertEqual(order.book, self.book1)
self.assertEqual(order.created_at, TEST_DATE)
self.assertEqual(order.end_at, None)
self.assertEqual(order.plated_end_at, TEST_DATE)
def test_get_by_id_negative(self):
"""Negative test of the CustomUser.get_by_id() method"""
order = Order.get_by_id(55)
self.assertIsNone(order)
def test_delete_by_id_positive(self):
""" Test of the CustomUser.delete_by_id() method """
self.assertTrue(Order.delete_by_id(103))
self.assertRaises(Order.DoesNotExist, Order.objects.get, pk=103)
self.assertEqual(self.book3, Book.objects.get(id=103))
self.assertEqual(self.user, CustomUser.objects.get(id=111))
def test_delete_by_id_negative(self):
""" Test of the CustomUser.delete_by_id() method """
self.assertFalse(Order.delete_by_id(999))
def test_create_positive(self):
""" Positive Test of the CustomUser.create method """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
order = Order.create(self.user_free, self.book2, TEST_DATE_END)
self.assertIsInstance(order, Order)
self.assertEqual(order.user, self.user_free)
self.assertEqual(order.book, self.book2)
self.assertEqual(order.created_at, TEST_DATE)
self.assertIsNone(order.end_at)
self.assertEqual(order.plated_end_at, TEST_DATE_END)
def test_create_negative_not_saved_user(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
user = CustomUser()
order = Order.create(user, self.book2, TEST_DATE_END)
self.assertIsNone(order)
def test_create_negative_limit_book(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
order = Order.create(self.user_free, self.book1, TEST_DATE_END)
self.assertIsNone(order)
def test_get_all(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
orders = Order.get_all()
self.assertListEqual(orders, [self.order1, self.order2, self.order3])
def test_get_not_returned_books(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
orders = Order.get_not_returned_books()
self.assertListEqual(orders, [self.order1, self.order2])
def test_update_plated_end_at(self):
order = Order.objects.get(id=101)
new_date = TEST_DATE_END + datetime.timedelta(days=4)
order.update(plated_end_at=new_date)
order = Order.objects.get(id=101)
self.assertEqual(order.id, 101)
self.assertEqual(order.user, self.user)
self.assertEqual(order.book, self.book1)
self.assertEqual(order.created_at, TEST_DATE)
self.assertEqual(order.end_at, None)
self.assertEqual(order.plated_end_at, new_date)
def test_update_end_at(self):
order = Order.objects.get(id=101)
new_date = TEST_DATE_END + datetime.timedelta(days=4)
order.update(end_at=new_date)
order = Order.objects.get(id=101)
self.assertEqual(order.id, 101)
self.assertEqual(order.user, self.user)
self.assertEqual(order.book, self.book1)
self.assertEqual(order.created_at, TEST_DATE)
self.assertEqual(order.end_at, new_date)
self.assertEqual(order.plated_end_at, TEST_DATE)
class TestAuthorModel(TestCase):
"""Class for CustomUser Model test"""
def setUp(self):
""" Create a user object to be used by the tests """
time_mock = datetime.datetime(2017, 4, 10, 12, 00, tzinfo=pytz.utc)
with mock.patch('django.utils.timezone.now') as mock_time:
mock_time.return_value = time_mock
self.user = CustomUser(id=111,
email='*****@*****.**',
password='******',
first_name='fname',
middle_name='mname',
last_name='lname')
self.user.save()
self.user_free = CustomUser(id=222,
email='*****@*****.**',
password='******',
first_name='2fname',
middle_name='2mname',
last_name='2lname')
self.user_free.save()
self.author1 = Author(id=101,
name="author1",
surname="s1",
patronymic="p1")
self.author1.save()
self.author2 = Author(id=102,
name="author2",
surname="s2",
patronymic="p2")
self.author2.save()
self.book1 = Book(id=101,
name="book1",
description="description1",
count=1)
self.book1.save()
self.book1.authors.add(self.author1)
self.book1.save()
self.book2 = Book(id=102, name="book2", description="description2")
self.book2.save()
self.book2.authors.add(self.author2)
self.book2.save()
self.book3 = Book(id=103, name="book3", description="description3")
self.book3.save()
self.book3.authors.add(self.author1)
self.book3.authors.add(self.author2)
self.book3.save()
self.order1 = Order(id=101,
user=self.user,
book=self.book1,
plated_end_at=TEST_DATE)
self.order1.save()
self.order2 = Order(id=102,
user=self.user,
book=self.book2,
plated_end_at=TEST_DATE)
self.order2.save()
self.order3 = Order(id=103,
user=self.user,
book=self.book3,
end_at=TEST_DATE_END,
plated_end_at=TEST_DATE)
self.order3.save()
def test__str__(self):
"""Test of the CustomUser.__str__() method"""
author_returned = str(Author.objects.get(id=101))
author_to_expect = "'id': 101, 'name': 'author1', 'surname': 's1', 'patronymic': 'p1'"
self.assertEqual(author_returned, author_to_expect)
def test__repr__(self):
"""Test of the CustomUser.__repr__() method"""
author_returned = repr(Author.objects.get(id=102))
author_to_expect = "Author(id=102)"
self.assertEqual(author_returned, author_to_expect)
def test_get_by_id_positive(self):
"""Positive test of the CustomUser.get_by_id() method"""
author = Author.get_by_id(101)
self.assertEqual(author.id, 101)
self.assertEqual(author.name, 'author1')
self.assertEqual(author.surname, "s1")
self.assertEqual(author.patronymic, "p1")
def test_get_by_id_negative(self):
"""Negative test of the CustomUser.get_by_id() method"""
author = Author.get_by_id(999)
self.assertIsNone(author)
def test_delete_by_id_positive(self):
""" Test of the CustomUser.delete_by_id() method """
self.assertTrue(Author.delete_by_id(101))
self.assertRaises(Author.DoesNotExist, Author.objects.get, pk=101)
def test_delete_by_id_negative(self):
""" Test of the CustomUser.delete_by_id() method """
self.assertFalse(Author.delete_by_id(999))
def test_get_all(self):
""" Positive Test of the CustomUser.create method TEST_DATE_END"""
authors = list(Author.get_all())
authors.sort(key=lambda author: author.id)
self.assertListEqual(authors, [self.author1, self.author2])
def test_update(self):
author = Author.objects.get(id=101)
author.update(name="testName",
surname="testSurname",
patronymic="testPatronymic")
author = Author.objects.get(id=101)
self.assertIsInstance(author, Author)
self.assertEqual(author.name, "testName")
self.assertEqual(author.surname, "testSurname")
self.assertEqual(author.patronymic, "testPatronymic")
def test_update_only_name(self):
author = Author.objects.get(id=101)
author.update(name="testName")
author = Author.objects.get(id=101)
self.assertIsInstance(author, Author)
self.assertEqual(author.name, "testName")
self.assertEqual(author.surname, "s1")
self.assertEqual(author.patronymic, "p1")
def test_update_not_valid_name(self):
author = Author.objects.get(id=101)
author.update(name="testName" * 5)
author = Author.objects.get(id=101)
self.assertIsInstance(author, Author)
self.assertEqual(author.name, "author1")
self.assertEqual(author.surname, "s1")
self.assertEqual(author.patronymic, "p1")
def test_create(self):
author = Author.create(name="testName", surname="s1", patronymic="p1")
author = Author.objects.get(id=author.id)
self.assertIsInstance(author, Author)
self.assertEqual(author.name, "testName")
self.assertEqual(author.surname, "s1")
self.assertEqual(author.patronymic, "p1")
def test_createnot_valid_surname(self):
author = Author.create(name="testName",
surname="s1" * 20,
patronymic="p1")
self.assertIsNone(author)
def exportToCsv(object_type, system_code, data, source_type, chart_name, user_id, company_id):
print 'in export to csv'
if object_type is None or system_code is None or data is None:
print 'returning due to none'
return
try:
if object_type == 'lead':
result = exportLeadsToCsv(system_code, data, chart_name, user_id, company_id)
print 'got result ' + str(result)
file_name = result['file_name']
if file_name != '':
content_type = result['content_type']
export_file = open(file_name, 'rb')
exportFile = ExportFile(company_id=company_id, owner_id=user_id, source=chart_name, source_type=source_type, type=content_type, file_name=os.path.basename(file_name))
exportFile.file.put(export_file, content_type=content_type)
exportFile.save()
try:
message = 'CSV file successfully exported'
notification = Notification()
#notification.company_id = company_id
notification.owner = user_id
notification.module = 'Exports'
notification.type = 'Background task'
notification.method = os.path.basename(__file__)
notification.message = message
notification.success = True
notification.read = False
notification.save()
user = CustomUser.objects(id=user_id).first()
if user is not None:
html_msg = '<p>Hola ' + user['first_name'] + '</p><p>Your download of data from ' + chart_name + ' is ready. It is available in My Exports with the file name ' + os.path.basename(file_name) + '.</p><p>Cheers</p><p>The Claritix crew<p>'
send_mail('[Claritix] Your CSV export is baked and ready', '', '*****@*****.**', [user['email']], html_message=html_msg)
except Exception as e:
send_notification(dict(
type='error',
success=False,
message=str(e)
))
else:
try:
message = 'CSV download failed'
notification = Notification()
#notification.company_id = company_id
notification.owner = user_id
notification.module = 'Exports'
notification.type = 'Background task'
notification.method = os.path.basename(__file__)
notification.message = message
notification.success = True
notification.read = False
notification.save()
user = CustomUser.objects(id=user_id).first()
if user is not None:
html_msg = '<p>Hola ' + user['first_name'] + '</p><p>Your download of data from ' + chart_name + ' failed. Please contact the Claritix team so that we can look into this.</p><p>Cheers</p><p>The Claritix crew<p>'
send_mail('[Claritix] Oh no! Your CSV download failed', '', '*****@*****.**', [user['email']], html_message=html_msg)
except Exception as e:
send_notification(dict(
type='error',
success=False,
message=str(e)
))
else:
return
except Exception as e:
print 'exception while trying to save CSV file: ' + str(e)
send_notification(dict(type='error', success=False, message=str(e)))
