Create an inspection template

  using 
  
  Google.Api.Gax.ResourceNames 
 
 ; 
 using 
  
  Google.Cloud.Dlp.V2 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 InspectTemplateCreate 
 { 
  
 public 
  
 static 
  
 InspectTemplate 
  
 Create 
 ( 
  
 string 
  
 projectId 
 , 
  
 string 
  
 templateId 
 , 
  
 string 
  
 displayName 
 , 
  
 string 
  
 description 
 , 
  
  Likelihood 
 
  
 likelihood 
 , 
  
 int 
  
 maxFindings 
 , 
  
 bool 
  
 includeQuote 
 ) 
  
 { 
  
 var 
  
 client 
  
 = 
  
  DlpServiceClient 
 
 . 
  Create 
 
 (); 
  
 var 
  
 request 
  
 = 
  
 new 
  
  CreateInspectTemplateRequest 
 
  
 { 
  
 Parent 
  
 = 
  
 new 
  
  LocationName 
 
 ( 
 projectId 
 , 
  
 "global" 
 ). 
 ToString 
 (), 
  
 InspectTemplate 
  
 = 
  
 new 
  
  InspectTemplate 
 
  
 { 
  
 DisplayName 
  
 = 
  
 displayName 
 , 
  
 Description 
  
 = 
  
 description 
 , 
  
 InspectConfig 
  
 = 
  
 new 
  
  InspectConfig 
 
  
 { 
  
 MinLikelihood 
  
 = 
  
 likelihood 
 , 
  
 Limits 
  
 = 
  
 new 
  
 InspectConfig 
 . 
 Types 
 . 
 FindingLimits 
  
 { 
  
 MaxFindingsPerRequest 
  
 = 
  
 maxFindings 
  
 }, 
  
 IncludeQuote 
  
 = 
  
 includeQuote 
  
 }, 
  
 }, 
  
 TemplateId 
  
 = 
  
 templateId 
  
 }; 
  
 var 
  
 response 
  
 = 
  
 client 
 . 
 CreateInspectTemplate 
 ( 
 request 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Successfully created template {response.Name}." 
 ); 
  
 return 
  
 response 
 ; 
  
 } 
 } 
 

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 dlp 
  
 "cloud.google.com/go/dlp/apiv2" 
  
 "cloud.google.com/go/dlp/apiv2/dlppb" 
 ) 
 // createInspectTemplate creates a template with the given configuration. 
 func 
  
 createInspectTemplate 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
  
 string 
 , 
  
 templateID 
 , 
  
 displayName 
 , 
  
 description 
  
 string 
 , 
  
 infoTypeNames 
  
 [] 
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "my-project-id" 
  
 // templateID := "my-template" 
  
 // displayName := "My Template" 
  
 // description := "My template description" 
  
 // infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"} 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 dlp 
 . 
  NewClient 
 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "dlp.NewClient: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
  Close 
 
 () 
  
 // Convert the info type strings to a list of InfoTypes. 
  
 var 
  
 infoTypes 
  
 [] 
 * 
 dlppb 
 . 
 InfoType 
  
 for 
  
 _ 
 , 
  
 it 
  
 := 
  
 range 
  
 infoTypeNames 
  
 { 
  
 infoTypes 
  
 = 
  
 append 
 ( 
 infoTypes 
 , 
  
& dlppb 
 . 
 InfoType 
 { 
 Name 
 : 
  
 it 
 }) 
  
 } 
  
 // Create a configured request. 
  
 req 
  
 := 
  
& dlppb 
 . 
 CreateInspectTemplateRequest 
 { 
  
 Parent 
 : 
  
 fmt 
 . 
 Sprintf 
 ( 
 "projects/%s/locations/global" 
 , 
  
 projectID 
 ), 
  
 TemplateId 
 : 
  
 templateID 
 , 
  
 InspectTemplate 
 : 
  
& dlppb 
 . 
 InspectTemplate 
 { 
  
 DisplayName 
 : 
  
 displayName 
 , 
  
 Description 
 : 
  
 description 
 , 
  
 InspectConfig 
 : 
  
& dlppb 
 . 
 InspectConfig 
 { 
  
 InfoTypes 
 : 
  
 infoTypes 
 , 
  
 MinLikelihood 
 : 
  
 dlppb 
 . 
  Likelihood_POSSIBLE 
 
 , 
  
 Limits 
 : 
  
& dlppb 
 . 
 InspectConfig_FindingLimits 
 { 
  
 MaxFindingsPerRequest 
 : 
  
 10 
 , 
  
 }, 
  
 }, 
  
 }, 
  
 } 
  
 // Send the request. 
  
 resp 
 , 
  
 err 
  
 := 
  
 client 
 . 
 CreateInspectTemplate 
 ( 
 ctx 
 , 
  
 req 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "CreateInspectTemplate: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // Print the result. 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Successfully created inspect template: %v" 
 , 
  
 resp 
 . 
 GetName 
 ()) 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.cloud.dlp.v2. DlpServiceClient 
 
 ; 
 import 
  
 com.google.privacy.dlp.v2. CreateInspectTemplateRequest 
 
 ; 
 import 
  
 com.google.privacy.dlp.v2. InfoType 
 
 ; 
 import 
  
 com.google.privacy.dlp.v2. InspectConfig 
 
 ; 
 import 
  
 com.google.privacy.dlp.v2. InspectTemplate 
 
 ; 
 import 
  
 com.google.privacy.dlp.v2. LocationName 
 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.util.List 
 ; 
 import 
  
 java.util.stream.Collectors 
 ; 
 import 
  
 java.util.stream.Stream 
 ; 
 class 
 TemplatesCreate 
  
 { 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 throws 
  
 Exception 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 String 
  
 projectId 
  
 = 
  
 "your-project-id" 
 ; 
  
 createInspectTemplate 
 ( 
 projectId 
 ); 
  
 } 
  
 // Creates a template to persist configuration information 
  
 public 
  
 static 
  
 void 
  
 createInspectTemplate 
 ( 
 String 
  
 projectId 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // Initialize client that will be used to send requests. This client only needs to be created 
  
 // once, and can be reused for multiple requests. After completing all of your requests, call 
  
 // the "close" method on the client to safely clean up any remaining background resources. 
  
 try 
  
 ( 
  DlpServiceClient 
 
  
 dlpServiceClient 
  
 = 
  
  DlpServiceClient 
 
 . 
 create 
 ()) 
  
 { 
  
 // Specify the type of info the inspection will look for. 
  
 // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types 
  
 List<InfoType> 
  
 infoTypes 
  
 = 
  
 Stream 
 . 
 of 
 ( 
 "PHONE_NUMBER" 
 , 
  
 "EMAIL_ADDRESS" 
 , 
  
 "CREDIT_CARD_NUMBER" 
 ) 
  
 . 
 map 
 ( 
 it 
  
 - 
>  
  InfoType 
 
 . 
 newBuilder 
 (). 
 setName 
 ( 
 it 
 ). 
 build 
 ()) 
  
 . 
 collect 
 ( 
 Collectors 
 . 
 toList 
 ()); 
  
 // Construct the inspection configuration for the template 
  
  InspectConfig 
 
  
 inspectConfig 
  
 = 
  
  InspectConfig 
 
 . 
 newBuilder 
 (). 
 addAllInfoTypes 
 ( 
 infoTypes 
 ). 
 build 
 (); 
  
 // Optionally set a display name and a description for the template 
  
 String 
  
 displayName 
  
 = 
  
 "Inspection Config Template" 
 ; 
  
 String 
  
 description 
  
 = 
  
 "Save configuration for future inspection jobs" 
 ; 
  
 // Build the template 
  
  InspectTemplate 
 
  
 inspectTemplate 
  
 = 
  
  InspectTemplate 
 
 . 
 newBuilder 
 () 
  
 . 
 setInspectConfig 
 ( 
 inspectConfig 
 ) 
  
 . 
 setDisplayName 
 ( 
 displayName 
 ) 
  
 . 
 setDescription 
 ( 
 description 
 ) 
  
 . 
 build 
 (); 
  
 // Create the request to be sent by the client 
  
  CreateInspectTemplateRequest 
 
  
 createInspectTemplateRequest 
  
 = 
  
  CreateInspectTemplateRequest 
 
 . 
 newBuilder 
 () 
  
 . 
 setParent 
 ( 
  LocationName 
 
 . 
 of 
 ( 
 projectId 
 , 
  
 "global" 
 ). 
 toString 
 ()) 
  
 . 
 setInspectTemplate 
 ( 
 inspectTemplate 
 ) 
  
 . 
 build 
 (); 
  
 // Send the request to the API and process the response 
  
  InspectTemplate 
 
  
 response 
  
 = 
  
 dlpServiceClient 
 . 
 createInspectTemplate 
 ( 
 createInspectTemplateRequest 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Template created: %s" 
 , 
  
 response 
 . 
  getName 
 
 ()); 
  
 } 
  
 } 
 } 
 

  // Imports the Google Cloud Data Loss Prevention library 
 const 
  
 DLP 
  
 = 
  
 require 
 ( 
 ' @google-cloud/dlp 
' 
 ); 
 // Instantiates a client 
 const 
  
 dlp 
  
 = 
  
 new 
  
 DLP 
 . 
  DlpServiceClient 
 
 (); 
 // The project ID to run the API call under 
 // const projectId = 'my-project'; 
 // The minimum likelihood required before returning a match 
 // const minLikelihood = 'LIKELIHOOD_UNSPECIFIED'; 
 // The maximum number of findings to report per request (0 = server maximum) 
 // const maxFindings = 0; 
 // The infoTypes of information to match 
 // const infoTypes = [{ name: 'PHONE_NUMBER' }, { name: 'EMAIL_ADDRESS' }, { name: 'CREDIT_CARD_NUMBER' }]; 
 // Whether to include the matching string 
 // const includeQuote = true; 
 // (Optional) The name of the template to be created. 
 // const templateId = 'my-template'; 
 // (Optional) The human-readable name to give the template 
 // const displayName = 'My template'; 
 async 
  
 function 
  
 createInspectTemplate 
 () 
  
 { 
  
 // Construct the inspection configuration for the template 
  
 const 
  
 inspectConfig 
  
 = 
  
 { 
  
 infoTypes 
 : 
  
 infoTypes 
 , 
  
 minLikelihood 
 : 
  
 minLikelihood 
 , 
  
 includeQuote 
 : 
  
 includeQuote 
 , 
  
 limits 
 : 
  
 { 
  
 maxFindingsPerRequest 
 : 
  
 maxFindings 
 , 
  
 }, 
  
 }; 
  
 // Construct template-creation request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 parent 
 : 
  
 `projects/ 
 ${ 
 projectId 
 } 
 /locations/global` 
 , 
  
 inspectTemplate 
 : 
  
 { 
  
 inspectConfig 
 : 
  
 inspectConfig 
 , 
  
 displayName 
 : 
  
 displayName 
 , 
  
 }, 
  
 templateId 
 : 
  
 templateId 
 , 
  
 }; 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 dlp 
 . 
 createInspectTemplate 
 ( 
 request 
 ); 
  
 const 
  
 templateName 
  
 = 
  
 response 
 . 
 name 
 ; 
  
 console 
 . 
 log 
 ( 
 `Successfully created template 
 ${ 
 templateName 
 } 
 .` 
 ); 
 } 
 createInspectTemplate 
 (); 
 

  use Google\Cloud\Dlp\V2\Client\DlpServiceClient; 
 use Google\Cloud\Dlp\V2\CreateInspectTemplateRequest; 
 use Google\Cloud\Dlp\V2\InfoType; 
 use Google\Cloud\Dlp\V2\InspectConfig; 
 use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits; 
 use Google\Cloud\Dlp\V2\InspectTemplate; 
 use Google\Cloud\Dlp\V2\Likelihood; 
 /** 
 * Create a new DLP inspection configuration template. 
 * 
 * @param string $callingProjectId project ID to run the API call under 
 * @param string $templateId       name of the template to be created 
 * @param string $displayName      (Optional) The human-readable name to give the template 
 * @param string $description      (Optional) A description for the trigger to be created 
 * @param int    $maxFindings      (Optional) The maximum number of findings to report per request (0 = server maximum) 
 */ 
 function create_inspect_template( 
 string $callingProjectId, 
 string $templateId, 
 string $displayName = '', 
 string $description = '', 
 int $maxFindings = 0 
 ): void { 
 // Instantiate a client. 
 $dlp = new DlpServiceClient(); 
 // ----- Construct inspection config ----- 
 // The infoTypes of information to match 
 $personNameInfoType = (new InfoType()) 
 ->setName('PERSON_NAME'); 
 $phoneNumberInfoType = (new InfoType()) 
 ->setName('PHONE_NUMBER'); 
 $infoTypes = [$personNameInfoType, $phoneNumberInfoType]; 
 // Whether to include the matching string in the response 
 $includeQuote = true; 
 // The minimum likelihood required before returning a match 
 $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED; 
 // Specify finding limits 
 $limits = (new FindingLimits()) 
 ->setMaxFindingsPerRequest($maxFindings); 
 // Create the configuration object 
 $inspectConfig = (new InspectConfig()) 
 ->setMinLikelihood($minLikelihood) 
 ->setLimits($limits) 
 ->setInfoTypes($infoTypes) 
 ->setIncludeQuote($includeQuote); 
 // Construct inspection template 
 $inspectTemplate = (new InspectTemplate()) 
 ->setInspectConfig($inspectConfig) 
 ->setDisplayName($displayName) 
 ->setDescription($description); 
 // Run request 
 $parent = "projects/$callingProjectId/locations/global"; 
 $createInspectTemplateRequest = (new CreateInspectTemplateRequest()) 
 ->setParent($parent) 
 ->setInspectTemplate($inspectTemplate) 
 ->setTemplateId($templateId); 
 $template = $dlp->createInspectTemplate($createInspectTemplateRequest); 
 // Print results 
 printf('Successfully created template %s' . PHP_EOL, $template->getName()); 
 } 
 

  from 
  
 typing 
  
 import 
 List 
 from 
  
 typing 
  
 import 
 Optional 
 import 
  
 google.cloud.dlp 
 def 
  
 create_inspect_template 
 ( 
 project 
 : 
 str 
 , 
 info_types 
 : 
 List 
 [ 
 str 
 ], 
 template_id 
 : 
 Optional 
 [ 
 str 
 ] 
 = 
 None 
 , 
 display_name 
 : 
 Optional 
 [ 
 str 
 ] 
 = 
 None 
 , 
 min_likelihood 
 : 
 Optional 
 [ 
 int 
 ] 
 = 
 None 
 , 
 max_findings 
 : 
 Optional 
 [ 
 int 
 ] 
 = 
 None 
 , 
 include_quote 
 : 
 Optional 
 [ 
 bool 
 ] 
 = 
 None 
 , 
 ) 
 - 
> None 
 : 
  
 """Creates a Data Loss Prevention API inspect template. 
 Args: 
 project: The Google Cloud project id to use as a parent resource. 
 info_types: A list of strings representing info types to look for. 
 A full list of info type categories can be fetched from the API. 
 template_id: The id of the template. If omitted, an id will be randomly 
 generated. 
 display_name: The optional display name of the template. 
 min_likelihood: A string representing the minimum likelihood threshold 
 that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED', 
 'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'. 
 max_findings: The maximum number of findings to report; 0 = no maximum. 
 include_quote: Boolean for whether to display a quote of the detected 
 information in the results. 
 Returns: 
 None; the response from the API is printed to the terminal. 
 """ 
 # Instantiate a client. 
 dlp 
 = 
 google 
 . 
 cloud 
 . 
  dlp_v2 
 
 . 
  DlpServiceClient 
 
 () 
 # Prepare info_types by converting the list of strings into a list of 
 # dictionaries (protos are also accepted). 
 info_types 
 = 
 [{ 
 "name" 
 : 
 info_type 
 } 
 for 
 info_type 
 in 
 info_types 
 ] 
 # Construct the configuration dictionary. Keys which are None may 
 # optionally be omitted entirely. 
 inspect_config 
 = 
 { 
 "info_types" 
 : 
 info_types 
 , 
 "min_likelihood" 
 : 
 min_likelihood 
 , 
 "include_quote" 
 : 
 include_quote 
 , 
 "limits" 
 : 
 { 
 "max_findings_per_request" 
 : 
 max_findings 
 }, 
 } 
 inspect_template 
 = 
 { 
 "inspect_config" 
 : 
 inspect_config 
 , 
 "display_name" 
 : 
 display_name 
 , 
 } 
 # Convert the project id into a full resource id. 
 parent 
 = 
 f 
 "projects/ 
 { 
 project 
 } 
 " 
 # Call the API. 
 response 
 = 
 dlp 
 . 
  create_inspect_template 
 
 ( 
 request 
 = 
 { 
 "parent" 
 : 
 parent 
 , 
 "inspect_template" 
 : 
 inspect_template 
 , 
 "template_id" 
 : 
 template_id 
 , 
 } 
 ) 
 print 
 ( 
 f 
 "Successfully created template 
 { 
 response 
 . 
 name 
 } 
 " 
 )