def addUser(request):
form = UserForm(request.POST)
if form.is_valid():
try:
with transaction.atomic():
enterprise = Enterprise()
enterprise.save()
request.session['idEnterprise'] = enterprise.id;
location= Location(enterprise=enterprise, lat=0, lng=0, name='Main Office')
location.save()
user = User(location = location, email=form.cleaned_data['email'],
password=form.cleaned_data['password'])
user.save()
request.session['idUser'] = user.id;
profile = Profile(user = user, role="Administrator")
profile.save()
return render(request, 'users/dashboard.html')
except Exception as e:
print(e)
messages.error(request, 'Sorry, Internal Error')
else:
messages.error(request, 'Please fill the form')
return HttpResponseRedirect('/signup')
def signup(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
password_confirmation = request.POST['password_confirmation']
#Check if the password is the same
if password != password_confirmation:
return render(request, 'users/signup.html',
{'error': 'Password confirmation does not match'})
#Handle exception for username already taken
try:
user = User.objects.create_user(username=username,
password=password)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': 'Username already exist'})
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.save()
profile = Profile(user=user)
profile.save()
return redirect('login')
return render(request, 'users/signup.html')
def signup_view(request):
"""Sign up view."""
if request.method == 'POST':
username = request.POST['username']
passwd = request.POST['passwd']
passwd_confirmation = request.POST['passwd_confirmation']
if passwd != passwd_confirmation:
return render(request, 'users/signup.html',
{'error': 'Password confirmation does not match'})
try:
user = User.objects.create_user(username=username, password=passwd)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': 'Username is already in user'})
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.save()
profile = Profile(user=user)
profile.save()
return redirect('login')
return render(request, 'users/signup.html')
def signup(request):
if request.method == 'POST':
username = request.POST['username']
passwd = request.POST['passwd']
passwd_confirmation = request.POST['passwd_confirmation']
if passwd != passwd_confirmation:
return render(request, 'users/signup.html',
{'error': "Passsword confirmation does not match"})
try:
user = User.objects.create_user(
username=username,
password=passwd,
)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': "Username is already in use"})
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.save()
profile = Profile(user=user)
profile.biography = "Prueba BIO"
profile.save()
return render(request, 'users/signup.html')
def register(request):
if request.method == 'POST' and not request.user.is_authenticated():
username = request.POST.get('username')
email = request.POST.get('email')
password = request.POST.get('password')
confirm = request.POST.get('confirm')
try:
existing_user = User.objects.get(username=username)
context = RequestContext(request, {'register_message': 'Username {} already exists.'.format(username)})
return render(request, 'home.html', context)
except ObjectDoesNotExist:
pass
try:
existing_user = User.objects.get(email=email)
context = RequestContext(request, {'register_message': 'E-mail {} already exists.'.format(email)})
return render(request, 'home.html', context)
except ObjectDoesNotExist:
pass
if password == confirm:
new_user = User.objects.create_user(username, email=email, password=password)
new_profile = Profile()
new_profile.user = new_user
new_profile.save()
return redirect('home')
else:
context = RequestContext(request, {'register_message': 'Passwords do not match.'.format(email)})
return render(request, 'home.html', context)
else:
return redirect('home')
def save(self):
"""Create user and profile."""
data = self.cleaned_data
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def change_friend(request, operation, username):
new_friend = User.objects.get(username=username)
if operation == 'add':
Profile.add_friend(request.user, new_friend)
elif operation == 'del':
Profile.del_friend(request.user, new_friend)
return redirect('/')
def handle(self, *args, **options):
basepath = 'media/faces'
faces = []
for entry in os.listdir(basepath):
if os.path.isfile(os.path.join(basepath, entry)):
faces.append(entry)
fake = Faker(['es_ES'])
for _ in range(10):
user = {
'username': fake.user_name(),
'first_name': fake.first_name(),
'email': fake.email(),
'password': fake.paragraph(nb_sentences=2)
}
new_user = User.objects.create_user(**user)
new_user.save()
p = {
'user':
new_user,
'website':
fake.url(),
'biography':
fake.paragraph(nb_sentences=5, variable_nb_sentences=False),
'phone_number':
fake.phone_number(),
}
profile = Profile(**p)
face = random.choice(faces)
f = File(open(os.path.join('media/faces', face), 'rb'))
profile.picture.save(f'{face}', f)
profile.save()
print(f'{new_user} : {profile}')
def handle(self, *args, **options):
for user in User.objects.all():
if Profile.objects.filter(user=user).count() == 0:
print "No profile for user: %s" % (user,)
new_profile = Profile(user=user, activation_key=generate_activation_key(user.username))
new_profile.save()
print "Created new profile for username: %s" % (user.username,)
def profile(request):
title = request.user.username
try:
current_user = request.user
projects = Project.objects.filter(poster=current_user).all()
profile = Profile.get_profile(current_user)
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
project = form.save(commit=False)
user_profile = Profile.get_profile(current_user)
project.poster = current_user
project.save()
return redirect('profile')
else:
form = ProjectForm()
except Exception as e:
raise Http404()
return render(request, "award/profile.html", {
'profile': profile,
"title": title,
"projects": projects,
"form": form
})
def save(self):
"""create user and profile."""
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def create_user(username, email_id="", password=None, first_name="", last_name=""):
""" This function called for new user sign up on p. interface. Thus username should be a valid phone number."""
usr = None
profile = None
if not username:
return usr, profile
username = username.strip()
is_type = "id"
if is_valid_mobile(username):
is_type = "mobile"
try:
usr = User(username=username, email="")
if password is None or password == "":
# use set_unusable_password to allow user to set his password in future
usr.set_unusable_password()
else:
usr.set_password(password)
if first_name:
usr.first_name = first_name
if last_name:
usr.last_name = last_name
usr.save()
profile = Profile(
user=usr, created_on=datetime.now(), primary_phone="", primary_email="", secondary_email=""
)
if first_name and last_name:
profile.full_name = "%s %s" % (first_name, last_name)
profile.save()
phone = Phone(user=profile, phone=username, type="primary")
phone.is_verified = True
phone.verified_on = datetime.now()
phone.save()
except Exception, e:
log.exception("Error create_user username: %s Exception: %s" % (username, repr(e)))
return None, None
def SignupView(request):
if request.method == 'POST':
username = request.POST['username']
passdw = request.POST['password']
passwd_co = request.POST['password_confirmation']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
if passdw != passwd_co:
return render(request, 'users/singup.html',
{'error': 'Password confirmation does not mach'})
user = User.objects.create_user(username=username, password=passdw)
user.first_name = first_name
user.last_name = last_name
user.email = email
profile = Profile(user=user)
profile.save()
return redirect('users:login')
return render(request, 'users/singup.html')
def safe(self):
data = self.cleaned_data
data.pop('password_conf')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def signup_view(request):
"""Handles user sign up"""
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
password_confirmation = request.POST['password_confirmation']
if password != password_confirmation:
return render(request, 'users/signup.html',
{'error': 'Passwords doesn\'t match'})
try:
user = User.objects.create_user(username=username,
password=password)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': 'Username is already in use'})
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.save()
profile = Profile(user=user)
profile.save()
messages.success(request, 'You\'ve registered successfully')
return redirect('login')
return render(request, 'users/signup.html')
def get_user_profile(user):
""" Returns user profile. Creates one if needed """
if not (user and user.is_authenticated()):
return None
pr = cache.get("users_profile:auth_user=%s" % user.id, None)
if pr:
return pr
pr = get_profile_by_email_or_phone(user.username)
if not pr:
pr = Profile.objects.filter(user=user).order_by("id")[:2]
if len(pr) > 1:
fb_log.info("Multiple profiles for user: %s" % user.username)
if pr:
pr = pr[0]
if not pr:
pr = Profile(user=user)
pr.created_on = datetime.now()
pr.save()
if is_valid_email(user.username):
try:
email = Email(email=user.username, user=pr, type="primary")
email.save()
except:
pass
if is_valid_mobile(user.username):
try:
phone = Phone(phone - user.username, user=pr, type="primary")
phone.save()
except:
pass
cache.set("users_profile:auth_user=%s" % user.id, pr)
return pr
def safe():
'''Create user and profile'''
data = self.cleaned_data
data.pop['password_confirmation']
user = User.objects.create_user(**data)
profile = Profile(user = user)
profile.save()
def save(self):
"""Create user and profile."""
data = self.cleaned_data
data.pop('password_confirmation') #Elimina este campo ya que no se usa
user = User.objects.create_user(**data) #desdobla el formulario en el modelo
profile = Profile(user=user)
profile.save()
def profile(user, **kwargs):
"""Return a saved profile for a given user."""
defaults = {'user': user}
defaults.update(kwargs)
p = Profile(**defaults)
p.save()
return p
def save(self):
"""Create user and profile"""
data = self.cleaned_data
data.pop('password_confirmation')
# Vamos a sacar de cleaned_Data nuestro password_confirmation, por que no nos servira.
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def _create_user(username, rolename, data=None):
if data is None:
data = {}
role = Role.select().where(Role.name==rolename).get()
Profile.create(username=username, email=username+'@srv.pl', role=role,
description=data.get('description', 'User ' + username + ' description'),
title=data.get('title', 'User ' + username + ' title'),
location=data.get('location', 'User ' + username + ' location'))
def profile(user, **kwargs):
"""Return a saved profile for a given user."""
defaults = {"user": user}
defaults.update(kwargs)
p = Profile(**defaults)
p.save()
return p
def save(self):
data = self.cleaned_data
data.pop('password_confirmation')
#**data is all the dictionary
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def save(self): #guaraado de datos
"""create user and profile"""
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(
**data) # aca s envia todo el diccionario **data
profile = Profile(user=user)
profile.save()
def save(self):
#CREATE USER AND PROFILE
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def save(self):
#create user and profile
data = super().clean()
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def init_profile(user):
LoadTestData.init_foaf()
profile = Profile(user=user, )
try:
return Profile.objects.get(user=user)
except ObjectDoesNotExist:
profile.save()
return profile
def save(self):
"""Create user and profile."""
data = self.cleaned_data
data.pop('password_confirmation')
# investigar que llega aqui
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def signup(request):
from auth.models import User
from auth import load_backend, login
from users.models import Profile, EmailVerify
from market_buy.forms import BuyerForm
form = BuyerForm(request.POST or None)
if form.is_valid():
""" Generate Auth User """
user = User.objects.create_user(form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password1"])
user.first_name = form.cleaned_data["first_name"]
user.last_name = form.cleaned_data["last_name"]
user.is_active = False
user.save()
""" Set profile """
profile = Profile(user=user)
profile.save()
""" Send mail to confirm account """
email_verify = EmailVerify(user=user, user_activation=True)
code = email_verify.generate_code()
email_verify.save()
# TODO: remove this
send_mail_account_confirmation(user, email_verify.code,
request.marketplace)
# return HttpResponseRedirect(reverse('confirmemail', args=[code]))
# for backend in settings.AUTHENTICATION_BACKENDS:
# if user == load_backend(backend).get_user(user.pk):
# user.backend = backend
# break
# if hasattr(user, 'backend'):
# login(request, user)
if request.session.get('sell_signup', False):
request.flash['message'] = _(
"<h5>Please check your email and confirm your account to start selling...</h5>"
)
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('market_sell_signup'))
else:
request.flash['message'] = _(
"<h5>Please check your email and confirm your account. Once confirmed you can Buy or Sell on GreatCoins.com</h5>"
)
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('market_home'))
else:
#request.method == GET
if request.GET.has_key('sell_signup'):
request.session['sell_signup'] = request.GET.get(
'sell_signup', '') == '1'
return render_to_response(
'%s/buy/register.html' % request.marketplace.template_prefix,
{'form': form}, RequestContext(request))
def save(self):
"""Create user and profile.
Como usamos los datos una vez que son validos"""
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def save(self):
"""Create user and profile."""
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile.interests.add(*self.cleaned_data.get('interests'))
profile = Profile(user=user)
profile.save()
def save(self):
"""Creacion de usuario y perfil en la DataBase"""
data = self.cleaned_data # Primero traemos los del form
data.pop(
'password_confirmation'
) # quitamos el dato de password confirmations que nos sirve con el modelo.
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def save(self):
# Crear un usuario y profile
data = self.cleaned_data
# sacar atributo
data.pop('password_confirmation')
# con el arg ** le envio todo el diccionario como el rest operator de js
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def test_profile(self):
# creating a user with a profile
u1 = User(username='******', password='******')
u1.save()
up1 = Profile(user_id=u1.id)
# checks that up1 is an instance of Profile
self.assertTrue(isinstance(up1, Profile))
# checks if up1 is equal to the user: u1.username + str('Profile')
self.assertEqual(up1.__str__(), u1.username + ' Profile')
def save(self):
"""Create user and profile."""
data = self.cleaned_data
data.pop('password_confirm'
) #pop saca los datos que no debemos enviar a la bd
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
profile = Profile(user = MainUser.objects.get(id=serializer.data['id']), bio=request.data['profile']['bio'], address=request.data['profile']['address'])
profile.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def form_valid(self, form):
# profile 따로 저장해줌
# 꼼수인데 방법이 되네요
user = form.save()
p = Profile()
p.user = user
p.save()
messages.success(self.request, '계정이 생성되었습니다')
return super(CreateUser, self).form_valid(form)
def post(self, request):
user_form = CreateUserForm(request.POST)
profile_form = CreateProfileForm(request.POST)
print(user_form.errors)
print(user_form.cleaned_data)
if user_form.is_valid() and profile_form.is_valid():
user = User(**user_form.cleaned_data)
user.save()
print('User表OK,,,,')
user_profile = Profile()
user_profile.user = user
user_profile.name = profile_form.cleaned_data['name']
user_profile.lnvalid_date = profile_form.cleaned_data[
'lnvalid_date']
user_profile.phone = profile_form.cleaned_data['phone']
user_profile.weixin = profile_form.cleaned_data['weixin']
user_profile.info = request.POST.getlist('info', None)[0]
user_profile.save()
print('userprofile表OK,,,,')
if request.POST.get('groups', None):
user.groups.set(request.POST.getlist('groups'))
register_email = RegisterEmail()
register_email.user = user
register_email.type_code = 0
register_email.code = random_str()
register_email.save()
contnet = """
<p>你好 %s: </p>
<p>恭喜您，您的账号已经创建成功 </p>
<p>用户名: %s </p>
<p><a href='%s'>请点击这里设置密码</a> </p>
""" % (user.username, user_profile.name,
settings.HOST_URL + reverse('user_create_password') +
'?code=' + str(register_email.code))
try:
send_mail(settings.EMAIL_USER, settings.EMAIL_PASSWORD,
user.email, settings.EMAIL_TITLE, contnet,
settings.EMAIL_HOST, settings.EMAIL_PORT)
print('邮件发送OK...')
except Exception as e:
print(e)
print('邮件发送失败...')
return redirect(reverse('user_list'))
def profile(user, **kwargs):
"""Return a saved profile for a given user."""
defaults = {'user': user, 'name': 'Test K. User', 'bio': 'Some bio.',
'website': 'http://support.mozilla.com',
'timezone': None, 'country': 'US', 'city': 'Mountain View'}
defaults.update(kwargs)
p = Profile(**defaults)
p.save()
return p
def signup(request):
from auth.models import User
from auth import load_backend, login
from users.models import Profile, EmailVerify
from market_buy.forms import BuyerForm
form = BuyerForm(request.POST or None)
if form.is_valid():
""" Generate Auth User """
user = User.objects.create_user(form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password1"])
user.first_name = form.cleaned_data["first_name"]
user.last_name = form.cleaned_data["last_name"]
user.is_active = False
user.save()
""" Set profile """
profile = Profile(user=user)
profile.save()
""" Send mail to confirm account """
email_verify = EmailVerify(user=user, user_activation=True)
code = email_verify.generate_code()
email_verify.save()
# TODO: remove this
send_mail_account_confirmation(user, email_verify.code, request.marketplace)
# return HttpResponseRedirect(reverse('confirmemail', args=[code]))
# for backend in settings.AUTHENTICATION_BACKENDS:
# if user == load_backend(backend).get_user(user.pk):
# user.backend = backend
# break
# if hasattr(user, 'backend'):
# login(request, user)
if request.session.get('sell_signup',False):
request.flash['message'] = _("<h5>Please check your email and confirm your account to start selling...</h5>")
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('market_sell_signup'))
else:
request.flash['message'] = _("<h5>Please check your email and confirm your account. Once confirmed you can Buy or Sell on GreatCoins.com</h5>")
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('market_home'))
else:
#request.method == GET
if request.GET.has_key('sell_signup'):
request.session['sell_signup'] = request.GET.get('sell_signup','') == '1'
return render_to_response('%s/buy/register.html'% request.marketplace.template_prefix,
{'form': form},
RequestContext(request))
def attach_fb(request):
if request.method == "POST":
data = request.POST
facebookid = data["id"]
email = data["email"]
first_name = data["first_name"]
last_name = data["last_name"]
user, profile = None, None
u_email = None
try:
u_email = UserEmail.objects.get(email=email)
profile = u_email.user
user = profile.user
except UserEmail.DoesNotExist:
try:
user = User.objects.get(Q(email=email) | Q(username=email))
except User.DoesNotExist:
user = User.objects.create_user(email, email, None)
user.first_name = first_name
user.last_name = last_name
user.save()
if not user.first_name:
user.first_name = first_name
user.save()
if not user.last_name:
user.last_name = last_name
user.save()
try:
profile = Profile.objects.get(user=user)
except Profile.DoesNotExist:
profile = Profile(user=user, full_name="%s %s" % (first_name, last_name))
# if not profile.full_name: overwrite facebook name
profile.full_name = "%s %s" % (first_name, last_name)
profile.facebook = facebookid
profile.save()
if not u_email:
u_email = UserEmail(email=email, user=profile, type="subscription")
u_email.save()
if request.user:
auth.logout(request)
request.session.flush()
user = auth.authenticate(facebook_user=user, **dict(request=request))
request.session["logged_through_facebook"] = True
if user:
request.session["atg_username"] = user.username
set_logged_in_user(request, user)
log.info("FACEBOOK USER LOGGED IN: %s" % user)
return HttpResponse("OK")
else:
return HttpResponse("OK")
return HttpResponse("FAILED")
def create_tables():
database.connect()
Category.drop_table(fail_silently=True)
Thread.drop_table(fail_silently=True)
Post.drop_table(fail_silently=True)
Role.drop_table(fail_silently=True)
Profile.drop_table(fail_silently=True)
database.create_tables([Category, Thread, Post, Profile, Role])
database.close()
if settings.DEBUG:
setup_temp_data()
def home(request):
if request.user.is_authenticated():
return render(request, 'dashboard.html')
else:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=request.POST["username"], password=request.POST["password"])
if user:
auth.login(request, user)
profile = Profile(user=user, last_login_source=request.META["REMOTE_ADDR"])
profile.save()
return render(request, 'dashboard.html')
return render(request, 'index.html')
def register(self, request, **cleaned_data):
"""Custom registration view.
"""
print('Starting registration')
print(cleaned_data)
u = User.objects.create_user(
cleaned_data['username'],
'',
cleaned_data['password1'])
p = Profile()
p.user = u
p.save()
messages.success(self.request,
'Thank you for registering. Now you can login.')
def registrar_usuario(request):
if request.POST:
f=RegistrationForm(request.POST)
if f.errors:
messages.error(request, 'El formulario contiene errores')
return render_to_response("registro_caja.html", {'form':f}, RequestContext(request))
else:
data = f.cleaned_data
user=User()
user.username=data["username"]
passwd=get_pronounceable_password(1,2)
user.set_password(passwd)
user.email = data['email']
user.first_name = data['first_name']
user.last_name = data['last_name']
user.save()
profile = Profile()
profile.user=user
profile.telefono = data['phone_number']
profile.celular = data['cellphone']
profile.direccion = data['address']
profile.tipo = CLIENTE
profile.save()
messages.success(request, 'Usuario creado con exito')
return render_to_response('mostrar_usuario.html', {'user':user,'passwd':passwd}, RequestContext(request))
else:
f=RegistrationForm()
return render_to_response("registro_caja.html", {'form':f}, RequestContext(request))
def profile(**kwargs):
"""Return a saved profile for a given user."""
defaults = {'name': 'Test K. User', 'bio': 'Some bio.',
'website': 'http://support.mozilla.com',
'timezone': None, 'country': 'US', 'city': 'Mountain View',
'locale': 'en-US'}
if 'user' not in kwargs:
u = user(save=True)
defaults['user'] = u
defaults.update(kwargs)
p = Profile(**defaults)
p.save()
return p
def create_profile(sender, instance, created, using, *args, **kwargs):
"""
Crea el perfil de usuario cuando se crea un usuario.
"""
from users.models import Profile
if created:
try:
sp_id = transaction.savepoint()
profile = Profile(user=instance, username=instance.username)
profile.save()
transaction.savepoint_commit(sp_id)
except Exception, e:
logging.error('ERROR: %s ' % e)
transaction.savepoint_rollback(sp_id)
def setUp(self):
# create store owner user and profile
self.owner = User.objects.create_user("test-owner", "*****@*****.**", "test-owner")
owner_profile = Profile(user=self.owner)
owner_profile.save()
# create a marketplace
self.marketplace = MarketPlace(name="greatcoins", title="greatcoins", slug="greatcoins",
template_prefix="greatcoins", base_domain="greatcoins.com")
self.marketplace.save()
# create a shop
self.shop = Shop(marketplace=self.marketplace, admin=self.owner, name="test_shop")
self.shop.save()
# create a Preference and SubscriptionPlan to shop
Preference(shop=self.shop).save()
self.shop.update()
plan = SubscriptionPlan(plan_id=1,
marketplace=self.marketplace,
trial_period=True,
total_store_revenue=1000,
concurrent_store_items=1000)
plan.save()
Subscription(owner=owner_profile, plan=plan).save()
# create marketplace categories and sub-categories
self.category = MarketCategory(marketplace=self.marketplace, name="Category")
self.category.save()
self.subcategory = MarketSubCategory(marketplace=self.marketplace, parent=self.category, name="SubCategory")
self.subcategory.save()
# create a user, profile and shipping data
self.user = User.objects.create_user("test-user", "*****@*****.**", "test-user")
Profile(user=self.user).save()
shippingdata = ShippingData(first_name='User',
last_name='Buyer',
street_address="Calle 54",
city="La Plata",
state="Buenos Aires",
zip="1900",
country="AR")
shippingdata.save()
# create a shopping cart
self.cart = Cart(shop=self.shop, bidder=self.user)
self.cart.shippingdata = shippingdata
self.cart.save()
def createUser(request):
print "** createUser DEBUG LOG**"
form = NewUserForm(request.POST)
print 'form set'
if form.is_valid():
newUser = form.save()
newUserProfile = Profile(user=newUser)
newUserProfile.save()
print "user '%s' created" % newUser.username
print '**OK**'
return HttpResponseRedirect(reverse('home'))
else:
form = NewUserForm()
print 'form reset'
print '**ERR FORM CREATION FAILED**'
return render(request, 'signup.html', {'form':form})
def get_agent(self, agent_name):
try:
usr = User.objects.get(username=agent_name)
p = usr.get_profile()
return p
except User.DoesNotExist:
try:
usr = User.objects.create_user(agent_name, '*****@*****.**' % agent_name)
usr.save()
p = Profile(user=usr, primary_phone=agent_name)
p.created_on = datetime.datetime.now()
p.save()
return p
except Exception, e:
log.error('Error creating agent %s' % repr(e))
return None
def create_temp_posts():
with open('fixtures/posts.json') as f:
posts = json.load(f)
for p in posts:
t = Thread.select().where(Thread.id==p['thread']).get()
u = Profile.select().where(Profile.id==p['author']).get()
Post.create(author=u, thread=t, body=p['body'], is_sticky=[['is_sticky']])
def add_agents():
from users.models import Profile
from django.contrib.auth.models import User
f = open('chaupaati')
lines = f.readlines()
for line in lines:
print line
line = line.strip()
print line.split(',')
password, name, loginid = line.split(',')
name = name.strip()
first_name = name.split(' ')[0]
loginid = loginid.strip()
password = password.strip()
u = User.objects.create_user(loginid, '*****@*****.**', password)
u.name = name
u.save()
agent = Profile()
agent.user = u
agent.full_name = '%s%s' % (name,password)
agent.primary_phone = '%s%s' % (first_name,password)
agent.is_agent = True
agent.save()
def register(request):
response = JSONResponse("success")
if request.method != 'POST':
response.add_error('Bad request.')
else:
print request.POST['birthday']
valid = True
match = User.objects.filter(username = request.POST['username'])
if len(match) > 0:
response.add_error('Username is already in use.', 'register_error')
valid = False
match = User.objects.filter(email = request.POST['email'])
if len(match) > 0:
response.add_error('Email address is already registered.', 'register_error')
valid = False
if len(request.POST['password']) < 6:
response.add_error('The entered password is less than 6 characters.', 'register_error')
valid = False
if len(request.POST['username']) < 3:
response.add_error('The requested username is too short.', 'register_error')
valid = False
if len(request.POST['firstname']) == 0 or len(request.POST['lastname']) == 0:
response.add_error('You must provide both first and last name.', 'register_error')
global mail_re
if mail_re == None:
mail_re = re.compile('^[a-zA-Z0-9._%-]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$')
if mail_re.match(request.POST['email']) is None:
response.add_error('Invalid email address', 'register_error')
valid = False
if valid == True:
user = User.objects.create_user(request.POST['username'], request.POST['email'], request.POST['password'])
user.save()
profile = Profile()
profile.userLink = user
profile.birthday = datetime.datetime.strptime(request.POST['birthday'], '%Y-%m-%d').date()
profile.firstname = request.POST['firstname']
profile.lastname = request.POST['lastname']
profile.country = request.POST['country']
profile.biography = request.POST['bio']
profile.rights = 0
profile.save()
user = authenticate(username=request.POST['username'], password=request.POST['password'])
login(request, user)
return response.respond()
def get_or_create_user(username, email_id="", password=None, first_name="", last_name=""):
usr = None
profile = None
if not username:
return usr, profile
username = username.strip()
is_type = "id"
if is_valid_mobile(username):
is_type = "mobile"
try:
phone = Phone.objects.get(phone=username)
profile = phone.user
usr = profile.user
except Phone.DoesNotExist:
try:
usr = User.objects.get(username=username)
except User.DoesNotExist:
usr = User(username=username, email="")
if password is None or password == "":
# use set_unusable_password to allow user to set his password in future
usr.set_unusable_password()
else:
usr.set_password(password)
if first_name:
usr.first_name = first_name
if last_name:
usr.last_name = last_name
usr.save()
try:
profile = Profile.objects.get(user=usr)
except Profile.DoesNotExist:
profile = Profile(
user=usr, created_on=datetime.now(), primary_phone="", primary_email="", secondary_email=""
)
profile.full_name = "%s %s" % (first_name, last_name)
if first_name and last_name:
profile.full_name = "%s %s" % (first_name, last_name)
profile.save()
phone = Phone(user=profile, phone=username, type="primary")
phone.save()
except Exception, e:
log.exception("Error get_or_create_user %s" % repr(e))
return None, None
def new(request):
if request.user.is_authenticated():
return redirect('microposts.views.index')
elif request.POST:
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
username = request.POST['username']
email = request.POST['email']
password = request.POST['password']
password_confirmation = request.POST['password_confirmation']
new_user = User.objects.create_user(username=username, email=email, password=password)
user_profile = Profile(user=new_user)
user_profile.save()
user = authenticate(username=username, password=password)
login(request, user)
return render(request, 'microposts/index.html', {'current_user' : request.user})
return render(request, 'users/index.html', {'signup_form_errors' : signup_form.errors})
else:
return render(request, 'users/index.html')
def save(self):
new_user = User.objects.create_user(
username=self.cleaned_data['username'],
email=self.cleaned_data['email'],
password=self.cleaned_data['password1']
)
new_user.first_name = self.cleaned_data['first_name']
new_user.last_name = self.cleaned_data['last_name']
new_user.is_active = False
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_key = sha.new(salt + new_user.username.encode('ascii', 'ignore')).hexdigest()
new_profile = Profile(
user=new_user,
activation_key=activation_key,
hide_real_name=self.cleaned_data['hide_real_name'],
)
new_user.save()
new_profile.save()
return new_profile
def setUp(self):
self.owner = User.objects.create_user("owner", "*****@*****.**", "testpw")
owner_profile = Profile(user=self.owner)
owner_profile.save()
self.user = User.objects.create_user("test", "*****@*****.**", "testpw")
self.user2 = User.objects.create_user("user2", "*****@*****.**", "user2")
Profile(user=self.user).save()
Profile(user=self.user2).save()
self.marketplace = MarketPlace(
name="greatsomething",
title="Great Something",
slug="great-something",
template_prefix="default",
base_domain="greatsomething.com",
)
self.marketplace.save()
self.shop = Shop(marketplace=self.marketplace, admin=self.owner, name="test_shop")
self.shop.save()
Preference(shop=self.shop).save()
self.shop.update()
plan = SubscriptionPlan(
plan_id=1,
marketplace=self.marketplace,
trial_period=True,
total_store_revenue=1000,
concurrent_store_items=1000,
)
plan.save()
Subscription(owner=owner_profile, plan=plan).save()
self.category = MarketCategory(marketplace=self.marketplace, name="Category1")
self.category.save()
self.subcategory = MarketSubCategory(marketplace=self.marketplace, parent=self.category, name="SubCategory1")
self.subcategory.save()
self.cart = Cart(shop=self.shop, bidder=self.user)
self.cart.save()
self.cart2 = Cart(shop=self.shop, bidder=self.user2)
self.cart2.save()
def run():
cursor = connections["old"].cursor()
# Delete existing profiles
print "Removing existing profiles..."
Profile.objects.all().delete()
# Delete existing users
print "Removing existing users..."
User.objects.exclude(pk=1).delete()
cursor.execute("SELECT id, login, encrypted_password, title, description, email, "
"homepage, institution, institution_url, grade_levels, department, "
"specializations, state, biography, why_interested, publish_portfolio, "
"publish_profile, role FROM _principals")
total_items = cursor.rowcount
print "Creating users..."
cnt = 0
for id, login, encrypted_password, title, description, email, \
homepage, institution, institution_url, grade_levels, department, \
specializations, state, biography, why_interested, publish_portfolio, \
publish_profile, role in cursor.fetchall():
cnt += 1
if role is None:
role = u""
if specializations is None:
specializations = []
if homepage is None:
homepage = u""
if institution is None:
institution = u""
if institution_url is None:
institution_url = u""
if department is None:
department = u""
if state is None:
state = u""
if biography is None:
biography = u""
if why_interested is None:
why_interested = u""
if publish_portfolio is None:
publish_portfolio = False
if publish_profile is None:
publish_profile = False
if grade_levels is None:
grade_levels = []
principal_id = "oer.member.%i" % id
try:
first_name, last_name = title.split(None, 1)
except ValueError:
first_name = title
last_name = u""
if len(first_name) > 30:
first_name = first_name[:30]
if len(last_name) > 30:
last_name = last_name[:30]
password = BCRYPT_PREFIX + encrypted_password
user = User(username=login,
password=password,
email=email,
first_name=first_name,
last_name=last_name
)
user.save()
profile = Profile(user=user,
principal_id=principal_id,
homepage=force_unicode(homepage),
institution=force_unicode(institution),
institution_url=force_unicode(institution_url),
department=force_unicode(department),
specializations=u"\n".join(force_unicode(specializations)),
state=force_unicode(state),
biography=force_unicode(biography),
why_interested=force_unicode(why_interested),
publish_portfolio=publish_portfolio,
publish_profile=publish_profile,
role=force_unicode(role))
try:
profile.save()
except DatabaseError:
import pprint
pprint.pprint(locals())
raise
for l in grade_levels:
l = slugify(l)
try:
grade_level = GradeLevel.objects.get(slug=l)
except GradeLevel.DoesNotExist:
print l
profile.grade_level.add(grade_level)
if cnt % 100 == 0:
print "%i of %i" % (cnt, total_items)
print "Done!"
usr = User.objects.get(username=username)
except User.DoesNotExist:
usr = User(username=username, email=username)
if password is None or password == "":
usr.set_unusable_password()
else:
usr.set_password(password)
if first_name:
usr.first_name = first_name
if last_name:
usr.last_name = last_name
usr.save()
try:
profile = Profile.objects.get(user=usr)
except Profile.DoesNotExist:
profile = Profile(user=usr, created_on=datetime.now())
profile.full_name = "%s %s" % (first_name, last_name)
if first_name and last_name:
profile.full_name = "%s %s" % (first_name, last_name)
profile.save()
email = Email(user=profile, email=username, type="primary", cleaned_email=clean_username)
email.save()
except Exception, e:
log.exception("Error get_or_create_user %s" % repr(e))
return None, None
log.info("get_or_create_user is_type is %s" % is_type)
return usr, profile
def formatMoney(value):
try:
def add_user(doc):
if doc['mobile'] in sellers: return
u = User()
try:
u = User.objects.get(username=doc['mobile'])
except User.DoesNotExist:
pass
u.username = doc['mobile']
if 'timestamp' in doc:
u.timestamp = doc['timestamp'].strftime('%Y-%m-%d %H:%M:%S')
else:
if 'modificationTime' in doc:
u.timestamp = doc['modificationTime'].strftime('%Y-%m-%d %H:%M:%S')
u.save()
p = Profile()
try:
p = Profile.objects.get(primary_phone=doc['mobile'])
if p.id != doc['id']:
record_duplicate(p.id, doc['id'])
return
except Profile.DoesNotExist:
pass
p.id = doc['id']
p.user = u
p.full_name = doc.get('name','')
p.gender = doc.get('gender','').lower()
if len(p.gender) > 1:
p.gender = p.gender[0]
if doc.get('dateOfBirth',None):
p.date_of_birth = doc['dateOfBirth'].strftime('%Y-%m-%d')
p.primary_phone = doc['mobile']
p.secondary_phone = doc.get('mobile2','')
p.primary_email = doc.get('email','').split(',')[0]
p.secondary_email = doc.get('email2','').split(',')[0]
p.buyer_or_seller = 'buyer'
p.type = doc.get('type','individual')
p.marketing_alerts = doc.get('dealAlerts','neutral')
p.salt = doc.get('salt','')
p.passcode = doc.get('passcode','')
p.created_on = u.timestamp
p.save()
