def save_user(): form = UserForm() service = UserService() if form.is_submitted(): _id = service.save_user(form.raw_inputs, form.mode) if _id is not None: return jsonify({'id':str(_id)}) else: return jsonify({'id':''}) else: return jsonify({'id':''})
def login(): '''When a user logs in, their session is marked as 'fresh'. ''' form = LoginForm() if form.errors == []: service = UserService() ret = service.login(form.account, form.password, form.remember_me) # flash('Logged in successfully!') return jsonify({'error':str(ret)}) else: # If input has error return jsonify({'error':str(form.errors[0])})
def token_verify(token): secret_key = current_app.config.get('SECRET_KEY') try: data = jwt.decode(token, secret_key, algorithm='HS256') return UserService.instance().get_one_or_fail(data['id']) except jwt.DecodeError: return False
class UserFriendsView(HTTPMethodView): user_repository = UserRepository(MySQLConnection) user_service = UserService(user_repository) friend_repository = FriendRepository(MySQLConnection) friend_service = FriendService(friend_repository) @doc.summary('Get friends of user') @doc.produces({'friends': [Friend]}, description='Friends of user') async def get(self, request, username: str): user = await self.user_service.get(username) return json( {'friends': await self.friend_service.get_all(user['seq'])}) @doc.summary('Create friend relationship of ') @doc.consumes(FriendCreation, content_type='application/json', location='body', required=True) async def post(self, request, username: str): user = await self.user_service.get(username) if user['seq'] != request.json['user_id']: abort(403) await self.friend_service.create(request.json)
class UserFriendRequestDetailView(HTTPMethodView): user_repository = UserRepository(MySQLConnection) user_service = UserService(user_repository) friend_request_repository = FriendRequestRepository(MySQLConnection) friend_request_service = FriendRequestService(friend_request_repository) @doc.summary('Get friend request') @doc.produces({'request': FriendRequest}, description='Request for the friend_request_id', content_type='application/json') async def get(self, request, username: str, friend_request_id: int): user = await self.user_service.get(username) friend_request = await self.friend_request_service.get( friend_request_id) if user['seq'] != friend_request_id['recipient']: abort(403) return json({'request': friend_request}) @doc.summary('Delete the friend request') async def delete(self, request, username: str, friend_request_id: int): user = await self.user_service.get(username) friend_request = await self.friend_request_service.get( friend_request_id) if user['seq'] != friend_request['recipient']: abort(403) await self.friend_request_service.delete(friend_request_id)
class User: def __init__(self): self.user_service = UserService() def on_post(self, req, resp): """crea un usuario para el sistema con su rol""" try: result = self.user_service.create(req.context['data'], self.session) resp.status = falcon.HTTP_201 # This is the default status resp.context['result'] = response_ok(result, "ok", 'created', 'post', req.path) except ValidationError as err: resp.status = falcon.HTTP_400 resp.context['result'] = response_error(err.messages, str("Validation Error"), 'post', req.path) except SerializerException as exc: resp.status = falcon.HTTP_500 resp.context['result'] = response_error( {}, "Internal Error. Contact the Admin.", 'post', req.path) except Exception as exc: resp.status = falcon.HTTP_400 resp.context['result'] = response_error({}, str(exc), 'post', req.path)
class UserFriendRequestView(HTTPMethodView): user_repository = UserRepository(MySQLConnection) user_service = UserService(user_repository) friend_request_repository = FriendRequestRepository(MySQLConnection) friend_request_service = FriendRequestService(friend_request_repository) @doc.summary('Get friend requests to the user') @doc.produces({'requests': [FriendRequest]}, description='Requests to the user', content_type='application/json') async def get(self, request, username: str): user = await self.user_service.get(username) return json({ 'requests': await self.friend_request_service.get_all(user['seq']) }) @doc.summary('Create friend request') @doc.consumes(FriendRequestCreation, location='body', content_type='application/json') async def post(self, request, username: str): user = await self.user_service.get(username) if user['seq'] != request.json['sender']: abort(403) await self.friend_request_service.create(request.json)
def auth_login(email: fields.Email(), password: fields.String()): user = UserService.instance().login(email, password) if not user: raise HTTPBadRequest("login", "failed") token_data = dict(id=user.id) return {"token": token_generate(token_data)}
class UserInformationView(HTTPMethodView): repository = UserRepository(MySQLConnection) service = UserService(repository) @doc.summary('Get user information') @doc.produces(User, description='User of the username', content_type='application/json') async def get(self, request, username: str): user = await self.service.get(username) del user['seq'] del user['user_id'] return json(user)
class UserSignupView(HTTPMethodView): repository = UserRepository(MySQLConnection) service = UserService(repository) @doc.summary('Register account') @doc.consumes( UserRegistration, location='body', content_type='application/json', required=True) @doc.produces({'success': bool}, description='the result of account registration', content_type='application/json') async def post(self, request: Request): await self.service.create(request.json) return json({ 'success': True })
class UserFieldGetterView(HTTPMethodView): repository = UserRepository(MySQLConnection) service = UserService(repository) field_name: str = getter_field field_type: type = getter_field_type @doc.summary(f'Get {field_name} of user') @doc.produces({getter_field: getter_field_type}, content_type='application/json', description=f'The value of {getter_field} field') async def get(self, request, username: str): field_name = self.field_name if field_name not in self.repository.patchable_fields: abort(404) user = await self.service.get(username) return json({field_name: user[field_name]})
class UserSigninView(HTTPMethodView): repository = UserRepository(MySQLConnection) service = UserService(repository) @doc.summary('Authenticate account') @doc.consumes(UserAuthentication, location='body', content_type='application/json', required=True) @doc.produces({'success': bool}, description='the result of account authentication', content_type='application/json') async def post(self, request: Request): user = await self.service.get(request.json['username']) return json({ 'success': check_password_hash(user['password'], (request.json['password'])) })
def start_service(): service = Service() add_post_service = AddPostService(service) remove_post_service = RemovePostService(service) feed_service = FeedService(service) category_service = CategoryService(service) vote_service = VoteService(service) comment_service = CommentService(service) user_service = UserService(service) user_liked_post_service = UserLikedPostService(service) email_validation_service = EmailValidationService(service) app = falcon.API(middleware=[HandleCORS()]) app.add_route('/add_post_to_category', add_post_service) app.add_route('/remove_post_from_category', remove_post_service) app.add_route('/feed', feed_service) app.add_route('/category', category_service) app.add_route('/vote', vote_service) app.add_route('/comment', comment_service) app.add_route('/user', user_service) app.add_route('/user_liked_post', user_liked_post_service) app.add_route('/email_validation', email_validation_service) return app
class UserPatchView(HTTPMethodView): repository = UserRepository(MySQLConnection) service = UserService(repository) field_name: str = patch_field field_type: type = patch_field_type @doc.summary(f'Get {field_name} of user') @doc.produces({patch_field: patch_field_type}, content_type='application/json', description=f'The value of {patch_field} field') async def get(self, request, username: str): field_name = self.field_name if field_name not in self.repository.patchable_fields: abort(404) user = await self.service.get(username) return json({field_name: user[field_name]}) @doc.summary(f'Patch {field_name} of user') @doc.consumes({'patch_data': { patch_field: patch_field_type }}, location="body", content_type='application/json') @doc.produces({'success': bool}, description='Result of the patch', content_type='application/json') async def put(self, request, username: str): field_name = self.field_name if field_name not in self.service.patchable_fields: abort(403) user = await self.service.get(username) await self.repository.patch( username, {field_name: user[field_name] + request.json[field_name]}) return json({'success': True})
def __init__(self): self.user_service = UserService()
def __init__(self, user_id: int) -> None: self.user_svc = UserService() self.user_id = user_id cur_validators = self.user_svc.get_all_validators(user_id) self.indices = [validator.indice for validator in cur_validators]
def user_info(): s = UserService() s.get_info() return s.render()
def edit_user(): payload = request.json user_svc = UserService() user_svc.update(current_identity.id, payload) return {'code': HTTPStatus.OK}
def register(): payload = request.json user_svc = UserService() user_svc.create(payload) return {'code': HTTPStatus.CREATED}
class ValidatorService: def __init__(self, user_id: int) -> None: self.user_svc = UserService() self.user_id = user_id cur_validators = self.user_svc.get_all_validators(user_id) self.indices = [validator.indice for validator in cur_validators] def create(self, indices: List[str]) -> List[ValidatorDT]: resp = requests.get(f'{config.BEACON_RPC_URI}/validators', params={'indices': indices}) resp = resp.json() index_to_pubkey = {} for val in resp['validatorList']: index_to_pubkey[val['index']] = b64_to_hex( val['validator']['publicKey']) validators_to_add = [ Validator(indice=i, pubkey=index_to_pubkey[i], user_id=self.user_id) for i in indices ] with SessionManager.session() as session: session.add_all(validators_to_add) return [ValidatorDT.from_model(m) for m in validators_to_add] def remove(self, indice: str) -> None: with SessionManager.session() as session: session.query(Validator).filter_by( indice=indice, user_id=self.user_id).delete(synchronize_session=False) def get(self) -> List[ValidatorDT]: with SessionManager.session() as session: rows = session.query(Validator).filter_by( user_id=self.user_id).all() return [ValidatorDT.from_model(m) for m in rows] def info(self) -> Dict: """Retrieve a validator total balance, balance over time, avg rating and rating per index. """ activation_epoch = self._get_activation_epoch() balances = self._get_balance(activation_epoch) validator_perf = self._get_validator_performance(activation_epoch) balance_overtime = self._get_balance_ovetime(activation_epoch, balances['total']) info_validator = {} for i in self.indices: info_validator[i] = { 'balance': balances['validators'][i], 'rating': validator_perf['validators'][i], } return { 'global': { 'balance': balances['total'], 'rating': validator_perf['avg'], 'overtime': balance_overtime, }, 'validators': info_validator, } def _get_balance_ovetime(self, activation_epoch: Dict[str, str], total_balance: str) -> Dict[str, str]: num_validators = len(activation_epoch) cur_epoch = int(self._get_current_epoch()) earliest_epoch = cur_epoch overtime = {} for epoch in activation_epoch.values(): if int(epoch) < int(earliest_epoch): earliest_epoch = int(epoch) if cur_epoch == earliest_epoch: increment = int(cur_epoch) // 6 step = 0 for _ in range(6): overtime[step] = 0 step += increment return overtime for _ in range(6): distance_epoch = cur_epoch - earliest_epoch increment = int(distance_epoch) // 6 balance_increment = (float(total_balance) - (num_validators * 32.00)) / 6 step = earliest_epoch step_balance = 32 * num_validators for _ in range(6): overtime[step] = step_balance step_balance += balance_increment step += increment return overtime def _get_validator_performance(self, activation_epoch: Dict[str, str]) -> Dict: """GET eth/v1alpha1/validators/performance Retrieve the inclusion distance for each validators assigned to current_user """ cur_epoch = int(self._get_current_epoch()) filter_active_indices = [ i for i in self.indices if int(activation_epoch[i]) <= int(cur_epoch) ] if len(filter_active_indices) == 0: return {i: '?' for i in self.indices} resp = requests.get(f'{config.BEACON_RPC_URI}/validators/performance', params={'indices': self.indices}) resp = resp.json() validator_perf = {i: '?' for i in self.indices} sum_distance = 0 for n, inclusion_dist in enumerate(resp['inclusionDistances']): distance_int = int(inclusion_dist) validator_perf[filter_active_indices[n]] = distance_int sum_distance += distance_int avg_perf = int(round(sum_distance // len(filter_active_indices))) return {'validators': validator_perf, 'avg': avg_perf} def _get_balance(self, activation_epoch: Dict[str, str]) -> Dict: """GET eth/v1alpha1/validator/balances Retrieve: a) the overall balance for all validators assigned to current_user over time b) balance for each individual validators """ # last_n_epoch = self._get_last_n_epoch() cur_epoch = int(self._get_current_epoch()) balances = {} balance_per_index = {i: '0' for i in self.indices} # for epoch in last_n_epoch: total_balance_epoch, balance_per_index = self._balance_for_epoch( activation_epoch, cur_epoch) balances['total'] = total_balance_epoch balances['validators'] = balance_per_index return balances def _balance_for_epoch(self, activation_epoch: Dict[str, str], epoch: str) -> Tuple[str, Dict[str, str]]: filter_active_indices = [ i for i in self.indices if int(activation_epoch[i]) <= int(epoch) ] if len(filter_active_indices) == 0: return '0', {i: '0' for i in self.indices} total_balance = 0 resp = requests.get( f'{config.BEACON_RPC_URI}/validators/balances', params={ 'indices': filter_active_indices, 'epoch': epoch }, ) resp = resp.json() balance_per_index = {} for json in resp['balances']: total_balance += int(json['balance']) balance_per_index[json['index']] = gwei_to_ether(json['balance']) return gwei_to_ether(total_balance), balance_per_index def _get_current_epoch(self) -> str: """Calculate the current epoch from genesis""" sec_since_genesis = int(time.time()) - config.EPOCH_GENESIS current_epoch = int(sec_since_genesis / config.SEC_PER_EPOCH) return str(current_epoch) def _get_last_n_epoch(self) -> List[str]: """Fetch last 7 days epoch""" pointer_epoch = int(self._get_current_epoch()) last_n_epoch = [pointer_epoch] for _ in range(6): pointer_epoch = max(1, pointer_epoch - config.EPOCH_PER_DAY) last_n_epoch = [pointer_epoch] + last_n_epoch if pointer_epoch == 0: break return last_n_epoch def _get_activation_epoch(self) -> Dict[str, str]: """GET /eth/v1alpha1/validators Retrieve activation epoch for each validator, None if not activated yet """ resp = requests.get(f'{config.BEACON_RPC_URI}/validators', params={'indices': self.indices}) resp = resp.json() validator_activation_epoch = {} for val in resp['validatorList']: validator_activation_epoch[ val['index']] = val['validator']['activationEpoch'] return validator_activation_epoch
def user_login(): s = UserService() s.login() return s.render()
class UserBaseResource(BaseResource): user_service = UserService() task_service = TaskService() user_serializer = UserSerializer()