neptune

var NeptuneCalls = []types.AWSService{
	{
		Name: "neptune:DescribeDBClusters",
		Call: func(ctx context.Context, sess *session.Session) (interface{}, error) {
			var allClusters []npCluster
			var lastErr error

			for _, region := range types.Regions {
				svc := neptune.New(sess, &aws.Config{Region: aws.String(region)})
				var marker *string
				for {
					input := &neptune.DescribeDBClustersInput{}
					if marker != nil {
						input.Marker = marker
					}
					output, err := svc.DescribeDBClustersWithContext(ctx, input)
					if err != nil {
						lastErr = err
						utils.HandleAWSError(false, "neptune:DescribeDBClusters", err)
						break
					}
					for _, cluster := range output.DBClusters {
						if cluster != nil {
							allClusters = append(allClusters, extractCluster(cluster, region))
						}
					}
					if output.Marker == nil {
						break
					}
					marker = output.Marker
				}
			}

			if len(allClusters) == 0 && lastErr != nil {
				return nil, lastErr
			}
			return allClusters, nil
		},
		Process: func(output interface{}, err error, debug bool) []types.ScanResult {
			var results []types.ScanResult

			if err != nil {
				utils.HandleAWSError(debug, "neptune:DescribeDBClusters", err)
				return []types.ScanResult{
					{
						ServiceName: "Neptune",
						MethodName:  "neptune:DescribeDBClusters",
						Error:       err,
						Timestamp:   time.Now(),
					},
				}
			}

			clusters, ok := output.([]npCluster)
			if !ok {
				utils.HandleAWSError(debug, "neptune:DescribeDBClusters", fmt.Errorf("unexpected output type %T", output))
				return results
			}

			for _, c := range clusters {
				results = append(results, types.ScanResult{
					ServiceName:  "Neptune",
					MethodName:   "neptune:DescribeDBClusters",
					ResourceType: "db-cluster",
					ResourceName: c.DBClusterIdentifier,
					Details: map[string]interface{}{
						"DBClusterIdentifier":              c.DBClusterIdentifier,
						"DBClusterArn":                     c.DBClusterArn,
						"Status":                           c.Status,
						"Engine":                           c.Engine,
						"EngineVersion":                    c.EngineVersion,
						"Endpoint":                         c.Endpoint,
						"ReaderEndpoint":                   c.ReaderEndpoint,
						"Port":                             c.Port,
						"MultiAZ":                          c.MultiAZ,
						"StorageEncrypted":                 c.StorageEncrypted,
						"KmsKeyId":                         c.KmsKeyId,
						"DeletionProtection":               c.DeletionProtection,
						"IAMDatabaseAuthenticationEnabled": c.IAMDatabaseAuthenticationEnabled,
						"DBClusterParameterGroup":          c.DBClusterParameterGroup,
						"ClusterCreateTime":                c.ClusterCreateTime,
						"Region":                           c.Region,
					},
					Timestamp: time.Now(),
				})

				utils.PrintResult(debug, "", "neptune:DescribeDBClusters",
					fmt.Sprintf("Neptune DB Cluster: %s (Status: %s, Engine: %s %s, Region: %s)", utils.ColorizeItem(c.DBClusterIdentifier), c.Status, c.Engine, c.EngineVersion, c.Region), nil)
			}
			return results
		},
		ModuleName: types.DefaultModuleName,
	},
	{
		Name: "neptune:DescribeDBInstances",
		Call: func(ctx context.Context, sess *session.Session) (interface{}, error) {
			var allInstances []npInstance
			var lastErr error

			for _, region := range types.Regions {
				svc := neptune.New(sess, &aws.Config{Region: aws.String(region)})
				var marker *string
				for {
					input := &neptune.DescribeDBInstancesInput{}
					if marker != nil {
						input.Marker = marker
					}
					output, err := svc.DescribeDBInstancesWithContext(ctx, input)
					if err != nil {
						lastErr = err
						utils.HandleAWSError(false, "neptune:DescribeDBInstances", err)
						break
					}
					for _, instance := range output.DBInstances {
						if instance != nil {
							allInstances = append(allInstances, extractInstance(instance, region))
						}
					}
					if output.Marker == nil {
						break
					}
					marker = output.Marker
				}
			}

			if len(allInstances) == 0 && lastErr != nil {
				return nil, lastErr
			}
			return allInstances, nil
		},
		Process: func(output interface{}, err error, debug bool) []types.ScanResult {
			var results []types.ScanResult

			if err != nil {
				utils.HandleAWSError(debug, "neptune:DescribeDBInstances", err)
				return []types.ScanResult{
					{
						ServiceName: "Neptune",
						MethodName:  "neptune:DescribeDBInstances",
						Error:       err,
						Timestamp:   time.Now(),
					},
				}
			}

			instances, ok := output.([]npInstance)
			if !ok {
				utils.HandleAWSError(debug, "neptune:DescribeDBInstances", fmt.Errorf("unexpected output type %T", output))
				return results
			}

			for _, i := range instances {
				results = append(results, types.ScanResult{
					ServiceName:  "Neptune",
					MethodName:   "neptune:DescribeDBInstances",
					ResourceType: "db-instance",
					ResourceName: i.DBInstanceIdentifier,
					Details: map[string]interface{}{
						"DBInstanceIdentifier":    i.DBInstanceIdentifier,
						"DBInstanceArn":           i.DBInstanceArn,
						"DBInstanceClass":         i.DBInstanceClass,
						"Engine":                  i.Engine,
						"EngineVersion":           i.EngineVersion,
						"DBInstanceStatus":        i.DBInstanceStatus,
						"EndpointAddress":         i.EndpointAddress,
						"EndpointPort":            i.EndpointPort,
						"DBClusterIdentifier":     i.DBClusterIdentifier,
						"AvailabilityZone":        i.AvailabilityZone,
						"PubliclyAccessible":      i.PubliclyAccessible,
						"StorageEncrypted":        i.StorageEncrypted,
						"AutoMinorVersionUpgrade": i.AutoMinorVersionUpgrade,
						"Region":                  i.Region,
					},
					Timestamp: time.Now(),
				})

				utils.PrintResult(debug, "", "neptune:DescribeDBInstances",
					fmt.Sprintf("Neptune DB Instance: %s (Status: %s, Class: %s, Cluster: %s, Region: %s)", utils.ColorizeItem(i.DBInstanceIdentifier), i.DBInstanceStatus, i.DBInstanceClass, i.DBClusterIdentifier, i.Region), nil)
			}
			return results
		},
		ModuleName: types.DefaultModuleName,
	},
	{
		Name: "neptune:DescribeDBClusterParameterGroups",
		Call: func(ctx context.Context, sess *session.Session) (interface{}, error) {
			var allGroups []npParameterGroup
			var lastErr error

			for _, region := range types.Regions {
				svc := neptune.New(sess, &aws.Config{Region: aws.String(region)})
				var marker *string
				for {
					input := &neptune.DescribeDBClusterParameterGroupsInput{}
					if marker != nil {
						input.Marker = marker
					}
					output, err := svc.DescribeDBClusterParameterGroupsWithContext(ctx, input)
					if err != nil {
						lastErr = err
						utils.HandleAWSError(false, "neptune:DescribeDBClusterParameterGroups", err)
						break
					}
					for _, pg := range output.DBClusterParameterGroups {
						if pg != nil {
							allGroups = append(allGroups, extractParameterGroup(pg, region))
						}
					}
					if output.Marker == nil {
						break
					}
					marker = output.Marker
				}
			}

			if len(allGroups) == 0 && lastErr != nil {
				return nil, lastErr
			}
			return allGroups, nil
		},
		Process: func(output interface{}, err error, debug bool) []types.ScanResult {
			var results []types.ScanResult

			if err != nil {
				utils.HandleAWSError(debug, "neptune:DescribeDBClusterParameterGroups", err)
				return []types.ScanResult{
					{
						ServiceName: "Neptune",
						MethodName:  "neptune:DescribeDBClusterParameterGroups",
						Error:       err,
						Timestamp:   time.Now(),
					},
				}
			}

			groups, ok := output.([]npParameterGroup)
			if !ok {
				utils.HandleAWSError(debug, "neptune:DescribeDBClusterParameterGroups", fmt.Errorf("unexpected output type %T", output))
				return results
			}

			for _, g := range groups {
				results = append(results, types.ScanResult{
					ServiceName:  "Neptune",
					MethodName:   "neptune:DescribeDBClusterParameterGroups",
					ResourceType: "db-cluster-parameter-group",
					ResourceName: g.DBClusterParameterGroupName,
					Details: map[string]interface{}{
						"DBClusterParameterGroupName": g.DBClusterParameterGroupName,
						"DBClusterParameterGroupArn":  g.DBClusterParameterGroupArn,
						"Description":                 g.Description,
						"DBParameterGroupFamily":      g.DBParameterGroupFamily,
						"Region":                      g.Region,
					},
					Timestamp: time.Now(),
				})

				utils.PrintResult(debug, "", "neptune:DescribeDBClusterParameterGroups",
					fmt.Sprintf("Neptune Cluster Parameter Group: %s (Family: %s, Region: %s)", utils.ColorizeItem(g.DBClusterParameterGroupName), g.DBParameterGroupFamily, g.Region), nil)
			}
			return results
		},
		ModuleName: types.DefaultModuleName,
	},
}