// Create session.
sess := session.Must(session.NewSessionWithOptions(session.Options{
	SharedConfigState: session.SharedConfigEnable,
}))
// Create DynamoDB client.
db := dynamodb.New(sess, &aws.Config{Endpoint: aws.String("http://localhost:8000")})

type Item struct {
	MyHashKey  string `dynamodbav:"MyHashKey"`
	MyRangeKey int    `dynamodbav:"MyRangeKey"`
	MyText     string `dynamodbav:"MyText"`
}

item := Item{
	MyHashKey:  "00001",
	MyRangeKey: 1,
	MyText:     "some text...",
}
// Convert item to dynamodb attribute.
av, err := dynamodbattribute.MarshalMap(item)
if err != nil {
	fmt.Println(err.Error())
	return
}
// Create an input.
input := &dynamodb.PutItemInput{
	TableName: aws.String("MyFirstTable"),
	Item:      av,
}
// Execute.
_, err = db.PutItem(input)
if err != nil {
	fmt.Println(err.Error())
	return
}

// Create an input.
input := &dynamodb.GetItemInput{
	TableName: aws.String("MyFirstTable"),
	Key: map[string]*dynamodb.AttributeValue{
		"MyHashKey": {
			S: aws.String("00001"),
		},
		"MyRangeKey": {
			N: aws.String("1"),
		},
	},
}
// Execute.
result, err := db.GetItem(input)
if err != nil {
	fmt.Println(err.Error())
	return
}
// Convert the dynamodb result to a struct.
item := Item{}
err = dynamodbattribute.UnmarshalMap(result.Item, &item)
if err != nil {
	fmt.Println(err.Error())
	return
}
fmt.Println(item) // {00001 1 some text...}

// Create an expression for update.
update := expression.UpdateBuilder{}.Set(expression.Name("MyText"), expression.Value("updated text"))
expr, err := expression.NewBuilder().WithUpdate(update).Build()
if err != nil {
	fmt.Println(err.Error())
	return
}
// Create an input.
input := &dynamodb.UpdateItemInput{
	TableName: aws.String("MyFirstTable"),
	Key: map[string]*dynamodb.AttributeValue{
		"MyHashKey": {
			S: aws.String("00001"),
		},
		"MyRangeKey": {
			N: aws.String("1"),
		},
	},
	ExpressionAttributeNames:  expr.Names(),
	ExpressionAttributeValues: expr.Values(),
	UpdateExpression:          expr.Update(),
	ConditionExpression:       expr.Condition(),
	ReturnValues:              aws.String(dynamodb.ReturnValueAllNew),
}
// Execute.
_, err = db.UpdateItem(input)
if err != nil {
	fmt.Println(err.Error())
	return
}

// Create an input.
input := &dynamodb.DeleteItemInput{
	TableName: aws.String("MyFirstTable"),
	Key: map[string]*dynamodb.AttributeValue{
		"MyHashKey": {
			S: aws.String("00001"),
		},
		"MyRangeKey": {
			N: aws.String("1"),
		},
	},
}
// Execute.
_, err := db.DeleteItem(input)
if err != nil {
	fmt.Println(err.Error())
	return
}

func (repo *BaseRepository) get(req, res domain.Domain, consistent bool) error {
	key, err := repo.KeyAttributes(req)
	if err != nil {
		return errors.Wrap(err, "failed to get DynamoDB key attributes")
	}
	input := &dynamodb.GetItemInput{
		TableName:      repo.Table(),
		Key:            key,
		ConsistentRead: aws.Bool(consistent),
	}
	// Execute.
	output, err := repo.DB.GetItem(input)
	if err != nil {
		return errors.Wrapf(err, "failed to execute DynamoDB Get API to %s", *repo.Table())
	}
	if len(output.Item) == 0 {
		return exception.NewNotFoundError("")
	}
	if err = dynamodbattribute.UnmarshalMap(output.Item, &res); err != nil {
		return errors.Wrap(err, "failed to DynamoDB unmarshal")
	}
	return nil
}

// KeyAttributes returns a map of *dymanodb.AttributeValue that is dynamodb table key from the passed struct.
func (repo *BaseRepository) KeyAttributes(domain interface{}) (map[string]*dynamodb.AttributeValue, error) {
	return repo.attributes(domain, func(tag reflect.StructTag) bool {
		_, ok := tag.Lookup("dynamodbkey")
		return ok
	})
}

func (repo *BaseRepository) attributes(domain interface{}, condition func(tag reflect.StructTag) bool) (map[string]*dynamodb.AttributeValue, error) {
	rv := reflect.Indirect(reflect.ValueOf(domain))
	if rv.Kind() != reflect.Struct {
		return nil, errors.New("domain must be a struct")
	}
	// Create dynamodb attributes.
	attr, err := dynamodbattribute.MarshalMap(rv.Interface())
	if err != nil {
		return nil, err
	}
	// Delete attributes by condition.
	var deleteAttr func(rv reflect.Value)
	deleteAttr = func(rv reflect.Value) {
		for i, rt := 0, rv.Type(); i < rv.NumField(); i++ {
			if rv.Field(i).Kind() == reflect.Struct && rt.Field(i).Anonymous {
				deleteAttr(rv.Field(i))
				continue
			}
			name, tag := rt.Field(i).Name, rt.Field(i).Tag
			if !condition(tag) {
				if dynamodbav := tag.Get("dynamodbav"); dynamodbav != "" {
					delete(attr, strings.Split(dynamodbav, ",")[0])
				} else {
					delete(attr, name)
				}
			}
		}
	}
	deleteAttr(rv)
	return attr, nil
}