def prepare_period(self, config: 'DocumentDigestConfig', dst_user: User, run_date: datetime.datetime) \
-> Tuple[datetime.datetime, datetime.datetime]:
period_start = (run_date - datetime.timedelta(days=run_date.weekday())) \
.replace(hour=0, minute=0, second=0, microsecond=0)
return period_start.astimezone(
dst_user.get_time_zone()), run_date.astimezone(
dst_user.get_time_zone())
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')
def create_superuser():
app = create_app()
with app.app_context(): #app上下文入栈，不然数据库操作无法获取app
username = input('please input username:'******'username is unvalid')
return
if User.is_username_exists(username=username):
print('username is exists,please use another one')
return
password = input('please input password:'******'please input password again:').strip()
if password and password == password2:
try:
user = User(username=username,
password=password,
is_superuser=True)
db.session.add(user)
db.session.commit()
except Exception:
print('create superuser error')
return
print('create superuser success')
else:
print('failed password')
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'))
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 __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
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()
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 setUp(self):
self.user = User()
self.user.save()
self.auth_header = {
'X_ACCESSTOKEN':
UsersService().generate_token(self.user, 'ethereum')
}
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)
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 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 extend(cls):
#1. 多表join
#2. 多字段映射同一个model
author = User.alias()
relyed_user = User.alias()
return cls.select(cls, Question, relyed_user.id, relyed_user.nick_name, author.id, author.nick_name).join(
Question, join_type=JOIN.LEFT_OUTER, on=cls.question).switch(cls).join(author, join_type=JOIN.LEFT_OUTER, on=cls.user).switch(cls).join(
relyed_user, join_type=JOIN.LEFT_OUTER, on=cls.reply_user
)
def create(self, validated_data):
'''
用户注册
'''
user = User(**validated_data)
# 把token保存到user对象中,随着返回值返回给前端,Restful风格自动会返回
user.token = user.gen_jwt_token()
return user
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 run_create():
'''生成表'''
sync_db.connect()
# sync_db.create_tables([UserProfile]) # 注意：如果检查没问题后数据库仍然报 (1215, 'Cannot add foreign key constraint') 那么需要使用下面的方式创建表，具体报错原因未知，可能create_tables内执行顺序不一致
# UserProfile.create_table()
Group.create_table()
Auth.create_table()
AuthPermission.create_table()
User.create_table()
sync_db.close()
def prepare_period(self, config: 'DocumentDigestConfig', dst_user: User, run_date: datetime.datetime) \
-> Tuple[datetime.datetime, datetime.datetime]:
this_day_start = run_date.replace(hour=0,
minute=0,
second=0,
microsecond=0)
prev_day_start = this_day_start - datetime.timedelta(days=1)
return prev_day_start.astimezone(
dst_user.get_time_zone()), this_day_start.astimezone(
dst_user.get_time_zone())
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 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 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')
}
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 prepare_period(self, config: 'DocumentDigestConfig', dst_user: User, run_date: datetime.datetime) \
-> Tuple[datetime.datetime, datetime.datetime]:
period_start = DocumentDigestSendDate.objects \
.filter(config=config, to=dst_user).order_by('-date').values_list('date', flat=True).first()
if not period_start:
period_start = (run_date - datetime.timedelta(days=run_date.weekday())) \
.replace(hour=0, minute=0, second=0, microsecond=0)
return period_start.astimezone(
dst_user.get_time_zone()), run_date.astimezone(
dst_user.get_time_zone())
def setup_method(self):
self.data = {
'email': '*****@*****.**',
'password': '******',
'active': True,
'full_name': 'Teste',
'cpf_cnpj': '11111111111'
}
# Crio uma instancia do modelo User
self.model = User(**self.data)
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()
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
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 run(self):
email = input('Enter email: ')
if User.query.filter(User.email == email).first():
print('! User with login "{}" already exists.'.format(email))
return
name = input('Enter name: ')
password = input('Enter password: '******'Role (admin/user, default=user): ')
user = User(name=name, email=email, role=role or User.ROLE_USER)
user.password = generate_password_hash(password)
db.session.add(user)
db.session.commit()
def _create_random_user():
random_name = utils.random_text()
user = User(
name=random_name,
email=f"{random_name}@mail.com",
join_date=utils.random_date(),
)
if utils.random_registered():
user.registration_date = utils.random_registration_date(user.join_date)
user.is_guest = False
return user
def extend(cls):
answer_author = User.alias()
answer_relyed_user = User.alias()
return cls.select(cls, Question, answer_relyed_user.id,
answer_relyed_user.nick_name, answer_author.id,
answer_author.nick_name).join(
Question,
join_type=JOIN.LEFT_OUTER,
on=cls.question).switch(cls).join(
answer_author,
join_type=JOIN.LEFT_OUTER,
on=cls.user).switch(cls).join(
answer_relyed_user,
join_type=JOIN.LEFT_OUTER,
on=cls.reply_user)
def validate(self, attrs):
'''
用户登录行为验证
'''
user = User.objects.filter(mobile=attrs["mobile"]).first()
if not user:
user = User(username=attrs["mobile"],mobile = attrs["mobile"],nick="用户{}".format(attrs["mobile"])).save()
if attrs['code'] != "111": #redis里面获取值,然后判断是否相等
raise ValidationError("验证码不正确")
# 把token保存到user对象中,随着返回值返回给前端,Restful风格自动会返回
attrs["token"] = user.gen_jwt_token()
attrs["id"] = user.id
return attrs
def get(self):
schema = UserSchema(many=True)
args = request.args
page_id = int(args["page"]) if args.get("page") else 1
page_size = int(args["page_size"]) if args.get("page_size") and args.get("page_size") < 1 \
else 10
try:
users = User.objects()
count = users.count()
if count == 0:
return resp_does_not_exist_resources("User", "usuário")
if count <= ((page_id-1)*page_size):
page_id = ceil(count/page_size)
users = users.paginate(page_id, page_size)
except FieldDoesNotExist as e:
return resp_exception("Users", description=e.__str__()+"field")
except Exception as e:
return resp_exception("Users", description=e.__str__())
extra = {
"page": users.page, "pages": users.pages, "total": users.total,
"params": {"page_size":page_size}
}
result = schema.dump(users.items)
return resp_ok(
"Users", MSG_RESOURCE_FETCHED_PAGINATED.format("Usuários"), result, **extra)
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])
async def post(self, *args, **kwargs):
param = self.request.body.decode('utf-8')
param = json.loads(param)
form = RestPasswordForm.from_json(param)
account = form.account.data
password = form.password.data
if account is None:
self.json(Result(code=10080, msg="参数有误, 不可缺少account参数."))
if password is None:
self.json(Result(code=10080, msg="参数有误, 不可缺少password参数."))
if form.validate():
try:
user = await self.application.objects.get(User,
account=account)
await self.application.objects.execute(
User.update(password=password).where(
User.account == account))
return self.json(Result(code=1, msg="修改密码成功！"))
except User.DoesNotExist:
return self.json(Result(code=10090, msg="该账号尚未被注册!"))
else:
return self.json(Result(code=10090, msg=form.errors))
def post(self):
form = UserForm()
if form.validate_on_submit():
user = User(
username=form.username.data,
email=form.email.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
avatar='',
is_active=True
)
user.set_password(form.password1.data)
db.session.add(user)
db.session.commit()
return redirect(url_for('admin.UserListView:index'))
else:
context = self.get_context_data()
context['form'] = form
return render_template('/admin/user_create.html', **context)
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()
def test_user_get_short_name():
user = User(email='*****@*****.**')
assert user.get_short_name() == '*****@*****.**'
username = raw_input("Username: "******"Username is require!")
sys.exit(False)
email = raw_input("Email: ")
if not email:
print("Email is require!")
sys.exit(False)
password = raw_input("Password: "******"Password is require!")
sys.exit(False)
re_password = raw_input("Re password: "******"Re Password is not equal password!")
sys.exit(False)
# Save information to database
try:
user = User(username=username, email=email)
user.set_password(password)
db.session.add(user)
db.session.commit()
except Exception as error:
print("Create superuser error!", error)
sys.exit(False)
print("Create superuser success!")
sys.exit(True)
manager.run()
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 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
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/')
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/')
