diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java index 63a718e6..22a239c0 100644 --- a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java @@ -18,10 +18,16 @@ import com.iab.gpp.encoder.section.UsCa; import com.iab.gpp.encoder.section.UsCo; import com.iab.gpp.encoder.section.UsCt; +import com.iab.gpp.encoder.section.UsDe; import com.iab.gpp.encoder.section.UsFl; +import com.iab.gpp.encoder.section.UsIa; import com.iab.gpp.encoder.section.UsMt; import com.iab.gpp.encoder.section.UsNat; +import com.iab.gpp.encoder.section.UsNe; +import com.iab.gpp.encoder.section.UsNh; +import com.iab.gpp.encoder.section.UsNj; import com.iab.gpp.encoder.section.UsOr; +import com.iab.gpp.encoder.section.UsTn; import com.iab.gpp.encoder.section.UsTx; import com.iab.gpp.encoder.section.UsUt; import com.iab.gpp.encoder.section.UsVa; @@ -31,10 +37,10 @@ public class GppModel { private Map sections = new HashMap<>(); private String encodedString; - + private boolean dirty = false; private boolean decoded = true; - + public GppModel() { } @@ -53,7 +59,7 @@ public void setFieldValue(String sectionName, String fieldName, Object value) { this.dirty = false; this.decoded = true; } - + EncodableSection section = null; if (!this.sections.containsKey(sectionName)) { if (sectionName.equals(TcfCaV1.NAME)) { @@ -95,6 +101,24 @@ public void setFieldValue(String sectionName, String fieldName, Object value) { } else if (sectionName.equals(UsTx.NAME)) { section = new UsTx(); this.sections.put(UsTx.NAME, section); + } else if (sectionName.equals(UsDe.NAME)) { + section = new UsDe(); + this.sections.put(UsDe.NAME, section); + } else if (sectionName.equals(UsIa.NAME)) { + section = new UsIa(); + this.sections.put(UsIa.NAME, section); + } else if (sectionName.equals(UsNe.NAME)) { + section = new UsNe(); + this.sections.put(UsNe.NAME, section); + } else if (sectionName.equals(UsNh.NAME)) { + section = new UsNh(); + this.sections.put(UsNh.NAME, section); + } else if (sectionName.equals(UsNj.NAME)) { + section = new UsNj(); + this.sections.put(UsNj.NAME, section); + } else if (sectionName.equals(UsTn.NAME)) { + section = new UsTn(); + this.sections.put(UsTn.NAME, section); } } else { section = this.sections.get(sectionName); @@ -118,7 +142,7 @@ public Object getFieldValue(String sectionName, String fieldName) { this.dirty = false; this.decoded = true; } - + if (this.sections.containsKey(sectionName)) { return this.sections.get(sectionName).getFieldValue(fieldName); } else { @@ -136,7 +160,7 @@ public boolean hasField(String sectionName, String fieldName) { this.dirty = false; this.decoded = true; } - + if (this.sections.containsKey(sectionName)) { return this.sections.get(sectionName).hasField(fieldName); } else { @@ -154,7 +178,7 @@ public boolean hasSection(String sectionName) { this.dirty = false; this.decoded = true; } - + return this.sections.containsKey(sectionName); } @@ -164,7 +188,7 @@ public HeaderV1 getHeader() { this.dirty = false; this.decoded = true; } - + HeaderV1 header = new HeaderV1(); try { header.setFieldValue("SectionIds", this.getSectionIds()); @@ -184,7 +208,7 @@ public EncodableSection getSection(String sectionName) { this.dirty = false; this.decoded = true; } - + if (this.sections.containsKey(sectionName)) { return this.sections.get(sectionName); } else { @@ -202,7 +226,7 @@ public void deleteSection(String sectionName) { this.dirty = false; this.decoded = true; } - + if (this.sections.containsKey(sectionName)) { this.sections.remove(sectionName); this.dirty = true; @@ -251,30 +275,54 @@ public UsUt getUsUtSection() { public UsCt getUsCtSection() { return (UsCt) getSection(UsCt.NAME); } - + public UsFl getUsFlSection() { return (UsFl) getSection(UsFl.NAME); } - + public UsMt getUsMtSection() { return (UsMt) getSection(UsMt.NAME); } - + public UsOr getUsOrSection() { return (UsOr) getSection(UsOr.NAME); } - + public UsTx getUsTxSection() { return (UsTx) getSection(UsTx.NAME); } - + + public UsDe getUsDeSection() { + return (UsDe) getSection(UsDe.NAME); + } + + public UsIa getUsIaSection() { + return (UsIa) getSection(UsIa.NAME); + } + + public UsNe getUsNeSection() { + return (UsNe) getSection(UsNe.NAME); + } + + public UsNh getUsNhSection() { + return (UsNh) getSection(UsNh.NAME); + } + + public UsNj getUsNjSection() { + return (UsNj) getSection(UsNj.NAME); + } + + public UsTn getUsTnSection() { + return (UsTn) getSection(UsTn.NAME); + } + public List getSectionIds() { if (!this.decoded) { this.sections = this.decodeModel(this.encodedString); this.dirty = false; this.decoded = true; } - + List sectionIds = new ArrayList<>(); for (int i = 0; i < Sections.SECTION_ORDER.size(); i++) { String sectionName = Sections.SECTION_ORDER.get(i); @@ -311,14 +359,14 @@ protected String encodeModel(Map sections) { } protected Map decodeModel(String str) { - if(str == null || str.isEmpty() || str.startsWith("D")) { + if (str == null || str.isEmpty() || str.startsWith("D")) { Map sections = new HashMap<>(); - - if(str != null && !str.isEmpty()) { + + if (str != null && !str.isEmpty()) { String[] encodedSections = str.split("~"); HeaderV1 header = new HeaderV1(encodedSections[0]); sections.put(HeaderV1.NAME, header); - + @SuppressWarnings("unchecked") List sectionIds = (List) header.getFieldValue("SectionIds"); for (int i = 0; i < sectionIds.size(); i++) { @@ -361,12 +409,30 @@ protected Map decodeModel(String str) { } else if (sectionIds.get(i).equals(UsTx.ID)) { UsTx section = new UsTx(encodedSections[i + 1]); sections.put(UsTx.NAME, section); + } else if (sectionIds.get(i).equals(UsDe.ID)) { + UsDe section = new UsDe(encodedSections[i + 1]); + sections.put(UsDe.NAME, section); + } else if (sectionIds.get(i).equals(UsIa.ID)) { + UsIa section = new UsIa(encodedSections[i + 1]); + sections.put(UsIa.NAME, section); + } else if (sectionIds.get(i).equals(UsNe.ID)) { + UsNe section = new UsNe(encodedSections[i + 1]); + sections.put(UsNe.NAME, section); + } else if (sectionIds.get(i).equals(UsNh.ID)) { + UsNh section = new UsNh(encodedSections[i + 1]); + sections.put(UsNh.NAME, section); + } else if (sectionIds.get(i).equals(UsNj.ID)) { + UsNj section = new UsNj(encodedSections[i + 1]); + sections.put(UsNj.NAME, section); + } else if (sectionIds.get(i).equals(UsTn.ID)) { + UsTn section = new UsTn(encodedSections[i + 1]); + sections.put(UsTn.NAME, section); } } } - + return sections; - } else if(str.startsWith("C")) { + } else if (str.startsWith("C")) { // old tcfeu only string Map sections = new HashMap<>(); @@ -393,7 +459,7 @@ public String encodeSection(String sectionName) { this.dirty = false; this.decoded = true; } - + if (this.sections.containsKey(sectionName)) { return this.sections.get(sectionName).encode(); } else { @@ -447,6 +513,24 @@ public void decodeSection(String sectionName, String encodedString) { } else if (sectionName.equals(UsTx.NAME)) { section = new UsTx(); this.sections.put(UsTx.NAME, section); + }else if (sectionName.equals(UsDe.NAME)) { + section = new UsDe(); + this.sections.put(UsDe.NAME, section); + }else if (sectionName.equals(UsIa.NAME)) { + section = new UsIa(); + this.sections.put(UsIa.NAME, section); + }else if (sectionName.equals(UsNe.NAME)) { + section = new UsNe(); + this.sections.put(UsNe.NAME, section); + }else if (sectionName.equals(UsNh.NAME)) { + section = new UsNh(); + this.sections.put(UsNh.NAME, section); + }else if (sectionName.equals(UsNj.NAME)) { + section = new UsNj(); + this.sections.put(UsNj.NAME, section); + }else if (sectionName.equals(UsTn.NAME)) { + section = new UsTn(); + this.sections.put(UsTn.NAME, section); } } else { section = this.sections.get(sectionName); @@ -456,7 +540,7 @@ public void decodeSection(String sectionName, String encodedString) { section.decode(encodedString); } } - + public String encode() { if (this.encodedString == null || this.encodedString.isEmpty() || this.dirty) { this.encodedString = encodeModel(this.sections); @@ -466,12 +550,12 @@ public String encode() { return this.encodedString; } - + public void decode(String encodedString) { this.encodedString = encodedString; this.dirty = false; this.decoded = false; } - - -} \ No newline at end of file + + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsDeField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsDeField.java new file mode 100644 index 00000000..2979f9b6 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsDeField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsDeField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String ADDITIONAL_DATA_PROCESSING_CONSENT = "AdditionalDataProcessingConsent"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USDE_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsDeField.VERSION, + UsDeField.PROCESSING_NOTICE, + UsDeField.SALE_OPT_OUT_NOTICE, + UsDeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsDeField.SALE_OPT_OUT, + UsDeField.TARGETED_ADVERTISING_OPT_OUT, + UsDeField.SENSITIVE_DATA_PROCESSING, + UsDeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsDeField.ADDITIONAL_DATA_PROCESSING_CONSENT, + UsDeField.MSPA_COVERED_TRANSACTION, + UsDeField.MSPA_OPT_OUT_OPTION_MODE, + UsDeField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USDE_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsDeField.GPC_SEGMENT_TYPE, + UsDeField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsIaField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsIaField.java new file mode 100644 index 00000000..f0c8d523 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsIaField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsIaField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SENSITIVE_DATA_OPT_OUT_NOTICE = "SensitiveDataOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USIA_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsIaField.VERSION, + UsIaField.PROCESSING_NOTICE, + UsIaField.SALE_OPT_OUT_NOTICE, + UsIaField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsIaField.SENSITIVE_DATA_OPT_OUT_NOTICE, + UsIaField.SALE_OPT_OUT, + UsIaField.TARGETED_ADVERTISING_OPT_OUT, + UsIaField.SENSITIVE_DATA_PROCESSING, + UsIaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsIaField.MSPA_COVERED_TRANSACTION, + UsIaField.MSPA_OPT_OUT_OPTION_MODE, + UsIaField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USIA_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsIaField.GPC_SEGMENT_TYPE, + UsIaField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNeField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNeField.java new file mode 100644 index 00000000..a4479a87 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNeField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsNeField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String ADDITIONAL_DATA_PROCESSING_CONSENT = "AdditionalDataProcessingConsent"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USNE_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNeField.VERSION, + UsNeField.PROCESSING_NOTICE, + UsNeField.SALE_OPT_OUT_NOTICE, + UsNeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsNeField.SALE_OPT_OUT, + UsNeField.TARGETED_ADVERTISING_OPT_OUT, + UsNeField.SENSITIVE_DATA_PROCESSING, + UsNeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsNeField.ADDITIONAL_DATA_PROCESSING_CONSENT, + UsNeField.MSPA_COVERED_TRANSACTION, + UsNeField.MSPA_OPT_OUT_OPTION_MODE, + UsNeField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USNE_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNeField.GPC_SEGMENT_TYPE, + UsNeField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNhField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNhField.java new file mode 100644 index 00000000..8381dc9b --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNhField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsNhField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String ADDITIONAL_DATA_PROCESSING_CONSENT = "AdditionalDataProcessingConsent"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USNH_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNhField.VERSION, + UsNhField.PROCESSING_NOTICE, + UsNhField.SALE_OPT_OUT_NOTICE, + UsNhField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsNhField.SALE_OPT_OUT, + UsNhField.TARGETED_ADVERTISING_OPT_OUT, + UsNhField.SENSITIVE_DATA_PROCESSING, + UsNhField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsNhField.ADDITIONAL_DATA_PROCESSING_CONSENT, + UsNhField.MSPA_COVERED_TRANSACTION, + UsNhField.MSPA_OPT_OUT_OPTION_MODE, + UsNhField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USNH_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNhField.GPC_SEGMENT_TYPE, + UsNhField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNjField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNjField.java new file mode 100644 index 00000000..2acba850 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsNjField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsNjField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String ADDITIONAL_DATA_PROCESSING_CONSENT = "AdditionalDataProcessingConsent"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USNJ_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNjField.VERSION, + UsNjField.PROCESSING_NOTICE, + UsNjField.SALE_OPT_OUT_NOTICE, + UsNjField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsNjField.SALE_OPT_OUT, + UsNjField.TARGETED_ADVERTISING_OPT_OUT, + UsNjField.SENSITIVE_DATA_PROCESSING, + UsNjField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsNjField.ADDITIONAL_DATA_PROCESSING_CONSENT, + UsNjField.MSPA_COVERED_TRANSACTION, + UsNjField.MSPA_OPT_OUT_OPTION_MODE, + UsNjField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USNJ_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsNjField.GPC_SEGMENT_TYPE, + UsNjField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsTnField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsTnField.java new file mode 100644 index 00000000..7ef8c75d --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsTnField.java @@ -0,0 +1,48 @@ +package com.iab.gpp.encoder.field; + +import java.util.Arrays; +import java.util.List; + +public class UsTnField { + + public static String VERSION = "Version"; + public static String PROCESSING_NOTICE = "ProcessingNotice"; + public static String SALE_OPT_OUT_NOTICE = "SaleOptOutNotice"; + public static String TARGETED_ADVERTISING_OPT_OUT_NOTICE = "TargetedAdvertisingOptOutNotice"; + public static String SALE_OPT_OUT = "SaleOptOut"; + public static String TARGETED_ADVERTISING_OPT_OUT = "TargetedAdvertisingOptOut"; + public static String SENSITIVE_DATA_PROCESSING = "SensitiveDataProcessing"; + public static String KNOWN_CHILD_SENSITIVE_DATA_CONSENTS = "KnownChildSensitiveDataConsents"; + public static String ADDITIONAL_DATA_PROCESSING_CONSENT = "AdditionalDataProcessingConsent"; + public static String MSPA_COVERED_TRANSACTION = "MspaCoveredTransaction"; + public static String MSPA_OPT_OUT_OPTION_MODE = "MspaOptOutOptionMode"; + public static String MSPA_SERVICE_PROVIDER_MODE = "MspaServiceProviderMode"; + + public static String GPC_SEGMENT_TYPE = "GpcSegmentType"; + public static String GPC_SEGMENT_INCLUDED = "GpcSegmentIncluded"; + public static String GPC = "Gpc"; + + //@formatter:off + public static List USTN_CORE_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsTnField.VERSION, + UsTnField.PROCESSING_NOTICE, + UsTnField.SALE_OPT_OUT_NOTICE, + UsTnField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsTnField.SALE_OPT_OUT, + UsTnField.TARGETED_ADVERTISING_OPT_OUT, + UsTnField.SENSITIVE_DATA_PROCESSING, + UsTnField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsTnField.ADDITIONAL_DATA_PROCESSING_CONSENT, + UsTnField.MSPA_COVERED_TRANSACTION, + UsTnField.MSPA_OPT_OUT_OPTION_MODE, + UsTnField.MSPA_SERVICE_PROVIDER_MODE + }); + //@formatter:on + + //@formatter:off + public static List USTN_GPC_SEGMENT_FIELD_NAMES = Arrays.asList(new String[] { + UsTnField.GPC_SEGMENT_TYPE, + UsTnField.GPC + }); + //@formatter:on +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/Sections.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/Sections.java index 7a867374..976805d3 100644 --- a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/Sections.java +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/Sections.java @@ -28,6 +28,12 @@ public class Sections { SECTION_ID_NAME_MAP.put(UsMt.ID, UsMt.NAME); SECTION_ID_NAME_MAP.put(UsOr.ID, UsOr.NAME); SECTION_ID_NAME_MAP.put(UsTx.ID, UsTx.NAME); + SECTION_ID_NAME_MAP.put(UsDe.ID, UsDe.NAME); + SECTION_ID_NAME_MAP.put(UsIa.ID, UsIa.NAME); + SECTION_ID_NAME_MAP.put(UsNe.ID, UsNe.NAME); + SECTION_ID_NAME_MAP.put(UsNh.ID, UsNh.NAME); + SECTION_ID_NAME_MAP.put(UsNj.ID, UsNj.NAME); + SECTION_ID_NAME_MAP.put(UsTn.ID, UsTn.NAME); SECTION_ORDER = new ArrayList(SECTION_ID_NAME_MAP.keySet()).stream().sorted() .map(id -> SECTION_ID_NAME_MAP.get(id)).collect(Collectors.toList()); diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsDe.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsDe.java new file mode 100644 index 00000000..82538ee7 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsDe.java @@ -0,0 +1,142 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsDeField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsDeCoreSegment; +import com.iab.gpp.encoder.segment.UsDeGpcSegment; + +public class UsDe extends AbstractLazilyEncodableSection { + + public static int ID = 17; + public static int VERSION = 1; + public static String NAME = "usde"; + + public UsDe() { + super(); + } + + public UsDe(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsDe.ID; + } + + @Override + public String getName() { + return UsDe.NAME; + } + + @Override + public int getVersion() { + return UsDe.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsDeCoreSegment()); + segments.add(new UsDeGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if (encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if (encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if (encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsDeField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsDeField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if (!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if (segments.size() >= 2 && segments.get(1).getFieldValue(UsDeField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsDeField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsDeField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsDeField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsDeField.SENSITIVE_DATA_PROCESSING); + } + + @SuppressWarnings("unchecked") + public List getKnownChildSensitiveDataConsents() { + return (List) this.getFieldValue(UsDeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsDeField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsDeField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsDeField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsDeField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsDeField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsDeField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsDeField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIa.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIa.java new file mode 100644 index 00000000..a3ab88e3 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIa.java @@ -0,0 +1,141 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsIaField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsIaCoreSegment; +import com.iab.gpp.encoder.segment.UsIaGpcSegment; + +public class UsIa extends AbstractLazilyEncodableSection { + + public static int ID = 18; + public static int VERSION = 1; + public static String NAME = "usia"; + + public UsIa() { + super(); + } + + public UsIa(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsIa.ID; + } + + @Override + public String getName() { + return UsIa.NAME; + } + + @Override + public int getVersion() { + return UsIa.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsIaCoreSegment()); + segments.add(new UsIaGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if (encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if (encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if (encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsIaField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsIaField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if (!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if (segments.size() >= 2 && segments.get(1).getFieldValue(UsIaField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsIaField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsIaField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSensitiveDataOptOutNotice() { + return (Integer) this.getFieldValue(UsIaField.SENSITIVE_DATA_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsIaField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsIaField.SENSITIVE_DATA_PROCESSING); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsIaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsIaField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsIaField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsIaField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsIaField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsIaField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsIaField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNe.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNe.java new file mode 100644 index 00000000..e8b7b882 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNe.java @@ -0,0 +1,141 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsNeField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsNeCoreSegment; +import com.iab.gpp.encoder.segment.UsNeGpcSegment; + +public class UsNe extends AbstractLazilyEncodableSection { + + public static int ID = 19; + public static int VERSION = 1; + public static String NAME = "usne"; + + public UsNe() { + super(); + } + + public UsNe(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsNe.ID; + } + + @Override + public String getName() { + return UsNe.NAME; + } + + @Override + public int getVersion() { + return UsNe.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsNeCoreSegment()); + segments.add(new UsNeGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if(encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if(encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if(encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsNeField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsNeField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if(!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if(segments.size() >= 2 && segments.get(1).getFieldValue(UsNeField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsNeField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsNeField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsNeField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsNeField.SENSITIVE_DATA_PROCESSING); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsNeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsNeField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsNeField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsNeField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsNeField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsNeField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsNeField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsNeField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNh.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNh.java new file mode 100644 index 00000000..7bf40fe2 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNh.java @@ -0,0 +1,142 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsNhField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsNhCoreSegment; +import com.iab.gpp.encoder.segment.UsNhGpcSegment; + +public class UsNh extends AbstractLazilyEncodableSection { + + public static int ID = 20; + public static int VERSION = 1; + public static String NAME = "usnh"; + + public UsNh() { + super(); + } + + public UsNh(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsNh.ID; + } + + @Override + public String getName() { + return UsNh.NAME; + } + + @Override + public int getVersion() { + return UsNh.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsNhCoreSegment()); + segments.add(new UsNhGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if(encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if(encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if(encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsNhField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsNhField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if(!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if(segments.size() >= 2 && segments.get(1).getFieldValue(UsNhField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsNhField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsNhField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsNhField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsNhField.SENSITIVE_DATA_PROCESSING); + } + + @SuppressWarnings("unchecked") + public List getKnownChildSensitiveDataConsents() { + return (List) this.getFieldValue(UsNhField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsNhField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsNhField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsNhField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsNhField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsNhField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsNhField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsNhField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNj.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNj.java new file mode 100644 index 00000000..f24e043f --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsNj.java @@ -0,0 +1,142 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsNjField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsNjCoreSegment; +import com.iab.gpp.encoder.segment.UsNjGpcSegment; + +public class UsNj extends AbstractLazilyEncodableSection { + + public static int ID = 21; + public static int VERSION = 1; + public static String NAME = "usnj"; + + public UsNj() { + super(); + } + + public UsNj(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsNj.ID; + } + + @Override + public String getName() { + return UsNj.NAME; + } + + @Override + public int getVersion() { + return UsNj.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsNjCoreSegment()); + segments.add(new UsNjGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if(encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if(encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if(encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsNjField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsNjField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if(!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if(segments.size() >= 2 && segments.get(1).getFieldValue(UsNjField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsNjField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsNjField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsNjField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsNjField.SENSITIVE_DATA_PROCESSING); + } + + @SuppressWarnings("unchecked") + public List getKnownChildSensitiveDataConsents() { + return (List) this.getFieldValue(UsNjField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsNjField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsNjField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsNjField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsNjField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsNjField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsNjField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsNjField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsTn.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsTn.java new file mode 100644 index 00000000..2403f09d --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsTn.java @@ -0,0 +1,141 @@ +package com.iab.gpp.encoder.section; + +import java.util.ArrayList; +import java.util.List; +import com.iab.gpp.encoder.field.UsTnField; +import com.iab.gpp.encoder.segment.EncodableSegment; +import com.iab.gpp.encoder.segment.UsTnCoreSegment; +import com.iab.gpp.encoder.segment.UsTnGpcSegment; + +public class UsTn extends AbstractLazilyEncodableSection { + + public static int ID = 22; + public static int VERSION = 1; + public static String NAME = "ustn"; + + public UsTn() { + super(); + } + + public UsTn(String encodedString) { + super(); + decode(encodedString); + } + + @Override + public int getId() { + return UsTn.ID; + } + + @Override + public String getName() { + return UsTn.NAME; + } + + @Override + public int getVersion() { + return UsTn.VERSION; + } + + @Override + protected List initializeSegments() { + List segments = new ArrayList<>(); + segments.add(new UsTnCoreSegment()); + segments.add(new UsTnGpcSegment()); + return segments; + } + + @Override + protected List decodeSection(String encodedString) { + List segments = initializeSegments(); + + if(encodedString != null && !encodedString.isEmpty()) { + String[] encodedSegments = encodedString.split("\\."); + + if(encodedSegments.length > 0) { + segments.get(0).decode(encodedSegments[0]); + } + + if(encodedSegments.length > 1) { + segments.get(1).setFieldValue(UsTnField.GPC_SEGMENT_INCLUDED, true); + segments.get(1).decode(encodedSegments[1]); + } else { + segments.get(1).setFieldValue(UsTnField.GPC_SEGMENT_INCLUDED, false); + } + } + + return segments; + } + + @Override + protected String encodeSection(List segments) { + List encodedSegments = new ArrayList<>(); + + if(!segments.isEmpty()) { + encodedSegments.add(segments.get(0).encode()); + if(segments.size() >= 2 && segments.get(1).getFieldValue(UsTnField.GPC_SEGMENT_INCLUDED).equals(true)) { + encodedSegments.add(segments.get(1).encode()); + } + } + + return String.join(".", encodedSegments); + } + + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsTnField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsTnField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsTnField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT); + } + + @SuppressWarnings("unchecked") + public List getSensitiveDataProcessing() { + return (List) this.getFieldValue(UsTnField.SENSITIVE_DATA_PROCESSING); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsTnField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsTnField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsTnField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaOptOutOptionMode() { + return (Integer) this.getFieldValue(UsTnField.MSPA_OPT_OUT_OPTION_MODE); + } + + public Integer getMspaServiceProviderMode() { + return (Integer) this.getFieldValue(UsTnField.MSPA_SERVICE_PROVIDER_MODE); + } + + public Integer getGpcSegmentType() { + return (Integer) this.getFieldValue(UsTnField.GPC_SEGMENT_TYPE); + } + + public Boolean getGpcSegmentIncluded() { + return (Boolean) this.getFieldValue(UsTnField.GPC_SEGMENT_INCLUDED); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsTnField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeCoreSegment.java new file mode 100644 index 00000000..a011faa0 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeCoreSegment.java @@ -0,0 +1,98 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsDeField; +import com.iab.gpp.encoder.field.UsVaField; +import com.iab.gpp.encoder.section.UsDe; + +public class UsDeCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsDeCoreSegment() { + super(); + } + + public UsDeCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsDeField.USDE_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsDeField.VERSION, new EncodableFixedInteger(6, UsDe.VERSION)); + fields.put(UsDeField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsVaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsDeField.ADDITIONAL_DATA_PROCESSING_CONSENT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsDeField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsDeCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeGpcSegment.java new file mode 100644 index 00000000..66fe0431 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsDeGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsDeField; + +public class UsDeGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsDeGpcSegment() { + super(); + } + + public UsDeGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsDeField.USDE_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsDeField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsDeField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsDeField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsDeGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaCoreSegment.java new file mode 100644 index 00000000..9cd9a917 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaCoreSegment.java @@ -0,0 +1,97 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsIaField; +import com.iab.gpp.encoder.field.UsVaField; +import com.iab.gpp.encoder.section.UsIa; + +public class UsIaCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsIaCoreSegment() { + super(); + } + + public UsIaCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsIaField.USIA_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsIaField.VERSION, new EncodableFixedInteger(6, UsIa.VERSION)); + fields.put(UsIaField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.SENSITIVE_DATA_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsVaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsIaField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsIaCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaGpcSegment.java new file mode 100644 index 00000000..12cb0bd6 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsIaGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsIaField; + +public class UsIaGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsIaGpcSegment() { + super(); + } + + public UsIaGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsIaField.USIA_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsIaField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsIaField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsIaField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsIaGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNatCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNatCoreSegment.java index 6b148ea9..204ea2f3 100644 --- a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNatCoreSegment.java +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNatCoreSegment.java @@ -67,9 +67,9 @@ protected EncodableBitStringFields initializeFields() { fields.put(UsNatField.TARGETED_ADVERTISING_OPT_OUT, new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); fields.put(UsNatField.SENSITIVE_DATA_PROCESSING, - new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); - fields.put(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, new EncodableFixedIntegerList(2, Arrays.asList(0, 0)) + fields.put(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0)) .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); fields.put(UsNatField.PERSONAL_DATA_CONSENTS, new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); @@ -96,6 +96,15 @@ protected void decodeSegment(String encodedString, EncodableBitStringFields fiel } try { String bitString = base64UrlEncoder.decode(encodedString); + + // Necessary to maintain backwards compatibility when sensitive data processing changed from a + // length of 12 to 16 and known child sensitive data consents changed from a length of 2 to 3 in the + // DE, IA, NE, NH, NJ, TN release + if (bitString.length() == 66) { + bitString = + bitString.substring(0, 48) + "00000000" + bitString.substring(48, 52) + "00" + bitString.substring(52, 62); + } + bitStringEncoder.decode(bitString, getFieldNames(), fields); } catch (Exception e) { throw new DecodingException("Unable to decode UsNatCoreSegment '" + encodedString + "'", e); @@ -115,8 +124,7 @@ public void validate() { ((EncodableFixedInteger) fields.get(UsNatField.TARGETED_ADVERTISING_OPT_OUT)).getValue(); Integer mspaServiceProviderMode = ((EncodableFixedInteger) fields.get(UsNatField.MSPA_SERVICE_PROVIDER_MODE)).getValue(); - Integer mspaOptOutOptionMode = - ((EncodableFixedInteger) fields.get(UsNatField.MSPA_OPT_OUT_OPTION_MODE)).getValue(); + Integer mspaOptOutOptionMode = ((EncodableFixedInteger) fields.get(UsNatField.MSPA_OPT_OUT_OPTION_MODE)).getValue(); Integer sensitiveDataLimtUserNotice = ((EncodableFixedInteger) fields.get(UsNatField.SENSITIVE_DATA_LIMIT_USE_NOTICE)).getValue(); diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeCoreSegment.java new file mode 100644 index 00000000..7a98c30f --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeCoreSegment.java @@ -0,0 +1,97 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNeField; +import com.iab.gpp.encoder.field.UsVaField; +import com.iab.gpp.encoder.section.UsNe; + +public class UsNeCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNeCoreSegment() { + super(); + } + + public UsNeCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNeField.USNE_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNeField.VERSION, new EncodableFixedInteger(6, UsNe.VERSION)); + fields.put(UsNeField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsVaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.ADDITIONAL_DATA_PROCESSING_CONSENT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNeField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNeCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeGpcSegment.java new file mode 100644 index 00000000..6d050371 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNeGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNeField; + +public class UsNeGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNeGpcSegment() { + super(); + } + + public UsNeGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNeField.USNE_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNeField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsNeField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsNeField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNeGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhCoreSegment.java new file mode 100644 index 00000000..76fedd66 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhCoreSegment.java @@ -0,0 +1,96 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNhField; +import com.iab.gpp.encoder.section.UsNh; + +public class UsNhCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNhCoreSegment() { + super(); + } + + public UsNhCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNhField.USNH_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNhField.VERSION, new EncodableFixedInteger(6, UsNh.VERSION)); + fields.put(UsNhField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsNhField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsNhField.ADDITIONAL_DATA_PROCESSING_CONSENT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNhField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNhCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhGpcSegment.java new file mode 100644 index 00000000..86587dd0 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNhGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNhField; + +public class UsNhGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNhGpcSegment() { + super(); + } + + public UsNhGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNhField.USNH_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNhField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsNhField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsNhField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNhGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjCoreSegment.java new file mode 100644 index 00000000..e71fecc1 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjCoreSegment.java @@ -0,0 +1,96 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNjField; +import com.iab.gpp.encoder.section.UsNj; + +public class UsNjCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNjCoreSegment() { + super(); + } + + public UsNjCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNjField.USNJ_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNjField.VERSION, new EncodableFixedInteger(6, UsNj.VERSION)); + fields.put(UsNjField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsNjField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsNjField.ADDITIONAL_DATA_PROCESSING_CONSENT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsNjField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNjCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjGpcSegment.java new file mode 100644 index 00000000..37ee7d34 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsNjGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsNjField; + +public class UsNjGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsNjGpcSegment() { + super(); + } + + public UsNjGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsNjField.USNJ_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsNjField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsNjField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsNjField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsNjGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnCoreSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnCoreSegment.java new file mode 100644 index 00000000..425f1305 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnCoreSegment.java @@ -0,0 +1,96 @@ +package com.iab.gpp.encoder.segment; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsTnField; +import com.iab.gpp.encoder.section.UsTn; + +public class UsTnCoreSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsTnCoreSegment() { + super(); + } + + public UsTnCoreSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsTnField.USTN_CORE_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + Predicate nullableBooleanAsTwoBitIntegerValidator = (n -> n >= 0 && n <= 2); + Predicate nonNullableBooleanAsTwoBitIntegerValidator = (n -> n >= 1 && n <= 2); + Predicate> nullableBooleanAsTwoBitIntegerListValidator = (l -> { + for (int n : l) { + if (n < 0 || n > 2) { + return false; + } + } + return true; + }); + + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsTnField.VERSION, new EncodableFixedInteger(6, UsTn.VERSION)); + fields.put(UsTnField.PROCESSING_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.SALE_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.SALE_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.TARGETED_ADVERTISING_OPT_OUT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.SENSITIVE_DATA_PROCESSING, + new EncodableFixedIntegerList(2, Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0)) + .withValidator(nullableBooleanAsTwoBitIntegerListValidator)); + fields.put(UsTnField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.ADDITIONAL_DATA_PROCESSING_CONSENT, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.MSPA_COVERED_TRANSACTION, + new EncodableFixedInteger(2, 1).withValidator(nonNullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.MSPA_OPT_OUT_OPTION_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + fields.put(UsTnField.MSPA_SERVICE_PROVIDER_MODE, + new EncodableFixedInteger(2, 0).withValidator(nullableBooleanAsTwoBitIntegerValidator)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if (encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsTnCoreSegment '" + encodedString + "'", e); + } + } + +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnGpcSegment.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnGpcSegment.java new file mode 100644 index 00000000..f4a0b32c --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/segment/UsTnGpcSegment.java @@ -0,0 +1,60 @@ +package com.iab.gpp.encoder.segment; + +import java.util.List; +import com.iab.gpp.encoder.base64.AbstractBase64UrlEncoder; +import com.iab.gpp.encoder.base64.CompressedBase64UrlEncoder; +import com.iab.gpp.encoder.bitstring.BitStringEncoder; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.field.EncodableBitStringFields; +import com.iab.gpp.encoder.field.UsTnField; + +public class UsTnGpcSegment extends AbstractLazilyEncodableSegment { + + private AbstractBase64UrlEncoder base64UrlEncoder = CompressedBase64UrlEncoder.getInstance(); + private BitStringEncoder bitStringEncoder = BitStringEncoder.getInstance(); + + public UsTnGpcSegment() { + super(); + } + + public UsTnGpcSegment(String encodedString) { + super(); + this.decode(encodedString); + } + + @Override + public List getFieldNames() { + return UsTnField.USTN_GPC_SEGMENT_FIELD_NAMES; + } + + @Override + protected EncodableBitStringFields initializeFields() { + EncodableBitStringFields fields = new EncodableBitStringFields(); + fields.put(UsTnField.GPC_SEGMENT_TYPE, new EncodableFixedInteger(2, 1)); + fields.put(UsTnField.GPC_SEGMENT_INCLUDED, new EncodableBoolean(true)); + fields.put(UsTnField.GPC, new EncodableBoolean(false)); + return fields; + } + + @Override + protected String encodeSegment(EncodableBitStringFields fields) { + String bitString = bitStringEncoder.encode(fields, getFieldNames()); + String encodedString = base64UrlEncoder.encode(bitString); + return encodedString; + } + + @Override + protected void decodeSegment(String encodedString, EncodableBitStringFields fields) { + if(encodedString == null || encodedString.isEmpty()) { + this.fields.reset(fields); + } + try { + String bitString = base64UrlEncoder.decode(encodedString); + bitStringEncoder.decode(bitString, getFieldNames(), fields); + } catch (Exception e) { + throw new DecodingException("Unable to decode UsTnGpcSegment '" + encodedString + "'", e); + } + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java index 8e83b800..9a6e9609 100644 --- a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java @@ -25,10 +25,16 @@ import com.iab.gpp.encoder.section.UsCa; import com.iab.gpp.encoder.section.UsCo; import com.iab.gpp.encoder.section.UsCt; +import com.iab.gpp.encoder.section.UsDe; import com.iab.gpp.encoder.section.UsFl; +import com.iab.gpp.encoder.section.UsIa; import com.iab.gpp.encoder.section.UsMt; import com.iab.gpp.encoder.section.UsNat; +import com.iab.gpp.encoder.section.UsNe; +import com.iab.gpp.encoder.section.UsNh; +import com.iab.gpp.encoder.section.UsNj; import com.iab.gpp.encoder.section.UsOr; +import com.iab.gpp.encoder.section.UsTn; import com.iab.gpp.encoder.section.UsTx; import com.iab.gpp.encoder.section.UsUt; import com.iab.gpp.encoder.section.UsVa; @@ -94,6 +100,12 @@ public void testEncodeDefaultAll() { Assertions.assertEquals(false, gppModel.hasSection(UsMt.NAME)); Assertions.assertEquals(false, gppModel.hasSection(UsOr.NAME)); Assertions.assertEquals(false, gppModel.hasSection(UsTx.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsDe.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsIa.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsNe.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsNh.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsNj.NAME)); + Assertions.assertEquals(false, gppModel.hasSection(UsTn.NAME)); gppModel.setFieldValue(TcfEuV2.NAME, TcfEuV2Field.VERSION, TcfEuV2.VERSION); gppModel.setFieldValue(TcfEuV2.NAME, TcfCaV1Field.CREATED, utcDateTime); @@ -112,6 +124,12 @@ public void testEncodeDefaultAll() { gppModel.setFieldValue(UsMt.NAME, UsMtField.VERSION, UsMt.VERSION); gppModel.setFieldValue(UsOr.NAME, UsOrField.VERSION, UsOr.VERSION); gppModel.setFieldValue(UsTx.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsDe.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsIa.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsNe.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsNh.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsNj.NAME, UsTxField.VERSION, UsTx.VERSION); + gppModel.setFieldValue(UsTn.NAME, UsTxField.VERSION, UsTx.VERSION); @@ -128,10 +146,16 @@ public void testEncodeDefaultAll() { Assertions.assertEquals(true, gppModel.hasSection(UsMt.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsOr.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsTx.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsDe.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsIa.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNe.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNh.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNj.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsTn.NAME)); String gppString = gppModel.encode(); Assertions.assertEquals( - "DBACOZY~CPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAAAA.QAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~BAAAAAAAAQA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA~BAAAAABA~BAAAAABA.QA~BAAAAAABAA.QA~BAAAAAQA.QA", + "DBACOdM~CPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAAAA.QAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~BAAAAAAAAABA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA~BAAAAABA~BAAAAABA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAQA.QA~BAAAAABA.QA~BAAAAAAAQA.QA~BAAAAAQA.QA", gppString); } @@ -391,7 +415,7 @@ public void testDecodeDefaults() { @Test public void testDecodeDefaultsAll() { String gppString = - "DBACOaw~CPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAAAA.QAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~BAAAAAAAAQA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA"; + "DBACOdM~CPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAAAA.QAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~BAAAAAAAAABA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA~BAAAAABA~BAAAAABA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAQA.QA~BAAAAABA.QA~BAAAAAAAQA.QA~BAAAAAQA.QA"; GppModel gppModel = new GppModel(gppString); Assertions.assertEquals(true, gppModel.hasSection(TcfEuV2.NAME)); @@ -403,6 +427,16 @@ public void testDecodeDefaultsAll() { Assertions.assertEquals(true, gppModel.hasSection(UsCo.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsUt.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsCt.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsFl.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsMt.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsOr.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsTx.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsDe.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsIa.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNe.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNh.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsNj.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsTn.NAME)); } @Test @@ -676,6 +710,52 @@ public void testDecode4() { } + @Test + public void testDecode5() { + GppModel gppModel = new GppModel("DBABLA~BVQqAAAAAgA.QA"); + gppModel.getFieldValue(UsNat.NAME, UspV1Field.VERSION); + } + + @Test + public void testDecode6() { + GppModel gppModel = new GppModel("DBABLA~BAAAAAAAAQA.QA"); + gppModel.getFieldValue(UsNat.NAME, UspV1Field.VERSION); + Assertions.assertEquals(Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.SENSITIVE_DATA_PROCESSING)); + Assertions.assertEquals(Arrays.asList(0, 0, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS)); + } + + @Test + public void testDecode7() { + GppModel gppModel = new GppModel("DBABLA~BAAAAAAAAABA.QA"); + gppModel.getFieldValue(UsNat.NAME, UspV1Field.VERSION); + Assertions.assertEquals(Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.SENSITIVE_DATA_PROCESSING)); + Assertions.assertEquals(Arrays.asList(0, 0, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS)); + } + + @Test + public void testDecode8() { + GppModel gppModel = new GppModel("DBABLA~BAAAAAABEQA.QA"); + gppModel.getFieldValue(UsNat.NAME, UspV1Field.VERSION); + Assertions.assertEquals(Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.SENSITIVE_DATA_PROCESSING)); + Assertions.assertEquals(Arrays.asList(0, 1, 0), + gppModel.getFieldValue(UsNat.NAME, UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS)); + } + + @Test + public void testDecode9() { + GppModel gppModel = new GppModel("DBABLA~BAAAAAAAAQRA.QA"); + gppModel.getFieldValue(UsNat.NAME, UspV1Field.VERSION); + Assertions.assertEquals(Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1), + gppModel.getFieldValue(UsNat.NAME, UsNatField.SENSITIVE_DATA_PROCESSING)); + Assertions.assertEquals(Arrays.asList(0, 0, 1), + gppModel.getFieldValue(UsNat.NAME, UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS)); + } + @Test public void testConsistency() { GppModel fromObjectModel = new GppModel(); @@ -741,4 +821,6 @@ public void testDecodingEmptyString() { gppModel.setFieldValue("uspv1", UspV1Field.NOTICE, 'Y'); Assertions.assertEquals("DBABTA~1Y--", gppModel.encode()); } + + } diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsDeTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsDeTest.java new file mode 100644 index 00000000..30341616 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsDeTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsDeField; + +public class UsDeTest { + + @Test + public void testEncode1() { + UsDe usDe = new UsDe(); + Assertions.assertEquals("BAAAAAABAA.QA", usDe.encode()); + } + + @Test + public void testEncode2() { + UsDe usDe = new UsDe(); + + usDe.setFieldValue(UsDeField.PROCESSING_NOTICE, 1); + usDe.setFieldValue(UsDeField.SALE_OPT_OUT_NOTICE, 1); + usDe.setFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usDe.setFieldValue(UsDeField.SALE_OPT_OUT, 1); + usDe.setFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT, 1); + usDe.setFieldValue(UsDeField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0)); + usDe.setFieldValue(UsDeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1, 0, 2, 1)); + usDe.setFieldValue(UsDeField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usDe.setFieldValue(UsDeField.MSPA_COVERED_TRANSACTION, 1); + usDe.setFieldValue(UsDeField.MSPA_OPT_OUT_OPTION_MODE, 1); + usDe.setFieldValue(UsDeField.MSPA_SERVICE_PROVIDER_MODE, 2); + usDe.setFieldValue(UsDeField.GPC, true); + + Assertions.assertEquals("BVWSSSSVYA.YA", usDe.encode()); + } + + @Test + public void testSetInvalidValues() { + UsDe usDe = new UsDe(); + + try { + usDe.setFieldValue(UsDeField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(1, 2, 3)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usDe.setFieldValue(UsDeField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsDe usDe = new UsDe(); + usDe.setFieldValue(UsDeField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAAABAA", usDe.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsDe usDe = new UsDe("BVWSSSSVYA.YA"); + + Assertions.assertEquals(1, usDe.getProcessingNotice()); + Assertions.assertEquals(1, usDe.getSaleOptOutNotice()); + Assertions.assertEquals(1, usDe.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usDe.getSaleOptOut()); + Assertions.assertEquals(1, usDe.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0), usDe.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1), usDe.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usDe.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usDe.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usDe.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usDe.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usDe.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsDe usDe = new UsDe("BVWSSSSVYA"); + + Assertions.assertEquals(1, usDe.getProcessingNotice()); + Assertions.assertEquals(1, usDe.getSaleOptOutNotice()); + Assertions.assertEquals(1, usDe.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usDe.getSaleOptOut()); + Assertions.assertEquals(1, usDe.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0), usDe.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1), usDe.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usDe.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usDe.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usDe.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usDe.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usDe.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsDe("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsIaTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsIaTest.java new file mode 100644 index 00000000..4171eac1 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsIaTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsIaField; + +public class UsIaTest { + + @Test + public void testEncode1() { + UsIa usIa = new UsIa(); + Assertions.assertEquals("BAAAAAQA.QA", usIa.encode()); + } + + @Test + public void testEncode2() { + UsIa usIa = new UsIa(); + + usIa.setFieldValue(UsIaField.PROCESSING_NOTICE, 1); + usIa.setFieldValue(UsIaField.SALE_OPT_OUT_NOTICE, 1); + usIa.setFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usIa.setFieldValue(UsIaField.SENSITIVE_DATA_OPT_OUT_NOTICE, 1); + usIa.setFieldValue(UsIaField.SALE_OPT_OUT, 1); + usIa.setFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT, 1); + usIa.setFieldValue(UsIaField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usIa.setFieldValue(UsIaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usIa.setFieldValue(UsIaField.MSPA_COVERED_TRANSACTION, 1); + usIa.setFieldValue(UsIaField.MSPA_OPT_OUT_OPTION_MODE, 1); + usIa.setFieldValue(UsIaField.MSPA_SERVICE_PROVIDER_MODE, 2); + usIa.setFieldValue(UsIaField.GPC, true); + + Assertions.assertEquals("BVVkklWA.YA", usIa.encode()); + } + + @Test + public void testSetInvalidValues() { + UsIa usIa = new UsIa(); + + try { + usIa.setFieldValue(UsIaField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.SENSITIVE_DATA_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIa.setFieldValue(UsIaField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsIa usIa = new UsIa(); + usIa.setFieldValue(UsIaField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAAQA", usIa.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsIa usIa = new UsIa("BVVkklWA.YA"); + + Assertions.assertEquals(1, usIa.getProcessingNotice()); + Assertions.assertEquals(1, usIa.getSaleOptOutNotice()); + Assertions.assertEquals(1, usIa.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usIa.getSensitiveDataOptOutNotice()); + Assertions.assertEquals(1, usIa.getSaleOptOut()); + Assertions.assertEquals(1, usIa.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usIa.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usIa.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usIa.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usIa.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usIa.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usIa.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsIa usIa = new UsIa("BVVkklWA"); + + Assertions.assertEquals(1, usIa.getProcessingNotice()); + Assertions.assertEquals(1, usIa.getSaleOptOutNotice()); + Assertions.assertEquals(1, usIa.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usIa.getSensitiveDataOptOutNotice()); + Assertions.assertEquals(1, usIa.getSaleOptOut()); + Assertions.assertEquals(1, usIa.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usIa.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usIa.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usIa.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usIa.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usIa.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usIa.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsIa("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNatTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNatTest.java index 52c8f589..85ee7013 100644 --- a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNatTest.java +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNatTest.java @@ -14,7 +14,7 @@ public class UsNatTest { public void testEncode1() { UsNat usNat = new UsNat(); - Assertions.assertEquals("BAAAAAAAAQA.QA", usNat.encode()); + Assertions.assertEquals("BAAAAAAAAABA.QA", usNat.encode()); } @Test @@ -30,15 +30,15 @@ public void testEncode2() { usNat.setFieldValue(UsNatField.SALE_OPT_OUT, 1); usNat.setFieldValue(UsNatField.SHARING_OPT_OUT, 1); usNat.setFieldValue(UsNatField.TARGETED_ADVERTISING_OPT_OUT, 1); - usNat.setFieldValue(UsNatField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0)); - usNat.setFieldValue(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1)); + usNat.setFieldValue(UsNatField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2)); + usNat.setFieldValue(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1, 0)); usNat.setFieldValue(UsNatField.PERSONAL_DATA_CONSENTS, 1); usNat.setFieldValue(UsNatField.MSPA_COVERED_TRANSACTION, 1); usNat.setFieldValue(UsNatField.MSPA_OPT_OUT_OPTION_MODE, 1); usNat.setFieldValue(UsNatField.MSPA_SERVICE_PROVIDER_MODE, 2); usNat.setFieldValue(UsNatField.GPC, true); - Assertions.assertEquals("BVVVkkkklWA.YA", usNat.encode()); + Assertions.assertEquals("BVVVkkkkkpFY.YA", usNat.encode()); } @Test @@ -575,15 +575,15 @@ public void testEncode3() { usNat.setFieldValue(UsNatField.SALE_OPT_OUT, 1); usNat.setFieldValue(UsNatField.SHARING_OPT_OUT, 1); usNat.setFieldValue(UsNatField.TARGETED_ADVERTISING_OPT_OUT, 1); - usNat.setFieldValue(UsNatField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0)); - usNat.setFieldValue(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1)); + usNat.setFieldValue(UsNatField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2)); + usNat.setFieldValue(UsNatField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1, 0)); usNat.setFieldValue(UsNatField.PERSONAL_DATA_CONSENTS, 1); usNat.setFieldValue(UsNatField.MSPA_COVERED_TRANSACTION, 1); usNat.setFieldValue(UsNatField.MSPA_OPT_OUT_OPTION_MODE, 1); usNat.setFieldValue(UsNatField.MSPA_SERVICE_PROVIDER_MODE, 2); usNat.setFieldValue(UsNatField.GPC, true); - Assertions.assertEquals("BVVVkkkklWA.YA", usNat.encode()); + Assertions.assertEquals("BVVVkkkkkpFY.YA", usNat.encode()); } @Test @@ -591,12 +591,12 @@ public void testEncodeWithGpcSegmentIncluded() { UsNat usNat = new UsNat(); usNat.setFieldValue(UsNatField.GPC_SEGMENT_INCLUDED, false); - Assertions.assertEquals("BAAAAAAAAQA", usNat.encode()); + Assertions.assertEquals("BAAAAAAAAABA", usNat.encode()); } @Test public void testDecode1() throws DecodingException { - UsNat usNat = new UsNat("BVVVkkkklWA.YA"); + UsNat usNat = new UsNat("BVVVkkkkkpFY.YA"); Assertions.assertEquals(1, usNat.getSharingNotice()); Assertions.assertEquals(1, usNat.getSaleOptOutNotice()); @@ -607,8 +607,8 @@ public void testDecode1() throws DecodingException { Assertions.assertEquals(1, usNat.getSaleOptOut()); Assertions.assertEquals(1, usNat.getSharingOptOut()); Assertions.assertEquals(1, usNat.getTargetedAdvertisingOptOut()); - Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0), usNat.getSensitiveDataProcessing()); - Assertions.assertEquals(Arrays.asList(2, 1), usNat.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2), usNat.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0), usNat.getKnownChildSensitiveDataConsents()); Assertions.assertEquals(1, usNat.getPersonalDataConsents()); Assertions.assertEquals(1, usNat.getMspaCoveredTransaction()); Assertions.assertEquals(1, usNat.getMspaOptOutOptionMode()); @@ -618,7 +618,7 @@ public void testDecode1() throws DecodingException { @Test public void testDecodeWithGpcSegmentExcluded() throws DecodingException { - UsNat usNat = new UsNat("BVVVkkkklWA"); + UsNat usNat = new UsNat("BVVVkkkkkpFY"); Assertions.assertEquals(1, usNat.getSharingNotice()); Assertions.assertEquals(1, usNat.getSaleOptOutNotice()); @@ -629,8 +629,8 @@ public void testDecodeWithGpcSegmentExcluded() throws DecodingException { Assertions.assertEquals(1, usNat.getSaleOptOut()); Assertions.assertEquals(1, usNat.getSharingOptOut()); Assertions.assertEquals(1, usNat.getTargetedAdvertisingOptOut()); - Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0), usNat.getSensitiveDataProcessing()); - Assertions.assertEquals(Arrays.asList(2, 1), usNat.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2), usNat.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0), usNat.getKnownChildSensitiveDataConsents()); Assertions.assertEquals(1, usNat.getPersonalDataConsents()); Assertions.assertEquals(1, usNat.getMspaCoveredTransaction()); Assertions.assertEquals(1, usNat.getMspaOptOutOptionMode()); diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNeTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNeTest.java new file mode 100644 index 00000000..e9e25743 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNeTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsNeField; + +public class UsNeTest { + + @Test + public void testEncode1() { + UsNe usNe = new UsNe(); + Assertions.assertEquals("BAAAAAQA.QA", usNe.encode()); + } + + @Test + public void testEncode2() { + UsNe usNe = new UsNe(); + + usNe.setFieldValue(UsNeField.PROCESSING_NOTICE, 1); + usNe.setFieldValue(UsNeField.SALE_OPT_OUT_NOTICE, 1); + usNe.setFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usNe.setFieldValue(UsNeField.SALE_OPT_OUT, 1); + usNe.setFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT, 1); + usNe.setFieldValue(UsNeField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usNe.setFieldValue(UsNeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usNe.setFieldValue(UsNeField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usNe.setFieldValue(UsNeField.MSPA_COVERED_TRANSACTION, 1); + usNe.setFieldValue(UsNeField.MSPA_OPT_OUT_OPTION_MODE, 1); + usNe.setFieldValue(UsNeField.MSPA_SERVICE_PROVIDER_MODE, 2); + usNe.setFieldValue(UsNeField.GPC, true); + + Assertions.assertEquals("BVWSSVWA.YA", usNe.encode()); + } + + @Test + public void testSetInvalidValues() { + UsNe usNe = new UsNe(); + + try { + usNe.setFieldValue(UsNeField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNe.setFieldValue(UsNeField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsNe usNe = new UsNe(); + usNe.setFieldValue(UsNeField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAAQA", usNe.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsNe usNe = new UsNe("BVWSSVWA.YA"); + + Assertions.assertEquals(1, usNe.getProcessingNotice()); + Assertions.assertEquals(1, usNe.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNe.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNe.getSaleOptOut()); + Assertions.assertEquals(1, usNe.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usNe.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usNe.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNe.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNe.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNe.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNe.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usNe.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsNe usNe = new UsNe("BVWSSVWA"); + + Assertions.assertEquals(1, usNe.getProcessingNotice()); + Assertions.assertEquals(1, usNe.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNe.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNe.getSaleOptOut()); + Assertions.assertEquals(1, usNe.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usNe.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usNe.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNe.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNe.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNe.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNe.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usNe.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsNe("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNhTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNhTest.java new file mode 100644 index 00000000..3211f9fc --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNhTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsNhField; + +public class UsNhTest { + + @Test + public void testEncode1() { + UsNh usNh = new UsNh(); + Assertions.assertEquals("BAAAAABA.QA", usNh.encode()); + } + + @Test + public void testEncode2() { + UsNh usNh = new UsNh(); + + usNh.setFieldValue(UsNhField.PROCESSING_NOTICE, 1); + usNh.setFieldValue(UsNhField.SALE_OPT_OUT_NOTICE, 1); + usNh.setFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usNh.setFieldValue(UsNhField.SALE_OPT_OUT, 1); + usNh.setFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT, 1); + usNh.setFieldValue(UsNhField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usNh.setFieldValue(UsNhField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1, 0)); + usNh.setFieldValue(UsNhField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usNh.setFieldValue(UsNhField.MSPA_COVERED_TRANSACTION, 1); + usNh.setFieldValue(UsNhField.MSPA_OPT_OUT_OPTION_MODE, 1); + usNh.setFieldValue(UsNhField.MSPA_SERVICE_PROVIDER_MODE, 2); + usNh.setFieldValue(UsNhField.GPC, true); + + Assertions.assertEquals("BVWSSZFY.YA", usNh.encode()); + } + + @Test + public void testSetInvalidValues() { + UsNh usNh = new UsNh(); + + try { + usNh.setFieldValue(UsNhField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(1, 2, 3)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNh.setFieldValue(UsNhField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsNh usNh = new UsNh(); + usNh.setFieldValue(UsNhField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAABA", usNh.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsNh usNh = new UsNh("BVWSSZFY.YA"); + + Assertions.assertEquals(1, usNh.getProcessingNotice()); + Assertions.assertEquals(1, usNh.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNh.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNh.getSaleOptOut()); + Assertions.assertEquals(1, usNh.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usNh.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0), usNh.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNh.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNh.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNh.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNh.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usNh.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsNh usNh = new UsNh("BVWSSZFY"); + + Assertions.assertEquals(1, usNh.getProcessingNotice()); + Assertions.assertEquals(1, usNh.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNh.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNh.getSaleOptOut()); + Assertions.assertEquals(1, usNh.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usNh.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0), usNh.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNh.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNh.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNh.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNh.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usNh.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsNh("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNjTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNjTest.java new file mode 100644 index 00000000..afda60bb --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsNjTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsNjField; + +public class UsNjTest { + + @Test + public void testEncode1() { + UsNj usNj = new UsNj(); + Assertions.assertEquals("BAAAAAAAQA.QA", usNj.encode()); + } + + @Test + public void testEncode2() { + UsNj usNj = new UsNj(); + + usNj.setFieldValue(UsNjField.PROCESSING_NOTICE, 1); + usNj.setFieldValue(UsNjField.SALE_OPT_OUT_NOTICE, 1); + usNj.setFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usNj.setFieldValue(UsNjField.SALE_OPT_OUT, 1); + usNj.setFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT, 1); + usNj.setFieldValue(UsNjField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 1)); + usNj.setFieldValue(UsNjField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(2, 1, 0, 2, 1)); + usNj.setFieldValue(UsNjField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usNj.setFieldValue(UsNjField.MSPA_COVERED_TRANSACTION, 1); + usNj.setFieldValue(UsNjField.MSPA_OPT_OUT_OPTION_MODE, 1); + usNj.setFieldValue(UsNjField.MSPA_SERVICE_PROVIDER_MODE, 2); + usNj.setFieldValue(UsNjField.GPC, true); + + Assertions.assertEquals("BVWSSRklWA.YA", usNj.encode()); + } + + @Test + public void testSetInvalidValues() { + UsNj usNj = new UsNj(); + + try { + usNj.setFieldValue(UsNjField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, Arrays.asList(1, 2, 3)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usNj.setFieldValue(UsNjField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsNj usNj = new UsNj(); + usNj.setFieldValue(UsNjField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAAAAQA", usNj.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsNj usNj = new UsNj("BVWSSRklWA.YA"); + + Assertions.assertEquals(1, usNj.getProcessingNotice()); + Assertions.assertEquals(1, usNj.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNj.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNj.getSaleOptOut()); + Assertions.assertEquals(1, usNj.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 1), usNj.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1), usNj.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNj.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNj.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNj.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNj.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usNj.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsNj usNj = new UsNj("BVWSSRklWA"); + + Assertions.assertEquals(1, usNj.getProcessingNotice()); + Assertions.assertEquals(1, usNj.getSaleOptOutNotice()); + Assertions.assertEquals(1, usNj.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usNj.getSaleOptOut()); + Assertions.assertEquals(1, usNj.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1, 0, 1), usNj.getSensitiveDataProcessing()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1), usNj.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usNj.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usNj.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usNj.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usNj.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usNj.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsNj("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsTnTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsTnTest.java new file mode 100644 index 00000000..8d0cae7d --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsTnTest.java @@ -0,0 +1,170 @@ +package com.iab.gpp.encoder.section; + + +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsTnField; + +public class UsTnTest { + + @Test + public void testEncode1() { + UsTn usTn = new UsTn(); + Assertions.assertEquals("BAAAAAQA.QA", usTn.encode()); + } + + @Test + public void testEncode2() { + UsTn usTn = new UsTn(); + + usTn.setFieldValue(UsTnField.PROCESSING_NOTICE, 1); + usTn.setFieldValue(UsTnField.SALE_OPT_OUT_NOTICE, 1); + usTn.setFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usTn.setFieldValue(UsTnField.SALE_OPT_OUT, 1); + usTn.setFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT, 1); + usTn.setFieldValue(UsTnField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usTn.setFieldValue(UsTnField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usTn.setFieldValue(UsTnField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usTn.setFieldValue(UsTnField.MSPA_COVERED_TRANSACTION, 1); + usTn.setFieldValue(UsTnField.MSPA_OPT_OUT_OPTION_MODE, 1); + usTn.setFieldValue(UsTnField.MSPA_SERVICE_PROVIDER_MODE, 2); + usTn.setFieldValue(UsTnField.GPC, true); + + Assertions.assertEquals("BVWSSVWA.YA", usTn.encode()); + } + + @Test + public void testSetInvalidValues() { + UsTn usTn = new UsTn(); + + try { + usTn.setFieldValue(UsTnField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.MSPA_OPT_OUT_OPTION_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usTn.setFieldValue(UsTnField.MSPA_SERVICE_PROVIDER_MODE, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testEncodeWithGpcSegmentExcluded() { + UsTn usTn = new UsTn(); + usTn.setFieldValue(UsTnField.GPC_SEGMENT_INCLUDED, false); + Assertions.assertEquals("BAAAAAQA", usTn.encode()); + } + + @Test + public void testDecode1() throws DecodingException { + UsTn usTn = new UsTn("BVWSSVWA.YA"); + + Assertions.assertEquals(1, usTn.getProcessingNotice()); + Assertions.assertEquals(1, usTn.getSaleOptOutNotice()); + Assertions.assertEquals(1, usTn.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usTn.getSaleOptOut()); + Assertions.assertEquals(1, usTn.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usTn.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usTn.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usTn.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usTn.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usTn.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usTn.getMspaServiceProviderMode()); + Assertions.assertEquals(true, usTn.getGpc()); + } + + @Test + public void testDecodeWithGpcSegmentExcluded() throws DecodingException { + UsTn usTn = new UsTn("BVWSSVWA"); + + Assertions.assertEquals(1, usTn.getProcessingNotice()); + Assertions.assertEquals(1, usTn.getSaleOptOutNotice()); + Assertions.assertEquals(1, usTn.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usTn.getSaleOptOut()); + Assertions.assertEquals(1, usTn.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usTn.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usTn.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usTn.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usTn.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usTn.getMspaOptOutOptionMode()); + Assertions.assertEquals(2, usTn.getMspaServiceProviderMode()); + Assertions.assertEquals(false, usTn.getGpcSegmentIncluded()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows(DecodingException.class, () -> { + new UsTn("z").getProcessingNotice(); + }); + } +}