Send events

  { 
  
 "operatingAccount" 
 : 
  
 { 
  
 "accountType" 
 : 
  
 " OPERATING_ACCOUNT_TYPE 
" 
 , 
  
 "accountId" 
 : 
  
 " OPERATING_ACCOUNT_ID 
" 
  
 }, 
  
 "loginAccount" 
 : 
  
 { 
  
 "accountType" 
 : 
  
 " LOGIN_ACCOUNT_TYPE 
" 
 , 
  
 "accountId" 
 : 
  
 " LOGIN_ACCOUNT_ID 
" 
  
 }, 
  
 "productDestinationId" 
 : 
  
 " PRODUCT_DESTINATION_ID 
" 
 } 
 

  { 
  
 "operatingAccount" 
 : 
  
 { 
  
 "accountType" 
 : 
  
 " OPERATING_ACCOUNT_TYPE 
" 
 , 
  
 "accountId" 
 : 
  
 " OPERATING_ACCOUNT_ID 
" 
  
 }, 
  
 "loginAccount" 
 : 
  
 { 
  
 "accountType" 
 : 
  
 " DATA_PARTNER 
" 
 , 
  
 "accountId" 
 : 
  
 " DATA_PARTNER_ACCOUNT_ID 
" 
  
 }, 
  
 "linkedAccount" 
 : 
  
 { 
  
 "accountType" 
 : 
  
 " LINKED_ACCOUNT_TYPE 
" 
 , 
  
 "accountId" 
 : 
  
 " LINKED_ACCOUNT_ID 
" 
  
 }, 
  
 "productDestinationId" 
 : 
  
 " PRODUCT_DESTINATION_ID 
" 
 } 
 

 // Copyright 2025 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     http://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 using 
  
 System 
 . 
 Text 
 . 
 Json 
 ; 
 using 
  
 CommandLine 
 ; 
 using 
  
 Google 
 . 
 Ads 
 . 
 DataManager 
 . 
 Util 
 ; 
 using 
  
 Google 
 . 
 Ads 
 . 
 DataManager 
 . 
 V1 
 ; 
 using 
  
 Google 
 . 
 Protobuf 
 . 
 WellKnownTypes 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Ads 
 . 
 DataManager 
 . 
 V1 
 . 
 ProductAccount 
 . 
 Types 
 ; 
 namespace 
  
 Google 
 . 
 Ads 
 . 
 DataManager 
 . 
 Samples 
 { 
  
 // <summary> 
  
 // Sends an <see cref="IngestEventsRequest" /> without using encryption. 
  
 // 
  
 // Event data is read from a data file. See the <c>events_1.json</c> file in the 
  
 // <c>sampledata</c> directory for an example. 
  
 // </summary> 
  
 public 
  
 class 
  
 IngestEvents 
  
 { 
  
 private 
  
 static 
  
 readonly 
  
 int 
  
 MaxEventsPerRequest 
  
 = 
  
 2 
 _000 
 ; 
  
 [ 
 Verb 
 ( 
 "ingest-events" 
 , 
  
 HelpText 
  
 = 
  
 "Sends an IngestEventsRequest without using encryption." 
 )] 
  
 public 
  
 class 
  
 Options 
  
 { 
  
 [ 
 Option 
 ( 
  
 "operatingAccountType" 
 , 
  
 Required 
  
 = 
  
 true 
 , 
  
 HelpText 
  
 = 
  
 "Account type of the operating account" 
  
 )] 
  
 public 
  
 AccountType 
  
 OperatingAccountType 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 [ 
 Option 
 ( 
  
 "operatingAccountId" 
 , 
  
 Required 
  
 = 
  
 true 
 , 
  
 HelpText 
  
 = 
  
 "ID of the operating account" 
  
 )] 
  
 public 
  
 string 
  
 OperatingAccountId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 = 
  
 null 
 !; 
  
 [ 
 Option 
 ( 
  
 "loginAccountType" 
 , 
  
 Required 
  
 = 
  
 false 
 , 
  
 HelpText 
  
 = 
  
 "Account type of the login account" 
  
 )] 
  
 public 
  
 AccountType 
 ? 
  
 LoginAccountType 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 [ 
 Option 
 ( 
 "loginAccountId" 
 , 
  
 Required 
  
 = 
  
 false 
 , 
  
 HelpText 
  
 = 
  
 "ID of the login account" 
 )] 
  
 public 
  
 string 
 ? 
  
 LoginAccountId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 [ 
 Option 
 ( 
  
 "linkedAccountProduct" 
 , 
  
 Required 
  
 = 
  
 false 
 , 
  
 HelpText 
  
 = 
  
 "Account type of the linked account" 
  
 )] 
  
 public 
  
 AccountType 
 ? 
  
 LinkedAccountType 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 [ 
 Option 
 ( 
 "linkedAccountId" 
 , 
  
 Required 
  
 = 
  
 false 
 , 
  
 HelpText 
  
 = 
  
 "ID of the linked account" 
 )] 
  
 public 
  
 string 
 ? 
  
 LinkedAccountId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 [ 
 Option 
 ( 
  
 "conversionActionId" 
 , 
  
 Required 
  
 = 
  
 true 
 , 
  
 HelpText 
  
 = 
  
 "ID of the conversion action" 
  
 )] 
  
 public 
  
 string 
  
 ConversionActionId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 = 
  
 null 
 !; 
  
 [ 
 Option 
 ( 
  
 "jsonFile" 
 , 
  
 Required 
  
 = 
  
 true 
 , 
  
 HelpText 
  
 = 
  
 "JSON file containing user data to ingest" 
  
 )] 
  
 public 
  
 string 
  
 JsonFile 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 = 
  
 null 
 !; 
  
 [ 
 Option 
 ( 
  
 "validateOnly" 
 , 
  
 Default 
  
 = 
  
 true 
 , 
  
 HelpText 
  
 = 
  
 "Whether to enable validateOnly on the request" 
  
 )] 
  
 public 
  
 bool 
  
 ValidateOnly 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 } 
  
 public 
  
 void 
  
 Run 
 ( 
 Options 
  
 options 
 ) 
  
 { 
  
 RunExample 
 ( 
  
 options 
 . 
 OperatingAccountType 
 , 
  
 options 
 . 
 OperatingAccountId 
 , 
  
 options 
 . 
 LoginAccountType 
 , 
  
 options 
 . 
 LoginAccountId 
 , 
  
 options 
 . 
 LinkedAccountType 
 , 
  
 options 
 . 
 LinkedAccountId 
 , 
  
 options 
 . 
 ConversionActionId 
 , 
  
 options 
 . 
 JsonFile 
 , 
  
 options 
 . 
 ValidateOnly 
  
 ); 
  
 } 
  
 private 
  
 void 
  
 RunExample 
 ( 
  
 AccountType 
  
 operatingAccountType 
 , 
  
 string 
  
 operatingAccountId 
 , 
  
 AccountType 
 ? 
  
 loginAccountType 
 , 
  
 string 
 ? 
  
 loginAccountId 
 , 
  
 AccountType 
 ? 
  
 linkedAccountType 
 , 
  
 string 
 ? 
  
 linkedAccountId 
 , 
  
 string 
  
 conversionActionId 
 , 
  
 string 
  
 jsonFile 
 , 
  
 bool 
  
 validateOnly 
  
 ) 
  
 { 
  
 if 
  
 ( 
 loginAccountId 
  
 == 
  
 null 
  
 ^ 
  
 loginAccountType 
  
 == 
  
 null 
 ) 
  
 { 
  
 throw 
  
 new 
  
 ArgumentException 
 ( 
  
 "Must specify either both or neither of login account ID and login account " 
  
 + 
  
 "type" 
  
 ); 
  
 } 
  
 if 
  
 ( 
 linkedAccountId 
  
 == 
  
 null 
  
 ^ 
  
 linkedAccountType 
  
 == 
  
 null 
 ) 
  
 { 
  
 throw 
  
 new 
  
 ArgumentException 
 ( 
  
 "Must specify either both or neither of linked account ID and linked account " 
  
 + 
  
 "type" 
  
 ); 
  
 } 
  
 // Reads member data from the data file. 
  
 List<EventRecord> 
  
 eventRecords 
  
 = 
  
 ReadEventData 
 ( 
 jsonFile 
 ); 
  
 // Gets an instance of the UserDataFormatter for normalizing and formatting the data. 
  
 UserDataFormatter 
  
 userDataFormatter 
  
 = 
  
 new 
  
 UserDataFormatter 
 (); 
  
 // Builds the events collection for the request. 
  
 var 
  
 events 
  
 = 
  
 new 
  
 List<Event> 
 (); 
  
 foreach 
  
 ( 
 var 
  
 eventRecord 
  
 in 
  
 eventRecords 
 ) 
  
 { 
  
 var 
  
 eventBuilder 
  
 = 
  
 new 
  
 Event 
 (); 
  
 try 
  
 { 
  
 eventBuilder 
 . 
 EventTimestamp 
  
 = 
  
 Timestamp 
 . 
 FromDateTime 
 ( 
  
 DateTime 
 . 
 Parse 
 ( 
 eventRecord 
 . 
 Timestamp 
  
 ?? 
  
 "" 
 ). 
 ToUniversalTime 
 () 
  
 ); 
  
 } 
  
 catch 
  
 ( 
 FormatException 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
  
 $ 
 "Skipping event with invalid timestamp: {eventRecord.Timestamp}" 
  
 ); 
  
 continue 
 ; 
  
 } 
  
 if 
  
 ( 
 string 
 . 
 IsNullOrEmpty 
 ( 
 eventRecord 
 . 
 TransactionId 
 )) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 "Skipping event with no transaction ID" 
 ); 
  
 continue 
 ; 
  
 } 
  
 eventBuilder 
 . 
 TransactionId 
  
 = 
  
 eventRecord 
 . 
 TransactionId 
 ; 
  
 if 
  
 (! 
 string 
 . 
 IsNullOrEmpty 
 ( 
 eventRecord 
 . 
 EventSource 
 )) 
  
 { 
  
 if 
  
 ( 
  
 System 
 . 
 Enum 
 . 
 TryParse 
 ( 
  
 eventRecord 
 . 
 EventSource 
 , 
  
 true 
 , 
  
 out 
  
 EventSource 
  
 eventSource 
  
 ) 
  
 ) 
  
 { 
  
 eventBuilder 
 . 
 EventSource 
  
 = 
  
 eventSource 
 ; 
  
 } 
  
 else 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
  
 $ 
 "Skipping event with invalid event source: {eventRecord.EventSource}" 
  
 ); 
  
 continue 
 ; 
  
 } 
  
 } 
  
 if 
  
 (! 
 string 
 . 
 IsNullOrEmpty 
 ( 
 eventRecord 
 . 
 Gclid 
 )) 
  
 { 
  
 eventBuilder 
 . 
 AdIdentifiers 
  
 = 
  
 new 
  
 AdIdentifiers 
  
 { 
  
 Gclid 
  
 = 
  
 eventRecord 
 . 
 Gclid 
  
 }; 
  
 } 
  
 if 
  
 (! 
 string 
 . 
 IsNullOrEmpty 
 ( 
 eventRecord 
 . 
 Currency 
 )) 
  
 { 
  
 eventBuilder 
 . 
 Currency 
  
 = 
  
 eventRecord 
 . 
 Currency 
 ; 
  
 } 
  
 if 
  
 ( 
 eventRecord 
 . 
 Value 
 . 
 HasValue 
 ) 
  
 { 
  
 eventBuilder 
 . 
 ConversionValue 
  
 = 
  
 eventRecord 
 . 
 Value 
 . 
 Value 
 ; 
  
 } 
  
 var 
  
 userDataBuilder 
  
 = 
  
 new 
  
 UserData 
 (); 
  
 // Adds a UserIdentifier for each valid email address for the eventRecord. 
  
 if 
  
 ( 
 eventRecord 
 . 
 Emails 
  
 != 
  
 null 
 ) 
  
 { 
  
 foreach 
  
 ( 
 var 
  
 email 
  
 in 
  
 eventRecord 
 . 
 Emails 
 ) 
  
 { 
  
 try 
  
 { 
  
 string 
  
 preparedEmail 
  
 = 
  
 userDataFormatter 
 . 
 ProcessEmailAddress 
 ( 
  
 email 
 , 
  
 UserDataFormatter 
 . 
 Encoding 
 . 
 Hex 
  
 ); 
  
 // Adds an email address identifier with the encoded email hash. 
  
 userDataBuilder 
 . 
 UserIdentifiers 
 . 
 Add 
 ( 
  
 new 
  
 UserIdentifier 
  
 { 
  
 EmailAddress 
  
 = 
  
 preparedEmail 
  
 } 
  
 ); 
  
 } 
  
 catch 
  
 ( 
 ArgumentException 
 ) 
  
 { 
  
 // Skips invalid input. 
  
 continue 
 ; 
  
 } 
  
 } 
  
 } 
  
 // Adds a UserIdentifier for each valid phone number for the eventRecord. 
  
 if 
  
 ( 
 eventRecord 
 . 
 PhoneNumbers 
  
 != 
  
 null 
 ) 
  
 { 
  
 foreach 
  
 ( 
 var 
  
 phoneNumber 
  
 in 
  
 eventRecord 
 . 
 PhoneNumbers 
 ) 
  
 { 
  
 try 
  
 { 
  
 string 
  
 preparedPhoneNumber 
  
 = 
  
 userDataFormatter 
 . 
 ProcessPhoneNumber 
 ( 
  
 phoneNumber 
 , 
  
 UserDataFormatter 
 . 
 Encoding 
 . 
 Hex 
  
 ); 
  
 // Adds a phone number identifier with the encoded phone hash. 
  
 userDataBuilder 
 . 
 UserIdentifiers 
 . 
 Add 
 ( 
  
 new 
  
 UserIdentifier 
  
 { 
  
 PhoneNumber 
  
 = 
  
 preparedPhoneNumber 
  
 } 
  
 ); 
  
 } 
  
 catch 
  
 ( 
 ArgumentException 
 ) 
  
 { 
  
 // Skips invalid input. 
  
 continue 
 ; 
  
 } 
  
 } 
  
 } 
  
 if 
  
 ( 
 userDataBuilder 
 . 
 UserIdentifiers 
 . 
 Any 
 ()) 
  
 { 
  
 eventBuilder 
 . 
 UserData 
  
 = 
  
 userDataBuilder 
 ; 
  
 } 
  
 events 
 . 
 Add 
 ( 
 eventBuilder 
 ); 
  
 } 
  
 // Builds the Destination for the request. 
  
 var 
  
 destinationBuilder 
  
 = 
  
 new 
  
 Destination 
  
 { 
  
 OperatingAccount 
  
 = 
  
 new 
  
 ProductAccount 
  
 { 
  
 AccountType 
  
 = 
  
 operatingAccountType 
 , 
  
 AccountId 
  
 = 
  
 operatingAccountId 
 , 
  
 }, 
  
 ProductDestinationId 
  
 = 
  
 conversionActionId 
 , 
  
 }; 
  
 if 
  
 ( 
 loginAccountType 
 . 
 HasValue 
 && 
 loginAccountId 
  
 != 
  
 null 
 ) 
  
 { 
  
 destinationBuilder 
 . 
 LoginAccount 
  
 = 
  
 new 
  
 ProductAccount 
  
 { 
  
 AccountType 
  
 = 
  
 loginAccountType 
 . 
 Value 
 , 
  
 AccountId 
  
 = 
  
 loginAccountId 
 , 
  
 }; 
  
 } 
  
 if 
  
 ( 
 linkedAccountType 
 . 
 HasValue 
 && 
 linkedAccountId 
  
 != 
  
 null 
 ) 
  
 { 
  
 destinationBuilder 
 . 
 LinkedAccount 
  
 = 
  
 new 
  
 ProductAccount 
  
 { 
  
 AccountType 
  
 = 
  
 linkedAccountType 
 . 
 Value 
 , 
  
 AccountId 
  
 = 
  
 linkedAccountId 
 , 
  
 }; 
  
 } 
  
 IngestionServiceClient 
  
 ingestionServiceClient 
  
 = 
  
 IngestionServiceClient 
 . 
 Create 
 (); 
  
 int 
  
 requestCount 
  
 = 
  
 0 
 ; 
  
 // Batches requests to send up to the maximum number of events per request. 
  
 for 
  
 ( 
 var 
  
 i 
  
 = 
  
 0 
 ; 
  
 i 
 < 
 events 
 . 
 Count 
 ; 
  
 i 
  
 += 
  
 MaxEventsPerRequest 
 ) 
  
 { 
  
 IEnumerable<Event> 
  
 batch 
  
 = 
  
 events 
 . 
 Skip 
 ( 
 i 
 ). 
 Take 
 ( 
 MaxEventsPerRequest 
 ); 
  
 requestCount 
 ++ 
 ; 
  
 var 
  
 request 
  
 = 
  
 new 
  
 IngestEventsRequest 
  
 { 
  
 Destinations 
  
 = 
  
 { 
  
 destinationBuilder 
  
 }, 
  
 // Adds events from the current batch. 
  
 Events 
  
 = 
  
 { 
  
 batch 
  
 }, 
  
 Consent 
  
 = 
  
 new 
  
 Consent 
  
 { 
  
 AdPersonalization 
  
 = 
  
 ConsentStatus 
 . 
 ConsentGranted 
 , 
  
 AdUserData 
  
 = 
  
 ConsentStatus 
 . 
 ConsentGranted 
 , 
  
 }, 
  
 // Sets validate_only. If true, then the Data Manager API only validates the 
  
 // request but doesn't apply changes. 
  
 ValidateOnly 
  
 = 
  
 validateOnly 
 , 
  
 Encoding 
  
 = 
  
 V1 
 . 
 Encoding 
 . 
 Hex 
 , 
  
 }; 
  
 // Sends the data to the Data Manager API. 
  
 IngestEventsResponse 
  
 response 
  
 = 
  
 ingestionServiceClient 
 . 
 IngestEvents 
 ( 
 request 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $ 
 "Response for request #{requestCount}:\n{response}" 
 ); 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 $ 
 "# of requests sent: {requestCount}" 
 ); 
  
 } 
  
 private 
  
 class 
  
 EventRecord 
  
 { 
  
 public 
  
 List<string> 
 ? 
  
 Emails 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 List<string> 
 ? 
  
 PhoneNumbers 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 string 
 ? 
  
 Timestamp 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 string 
 ? 
  
 TransactionId 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 string 
 ? 
  
 EventSource 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 double 
 ? 
  
 Value 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 string 
 ? 
  
 Currency 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 public 
  
 string 
 ? 
  
 Gclid 
  
 { 
  
 get 
 ; 
  
 set 
 ; 
  
 } 
  
 } 
  
 private 
  
 List<EventRecord> 
  
 ReadEventData 
 ( 
 string 
  
 jsonFile 
 ) 
  
 { 
  
 string 
  
 jsonString 
  
 = 
  
 File 
 . 
 ReadAllText 
 ( 
 jsonFile 
 ); 
  
 var 
  
 options 
  
 = 
  
 new 
  
 JsonSerializerOptions 
  
 { 
  
 PropertyNameCaseInsensitive 
  
 = 
  
 true 
  
 }; 
  
 return 
  
 JsonSerializer 
 . 
 Deserialize<List<EventRecord> 
> ( 
 jsonString 
 , 
  
 options 
 ) 
  
 ?? 
  
 new 
  
 List<EventRecord> 
 (); 
  
 } 
  
 } 
 } 
 
  IngestEvents 
 . 
 cs 
 
 

 // Copyright 2025 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     http://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 package 
  
 com.google.ads.datamanager.samples 
 ; 
 import 
  
 com.beust.jcommander.Parameter 
 ; 
 import 
  
 com.google.ads.datamanager.samples.common.BaseParamsConfig 
 ; 
 import 
  
 com.google.ads.datamanager.util.UserDataFormatter 
 ; 
 import 
  
 com.google.ads.datamanager.util.UserDataFormatter.Encoding 
 ; 
 import 
  
 com.google.ads.datamanager.v1.AdIdentifiers 
 ; 
 import 
  
 com.google.ads.datamanager.v1.Consent 
 ; 
 import 
  
 com.google.ads.datamanager.v1.ConsentStatus 
 ; 
 import 
  
 com.google.ads.datamanager.v1.Destination 
 ; 
 import 
  
 com.google.ads.datamanager.v1.Event 
 ; 
 import 
  
 com.google.ads.datamanager.v1.EventSource 
 ; 
 import 
  
 com.google.ads.datamanager.v1.IngestEventsRequest 
 ; 
 import 
  
 com.google.ads.datamanager.v1.IngestEventsResponse 
 ; 
 import 
  
 com.google.ads.datamanager.v1.IngestionServiceClient 
 ; 
 import 
  
 com.google.ads.datamanager.v1.ProductAccount 
 ; 
 import 
  
 com.google.ads.datamanager.v1.ProductAccount.AccountType 
 ; 
 import 
  
 com.google.ads.datamanager.v1.UserData 
 ; 
 import 
  
 com.google.ads.datamanager.v1.UserIdentifier 
 ; 
 import 
  
 com.google.common.base.Strings 
 ; 
 import 
  
 com.google.common.collect.Lists 
 ; 
 import 
  
 com.google.common.reflect.TypeToken 
 ; 
 import 
  
 com.google.gson.GsonBuilder 
 ; 
 import 
  
 com.google.protobuf.util.Timestamps 
 ; 
 import 
  
 java.io.BufferedReader 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.lang.reflect.Type 
 ; 
 import 
  
 java.nio.charset.StandardCharsets 
 ; 
 import 
  
 java.nio.file.Files 
 ; 
 import 
  
 java.nio.file.Paths 
 ; 
 import 
  
 java.text.ParseException 
 ; 
 import 
  
 java.util.ArrayList 
 ; 
 import 
  
 java.util.List 
 ; 
 import 
  
 java.util.logging.Logger 
 ; 
 /** 
 * Sends an {@link IngestEventsRequest} without using encryption. 
 * 
 * <p>Event data is read from a data file. See the {@code events_1.json} file in the {@code 
 * resources/sampledata} directory for a sample file. 
 */ 
 public 
  
 class 
 IngestEvents 
  
 { 
  
 private 
  
 static 
  
 final 
  
 Logger 
  
 LOGGER 
  
 = 
  
 Logger 
 . 
 getLogger 
 ( 
 IngestEvents 
 . 
 class 
 . 
 getName 
 ()); 
  
 /** The maximum number of events allowed per request. */ 
  
 private 
  
 static 
  
 final 
  
 int 
  
 MAX_EVENTS_PER_REQUEST 
  
 = 
  
 2_000 
 ; 
  
 private 
  
 static 
  
 final 
  
 class 
 ParamsConfig 
  
 extends 
  
 BaseParamsConfig<ParamsConfig> 
  
 { 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--operatingAccountType" 
 , 
  
 required 
  
 = 
  
 true 
 , 
  
 description 
  
 = 
  
 "Account type of the operating account" 
 ) 
  
 AccountType 
  
 operatingAccountType 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--operatingAccountId" 
 , 
  
 required 
  
 = 
  
 true 
 , 
  
 description 
  
 = 
  
 "ID of the operating account" 
 ) 
  
 String 
  
 operatingAccountId 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--loginAccountType" 
 , 
  
 required 
  
 = 
  
 false 
 , 
  
 description 
  
 = 
  
 "Account type of the login account" 
 ) 
  
 AccountType 
  
 loginAccountType 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--loginAccountId" 
 , 
  
 required 
  
 = 
  
 false 
 , 
  
 description 
  
 = 
  
 "ID of the login account" 
 ) 
  
 String 
  
 loginAccountId 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--linkedAccountType" 
 , 
  
 required 
  
 = 
  
 false 
 , 
  
 description 
  
 = 
  
 "Account type of the linked account" 
 ) 
  
 AccountType 
  
 linkedAccountType 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--linkedAccountId" 
 , 
  
 required 
  
 = 
  
 false 
 , 
  
 description 
  
 = 
  
 "ID of the linked account" 
 ) 
  
 String 
  
 linkedAccountId 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--conversionActionId" 
 , 
  
 required 
  
 = 
  
 true 
 , 
  
 description 
  
 = 
  
 "ID of the conversion action" 
 ) 
  
 String 
  
 conversionActionId 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--jsonFile" 
 , 
  
 required 
  
 = 
  
 true 
 , 
  
 description 
  
 = 
  
 "JSON file containing user data to ingest" 
 ) 
  
 String 
  
 jsonFile 
 ; 
  
 @Parameter 
 ( 
  
 names 
  
 = 
  
 "--validateOnly" 
 , 
  
 required 
  
 = 
  
 false 
 , 
  
 arity 
  
 = 
  
 1 
 , 
  
 description 
  
 = 
  
 "Whether to enable validateOnly on the request" 
 ) 
  
 boolean 
  
 validateOnly 
  
 = 
  
 true 
 ; 
  
 } 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 ParamsConfig 
  
 paramsConfig 
  
 = 
  
 new 
  
 ParamsConfig 
 (). 
 parseOrExit 
 ( 
 args 
 ); 
  
 if 
  
 (( 
 paramsConfig 
 . 
 loginAccountId 
  
 == 
  
 null 
 ) 
  
 != 
  
 ( 
 paramsConfig 
 . 
 loginAccountType 
  
 == 
  
 null 
 )) 
  
 { 
  
 throw 
  
 new 
  
 IllegalArgumentException 
 ( 
  
 "Must specify either both or neither of login account ID and login account type" 
 ); 
  
 } 
  
 if 
  
 (( 
 paramsConfig 
 . 
 linkedAccountId 
  
 == 
  
 null 
 ) 
  
 != 
  
 ( 
 paramsConfig 
 . 
 linkedAccountType 
  
 == 
  
 null 
 )) 
  
 { 
  
 throw 
  
 new 
  
 IllegalArgumentException 
 ( 
  
 "Must specify either both or neither of linked account ID and linked account type" 
 ); 
  
 } 
  
 new 
  
 IngestEvents 
 (). 
 runExample 
 ( 
 paramsConfig 
 ); 
  
 } 
  
 /** 
 * Runs the example. This sample assumes that the login and operating account are the same. 
 * 
 * @param params the parameters for the example 
 */ 
  
 private 
  
 void 
  
 runExample 
 ( 
 ParamsConfig 
  
 params 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // Reads event data from the JSON file. 
  
 List<EventRecord> 
  
 eventRecords 
  
 = 
  
 readEventData 
 ( 
 params 
 . 
 jsonFile 
 ); 
  
 // Gets an instance of the UserDataFormatter for normalizing and formatting the data. 
  
 UserDataFormatter 
  
 userDataFormatter 
  
 = 
  
 UserDataFormatter 
 . 
 create 
 (); 
  
 // Builds the events collection for the request. 
  
 List<Event> 
  
 events 
  
 = 
  
 new 
  
 ArrayList 
<> (); 
  
 for 
  
 ( 
 EventRecord 
  
 eventRecord 
  
 : 
  
 eventRecords 
 ) 
  
 { 
  
 Event 
 . 
 Builder 
  
 eventBuilder 
  
 = 
  
 Event 
 . 
 newBuilder 
 (); 
  
 try 
  
 { 
  
 eventBuilder 
 . 
 setEventTimestamp 
 ( 
 Timestamps 
 . 
 parse 
 ( 
 eventRecord 
 . 
 timestamp 
 )); 
  
 } 
  
 catch 
  
 ( 
 ParseException 
  
 pe 
 ) 
  
 { 
  
 LOGGER 
 . 
 warning 
 ( 
  
 () 
  
 - 
>  
 String 
 . 
 format 
 ( 
 "Skipping event with invalid timestamp: %s" 
 , 
  
 eventRecord 
 . 
 timestamp 
 )); 
  
 continue 
 ; 
  
 } 
  
 if 
  
 ( 
 Strings 
 . 
 isNullOrEmpty 
 ( 
 eventRecord 
 . 
 transactionId 
 )) 
  
 { 
  
 LOGGER 
 . 
 warning 
 ( 
 "Skipping event with no transaction ID" 
 ); 
  
 continue 
 ; 
  
 } 
  
 eventBuilder 
 . 
 setTransactionId 
 ( 
 eventRecord 
 . 
 transactionId 
 ); 
  
 if 
  
 ( 
 ! 
 Strings 
 . 
 isNullOrEmpty 
 ( 
 eventRecord 
 . 
 eventSource 
 )) 
  
 { 
  
 try 
  
 { 
  
 eventBuilder 
 . 
 setEventSource 
 ( 
 EventSource 
 . 
 valueOf 
 ( 
 eventRecord 
 . 
 eventSource 
 )); 
  
 } 
  
 catch 
  
 ( 
 IllegalArgumentException 
  
 iae 
 ) 
  
 { 
  
 LOGGER 
 . 
 warning 
 ( 
 "Skipping event with invalid event source: " 
  
 + 
  
 eventRecord 
 . 
 eventSource 
 ); 
  
 continue 
 ; 
  
 } 
  
 } 
  
 if 
  
 ( 
 ! 
 Strings 
 . 
 isNullOrEmpty 
 ( 
 eventRecord 
 . 
 gclid 
 )) 
  
 { 
  
 eventBuilder 
 . 
 setAdIdentifiers 
 ( 
 AdIdentifiers 
 . 
 newBuilder 
 (). 
 setGclid 
 ( 
 eventRecord 
 . 
 gclid 
 )); 
  
 } 
  
 if 
  
 ( 
 ! 
 Strings 
 . 
 isNullOrEmpty 
 ( 
 eventRecord 
 . 
 currency 
 )) 
  
 { 
  
 eventBuilder 
 . 
 setCurrency 
 ( 
 eventRecord 
 . 
 currency 
 ); 
  
 } 
  
 if 
  
 ( 
 eventRecord 
 . 
 value 
  
 != 
  
 null 
 ) 
  
 { 
  
 eventBuilder 
 . 
 setConversionValue 
 ( 
 eventRecord 
 . 
 value 
 ); 
  
 } 
  
 UserData 
 . 
 Builder 
  
 userDataBuilder 
  
 = 
  
 UserData 
 . 
 newBuilder 
 (); 
  
 // Adds a UserIdentifier for each valid email address for the eventRecord. 
  
 if 
  
 ( 
 eventRecord 
 . 
 emails 
  
 != 
  
 null 
 ) 
  
 { 
  
 for 
  
 ( 
 String 
  
 email 
  
 : 
  
 eventRecord 
 . 
 emails 
 ) 
  
 { 
  
 String 
  
 preparedEmail 
 ; 
  
 try 
  
 { 
  
 preparedEmail 
  
 = 
  
 userDataFormatter 
 . 
 processEmailAddress 
 ( 
 email 
 , 
  
 Encoding 
 . 
 HEX 
 ); 
  
 } 
  
 catch 
  
 ( 
 IllegalArgumentException 
  
 iae 
 ) 
  
 { 
  
 // Skips invalid input. 
  
 continue 
 ; 
  
 } 
  
 // Sets the email address identifier to the encoded email hash. 
  
 userDataBuilder 
 . 
 addUserIdentifiers 
 ( 
  
 UserIdentifier 
 . 
 newBuilder 
 (). 
 setEmailAddress 
 ( 
 preparedEmail 
 )); 
  
 } 
  
 } 
  
 // Adds a UserIdentifier for each valid phone number for the eventRecord. 
  
 if 
  
 ( 
 eventRecord 
 . 
 phoneNumbers 
  
 != 
  
 null 
 ) 
  
 { 
  
 for 
  
 ( 
 String 
  
 phoneNumber 
  
 : 
  
 eventRecord 
 . 
 phoneNumbers 
 ) 
  
 { 
  
 String 
  
 preparedPhoneNumber 
 ; 
  
 try 
  
 { 
  
 preparedPhoneNumber 
  
 = 
  
 userDataFormatter 
 . 
 processPhoneNumber 
 ( 
 phoneNumber 
 , 
  
 Encoding 
 . 
 HEX 
 ); 
  
 } 
  
 catch 
  
 ( 
 IllegalArgumentException 
  
 iae 
 ) 
  
 { 
  
 // Skips invalid input. 
  
 continue 
 ; 
  
 } 
  
 // Sets the phone number identifier to the encoded phone number hash. 
  
 userDataBuilder 
 . 
 addUserIdentifiers 
 ( 
  
 UserIdentifier 
 . 
 newBuilder 
 (). 
 setPhoneNumber 
 ( 
 preparedPhoneNumber 
 )); 
  
 } 
  
 } 
  
 if 
  
 ( 
 userDataBuilder 
 . 
 getUserIdentifiersCount 
 () 
 > 
 0 
 ) 
  
 { 
  
 eventBuilder 
 . 
 setUserData 
 ( 
 userDataBuilder 
 ); 
  
 } 
  
 events 
 . 
 add 
 ( 
 eventBuilder 
 . 
 build 
 ()); 
  
 } 
  
 // Builds the Destination for the request. 
  
 Destination 
 . 
 Builder 
  
 destinationBuilder 
  
 = 
  
 Destination 
 . 
 newBuilder 
 () 
  
 . 
 setOperatingAccount 
 ( 
  
 ProductAccount 
 . 
 newBuilder 
 () 
  
 . 
 setAccountType 
 ( 
 params 
 . 
 operatingAccountType 
 ) 
  
 . 
 setAccountId 
 ( 
 params 
 . 
 operatingAccountId 
 )) 
  
 . 
 setProductDestinationId 
 ( 
 params 
 . 
 conversionActionId 
 ); 
  
 if 
  
 ( 
 params 
 . 
 loginAccountType 
  
 != 
  
 null 
 && 
 params 
 . 
 loginAccountId 
  
 != 
  
 null 
 ) 
  
 { 
  
 destinationBuilder 
 . 
 setLoginAccount 
 ( 
  
 ProductAccount 
 . 
 newBuilder 
 () 
  
 . 
 setAccountType 
 ( 
 params 
 . 
 loginAccountType 
 ) 
  
 . 
 setAccountId 
 ( 
 params 
 . 
 loginAccountId 
 )); 
  
 } 
  
 if 
  
 ( 
 params 
 . 
 linkedAccountType 
  
 != 
  
 null 
 && 
 params 
 . 
 linkedAccountId 
  
 != 
  
 null 
 ) 
  
 { 
  
 destinationBuilder 
 . 
 setLinkedAccount 
 ( 
  
 ProductAccount 
 . 
 newBuilder 
 () 
  
 . 
 setAccountType 
 ( 
 params 
 . 
 linkedAccountType 
 ) 
  
 . 
 setAccountId 
 ( 
 params 
 . 
 linkedAccountId 
 )); 
  
 } 
  
 try 
  
 ( 
 IngestionServiceClient 
  
 ingestionServiceClient 
  
 = 
  
 IngestionServiceClient 
 . 
 create 
 ()) 
  
 { 
  
 int 
  
 requestCount 
  
 = 
  
 0 
 ; 
  
 // Batches requests to send up to the maximum number of events per request. 
  
 for 
  
 ( 
 List<Event> 
  
 eventsBatch 
  
 : 
  
 Lists 
 . 
 partition 
 ( 
 events 
 , 
  
 MAX_EVENTS_PER_REQUEST 
 )) 
  
 { 
  
 requestCount 
 ++ 
 ; 
  
 // Builds the request. 
  
 IngestEventsRequest 
  
 request 
  
 = 
  
 IngestEventsRequest 
 . 
 newBuilder 
 () 
  
 . 
 addDestinations 
 ( 
 destinationBuilder 
 ) 
  
 // Adds events from the current batch. 
  
 . 
 addAllEvents 
 ( 
 eventsBatch 
 ) 
  
 . 
 setConsent 
 ( 
  
 Consent 
 . 
 newBuilder 
 () 
  
 . 
 setAdPersonalization 
 ( 
 ConsentStatus 
 . 
 CONSENT_GRANTED 
 ) 
  
 . 
 setAdUserData 
 ( 
 ConsentStatus 
 . 
 CONSENT_GRANTED 
 )) 
  
 // Sets validate_only. If true, then the Data Manager API only validates the request 
  
 // but doesn't apply changes. 
  
 . 
 setValidateOnly 
 ( 
 params 
 . 
 validateOnly 
 ) 
  
 // Sets encoding to match the encoding used. 
  
 . 
 setEncoding 
 ( 
 com 
 . 
 google 
 . 
 ads 
 . 
 datamanager 
 . 
 v1 
 . 
 Encoding 
 . 
 HEX 
 ) 
  
 . 
 build 
 (); 
  
 LOGGER 
 . 
 info 
 (() 
  
 - 
>  
 String 
 . 
 format 
 ( 
 "Request:%n%s" 
 , 
  
 request 
 )); 
  
 IngestEventsResponse 
  
 response 
  
 = 
  
 ingestionServiceClient 
 . 
 ingestEvents 
 ( 
 request 
 ); 
  
 LOGGER 
 . 
 info 
 ( 
 String 
 . 
 format 
 ( 
 "Response for request #:%n%s" 
 , 
  
 requestCount 
 , 
  
 response 
 )); 
  
 } 
  
 LOGGER 
 . 
 info 
 ( 
 "# of requests sent: " 
  
 + 
  
 requestCount 
 ); 
  
 } 
  
 } 
  
 /** Data object for a single row of input data. */ 
  
 @SuppressWarnings 
 ( 
 "unused" 
 ) 
  
 private 
  
 static 
  
 class 
 EventRecord 
  
 { 
  
 private 
  
 List<String> 
  
 emails 
 ; 
  
 private 
  
 List<String> 
  
 phoneNumbers 
 ; 
  
 private 
  
 String 
  
 timestamp 
 ; 
  
 private 
  
 String 
  
 transactionId 
 ; 
  
 private 
  
 String 
  
 eventSource 
 ; 
  
 private 
  
 Double 
  
 value 
 ; 
  
 private 
  
 String 
  
 currency 
 ; 
  
 private 
  
 String 
  
 gclid 
 ; 
  
 } 
  
 /** Reads the data file and parses each line into a {@link EventRecord} object. */ 
  
 private 
  
 List<EventRecord> 
  
 readEventData 
 ( 
 String 
  
 jsonFile 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 try 
  
 ( 
 BufferedReader 
  
 jsonReader 
  
 = 
  
 Files 
 . 
 newBufferedReader 
 ( 
 Paths 
 . 
 get 
 ( 
 jsonFile 
 ), 
  
 StandardCharsets 
 . 
 UTF_8 
 )) 
  
 { 
  
 // Define the type for Gson to deserialize into (List of EventRecord objects) 
  
 Type 
  
 recordListType 
  
 = 
  
 new 
  
 TypeToken<ArrayList<EventRecord> 
> () 
  
 {}. 
 getType 
 (); 
  
 // Parse the JSON string from the file into a List of EventRecord objects 
  
 return 
  
 new 
  
 GsonBuilder 
 (). 
 create 
 (). 
 fromJson 
 ( 
 jsonReader 
 , 
  
 recordListType 
 ); 
  
 } 
  
 } 
 } 
 
  IngestEvents 
 . 
 java 
 
 

 #!/usr/bin/env node 
 // Copyright 2025 Google LLC 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License. 
 // You may obtain a copy of the License at 
 // 
 //     https://www.apache.org/licenses/LICENSE-2.0 
 // 
 // Unless required by applicable law or agreed to in writing, software 
 // distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 // See the License for the specific language governing permissions and 
 // limitations under the License. 
 'use strict' 
 ; 
 import 
  
 { 
 IngestionServiceClient 
 } 
  
 from 
  
 '@google-ads/datamanager' 
 ; 
 import 
  
 { 
 protos 
 } 
  
 from 
  
 '@google-ads/datamanager' 
 ; 
 const 
  
 { 
  
 Event 
 : 
  
 DataManagerEvent 
 , 
  
 Destination 
 , 
  
 Encoding 
 : 
  
 DataManagerEncoding 
 , 
  
 EventSource 
 , 
  
 Consent 
 , 
  
 ConsentStatus 
 , 
  
 IngestEventsRequest 
 , 
  
 ProductAccount 
 , 
  
 UserData 
 , 
  
 UserIdentifier 
 , 
 } 
  
 = 
  
 protos 
 . 
 google 
 . 
 ads 
 . 
 datamanager 
 . 
 v1 
 ; 
 import 
  
 { 
 UserDataFormatter 
 , 
  
 Encoding 
 } 
  
 from 
  
 '@google-ads/data-manager-util' 
 ; 
 import 
  
 * 
  
 as 
  
 fs 
  
 from 
  
 'fs' 
 ; 
 import 
  
 * 
  
 as 
  
 yargs 
  
 from 
  
 'yargs' 
 ; 
 const 
  
 MAX_EVENTS_PER_REQUEST 
  
 = 
  
 10000 
 ; 
 interface 
  
 Arguments 
  
 { 
  
 operating_account_type 
 : 
  
 string 
 ; 
  
 operating_account_id 
 : 
  
 string 
 ; 
  
 conversion_action_id 
 : 
  
 string 
 ; 
  
 json_file 
 : 
  
 string 
 ; 
  
 validate_only 
 : 
  
 boolean 
 ; 
  
 login_account_type 
 ?: 
  
 string 
 ; 
  
 login_account_id 
 ?: 
  
 string 
 ; 
  
 linked_account_type 
 ?: 
  
 string 
 ; 
  
 linked_account_id 
 ?: 
  
 string 
 ; 
  
 [ 
 x 
 : 
  
 string 
 ] 
 : 
  
 unknown 
 ; 
 } 
 interface 
  
 EventRow 
  
 { 
  
 timestamp 
 : 
  
 string 
 ; 
  
 transactionId 
 : 
  
 string 
 ; 
  
 eventSource 
 ?: 
  
 string 
 ; 
  
 gclid 
 ?: 
  
 string 
 ; 
  
 currency 
 ?: 
  
 string 
 ; 
  
 value 
 ?: 
  
 number 
 ; 
  
 emails 
 ?: 
  
 string 
 []; 
  
 phoneNumbers 
 ?: 
  
 string 
 []; 
 } 
 /** 
 * The main function for the IngestEvents sample. 
 */ 
 async 
  
 function 
  
 main 
 () 
  
 { 
  
 const 
  
 argv 
 : 
  
 Arguments 
  
 = 
  
 yargs 
  
 . 
 option 
 ( 
 'operating_account_type' 
 , 
  
 { 
  
 describe 
 : 
  
 'The account type of the operating account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 required 
 : 
  
 true 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'operating_account_id' 
 , 
  
 { 
  
 describe 
 : 
  
 'The ID of the operating account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 required 
 : 
  
 true 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'conversion_action_id' 
 , 
  
 { 
  
 describe 
 : 
  
 'The ID of the conversion action.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 required 
 : 
  
 true 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'json_file' 
 , 
  
 { 
  
 describe 
 : 
  
 'JSON file containing user data to ingest.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 required 
 : 
  
 true 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'validate_only' 
 , 
  
 { 
  
 describe 
 : 
  
 'Whether to enable validate_only on the request.' 
 , 
  
 type 
 : 
  
 'boolean' 
 , 
  
 default 
 : 
  
 true 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'login_account_type' 
 , 
  
 { 
  
 describe 
 : 
  
 'The account type of the login account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'login_account_id' 
 , 
  
 { 
  
 describe 
 : 
  
 'The ID of the login account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'linked_account_type' 
 , 
  
 { 
  
 describe 
 : 
  
 'The account type of the linked account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'linked_account_id' 
 , 
  
 { 
  
 describe 
 : 
  
 'The ID of the linked account.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 }) 
  
 . 
 option 
 ( 
 'config' 
 , 
  
 { 
  
 describe 
 : 
  
 'Path to a JSON file with arguments.' 
 , 
  
 type 
 : 
  
 'string' 
 , 
  
 }) 
  
 . 
 config 
 ( 
 'config' 
 ) 
  
 . 
 check 
 (( 
 args 
 : 
  
 Arguments 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
  
 ( 
 args 
 . 
 login_account_type 
 && 
 ! 
 args 
 . 
 login_account_id 
 ) 
  
 || 
  
 ( 
 ! 
 args 
 . 
 login_account_type 
 && 
 args 
 . 
 login_account_id 
 ) 
  
 ) 
  
 { 
  
 throw 
  
 new 
  
 Error 
 ( 
  
 'Must specify either both or neither of login account type ' 
  
 + 
  
 'and login account ID' 
 , 
  
 ); 
  
 } 
  
 if 
  
 ( 
  
 ( 
 args 
 . 
 linked_account_type 
 && 
 ! 
 args 
 . 
 linked_account_id 
 ) 
  
 || 
  
 ( 
 ! 
 args 
 . 
 linked_account_type 
 && 
 args 
 . 
 linked_account_id 
 ) 
  
 ) 
  
 { 
  
 throw 
  
 new 
  
 Error 
 ( 
  
 'Must specify either both or neither of linked account type ' 
  
 + 
  
 'and linked account ID' 
 , 
  
 ); 
  
 } 
  
 return 
  
 true 
 ; 
  
 }) 
  
 . 
 parseSync 
 (); 
  
 // Reads event data from the JSON file. 
  
 const 
  
 eventRows 
 : 
  
 EventRow 
 [] 
  
 = 
  
 readEventDataFile 
 ( 
 argv 
 . 
 json_file 
 ); 
  
 // Builds the events collection for the request. 
  
 const 
  
 events 
  
 = 
  
 []; 
  
 const 
  
 formatter 
  
 = 
  
 new 
  
 UserDataFormatter 
 (); 
  
 for 
  
 ( 
 const 
  
 eventRow 
  
 of 
  
 eventRows 
 ) 
  
 { 
  
 const 
  
 event 
  
 = 
  
 DataManagerEvent 
 . 
 create 
 (); 
  
 try 
  
 { 
  
 const 
  
 date 
  
 = 
  
 new 
  
 Date 
 ( 
 eventRow 
 . 
 timestamp 
 ); 
  
 event 
 . 
 eventTimestamp 
  
 = 
  
 { 
  
 seconds 
 : 
  
 Math 
 . 
 floor 
 ( 
 date 
 . 
 getTime 
 () 
  
 / 
  
 1000 
 ), 
  
 nanos 
 : 
  
 ( 
 date 
 . 
 getTime 
 () 
  
 % 
  
 1000 
 ) 
  
 * 
  
 1e6 
 , 
  
 }; 
  
 } 
  
 catch 
  
 ( 
 e 
 ) 
  
 { 
  
 console 
 . 
 warn 
 ( 
  
 `Invalid timestamp format: 
 ${ 
 eventRow 
 . 
 timestamp 
 } 
 . Skipping row.` 
 , 
  
 ); 
  
 continue 
 ; 
  
 } 
  
 if 
  
 ( 
 ! 
 eventRow 
 . 
 transactionId 
 ) 
  
 { 
  
 console 
 . 
 warn 
 ( 
 'Skipping event with no transaction ID' 
 ); 
  
 continue 
 ; 
  
 } 
  
 event 
 . 
 transactionId 
  
 = 
  
 eventRow 
 . 
 transactionId 
 ; 
  
 if 
  
 ( 
 eventRow 
 . 
 eventSource 
 ) 
  
 { 
  
 const 
  
 eventSourceEnumValue 
 : 
  
 number 
  
 | 
  
 undefined 
  
 = 
  
 EventSource 
 [ 
 eventRow 
 . 
 eventSource 
  
 as 
  
 keyof 
  
 typeof 
  
 EventSource 
 ]; 
  
 if 
  
 ( 
 eventSourceEnumValue 
  
 === 
  
 undefined 
 ) 
  
 { 
  
 console 
 . 
 warn 
 ( 
  
 `Skipping event with invalid event_source: 
 ${ 
 eventRow 
 . 
 eventSource 
 } 
 ` 
 , 
  
 ); 
  
 continue 
 ; 
  
 } 
  
 event 
 . 
 eventSource 
  
 = 
  
 eventSourceEnumValue 
 ; 
  
 } 
  
 if 
  
 ( 
 eventRow 
 . 
 gclid 
 ) 
  
 { 
  
 event 
 . 
 adIdentifiers 
  
 = 
  
 { 
 gclid 
 : 
  
 eventRow 
 . 
 gclid 
 }; 
  
 } 
  
 if 
  
 ( 
 eventRow 
 . 
 currency 
 ) 
  
 { 
  
 event 
 . 
 currency 
  
 = 
  
 eventRow 
 . 
 currency 
 ; 
  
 } 
  
 if 
  
 ( 
 eventRow 
 . 
 value 
 ) 
  
 { 
  
 event 
 . 
 conversionValue 
  
 = 
  
 eventRow 
 . 
 value 
 ; 
  
 } 
  
 const 
  
 userData 
  
 = 
  
 UserData 
 . 
 create 
 (); 
  
 // Adds a UserIdentifier for each valid email address for the eventRecord. 
  
 if 
  
 ( 
 eventRow 
 . 
 emails 
 ) 
  
 { 
  
 for 
  
 ( 
 const 
  
 email 
  
 of 
  
 eventRow 
 . 
 emails 
 ) 
  
 { 
  
 try 
  
 { 
  
 const 
  
 processedEmail 
  
 = 
  
 formatter 
 . 
 processEmailAddress 
 ( 
  
 email 
 , 
  
 Encoding 
 . 
 HEX 
 , 
  
 ); 
  
 userData 
 . 
 userIdentifiers 
 . 
 push 
 ( 
  
 UserIdentifier 
 . 
 create 
 ({ 
 emailAddress 
 : 
  
 processedEmail 
 }), 
  
 ); 
  
 } 
  
 catch 
  
 ( 
 e 
 ) 
  
 { 
  
 console 
 . 
 warn 
 ( 
 `Invalid email address: 
 ${ 
 email 
 } 
 . Skipping.` 
 ); 
  
 } 
  
 } 
  
 } 
  
 // Adds a UserIdentifier for each valid phone number for the eventRecord. 
  
 if 
  
 ( 
 eventRow 
 . 
 phoneNumbers 
 ) 
  
 { 
  
 for 
  
 ( 
 const 
  
 phoneNumber 
  
 of 
  
 eventRow 
 . 
 phoneNumbers 
 ) 
  
 { 
  
 try 
  
 { 
  
 const 
  
 processedPhone 
  
 = 
  
 formatter 
 . 
 processPhoneNumber 
 ( 
  
 phoneNumber 
 , 
  
 Encoding 
 . 
 HEX 
 , 
  
 ); 
  
 userData 
 . 
 userIdentifiers 
 . 
 push 
 ( 
  
 UserIdentifier 
 . 
 create 
 ({ 
 phoneNumber 
 : 
  
 processedPhone 
 }), 
  
 ); 
  
 } 
  
 catch 
  
 ( 
 e 
 ) 
  
 { 
  
 console 
 . 
 warn 
 ( 
 `Invalid phone: 
 ${ 
 phoneNumber 
 } 
 . Skipping.` 
 ); 
  
 } 
  
 } 
  
 } 
  
 if 
  
 ( 
 userData 
 . 
 userIdentifiers 
 . 
 length 
 > 
 0 
 ) 
  
 { 
  
 event 
 . 
 userData 
  
 = 
  
 userData 
 ; 
  
 } 
  
 events 
 . 
 push 
 ( 
 event 
 ); 
  
 } 
  
 // Sets up the Destination. 
  
 const 
  
 operatingAccountType 
  
 = 
  
 convertToAccountType 
 ( 
  
 argv 
 . 
 operating_account_type 
 , 
  
 'operating_account_type' 
 , 
  
 ); 
  
 const 
  
 destination 
  
 = 
  
 Destination 
 . 
 create 
 ({ 
  
 operatingAccount 
 : 
  
 ProductAccount 
 . 
 create 
 ({ 
  
 accountType 
 : 
  
 operatingAccountType 
 , 
  
 accountId 
 : 
  
 argv 
 . 
 operating_account_id 
 , 
  
 }), 
  
 productDestinationId 
 : 
  
 argv 
 . 
 conversion_action_id 
 , 
  
 }); 
  
 // The login account is optional. 
  
 if 
  
 ( 
 argv 
 . 
 login_account_type 
 ) 
  
 { 
  
 const 
  
 loginAccountType 
  
 = 
  
 convertToAccountType 
 ( 
  
 argv 
 . 
 login_account_type 
 , 
  
 'login_account_type' 
 , 
  
 ); 
  
 destination 
 . 
 loginAccount 
  
 = 
  
 ProductAccount 
 . 
 create 
 ({ 
  
 accountType 
 : 
  
 loginAccountType 
 , 
  
 accountId 
 : 
  
 argv 
 . 
 login_account_id 
 , 
  
 }); 
  
 } 
  
 // The linked account is optional. 
  
 if 
  
 ( 
 argv 
 . 
 linked_account_type 
 ) 
  
 { 
  
 const 
  
 linkedAccountType 
  
 = 
  
 convertToAccountType 
 ( 
  
 argv 
 . 
 linked_account_type 
 , 
  
 'linked_account_type' 
 , 
  
 ); 
  
 destination 
 . 
 linkedAccount 
  
 = 
  
 ProductAccount 
 . 
 create 
 ({ 
  
 accountType 
 : 
  
 linkedAccountType 
 , 
  
 accountId 
 : 
  
 argv 
 . 
 linked_account_id 
 , 
  
 }); 
  
 } 
  
 const 
  
 client 
  
 = 
  
 new 
  
 IngestionServiceClient 
 (); 
  
 let 
  
 requestCount 
  
 = 
  
 0 
 ; 
  
 // Batches requests to send up to the maximum number of events per request. 
  
 for 
  
 ( 
 let 
  
 i 
  
 = 
  
 0 
 ; 
  
 i 
 < 
 events 
 . 
 length 
 ; 
  
 i 
  
 += 
  
 MAX_EVENTS_PER_REQUEST 
 ) 
  
 { 
  
 requestCount 
 ++ 
 ; 
  
 const 
  
 eventsBatch 
  
 = 
  
 events 
 . 
 slice 
 ( 
 i 
 , 
  
 i 
  
 + 
  
 MAX_EVENTS_PER_REQUEST 
 ); 
  
 // Builds the request. 
  
 const 
  
 request 
  
 = 
  
 IngestEventsRequest 
 . 
 create 
 ({ 
  
 destinations 
 : 
  
 [ 
 destination 
 ], 
  
 // Adds events from the current batch. 
  
 events 
 : 
  
 eventsBatch 
 , 
  
 consent 
 : 
  
 Consent 
 . 
 create 
 ({ 
  
 adUserData 
 : 
  
 ConsentStatus 
 . 
 CONSENT_GRANTED 
 , 
  
 adPersonalization 
 : 
  
 ConsentStatus 
 . 
 CONSENT_GRANTED 
 , 
  
 }), 
  
 // Sets encoding to match the encoding used. 
  
 encoding 
 : 
  
 DataManagerEncoding 
 . 
 HEX 
 , 
  
 // Sets validate_only. If true, then the Data Manager API only validates the request 
  
 validateOnly 
 : 
  
 argv 
 . 
 validate_only 
 , 
  
 }); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 client 
 . 
 ingestEvents 
 ( 
 request 
 ); 
  
 console 
 . 
 log 
 ( 
 `Response for request # 
 ${ 
 requestCount 
 } 
 :\n` 
 , 
  
 response 
 ); 
  
 } 
  
 console 
 . 
 log 
 ( 
 `# of requests sent: 
 ${ 
 requestCount 
 } 
 ` 
 ); 
 } 
 /** 
 * Reads the event data from the given JSON file. 
 * @param {string} jsonFile The path to the JSON file. 
 * @return {EventRow[]} An array of event data. 
 */ 
 function 
  
 readEventDataFile 
 ( 
 jsonFile 
 : 
  
 string 
 ) 
 : 
  
 EventRow 
 [] 
  
 { 
  
 const 
  
 fileContent 
  
 = 
  
 fs 
 . 
 readFileSync 
 ( 
 jsonFile 
 , 
  
 'utf8' 
 ); 
  
 return 
  
 JSON 
 . 
 parse 
 ( 
 fileContent 
 ); 
 } 
 /** 
 * Validates that a given string is an enum value for the AccountType enum, and 
 * if validation passes, returns the AccountType enum value. 
 * @param proposedValue the name of an AccountType enum value 
 * @param paramName the name of the parameter to use in the error message if validation fails 
 * @returns {protos.google.ads.datamanager.v1.ProductAccount.AccountType} The corresponding enum value. 
 * @throws {Error} If the string is not an AccountType enum value. 
 */ 
 function 
  
 convertToAccountType 
 ( 
  
 proposedValue 
 : 
  
 string 
 , 
  
 paramName 
 : 
  
 string 
 , 
 ) 
 : 
  
 protos 
 . 
 google 
 . 
 ads 
 . 
 datamanager 
 . 
 v1 
 . 
 ProductAccount 
 . 
 AccountType 
  
 { 
  
 const 
  
 AccountType 
  
 = 
  
 ProductAccount 
 . 
 AccountType 
 ; 
  
 const 
  
 accountTypeEnumNames 
  
 = 
  
 Object 
 . 
 keys 
 ( 
 AccountType 
 ). 
 filter 
 ( 
 key 
  
 = 
>  
 isNaN 
 ( 
 Number 
 ( 
 key 
 )), 
  
 ); 
  
 if 
  
 ( 
 ! 
 accountTypeEnumNames 
 . 
 includes 
 ( 
 proposedValue 
 )) 
  
 { 
  
 throw 
  
 new 
  
 Error 
 ( 
 `Invalid 
 ${ 
 paramName 
 } 
 : 
 ${ 
 proposedValue 
 } 
 ` 
 ); 
  
 } 
  
 return 
  
 AccountType 
 [ 
 proposedValue 
  
 as 
  
 keyof 
  
 typeof 
  
 AccountType 
 ]; 
 } 
 if 
  
 ( 
 require 
 . 
 main 
  
 === 
  
 module 
 ) 
  
 { 
  
 main 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 ); 
 } 
 
  ingest_events 
 . 
 ts