Update Create Team to use entityName for create requests

ingestion/src/metadata/ingestion/source/database/sample_data.py

@@ -101,7 +101,6 @@
 from metadata.generated.schema.entity.services.pipelineService import PipelineService
 from metadata.generated.schema.entity.services.searchService import SearchService
 from metadata.generated.schema.entity.services.storageService import StorageService
-from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import User
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
@@ -681,26 +680,8 @@ def ingest_teams(self) -> Iterable[Either[CreateTeamRequest]]:
         """
         for team in self.teams["teams"]:
             team_to_ingest = CreateTeamRequest(
-                name=team["name"], teamType=team["teamType"]
-            )
-            if team["parent"] is not None:
-                parent_list_id = []
-                for parent in team["parent"]:
-                    tries = 3
-                    parent_object = self.metadata.get_by_name(entity=Team, fqn=parent)
-                    while not parent_object and tries > 0:
-                        logger.info(f"Trying to GET {parent} Parent Team")
-                        parent_object = self.metadata.get_by_name(
-                            entity=Team,
-                            fqn=parent,
-                        )
-                        tries -= 1
-
-                    if parent_object:
-                        parent_list_id.append(parent_object.id)
-
-                team_to_ingest.parents = parent_list_id
-
+                name=team["name"], teamType=team["teamType"], parents=team.get("parent")
+            )
             yield Either(right=team_to_ingest)
 
     def ingest_mysql(self) -> Iterable[Either[Entity]]:

ingestion/tests/integration/ometa/test_ometa_patch.py

@@ -184,12 +184,18 @@ def setUpClass(cls) -> None:
 
         cls.team_1 = cls.metadata.create_or_update(
             data=get_create_team_entity(
-                name="Team 1", users=[cls.user_1.id, cls.user_2.id]
+                name="Team 1",
+                users=[
+                    cls.user_1.fullyQualifiedName.root,
+                    cls.user_2.fullyQualifiedName.root,
+                ],
             )
         )
 
         cls.team_2 = cls.metadata.create_or_update(
-            data=get_create_team_entity(name="Team 2", users=[cls.user_2.id])
+            data=get_create_team_entity(
+                name="Team 2", users=[cls.user_2.fullyQualifiedName.root]
+            )
         )
 
         cls.owner_user_1 = EntityReferenceList(

ingestion/tests/integration/ometa/test_ometa_role_policy_api.py

@@ -645,8 +645,8 @@ def test_role_add_team(self):
             data=CreateTeamRequest(
                 name="test-role-team-1",
                 teamType="Group",
-                users=[user.id],
-                defaultRoles=[role.id],
+                users=[user.fullyQualifiedName.root],
+                defaultRoles=[role.fullyQualifiedName.root],
             )
         )
 

openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/searchIndex/SearchIndexApp.java

@@ -10,11 +10,17 @@
 import static org.openmetadata.service.workflows.searchIndex.ReindexingUtil.ENTITY_TYPE_KEY;
 import static org.openmetadata.service.workflows.searchIndex.ReindexingUtil.isDataInsightIndex;
 
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -84,6 +90,7 @@ public class SearchIndexApp extends AbstractNativeApplication {
   private final AtomicReference<Integer> batchSize = new AtomicReference<>(5);
   private JobExecutionContext jobExecutionContext;
   private volatile boolean stopped = false;
+  Queue<Map<String, Object>> entityRecords = new ConcurrentLinkedQueue<>();
 
   public SearchIndexApp(CollectionDAO collectionDAO, SearchRepository searchRepository) {
     super(collectionDAO, searchRepository);
@@ -226,6 +233,20 @@ private void performReindex(JobExecutionContext jobExecutionContext) throws Inte
     } finally {
       shutdownExecutor(jobExecutor, "JobExecutor", 20, TimeUnit.SECONDS);
       shutdownExecutor(producerExecutor, "ReaderExecutor", 1, TimeUnit.MINUTES);
+
+      for (Map<String, Object> rec : entityRecords) {
+        try (BufferedWriter writer =
+            new BufferedWriter(
+                new FileWriter(
+                    String.format(
+                        "/Users/mohityadav/IdeaProjects/OMTesting/sample_data/%s.json",
+                        rec.get(ENTITY_TYPE_KEY)),
+                    true))) {
+          writer.write(JsonUtils.pojoToJson(rec, true));
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
     }
   }
 
@@ -574,6 +595,20 @@ private void processReadTask(
       LOG.debug("Read Entities with entityType: {},  CurrentOffset: {}", entityType, offset);
       if (resultList != null) {
         ResultList<?> entities = extractEntities(entityType, resultList);
+        Map<String, Object> contextData = new HashMap<>();
+        List<Map<String, Object>> resultData = new ArrayList<>();
+        for (Object ob : entities.getData()) {
+          Map<String, Object> result = JsonUtils.getMap(ob);
+          Map<String, Object> ansert = new HashMap<>();
+          ansert.put("teamType", result.get("teamType"));
+          ansert.put("name", result.get("name"));
+          ansert.put("parents", result.get("parents"));
+          ansert.put("isJoinable", result.get("isJoinable"));
+          resultData.add(ansert);
+        }
+        contextData.put(ENTITY_TYPE_KEY, entityType);
+        contextData.put("records", resultData);
+        entityRecords.add(contextData);
         if (!nullOrEmpty(entities.getData())) {
           IndexingTask<?> task = new IndexingTask<>(entityType, entities, offset);
           processTask(task, jobExecutionContext);

openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/EntityRepository.java

@@ -990,6 +990,17 @@ public final PutResponse<T> createOrUpdate(UriInfo uriInfo, T updated) {
     return update(uriInfo, original, updated);
   }
 
+  @Transaction
+  public final PutResponse<T> createOrUpdate(UriInfo uriInfo, String updatedJson) {
+    T updated = JsonUtils.readValue(updatedJson, entityClass);
+    T original = findByNameOrNull(updated.getFullyQualifiedName(), ALL);
+    if (original == null) { // If an original entity does not exist then create it, else update
+      return new PutResponse<>(
+          Status.CREATED, withHref(uriInfo, createNewEntity(updated)), ENTITY_CREATED);
+    }
+    return update(uriInfo, original, updated);
+  }
+
   @SuppressWarnings("unused")
   protected void postCreate(T entity) {
     if (supportsSearch) {

openmetadata-service/src/main/java/org/openmetadata/service/resources/teams/TeamResource.java

@@ -749,4 +749,26 @@ public Response importCsvAsync(
       String csv) {
     return importCsvInternalAsync(securityContext, name, csv, dryRun);
   }
+
+  private Team getTeam(CreateTeam ct, String user) {
+    if (ct.getTeamType().equals(TeamType.ORGANIZATION)) {
+      throw new IllegalArgumentException(CREATE_ORGANIZATION);
+    }
+    if (ct.getTeamType().equals(TeamType.GROUP) && ct.getChildren() != null) {
+      throw new IllegalArgumentException(CREATE_GROUP);
+    }
+    return repository
+        .copy(new Team(), ct, user)
+        .withProfile(ct.getProfile())
+        .withIsJoinable(ct.getIsJoinable())
+        .withUsers(EntityUtil.populateEntityReferenceFromFqn(ct.getUsers(), Entity.USER))
+        .withDefaultRoles(
+            EntityUtil.populateEntityReferenceFromFqn(ct.getDefaultRoles(), Entity.ROLE))
+        .withTeamType(ct.getTeamType())
+        .withParents(EntityUtil.populateEntityReferenceFromFqn(ct.getParents(), Entity.TEAM))
+        .withChildren(EntityUtil.populateEntityReferenceFromFqn(ct.getChildren(), Entity.TEAM))
+        .withPolicies(EntityUtil.populateEntityReferenceFromFqn(ct.getPolicies(), Entity.POLICY))
+        .withEmail(ct.getEmail())
+        .withDomains(EntityUtil.getEntityReferences(Entity.DOMAIN, ct.getDomains()));
+  }
 }

openmetadata-service/src/main/java/org/openmetadata/service/util/EntityUtil.java

@@ -267,13 +267,31 @@ public static List<EntityReference> toEntityReferences(List<UUID> ids, String en
         .collect(Collectors.toList());
   }
 
+  public static List<EntityReference> populateEntityReferenceFromFqn(
+      List<String> fqns, String entityType) {
+    if (fqns == null) {
+      return null;
+    }
+    return populateEntityReferences(
+        fqns.stream()
+            .map(fqn -> new EntityReference().withFullyQualifiedName(fqn).withType(entityType))
+            .collect(Collectors.toList()));
+  }
+
   public static List<UUID> refToIds(List<EntityReference> refs) {
     if (refs == null) {
       return null;
     }
     return refs.stream().map(EntityReference::getId).collect(Collectors.toList());
   }
 
+  public static List<String> refToFqns(List<EntityReference> refs) {
+    if (refs == null) {
+      return null;
+    }
+    return refs.stream().map(EntityReference::getFullyQualifiedName).collect(Collectors.toList());
+  }
+
   public static <T> boolean isDescriptionRequired(Class<T> clz) {
     // Returns true if description field in entity is required
     try {

openmetadata-service/src/test/java/org/openmetadata/service/resources/feeds/FeedResourceTest.java

@@ -177,7 +177,7 @@ public void setup(TestInfo test) throws IOException, URISyntaxException {
             .createRequest(test, 4)
             .withDisplayName("Team2")
             .withDescription("Team2 description")
-            .withUsers(List.of(USER2.getId()));
+            .withUsers(List.of(USER2.getFullyQualifiedName()));
     TEAM2 = teamResourceTest.createAndCheckEntity(createTeam, ADMIN_AUTH_HEADERS);
     EntityReference TEAM2_REF = TEAM2.getEntityReference();
 

openmetadata-service/src/test/java/org/openmetadata/service/resources/feeds/SuggestionsResourceTest.java

@@ -104,7 +104,7 @@ public void setup(TestInfo test) throws IOException, URISyntaxException {
             .createRequest(test, 4)
             .withDisplayName("Team2")
             .withDescription("Team2 description")
-            .withUsers(List.of(USER2.getId()));
+            .withUsers(List.of(USER2.getFullyQualifiedName()));
     TEAM2 = teamResourceTest.createAndCheckEntity(createTeam, ADMIN_AUTH_HEADERS);
     EntityReference TEAM2_REF = TEAM2.getEntityReference();
 

openmetadata-service/src/test/java/org/openmetadata/service/resources/policies/PolicyResourceTest.java

@@ -429,7 +429,9 @@ void get_policyTeamsAndRoles(TestInfo test) throws IOException {
     for (int i = 0; i < 3; i++) {
       // Team X has Policy X
       CreateTeam createTeam =
-          TEAM_TEST.createRequest(test, i).withPolicies(List.of(policies.get(i).getId()));
+          TEAM_TEST
+              .createRequest(test, i)
+              .withPolicies(List.of(policies.get(i).getFullyQualifiedName()));
       teams.add(TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS));
     }
 
@@ -542,15 +544,27 @@ void test_roles_policies_scenarios() throws HttpResponseException {
         TEAM_TEST
             .createRequest("rolesPoliciesTeam2")
             .withTeamType(DEPARTMENT)
-            .withDefaultRoles(listOf(DATA_STEWARD_ROLE.getId()));
+            .withDefaultRoles(listOf(DATA_STEWARD_ROLE.getFullyQualifiedName()));
     Team team2 = TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS);
-    createTeam = TEAM_TEST.createRequest("rolesPoliciesTeam11").withParents(listOf(team1.getId()));
+    createTeam =
+        TEAM_TEST
+            .createRequest("rolesPoliciesTeam11")
+            .withParents(listOf(team1.getFullyQualifiedName()));
     Team team11 = TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS);
-    createTeam = TEAM_TEST.createRequest("rolesPoliciesTeam12").withParents(listOf(team1.getId()));
+    createTeam =
+        TEAM_TEST
+            .createRequest("rolesPoliciesTeam12")
+            .withParents(listOf(team1.getFullyQualifiedName()));
     Team team12 = TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS);
-    createTeam = TEAM_TEST.createRequest("rolesPoliciesTeam21").withParents(listOf(team2.getId()));
+    createTeam =
+        TEAM_TEST
+            .createRequest("rolesPoliciesTeam21")
+            .withParents(listOf(team2.getFullyQualifiedName()));
     Team team21 = TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS);
-    createTeam = TEAM_TEST.createRequest("rolesPoliciesTeam22").withParents(listOf(team2.getId()));
+    createTeam =
+        TEAM_TEST
+            .createRequest("rolesPoliciesTeam22")
+            .withParents(listOf(team2.getFullyQualifiedName()));
     Team team22 = TEAM_TEST.createEntity(createTeam, ADMIN_AUTH_HEADERS);
 
     // Create users - Team2 has default role DataSteward

openmetadata-service/src/test/java/org/openmetadata/service/resources/teams/RoleResourceTest.java

@@ -194,12 +194,12 @@ public Role validateGetWithDifferentFields(Role role, boolean byName)
       teamResourceTest.createEntity(
           teamResourceTest
               .createRequest("roleTeam1", "", "", null)
-              .withDefaultRoles(List.of(role.getId())),
+              .withDefaultRoles(List.of(role.getFullyQualifiedName())),
           ADMIN_AUTH_HEADERS);
       teamResourceTest.createEntity(
           teamResourceTest
               .createRequest("roleTeam2", "", "", null)
-              .withDefaultRoles(List.of(role.getId())),
+              .withDefaultRoles(List.of(role.getFullyQualifiedName())),
           ADMIN_AUTH_HEADERS);
     }