First stab at HTTP API endpoints

metagov/metagov/core/identity.py

@@ -61,7 +61,9 @@ def link_account(external_id, community, platform_type, platform_identifier, com
 
 def unlink_account(community, platform_type, platform_identifier, community_platform_id=None):
     """Unlinks a platform account from a metagov user. Uses community & platform information
-    which should be, together, unique to a metagovID."""
+    which should be, together, unique to a metagovID.
+
+    FIXME: return something else here - the metagov identity data object without the linked account??"""
 
     result = LinkedAccount.objects.filter(community=community, platform_type=platform_type,
         platform_identifier=platform_identifier)
@@ -77,11 +79,14 @@ def unlink_account(community, platform_type, platform_identifier, community_plat
 
 # Data Retrieval
 
+def strip_null_values_from_dict(dictionary):
+    return {key: val for key, val in dictionary.items() if val is not None}
+
 def get_filters(platform_type, community_platform_id, link_type, link_quality):
     """Helper function to filter by keys only when value is not None."""
     filters = {"platform_type": platform_type, "community_platform_id": community_platform_id,
         "link_type": link_type, "link_quality": link_quality}
-    return {key: val for key, val in filters.items() if val is not None}
+    return strip_null_values_from_dict(filters)
 
 def get_identity_data_object(metagovID):
     """Helper function, takes a MetagovID object instance and creates a json dictionary for its
@@ -163,4 +168,4 @@ def get_linked_account(external_id, platform_type, community_platform_id=None):
         if account.platform_type == platform_type:
             if not community_platform_id or account.community_platform_id == community_platform_id:
                 return account.serialize()
-    return None
+    return {}

metagov/metagov/core/tests.py

@@ -147,4 +147,4 @@ def test_get_linked_account(self):
         self.assertEquals(result["platform_type"], "OpenCollective")
         self.assertEquals(result["platform_identifier"], "tobin_heath")
         result = identity.get_linked_account(new_id.external_id, "Slack")
-        self.assertEquals(result, None)
+        self.assertEquals(result, {})

metagov/metagov/core/views.py

@@ -586,3 +586,118 @@ def get_plugin_instance(plugin_name, community):
     if not plugin:
         raise ValidationError(f"Plugin '{plugin_name}' not enabled for community '{community}'")
     return plugin
+
+
+# Identity Views
+from metagov.core import identity
+
+@api_view(["POST"])
+def create_id(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "community": Community.objects.get(slug=data["community_slug"]),
+            "count": data.get("count", None)
+        }
+        new_id = identity.create_id(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(new_id, status=status.HTTP_201_CREATED)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["POST"])
+def merge_ids(request):
+    data = JSONParser().parse(request)
+    try:
+        identity.merge_ids(data["primary_instance_id"], data["secondary_instance_id"])
+        return JsonResponse(status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["POST"])
+def link_account(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "external_id": data["external_id"],
+            "community": Community.objects.get(slug=data["community_slug"]),
+            "platform_type": data["platform_type"],
+            "platform_identifier": data["platform_identifier"],
+            "community_platform_id": data.get("community_platform_id", None),
+            "custom_data": data.get("custom_data", None),
+            "link_type": data.get("link_type", None),
+            "link_quality": data.get("link_quality", None),
+        }
+        account = identity.link_account(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(account.serialize(), status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["POST"])
+def unlink_account(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "community": Community.objects.get(slug=data["community_slug"]),
+            "platform_type": data["platform_type"],
+            "platform_identifier": data["platform_identifier"],
+            "community_platform_id": data.get("community_platform_id", None)
+        }
+        account_deleted = identity.link_account(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(account_deleted, status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["GET"])
+def get_user(request):
+    data = JSONParser().parse(request)
+    try:
+        return JsonResponse(identity.get_user(data["external_id"]), status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["GET"])
+def get_users(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "community": Community.objects.get(slug=data["community_slug"]),
+            "platform_type": data.get("platform_type", None),
+            "community_platform_id": data.get("community_platform_id", None),
+            "link_type": data.get("link_type", None),
+            "link_quality": data.get("link_quality", None),
+        }
+        user_data = identity.get_users(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(user_data, status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["GET"])
+def filter_users_by_account(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "external_id_list": data["external_id_list"],
+            "community": Community.objects.get(slug=data["community_slug"]),
+            "platform_type": data.get("platform_type", None),
+            "community_platform_id": data.get("community_platform_id", None),
+            "link_type": data.get("link_type", None),
+            "link_quality": data.get("link_quality", None),
+        }
+        user_data = identity.filter_users_by_account(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(user_data, status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)
+
+@api_view(["GET"])
+def get_linked_account(request):
+    data = JSONParser().parse(request)
+    try:
+        params = {
+            "external_id": data["external_id"],
+            "platform_type": data["platform_type"],
+            "community_platform_id": data.get("community_platform_id", None)
+        }
+        user_data = identity.get_linked_account(**identity.strip_null_values_from_dict(params))
+        return JsonResponse(user_data, status=status.HTTP_200_OK)
+    except Exception as error:
+        return JsonResponse(error, status=status.HTTP_400_BAD_REQUEST)