def save_user_from_row(user_row):
user = User()
try:
user.id = User.objects.last().pk + 1 #user_row[0]
except: #TypeError:
user.id = 1
user.username = user_row[1]
user.save()
def authenticate(self, username=None, password=None):
if username is None:
return None
user = User(username, password)
# TODO Perform authentication against TDA
if username == 'Aladdin' and password == 'open sesame':
user.id = 1
user.is_staff = False
elif username == 'admin' and password == 'admin':
user.id = 2
user.is_staff = True
else:
user = None
return user
def solo(request, producto_id):
product=producto.objects.get(id= producto_id)
comentarios = comentario.objects.filter(item_id= producto_id)
print(product.tienda_id)
ids= product.tienda_id
tien=tienda.objects.get(id=ids)
page = request.GET.get('page',1)
try:
paginator = Paginator(comentarios, 3)
comentarios = paginator.page(page)
except:
raise Http404
if request.method == 'POST':
pe = pedido()
pe.item = product
pe.cantidad = int(request.POST.get('cantidad'))
pe.contacto = int(request.POST.get('contacto'))
pe.direccion = request.POST.get('direccion')
pe.detalle = request.POST.get('detalle')
pe.precio = int(request.POST.get('total'))
pe.enviado = False
us = User()
us.id = int(request.POST.get('usid'))
pe.cliente = us
pe.local = tien
pe.save()
send_email(pe)
return render(request, "confirma.html",{ "tienda":tien })
return render(request, "solo.html",{"producto":product, "tienda":tien ,"entity":comentarios})
def get(self, request, *args, **kwargs):
cedula = self.kwargs['cedula']
datos_n = Datos.objects.get(cedula=cedula)
nombre = datos_n.p_nombre.strip()
apellido = datos_n.p_apellido
usuario_clave = nombre[:1] + apellido
usuario_clave = usuario_clave.lower()
clave = handler.encrypt(usuario_clave)
datos_u = User.objects.all().order_by('-id')[:1]
datos_u_v = datos_u.values('id')
ultimo_id_user = datos_u_v[0]['id'] + 1
useradd = User()
useradd.id = ultimo_id_user
useradd.username = cedula
useradd.password = clave
useradd.first_name = nombre
useradd.last_name = apellido
useradd.is_active = False
useradd.save()
ultimo = useradd.id
datos_user = Datos.objects.all()
datos_user_f = datos_user.filter(cedula=cedula)
datos_user_f.update(usuario_id=ultimo, grupo_usuario=3)
return HttpResponse('<div>Creando...</div>')
def create_weiboUser(wname,uid):
temp=Users.objects.create(name=wname,password=uid,weibo_id=uid,login_type=1)
user=User()
user.username=wname
user.set_password(uid)
user.id=temp.id
user.save()
def handle(self, *args, **options):
cursors = {
"default": connections["default"].cursor(),
"old": connections["old"].cursor(),
}
# User model
cursors["old"].execute("SELECT * FROM auth_user ORDER BY id")
for row in cursors["old"].fetchall():
if User.objects.filter(username=row[1]).exists():
continue
u = User()
u.id = row[0]
u.username = row[1]
u.first_name = row[2]
u.last_name = row[3]
u.email = row[4]
u.password = row[5]
u.is_staff = row[6]
u.is_active = row[7]
u.is_superuser = row[8]
u.last_login = row[9]
u.date_joined = row[10]
u.save()
EmailAddress(user=u, email=u.email, verified=True, primary=True).save()
print "[User] migrated %s" % u.username
cursors["default"].execute("SELECT setval('auth_user_id_seq', (SELECT max(id) FROM auth_user))")
def get_or_create_customer(buyer_id):
cus_conn = get_temp_conn()
t_cursor = cus_conn.cursor()
t_cursor.execute("select %s from flashsale_customer where id=%d " %
(','.join(BUYER_FIELDS), buyer_id))
buyer_tuple = t_cursor.fetchone()
buyer_dict = dict(zip(BUYER_FIELDS, buyer_tuple))
t_cursor.execute("select %s from auth_user where id=%d " %
(','.join(USER_FIELDS), buyer_dict['user_id']))
user_tuple = t_cursor.fetchone()
user_dict = dict(zip(USER_FIELDS, user_tuple))
t_cursor.close()
cus_conn.close()
buyer = Customer.objects.normal_customer.filter(
unionid=buyer_dict['unionid']).first()
if buyer:
return buyer
user = User.objects.filter(username=buyer_dict['unionid']).first()
if not user:
user = User()
for k, v in user_dict.items():
setattr(user, k, v)
user.id = None
user.save()
buyer = Customer()
for k, v in buyer_dict.items():
setattr(buyer, k, v)
buyer.id = None
buyer.user = user
buyer.save()
return buyer
def handle(self, *args, **kwargs):
print('Deleting User')
for u in User.objects.all():
try:
u.delete()
except:
pass
try:
u = User.objects.get(username='******')
except:
u = User()
u.id = 1
u.username = '******'
u.is_active = True
u.is_superuser = True
u.is_staff = True
u.save()
u.set_password('admin')
u.save()
pr = u.profile
pr.name = 'Админ Админович'
pr.phone = '081234567'
pr.save()
print('Creating superuser login admin password admin.')
def create_myUser(uname,psword):
temp=Users.objects.create(name=uname,password=psword,login_type=0)
user=User()
user.username=uname
user.set_password(psword)
user.id=temp.id
user.save()
def update_profile(request, id):
if request.method == 'POST':
try:
pro = profile.objects.get(id=User.objects.get(id=id).profile.id)
pro.delete()
user = User()
user.id = request.user.id
user.first_name, user.last_name, user.profile.profile_discreption, user.profile.image = request.POST[
'first_name'], request.POST['last_name'], request.POST[
'profile_discreption'], request.FILES['image']
user.profile.user = request.user
user.save()
except:
pro = profile()
pro.user = request.user
pro.profile_discreption = request.POST['profile_discreption']
pro.image = request.FILES['image']
pro.save()
user = User.objects.get(id=id)
user.first_name, user.last_name = request.POST[
'first_name'], request.POST['last_name']
user.save()
return redirect(request.META.get('HTTP_REFERER'))
def save_user_from_row(user_row):
user = User()
user.id = user_row[0] + 1
user.username = user_row[1]
# review.wine = Wine.objects.get(id=review_row[2])
# review.rating = review_row[3]
# review.pub_date = datetime.datetime.now()
# review.comment = review_row[4]
user.save()
def create_user(self, is_active=True):
user = User()
user.id = 1
user.username = '******'
user.email = '*****@*****.**'
user.first_name = 'first'
user.set_password('1234')
user.is_active = is_active
user.save()
def save_user_from_row(user_row):
user = User()
user.id = user_row[1]
user.username = user_row[2]
user.age = user_row[5]
user.gender = user_row[6]
user.occupation = user_row[0]
print(user.id, user.username, user.age, user.gender, user.occupation)
user.save()
def setUp(self):
test_user = User()
test_user.id = 1
try:
test_user.username = "******"
except Exception, e:
print e
test_user.username = "******"
def setUp(self):
test_user = User()
test_user.id = 1
try:
test_user.username = "******"
except Exception, e:
print e
test_user.username = "******"
def start(self):
c = int(self.count / 10)
for i in range(c):
t1 = Team(
name='team_{}'.format(i),
games=self.count,
)
t2 = Team(
name='team_{}'.format(i),
games=self.count,
)
t1.save(using='db1')
t2.save(using='db2')
for j in range(10):
u = User(username='******'.format(j + 10 * i),
email='ivan@ivan{}.ru'.format(j + 10 * i))
u.set_password('ivan123')
u.first_name = 'ivan{}'.format(j + 10 * i)
u.last_name = 'ivanov{}'.format(j + 10 * i)
ran_db = random.randint(1, 2)
u.id = int(get_pk() + str(ran_db))
print(u.id)
u.save(using='db' + str(ran_db))
if ran_db == 1:
tu = UserTeam(
user=u,
team=t1,
)
else:
tu = UserTeam(
user=u,
team=t2,
)
tu.save(using='db' + str(ran_db))
cc = int(self.count / 100)
for i in range(cc):
t = Turn(name='turn{}'.format(i))
t.save(using='db1')
t.save(using='db2')
for j in range(10):
m = Match(name='match{}'.format(j + 10 * i), turn_id=t.id)
m.save(using='db1')
m.save(using='db2')
for l in range(10):
g = Game(name='game___{}'.format(l + 10 * j + 100 * i),
match_id=m.id)
ran_db = random.randint(1, 2)
g.id = int(get_pk() + str(ran_db))
g.save(using='db' + str(ran_db))
tm = Team.objects.using('db' + str(ran_db)).filter(
name='team_{}'.format(j + 10 * i))[0]
gt = GameTeam(game=g, team=tm)
gt.save(using='db' + str(ran_db))
def test_username_already_in_use(self):
user = User()
user.id = 1
user.first_name = 'name'
user.username = '******'
user.email = '*****@*****.**'
user.set_password('1234')
user.save()
request = Mock(POST=self.data)
form = UserForm(request)
self.assertFalse(form.is_valid())
def createUserDB(apps, schema_editor):
usersDF = getUserDataFrame()
for index in usersDF.index:
userID, zipCode = usersDF['userID'][index], str(
usersDF['zipCode'][index])
newUser = User(username=str(userID))
newUser.set_password(zipCode)
newUser.id = userID
newUser.save()
def save_user_from_row(user_row):
user = User()
user.id = user_row[0]
user.username = user_row[1]
user.first_name = user_row[2]
user.last_name = user_row[3]
user.is_superuser = 0
user.email = user_row[4]
user.is_staff = 0
user.is_active = 1
user.date_joined = user_row[5]
user.save()
def multidb_user_creation(sender, instance, action, **kwargs):
if action == 'post_add' and instance.notification:
dbs = instance.databases.all()
for db in dbs:
user = User(username=instance.user.username,
password=instance.user.password,
email=instance.user.email)
user.id = instance.user.id
user.save(using=db.name)
dbuser = DatabaseUser(user=user, notification=False)
dbuser.id = instance.id
dbuser.save(using=db.name, force_insert=True)
def setUp(self):
self.data = {'first_name': 'first_name',
'email': '*****@*****.**'}
user = User()
user.id = 1
user.first_name = 'name'
user.username = '******'
user.email = '*****@*****.**'
user.set_password('1234')
self.user = user
self.user.save()
def setUp(self):
self.data = {'password': '******',
'confirm_password': '******'}
user = User()
user.id = 1
user.first_name = 'name'
user.username = '******'
user.email = '*****@*****.**'
user.set_password('1234')
self.user = user
self.user.save()
def test_has_user_voted_for_song(self):
vote_service = VoteService()
vote = Vote()
vote.user_id = 1
vote.song_id = 1
vote.created_date = datetime.now()
vote.like = True
vote.save()
user = User()
user.id = 1
song = Song
song.id = 1
self.assertTrue(vote_service.has_user_voted_for_song(song, user))
def test_logout_view(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name="Unit",
last_name="Test")
user.save()
user.id = 99
profile = Profile(user=user, reports=0, user_type=0)
profile.save()
c = Client()
login_result = c.login(username='******', password='******')
self.assertFalse(login_result)
def get_all_users():
reader = open('dataset/u.data', 'r')
count = 0
for line in reader:
line = line.split('\t')
user = User()
user.id = int(line[0])
user.username = line[0]
if not User.objects.filter(id=int(line[0])).exists():
user.save()
print(count)
count += 1
reader.close()
def registroSesion(request):
status = 200
success = 'Ok'
error = 'Nada'
if request.method == 'POST' and request.is_ajax(): # If the form has been submitted...
# form = SurfSesionRegister(request.POST) # A form bound to the POST data
surf_sesion = SurfSesionRegister()
if request.is_ajax(): # All validation rules pass
try:
spot_id = request.POST.get("surfspot")
user_id = request.user.id
horaInicio = request.POST.get("horaInicio")
horaFin = request.POST.get("horaFin")
fecha = request.POST.get("fecha")
fecha1 = datetime.strptime(fecha, "%d-%m-%Y").strftime("%Y-%m-%d")
tipoTabla = request.POST.get("tipoTabla")
feetTabla = request.POST.get("feetTabla")
inchesTabla = request.POST.get("inchesTabla")
estrellas = request.POST.get("estrellas")
spot = SurfSpot()
user = User()
spot.id = spot_id
user.id = user_id
surf_sesion.surfspot = spot
surf_sesion.user = user
surf_sesion.horaInicio = horaInicio
surf_sesion.horaFin = horaFin
surf_sesion.fecha = fecha1
surf_sesion.tipoTabla = tipoTabla
surf_sesion.feetTabla = feetTabla
surf_sesion.inchesTabla = inchesTabla
surf_sesion.estrellas = estrellas
# Save new surf_sesion attributes
surf_sesion.save()
success = 'Registro guardado con exito'
except:
status = constants.Status.CONFLICT
error = 'Error en el formulario'
else:
error = 'Error en el formulario'
status = constants.Status.CONFLICT
return HttpResponse({'error': error, 'success': success}, status=status)
def get_user(self, user_id):
try:
user_url = api_url+"Users/%s" % user_id
response = requests.get(user_url)
if response.status_code == 404:
return None
user_object = response.json()
user = User(username=user_object['Name'], password=user_object['Password'], id=user_object['Id'])
user.id = user_object['Id']
user.save = save
return user
except User.DoesNotExist:
return None
def init_user(**data_user):
"""
Fonction qui crée et initialise un User et le renvoie.
Contient :
- l'id du User
- son nom d'utilisateur
- son email
- son mot de passe
:param int or str data_user:
:return: return the User created
"""
user = User(username=data_user['username'], email=data_user['email'], password=data_user['password'])
user.id = data_user['id']
user.save()
return user
def authenticate(self, username=None, password=None):
user_url = api_url+"Users/0/?name=%s" % username
response = requests.get(user_url)
if response.status_code == 404:
return None
user_object = response.json()
if user_object is not None:
if user_object['Password'] == password:
user = User(username=user_object['Name'], password=user_object['Password'], id=user_object['Id'])
user.id = user_object['Id']
user.save = save
return user
return None
def test_user_has_permission_product_type_member_no_permission(self, mock_get):
other_user = User()
other_user.id = 2
product_type_member_other_user = Product_Type_Member()
product_type_member_other_user.id = 2
product_type_member_other_user.user = other_user
product_type_member_other_user.product_type = self.product_type
product_type_member_other_user.role = Roles.Reader
mock_get.return_value = product_type_member_other_user
result = user_has_permission(other_user, self.product_type_member_owner, Permissions.Product_Type_Member_Delete)
self.assertFalse(result)
self.assertEqual(mock_get.call_args[1]['user'], other_user)
self.assertEqual(mock_get.call_args[1]['product_type'], self.product_type)
def test_saving_and_retrieving_users(self):
new_user = User()
new_user.username = "******"
new_user.id = 3
new_user.email = "*****@*****.**"
new_user.first_name = "Nemo"
new_user.last_name = "the Fish"
new_user.save()
saved_users = User.objects.all()
first_saved_user = saved_users[0]
self.assertTrue(saved_users.count > 10)
self.assertEqual(first_saved_user.email, "*****@*****.**")
def test_user_has_permission_product_member_success(self, mock_get):
other_user = User()
other_user.id = 2
product_member_other_user = Product_Member()
product_member_other_user.id = 2
product_member_other_user.user = other_user
product_member_other_user.product_type = self.product
product_member_other_user.role = Roles.Owner
mock_get.return_value = product_member_other_user
result = user_has_permission(other_user, self.product_member_reader, Permissions.Product_Member_Delete)
self.assertTrue(result)
self.assertEqual(mock_get.call_args[1]['user'], other_user)
self.assertEqual(mock_get.call_args[1]['product'], self.product)
def UserLogin(request):
if request.method == "POST":
from main.models import User
# Find if User already exists
newUser = User()
oldUser = User.objects.filter(facebook_id=request.POST["id"])
if len(oldUser) > 0:
newUser.id = oldUser[0].id
newUser.token = oldUser[0].token
else:
import string, random
chars = string.ascii_uppercase + string.digits + string.ascii_lowercase
newUser.token = "".join(random.choice(chars) for x in range(40))
# Update user data
if "name" in request.POST:
newUser.name = request.POST["name"]
if "first_name" in request.POST:
newUser.first_name = request.POST["first_name"]
if "last_name" in request.POST:
newUser.last_name = request.POST["last_name"]
if "username" in request.POST:
newUser.username = request.POST["username"]
if "email" in request.POST:
newUser.email = request.POST["email"]
if "gender" in request.POST:
newUser.gender = request.POST["gender"]
# if 'birthday' in request.POST:
# user.birthday = request.POST['birthday']
newUser.avatar = "http://graph.facebook.com/" + request.POST["id"] + "/picture"
newUser.facebook_id = request.POST["id"]
newUser.save()
context = {"token": newUser.token}
else:
context = {"token": "Forbidden"}
return render_to_response("login.html", context, context_instance=RequestContext(request))
def test_user_has_permission_product_member_success(self, mock_foo):
other_user = User()
other_user.id = 2
product_member_other_user = Product_Member()
product_member_other_user.id = 2
product_member_other_user.user = other_user
product_member_other_user.product = self.product
product_member_other_user.role = Role.objects.get(id=Roles.Owner)
mock_foo.select_related.return_value = mock_foo
mock_foo.select_related.return_value = mock_foo
mock_foo.filter.return_value = [product_member_other_user]
result = user_has_permission(other_user, self.product_member_reader, Permissions.Product_Member_Delete)
self.assertTrue(result)
mock_foo.filter.assert_called_with(user=other_user)
def UserLogin(request):
if request.method == 'POST':
from main.models import User
# Find if User already exists
newUser = User()
oldUser = User.objects.filter(facebook_id=request.POST['id'])
if len(oldUser) > 0:
newUser.id = oldUser[0].id
newUser.token = oldUser[0].token
else:
import string, random
chars = string.ascii_uppercase + string.digits + string.ascii_lowercase
newUser.token = ''.join(random.choice(chars) for x in range(40))
# Update user data
if 'name' in request.POST:
newUser.name = request.POST['name']
if 'first_name' in request.POST:
newUser.first_name = request.POST['first_name']
if 'last_name' in request.POST:
newUser.last_name = request.POST['last_name']
if 'username' in request.POST:
newUser.username = request.POST['username']
if 'email' in request.POST:
newUser.email = request.POST['email']
if 'gender' in request.POST:
newUser.gender = request.POST['gender']
#if 'birthday' in request.POST:
# user.birthday = request.POST['birthday']
newUser.avatar = 'http://graph.facebook.com/' + request.POST['id'] + '/picture'
newUser.facebook_id = request.POST['id']
newUser.save()
context = { 'token': newUser.token }
else:
context = { 'token': 'Forbidden' }
return render_to_response('login.html', context, context_instance=RequestContext(request))
def importUsers(editors):
from session.models import OldUser, OldPassword
from django.contrib.auth.models import User
from django.utils import six, timezone
all_users = OldUser.objects.all()
for u in all_users:
if u.username == 'God':
continue
if User.objects.filter(username=u.username).exists():
newUser = User.objects.get(username=u.username)
else:
# We want the user id to match the old user id, so
# comments and everything else continue to work.
# Therefore we aren't using the usual function to
# create a user:
# newUser = User.objects.create_user(u.username)
#
# Instead we do it manually
now = timezone.now()
newUser = User(username=u.username,
is_staff=False,
is_active=True,
is_superuser=False,
date_joined=now)
newUser.id = u.id
newUser.save()
# now we copy over some properties
if u.first is not None:
newUser.first_name = u.first
if u.last is not None:
newUser.last_name = u.last
if u.admin == True:
newUser.is_staff = True
if u.cdeditor == True:
editors.user_set.add(newUser)
if u.active == True:
newUser.is_active = True
else:
newUser.is_active = False
if u.password is not None:
OldPassword.objects.filter(user=newUser).delete()
OldPassword.objects.create(user=newUser, password=u.password)
newUser.save()
def forwards(self, orm):
user = User()
user.id = 1
user.username = '******'
user.first_name = 'Guedes'
user.email = '*****@*****.**'
user.set_password('asdfgh')
user.is_staff = True
user.is_active = True
user.is_superuser = True
user.save()
nonprofit = orm.Nonprofit()
nonprofit.user = orm['auth.User'].objects.get(id=1)
nonprofit.name = 'Atados'
nonprofit.slug = 'atados'
nonprofit.save()
def test_setParamsSerializer(self):
from ..serializer import ParamsSerializer, s
from myadmin.models.user import User
class AdminSerializer(BaseModelSerializer):
f1 = s.CharField(label=_('f1'), default='default f1')
f2 = s.CharField(label=_('f2'),
default='default f1',
allow_null=True,
required=False)
class Meta:
model = User
fields = '__all__'
u = User()
u.username = '******'
u.id = 3
a = AdminSerializer(instance=u,
data={
'username': '******',
'alias': 'alias'
}).o
a.f1 = 'f1'
a.username = '******'
self.assertEqual(a.f1, 'f1')
self.assertTrue(a.get('f1'), 'f1')
self.assertEqual(a.username, 'c_username')
self.assertTrue(a.get('username'), 'c_username')
class ChangePasswordSerializer(ParamsSerializer):
old_password = s.CharField(label=_('旧密码'))
new_password1 = s.CharField(label=_('新密码'), default='3')
new_password2 = s.CharField(label=_('确认密码'))
ss = ChangePasswordSerializer()
ss.o.old_password = '******'
ss.new_password2 = 'asd'
# ss.validation()
self.assertEqual(ss.data.old_password, 'asd')
from framework.utils import json_dumps
self.assertEqual(json_dumps(ss),
json_dumps(json.loads(json_dumps(ss))))
def new_shrt(request):
#1)
if request.method == 'POST':
form = ShrtForm(request.POST)
#2)
if form.is_valid():
#user ?
if request.user.is_authenticated():
user = request.user
else:
user = User()
user.id = 0
human = True
#create a md5sum on the urlfull
urlmd5 = hashlib.md5(form.cleaned_data['urlfull'])
#get the size of the random shortener string
length = settings.SHRT
#let's generate the shortener string
shrt = urlshortener()
urlshort = shrt.run(length["url_size"])
#start an instance of the form
new_shortener = form.save(commit=False)
#assign the shortener
new_shortener.urlshort = urlshort
#assign the urlmd5 calculated "before" the "try/except"
new_shortener.urlmd5 = urlmd5.hexdigest()
#assign the user object
new_shortener.user = user
#finally : SAVE !
new_shortener.save()
return redirect(home)
#part done while the request.methode != POST or form is not valid
context = {'form': form, 'shrt': Shrt.objects.all}
context.update(csrf(request))
return render_to_response('django_shortener/home.html',
context,
context_instance=RequestContext(request))
def pedidos(request, tienda_id, producto_id):
tien = tienda.objects.get(id = tienda_id)
product=producto.objects.get(id= producto_id)
if request.method == 'POST':
print('printing POST::: ', request.POST)
pe = pedido()
pe.item = product
pe.cantidad = int(request.POST.get('cantidad'))
pe.contacto = int(request.POST.get('contacto'))
pe.direccion = request.POST.get('direccion')
pe.detalle = request.POST.get('detalle')
pe.precio = int(request.POST.get('total'))
us = User()
us.id = int(request.POST.get('usid'))
pe.cliente = us
pe.local = tien
pe.save()
return redirect('/entra')
return render(request, "pedido.html",{"producto":product})
def show_list(request, doctor='department', specialty='all'):
queries = []
queries.append( 'Begin: %i' % len(connection.queries) )
# get the doctors to list on the sidebar filter
DocGroup = AuthGroup.objects.get(name='Provider')
doctors_list = DocGroup.user_set.select_related().order_by('last_name','first_name')
queries.append( 'Post Docs: %i' % len(connection.queries) )
# determine if the "doctor" being viewed is valid or the generic department list
if doctor == 'department':
selected_doctor = User()
selected_doctor.id = 0
selected_doctor.username = "******"
else:
# if someone fiddles with the URL and gives an invalid doc, then 404
selected_doctor = get_object_or_404(User, username=doctor)
# determine if the specialty being viewed is valid or all specialties
if specialty == 'all':
selected_specialty = Specialty()
selected_specialty.id = 0
selected_specialty.slug = "all"
specialties = list(Specialty.objects.all())
else:
# if someone fiddles with the URL and gives an invalid specialty, then 404
selected_specialty = get_object_or_404(Specialty, slug=specialty)
specialties = [selected_specialty]
queries.append( 'Post Selected: %i' % len(connection.queries) )
cache_key = "%i,%i,%i" % ( settings.SITE_ID, selected_doctor.id, selected_specialty.id)
logging.debug('Lookup on %s' % cache_key)
cached_info = cache.get( cache_key )
if not cached_info:
# build the full tree of specialt(y|ies)/group(s)/specialist(s)
specialty_list = build_tree(specialties)
queries.append( 'Post Tree construction: %i' % len(connection.queries) )
if selected_doctor.id:
queries.append( 'Pre-UP Sets: %i' % len(connection.queries) )
upg_set = set([ dict.values()[0] for dict in UserPreferredGroup.objects.filter(user=selected_doctor).values('group') ])
ups_set = set([ dict.values()[0] for dict in UserPreferredSpecialist.objects.filter(user=selected_doctor).values('specialist') ])
queries.append( 'Post-UP Sets: %i' % len(connection.queries) )
for specialty in specialty_list:
for group in specialty.group_list:
group.preferred = group.id in upg_set
for specialist in group.specialist_list:
specialist.preferred = specialist.id in ups_set
queries.append( 'Post Preferred: %i' % len(connection.queries) )
cache.set( cache_key, specialty_list)
else:
specialty_list = cached_info
all_specialties = Specialty.objects.all().order_by('name')
context_dict = {
'doctors_list' : doctors_list,
'all_specialties' : all_specialties,
'specialty_list' : specialty_list,
'selected_doctor' : selected_doctor,
'selected_specialty' : selected_specialty,
'query_count' : "<br>".join(queries),
}
if selected_doctor == request.user:
return render_to_response('user_preferred_list.html', context_dict, context_instance=RequestContext(request))
#elif request.user.username == 'jwineinger' and selected_doctor.id == 0:
# return render_to_response('preferred_list.html', context_dict, context_instance=RequestContext(request))
else:
return render_to_response('noneditable_referral_list.html', context_dict, context_instance=RequestContext(request))
def save_user_from_row(user_row):
user = User()
user.id = user_row[0]
user.username = user_row[1]
user.save()
def setUp(self):
test_user = User(username=self.USERNAME)
test_user.id = 2
test_user.set_password(self.PASSWORD)
test_user.email = self.EMAIL
test_user.save()
#from geohealth.models import Birds
#il = list(Birds.objects.all())
#objects = Birds.objects.order_by("animal","gmt_date").distinct("animal","gmt_date")
from django.contrib.auth.models import User
from accounts.models import Profile, user_post_save
from accounts.fields import COUNTRIES
from photos.models import Photo, PhotoUser
objects = PhotoUser.objects.all().filter(id__gt=760)
l = list(objects)
print len(l)
models.signals.post_save.disconnect(user_post_save, User)
for pu in l:
u = User()
u.id = pu.id
u.username = pu.username
u.password = pu.password
u.email = pu.email
u.date_joined = pu.createdate
if type(pu.timestamp) == int:
u.last_login = datetime.fromtimestamp(pu.timestamp)
if pu.name is not None:
names = pu.name.strip().split(' ',1)
for n in names:
if len(n) > 29:
print n
if len(names) == 1:
u.first_name = names[0].strip()
def user_save(request):
user = App.get_user_info(request)
if not user:
return HttpResponse(json.dumps({
'code': 66,
'msg': u'login error！'
}),
content_type='application/json')
if request.method == 'POST':
username = request.POST.get('username', '')
password = request.POST.get('password', '')
email = request.POST.get('email', '')
other_email = request.POST.get('other_email', '')
email_pass = request.POST.get('email_pass', '')
smtp_server = request.POST.get('smtp_server', '')
stocks_role = request.POST.get('stocks_role', '')
id = request.POST.get('id', '')
if email_pass:
email_pass = common.encrypt(16, email_pass)
if not id:
if not username or not password:
return HttpResponse(json.dumps({
'code':
0,
'msg':
u'Username/Password is empty！'
}),
content_type='application/json')
check = User.objects.filter(username=username)
if check:
return HttpResponse(json.dumps({
'code': 0,
'msg': u'Username is existed！'
}),
content_type='application/json')
user = User()
user.username = username
user.set_password(password)
user.email = email
user.id
user.save()
user_file = UserProfile()
user_file.id = user.userprofile.id
user_file.user_id = user.id
user_file.role = 99
user_file.stocks_role = stocks_role
user_file.other_email = other_email
user_file.email_pass = email_pass
user_file.smtp_server = smtp_server
user_file.state = 1
user_file.save()
return HttpResponse(json.dumps({
'code': 1,
'msg': u'Work is done!'
}),
content_type='application/json')
else:
if not username:
return HttpResponse(json.dumps({
'code': 0,
'msg': u'Username is empty！'
}),
content_type='application/json')
check = User.objects.filter(username=username).exclude(id=id)
if check:
return HttpResponse(json.dumps({
'code': 0,
'msg': u'Username is existed！'
}),
content_type='application/json')
update_fields = ['username', 'email']
user = User()
user.username = username
if password:
user.set_password(password)
update_fields.append('password')
user.email = email
user.id = id
user.save(update_fields=update_fields)
obj = UserProfile.objects.filter(user_id=id)
if obj:
obj.update(stocks_role=stocks_role,
other_email=other_email,
email_pass=email_pass,
smtp_server=smtp_server)
return HttpResponse(json.dumps({
'code': 1,
'msg': u'Work is done!'
}),
content_type='application/json')
def save_user(self):
user = App.get_user_info(self)
if not user:
return HttpResponseRedirect("/admin/maxlead_site/login/")
if self.method == 'POST':
user_id = self.POST.get('id', '')
group = self.POST.get('group', 1)
user_file = user
update_fields = ['username', 'email']
update_fields1 = ['state', 'role', 'group']
if user_file.role == 2:
user = User()
user.username = self.POST.get('username', '')
if self.POST.get('password', ''):
user.set_password(self.POST.get('password', ''))
update_fields.append('password')
user.email = self.POST.get('email', '')
if user_id:
user_pro = UserProfile.objects.get(id=user_id)
user.id = user_pro.user.id
user.save(update_fields=update_fields)
else:
user.id
user.save()
user_file = UserProfile()
user_file.id = user.userprofile.id
user_file.user_id = user.id
user_file.state = self.POST.get('state', '')
user_file.role = self.POST.get('role', '')
if user_file.role == '1':
group = user_file.id
if not group:
group = 1
user_file.group = UserProfile.objects.filter(id=int(group))[0]
user_file.save(update_fields=update_fields1)
return HttpResponseRedirect("/admin/maxlead_site/user_list/")
else:
if user_id and int(user_id) == user.id:
user = User()
user.id = user_file.user.id
user.username = self.POST.get('username', '')
user.email = self.POST.get('email', '')
if self.POST.get('password', ''):
user.set_password(self.POST.get('password', ''))
update_fields.append('password')
user.save(update_fields=update_fields)
user_file = UserProfile()
user_file.id = user.id
return HttpResponseRedirect("/admin/maxlead_site/user_detail/")
else:
if user.role == 2:
menber_group = UserProfile.objects.filter(role=1,
state=1).all()
return render(
self, 'user/add.html', {
'user': user,
'avator': user.user.username[0],
'member_groups': menber_group
})
else:
return HttpResponseRedirect("/admin/maxlead_site/index/")
def testlogin(request,uid=''):
user = User()
user.id = uid
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request,user)
return HttpResponseRedirect('/')
from signbank.video.models import *
import os
import shutil
import json
json_data = open("/var/www/signbank/repo/signbank/dictionary/users.json",
encoding="utf-8")
data1 = json.load(json_data)
json_data = open("/var/www/signbank/repo/signbank/dictionary/migracao.json",
encoding="utf-8")
data2 = json.load(json_data)
for user in data1["usuarios"]:
usuario = User()
usuario.id = user["id"]
usuario.username = user["nome"]
usuario.email = user["email"]
usuario.first_name = user["nomeCompleto"].split(" ", 1)[0]
usuario.date_joined = user["dataCadastro"]
if user["grupo"] == 1:
usuario.is_staff = 1
usuario.is_superuser = 1
else:
usuario.is_staff = 1
usuario.is_superuser = 0
usuario.save()
for sinal in data2["dictionary_gloss"]:
if sinal["inWeb"] != "4":
try:
def get_user():
user = User(username="******")
user.id = 1
return user
def create_user(id=None, username='', password=''):
user = User(username=username)
user.id = id
user.set_password(password)
user.save()
return user
def setUp(self):
test_user = User(username=self.USERNAME)
test_user.id = 2
test_user.set_password(self.PASSWORD)
test_user.email = self.EMAIL
test_user.save()
def save_user_from_row(user_row):
user = User()
user.id = user_row[0]
user.username = user_row[1]
user.save()
def save_user_from_row(user_row):
user = User()
user.id = user_row[1]
user.username = user_row[2]
print(user.id, user.username)
user.save()
