class UserTestCase(CleanupTestCaseMixin, APITestCase):
def init_data(self, access_as='apikey', headers=True, create_user=True):
self.instance = G(Instance, name='testinstance')
set_current_instance(self.instance)
if create_user:
self.user = User(username='******')
self.user.set_password('test')
self.user.save()
if access_as == 'apikey':
self.apikey = self.instance.create_apikey(allow_user_create=True)
self.credentials = {'username': '******', 'password': '******'}
if headers:
self.client.defaults['HTTP_X_API_KEY'] = self.apikey.key
if create_user or getattr(self, 'user', None):
self.client.defaults['HTTP_X_USER_KEY'] = self.user.key
else:
self.admin = G(Admin, email='*****@*****.**', is_active=True)
self.admin.add_to_instance(self.instance)
if headers:
self.client.defaults['HTTP_X_API_KEY'] = self.admin.key
def _get_user_profile(self, user):
user_profile_klass = Klass.get_user_profile()
return DataObject.objects.filter(_klass=user_profile_klass,
owner=user).get()
class TestProfileImageResize(TestCase):
def setUp(self):
self.user = User(
email="*****@*****.**",
password="******"
)
self.user.save()
self.profile = Profile(
prefix="Mr",
middle="Jim",
suffix="Jr",
first_name="Ben",
last_name="Gilbertson",
nick_name="Bengi",
headline="Mr Bengil, Master of the Universe",
dob=datetime.date(200, 1, 1),
user=self.user,
profile_image=create_image_file(),
activation_key="ABCDEFGHIJK"
)
self.profile.save()
# @unittest.skip("Takes too long, eats the CPU")
def test_profile_valid(self):
self.assertIsInstance(self.profile, Profile)
self.assertTrue(self.profile.profile_image is not None)
file_regex = re.compile(r'uploads/profile_img/test.*\.png')
self.assertRegexpMatches(self.profile.profile_image.name, file_regex)
# self.assertEqual(self.profile.profile_image.name, 'uploads/profile_img/test_*.png')
# @unittest.skip("Takes Too Long, eats CPU")
def test_profile_img_resize(self):
path = settings.BASE_DIR + str(self.profile.profile_image.url)
new_path = resize_image(path, 50, append_str="thumb")
self.assertRegexpMatches(new_path, re.compile(r'.*thumb\.png'))
def post(self, request, *args, **kwargs):
email_data = self.request.data
email_address = email_data.__getitem__("email")
length = 5
numbers = '0123456789'
validation_code = ''.join(
random.choice(numbers) for _ in range(length))
subject = 'Welcome to Motion'
message = 'Here is your validation code ' + validation_code
recipient = email_address
send_mail(subject,
message,
EMAIL_HOST_USER, [recipient],
fail_silently=False)
try:
new_user = User(email=email_address,
username=email_address,
is_active=False)
new_user.save()
registration_profile = RegistrationProfile(user=new_user,
code=validation_code)
registration_profile.save()
return Response(status=status.HTTP_200_OK)
except IntegrityError:
return Response(data="This email is already taken.", status=400)
def save_user(validated_data):
user = User(email=validated_data['email'])
user.set_password(validated_data['password'])
user.first_name = validated_data.get('first_name', None)
user.last_name = validated_data.get('last_name', None)
user.is_active = True
user.save()
def addUsers(request):
if request.method == "POST":
statement = User(user=request.POST.get('user'), password=request.POST.get('password'), email=request.POST.get('email'))
statement.save()
sta = 'user: '******'user') + ' and password: '******'password') + ' Has sido Guardados'
title = 'Registro de usuario nuevo'
body = 'se ha Creado un nuevo usuario para usted, llamado: '+request.POST.get('user')+' y su password es: '+request.POST.get('password') + ', muchas gracias, atentamente BrayanDev'
email_send = request.POST.get('email')
#settings.DEFAULT_FROM_EMAIL = '*****@*****.**'
#email_send_now = settings.DEFAULT_FROM_EMAIL
#email = EmailMessage(title, body, to=[email_send])
#email.send()
#context = {'guardado':'Guardado'}
email = request.POST.get('email', None)
subject = 'Registro'
message = 'Bienvenido, hemos creado tu cuenta.'
context = {'body':body, 'email': email, 'subject': subject, 'message': message, 'user':request.POST.get('user'), 'password':request.POST.get('password')}
html_message = render_to_string('template_email/email.html', {'context': context})
plain_message = strip_tags(html_message)
send_mail(title, plain_message, settings.EMAIL_HOST_USER,
[email_send], html_message=html_message, fail_silently=False)
return render(request, 'users/add_users.html', {'sta':body})
return render(request, 'users/add_users.html')
class DappsCRUDIntegrationTests(WebTest):
def setUp(self):
self.user = User()
self.user.save()
self.constructor = Constructor.create(price=0)
self.constructor.save()
self.auth_header = {
'X_ACCESSTOKEN':
UsersService().generate_token(self.user, 'ethereum')
}
def test_update(self):
dapp = Dapp.create(constructor=self.constructor, user=self.user)
dapp.save()
fields = {
'address': '0x00',
'network_id': '2',
'has_public_access': True,
'title': 'new title'
}
for field, val in fields.items():
resp = self.app.post_json('/api/dapps/{}/update'.format(dapp.slug),
params={field: val},
headers=self.auth_header)
assert resp.status_code == 200
assert getattr(
dapp, field) != val, "field {} mustn't be equal {}".format(
field, val)
dapp.refresh_from_db()
assert getattr(dapp,
field) == val, "field {} must be equal {}".format(
field, val)
def test_add_to_dashboard(self):
user2 = User()
user2.username = '******'
user2.save()
dapp = Dapp.create(constructor=self.constructor, user=user2)
dapp.has_public_access = True
dapp.title = 'titl'
dapp.save()
assert Dapp.objects.count() == 1
resp = self.app.post_json('/api/dapps/{}/add-to-dashboard'.format(
dapp.slug),
headers=self.auth_header)
assert resp.status_code == 200
assert 'ok' in resp.json
assert Dapp.objects.count() == 2
dapps = Dapp.objects.order_by('created_at').all()
assert dapps[0].pk == dapp.pk
assert dapps[1].title == dapp.title
assert dapps[1].user_id == self.user.pk
assert dapps[1].created_at != dapps[0].created_at
def save_user(validated_data):
user = User(email=validated_data['email'])
user.set_password(validated_data['password'])
user.is_staff = False
user.is_active = True
user.email_confirmation_token = generate_unique_key(user.email)
user.save()
def save_user(validated_data):
invitation = InvitationToUserAndWarehouseAdmin.objects.filter(email=validated_data['email']).first()
if invitation is not None:
if invitation.accepted:
user = User(email=validated_data['email'])
user.set_password(validated_data['password'])
user.first_name = invitation.first_name
user.last_name = invitation.last_name
user.is_staff = False
user.is_active = True
user.role = invitation.role
user.email_confirmation_token = generate_unique_key(user.email)
user.save()
if user.role == 'general':
company_general_user = CompanyUser(user=user, company=invitation.company)
company_general_user.save()
elif user.role == 'warehouse':
warehouse_admin = CompanyWarehouseAdmins(user=user, company=invitation.company)
warehouse_admin.save()
msg = "%s %s (%s) accepted your invitation." % (
invitation.first_name, invitation.first_name, invitation.role)
from_invited_user = User.objects.filter(pk=invitation.user).first()
print(from_invited_user)
if from_invited_user.role == 'warehouse':
notif = WarehouseAdminNotifications(user=from_invited_user.id, text=msg, seen=False)
notif.save()
notification = CompanyAdminsNotification(company=invitation.company, text=msg)
notification.save()
InvitationToUserAndWarehouseAdmin.objects.filter(email=validated_data['email']).delete()
else:
raise serializers.ValidationError({'detail': 'Account not accepted.'})
else:
raise serializers.ValidationError({'detail': 'Invalid email'})
def new_user(request):
if request.is_ajax():
data = request.POST['data']
data = json.loads(data)
data.pop("id", None)
data['is_active'] = True
data['is_superuser'] = False
data['password'] = '******'
try:
user = User(**data)
user.validate_unique()
user.save()
context = {
'results': user.as_json(),
'totalProperty': 0,
'success': True
}
except ValidationError as e:
non_field_errors = e.messages
context = {
'msg': non_field_errors,
'results': [],
'totalProperty': 0,
'success': False
}
context = json.dumps(context)
return HttpResponse(context, content_type='application/json')
return Http404
def __create_contract_ui(self):
user = User()
user.save()
ui_testnet = ContractUI(
name='erc201',
slug='erc201',
blockchain='ethereum',
address='0x0123456789012345678901234567890123456789',
network_id='42',
description='qqqqqqq',
functions={'transfer': {
'title': 'arg1'
}},
abi=[],
user=user)
ui_testnet.full_clean(exclude=['abi', 'created_at', 'updated_at'])
ui_testnet.save()
ui = ContractUI(name='erc20',
slug='erc20',
blockchain='ethereum',
address='0x0123456789012345678901234567890123456789',
network_id='1',
description='qqqqqqq',
functions={'transfer': {
'title': 'arg1'
}},
abi=[],
user=user)
ui.full_clean(exclude=['abi', 'created_at', 'updated_at'])
ui.save()
return ui
def post():
form, error = JsonParser('name', 'type', 'zone', 'db_host', 'db_user', 'db_password','db_port',
Argument('desc', nullable=True, required=False)).parse()
if error is None:
host = User(**form)
host.save()
return json_response(host)
return json_response(message=error)
def create(self, validated_data: dict) -> User:
validated_data['is_enabled'] = False
validated_data['is_admin'] = False
user = User(**validated_data)
user.set_password(validated_data['password'])
user.save()
self.send_confirmation_email(user, validated_data['password'])
return user
def create(self, validated_data):
user = User(
username=validated_data['username'],
name=validated_data['name'],
)
user.set_password(validated_data['password'])
user.save()
return user
def create(self, validated_data):
password = validated_data.pop('password') if validated_data.get(
'password') else None
user = User(**validated_data)
if password and password != '':
user.set_password(password)
user.save()
return user
class RequestsCRUDIntegrationTests(WebTest):
def setUp(self):
self.constructor = Constructor.create(price=0)
self.constructor.save()
self.dapp = Dapp.create(constructor=self.constructor)
self.dapp.save()
self.user = User()
self.user.save()
self.auth_header = {
'X_ACCESSTOKEN':
UsersService().generate_token(self.user, 'ethereum')
}
def test_get_empty(self):
resp = self.app.get('/api/dapps/{}/requests'.format(self.dapp.slug))
assert resp.json == []
def test_save_error(self):
resp = self.app.post_json('/api/dapps/{}/requests'.format(
self.dapp.slug),
params={},
expect_errors=True,
headers=self.auth_header)
assert resp.status_code == 400
def test_save(self):
resp = self.app.post_json('/api/dapps/{}/requests'.format(
self.dapp.slug),
params={
'execution_datetime':
'2018-08-01T22:00:00+03:00',
'initiator_address':
'0xffee00',
'function_name':
'call_this',
'function_title':
'Call this',
'function_description':
'Call this please',
'function_arguments': [{
"title": "arg1",
'description': 'descr',
'value': 'val'
}],
'result':
55,
'is_success':
True,
},
headers=self.auth_header,
expect_errors=True)
assert resp.status_code == 201
resp = self.app.get('/api/dapps/{}/requests'.format(self.dapp.slug),
headers=self.auth_header)
assert len(resp.json) == 1
def post(self, request):
"""
对注册页面发送过来的form表单数据进行处理
:return:
"""
# 获取post请求参数
username = request.POST.get('username')
password = request.POST.get('password')
password2 = request.POST.get('password2')
uphone = request.POST.get('mobile')
code = request.POST.get('code')
email = request.POST.get('email')
allow = request.POST.get('allow') # 用户协议，勾选后得到：on
print('手机 验证码', uphone, code, request.session.get('message_code'))
# todo:检验参数合法性
# 判断参数不能为空
if not all([username, password, password2, email, uphone, code]):
return render(request, 'register.html', {'errmsg': "注册信息不能为空"})
# 判断两次输入的密码是否一致
if password != password2:
return render(request, 'register.html', {'errmsg': "两次密码不一致"})
# 判断邮箱合法
if not re.match('^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': "邮箱不合法"})
# 判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': "请勾选用户协议"})
# 判断手机输入是否正确
if not re.match('^1[345678]\d{9}$', uphone):
return render(request, 'register.html', {'errmsg': "手机输入不合法"})
# 判断验证码是否正确
if code != request.session.get('message_code'):
return render(request, 'register.html', {'errmsg': "验证码校验错误"})
# 处理业务：保存用户到数据表中
# django提供的方法，会对密码进行加密
user = User()
try:
user = User.objects.create_user(username,
email,
password,
uphone=uphone) # type: User
# 修改用户状态为未激活
user.is_active = False
user.save()
except IntegrityError:
# 判断用户是否存在
return render(request, 'register.html', {'errmsg': "用户名已存在"})
# todo:发送激活邮件
token = user.generate_active_token()
# 同步发送：会阻塞
# RegisterView.send_active_email(username, email, token)
# 使用celery异步发送：不会阻塞
# 会保存方法名
send_active_email.delay(username, email, token)
return HttpResponse("注册成功！")
def handle(self, *args, **options):
with transaction.atomic():
sponsor = User.objects.first()
sponsor.status = 'active'
sponsor.wallet = '3KRGxJLyFH7mLJG3yvwymADnDoDFzfJ73D'
sponsor.save()
plan = Plans.objects.first()
expiry_date = datetime.now() + timedelta(
days=settings.PAGSIM_EXPIRY_DAYS)
c = Charges()
c.amount = plan.down
c.expiry_date = expiry_date
c.description = "{} PLAN PAYMENT BY {}".format(
plan.name, sponsor.username)
c.identifier = uuid.uuid4().hex
c.return_url = 'http://*****:*****@example.com'.format(i)
user.status = 'active'
user.save()
c = Charges()
c.amount = plan.down
c.expiry_date = expiry_date
c.description = "{} PLAN PAYMENT BY {}".format(
plan.name, user.username)
c.identifier = uuid.uuid4().hex
c.return_url = 'http://localhost:8000{}'.format(
reverse('financial-payment-received'))
c.plan = plan
c.user = user
c.request = json.dumps([1, 2, 3])
c.response = json.dumps([1, 2, 3])
c.wallet = '3KRGxJLyFH7mLJG3yvwymADnDoDFzfJ73D'
c.transaction_status = 1
c.status = 1
c.save()
print("Creating user Demo {}".format(i))
def test_create_error(self):
new_user = User(email='*****@*****.**', password='******')
new_user.save()
biz_card = BusinessCard(user_id=new_user)
biz_card.save()
with self.assertRaises(ValueError):
new_contact = Contacts(businesscard_id=biz_card,
user_id=new_user.id)
new_contact.save()
def setUpTestData(cls):
user = User(username='******', password='******')
user.save()
for i in range(20):
question = Question(title='title{0}'.format(i),
content='content{0}'.format(i),
create_by=user,
vote_count=20 - i)
question.save()
def create(self, validated_data):
"""
This method is used to create a new user instance. In this case, is
overwritten in order to edit a field.
Default: Model.objects.create(**validated_data).
"""
user = User(**validated_data)
user.set_password(validated_data['password'])
user.save()
return user
class UserModelTest(TestCase):
def setUp(self):
self.test_user = User(email='*****@*****.**', password=PASSWORD)
self.test_user.save()
def test_user_to_string_email(self):
self.assertEquals(str(self.test_user), '*****@*****.**')
def tearDown(self):
self.test_user.delete()
def set_new_social_user_default_group(sender, instance: User, **kwargs):
if not kwargs.get('created', False):
return
if instance.origin != User.USER_ORIGIN_SOCIAL:
return
group_name = DEFAULT_USER_GROUP.val
if not group_name:
return
group = Group.objects.get(name=group_name)
instance.groups.add(group)
instance.save()
class TestContactMedia(TestCase):
def setUp(self):
self.user = User(
email="*****@*****.**",
password="******"
)
self.user.save()
self.biz_card = BusinessCard(user_id=self.user)
self.biz_card.save()
self.contact = Contacts(businesscard_id=self.biz_card,
user_id=self.user)
self.contact.save()
def register_user(self, blockchain: str, identity: str) -> User:
#todo do not allow custom usernames with prefix user_
user = User(username='******'.format(blockchain, identity),
first_name=blockchain,
last_name=identity)
user.save()
identity = UserIdentity(identity=identity,
blockchain=blockchain,
user=user)
identity.save()
return user
def setUpTestData(cls):
user = User(username='******', password='******')
user.save()
tags = [
'python,django',
'python',
'js,react',
'drf',
]
for i in range(20):
question = Question(title='title{0}'.format(i),
content='content{0}'.format(i),
create_by=user,
vote_count=20 - i)
question.save()
question.save_tags(tags[i // 5])
class AddTest(WebTest):
def setUp(self):
self.user = User()
self.user.save()
self.auth_header = {
'X_ACCESSTOKEN':
UsersService().generate_token(self.user, 'ethereum')
}
def test_add(self):
ui = ContractUI(name='erc202',
slug='erc202',
blockchain='ethereum',
description='qq',
functions={
'transfer': {
'title': 'arg1'
},
'symbol': {
'title': 'arg1'
},
'decimal': {
'title': 'arg1'
},
'name': {
'title': 'arg1'
},
},
abi=ETH_ABI)
ui.full_clean(exclude=['abi', 'created_at', 'updated_at', 'user'])
ui.save()
resp = self.app.post_json('/api/contracts_uis/1/add-to-dashboard',
params={
'network_id':
'4',
'address':
'0x000000000000000000000000000000000007'
},
headers=self.auth_header)
self.assertIn('ok', resp.json)
dapps = Dapp.objects.filter(
address='0x000000000000000000000000000000000007', network_id='4')
self.assertEqual(1, len(dapps))
self.assertEqual(dapps[0].contract_ui, ui)
def addcustomer(self, request, *args, **kwargs):
# userdn = request.user.account_id
# token = request.auth
serializer = AddCustomerSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
# name = serializer.validated_data['name']
email = serializer.validated_data['email']
user = User()
user.username = username
user.set_admin_permission('khachhang')
user.set_password(password)
# user.name = name
user.email = email
user.save()
return Response(data=user.id, status=status.HTTP_200_OK)
def test_create_with_no_unit(self):
user = User(email='*****@*****.**', password='******', is_superuser=True)
user.save()
self.assertEqual(User.objects.count(), 1)
self.client.force_authenticate(user=user)
response = self.client.post('http://0.0.0.0:8000/api/recipes',
{'title': 'Recipe'},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Recipe.objects.count(), 1)
response = self.client.post(
'http://0.0.0.0:8000/api/recipes/1/ingredients',
{'name': 'Ingredient'},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Ingredient.objects.count(), 1)
def save_user(validated_data):
user = User(email=validated_data['email'],
name=validated_data['name'],
phone_number=validated_data['phone_number'])
user.set_password(validated_data['password'])
user.is_active = False
user.email_confirmation_token = generate_unique_key(user.email)
user.save()
send_email_job_registration(
'Print Studio',
user.email,
'account_confirmation',
{
'token': user.email_confirmation_token,
'name': user.name
},
'Welcome to Print Studio',
)
def save_user(validated_data):
"""
Saving signed up user to db,
Send email address confirmation email to user.
"""
user = User(email=validated_data['email'])
user.set_password(validated_data['password'])
user.is_active = False
user.first_name = validated_data['first_name']
user.last_name = validated_data['last_name']
user.is_active = False
user.email_confirmation_token = generate_unique_key(user.email)
user.save()
send_email_job(
user.email,
'account_confirmation',
{'token': user.email_confirmation_token},
'Email Confirmation',
)
def createTempUser(request):
if "restaurant" not in request.session:
messages.error(request, "You do not have authorization to do that")
return redirect("/")
if request.method == "POST":
newUser = User(lastName=request.POST["name"],
time=datetime.datetime.now(),
partySize=request.POST["partySize"],
isTemp=True,
restaurant=Restaurant.objects.get(
id=request.session["restaurant"]))
if len(request.POST["email"]) > 0:
newUser.email = request.POST["email"]
newUser.save()
return redirect("/restaurants/dashboard")
def users_context():
init_username = '******'
init_password = '******'
user = User(
username=init_username,
name='지찬규',
)
user.set_password(init_password)
user.save()
user_session = UserSession.objects.create(user_id=user.id,
ip='127.0.0.1',
uuid=uuid4().__str__())
init_data = {
'user': user,
'session': user_session,
'init_username': init_username,
'init_password': init_password
}
return init_data
def test_add_to_dashboard(self):
user2 = User()
user2.username = '******'
user2.save()
dapp = Dapp.create(constructor=self.constructor)
dapp.has_public_access = True
dapp.title = 'titl'
dapp.save()
UserDapp.objects.create(user=user2, dapp=dapp, title=dapp.title)
assert Dapp.objects.count() == 1
resp = self.app.post_json('/api/dapps/{}/add-to-dashboard'.format(
dapp.slug),
headers=self.auth_header)
assert resp.status_code == 200
assert 'ok' in resp.json
self.assertEqual(1, Dapp.objects.count())
dapps = Dapp.objects.order_by('created_at').all()
assert dapps[0].pk == dapp.pk
self.assertIn(self.user, dapps[0].users.all())
self.assertIn(user2, dapps[0].users.all())
def MaestrosView(request,pagina):
if request.user.is_authenticated and request.user.is_staff and request.user.is_superuser:
maestros = User.objects.filter(status='Maestro')
paginator = Paginator(maestros,10)
try:
page=int(pagina)
except:
page = 1
try:
maestros=paginator.page(page)
except (EmptyPage,InvalidPage):
maestros = paginator.page(paginator.num_pages)
info = "Iniciando"
if request.method =="POST":
if "buscando" in request.POST:
try:
buscando = request.POST['buscando']
maestros = User.objects.filter(nombres__contains=buscando,status='Maestro')
info = 'Encontrados'
conte = {'informacion':info,'form':form,'maestros':maestros,'maestros':maestros}
return render_to_response('Admin/maestros.html',conte, context_instance=RequestContext(request))
except:
pass
if "id_product" in request.POST:
try:
id_producto = request.POST['id_product']
p = User.objects.get(pk=id_producto)
p.delete()#eliminamos el registro
return HttpResponseRedirect('/Administrador/maestros/page/1/')
except:
return HttpResponseRedirect('/Administrador/maestros/page/1/')
form = UserForm(request.POST,request.FILES)
if "nuevo" in request.POST:
if form.is_valid():
m = User()
username = form.cleaned_data['username']
password = form.cleaned_data['password']
nombres = form.cleaned_data['nombres']
apellidos = form.cleaned_data['apellidos']
m.username = username
m.set_password(password)
m.nombres = nombres
m.apellidos = apellidos
m.status = "Maestro"
m.is_staff = True
m.is_actve = True
m.is_superuser = False
m.save() #Guardamos la informacion
return HttpResponseRedirect('/Administrador/maestros/page/1/')
else:
form = UserForm()
info = 'Completa todos los datos'
ctx = {'informacion':info,'form':form,'maestros':maestros}
return render_to_response('Admin/maestros.html',ctx, context_instance=RequestContext(request))
else:
form = UserForm()
info = "Iniciando"
ctx = {'form':form,'informacion':info,'maestros':maestros}
return render_to_response('Admin/maestros.html',ctx, context_instance=RequestContext(request))
ctx = {'form':form,'informacion':info,'maestros':maestros}
return render_to_response('Admin/maestros.html',ctx, context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/login/')
class TestContactModel(TestCase):
def setUp(self):
self.user = User(
email="*****@*****.**",
password="******"
)
self.user.save()
self.biz_card = BusinessCard(user_id=self.user)
self.biz_card.save()
self.contact = Contacts(businesscard_id=self.biz_card,
user_id=self.user)
self.contact.save()
def test_user_create(self):
self.assertIsInstance(self.user, User)
def test_contact_create(self):
self.assertIsInstance(self.biz_card, BusinessCard)
contact = Contacts(businesscard_id=self.biz_card)
# contact.save()
self.assertIsInstance(contact, Contacts)
def test_contact_media_create(self):
contact_media = ContactMedia(user_id=self.user,
contact_id=self.contact,
img_url=create_image_file()
)
contact_media.save()
self.assertIsInstance(contact_media, ContactMedia)
self.assertRegexpMatches(
contact_media.img_url.url,
re.compile(r'.*bcards_gallery/*test.*\.png'))
def test_contact_profile_create(self):
request = HttpRequest()
request.user = self.user
contact_view_set = storeContactsViewSet()
request.data = {}
request.data['contact_profile_image'] = create_image_file()
request.data['contact_id'] = self.contact.id
request.data['user_id'] = self.contact.id
response = contact_view_set.upload_contact_profile(request)
self.assertEqual(response.status_code, 200)
def test_invalidcontact_profile_create(self):
request = HttpRequest()
request.user = self.user
contact_view_set = storeContactsViewSet()
request.data = {}
request.data['contact_profile_image'] = create_image_file()
request.data['contact_id'] = 5000
response = contact_view_set.upload_contact_profile(request)
self.assertEqual(response.status_code, 400, "Invalid Contact id")
def test_create_error(self):
new_user = User(email='*****@*****.**', password='******')
new_user.save()
biz_card = BusinessCard(user_id=new_user)
biz_card.save()
with self.assertRaises(ValueError):
new_contact = Contacts(businesscard_id=biz_card,
user_id=new_user.id)
new_contact.save()
def tearDown(self):
self.user.delete()
self.biz_card.delete()
self.contact.delete()
def AlumnosView(request,pagina):
if request.user.is_authenticated and request.user.is_staff and request.user.is_superuser:
alumnos = User.objects.filter(status='Alumno')
paginator = Paginator(alumnos,10)
try:
page=int(pagina)
except:
page = 1
try:
alumnos=paginator.page(page)
except (EmptyPage,InvalidPage):
alumnos = paginator.page(paginator.num_pages)
fecha = datetime.now()
if fecha.month == 2 or fecha.month == 9:
for alumno in alumnos:
alumno.status_semestre = True
alumno.save()
info = "Iniciando"
if request.method =="POST":
if "buscando" in request.POST:
buscando = request.POST['buscando']
try:
alumnos = User.objects.filter(username__contains=buscando,status='Alumno')
if alumnos.count() == 0:
alumnos = User.objects.filter(nombres__contains=buscando,status='Alumno')
info = 'Encontrados'
conte = {'informacion':info,'alumnos':alumnos,'alumnos':alumnos}
return render_to_response('Admin/alumnos.html',conte, context_instance=RequestContext(request))
except:
pass
if "id_product" in request.POST:
try:
id_producto = request.POST['id_product']
p = User.objects.get(pk=id_producto)
p.delete()#eliminamos el registro
return HttpResponseRedirect('/Administrador/alumnos/page/1/')
except:
return HttpResponseRedirect('/Administrador/alumnos/page/1/')
if "actualizar" in request.POST:
try:
for alu in alumnos:
if alu.status_semestre == True:
sem = int(alu.semestre)
if sem < 12:
alu.semestre = sem+1
alu.status_semestre = False
alu.save()
return HttpResponseRedirect('/Administrador/alumnos/page/1/')
except:
return HttpResponseRedirect('/Administrador/alumnos/page/1/')
formAlu = AlumnoForm(request.POST,request.FILES)
if "nuevo" in request.POST:
if formAlu.is_valid():
al = User()
username = formAlu.cleaned_data['username']
password = formAlu.cleaned_data['password']
nombres = formAlu.cleaned_data['nombres']
apellidos = formAlu.cleaned_data['apellidos']
carrera = formAlu.cleaned_data['carrera']
semestre = formAlu.cleaned_data['semestre']
al.username = username
al.set_password(password)
al.nombres = nombres
al.apellidos = apellidos
al.carrera = carrera
al.semestre = semestre
al.status = "Alumno"
al.is_staff = False
al.is_actve = True
al.is_superuser = False
al.save() #Guardamos la informacion
return HttpResponseRedirect('/Administrador/alumnos/page/1/')
else:
formAlu = AlumnoForm()
info = 'Algun dato es erroneo'
ctx = {'informacion':info,'formAlu':formAlu,'alumnos':alumnos,'fecha':fecha}
return render_to_response('Admin/alumnos.html',ctx, context_instance=RequestContext(request))
else:
formAlu = AlumnoForm()
info = "Iniciando"
ctx = {'formAlu':formAlu,'informacion':info,'alumnos':alumnos,'fecha':fecha}
return render_to_response('Admin/alumnos.html',ctx, context_instance=RequestContext(request))
ctx = {'formAlu':formAlu,'informacion':info,'alumnos':alumnos,'fecha':fecha}
return render_to_response('Admin/alumnos.html',ctx, context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/login/')
def save_booking(self, first_name, last_name, contact_number, email_from, email_to, reference_number,
message, address, suburb, state, country, postcode, appointment_date, total_price,
deposit_paid, total_owing, booking_type):
"""
Saves the booking details into the database.
:param first_name:
:param last_name:
:param contact_number:
:param email_from:
:param email_to:
:param reference_number:
:param message:
:param address:
:param suburb:
:param state:
:param country:
:param postcode:
:param appointment_date:
:param total_price:
:param deposit_paid:
:param total_owing:
:param booking_type:
:return: True if successful, False otherwise
"""
appointment_date_obj = datetime.strptime(appointment_date, '%A, %d %B %Y')
# if user exists, delete it
try:
existing_user = User.objects.get(email_address=email_to)
if not existing_user.administrator:
existing_user.first_name = first_name
existing_user.last_name = last_name
existing_user.contact_number = contact_number
existing_user.address = address
existing_user.suburb = suburb
existing_user.state = state
existing_user.postcode = country
existing_user.country = Country.objects.get(iso='AU')
existing_user.save()
except ObjectDoesNotExist:
pass
# save user detail
user = User(email_address=email_to, first_name=first_name, last_name=last_name, contact_number=contact_number,
address=address, suburb=suburb, state=state, postcode=postcode, receive_newsletter=True,
administrator=False, country=Country.objects.get(iso='AU'))
user.save()
# save booking detail
deposit_paid_arr = deposit_paid.split(' ')
deposit_paid_amount = float(deposit_paid_arr[0])
booking = Booking(reference_number=reference_number, appointment_date=appointment_date_obj,
message_to_consultant=message, paid_amount=deposit_paid_amount, email_address=user,
booking_type=BookingTypes.objects.get(name=booking_type))
booking.save()
# send confirmation email to user
self.send_confirmation_email(first_name, last_name, contact_number, email_from, email_to, reference_number,
message, address, suburb, state, country, postcode, appointment_date,
total_price, deposit_paid, total_owing, booking_type)
return True
