def test_dict_field_serialize(self, user):
user.various_data = {"foo": "bar"}
field = fields.Dict()
assert field.serialize("various_data", user) == {"foo": "bar"}
class Result(Schema):
created_at = fields.DateTime()
clusters = fields.Dict(values=fields.Nested(Item()), keys=fields.Int())
class FactsSchema(Schema):
namespace = fields.Str()
facts = fields.Dict()
class DatabaseParametersSchemaMixin: # pylint: disable=too-few-public-methods
"""
Allow SQLAlchemy URI to be passed as separate parameters.
This mixin is a first step in allowing the users to test, create and
edit databases without having to know how to write a SQLAlchemy URI.
Instead, each database defines the parameters that it takes (eg,
username, password, host, etc.) and the SQLAlchemy URI is built from
these parameters.
When using this mixin make sure that `sqlalchemy_uri` is not required.
"""
engine = fields.String(allow_none=True, description="SQLAlchemy engine to use")
parameters = fields.Dict(
keys=fields.String(),
values=fields.Raw(),
description="DB-specific parameters for configuration",
)
configuration_method = EnumField(
ConfigurationMethod,
by_value=True,
description=configuration_method_description,
missing=ConfigurationMethod.SQLALCHEMY_FORM,
)
# pylint: disable=no-self-use, unused-argument
@pre_load
def build_sqlalchemy_uri(
self, data: Dict[str, Any], **kwargs: Any
) -> Dict[str, Any]:
"""
Build SQLAlchemy URI from separate parameters.
This is used for databases that support being configured by individual
parameters (eg, username, password, host, etc.), instead of requiring
the constructed SQLAlchemy URI to be passed.
"""
parameters = data.pop("parameters", {})
# TODO(AAfghahi) standardize engine.
engine = (
data.pop("engine", None)
or parameters.pop("engine", None)
or data.pop("backend", None)
)
configuration_method = data.get("configuration_method")
if configuration_method == ConfigurationMethod.DYNAMIC_FORM:
engine_spec = get_engine_spec(engine)
if not hasattr(engine_spec, "build_sqlalchemy_uri") or not hasattr(
engine_spec, "parameters_schema"
):
raise ValidationError(
[
_(
'Engine spec "InvalidEngine" does not support '
"being configured via individual parameters."
)
]
)
# validate parameters
parameters = engine_spec.parameters_schema.load(parameters) # type: ignore
serialized_encrypted_extra = data.get("encrypted_extra") or "{}"
try:
encrypted_extra = json.loads(serialized_encrypted_extra)
except json.decoder.JSONDecodeError:
encrypted_extra = {}
data["sqlalchemy_uri"] = engine_spec.build_sqlalchemy_uri( # type: ignore
parameters, encrypted_extra
)
return data
class DisplacementEnergiesTrainingSetSchema(BaseSchema):
type = fields.String(required=True,
validate=validate.Equal('displacement_energies'))
data = fields.Dict(required=True)
class ActionResultBase(Linkable):
resultType = fields.String(required=True, example='object')
result = fields.Dict()
class RequestedAttribute(Schema):
"""RequestedAttribute model."""
name = fields.Str(required=True)
restrictions = fields.List(fields.Dict(), required=False)
class ImportV1DatabaseExtraSchema(Schema):
metadata_params = fields.Dict(keys=fields.Str(), values=fields.Raw())
engine_params = fields.Dict(keys=fields.Str(), values=fields.Raw())
metadata_cache_timeout = fields.Dict(keys=fields.Str(), values=fields.Integer())
schemas_allowed_for_csv_upload = fields.List(fields.String())
cost_estimate_enabled = fields.Boolean()
class ClusterDeploymentListResource(Resource):
@user_required
@use_kwargs({
"namespace": fields.String(),
"limit": fields.Integer()
}, locations=("querystring", ))
def get(self, cluster_id, **kwargs):
"""获取组织集群的无状态应用
---
tags:
- 集群
parameters:
- name: namespace
in: querystring
type: string
required: false
- name: limit
in: querystring
type: int
required: false
responses:
200:
examples:
response: {"data": [{
"create_time": "",
"name": "test-deployment",
"namespace": "test-namespace",
"replicas": 2,
"labels": "test-labels"
}], "message": "ok"}
"""
namespace = kwargs.get("namespace")
try:
k8s = get_k8s(cluster_id)
except Exception as e:
return json_response(message=str(e), status=404)
if namespace:
k8s_deployment_list = k8s.v1beta_app.list_namespaced_deployment(**kwargs)
else:
k8s_deployment_list = k8s.v1beta_app.list_deployment_for_all_namespaces(**kwargs)
data = list()
for item in k8s_deployment_list.items:
metadata = item.metadata
data.append({
"create_time": metadata.creation_timestamp,
"name": metadata.name,
"namespace": metadata.namespace,
"replicas": item.spec.replicas,
"labels": item.metadata.labels
})
return json_response(data=data, message="ClusterDeploymentResource")
@user_required
@use_kwargs({
"name": fields.String(required=True),
"namespace": fields.String(required=True),
"image": fields.String(required=True),
"image_tag": fields.String(required=True),
"replicas": fields.Integer(required=True),
"ports": fields.List(cls_or_instance=fields.Dict()),
"env": fields.List(cls_or_instance=fields.Dict()),
}, localtion=("json", ))
def post(self, cluster_id, **kwargs):
"""创建集群无状态应用
---
tags:
- 集群
parameters:
- name: name
in: json
type: string
required: true
- name: namespace
in: json
type: string
required: true
- name: image
in: json
type: string
required: true
- name: image_tag
in: json
type: string
required: true
- name: replicas
in: json
type: int
required: true
- name: ports
in: json
type: array
required: false
examples: [{"port":5000, "protocol": "TCP"}, {"port":8080, "protocol": "UDP"}]
- name: env
in: json
type: array
required: false
examples: [{"key":PYTHON_ENV, "value": "production"}]
responses:
200:
examples:
response: {"data": [{
"create_time": "",
"name": "test-deployment",
"namespace": "test-namespace",
"replicas": 2,
"labels": "test-labels"
}], "message": "ok"}
"""
kwargs["ports"] = valid_deployment_ports(kwargs.get("ports", list()))
kwargs["env"] = valid_env(kwargs.get("env", list()))
try:
k8s = get_k8s(cluster_id)
except Exception as e:
return json_response(message=str(e), status=404)
create_result = k8s.create_deployment(**kwargs)
status = 200 if create_result["success"] is True else 500
message = create_result["message"] + " - " + str(create_result.get("error", ""))
return json_response(message=message, status=status)
class SlrData(Schema):
slr = fields.Dict(required=True)
@routes.post(r"/v1/groups/{group_id:\d+}/accounts")
@docs(
tags=["accounts"],
summary="create a new group account",
description="",
responses={200: {"schema": AccountSchema(), "description": ""}},
)
@json_schema(
Schema.from_dict(
{
"name": fields.Str(),
"description": fields.Str(),
"type": fields.Str(),
"clearing_shares": fields.Dict(
fields.Int(), fields.Number(), allow_none=True, load_default=None
),
},
name="CreateAccountSchema",
)
)
async def create_account(request: web.Request):
data = request["json"]
account_id = await request.app["account_service"].create_account(
user_id=request["user"]["user_id"],
group_id=int(request.match_info["group_id"]),
name=data["name"],
description=data["description"],
type=data["type"],
clearing_shares=data["clearing_shares"],
)
def test_structured_dict_key_value_serialize(self, user):
user.various_data = {1: decimal.Decimal("1")}
field = fields.Dict(keys=fields.Str, values=fields.Decimal)
assert field.serialize("various_data", user) == {"1": 1}
def test_structured_dict_key_serialize(self, user):
user.various_data = {1: "bar"}
field = fields.Dict(keys=fields.Str)
assert field.serialize("various_data", user) == {"1": "bar"}
def test_dict_field_serialize_ordereddict(self, user):
user.various_data = OrderedDict([("foo", "bar"), ("bar", "baz")])
field = fields.Dict()
assert field.serialize("various_data", user) == OrderedDict(
[("foo", "bar"), ("bar", "baz")]
)
class ClassificationState(Schema):
"""Define schema for status of configured conditions."""
blocking_conditions = fields.Dict()
informative_conditions = fields.Dict()
class ClusterServiceListResource(Resource):
@user_required
@use_kwargs({
"namespace": fields.String(),
"limit": fields.Integer()
})
def get(self, cluster_id, **kwargs):
"""获取集群service服务列表
---
tags:
- 集群
parameters:
- name: namespace
in: url
type: string
required: false
- name: limit
in: querystring
type: int
required: false
responses:
200:
examples:
response: {"data": [], "message": "ok"}
"""
namespace = kwargs.get("namespace")
try:
k8s = get_k8s(cluster_id)
except Exception as e:
return json_response(message=str(e), status=404)
if namespace:
k8s_service_list = k8s.v1core_app.list_namespaced_service(**kwargs)
else:
k8s_service_list = k8s.v1core_app.list_service_for_all_namespaces(**kwargs)
data = list()
for item in k8s_service_list.items:
try:
metadata = item.metadata
data.append({
"create_time": metadata.creation_timestamp,
"name": metadata.name,
"namespace": metadata.namespace,
"labels": item.metadata.labels,
"type": item.spec.type,
"selector": item.spec.selector,
"ports": [port.__dict__ for port in item.spec.ports]
})
except Exception as e:
_ = e
return json_response(data=data)
@user_required
@use_kwargs({
"name": fields.String(required=True),
"namespace": fields.String(required=True),
"deployment_name": fields.String(required=True),
"ports": fields.List(cls_or_instance=fields.Dict())
}, locations=("json", ))
def post(self, cluster_id, **kwargs):
"""新建集群service服务
---
tags:
- 集群
parameters:
- name: name
in: json
type: string
required: true
- name: namespace
in: json
type: string
required: true
- name: deployment_name
in: json
type: string
required: true
- name: ports
in: json
type: string
required: false
examples:
response: [{"port":80, "targetPort": 80, "protocol": "TCP"}]
responses:
200:
description: A list of colors (may be filtered by palette)
examples:
response: {"data": null, "message": "修改成功"}
"""
kwargs["ports"] = valid_service_ports(kwargs.get("ports"))
try:
k8s = get_k8s(cluster_id)
except Exception as e:
return json_response(message=str(e), status=404)
create_result = k8s.create_service(**kwargs)
status = 200 if create_result["success"] is True else 500
message = create_result["message"] + " - " + str(create_result.get("error", ""))
return json_response(message=message, status=status)
class ClassificationStateV2(Schema):
"""Define schema for status of configured conditions for API (version 2.0)."""
blocking_conditions = fields.List(fields.Dict())
informative_conditions = fields.List(fields.Dict())
class IssuerRevRegRecordSchema(BaseRecordSchema):
"""Schema to allow serialization/deserialization of revocation registry records."""
class Meta:
"""IssuerRevRegRecordSchema metadata."""
model_class = IssuerRevRegRecord
record_id = fields.Str(
required=False,
description="Issuer revocation registry record identifier",
example=UUIDFour.EXAMPLE,
)
cred_def_id = fields.Str(
required=False,
description="Credential definition identifier",
**INDY_CRED_DEF_ID,
)
error_msg = fields.Str(
required=False,
description="Error message",
example="Revocation registry undefined",
)
issuance_type = fields.Str(
required=False,
description="Issuance type (ISSUANCE_BY_DEFAULT or ISSUANCE_ON_DEMAND)",
example=IssuerRevRegRecord.ISSUANCE_BY_DEFAULT,
validate=validate.OneOf(
[
IssuerRevRegRecord.ISSUANCE_BY_DEFAULT,
IssuerRevRegRecord.ISSUANCE_ON_DEMAND,
]
),
)
issuer_did = fields.Str(required=False, description="Issuer DID", **INDY_DID)
max_cred_num = fields.Int(
required=False,
description="Maximum number of credentials for revocation registry",
example=1000,
)
revoc_def_type = fields.Str(
required=False,
description="Revocation registry type (specify CL_ACCUM)",
example="CL_ACCUM",
validate=validate.Equal("CL_ACCUM"),
)
revoc_reg_id = fields.Str(
required=False, description="Revocation registry identifier", **INDY_REV_REG_ID
)
revoc_reg_def = fields.Dict(
required=False, description="Revocation registry definition"
)
revoc_reg_entry = fields.Dict(
required=False, description="Revocation registry entry"
)
tag = fields.Str(
required=False, description="Tag within issuer revocation registry identifier"
)
tails_hash = fields.Str(
required=False, description="Tails hash", **BASE58_SHA256_HASH
)
tails_public_uri = fields.Str(
required=False, description="Public URI for tails file"
)
tails_local_path = fields.Str(
required=False, description="Local path to tails file"
)
pending_pub = fields.List(
fields.Str(example="23"),
description=(
"Credential revocation identifier for credential "
"revoked and pending publication to ledger"
),
required=False,
)
class ActionResultObject(ActionResultBase):
resultType = fields.Constant('object')
value = fields.Dict(required=True,
allow_none=True,
example={'foo': 'bar'},
description="The return value of this action.")
'their_role':
fields.Str(required=False)
})
StaticConnectionList, StaticConnectionListSchema = generate_model_schema(
name='StaticConnectionList',
handler='acapy_plugin_toolbox.util.PassHandler',
msg_type=STATIC_CONNECTION_LIST,
schema={
'results':
fields.List(
fields.Dict(connection_id=fields.Str(),
their_info=fields.Dict(label=fields.Str(),
did=fields.Str(),
vk=fields.Str(),
endpoint=fields.Str()),
my_info=fields.Dict(label=fields.Str(),
did=fields.Str(),
vk=fields.Str(),
endpoint=fields.Str())))
})
class StaticConnectionGetListHandler(BaseHandler):
"""Handler for static connection get list requests."""
@admin_only
async def handle(self, context: RequestContext, responder: BaseResponder):
"""Handle static connection get list request."""
connection_mgr = ConnectionManager(context)
wallet: BaseWallet = await context.inject(BaseWallet)
try:
class SendPresentationRequestSchema(Schema):
"""Request schema for sending a presentation."""
self_attested_attributes = fields.Dict(required=True)
requested_attributes = fields.Dict(required=True)
requested_predicates = fields.Dict(required=True)
class PreferenceSchema(Schema):
preferences = fields.Dict()
class DatabaseRelatedDashboard(Schema):
id = fields.Integer()
json_metadata = fields.Dict()
slug = fields.String()
title = fields.String()
class V20CredExRecordSchema(BaseExchangeSchema):
"""Schema to allow serialization/deserialization of credential exchange records."""
class Meta:
"""V20CredExSchema metadata."""
model_class = V20CredExRecord
cred_ex_id = fields.Str(
required=False,
description="Credential exchange identifier",
example=UUIDFour.EXAMPLE,
)
connection_id = fields.Str(required=False,
description="Connection identifier",
example=UUIDFour.EXAMPLE)
thread_id = fields.Str(required=False,
description="Thread identifier",
example=UUIDFour.EXAMPLE)
parent_thread_id = fields.Str(required=False,
description="Parent thread identifier",
example=UUIDFour.EXAMPLE)
initiator = fields.Str(
required=False,
description="Issue-credential exchange initiator: self or external",
example=V20CredExRecord.INITIATOR_SELF,
validate=validate.OneOf([
getattr(V20CredExRecord, m) for m in vars(V20CredExRecord)
if m.startswith("INITIATOR_")
]),
)
role = fields.Str(
required=False,
description="Issue-credential exchange role: holder or issuer",
example=V20CredExRecord.ROLE_ISSUER,
validate=validate.OneOf([
getattr(V20CredExRecord, m) for m in vars(V20CredExRecord)
if m.startswith("ROLE_")
]),
)
state = fields.Str(
required=False,
description="Issue-credential exchange state",
example=V20CredExRecord.STATE_DONE,
validate=validate.OneOf([
getattr(V20CredExRecord, m) for m in vars(V20CredExRecord)
if m.startswith("STATE_")
]),
)
cred_preview = fields.Nested(
V20CredPreviewSchema(),
required=False,
dump_only=True,
description="Credential preview from credential proposal",
)
cred_proposal = fields.Nested(
V20CredProposalSchema(),
required=False,
description="Credential proposal message",
)
cred_offer = fields.Nested(
V20CredOfferSchema(),
required=False,
description="Credential offer message",
)
cred_request = fields.Nested(
V20CredRequestSchema(),
required=False,
description="Serialized credential request message",
)
cred_issue = fields.Nested(
V20CredIssueSchema(),
required=False,
description="Serialized credential issue message",
)
by_format = fields.Nested(
Schema.from_dict(
{
"cred_proposal": fields.Dict(required=False),
"cred_offer": fields.Dict(required=False),
"cred_request": fields.Dict(required=False),
"cred_issue": fields.Dict(required=False),
},
name="V20CredExRecordByFormatSchema",
),
required=False,
description=
("Attachment content by format for proposal, offer, request, and issue"
),
dump_only=True,
)
auto_offer = fields.Bool(
required=False,
description="Holder choice to accept offer in this credential exchange",
example=False,
)
auto_issue = fields.Bool(
required=False,
description=
"Issuer choice to issue to request in this credential exchange",
example=False,
)
auto_remove = fields.Bool(
required=False,
default=True,
description=
("Issuer choice to remove this credential exchange record when complete"
),
example=False,
)
error_msg = fields.Str(
required=False,
description="Error message",
example="The front fell off",
)
class PointDefectsTrainingSetSchema(BaseSchema):
type = fields.String(required=True,
validate=validate.Equal('point_defects'))
data = fields.Dict(required=True)
class AliasesResponseSchema(Schema):
class AliasError(Schema):
detail = fields.Str(required=True)
data = fields.Dict(keys=fields.Str, values=fields.Nested(RecordSchema))
errors = fields.List(fields.Nested(AliasError))
class DiskDeviceSchema(Schema):
device = fields.Str(validate=validate.Length(max=2048))
label = fields.Str(validate=validate.Length(max=1024))
options = fields.Dict()
mount_point = fields.Str(validate=validate.Length(max=2048))
type = fields.Str(validate=validate.Length(max=256))
def test_dict_field_deserialization(self):
field = fields.Dict()
assert field.deserialize({"foo": "bar"}) == {"foo": "bar"}
with pytest.raises(ValidationError) as excinfo:
field.deserialize('baddict')
assert excinfo.value.args[0] == 'Not a valid mapping type.'
class RouteSchemaMixin(Schema):
link = fields.List(fields.String())
route = fields.Dict()
def test_dict_field_invalid_dict_but_okay(self, user):
user.various_data = "okaydict"
field = fields.Dict()
field.serialize("various_data", user)
assert field.serialize("various_data", user) == "okaydict"
