async def activate(
zone_id: int,
zone_repo: ZoneRepo = Depends(ZoneRepo),
token: TokenPayload = ScopedTo("zone:update"),
):
zone = zone_repo.get(zone_id).update({"is_active": True}).data()
return ZoneResponse(zone=zone)
async def index(
dns_server: str,
sort_qs: SortQS = Depends(SortQS),
search: str = Query(None),
pagination: PaginationQS = Depends(PaginationQS),
zone_repo: ZoneRepo = Depends(ZoneRepo),
token: TokenPayload = Depends(ScopedTo("zone:list")),
includes: List[str] = Query(None),
):
includes = only(includes, ["zones"], values=True)
# Support ability to either submit dns_server.name or dns_server.id as dns_server_id
zone_dns_server_id_label = zone_repo.label("dns_server_id")
try:
dns_server = int(dns_server)
label = zone_dns_server_id_label
except ValueError:
label = zone_repo.label("dns_server.name")
pg, items = (zone_repo.search(search).loads(includes).filter_or(
label == dns_server, zone_dns_server_id_label.is_(None)).sort(
sort_qs).paginate(pagination).includes(includes).data())
return ZonesResponse(pagination=pg, zones=items)
async def update(
user_id: int,
form: UserEditForm,
user_repo: UserRepo = Depends(UserRepo()),
token: TokenPayload = Depends(
ScopedTo("user:update", "super", satisfy="one")),
):
email = getattr(form, "email", None)
if email:
for u in user_repo.new().all().results():
print("USER:"******"Invalid Email Address",
code=422,
field="email")
data = only(form, ["email", "is_active", "is_superuser"])
if getattr(form, "password", None):
data["hashed_password"] = hash_password(form.password)
item = user_repo.new().get_or_fail(user_id).update(data).data()
return UserResponse(user=item)
async def update(
zone_id: int,
form: ZoneCreateForm,
zone_repo: ZoneRepo = Depends(ZoneRepo()),
dns_server_repo: DnsServerRepo = Depends(DnsServerRepo()),
token: TokenPayload = Depends(ScopedTo("zone:update")),
includes: List[str] = Query(None),
):
data = only(dict(form), ["ip", "domain"])
if "domain" in data:
data["domain"] = data["domain"].lower()
existing_domain = zone_repo.first(domain=data["domain"]).results()
if existing_domain and existing_domain.id != zone_id:
abort_for_input("domain", "A Zone with that domain already exists")
zone_repo.clear()
if form.dns_server_id is not None:
if form.dns_server_id is 0:
data["dns_server_id"] = None
elif dns_server_repo.exists(id=form.dns_server_id):
dns_server = dns_server_repo.results()
data["dns_server"] = dns_server
zone = (zone_repo.loads(includes).get_or_fail(zone_id).update(
data).includes(includes).data())
return ZoneResponse(zone=zone)
async def destroy(
user_id: int,
user_repo: UserRepo = Depends(UserRepo()),
token: TokenPayload = Depends(
ScopedTo("user:create", "super", satisfy="one")),
user: User = Depends(current_user),
):
if user_id == user.id:
abort(403, msg="Cannot deactivate self")
remaining_supers = len(
user_repo.filter(
user_repo.label("is_superuser") == True,
user_repo.label("is_active") == True,
user_repo.label("id") != user_id,
).all().results())
if remaining_supers < 1:
abort(
403,
msg="Cannot deactivate user. No other active super users available."
)
user_repo.clear()
messages = [{"text": "Deactivation Succesful", "type": "success"}]
if not user_repo.exists(id=user_id):
return BaseResponse(messages=messages)
user_repo.deactivate(user_id)
return BaseResponse(messages=messages)
async def store(
form: DnsRequestCreateForm,
dns_request_repo: DnsRequestRepo = Depends(DnsRequestRepo()),
zone_repo: ZoneRepo = Depends(ZoneRepo()),
dns_server_repo: DnsServerRepo = Depends(DnsServerRepo()),
token: str = Depends(ScopedTo("dns-request:create")),
):
dns_server_id = (dns_server_repo.first_or_fail(
name=form.dns_server_name.lower()).results().id)
zone = (zone_repo.filter(
literal(form.name.lower()).contains(
zone_repo.label("domain"))).first().results())
zone_id = zone.id if zone else None
data = only(dict(form),
["name", "source_address", "source_port", "type", "protocol"])
data["name"] = data["name"].lower()
data["type"] = data["type"].upper()
data["dns_server_id"] = dns_server_id
data["zone_id"] = zone_id
dns_request = dns_request_repo.create(data).data()
return DnsRequestResponse(dns_request=dns_request)
async def show(
user_repo: UserRepo = Depends(UserRepo),
token: TokenPayload = ScopedTo("profile"),
user: User = Depends(current_user),
):
item = user_repo.set_results(user).data()
return UserResponse(user=item)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
zone_repo: ZoneRepo = Depends(ZoneRepo),
token: TokenPayload = ScopedTo("zone:list"),
):
pg, items = zone_repo.sort(sort_qs).paginate(pagination).data()
return ZonesResponse(pagination=pg, zones=items)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo),
token: TokenPayload = ScopedTo("api-token:list"),
):
pg, items = api_token_repo.sort(sort_qs).paginate(pagination).data()
return ApiTokensResponse(pagination=pg, api_tokens=items)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
dns_request_repo: DnsRequestRepo = Depends(DnsRequestRepo),
token: TokenPayload = ScopedTo("dns-request:list"),
):
pg, items = dns_request_repo.sort(sort_qs).paginate(pagination).data()
return DnsRequestsResponse(pagination=pg, dns_requests=items)
async def activate(
user_id: int,
user_repo: UserRepo = Depends(UserRepo()),
token: TokenPayload = Depends(ScopedTo("user:create", "super")),
):
user = user_repo.get_or_fail(user_id).update({"is_active": True}).data()
return UserResponse(user=user)
async def login(token: TokenPayload = ScopedTo("refresh"),
user: User = Depends(current_user)):
token = create_bearer_token(data={
"sub": token.sub,
"scopes": " ".join(token.scopes)
})
return PasswordAuthResponse(token_type="bearer",
access_token=str(token.decode()))
async def store(
form: ZoneCreateForm,
zone_repo: ZoneRepo = Depends(ZoneRepo),
token: TokenPayload = ScopedTo("zone:create"),
):
zone = zone_repo.create(form).data()
return ZoneResponse(zone=zone)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
user_repo: UserRepo = Depends(UserRepo),
token: TokenPayload = Depends(ScopedTo("user:list")),
):
pg, items = user_repo.sort(sort_qs).paginate(pagination).data()
return UsersResponse(pagination=pg, users=items)
async def index(
pagination: PaginationQS = Depends(PaginationQS),
user_repo: UserRepo = Depends(UserRepo),
token: str = ScopedTo("user:list"),
):
pg, items = user_repo.paginate(pagination)
items = [UserData(id=i.id, email=i.email) for i in items]
return UsersResponse(pagination=pg, users=items)
async def show(
user_repo: UserRepo = Depends(UserRepo()),
token: TokenPayload = Depends(ScopedTo("profile")),
user: User = Depends(current_user),
):
logger.critical("Loading user")
item = user_repo.set_results(user).data()
return UserResponse(user=item)
async def destroy(
dns_record_id: int,
dns_record_repo: DnsRecordRepo = Depends(DnsRecordRepo()),
token: TokenPayload = Depends(ScopedTo("dns-record:destroy")),
):
dns_record_repo.first_or_fail(id=dns_record_id).delete()
messages = [{"text": "Delete Succesful", "type": "success"}]
return BaseResponse(messages=messages)
async def index(
api_token_id: int,
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo),
token: TokenPayload = ScopedTo("api-token:read"),
):
if not api_token_repo.exists(api_token_id):
raise HTTPException(404, detail="Not found")
api_token = api_token_repo.data()
return ApiTokenResponse(api_token=api_token)
async def index(
api_token_id: int,
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo),
token: TokenPayload = ScopedTo("api-token:read"),
):
# TODO: require stronger scope
if not api_token_repo.exists(api_token_id):
raise HTTPException(404, detail="Not found")
api_token = api_token_repo.set_data_model(SensitiveApiTokenData).data()
return SensitiveApiTokenResponse(api_token=api_token)
async def destroy(
api_token_id: int,
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo()),
token: TokenPayload = Depends(ScopedTo("api-token:destroy")),
):
messages = [{"text": "Deactivation Succesful", "type": "success"}]
if not api_token_repo.exists(api_token_id):
return BaseResponse(messages=messages)
api_token_repo.deactivate(api_token_id)
return BaseResponse(messages=messages)
async def destroy(
zone_id: int,
zone_repo: ZoneRepo = Depends(ZoneRepo),
token: TokenPayload = ScopedTo("zone:destroy"),
):
messages = [{"text": "Deactivation Succesful", "type": "success"}]
if not zone_repo.exists(zone_id):
return BaseResponse(messages=messages)
zone_repo.deactivate(zone_id)
return BaseResponse(messages=messages)
async def show(
zone_id: int,
zone_repo: ZoneRepo = Depends(ZoneRepo()),
token: TokenPayload = Depends(ScopedTo("zone:show")),
includes: List[str] = Query(None),
):
includes = only(includes, ["dns_server", "dns_records"], values=True)
zone = zone_repo.loads(includes).get_or_fail(zone_id).includes(
includes).data()
return ZoneResponse(zone=zone)
async def show(
api_token_id: int,
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo()),
token: TokenPayload = Depends(ScopedTo("api-token:read")),
includes: List[str] = Query(None),
):
if (not api_token_repo.loads("dns_server").strict().includes(
includes).exists(api_token_id)):
raise HTTPException(404, detail="Not found")
api_token = api_token_repo.data()
return ApiTokenResponse(api_token=api_token)
async def show(
user_id: int,
user_repo: UserRepo = Depends(UserRepo()),
token: TokenPayload = Depends(ScopedTo("user:show", "super")),
includes: List[str] = Query(None),
):
includes = only(includes, [], values=True)
item = user_repo.loads(includes).get_or_fail(user_id).includes(
includes).data()
return UserResponse(user=item)
async def store(
form: DnsServerCreateForm,
dns_server_repo: DnsServerRepo = Depends(DnsServerRepo),
token: TokenPayload = Depends(ScopedTo("dns-server:create")),
):
if dns_server_repo.exists(name=form.name.lower()):
abort(422, "Invalid Name")
data = only(dict(form), ["name"])
data["name"] = data["name"].lower()
item = dns_server_repo.create(data).data()
return DnsServerResponse(dns_server=item)
async def show(
dns_record_id: int,
dns_record_repo: DnsRecordRepo = Depends(DnsRecordRepo()),
token: TokenPayload = Depends(ScopedTo("dns-record:show")),
includes: List[str] = Query(None),
):
includes = only(includes, ["zone"], values=True)
item = (dns_record_repo.loads("zone").first_or_fail(
id=dns_record_id).includes(includes).data())
return DnsRecordResponse(dns_record=item)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
zone_repo: ZoneRepo = Depends(ZoneRepo()),
token: TokenPayload = Depends(ScopedTo("zone:list")),
includes: List[str] = Query(None),
):
includes = only(includes, ["dns_server", "dns_records"], values=True)
pg, items = (zone_repo.loads(includes).strict().sort(sort_qs).paginate(
pagination).includes(includes).data())
return ZonesResponse(pagination=pg, zones=items)
async def sensitive(
api_token_id: int,
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo()),
token: TokenPayload = Depends(ScopedTo("api-token:read")),
includes: List[str] = Query(None),
):
# TODO: require stronger scope
if not api_token_repo.exists(api_token_id):
raise HTTPException(404, detail="Not found")
api_token = (api_token_repo.loads("dns_server").set_data_model(
SensitiveApiTokenData).includes(includes).data())
return SensitiveApiTokenResponse(api_token=api_token)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
api_token_repo: ApiTokenRepo = Depends(ApiTokenRepo()),
token: TokenPayload = Depends(ScopedTo("api-token:list")),
includes: List[str] = Query(None),
):
includes = only(includes, ["dns_server"], values=True)
pg, items = (api_token_repo.loads("dns_server").strict().sort(
sort_qs).paginate(pagination).includes(includes).data())
return ApiTokensResponse(pagination=pg, api_tokens=items)
async def index(
sort_qs: SortQS = Depends(SortQS),
pagination: PaginationQS = Depends(PaginationQS),
dns_record_repo: DnsRecordRepo = Depends(DnsRecordRepo()),
token: TokenPayload = Depends(ScopedTo("dns-record:list")),
includes: List[str] = Query(None),
):
includes = only(includes, ["zone"], values=True)
pg, items = (dns_record_repo.loads("zone").sort(sort_qs).paginate(
pagination).includes(includes).data())
return DnsRecordsResponse(pagination=pg, dns_records=items)
