Coverage for api/roles/schema.py: 100.00%

1from pydantic import BaseModel, Field 

2from typing import Optional, Dict, List 

3 

4class RoleResponse(BaseModel): 

5 id: str = Field(..., description="Role ID") 

6 name: str = Field(..., description="Role name") 

7 description: Optional[str] = Field(None, description="Role description") 

8 

9class RolesListResponse(BaseModel): 

10 roles: List[RoleResponse] = Field(..., description="List of roles") 

11 

12class RoleCreate(BaseModel): 

13 name: str = Field(..., min_length=1, max_length=100, description="Role name") 

14 description: Optional[str] = Field(None, max_length=500, description="Role description") 

15 

16class RoleUpdate(BaseModel): 

17 name: Optional[str] = Field(None, min_length=1, max_length=100, description="Role name") 

18 description: Optional[str] = Field(None, max_length=500, description="Role description") 

19 

20class RoleAttributesMapping(BaseModel): 

21 attributes: Dict[str, bool] = Field( 

22 ..., 

23 description="Role attributes mapping (attribute_name: value)", 

24 example={ 

25 "view-users": True, 

26 "manage-users": False, 

27 "view-roles": True 

28 } 

29 ) 

30 

31 @classmethod 

32 def get_example_response(cls): 

33 return { 

34 "code": 200, 

35 "message": "Role attributes mapping example", 

36 "data": { 

37 "attributes": { 

38 "view-users": True, 

39 "manage-users": False, 

40 "view-roles": True 

41 } 

42 } 

43 } 

44 

45class RoleAttributeDetail(BaseModel): 

46 name: str = Field(..., description="Attribute name", example="view-users") 

47 value: bool = Field(..., description="Whether the role has this attribute", example=True) 

48 

49 

50class RoleAttributesGroup(BaseModel): 

51 group: str = Field(..., description="Top-level group key", example="user-role-management") 

52 categories: Dict[str, List[RoleAttributeDetail]] = Field(..., description="Categories inside this group (category -> attributes)") 

53 

54 

55class RoleAttributesGroupedResponse(BaseModel): 

56 groups: List[RoleAttributesGroup] = Field(..., description="Role attributes grouped by group and category") 

57 

58 @classmethod 

59 def get_example_response(cls): 

60 return { 

61 "code": 200, 

62 "message": "Successfully retrieved role attributes mapping", 

63 "data": { 

64 "groups": [ 

65 { 

66 "group": "user-role-management", 

67 "categories": { 

68 "user": [ 

69 { 

70 "name": "view-users", 

71 "value": True 

72 }, 

73 { 

74 "name": "manage-users", 

75 "value": False 

76 } 

77 ], 

78 "role": [ 

79 { 

80 "name": "view-roles", 

81 "value": True 

82 } 

83 ] 

84 } 

85 } 

86 ] 

87 } 

88 } 

89 

90class AttributeMappingResult(BaseModel): 

91 attribute_id: str = Field(..., description="Attribute ID") 

92 status: str = Field(..., description="Processing status: success, failed", pattern="^(success|failed)$") 

93 message: str = Field(..., description="Result message") 

94 

95class RoleAttributeMappingBatchResponse(BaseModel): 

96 results: List[AttributeMappingResult] = Field(..., description="Individual attribute mapping results") 

97 total_attributes: int = Field(..., description="Total number of attributes processed") 

98 success_count: int = Field(..., description="Number of successfully processed attributes") 

99 failed_count: int = Field(..., description="Number of failed attributes") 

100 

101class PermissionCheckRequest(BaseModel): 

102 attributes: Optional[List[str]] = Field( 

103 None, 

104 min_items=1, 

105 description="List of permission attributes to check. If not provided, returns all user permissions.", 

106 example=["view-users", "manage-roles"] 

107 ) 

108 

109class PermissionCheckResponse(BaseModel): 

110 permissions: Dict[str, bool] = Field( 

111 ..., 

112 description="Permission check results (attribute_name: has_permission)", 

113 example={ 

114 "view-users": True, 

115 "manage-users": False, 

116 "view-roles": True, 

117 "manage-roles": False 

118 } 

119 ) 

120 

121 @classmethod 

122 def get_example_response(cls): 

123 return { 

124 "code": 200, 

125 "message": "User permissions retrieved", 

126 "data": { 

127 "permissions": { 

128 "view-users": True, 

129 "manage-users": False, 

130 "view-roles": True, 

131 "manage-roles": False 

132 } 

133 } 

134 } 

135 

136role_attributes_success_response_example = { 

137 "code": 200, 

138 "message": "All role attributes processed successfully", 

139 "data": { 

140 "results": [ 

141 { 

142 "attribute_id": "attr-001", 

143 "status": "success", 

144 "message": "Updated successfully" 

145 }, 

146 { 

147 "attribute_id": "attr-002", 

148 "status": "success", 

149 "message": "Updated successfully" 

150 } 

151 ], 

152 "total_attributes": 2, 

153 "success_count": 2, 

154 "failed_count": 0 

155 } 

156} 

157 

158role_attributes_partial_response_example = { 

159 "code": 207, 

160 "message": "Role attributes processed with partial success", 

161 "data": { 

162 "results": [ 

163 { 

164 "attribute_id": "attr-001", 

165 "status": "success", 

166 "message": "Updated successfully" 

167 }, 

168 { 

169 "attribute_id": "attr-002", 

170 "status": "failed", 

171 "message": "Invalid attribute ID" 

172 } 

173 ], 

174 "total_attributes": 2, 

175 "success_count": 1, 

176 "failed_count": 1 

177 } 

178} 

179 

180role_attributes_failed_response_example = { 

181 "code": 400, 

182 "message": "All role attributes failed to process", 

183 "data": { 

184 "results": [ 

185 { 

186 "attribute_id": "invalid-attr-001", 

187 "status": "failed", 

188 "message": "Invalid attribute ID" 

189 }, 

190 { 

191 "attribute_id": "invalid-attr-002", 

192 "status": "failed", 

193 "message": "Invalid attribute ID" 

194 } 

195 ], 

196 "total_attributes": 2, 

197 "success_count": 0, 

198 "failed_count": 2 

199 } 

200}