// Create creates a new work item in the repository
// returns BadParameterError, ConversionError or InternalError
func (r *GormWorkItemRepository) Create(ctx context.Context, typeID string, fields map[string]interface{}, creator string) (*app.WorkItem, error) {
wiType, err := r.wir.LoadTypeFromDB(ctx, typeID)
if err != nil {
return nil, errors.NewBadParameterError("type", typeID)
}
wi := WorkItem{
Type: typeID,
Fields: Fields{},
}
fields[SystemCreator] = creator
for fieldName, fieldDef := range wiType.Fields {
if fieldName == SystemCreatedAt {
continue
}
fieldValue := fields[fieldName]
var err error
wi.Fields[fieldName], err = fieldDef.ConvertToModel(fieldName, fieldValue)
if err != nil {
return nil, errors.NewBadParameterError(fieldName, fieldValue)
}
if fieldName == SystemDescription && wi.Fields[fieldName] != nil {
description := rendering.NewMarkupContentFromMap(wi.Fields[fieldName].(map[string]interface{}))
if !rendering.IsMarkupSupported(description.Markup) {
return nil, errors.NewBadParameterError(fieldName, fieldValue)
}
}
}
tx := r.db
if err = tx.Create(&wi).Error; err != nil {
return nil, errors.NewInternalError(err.Error())
}
return convertWorkItemModelToApp(wiType, &wi)
}
// ConvertFromModel implements the FieldType interface
func (fieldType SimpleType) ConvertFromModel(value interface{}) (interface{}, error) {
if value == nil {
return nil, nil
}
valueType := reflect.TypeOf(value)
switch fieldType.GetKind() {
case KindString, KindURL, KindUser, KindInteger, KindFloat, KindDuration, KindIteration, KindArea:
return value, nil
case KindInstant:
return time.Unix(0, value.(int64)), nil
case KindWorkitemReference:
if valueType.Kind() != reflect.String {
return nil, fmt.Errorf("value %v should be %s, but is %s", value, "string", valueType.Name())
}
return strconv.FormatUint(value.(uint64), 10), nil
case KindMarkup:
if valueType.Kind() != reflect.Map {
return nil, errors.Errorf("value %v should be %s, but is %s", value, reflect.Map, valueType.Name())
}
markupContent := rendering.NewMarkupContentFromMap(value.(map[string]interface{}))
return markupContent, nil
default:
return nil, errors.Errorf("unexpected field type: %s", fieldType.GetKind())
}
}
func TestNewMarkupContentFromMapWithMissingMarkup(t *testing.T) {
// given
input := make(map[string]interface{})
input[rendering.ContentKey] = "foo"
// when
result := rendering.NewMarkupContentFromMap(input)
// then
assert.Equal(t, input[rendering.ContentKey].(string), result.Content)
assert.Equal(t, rendering.SystemMarkupDefault, result.Markup)
}
