Merge pull request #953 from th37rose/feature/bundle

Feature/bundle

Author: ludomikula

server/api-service/lowcoder-domain/src/main/java/org/lowcoder/domain/bundle/model/Bundle.java

@@ -6,6 +6,7 @@
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.experimental.SuperBuilder;
+import org.apache.commons.lang3.BooleanUtils;
 import org.lowcoder.sdk.models.HasIdAndAuditing;
 import org.springframework.data.mongodb.core.mapping.Document;
 
@@ -32,4 +33,16 @@ public class Bundle extends HasIdAndAuditing {
 
     private Map<String, Object> editingBundleDSL;
     private Map<String, Object> publishedBundleDSL;
+
+    public boolean isPublicToAll() {
+        return BooleanUtils.toBooleanDefaultIfNull(publicToAll, false);
+    }
+
+    public boolean isPublicToMarketplace() {
+        return BooleanUtils.toBooleanDefaultIfNull(publicToMarketplace, false);
+    }
+
+    public boolean agencyProfile() {
+        return BooleanUtils.toBooleanDefaultIfNull(agencyProfile, false);
+    }
 }

server/api-service/lowcoder-domain/src/main/java/org/lowcoder/domain/bundle/service/BundleService.java

@@ -9,20 +9,25 @@
 import reactor.core.publisher.Mono;
 
 import java.util.Collection;
+import java.util.Map;
 import java.util.Set;
 
 public interface BundleService {
     Mono<Boolean> updateById(String id, Bundle resource);
 
     Mono<Bundle> findById(String id);
 
+    Mono<Bundle> findByIdWithoutDsl(String id);
+
     Mono<Bundle> create(Bundle bundle, String userId);
 
     Flux<Bundle> findByUserId(String bundleId);
 
     Mono<Void> deleteAllById(Collection<String> ids);
 
     Mono<Boolean> exist(String id);
+    Mono<Bundle> publish(String bundleId);
+    Mono<Boolean> updatePublishedBundleDSL(String bundleId, Map<String, Object> bundleDSL);
 
     @NonEmptyMono
     @SuppressWarnings("ReactiveStreamsNullableInLambdaInTransform")

server/api-service/lowcoder-domain/src/main/java/org/lowcoder/domain/bundle/service/BundleServiceImpl.java

@@ -2,8 +2,6 @@
 
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
-import org.lowcoder.domain.application.model.Application;
-import org.lowcoder.domain.application.model.ApplicationRequestType;
 import org.lowcoder.domain.bundle.model.Bundle;
 import org.lowcoder.domain.bundle.model.BundleRequestType;
 import org.lowcoder.domain.bundle.repository.BundleRepository;
@@ -54,6 +52,16 @@ public Mono<Bundle> findById(String id) {
                 .switchIfEmpty(Mono.error(new BizException(BizError.NO_RESOURCE_FOUND, "BUNDLE_NOT_FOUND", id)));
     }
 
+    @Override
+    public Mono<Bundle> findByIdWithoutDsl(String id) {
+        if (id == null) {
+            return Mono.error(new BizException(BizError.INVALID_PARAMETER, "INVALID_PARAMETER", FieldName.ID));
+        }
+
+        return repository.findById(id)
+                .switchIfEmpty(Mono.error(new BizException(BizError.NO_RESOURCE_FOUND, "CANT_FIND_BUNDLE", id)));
+    }
+
     @Override
     public Mono<Bundle> create(Bundle newbundle, String visitorId) {
         return repository.save(newbundle)
@@ -82,10 +90,24 @@ public Mono<Boolean> exist(String id) {
                 });
     }
 
+    @Override
+    public Mono<Bundle> publish(String bundleId) {
+        return findById(bundleId)
+                .flatMap(newBundle -> { // copy editingApplicationDSL to publishedApplicationDSL
+                    Map<String, Object> editingBundleDSL = newBundle.getEditingBundleDSL();
+                    return updatePublishedBundleDSL(bundleId, editingBundleDSL)
+                            .thenReturn(newBundle);
+                });
+    }
+
+    @Override
+    public Mono<Boolean> updatePublishedBundleDSL(String bundleId, Map<String, Object> bundleDSL) {
+        Bundle bundle = Bundle.builder().publishedBundleDSL(bundleDSL).build();
+        return mongoUpsertHelper.updateById(bundle, bundleId);
+    }
 
     @Override
     @NonEmptyMono
-    @SuppressWarnings("ReactiveStreamsNullableInLambdaInTransform")
     public Mono<Set<String>> getFilteredPublicBundleIds(BundleRequestType requestType, Collection<String> bundleIds, String userId, Boolean isPrivateMarketplace) {
         boolean isAnonymous = StringUtils.isBlank(userId);
         switch(requestType)
@@ -149,7 +171,7 @@ public Mono<Set<String>> getPrivateBundleIds(Collection<String> bundleIds, Strin
     @SuppressWarnings("ReactiveStreamsNullableInLambdaInTransform")
     public Mono<Set<String>> getPublicMarketplaceBundleIds(Collection<String> bundleIds, boolean isAnonymous, boolean isPrivateMarketplace) {
 
-        if ((isAnonymous && !isPrivateMarketplace) || !isAnonymous)
+        if (!isAnonymous || !isPrivateMarketplace)
         {
             return repository.findByPublicToAllIsTrueAndPublicToMarketplaceIsTrueAndIdIn(bundleIds)
                     .map(HasIdAndAuditing::getId)

server/api-service/lowcoder-domain/src/main/java/org/lowcoder/domain/permission/service/ResourcePermissionService.java

@@ -23,6 +23,8 @@ Mono<Map<String, Collection<ResourcePermission>>> getByResourceTypeAndResourceId
 
     @NonEmptyMono
     Mono<List<ResourcePermission>> getByApplicationId(String applicationId);
+    @NonEmptyMono
+    Mono<List<ResourcePermission>> getByBundleId(String bundleId);
 
     @NonEmptyMono
     Mono<List<ResourcePermission>> getByDataSourceId(String dataSourceId);

server/api-service/lowcoder-domain/src/main/java/org/lowcoder/domain/permission/service/ResourcePermissionServiceImpl.java

@@ -57,6 +57,12 @@ public Mono<List<ResourcePermission>> getByApplicationId(String applicationId) {
         return getByResourceTypeAndResourceId(ResourceType.APPLICATION, applicationId);
     }
 
+    @Override
+    @NonEmptyMono
+    public Mono<List<ResourcePermission>> getByBundleId(String bundleId) {
+        return getByResourceTypeAndResourceId(ResourceType.BUNDLE, bundleId);
+    }
+
     @Override
     @NonEmptyMono
     public Mono<List<ResourcePermission>> getByDataSourceId(String dataSourceId) {

server/api-service/lowcoder-server/src/main/java/org/lowcoder/api/bundle/BundleApiService.java

@@ -23,15 +23,18 @@ public interface BundleApiService {
 
     Mono<Void> checkBundleCurrentUser(Bundle bundle, String currentOrgId);
     Mono<BundleInfoView> getPublishedBundle(String bundleId, BundleRequestType requestType);
+    Mono<BundleInfoView> getEditingBundle(String bundleId);
 
     Mono<Bundle> delete(@Nonnull String bundleId);
 
     Mono<Boolean> recycle(String bundleId);
 
     Mono<Boolean> restore(String bundleId);
     Flux<BundleInfoView> getRecycledBundles();
+    Mono<BundlePermissionView> getBundlePermissions(String bundleId);
 
     Mono<BundleInfoView> update(Bundle bundle);
+    Mono<BundleInfoView> publish(String bundleId);
 
     Mono<Void> moveApp(String applicationId, String fromBundled, String toBundleId);
 
@@ -41,12 +44,14 @@ public interface BundleApiService {
 
     @Nonnull
     Mono<ResourcePermission> checkBundlePermissionWithReadableErrorMsg(String bundleId, ResourceAction action, BundleRequestType requestType);
+    @Nonnull
+    Mono<ResourcePermission> checkPermissionWithReadableErrorMsg(String bundleId, ResourceAction action);
 
-    Mono<Void> grantPermission(String bundleId, Set<String> userIds, Set<String> groupIds, ResourceRole role);
+    Mono<Boolean> grantPermission(String bundleId, Set<String> userIds, Set<String> groupIds, ResourceRole role);
 
-    Mono<Void> updatePermission(String bundleId, String permissionId, ResourceRole role);
+    Mono<Boolean> updatePermission(String bundleId, String permissionId, ResourceRole role);
 
-    Mono<Void> removePermission(String bundleId, String permissionId);
+    Mono<Boolean> removePermission(String bundleId, String permissionId);
 
     Mono<BundlePermissionView> getPermissions(String bundleId);