github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/internal/domain/document/converter.go (about)

     1  package document
     2  
     3  import (
     4  	"time"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/internal/repo"
     7  	"github.com/pkg/errors"
     8  
     9  	"github.com/kyma-incubator/compass/components/director/internal/model"
    10  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    11  )
    12  
    13  type converter struct {
    14  	frConverter FetchRequestConverter
    15  }
    16  
    17  // NewConverter missing godoc
    18  func NewConverter(frConverter FetchRequestConverter) *converter {
    19  	return &converter{frConverter: frConverter}
    20  }
    21  
    22  // ToGraphQL missing godoc
    23  func (c *converter) ToGraphQL(in *model.Document) *graphql.Document {
    24  	if in == nil {
    25  		return nil
    26  	}
    27  
    28  	var clob *graphql.CLOB
    29  	if in.Data != nil {
    30  		tmp := graphql.CLOB(*in.Data)
    31  		clob = &tmp
    32  	}
    33  
    34  	return &graphql.Document{
    35  		BundleID:    in.BundleID,
    36  		Title:       in.Title,
    37  		DisplayName: in.DisplayName,
    38  		Description: in.Description,
    39  		Format:      graphql.DocumentFormat(in.Format),
    40  		Kind:        in.Kind,
    41  		Data:        clob,
    42  		BaseEntity: &graphql.BaseEntity{
    43  			ID:        in.ID,
    44  			Ready:     in.Ready,
    45  			CreatedAt: timePtrToTimestampPtr(in.CreatedAt),
    46  			UpdatedAt: timePtrToTimestampPtr(in.UpdatedAt),
    47  			DeletedAt: timePtrToTimestampPtr(in.DeletedAt),
    48  			Error:     in.Error,
    49  		},
    50  	}
    51  }
    52  
    53  // MultipleToGraphQL missing godoc
    54  func (c *converter) MultipleToGraphQL(in []*model.Document) []*graphql.Document {
    55  	documents := make([]*graphql.Document, 0, len(in))
    56  	for _, r := range in {
    57  		if r == nil {
    58  			continue
    59  		}
    60  
    61  		documents = append(documents, c.ToGraphQL(r))
    62  	}
    63  
    64  	return documents
    65  }
    66  
    67  // InputFromGraphQL missing godoc
    68  func (c *converter) InputFromGraphQL(in *graphql.DocumentInput) (*model.DocumentInput, error) {
    69  	if in == nil {
    70  		return nil, nil
    71  	}
    72  
    73  	var data *string
    74  	if in.Data != nil {
    75  		tmp := string(*in.Data)
    76  		data = &tmp
    77  	}
    78  
    79  	fetchReq, err := c.frConverter.InputFromGraphQL(in.FetchRequest)
    80  	if err != nil {
    81  		return nil, errors.Wrap(err, "while converting FetchRequestInput input")
    82  	}
    83  
    84  	return &model.DocumentInput{
    85  		Title:        in.Title,
    86  		DisplayName:  in.DisplayName,
    87  		Description:  in.Description,
    88  		Format:       model.DocumentFormat(in.Format),
    89  		Kind:         in.Kind,
    90  		Data:         data,
    91  		FetchRequest: fetchReq,
    92  	}, nil
    93  }
    94  
    95  // MultipleInputFromGraphQL missing godoc
    96  func (c *converter) MultipleInputFromGraphQL(in []*graphql.DocumentInput) ([]*model.DocumentInput, error) {
    97  	inputs := make([]*model.DocumentInput, 0, len(in))
    98  	for _, r := range in {
    99  		if r == nil {
   100  			continue
   101  		}
   102  
   103  		docInput, err := c.InputFromGraphQL(r)
   104  		if err != nil {
   105  			return nil, err
   106  		}
   107  
   108  		inputs = append(inputs, docInput)
   109  	}
   110  
   111  	return inputs, nil
   112  }
   113  
   114  // ToEntity missing godoc
   115  func (c *converter) ToEntity(in *model.Document) (*Entity, error) {
   116  	kind := repo.NewNullableString(in.Kind)
   117  	data := repo.NewNullableString(in.Data)
   118  
   119  	out := &Entity{
   120  		BndlID:                       in.BundleID,
   121  		AppID:                        repo.NewNullableString(in.AppID),
   122  		ApplicationTemplateVersionID: repo.NewNullableString(in.ApplicationTemplateVersionID),
   123  		Title:                        in.Title,
   124  		DisplayName:                  in.DisplayName,
   125  		Description:                  in.Description,
   126  		Format:                       string(in.Format),
   127  		Kind:                         kind,
   128  		Data:                         data,
   129  		BaseEntity: &repo.BaseEntity{
   130  			ID:        in.ID,
   131  			Ready:     in.Ready,
   132  			CreatedAt: in.CreatedAt,
   133  			UpdatedAt: in.UpdatedAt,
   134  			DeletedAt: in.DeletedAt,
   135  			Error:     repo.NewNullableString(in.Error),
   136  		},
   137  	}
   138  
   139  	return out, nil
   140  }
   141  
   142  // FromEntity missing godoc
   143  func (c *converter) FromEntity(in *Entity) (*model.Document, error) {
   144  	kind := repo.StringPtrFromNullableString(in.Kind)
   145  	data := repo.StringPtrFromNullableString(in.Data)
   146  
   147  	out := &model.Document{
   148  		BundleID:                     in.BndlID,
   149  		AppID:                        repo.StringPtrFromNullableString(in.AppID),
   150  		ApplicationTemplateVersionID: repo.StringPtrFromNullableString(in.ApplicationTemplateVersionID),
   151  		Title:                        in.Title,
   152  		DisplayName:                  in.DisplayName,
   153  		Description:                  in.Description,
   154  		Format:                       model.DocumentFormat(in.Format),
   155  		Kind:                         kind,
   156  		Data:                         data,
   157  		BaseEntity: &model.BaseEntity{
   158  			ID:        in.ID,
   159  			Ready:     in.Ready,
   160  			CreatedAt: in.CreatedAt,
   161  			UpdatedAt: in.UpdatedAt,
   162  			DeletedAt: in.DeletedAt,
   163  			Error:     repo.StringPtrFromNullableString(in.Error),
   164  		},
   165  	}
   166  	return out, nil
   167  }
   168  
   169  func timePtrToTimestampPtr(time *time.Time) *graphql.Timestamp {
   170  	if time == nil {
   171  		return nil
   172  	}
   173  
   174  	t := graphql.Timestamp(*time)
   175  	return &t
   176  }