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()