Temporal Workflow and Microservices

				
					func CalculateParallelepipedWorkflow(ctx workflow.Context, req CalculateParallelepipedWorkflowRequest) (resp CalculateParallelepipedWorkflowResponse, err error) {
	if len(req.Parallelepipeds) == 0 {
		err = BusinessError{"there are no figures to process"}
		return
	}

	if isIDsRepeat(req.Parallelepipeds) {
		err = BusinessError{"the ids of the figures in the input should be unique"}
		return
	}

	if req.BatchSize <= 0 {
		err = BusinessError{"makeBatch size cannot be less or equal to zero"}
		return
	}

	batchCount := batchCount(len(req.Parallelepipeds), req.BatchSize)

	selector := workflow.NewNamedSelector(ctx, "select-parallelepiped-batches")
	var errOneBatch error
	cancelCtx, cancelHandler := workflow.WithCancel(ctx)

	count := 0
	squareMap := make(map[string]float64)
	volumeMap := make(map[string]float64)
	for i := 0; i < batchCount; i++ {
		batch := makeBatch(req.Parallelepipeds, i, req.BatchSize)

		future := processSquareAsync(cancelCtx, batch)
		selector.AddFuture(future, func(f workflow.Future) {
			respSquare := square.CalculateRectangleSquareResponse{}
			if err := f.Get(cancelCtx, &respSquare); err != nil {
				cancelHandler()
				errOneBatch = err
			} else {
				copyResult(squareMap, respSquare.Squares)
			}
		})
		count++

		future = processVolumeAsync(cancelCtx, batch)
		selector.AddFuture(future, func(f workflow.Future) {
			respVolume := volume.CalculateParallelepipedVolumeResponse{}
			if err := f.Get(cancelCtx, &respVolume); err != nil {
				cancelHandler()
				errOneBatch = err
			} else {
				copyResult(volumeMap, respVolume.Volumes)
			}
		})
		count++
	}

	// wait until everything processed
	for i := 0; i < count; i++ {
		selector.Select(ctx)
		if errOneBatch != nil {
			return CalculateParallelepipedWorkflowResponse{}, errOneBatch
		}
	}

	// map the output
	var outputFigures = make([]Parallelepiped, 0, len(req.Parallelepipeds))
	for _, p := range req.Parallelepipeds {
		outputP := p
		outputP.BaseSquare = squareMap[p.ID]
		outputP.Volume = volumeMap[p.ID]
		outputFigures = append(outputFigures, outputP)
	}
	return CalculateParallelepipedWorkflowResponse{Parallelepipeds: outputFigures}, nil
}
				
			

				
					type Rectangle struct {
	ID     string
	Length float64
	Width  float64
}

type Service struct{}

type CalculateRectangleSquareRequest struct {
	Rectangles []Rectangle
}

type CalculateRectangleSquareResponse struct {
	Squares map[string]float64
}