Introduce templateId constants

core/block/template/templateimpl/impl.go

@@ -36,12 +36,14 @@ import (
 )
 
 const (
-	CName           = "template"
-	BlankTemplateId = "blank"
+	CName                = "template"
+	BlankTemplateId      = "blank"
+	DefaultTemplateId    = "default"
+	LastEditedTemplateId = "lastEdited"
 )
 
 var (
-	log = logging.Logger("template")
+	log = logging.Logger(CName)
 
 	templateIsPreferableRelationKeys = []domain.RelationKey{
 		bundle.RelationKeyLayout,
@@ -110,18 +112,93 @@ func (s *service) CreateTemplateStateWithDetails(req templateSvc.CreateTemplateR
 }
 
 func (s *service) resolveValidTemplateId(spaceId, templateId, typeId string) (string, error) {
+	switch templateId {
+	case BlankTemplateId:
+		return BlankTemplateId, nil
+	case DefaultTemplateId:
+		return s.getDefaultTemplateId(spaceId, typeId)
+	case LastEditedTemplateId:
+		return s.getLastEditedTemplateId(spaceId, typeId)
+	case "":
+		defaultTemplateId, err := s.getDefaultTemplateId(spaceId, typeId)
+		if err == nil && defaultTemplateId != "" {
+			return defaultTemplateId, nil
+		}
+		lastEditedTemplateId, err := s.getLastEditedTemplateId(spaceId, typeId)
+		if err == nil && lastEditedTemplateId != "" {
+			return lastEditedTemplateId, nil
+		}
+		return BlankTemplateId, nil
+	}
+
+	records, err := s.queryTemplatesByType(spaceId, typeId)
+	if err != nil {
+		return "", fmt.Errorf("failed to query templates: %w", err)
+	}
+
+	if len(records) == 0 {
+		// if no templates presented, we should create new object with blank template
+		return BlankTemplateId, nil
+	}
+
+	defaultTemplateId, err := s.getDefaultTemplateId(spaceId, typeId)
+	if err != nil {
+		defaultTemplateId = ""
+	}
+
+	var defaultTemplateIsValid bool
+	for _, record := range records {
+		recordId := record.Details.GetString(bundle.RelationKeyId)
+		if recordId == templateId {
+			return templateId, nil
+		}
+		if !defaultTemplateIsValid && defaultTemplateId != "" && recordId == defaultTemplateId {
+			defaultTemplateIsValid = true
+		}
+	}
+
+	// if requested templateId was not found in store, we should use default template
+	if defaultTemplateIsValid {
+		return defaultTemplateId, nil
+	}
+
+	// if default template is not set or not valid, we should use last edited template
+	return records[0].Details.GetString(bundle.RelationKeyId), nil
+}
+
+func (s *service) getDefaultTemplateId(spaceId, typeId string) (string, error) {
+	details, err := s.store.SpaceIndex(spaceId).GetDetails(typeId)
+	if err != nil {
+		return "", fmt.Errorf("failed to get details of type object from store: %w", err)
+	}
+	return details.GetString(bundle.RelationKeyDefaultTemplateId), nil
+}
+
+func (s *service) getLastEditedTemplateId(spaceId, typeId string) (string, error) {
+	records, err := s.queryTemplatesByType(spaceId, typeId)
+	if err != nil {
+		return "", fmt.Errorf("failed to query templates: %w", err)
+	}
+	if len(records) == 0 {
+		return "", nil
+	}
+	return records[0].Details.GetString(bundle.RelationKeyId), nil
+}
+
+// queryTemplatesByType queries templates by particular type sorted by lastModifiedDate
+func (s *service) queryTemplatesByType(spaceId, typeId string) ([]database.Record, error) {
 	var ctx = context.Background()
 
 	spc, err := s.spaceService.Get(ctx, spaceId)
 	if err != nil {
-		return "", fmt.Errorf("failed to get space: %w", err)
+		return nil, fmt.Errorf("failed to get space: %w", err)
 	}
 	templateTypeId, err := spc.GetTypeIdByKey(ctx, bundle.TypeKeyTemplate)
 	if err != nil {
-		return "", fmt.Errorf("failed to get template type id from space: %w", err)
+		return nil, fmt.Errorf("failed to get template type id from space: %w", err)
 	}
 
-	records, err := s.store.SpaceIndex(spaceId).Query(database.Query{
+	return s.store.SpaceIndex(spaceId).Query(database.Query{
 		Filters: []database.FilterRequest{
 			{
 				RelationKey: bundle.RelationKeyType,
@@ -139,28 +216,6 @@ func (s *service) resolveValidTemplateId(spaceId, templateId, typeId string) (st
 			Type:        model.BlockContentDataviewSort_Desc,
 		}},
 	})
-
-	if err != nil {
-		return "", fmt.Errorf("failed to query templates: %w", err)
-	}
-
-	if len(records) == 0 {
-		// if no valid templates presented, we shell create new object with blank template
-		return "", nil
-	}
-
-	if templateId == "" {
-		return records[0].Details.GetString(bundle.RelationKeyId), nil
-	}
-
-	for _, record := range records {
-		if record.Details.GetString(bundle.RelationKeyId) == templateId {
-			return templateId, nil
-		}
-	}
-
-	// if requested templateId was not found in store, we should use last modified template
-	return records[0].Details.GetString(bundle.RelationKeyId), nil
 }
 
 // CreateTemplateStateFromSmartBlock duplicates the logic of CreateTemplateStateWithDetails but does not take the lock on smartBlock.

core/block/template/templateimpl/impl_test.go

@@ -326,6 +326,7 @@ func TestService_resolveValidTemplateId(t *testing.T) {
 		{"requested template is invalid", spaceId, "invalid", templateId1},
 		{"requested template is deleted", spaceId, templateId3, templateId1},
 		{"requested template is empty", spaceId, "", templateId1},
+		{"requested template is blank", spaceId, BlankTemplateId, BlankTemplateId},
 		{"no valid template exists", otherSpaceId, "templateId", ""},
 	} {
 		t.Run(tc.name, func(t *testing.T) {