5781074449

Committed 07 Aug 2023 04:35AM UTC coverage: 73.901% (-2.1%) from 76.038%

Build # 5781074449

Build Type

Pull #56

github

Committed by

rahmatrhd

Commit Message

fix: check required private log viewer permission

Pull Request Pull Request #56: feat: grant dormancy check

Run Details

413 of 413 new or added lines in 15 files covered. (100.0%)

8186 of 11077 relevant lines covered (73.9%)

4.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/api/handler/v1beta1/activity.go

package v1beta1

import (
        "context"
        "errors"

        guardianv1beta1 "github.com/goto/guardian/api/proto/gotocompany/guardian/v1beta1"
        "github.com/goto/guardian/core/activity"
        "github.com/goto/guardian/domain"
        "google.golang.org/grpc/codes"
        "google.golang.org/grpc/status"
)

func (s *GRPCServer) GetActivity(ctx context.Context, req *guardianv1beta1.GetActivityRequest) (*guardianv1beta1.GetActivityResponse, error) {
        a, err := s.activityService.GetOne(ctx, req.GetId())
        if err != nil {
                if errors.Is(err, activity.ErrNotFound) {
                        return nil, status.Errorf(codes.NotFound, "activity not found")
                }
                return nil, status.Errorf(codes.Internal, "failed to get activity: %v", err)
        }

        activityProto, err := s.adapter.ToActivityProto(a)
        if err != nil {
                return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)
        }

        return &guardianv1beta1.GetActivityResponse{
                Activity: activityProto,
        }, nil
}

func (s *GRPCServer) ListActivities(ctx context.Context, req *guardianv1beta1.ListActivitiesRequest) (*guardianv1beta1.ListActivitiesResponse, error) {
        filter := domain.ListProviderActivitiesFilter{
                ProviderIDs: req.GetProviderIds(),
                AccountIDs:  req.GetAccountIds(),
                ResourceIDs: req.GetResourceIds(),
                Types:       req.GetTypes(),
        }
        if req.GetTimestampGte() != nil {
                t := req.GetTimestampGte().AsTime()
                filter.TimestampGte = &t
        }
        if req.GetTimestampLte() != nil {
                t := req.GetTimestampLte().AsTime()
                filter.TimestampLte = &t
        }

        activities, err := s.activityService.Find(ctx, filter)
        if err != nil {
                return nil, status.Errorf(codes.Internal, "failed to list activities: %v", err)
        }

        activityProtos := []*guardianv1beta1.ProviderActivity{}
        for _, a := range activities {
                activityProto, err := s.adapter.ToActivityProto(a)
                if err != nil {
                        return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)
                }
                activityProtos = append(activityProtos, activityProto)
        }

        return &guardianv1beta1.ListActivitiesResponse{
                Activities: activityProtos,
        }, nil
}

func (s *GRPCServer) ImportActivities(ctx context.Context, req *guardianv1beta1.ImportActivitiesRequest) (*guardianv1beta1.ImportActivitiesResponse, error) {
        filter := domain.ListActivitiesFilter{
                ProviderID:  req.GetProviderId(),
                ResourceIDs: req.GetResourceIds(),
                AccountIDs:  req.GetAccountIds(),
        }
        if req.GetTimestampGte() != nil {
                t := req.GetTimestampGte().AsTime()
                filter.TimestampGte = &t
        }
        if req.GetTimestampLte() != nil {
                t := req.GetTimestampLte().AsTime()
                filter.TimestampLte = &t
        }

        activities, err := s.activityService.Import(ctx, filter)
        if err != nil {
                return nil, status.Errorf(codes.Internal, "failed to import activities: %v", err)
        }

        activityProtos := []*guardianv1beta1.ProviderActivity{}
        for _, a := range activities {
                activity, err := s.adapter.ToActivityProto(a)
                if err != nil {
                        return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)
                }

                activityProtos = append(activityProtos, activity)
        }

        return &guardianv1beta1.ImportActivitiesResponse{
                Activities: activityProtos,
        }, nil
}

1	package v1beta1
2
3	import (
4	"context"
5	"errors"
6
7	guardianv1beta1 "github.com/goto/guardian/api/proto/gotocompany/guardian/v1beta1"
8	"github.com/goto/guardian/core/activity"
9	"github.com/goto/guardian/domain"
10	"google.golang.org/grpc/codes"
11	"google.golang.org/grpc/status"
12	)
13
14	func (s GRPCServer) GetActivity(ctx context.Context, req guardianv1beta1.GetActivityRequest) (*guardianv1beta1.GetActivityResponse, error) {	×
15	a, err := s.activityService.GetOne(ctx, req.GetId())	×
16	if err != nil {	×
17	if errors.Is(err, activity.ErrNotFound) {	×
18	return nil, status.Errorf(codes.NotFound, "activity not found")	×
19	}	×
20	return nil, status.Errorf(codes.Internal, "failed to get activity: %v", err)	×
21	}
22
23	activityProto, err := s.adapter.ToActivityProto(a)	×
24	if err != nil {	×
25	return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)	×
26	}	×
27
28	return &guardianv1beta1.GetActivityResponse{	×
29	Activity: activityProto,	×
30	}, nil	×
31	}
32
33	func (s GRPCServer) ListActivities(ctx context.Context, req guardianv1beta1.ListActivitiesRequest) (*guardianv1beta1.ListActivitiesResponse, error) {	×
34	filter := domain.ListProviderActivitiesFilter{	×
35	ProviderIDs: req.GetProviderIds(),	×
36	AccountIDs: req.GetAccountIds(),	×
37	ResourceIDs: req.GetResourceIds(),	×
38	Types: req.GetTypes(),	×
39	}	×
40	if req.GetTimestampGte() != nil {	×
41	t := req.GetTimestampGte().AsTime()	×
42	filter.TimestampGte = &t	×
43	}	×
44	if req.GetTimestampLte() != nil {	×
45	t := req.GetTimestampLte().AsTime()	×
46	filter.TimestampLte = &t	×
47	}	×
48
49	activities, err := s.activityService.Find(ctx, filter)	×
50	if err != nil {	×
51	return nil, status.Errorf(codes.Internal, "failed to list activities: %v", err)	×
52	}	×
53
54	activityProtos := []*guardianv1beta1.ProviderActivity{}	×
55	for _, a := range activities {	×
56	activityProto, err := s.adapter.ToActivityProto(a)	×
57	if err != nil {	×
58	return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)	×
59	}	×
60	activityProtos = append(activityProtos, activityProto)	×
61	}
62
63	return &guardianv1beta1.ListActivitiesResponse{	×
64	Activities: activityProtos,	×
65	}, nil	×
66	}
67
68	func (s GRPCServer) ImportActivities(ctx context.Context, req guardianv1beta1.ImportActivitiesRequest) (*guardianv1beta1.ImportActivitiesResponse, error) {	×
69	filter := domain.ListActivitiesFilter{	×
70	ProviderID: req.GetProviderId(),	×
71	ResourceIDs: req.GetResourceIds(),	×
72	AccountIDs: req.GetAccountIds(),	×
73	}	×
74	if req.GetTimestampGte() != nil {	×
75	t := req.GetTimestampGte().AsTime()	×
76	filter.TimestampGte = &t	×
77	}	×
78	if req.GetTimestampLte() != nil {	×
79	t := req.GetTimestampLte().AsTime()	×
80	filter.TimestampLte = &t	×
81	}	×
82
83	activities, err := s.activityService.Import(ctx, filter)	×
84	if err != nil {	×
85	return nil, status.Errorf(codes.Internal, "failed to import activities: %v", err)	×
86	}	×
87
88	activityProtos := []*guardianv1beta1.ProviderActivity{}	×
89	for _, a := range activities {	×
90	activity, err := s.adapter.ToActivityProto(a)	×
91	if err != nil {	×
92	return nil, status.Errorf(codes.Internal, "failed to parse proto: %v", err)	×
93	}	×
94
95	activityProtos = append(activityProtos, activity)	×
96	}
97
98	return &guardianv1beta1.ImportActivitiesResponse{	×
99	Activities: activityProtos,	×
100	}, nil	×
101	}

goto / guardian / 5781074449

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous