tools_groupmgt.py 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232
  1. """Definition des outils MCP (operations de gestion de groupes)."""
  2. from __future__ import annotations
  3. from typing import Annotated, Any
  4. from pydantic import Field
  5. from mcp.types import ToolAnnotations
  6. from ..services.client_rest import ClientRest, HTTPMethod
  7. _WRITE_ONLY = ToolAnnotations(readOnlyHint=False, destructiveHint=False)
  8. _WRITE_DESTRUCTIVE = ToolAnnotations(readOnlyHint=False, destructiveHint=True)
  9. _WRITE_IDEMPOTENT = ToolAnnotations(
  10. readOnlyHint=False, destructiveHint=True, idempotentHint=True
  11. )
  12. # --- createResourceGroup ---
  13. ResourceGroupName = Annotated[str, Field(description="name of the resource group")]
  14. AccessAdmin = Annotated[
  15. bool | None,
  16. Field(default=None, description="grant the Administrator user group access to the new resource group"),
  17. ]
  18. AccessAnon = Annotated[
  19. bool | None,
  20. Field(default=None, description="grant anonymous users view access to the new resource group"),
  21. ]
  22. AccessParallel = Annotated[
  23. bool | None,
  24. Field(default=None, description="create a parallel user group with the same name"),
  25. ]
  26. AccessContexts = Annotated[
  27. str | None,
  28. Field(default=None, description="comma-separated context keys for access policies"),
  29. ]
  30. AccessUserGroups = Annotated[
  31. str | None,
  32. Field(default=None, description="comma-separated user group names to grant access"),
  33. ]
  34. # --- updateResourceGroup / removeResourceGroup ---
  35. ResourceGroupId = Annotated[int | str, Field(description="resource group id or name")]
  36. ResourceIds = Annotated[
  37. list[int],
  38. Field(description="array of resource ids, e.g. [12, 45, 78]"),
  39. ]
  40. # --- createUserGroup ---
  41. UserGroupName = Annotated[str, Field(description="user group name to create")]
  42. UserGroupDescription = Annotated[str | None, Field(default=None, description="user group description")]
  43. Users = Annotated[
  44. str | None,
  45. Field(default=None, description="comma-separated list of username or username:role key pairs"),
  46. ]
  47. UserGroupParent = Annotated[int | None, Field(default=None, description="parent of the group")]
  48. CreateParallelResourceGroup = Annotated[
  49. str | None,
  50. Field(
  51. default=None,
  52. description="if set, create a parallel resource group with the same name for the user group",
  53. ),
  54. ]
  55. AddResourceGroups = Annotated[
  56. str | None,
  57. Field(default=None, description="comma-delimited list of resource group names to add to the user group"),
  58. ]
  59. # --- createAccess / updateAccess ---
  60. UserGroupId = Annotated[int | str, Field(description="user group id or name")]
  61. AccessPolicy = Annotated[
  62. int | str | None,
  63. Field(default=None, description="access policy id or name (default: Resource)"),
  64. ]
  65. Authority = Annotated[int | None, Field(default=None, description="authority level (minimum user role required)")]
  66. ContextKey = Annotated[str | None, Field(default=None, description="context key")]
  67. # --- updateAccess / removeAccess ---
  68. AccessId = Annotated[int, Field(description="ACL access entry id")]
  69. UserGroupIdRemove = Annotated[int, Field(description="user group id")]
  70. def _omit_none(**kwargs: Any) -> dict[str, Any]:
  71. return {key: value for key, value in kwargs.items() if value is not None}
  72. def register_groupmgt_tools(mcp_server: Any, client_rest: ClientRest) -> None:
  73. """Enregistre les outils de gestion de groupes du serveur MCP."""
  74. @mcp_server.tool(
  75. description="Creer un nouveau groupe de ressource.",
  76. annotations=_WRITE_ONLY,
  77. )
  78. def createResourceGroup(
  79. name: ResourceGroupName,
  80. accessAdmin: AccessAdmin = None,
  81. accessAnon: AccessAnon = None,
  82. accessParallel: AccessParallel = None,
  83. accessContexts: AccessContexts = None,
  84. accessUserGroups: AccessUserGroups = None,
  85. ) -> dict[str, Any]:
  86. return client_rest.execute(
  87. method=HTTPMethod.POST,
  88. endpoint="/rest/groupmgt/resources",
  89. json=_omit_none(
  90. name=name,
  91. accessAdmin=accessAdmin,
  92. accessAnon=accessAnon,
  93. accessParallel=accessParallel,
  94. accessContexts=accessContexts,
  95. accessUserGroups=accessUserGroups,
  96. ),
  97. )
  98. @mcp_server.tool(
  99. description="Ajouter des ressources MODX a un groupe de ressource existant.",
  100. annotations=_WRITE_IDEMPOTENT,
  101. )
  102. def updateResourceGroup(
  103. id: ResourceGroupId,
  104. resources: ResourceIds,
  105. ) -> dict[str, Any]:
  106. return client_rest.execute(
  107. method=HTTPMethod.PUT,
  108. endpoint="/rest/groupmgt/resources",
  109. json={"id": id, "resources": resources},
  110. )
  111. @mcp_server.tool(
  112. description="Retirer des ressources MODX d'un groupe de ressource.",
  113. annotations=_WRITE_DESTRUCTIVE,
  114. )
  115. def removeResourceGroup(
  116. id: ResourceGroupId,
  117. resources: ResourceIds,
  118. ) -> dict[str, Any]:
  119. return client_rest.execute(
  120. method=HTTPMethod.DELETE,
  121. endpoint=f"/rest/groupmgt/resources/{id}",
  122. params={
  123. "resources[]": resources
  124. }
  125. )
  126. @mcp_server.tool(
  127. description="Creer un nouveau groupe d'utilisateur.",
  128. annotations=_WRITE_ONLY,
  129. )
  130. def createUserGroup(
  131. name: UserGroupName,
  132. description: UserGroupDescription = None,
  133. users: Users = None,
  134. parent: UserGroupParent = None,
  135. createResourceGroup: CreateParallelResourceGroup = None,
  136. addResourceGroups: AddResourceGroups = None,
  137. ) -> dict[str, Any]:
  138. return client_rest.execute(
  139. method=HTTPMethod.POST,
  140. endpoint="/rest/groupmgt/group",
  141. json=_omit_none(
  142. name=name,
  143. description=description,
  144. users=users,
  145. parent=parent,
  146. createResourceGroup=createResourceGroup,
  147. addResourceGroups=addResourceGroups,
  148. ),
  149. )
  150. @mcp_server.tool(
  151. description="Creer un acces entre un groupe d'utilisateur et un groupe de ressource.",
  152. annotations=_WRITE_ONLY,
  153. )
  154. def createAccess(
  155. id: UserGroupId,
  156. resourceGroup: ResourceGroupId,
  157. policy: AccessPolicy = None,
  158. authority: Authority = None,
  159. context: ContextKey = None,
  160. ) -> dict[str, Any]:
  161. return client_rest.execute(
  162. method=HTTPMethod.POST,
  163. endpoint="/rest/groupmgt/access",
  164. json=_omit_none(
  165. id=id,
  166. resourceGroup=resourceGroup,
  167. policy=policy,
  168. authority=authority,
  169. context=context,
  170. ),
  171. )
  172. @mcp_server.tool(
  173. description="Mettre a jour un acces existant entre un groupe d'utilisateur et un groupe de ressource.",
  174. annotations=_WRITE_IDEMPOTENT,
  175. )
  176. def updateAccess(
  177. id: UserGroupId,
  178. accessId: AccessId,
  179. resourceGroup: ResourceGroupId | None = None,
  180. policy: AccessPolicy = None,
  181. authority: Authority = None,
  182. context: ContextKey = None,
  183. ) -> dict[str, Any]:
  184. return client_rest.execute(
  185. method=HTTPMethod.PUT,
  186. endpoint="/rest/groupmgt/access",
  187. json=_omit_none(
  188. id=id,
  189. accessId=accessId,
  190. resourceGroup=resourceGroup,
  191. policy=policy,
  192. authority=authority,
  193. context=context,
  194. ),
  195. )
  196. @mcp_server.tool(
  197. description="Supprimer un acces existant entre un groupe d'utilisateur et un groupe de ressource.",
  198. annotations=_WRITE_DESTRUCTIVE,
  199. )
  200. def removeAccess(
  201. id: UserGroupIdRemove,
  202. accessId: AccessId,
  203. ) -> dict[str, Any]:
  204. return client_rest.execute(
  205. method=HTTPMethod.DELETE,
  206. endpoint=f"/rest/groupmgt/access/{id}",
  207. params={
  208. "accessId": accessId
  209. }
  210. )