def register():
form = RegisterForm()
if form.validate_on_submit():
salt = bcrypt.gensalt()
hashed_password = bcrypt.hashpw(form.password.data, salt)
code = str(uuid.uuid4())
user = User(
username=form.username.data,
password=hashed_password,
email=form.email.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
change_configuration={
"new_email": form.email.data.lower(),
"confirmation_code": code
}
)
# email the user
body_html = render_template('mail/user/register.html', user=user)
body_text = render_template('mail/user/register.txt', user=user)
email(user.email, "Welcome to Flaskbook", body_html, body_text)
user.save()
return redirect(url_for('home_app.home'))
return render_template('user/register.html', form=form)
def login(username=None):
'''
Does all the login stuff
The whole login system is called from this
'''
# Check if banned first
b = User.chkbnid(User.host())
# cuserid(NULL));
logger.debug("BANNED %d", b)
if username:
username = username.lower()
user = User.by_username(username)
if user:
authenticate(user)
return user
# Get the user name
user = None
while not user:
user = input_username(username)
username = ''
if user.id:
# Password checking
authenticate(user)
else:
register(user)
cls()
return user
def lookup_users_by_phone(phone_number):
"""Attempt to match the given phone number in an arbitrary format to one or more members"""
phone_number = re.sub('\s', '', phone_number)
if phone_number == '':
return []
# Perform raw query in order to use MSSQL's 'REPLACE' function to remove whitespace
# Note that we're excluding Actors with end_code 'dublett' manually here
actors = Actor.objects.raw(
"select * from Actor where REPLACE(MobPh, ' ', '') = %s AND EndCd != %s;",
[phone_number, ACTOR_ENDCODE_DUBLETT]
)
# Filter on personal members; we're never handling other membership types
actors = [actor for actor in actors if actor.is_personal_member()]
# Perform raw query in order to use MSSQL's 'REPLACE' function to remove whitespace
# Note that we're excluding inactive Enrollments manually (like Enrollment.get_active() would have) here
query = 'select * from %s where (("Paymethod" = %s or "Paymethod" = %s ) and ' \
'"SubmittedDt" is null and REPLACE(Mob, \' \', \'\') = %s );' % (
Enrollment._meta.db_table, '%s', '%s', '%s',
)
params = [PAYMENT_METHOD_CODES['card'], PAYMENT_METHOD_CODES['invoice'], phone_number]
pending_actors = Enrollment.objects.raw(query, params)
# Convert the matching actors to users
users = [User.get_or_create_inactive(memberid=actor.memberid) for actor in actors]
users += [User.get_or_create_inactive(memberid=actor.memberid) for actor in pending_actors]
return users
def members(request, version, format):
if request.method == 'GET':
require_focus(request)
try:
if 'sherpa_id' in request.GET and 'medlemsnummer' in request.GET:
user = User.get_users(include_pending=True).get(id=request.GET['sherpa_id'], memberid=request.GET['medlemsnummer'])
elif 'sherpa_id' in request.GET:
user = User.get_users(include_pending=True).get(id=request.GET['sherpa_id'])
elif 'medlemsnummer' in request.GET:
try:
user = User.get_or_create_inactive(memberid=request.GET['medlemsnummer'], include_pending=True)
except (Enrollment.DoesNotExist, ValueError):
# No such member
raise User.DoesNotExist
else:
raise BadRequest(
u"You must supply either an 'sherpa_id' or 'medlemsnummer' parameter for member lookup",
code=error_codes.MISSING_REQUIRED_PARAMETER,
http_code=400
)
return HttpResponse(json.dumps(get_member_data(user)))
except (User.DoesNotExist, ValueError):
raise BadRequest(
u"A member matching that 'sherpa_id', 'medlemsnummer', or both if both were provided, does not exist.",
code=error_codes.RESOURCE_NOT_FOUND,
http_code=404
)
else:
raise BadRequest(
u"Unsupported HTTP verb",
code=error_codes.UNSUPPORTED_HTTP_VERB,
http_code=400
)
def confirm_membership_by_token(request):
"""
Confirm the membership with only the given token as authentication. Note that the URL to this view is hardcoded in
Focus which sends out emails/SMS with the URL and correct token.
"""
try:
token = request.GET['code']
actor = Actor.objects.get(family_youth_member_accepted_token=token)
youth_user = User.get_or_create_inactive(memberid=actor.memberid)
context = {
'token': token,
'youth_user': youth_user,
}
except (KeyError, Actor.DoesNotExist):
raise Http404
if request.method == 'GET':
return render(request, 'common/user/membership_confirmation.html', context)
elif request.method == 'POST':
try:
User.confirm_membership_by_token(token)
librato.increment('sherpa.medlemmer.familiemedlemskap.bekreft_ungdomsmedlem')
return redirect('%s?code=%s' % (reverse('user:confirm_membership_by_token'), token))
except:
context['confirmation_error'] = True
return render(request, 'common/user/membership_confirmation.html', context)
def handle(self, *args, **options):
file_name = args[0]
f = open(file_name, "rb")
d = csv.DictReader(f)
for row in d:
username = row["username"]
if User.objects.filter(username=username).exists():
print "User %s exists." % (username)
else:
first_name = row.get("first_name", "")
last_name = row.get("last_name", "")
email = row.get("email", "")
locality = row.get("locality", "")
gender = row.get("gender", "")
password = row.get("password", "")
user = User(username=username, email=email, first_name=first_name, last_name=last_name)
user.set_password(password)
user.save()
user.profile.gender = gender
try:
user.profile.locality = Entity.objects.get(id=locality)
except ObjectDoesNotExist:
print "user %s locality id %s does not exist" % (username, locality)
user.profile.save()
def load_user(id):
if id is None:
redirect('/login')
user = User()
user.get_by_id(id)
if user.is_active():
return user
else:
return None
def create(name, email, avatar, social_ids=None, social_accounts=None):
user = User(
name=name,
email=email,
avatar=avatar,
social_ids=social_ids or [],
social_accounts=social_accounts or []
)
yield user.save()
return user
def attempt_login(request):
matches = authenticate_users(request.POST['email'], request.POST['password'])
if len(matches) == 1:
# Exactly one match, cool, just authenticate the user
user = authenticate(user=matches[0])
log_user_in(request, user)
return matches, None
elif len(matches) > 1:
# Multiple matches, let the caller handle this
return matches, None
elif len(matches) == 0:
# Incorrect credentials. Check if this is a user from the old userpage system
old_member = authenticate_sherpa2_user(request.POST['email'], request.POST['password'])
if old_member is not None:
# Actually, it is! Let's try to import them.
if User.get_users().filter(memberid=old_member.memberid, is_inactive=False).exists():
return matches, 'old_memberid_but_memberid_exists'
# Check if a pending user exists. This shouldn't ever happen (a pending user is recently
# enrolled, and an existing user will have been member for a long time).
if User.objects.filter(memberid=old_member.memberid, is_pending=True).exists():
# Give the same error ("user exists, you need to use your new password")
return matches, 'old_memberid_but_memberid_exists'
# Verify that they exist in the membersystem (this turned out to be an incorrect assumption)
if not Actor.get_personal_members().filter(memberid=old_member.memberid).exists():
# We're not quite sure why this can happen, so we'll just give them the invalid
# credentials message - but this might be confusing for those who were able to log
# in previously.
return matches, 'invalid_credentials'
# Create the new user
try:
# Check if the user's already created as inactive
user = User.get_users().get(memberid=old_member.memberid, is_inactive=True)
user.is_inactive = False
user.set_password(request.POST['password'])
user.save()
except User.DoesNotExist:
# New user
user = User(identifier=old_member.memberid, memberid=old_member.memberid)
user.set_password(request.POST['password'])
user.save()
# Update the email on this actor, in case it were to differ from the sherpa2 email
user.update_personal_data({'email': request.POST['email']})
# Import any fjelltreffen-annonser from the old system
import_fjelltreffen_annonser(user)
authenticate(user=user)
log_user_in(request, user)
return [user], None
else:
# No luck, just provide the error message
return matches, 'invalid_credentials'
def verify_memberid(ip_address, memberid, country_code, zipcode):
"""
Returns a User object matching the given memberid, country code, and if
Norwegian; also zipcode. Includes pending users by default. Raises a range
of exceptions if the provided data is invalid or does not match any user:
- MemberidLookupsExceeded: If the client IP address has performed more
lookups than we allowed
- CountryDoesNotExist: If the given country code is invalid
- ActorIsNotPersonalMember: If the data matches an Actor in Focus who
isn't a personal member
- NoMatchingMemberid: If the data doesn't match any member
"""
# Check that the memberid is correct (and retrieve the Actor-entry)
if memberid_lookups_exceeded(ip_address):
raise MemberidLookupsExceeded
if not FocusCountry.objects.filter(code=country_code).exists():
raise CountryDoesNotExist
# Not filtering on Actor.get_personal_members() in order to raise explicit
# exception for non-personal-membership matches; see below
actor = Actor.objects.filter(
memberid=memberid,
address__country_code=country_code
)
# Require correct zipcode for domestic members
if country_code == 'NO':
actor = actor.filter(address__zipcode=zipcode)
if actor.exists():
actor = actor.get()
# Check that it's a proper member object (note that we didn't filter
# the query on Actor.get_personal_members())
if not actor.is_personal_member():
raise ActorIsNotPersonalMember
return User.get_or_create_inactive(memberid=actor.memberid)
# No matching actors, check for pending users
enrollment = Enrollment.get_active().filter(memberid=memberid)
# Require correct zipcode for domestic members
if country_code == 'NO':
enrollment = enrollment.filter(zipcode=zipcode)
if enrollment.exists():
return User.get_or_create_inactive(memberid=memberid)
# No matches
raise NoMatchingMemberid
def post(self):
context = self.get_context()
form = context.get('form')
if form.validate():
user = User()
form.populate_obj(user)
user.password = str(flask_bcrypt.generate_password_hash(user.password),'utf-8')
user.save()
return redirect(url_for('user.login'))
flash('Your request failed to pass','newAccount')
return redirect(url_for('user.new'))
def validate(self):
is_valid = super().validate()
if not is_valid:
return is_valid
user = self.request().user
old_pass = self.del_model_value('pass0')
if User.check_password(old_pass, user) or User.check_otp(old_pass, user):
self.add_model_value('id', self.m_request.user.id)
print(self.m_values)
else:
is_valid = False
self.set_error('pass0', 'Old password in wrong, not working?, try OTP')
return is_valid
def login():
if request.method == "POST" and "j_username" in request.form:
name = request.form["j_username"]
user_obj = User()
user = user_obj.get_by_name_w_password(name)
if user and flask_bcrypt.check_password_hash(user.password, request.form["j_password"]) and user.is_valid():
remember = request.form.get("remember", "no") == "yes"
if login_user(user, remember=remember) and user.type == 1:
return redirect('/device/index')
else:
flash("登录失败")
return render_template("/auth/login.html")
def contact_person_search(request, forening_id):
current_forening = Forening.objects.get(id=forening_id)
if current_forening not in request.user.all_foreninger():
raise PermissionDenied
MAX_HITS = 100
if len(request.POST['q']) < settings.ADMIN_USER_SEARCH_CHAR_LENGTH:
raise PermissionDenied
local_nonmember_users = User.get_users().filter(memberid__isnull=True)
for word in request.POST['q'].split():
local_nonmember_users = local_nonmember_users.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word)
)
local_nonmember_users = local_nonmember_users.order_by('first_name')
actors = Actor.get_personal_members()
for word in request.POST['q'].split():
actors = actors.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word) |
Q(memberid__icontains=word)
)
actors = actors.order_by('first_name')
# Get (or create) the user objects for the first MAX_HITS actor-hits
users = [
User.get_or_create_inactive(a.memberid)
for a in actors[:MAX_HITS]]
# Merge with non-members
users = sorted(
list(users) + list(local_nonmember_users),
key=lambda u: u.get_full_name())
context = {
'current_forening': current_forening,
'users': users[:MAX_HITS],
}
return HttpResponse(json.dumps({
'results': render_to_string(
'central/admin/foreninger/contact_person_search_results.html',
context,
request=request,
),
'max_hits_exceeded': len(users) > MAX_HITS or len(actors) > MAX_HITS
}))
def search(request):
if not request.is_ajax() or request.method != 'POST':
return redirect('admin.users.views.index')
if len(request.POST['q']) < settings.ADMIN_USER_SEARCH_CHAR_LENGTH:
raise PermissionDenied
local_users = User.get_users().filter(memberid__isnull=True)
for word in request.POST['q'].split():
local_users = local_users.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word))
local_users = local_users.order_by('first_name')
actors = Actor.get_personal_members()
for word in request.POST['q'].split():
actors = actors.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word) |
Q(memberid__icontains=word))
actors = actors.order_by('first_name')
# Match expired users only on memberid
expired_users = User.objects.all()
for word in request.POST['q'].split():
expired_users = expired_users.filter(memberid__icontains=word)
expired_users = [u for u in expired_users if not Actor.get_personal_members().filter(memberid=u.memberid).exists()]
# Pending users
pending_enrollment = Enrollment.get_active()
for word in request.POST['q'].split():
pending_enrollment = pending_enrollment.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word) |
Q(memberid__icontains=word))
pending_enrollment = pending_enrollment.order_by('first_name')
members = User.get_users().filter(memberid__in=[a.memberid for a in actors])
pending_users = User.get_users(include_pending=True).filter(memberid__in=[e.memberid for e in pending_enrollment])
actors_without_user = [a for a in actors if a.memberid not in list(members.values_list('memberid', flat=True))]
users = list(local_users) + list(members) + list(pending_users)
context = RequestContext(request, {
'users': users,
'actors_without_user': actors_without_user,
'expired_users': expired_users
})
return HttpResponse(render_to_string('common/admin/users/user_results.html', context))
def createuser():
import getpass
from user.models import User
db = Session()
while True:
name = raw_input('username:'******'user exists'
else:
break
pwd = getpass.getpass('password:')
user = User(username=name)
user.set_password(pwd)
db.add(user)
db.commit()
def list_albums(request, album):
albums = Album.objects.filter(parent=album).order_by("name")
parents = []
images = None
current_album = None
if album is not None:
current_album = Album.objects.get(id=album)
images = Image.objects.filter(album=album)
parents = list_parents(current_album)
fotokonkurranse_album = Fotokonkurranse.objects.get().album
context = {
"album": album,
"albums": albums,
"albumpath": parents,
"current_album": current_album,
"images": images,
"origin": request.get_full_path(),
"all_users": sorted(User.sherpa_users(), key=lambda u: u.get_first_name()),
"current_navigation": "albums",
"image_search_length": settings.IMAGE_SEARCH_LENGTH,
"fotokonkurranse_album": fotokonkurranse_album,
"album_download_part_count": Album.DOWNLOAD_PART_COUNT,
}
return render(request, "central/admin/images/list_albums.html", context)
def get_queryset(self):
# This method uses Focus and local users to compile a search result
# containing users.
# See the comment on the class definition of the lazy_queryset variable
if self.lazy_queryset:
return self.lazy_queryset
SEARCH_MAX_HITS = 100
search = self.request.query_params.get('search', '').strip()
if len(search) < settings.ADMIN_USER_SEARCH_CHAR_LENGTH:
raise PermissionDenied
local_users = User.get_users()
for word in search.split():
local_users = local_users.filter(
Q(first_name__icontains=word) |
Q(last_name__icontains=word) |
Q(email__icontains=word))
local_users = local_users.order_by('first_name')[:SEARCH_MAX_HITS]
users = sorted(list(local_users), key=lambda u: u.get_full_name(True))
self.lazy_queryset = users
return users
def user_post(self, *args):
pagename = args[0]
if args[0] is None:
pagename=""
exercise = Exercise.query().filter("url = ",pagename).get()
submission = self.request.get('code')
program = exercise.outside_code.format(submission)
action = self.request.get('action')
response = dict()
if action == 'check':
response = exercise.checker.checkWork(program, self.username)
if response['passed']:
user = User.query().filter('username = '******'test':
message = ''
logging.info(self.request.get('input'))
response = exercise.checker.submit(program, self.username, self.request.get('input'))
if (response['error'] != "OK" or
int(response['result']) != 15 or
response['output'] is None):
message = response['error_message']
response['message'] = message
self.write_json(response);
def list_albums(request, album):
albums = Album.objects.filter(parent=album).order_by('name')
parents = []
images = None
current_album = None
if album is not None:
current_album = Album.objects.get(id=album)
images = Image.objects.filter(album=album)
parents = list_parents(current_album)
fotokonkurranse_album = Fotokonkurranse.objects.get().album
context = {
'album': album,
'albums': albums,
'albumpath': parents,
'current_album': current_album,
'images': images,
'origin': request.get_full_path(),
'all_users': sorted(User.sherpa_users(), key=lambda u: u.get_first_name()),
'current_navigation': 'albums',
'image_search_length': settings.IMAGE_SEARCH_LENGTH,
'fotokonkurranse_album': fotokonkurranse_album,
'album_download_part_count': Album.DOWNLOAD_PART_COUNT,
}
return render(request, 'common/admin/images/list_albums.html', context)
def get_user(handler):
if 'pk' in handler.session:
try:
return (yield User.load(pk=handler.session['pk']))
except ObjectDoesNotExist:
return AnonymousUser()
return AnonymousUser()
def check_host(host):
'''
Check we are running on the correct host
see the notes about the use of flock();
and the affects of lockf();
'''
assert User.host() == host, "AberMUD is only available on {}, not on {}".format(host, User.host())
def _deserialize(self):
"""Look up the User objects from stored session ids and store them"""
raw_data = self.request.session[self._session_key()]
# If this is an older session, discard it and create a new default one
if self._is_old_session(raw_data):
self._create()
raw_data = self.request.session[self._session_key()]
self.participants = [
Participant(
signup_session=self,
id=p['id'],
user=User.get_cached(id=p['user_id']) if p['user_id'] is not None else None,
first_name=p['first_name'],
last_name=p['last_name'],
email=p['email'],
phone=p['phone'],
birth_date=datetime.strptime(p['birth_date'], "%Y-%m-%d").date() if p['birth_date'] is not None else None,
state=p['state'],
use_parent_contact_info=p['use_parent_contact_info'],
use_signee_contact_info=p['use_signee_contact_info'],
discount_code=p['discount_code'],
signee_relation=p['signee_relation'],
answers=p['answers'],
extras=p['extras'],
)
for p in raw_data['participants']
]
self.comment = raw_data['comment']
self.extras = raw_data['extras']
self.extras_defaults_set = raw_data['extras_defaults_set']
self.participate_together = raw_data['participate_together']
def validate_existing(self):
try:
user = ExistingUser.get_or_create_inactive(memberid=self.existing_memberid)
except (ExistingUser.DoesNotExist, ValueError):
return False
if not user.payment.status['is_paid']:
return False
if user.get_dnt_age() < settings.MEMBERSHIP['AGES']['YOUTH']:
return False
if user.is_related_member():
return False
if user.has_membership_type('family_primary'):
return False
if user.address.country.code != self.country:
return False
if self.country == 'NO' and user.address.zipcode.zipcode != self.zipcode:
return False
return True
def school():
if request.method == 'GET':
# fields to be hidden come here
field_args = {'user': {'widget': wtforms.widgets.HiddenInput()}}
return cruder(request, School, 'school.html', 'school', 'School', field_args)
else:
obj_form = model_form(School)
form = obj_form(request.form)
sid = form.save().id
User.objects(id=g.user.get_id()).update_one(set__school=request.form['school_name'])
User.objects(id=g.user.get_id()).update_one(set__schoolid=str(sid))
g.user.reload()
if request.args['s'] == 't':
return render_template('complete.html')
return redirect(url_for('.school', m='r', id=str(sid)))
def login_chosen_user(request):
if 'authenticated_users' not in request.session:
return redirect('user:login.login')
if 'user' not in request.POST:
del request.session['authenticated_users']
return redirect('user:login.login')
# Verify that the user authenticated for this user
if not int(request.POST['user']) in request.session['authenticated_users']:
del request.session['authenticated_users']
return redirect('user:login.login')
# All is swell, log the user in
user = User.get_users(include_pending=True).get(id=request.POST['user'], is_inactive=False)
user = authenticate(user=user)
log_user_in(request, user)
del request.session['authenticated_users']
if request.site.is_central():
return redirect(request.GET.get('next', reverse('user:home')))
else:
if 'sso_checked' in request.session:
del request.session['sso_checked']
return redirect(sso_login_url(
request.site,
request.user,
request.GET.get('next', reverse('user:home')),
))
def process_invoice(request):
if 'enrollment' not in request.session:
return redirect('enrollment:registration')
enrollment = get_or_create_enrollment(request)
if enrollment.state == 'registration':
# Whoops, how did we get here without going through payment first? Redirect back.
return redirect('enrollment:payment_method')
elif enrollment.state == 'payment':
# Cool, this is where we want to be.
pass
elif enrollment.state == 'complete':
# Registration has already been completed, redirect forwards to results page
return redirect('enrollment:result')
for user in enrollment.users.all():
user.pending_user = User.create_pending_user(user.memberid)
user.save()
librato.increment('sherpa.medlemmer.innmeldinger')
if enrollment.relation_type == 'family':
librato.increment('sherpa.familiemedlemskap.innmelding.faktura_valgt')
prepare_and_send_email(request, enrollment)
enrollment.save_prices()
enrollment.state = 'complete'
enrollment.result = 'success_invoice'
enrollment.save()
return redirect('enrollment:result')
def users_remove_access(request, forening_id):
current_forening = Forening.objects.get(id=forening_id)
if current_forening not in request.user.all_foreninger():
raise PermissionDenied
# Verify that the user has admin access to the association
cur_user_is_valid = request.user.has_perm(
'sherpa/association/admin',
association_id=current_forening.id,
)
# ... or is Sherpa admin
if not cur_user_is_valid and not request.user.has_perm('sherpa/admin'):
raise PermissionDenied
other_user = User.get_users(
include_pending=True).get(id=request.POST['user'])
other_user.remove_perm(
'sherpa/association/user',
association_id=current_forening.id,
)
other_user.remove_perm(
'sherpa/association/admin',
association_id=current_forening.id,
)
messages.info(request, 'permission_deleted')
cache.delete('user.%s.all_foreninger' % other_user.id)
return redirect('admin:foreninger.users', current_forening.id)
def update(self):
print('saving ....')
if User.update(self.model_values()):
self.add_model_value('pass0', 'xxxxxxxxxxx')
self.add_model_value('password', 'xxxxxxxxxxx')
return self.result()
return None
def _add(self, user_id):
if user_id not in self._nodes:
from user.models import User
with db.session():
self._nodes[user_id] = Node(self, User.get_or_create(user_id))
else:
if not self._nodes[user_id].online:
self._nodes[user_id].ping()
class ModelTest(TestCase):
def setUp(self):
self._test_user = User(username="******")
self._test_user.save()
def test_make_attrbase(self):
entity = Entity(name="test01", created_user=self._test_user)
entity.save()
attr_base = EntityAttr(
name="hoge",
type=AttrTypeValue["object"],
created_user=self._test_user,
parent_entity=entity,
)
attr_base.save()
self.assertEqual(attr_base.name, "hoge")
self.assertTrue(isinstance(attr_base.type, int))
self.assertEqual(attr_base.referral.count(), 0)
def test_make_entity(self):
entity = Entity(name="test01", created_user=self._test_user)
entity.save()
self.assertEqual(entity.name, "test01")
self.assertEqual(list(entity.attrs.all()), [])
self.assertTrue(entity.is_active)
def test_set_parent(self):
entity = Entity(name="test01", created_user=self._test_user)
entity.save()
attr_base = EntityAttr(
name="hoge",
type=AttrTypeValue["object"],
created_user=self._test_user,
parent_entity=entity,
)
attr_base.save()
self.assertEqual(attr_base.parent_entity, entity)
def test_import_with_existed_object(self):
entity = Entity(name="test01",
note="note1",
created_user=self._test_user)
entity.save()
EntityResource.import_data_from_request(
{
"id": entity.id,
"name": entity.name,
"note": entity.note,
"created_user": entity.created_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, entity.name)
self.assertEqual(Entity.objects.last().note, entity.note)
self.assertEqual(Entity.objects.last().created_user, self._test_user)
def test_import_with_new_object(self):
EntityResource.import_data_from_request(
{
"name": "foo",
"note": "bar",
"created_user": self._test_user,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, "foo")
self.assertEqual(Entity.objects.last().note, "bar")
self.assertEqual(Entity.objects.last().created_user, self._test_user)
def test_import_with_updating_object(self):
entity = Entity(name="test01",
note="note1",
created_user=self._test_user)
entity.save()
EntityResource.import_data_from_request(
{
"id": entity.id,
"name": "changed_name",
"note": "changed_note",
"created_user": entity.created_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, "changed_name")
self.assertEqual(Entity.objects.last().note, "changed_note")
self.assertEqual(Entity.objects.last().created_user, self._test_user)
def test_import_with_invalid_parameter(self):
with self.assertRaises(RuntimeError):
EntityResource.import_data_from_request(
{
"name": "hoge",
"note": "fuga",
"invalid_key": "invalid_value",
"created_user": self._test_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 0)
def test_import_without_mandatory_parameter(self):
with self.assertRaises(RuntimeError):
EntityResource.import_data_from_request(
{
"note": "fuga",
"created_user": self._test_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 0)
def test_import_with_spoofing_parameter(self):
user = User.objects.create(username="******")
EntityResource.import_data_from_request(
{
"name": "entity",
"note": "note",
"created_user": user
}, self._test_user)
self.assertEqual(Entity.objects.count(), 0)
def test_import_without_permission_parameter(self):
user = User.objects.create(username="******")
entity = Entity.objects.create(name="origin_name",
created_user=user,
is_public=False)
entity.save()
EntityResource.import_data_from_request(
{
"id": entity.id,
"name": "changed_name",
"note": "changed_note",
"created_user": entity.created_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, "origin_name")
def test_import_entity_attr_with_changing_type(self):
"""
This checks the attribute type wouldn't be changed by specifying type.
"""
user = self._test_user
entity = Entity.objects.create(name="Entity",
created_user=user,
is_public=False)
entity_attr = EntityAttr.objects.create(
**{
"name": "attr",
"type": AttrTypeValue["string"],
"created_user": user,
"parent_entity": entity,
})
entity.attrs.add(entity_attr)
EntityAttrResource.import_data_from_request(
{
"id": entity_attr.id,
"name": "changed-attr",
"type": AttrTypeValue["array_string"],
"entity": entity.name,
"created_user": user.username,
},
user,
)
entity_attr.refresh_from_db()
self.assertEqual(entity_attr.name, "changed-attr")
self.assertEqual(entity_attr.type, AttrTypeValue["string"])
def test_import_entity_attr_without_specifying_type(self):
"""
This import EntityAttr without specifying type parameter.
"""
user = self._test_user
entity = Entity.objects.create(name="Entity",
created_user=user,
is_public=False)
entity_attr = EntityAttr.objects.create(
**{
"name": "attr",
"type": AttrTypeValue["string"],
"created_user": user,
"parent_entity": entity,
})
entity.attrs.add(entity_attr)
EntityAttrResource.import_data_from_request(
{
"id": entity_attr.id,
"name": "changed-attr",
"entity": entity.name,
"created_user": user.username,
},
user,
)
entity_attr.refresh_from_db()
self.assertEqual(entity_attr.name, "changed-attr")
self.assertEqual(entity_attr.type, AttrTypeValue["string"])
def test_import_entity_attr_without_specifying_id(self):
"""
This checks an attribute would be created by importing.
"""
user = self._test_user
entity = Entity.objects.create(name="Entity",
created_user=user,
is_public=False)
EntityAttrResource.import_data_from_request(
{
"name": "attr",
"type": AttrTypeValue["array_string"],
"entity": entity.name,
"created_user": user.username,
},
user,
)
entity.refresh_from_db()
self.assertEqual(
[(x.name, x.type) for x in entity.attrs.all()],
[("attr", AttrTypeValue["array_string"])],
)
def test_import_entity_attr_without_specifying_id_and_type(self):
"""
This checks an attribute wouldn't be created by importing because of luck of parameters
"""
user = self._test_user
entity = Entity.objects.create(name="Entity",
created_user=user,
is_public=False)
# This processing would be failed because 'type' parameter is necessary for creating
# a new EntityAttr instance by importing processing.
with self.assertRaises(RuntimeError) as cm:
EntityAttrResource.import_data_from_request(
{
"name": "attr",
"entity": entity.name,
"created_user": user.username
},
user,
)
# Check assert exception message
self.assertEqual(
cm.exception.args[0],
"The parameter 'type' is mandatory when a new EntityAtter create",
)
# This checks EntityAttr would not be created
self.assertFalse(
EntityAttr.objects.filter(parent_entity=entity,
is_active=True).exists())
def test_is_update_method(self):
user = User.objects.create(username="******")
entity_ref = Entity.objects.create(name="entity_ref",
created_user=user)
entity = Entity.objects.create(name="entity", created_user=user)
attr = EntityAttr.objects.create(
name="attr",
type=AttrTypeValue["object"],
created_user=user,
parent_entity=entity,
)
attr.referral.add(entity)
# initialize params which is same with the EntityAttr `attr`
params = {
"name": attr.name,
"refs": [entity.id],
"index": attr.index,
"is_mandatory": attr.is_mandatory,
"is_delete_in_chain": attr.is_delete_in_chain,
}
# check not to change any parameter
self.assertFalse(attr.is_updated(**params))
# check to change name parameter
changed_params = copy(params)
changed_params["name"] = "name (changed)"
self.assertTrue(attr.is_updated(**changed_params))
# check to change referrals parameter
changed_params = copy(params)
changed_params["refs"] = [entity_ref]
self.assertTrue(attr.is_updated(**changed_params))
# check to change index parameter
changed_params = copy(params)
changed_params["index"] = attr.index + 1
self.assertTrue(attr.is_updated(**changed_params))
# check to change is_mandatory parameter
changed_params = copy(params)
changed_params["is_mandatory"] = not params["is_mandatory"]
self.assertTrue(attr.is_updated(**changed_params))
# check to change is_delete_in_chain parameter
changed_params = copy(params)
changed_params["is_delete_in_chain"] = not params["is_delete_in_chain"]
self.assertTrue(attr.is_updated(**changed_params))
def create_test_weibo():
'''创建微博测试数据'''
users = User.fake_users(50)
uid_list = [u.id for u in users]
Weibo.fake_weibos(uid_list, 5000)
def populate_users(self):
first_item = User()
def __init__(self):
"""
Constructor.
"""
self.user = User()
# encoding: utf-8
# -*- coding: utf-8 -*-
# author = ‘LW’
from user.models import User
from datetime import datetime
for i in range(10):
u = User()
u.name = 'kk_{0}'.format(i)
u.age = i + 1
u.create_time = datetime.now()
u.save()
# <
User.objects.filter(age__lt=5)
# <=
User.objects.filter(age__lte=5)
# >
User.objects.filter(age__gt=5)
# >=
User.objects.filter(age__gte=5)
# like %%
User.objects.filter(name__contains='kk')
# like %val
User.objects.filter(name__startswith='kk')
# like val%
User.objects.filter(name__endswith='9')
# and
User.objects.filter(age__gt=5, name__endswith='9')
# in
def setUp(self):
self._test_user = User(username="******")
self._test_user.save()
