def member_add_membership_days( entity_id=None, type=Arg(Enum(Span.MEMBERSHIP, Span.LABACCESS, Span.SPECIAL_LABACESS)), days=Arg(natural1), creation_reason=Arg(non_empty_str), default_start_date=Arg(iso_date, required=False)): return add_membership_days(entity_id, type, days, creation_reason, default_start_date).as_json()
def memberbooth_member(member_number=Arg(int)): member = db_session.query(Member).filter( Member.member_number == member_number, Member.deleted_at.is_(None)).first() if not member: return None membership_data = get_membership_summary(member.member_id) return memberbooth_response_object(member, membership_data)
def memberbooth_tag(tagid=Arg(int)): key = db_session.query(Key)\ .join(Key.member) \ .filter(Key.tagid == tagid) \ .filter( Member.deleted_at.is_(None), Key.deleted_at.is_(None), ) \ .first() if key is None: return None membership_data = get_membership_summary(key.member_id) return memberbooth_response_object(key.member, membership_data)
def login(grant_type=Arg(Enum('password')), username=Arg(str), password=Arg(str)): """ Login user with username and password, returns token. """ assert grant_type username = username.strip() return auth.login(request.remote_addr, request.user_agent.string, username, password)
def password_reset(reset_token: str=Arg(non_empty_str), unhashed_password: str=Arg(str)): """ Reset the password for a user. """ return auth.password_reset(reset_token, unhashed_password)
def request_password_reset(user_identification: str=Arg(non_empty_str)): """ Send a reset password link to the users email. """ user_identification = user_identification.strip() return auth.request_password_reset(user_identification)
def send_access_token(redirect=Arg(str, required=False), user_identification: str = Arg(str)): """ Send access token email to user with username or member_number user_identification. """ return send_access_token_email(redirect or "/member", user_identification, request.remote_addr, request.user_agent.string)
def box_terminator_nag_route(member_number=Arg(int), box_label_id=Arg(int), nag_type=Arg(symbol)): """ Send a nag email for this box. """ return box_terminator_nag(member_number, box_label_id, nag_type)
def box_terminator_validate_route(member_number=Arg(int), box_label_id=Arg(int)): """ Used when scanning boxes. """ return box_terminator_validate(member_number, box_label_id, g.session_token)
def list(self, sort_by=Arg(symbol, required=False), sort_order=Arg(Enum(DESC, ASC), required=False), search: str = Arg(str, required=False), page_size=Arg(natural0, required=False), page=Arg(natural1, required=False), expand=Arg(symbol, required=False), relation=None, related_entity_id=None): query = db_session.query(self.model) if not self.list_deleted: query = query.filter(self.model.deleted_at.is_(None)) if relation and related_entity_id: query = relation.filter(query, related_entity_id) if search: for term in search.split(): expression = or_(*[ self.columns[column_name].like(f"%{term}%") for column_name in self.search_columns ]) query = query.filter(expression) if expand: expand_field = self.expand_fields.get(expand) if not expand_field: raise UnprocessableEntity(f"Expand of {expand} not allowed.", fields='expand', what=BAD_VALUE) query = query.outerjoin( expand_field.relation).add_columns(*expand_field.columns) column_obj_converter = [ to_obj_converters[type(c.type)] for c in expand_field.columns ] # Use to_obj that can unpack result row. def to_obj(row): obj = self.to_obj(row[0]) for value, column, converter in zip(row[1:], expand_field.columns, column_obj_converter): obj[column.name] = converter(value) return obj else: # Use regular to_obj. to_obj = self.to_obj sort_column = sort_by or self.default_sort_column sort_order = sort_order or self.default_sort_order if sort_column: try: column = self.columns[sort_column] except KeyError: raise UnprocessableEntity( f"Can't sort on column {sort_column}.", fields='sort_column', what=BAD_VALUE) order = desc if sort_order == DESC else asc query = query.order_by(order(column)) count = query.count() page_size = 25 if page_size is None else page_size page = page or 1 if page_size: query = query.limit(page_size).offset((page - 1) * page_size) return dict(total=count, page=page, page_size=page_size, last_page=max(1, ceil(count / page_size)) if page_size else 1, data=[to_obj(entity) for entity in query])
def process_stripe_events_route(start=Arg(str, required=False), source_id=Arg(str, required=False), type=Arg(str, required=False)): """ Used to make server fetch stripe events, used for testing since webhook is hard to use. """ return process_stripe_events(start, source_id, type)
def view_wrapper(*args, **kwargs): try: has_permission = (permission == PUBLIC or permission in g.permissions) if not has_permission: raise Forbidden( message= f"'{permission}' permission is required for this operation." ) Arg.fill_args(params, kwargs) data = f(*args, **kwargs) if flat_return: result = jsonify({**data, 'status': status}), code else: result = jsonify({ 'status': status, 'data': data }), code if commit and not commit_on_error: db_session.commit() except IntegrityError as e: if isinstance(e.orig, pymysql.err.IntegrityError): # This parsing of db errors is very sketchy, but there are tests for it so at least we know # if it stops working. errno, error = e.orig.args if errno == DUP_ENTRY: m = re.match(r".*?'([^']*)'.*?'([^']*)'.*", error) if m: value = m.group(1) index = m.group(2) try: fields = fields_by_index[index] raise UnprocessableEntity( f"Duplicate '{fields}', '{value}' already exists.", what=NOT_UNIQUE, fields=fields) except KeyError: logger.warning( f"index {index} is missing in index to fields mapping" ) raise UnprocessableEntity( f"Duplicate '{value}' not allowed.", what=NOT_UNIQUE) else: raise UnprocessableEntity(f"Duplicate entry.", what=NOT_UNIQUE) if errno == BAD_NULL_ERROR: m = re.match(r".*?'([^']*)'.*", error) if m: field = m.group(1) else: field = None raise UnprocessableEntity( f"'{field}' is required." if field else "Required field missing.", fields=field, what=REQUIRED) raise UnprocessableEntity( "Could not save entity using the sent data.", log=f"unrecoginized integrity error: {str(e)}") finally: if commit_on_error: db_session.commit() return result