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 handle(self, *args, **options):
"""Create fake users and statuses for Mowdie."""
from faker import Faker
import random
from django.conf import settings
from PyMarkovTextGenerator import Markov
fake = Faker()
textgen = Markov(prob=True, level=3)
with open(settings.BASE_DIR + "/../john_carter.txt") as file:
textgen.parse(file.read())
def update_text():
return textgen.generate(
startf=lambda db: random.choice([x for x in db
if x[0][0].isupper()]),
endf=lambda s: len(s) > 120)
Favorite.objects.all().delete()
Update.objects.all().delete()
User.objects.all().delete()
users = []
for _ in range(20):
user = User(username=fake.user_name(),
email=fake.email())
user.set_password("password")
user.save()
Profile(user=user).save()
users.append(user)
user = User(username="******",
email="*****@*****.**",
is_staff=True,
is_superuser=True)
user.set_password("password")
user.save()
Profile(user=user).save()
updates = []
for _ in range(100):
update = Update(text=update_text(),
posted_at=make_aware(fake.date_time_this_year()),
user=random.choice(users))
update.save()
updates.append(update)
combos = random.sample([(user, update)
for user in users
for update in updates], 200)
for user, update in combos:
favorite = Favorite(user=user, update=update)
favorite.save()
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 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 profile(request, username):
title = 'Profile'
profile_user = get_object_or_404(User, username=username)
profile = Profile.objects.filter(user=profile_user)
# We check if the user has a profile image and if not we provide him an avatar
if profile.exists():
if profile[0].profile_image:
user_has_profile_image = True
else:
user_has_profile_image = False
else:
user_has_profile_image = False
p = Profile()
p.user = profile_user
avatar = p.avatar(128)
return render(
request, 'users/profile.html', {
'title': title,
'profile': profile,
'avatar': avatar,
'profile_user': profile_user,
'user_has_profile_image': user_has_profile_image
})
def setUp(self):
user = User.objects.create_user('test', '*****@*****.**', 'test')
self.user = user
profile = Profile(user=user)
profile.save()
company = Company(corp_name="test회사")
company.save()
self.company = company
self.assertIsInstance(company, Company)
user = {
"username": "******",
"password": "******"
}
response = self.client.post('/api/v1/auth/login/', json.dumps(user), content_type='application/json')
self.assertEqual(response.status_code, 200)
self.token = response.data['access_token']
self.csrftoken = response.cookies.get('csrftoken').value
self.assertNotEqual(self.token, '')
self.headers = {
"HTTP_Authorization": "jwt " + self.token,
"X-CSRFToken": self.csrftoken,
}
def handle(self, *args, **options):
users = AuthModel.objects.filter(profile=None).all()
for user in users:
# print(user)
# if not user.profile:
Profile(user=user).save()
print('Added profile to %s users' % len(users))
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 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 handle(self, *args, **options):
users = AuthUserModel.objects.filter(profile=None).all()
for user in users:
Profile(user=user).save()
print('Added to profile to %s users.' % len(users))
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 save(self):
"""Create user and profile."""
data = self.cleaned_data
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
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 post(self, request, format=None):
print(request.FILES)
serializer = UserSignupSerailizer(data=request.data)
serializer.is_valid(raise_exception=True)
if request.data['password'] != request.data['passwordConfirmation']:
return Response(
{'message': 'password dont match with password confirmation'},
status=status.HTTP_400_BAD_REQUEST)
try:
user = User.objects.create_user(username=request.data['username'],
password=request.data['password'])
except:
return Response({'error': 'Username is already in user'},
status=status.HTTP_400_BAD_REQUEST)
user.first_name = request.data['firstName']
user.last_name = request.data['lastName']
user.email = request.data['email']
user.save()
profile = Profile(user=user)
profile.identification = request.data['identificationNumber']
profile.photo = request.FILES['photo']
profile.save()
token = serializer.save()
data = {
'status': 'ok',
'token': token['token'],
'username': token['username']
}
return Response(data, status=status.HTTP_201_CREATED)
def signup_view(request):
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' : 'Las contraseñas no coinsiden'})
user = User.objects.create_user(username=username, password=password)
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.position = request.POST['position']
user.save()
profile = Profile(user=user)
profile.save()
return redirect('login')
return render(request, 'users/signup.html')
def signup_view(request):
""" Register a user in the DB and the plataform """
if request.method == "POST":
username = request.POST['username']
passwd = request.POST['password']
confirmation_passwd = request.POST['password_confirmation']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
if passwd != confirmation_passwd:
# validacion de contrasenas diferentes
error = {'msg': 'Password Dont Macth'}
return render(request, 'users/signup.html', error)
# creando el usuario base
try:
user = User.objects.create_user(username=username, password=passwd)
except IntegrityError:
error = {'msg': 'Username is already picked'}
return render(request, 'users/signup.html', error)
# asignamos los datos
user.first_name = first_name
user.last_name = last_name
user.email = email
# Inicializando el profile y le pasamos el user
profile = Profile(user=user)
profile.save()
print('user saved')
return redirect("login")
return render(request, 'users/signup.html')
def save(self):
data = self.cleaned_data
data.pop('password_confirmation')
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
def signup_view(request):
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 does not match'})
# Create a new user
try:
user = User.objects.create_user(username=username,
password=password)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': 'This 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()
# Create a new profile
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']
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 save(self):
"""Create user and profile."""
data = self.cleaned_data
data.pop('password_confirmation') # we don't need to keep this
user = User.objects.create_user(**data)
profile = Profile(user=user)
profile.save()
## YA NO LO USAREMOS MAS, PODEMOS ELIMINARLO
#class ProfileForm(forms.Form):
# """Profile form."""
#
# website = forms.URLField(
# max_length=200,
# required=True
# )
# biography = forms.CharField(
# max_length=500,
# required=False
# )
# phone_number = forms.CharField(
# max_length=20,
# required=False
# )
# picture = forms.ImageField()
def signup(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
code = request.POST['code']
if int(code) == 1441:
try:
user = User.objects.create_user(username=username,
password=password)
except:
return render(request, 'users/signup.html',
{'error': 'Nombre de usuario ya existe'})
user.email = email
user.first_name = first_name
user.last_name = last_name
user.save()
profileU = Profile(user=user)
profileU.save()
return redirect('login')
else:
return render(request, 'users/signup.html',
{'error': 'Codigo incorrecto'})
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': 'Las contraseñas no coinciden'})
try:
user = User.objects.create_user(username=username, password=passwd)
except IntegrityError:
return render(request, 'users/signup.html',
{'error': 'El usuario ya existe'})
#Linea de creacion del usuario
user = User.objects.create_user(username=username, password=passwd)
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
profile = Profile(user=user)
profile.save()
user.save()
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 view_sing_up(request):
if request.method == 'POST':
username = request.POST['inputUserN']
password = request.POST['inputPassword']
confirm = request.POST['inputConfirm']
if confirm != password:
return render(request, 'User/sign_up.html',
{'error': 'La contraseña no coincide'})
# try catch para que no se dañe si se pasa un username que ya existe
try:
# Le pasamos las variables que recibimos al modelo user de django
user = User.objects.create_user(username=username,
password=password)
except IntegrityError:
return render(request, 'User/sign_up.html',
{'error': 'El nombre de usuario ya esta en uso'})
# Le pasamos las variables que recibimos al modelo user de django
user.first_name = request.POST['inputFName']
user.last_name = request.POST['inputLName']
user.email = request.POST['inputEmail']
user.save()
# Como el model profile tiene la PK del modelo user de django se le pasa lo que tiene a profile
profile = Profile(user=user)
profile.save()
return redirect('Login')
return render(request, 'User/sign_up.html')
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 create_profile(self, data):
"""
Functionality:
Params:
Response:
"""
try:
profile = Profile.objects.filter(email=data["email"])[:1].get()
except:
profile = None
if profile is None:
profile = Profile(
email=data["email"],
username=data["username"],
fullname=data["fullname"],
address=data["address"],
gender=data["gender"] if data["gender"] else 1,
image=data["image"],
phone_no=data["phone_no"]
)
profile.set_password(data["password"])
setattr(profile, "is_active", False)
profile.save()
serializer = ProfileSerializer(profile)
return serializer.data
else:
return {"message": "Already Exists"}
def signup(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 edit_profile(request):
title = 'Edit profile'
if request.method == "POST":
# request.user.username is the original username
form = EditProfileForm(request.user.username, request.POST,
request.FILES)
if form.is_valid():
username = form.cleaned_data["username"]
phone_number = form.cleaned_data["phone_number"]
location = form.cleaned_data["location"]
profile_image = form.cleaned_data["profile_image"]
user = get_object_or_404(User, id=request.user.id)
# We use a transaction so that if one of the requests below fails all previous ones are canceled
try:
with transaction.atomic():
edit = Profile.objects.filter(user=user)
if edit.exists():
edit = Profile.objects.get(user=user)
edit.phone_number = phone_number
edit.location = location
if profile_image:
edit.profile_image = request.FILES['profile_image']
edit.save()
user.username = username
user.save()
else:
edit = Profile(user=user)
edit.phone_number = phone_number
edit.location = location
edit.profile_image = profile_image
user.username = username
edit.save()
user.save()
messages.add_message(request, messages.SUCCESS,
'Your changes have been saved.')
return redirect('users:profile', username=user.username)
except IntegrityError:
form.errors[
'internal'] = "An internal error has occurred. Please try your request again."
else:
edit = Profile.objects.filter(user=request.user)
if edit.exists():
form = EditProfileForm(
request.user.username, {
'username': request.user.username,
'phone_number': edit[0].phone_number,
'location': edit[0].location
}, request.FILES)
else:
form = EditProfileForm(request.user.username,
{'username': request.user.username},
request.FILES)
return render(request, 'users/edit_profile.html', {
'title': title,
'form': form
})
def twitter_authenticated(request):
# Step 1. Use the request token in the session to build a new client.
token = oauth.Token(
request.session['request_token']['oauth_token'],
request.session['request_token']['oauth_token_secret']
)
token.set_verifier(request.GET['oauth_verifier'])
client = oauth.Client(consumer, token)
# Step 2. Request the authorized access token from Twitter.
resp, content = client.request(access_token_url, "GET")
if resp['status'] != '200':
print(content)
raise Exception("Invalid response from Twitter.")
"""
This is what you'll get back from Twitter. Note that it includes the
user's user_id and screen_name.
{
'oauth_token_secret': 'IcJXPiJh8be3BjDWW50uCY31chyhsMHEhqJVsphC3M',
'user_id': '120889797',
'oauth_token': '120889797-H5zNnM3qE0iFoTTpNEHIz3noL9FKzXiOxwtnyVOD',
'screen_name': 'heyismysiteup'
}
"""
access_token = convert(dict(parse.parse_qsl(content)))
# Step 3. Lookup the user or create them if they don't exist.
try:
user = User.objects.get(username=access_token['screen_name'])
except User.DoesNotExist:
# When creating the user I just use their [email protected]
# for their email and the oauth_token_secret for their password.
# These two things will likely never be used. Alternatively, you
# can prompt them for their email here. Either way, the password
# should never be used.
user = User.objects.create_user(
access_token['screen_name'],
'*****@*****.**' % access_token['screen_name'],
access_token['oauth_token_secret']
)
# Save our permanent token and secret for later.
profile = Profile()
profile.user = user
profile.oauth_token = access_token['oauth_token']
profile.oauth_secret = access_token['oauth_token_secret']
profile.created_now = True
profile.save()
# Authenticate the user and log them in using Django's pre-built
# functions for these things.
user = authenticate(
username=access_token['screen_name'],
password=access_token['oauth_token_secret']
)
login(request, user)
return HttpResponseRedirect(home_url)
def test_destroy(self):
Profile(user=self.user).save()
request = factory.delete('/', format='json')
force_authenticate(request, self.user)
response = self.view(request)
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT)
