graph_access_security_hub

1
import uuid
2

3
from faststream.rabbit import RabbitBroker
4

5
from src.api.amqp import api_router
6
from src.config.amqp import AMQP_CONFIG, GASH_EXCHANGE
7
from src.api.amqp.v1.queues import (
8
    ScopeQueuesV1,
9
    ResourceQueuesV1,
10
    UserQueuesV1,
11
    PermitQueuesV1,
12
)
13
AMQP_CONFIG.host = 'localhost'
14
broker = RabbitBroker(AMQP_CONFIG.connection_url())
15
broker.include_routers(api_router)
16

17

18
async def main():
19
    async with broker:
20
        owner_data = {
21
            "id_": str(uuid.uuid4()),
22
            "role": "owner",
23
            "resources": [],
24
            "belong_scopes": [],
25
        }
26
        company_data = {
27
            "id_": str(uuid.uuid4()),
28
            "name": "company",
29
            "owner": {
30
                "id_": owner_data["id_"],
31
                "role": owner_data["role"],
32
            },
33
            "users": [],
34
            "scopes": [],
35
            "resources": [],
36
        }
37
        selling_point_data = {
38
            "id_": str(uuid.uuid4()),
39
            "name": "selling_point",
40
            "owner": {
41
                "id_": owner_data["id_"],
42
                "role": owner_data["role"],
43
            },
44
            "users": [],
45
            "scopes": [],
46
            "resources": [],
47
        }
48
        company_update_data = {
49
            "id_": company_data["id_"],
50
            "old_name": "company",
51
            "new_scopes": [
52
                {
53
                    "id_": selling_point_data["id_"],
54
                    "name": selling_point_data["name"],
55
                }
56
            ]
57
        }
58
        company_resource_data = {
59
            "id_": str(uuid.uuid4()),
60
            "type": "company_resource",
61
            "users": [],
62
            "scopes": [
63
                {
64
                    "id_": company_data["id_"],
65
                    "name": "company",
66
                }
67
            ],   
68
        }
69
        employee_data = {
70
            "id_": str(uuid.uuid4()),
71
            "role": "empoyee",
72
            "resources": [],
73
            "belong_scopes": [
74
                {
75
                    "id_": company_data["id_"],
76
                    "name": company_data["name"],
77
                }
78
            ],
79
        }
80
        false_permit_request_data = {
81
            "subject": {
82
                "id_": employee_data["id_"],
83
                "role": employee_data["role"],
84
            },
85
            "object": {
86
                "id_": company_resource_data["id_"],
87
                "type": company_resource_data["type"],
88
            },
89
            "action": "read",
90
        }
91
        true_permit_request_data = {
92
            "subject": {
93
                "id_": owner_data["id_"],
94
                "role": owner_data["role"],
95
            },
96
            "object": {
97
                "id_": company_resource_data["id_"],
98
                "type": company_resource_data["type"],
99
            },
100
            "action": "read",
101
        }
102
        await broker.publish(
103
            message=owner_data,
104
            queue=UserQueuesV1.CREATE,
105
            exchange=GASH_EXCHANGE,
106
            rpc=True,
107
        )
108
        await broker.publish(
109
            message=company_data,
110
            queue=ScopeQueuesV1.CREATE,
111
            exchange=GASH_EXCHANGE,
112
            rpc=True,
113
        )
114
        await broker.publish(
115
            message=selling_point_data,
116
            queue=ScopeQueuesV1.CREATE,
117
            exchange=GASH_EXCHANGE,
118
            rpc=True,
119
        )
120
        await broker.publish(
121
            message=company_update_data,
122
            queue=ScopeQueuesV1.UPDATE,
123
            exchange=GASH_EXCHANGE,
124
            rpc=True,
125
        )
126
        await broker.publish(
127
            message=company_resource_data,
128
            queue=ResourceQueuesV1.CREATE,
129
            exchange=GASH_EXCHANGE,
130
            rpc=True,
131
        )
132
        await broker.publish(
133
            message=employee_data,
134
            queue=UserQueuesV1.CREATE,
135
            exchange=GASH_EXCHANGE,
136
            rpc=True,
137
        )
138
        permit_false = await broker.publish(
139
            message=false_permit_request_data,
140
            queue=PermitQueuesV1.GET,
141
            exchange=GASH_EXCHANGE,
142
            rpc=True,
143
        )
144
        print(f"{permit_false = }")
145
        permit_true = await broker.publish(
146
            message=true_permit_request_data,
147
            queue=PermitQueuesV1.GET,
148
            exchange=GASH_EXCHANGE,
149
            rpc=True,
150
        )
151
        print(f"{permit_true = }")
152

153

154
if __name__ == "__main__":
155
    import asyncio
156
    asyncio.run(main())