def get(self):
"""
Paginated access to users
"""
parser = reqparse.RequestParser()
parser.add_argument("me", type=bool, default=None)
parser.add_argument("signups", type=bool, default=None)
parser.add_argument("page", type=int, required=False, default=1)
parser.add_argument("per_page", type=int, required=False, default=10)
args = parser.parse_args()
# Let unauthenticated users see if they can register an account
if args.signups:
if "PERMIT_NEW_ACCOUNTS" in app.config:
return app.config["PERMIT_NEW_ACCOUNTS"]
return None
user = auth(session, required=True)
if args.me:
s = Session.query.filter(Session.session_id == session['session']).first()
response = user.jsonify()
response['session'] = s.jsonify()
return response
if not user.can("see_all"):
return {}, 403
query = User.query.order_by(desc(User.created)).paginate(args.page, args.per_page)
return make_response(request.url, query, revisions=True)
def get(self, username):
user = auth(session, required=True)
parser = reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
if user.username != username and not user.can("see_all"):
return {}, 403
if user.username != username:
user = User.query.filter(User.username == username).first()
if not user:
return {}, 404
query = Friend.query.filter(Friend.user == user)\
.order_by(desc(Friend.created)).paginate(args.page, args.per_page)
response = make_response(request.url, query)
# Check the remote side of each request
for i, friend_request in enumerate(response['data']):
address = friend_request['address']
network, node_id, uid = address.split('/')
router = app.routes.get(network, None)
if router != None:
message_body = {"add": {"from": user.uid, "to": address}}
remote_state = router.protocol.rpc_friend(message_body)
if remote_state[0]:
response['data'][i]['status'] = remote_state[0]['status']
return response
def get(self, query):
user = auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
revisions = [_ for _ in Revision.query.all() if query in _.url and \
(_.user == user or _.public)]
pages = Pagination(revisions, args.page, args.per_page)
response = make_response(request.url, pages)
return response
def get(self):
"""
A paginated resource for Domains
"""
auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, required=False, default=1)
parser.add_argument("per_page", type=int, required=False, default=10)
args = parser.parse_args()
query = Domain.query.paginate(args.page, args.per_page)
return make_response(request.url, query)
def get(self):
user = auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
if user.can("see_all"):
query = Revision.query.order_by(desc(Revision.created)).paginate(args.page, args.per_page)
else:
query = Revision.query.filter(or_(Revision.public == True, Revision.user == user))\
.order_by(desc(Revision.created)).paginate(args.page, args.per_page)
return make_response(request.url, query)
def get(self, domain):
"""
"""
auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, help="", required=False, default=1)
parser.add_argument("per_page", type=int, help="", required=False, default=10)
args = parser.parse_args()
domain = Domain.query.filter(Domain.name == domain).first()
if not domain:
return {}, 404
pages = Pagination(domain.resources, args.page, args.per_page)
return make_response(request.url, pages)
def get(self):
"""
Implements /v1/privs
"""
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, required=False, default=1)
parser.add_argument("per_page", type=int, required=False, default=10)
args = parser.parse_args()
user = auth(session, required=True)
if not user.can("see_all"):
return {}, 403
query = Priv.query.order_by(desc(Priv.created)).paginate(args.page, args.per_page)
return make_response(request.url, query)
def get(self, network):
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
routes = app.routes.get(network, None)
if not routes:
return {}, 404
peers = [peer for peer in routes]
pages = Pagination(peers, args.page, args.per_page)
response = routes.jsonify()
response.update(make_response(request.url, pages))
return response
def get(self, username):
user = auth(session, required=True)
if user.username != username and not user.can("see_all"):
return {}, 403
parser = reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=20)
args = parser.parse_args()
user = User.query.filter(User.username == username).first()
if user == None:
return 404
query = Revision.query.filter(Revision.user == user)\
.order_by(desc(Revision.created)).paginate(args.page, args.per_page)
return make_response(request.url, query)
def get(self):
auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
parser.add_argument("network", type=str, default=None)
args = parser.parse_args()
if not args.network:
routes = app.routes._default
else:
routes = app.routes.get(args.network, None)
if not routes:
return {}, 404
peers = [peer for peer in routes]
pages = Pagination(peers, args.page, args.per_page)
return make_response(request.url, pages)
def get(self):
auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, required=False, default=1)
parser.add_argument("per_page", type=int, required=False, default=10)
args = parser.parse_args()
routes = app.routes.values()
pages = Pagination(routes, args.page, args.per_page)
response = make_response(request.url, pages)
# Calculate the number of unique nodes we know of
peers = []
for router in routes:
peers.extend([peer.threeple for peer in router])
peers = set(peers)
response['peers'] = len(peers)
return response
def get(self, network):
auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
routes = app.routes.get(network, None)
if not routes:
return {}, 404
peers = [peer for peer in routes]
pages = Pagination(peers, args.page, args.per_page)
pages.items = [p.jsonify(string_id=True) for p in pages.items]
# Would like to make the following more elegant.
# for i, j in enumerate(pages.items):
# pages.items[i]['node'] = (str(j['node'][0]), j['node'][1], j['node'][2])
return make_response(request.url, pages, jsonify=False)
def get(self):
"""
Return all DHT downloads across all networks.
"""
user = auth(session, required=True)
parser = restful.reqparse.RequestParser()
parser.add_argument("page", type=int, default=1)
parser.add_argument("per_page", type=int, default=10)
args = parser.parse_args()
if not user.can("see_all") and not user.can("review_downloads"):
return {}, 403
response = []
for routes in app.routes.values():
r = {'network': routes.network}
r['downloads'] = [{f: routes.protocol.downloads[f]} for \
f in routes.protocol.downloads]
response.append(r)
pages = Pagination(response, args.page, args.per_page)
return make_response(request.url, pages, jsonify=False)
